Threads_merge_opposite

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

#define TYP double

// funkce rand() je pouze 16 bitova
// rand32 vraci 32 bitove nahodne cislo
int rand32()
{
    return rand() * RAND_MAX + rand();
}

// Pouziti globalnich promennych zjednodusuje ukazku pouziti vlaken.
// Neni ovsem programatorsky spravne!
// Globalni promenne: DELKA - pocet prvku na ktere odkazuje POLE
int DELKA;
TYP *POLE;
// osobně ani nevím, proč jsem tam ty globálné proměné nechával, když jsem to stejně pak posílal přes parametry x)
// vypocet casoveho intervalu v milisekundach
int kolik_ms( LPFILETIME pred, LPFILETIME po )
{
    hyper pred64b = pred->dwHighDateTime;
    pred64b = ( pred64b << 32 ) | pred->dwLowDateTime;
    hyper po64b = po->dwHighDateTime;
    po64b = ( po64b << 32 ) | po->dwLowDateTime;
    // konverze 100ns -> 1ms
    return ( int ) ( ( po64b - pred64b ) / 10000 );
}
void tiskP (void)
{
    // hned return nechci tisknout zrovna (stotisíc čísel vytisknout by dalo zabrat...  ato několikrát... x) - pro menší pole zakomentovat return... x)
    return;
    for (int i = 0; i < DELKA; i++)
    {
        printf("%4.2f\n", POLE[i]);
    }
    printf("---------------------------------------\n");
}
void bubleSort(int levy, int pravy, TYP *pole){
    for(int i = 0; i < pravy-levy; i++){
        for(int j = 0; j < pravy - i-levy-1; j++){
            if(pole[j+1+levy] < pole[j+levy]){
                TYP tmp = pole[j + 1+levy];
                pole[j + 1+levy] = pole[j+levy];
                pole[j+levy] = tmp;
            }
        }
        //tiskP();
    }
}
typedef struct {
    int Od;
    int Do;
    TYP *pole;
} param;

DWORD WINAPI buble1( LPVOID s)
{
    printf( "Startuje vlakno buble1\n" );
    //MAX2 = hledej_max( DELKA / 2, DELKA, POLE );
    param *tmp = (param *)s;
    bubleSort(tmp->Od, tmp->Do, tmp->pole);
    return 0;
}

void genArray(int levy, int pravy, TYP *pole){
    int x = 0;
    for (int i = levy; i < pravy; i++)
    {
        x = rand32()%100000;
        pole[i] = (TYP)(x / 100.00);

    }
}


DWORD WINAPI genArray1( LPVOID s)
{
    printf( "Startuje vlakno gen1\n" );
    //MAX2 = hledej_max( DELKA / 2, DELKA, POLE );
    param *tmp = (param *)s;
    genArray(tmp->Od, tmp->Do, tmp->pole);

    return 0;
}

int main( int na, char **arg )
{
    DELKA = 100000;
    POLE = new TYP[DELKA];

    param *s1 = new param;
    param *s2 = new param;

    s1->Od = 0;
    s1->Do = DELKA/2;
    s1->pole = POLE;

    s2->Do = DELKA;
    s2->Od = DELKA/2;
    s2->pole = POLE;

    HANDLE v1, v2;
//naplnění pole náhodnými čísly přes dvě vlákna
    v1 = CreateThread( 0, 0, genArray1, s1, 0, 0 );
    v2 = CreateThread( 0, 0, genArray1, s2, 0, 0 );
//čekní na ukončení vláken
    WaitForSingleObject( v1, INFINITE );
    WaitForSingleObject( v2, INFINITE );

    tiskP();

    FILETIME cas_pred, cas_po;
//měření čaasu... viz ukázka vláken....
    GetSystemTimeAsFileTime ( &cas_pred );

//seřezování pole přes dvě vlákna bubblesortem - pro stotisíc čísel cca 14,5 sekund
    v1 = CreateThread( 0, 0, buble1, s1, 0, 0 );
    v2 = CreateThread( 0, 0, buble1, s2, 0, 0 );
    WaitForSingleObject( v1, INFINITE );
    WaitForSingleObject( v2, INFINITE );
    GetSystemTimeAsFileTime( &cas_po );
//konec meření času
    tiskP();
    printf( "Cas buble byl %d [ms]\n----------------------------\n", kolik_ms( &cas_pred, &cas_po ) );

    GetSystemTimeAsFileTime ( &cas_pred );
//převracení pole
    for (int i = 0; i < (int)(DELKA/2); i++)
    {
        TYP tmp = POLE[i];
        POLE[i] = POLE[DELKA-1-i];
        POLE[DELKA-1-i] = tmp;
    }
    GetSystemTimeAsFileTime( &cas_po );
    tiskP();
    printf( "Cas prevraceni byl %d [ms]\n----------------------------\n", kolik_ms( &cas_pred, &cas_po ) );

//spojení pole tak, aby bylo celé seřazené a né jen 1. půlka a pak 2.půlka...
    TYP *tmp_p = new TYP[DELKA];
    printf("ZACATEK SPOJOVANI\n");
    int a = 0, b = DELKA/2;

    for (int i = 0; i < DELKA; i++)
    {
        if (a > DELKA/2) a = DELKA/2-1;
        if (b > DELKA) b = DELKA -1;
        if (POLE[a] > POLE[b])
        {
            tmp_p[i] = POLE[a];
            a++;
        }
        else
        {
            tmp_p[i] = POLE[b];
            b++;
        }
    }
    delete []POLE;
    POLE = tmp_p;
    tiskP();
    printf("KONEC SPOJOVANI\n");
    s1->pole = POLE;
    s2->pole = POLE;

//znova naplnění pole náhodnými čísly přes dvě vlákna
    v1 = CreateThread( 0, 0, genArray1, s1, 0, 0 );
    v2 = CreateThread( 0, 0, genArray1, s2, 0, 0 );
    WaitForSingleObject( v1, INFINITE );
    WaitForSingleObject( v2, INFINITE );
    tiskP();

//nastavení struktury param s1 - od 0 do DELKA, na POLE
    s1->Od = 0;
    s1->Do = DELKA;
    s1->pole = POLE;
//zacatek mereni
    GetSystemTimeAsFileTime ( &cas_pred );
//serazeni pole pomocí jednoho vlákna  - pro stotisíc čísel cca 58 sekund
    v1 = CreateThread( 0, 0, buble1, s1, 0, 0 );
    WaitForSingleObject( v1, INFINITE );
    GetSystemTimeAsFileTime( &cas_po );
    tiskP();
    printf( "Cas jedno vlakno byl %d [ms]\n----------------------------\n", kolik_ms( &cas_pred, &cas_po ) );

//uložení pole do textového souboru
    FILE *p;
    if ((p = fopen("out.txt", "w")) != NULL)
    {
    for (int i = 0; i < DELKA; i++)
    {
        fprintf(p,"%4.2f\n", POLE[i]);
    }
    fclose(p);
    }
// uvolnení využívané paměťi v hromadě.. nenechávame po sobě bordel přece
    delete []POLE;
    delete s1;
    delete s2;
}