Podivat se

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <sys/param.h>
#include <pthread.h>
#include <iostream>

#define TYPE int

using namespace std;

const int POCET_VLAKEN = 3;  //konstanta
const int POCET_CISEL = 30;  //konstanta

struct structThread{         //struktura
    int id;                     //název vlákna id
    int from;
    int to;
    TYPE *data;             //pointer na pùvodní pole, které budeme tøídit
};

int timeval_to_ms(timeval *before, timeval *after);
void fillArrayRandom(TYPE *cisla, int velikostPole);
void vypisPole(TYPE *cisla, int velikostPole);
void bubbleSort(TYPE *cisla, int zacatek, int konec);
void *vlaknoTrideni( void *void_arg );
void *vlaknoPlneni(void *void_arg);


int main(){
    pthread_t vlaknoId[POCET_VLAKEN];           //vytvoøíme si pole vláken
    pthread_t naplnPole;                        //vlákno plnìní pole
    structThread vlaknoStruct[POCET_VLAKEN];    //vytvoøíme pole struktur pro vlákna, pro kažé vlákno potøebujeme svoji strukturu
    TYPE velkePole[POCET_CISEL];                //poèáteèní pole, které se naplnìní random èísly
    TYPE vyslednePole[POCET_CISEL];             // vysledne pole
    timeval casPred,casPo;                      // èasové promnìné

    //naplneni a synchronizace
    pthread_create( &naplnPole, NULL, vlaknoPlneni, &velkePole);    //vytvoøíme vlákno, které naplní pole
    pthread_join(naplnPole, NULL );                                 //poèkáme na dokonèení vlákna

    //predani parametru srukture
    for (int i = 0; i < POCET_VLAKEN; i++){                 //vymezení èásti velkého pole, které setøídí jedno vlákno
        vlaknoStruct[i].id = i;                         //identifikace vlákna
        vlaknoStruct[i].data = velkePole;               //data, které bude vlákno zpracovávat
        vlaknoStruct[i].from = i * (POCET_CISEL/POCET_VLAKEN);                      //tøídìní od
        vlaknoStruct[i].to = vlaknoStruct[i].from + (POCET_CISEL/POCET_VLAKEN);        //tøídìní do, vypoèítáme kolik èísel pøijde na jedno vlákno
    }

    // trideni
    gettimeofday( &casPred, NULL );      //zmeøení èasu na zaèátku, pak se uloží do caspPred
    for (int i = 0; i < POCET_VLAKEN; i++){     //pustí všechny vlákna najednou 0-3
        pthread_create( &vlaknoId[i], NULL, vlaknoTrideni, &vlaknoStruct[i] );  //spuštìní vlákna, Null, pøiøadíme funkci, a jeden parametr funkce, opakovanì pro další vlákno
    }
    // synchronizacia jednotlivych vlakien
    for (int i = 0; i < POCET_VLAKEN; i++){
        pthread_join( vlaknoId[i], NULL );          //èekáme až všechny vlákna skonèí
    }

    cout<<"Pole pred:"<<endl;
    vypisPole(velkePole, POCET_CISEL);
    int counter = 0;       //index ukladaneho prvku do noveho pole
    while(true){
        TYPE minPrvek;      //promnìná pro minimální prvek
        int indexMin;       //index èásti pole, kde jsme sebrali nejmenší prvek
        int pocetProhledenych = 0;     //
        //prvni minimum
        for(int i = 0; i < POCET_VLAKEN; i++){      //zachycení první minimun
            if(vlaknoStruct[i].from < vlaknoStruct[i].to){  //  jestli èást ještì mùžeme prohlédávat
                minPrvek = vlaknoStruct[i].data[vlaknoStruct[i].from]; //zachytíme si hodnotu minimálního prvku
                indexMin = i; //zachytíme si èást pole, odkud jsme sebrali nejmenší prvek
                break;
            }
        }

        //celkove minimum
        for(int i = 0; i < POCET_VLAKEN; i++){          //prohledáme všechny èásti
            if(vlaknoStruct[i].from < vlaknoStruct[i].to){      //které se dají prohledat
                if(vlaknoStruct[i].data[vlaknoStruct[i].from] < minPrvek){      //chytíme si hodnotu nejmenší prvku v jedné èásti a porovnáme s aktuálním min.prvkem
                    minPrvek = vlaknoStruct[i].data[vlaknoStruct[i].from];      //zachytíme si nový minimální prvek a èást z kama jsme ho vzali
                    indexMin = i;
                }
                pocetProhledanych++;        //zachytíme poèet prohledaných èástí
            }
        }
        //naplneni noveho pole
        vlaknoStruct[indexMin].from +=1;  //posunutí indexu from v èásti pole, z kama jsme sebrali minimum
        vyslednePole[counter] = minPrvek; //do vysledneho pole na index counter zapíšeme ten minimální prvek
        counter++;                          //counter si zvìtším o jednu pozici, na kterou budeme zapisovat další èíslo
        if(pocetProhledenych == 0){       //pokud jsme neprohledali žádnou èást, cyklus konèí
            break;
        }

    }
    gettimeofday( &casPo, NULL );           //zachytíme èas po setøídení
    cout<<"The sort time: "<< timeval_to_ms( &casPred, &casPo )<<"[ms]"<<endl; //vypíšeme èas tøídìní

    cout<<"Pole po:"<<endl;
    vypisPole(vyslednePole, POCET_CISEL);
    return 0;
}

void fillArrayRandom(TYPE *cisla, int velikostPole){    //naplnìní pole random èísly
    srand((int)time(NULL));
    for (int i = 0; i < velikostPole; i++){
        cisla[i] = (rand() % 1000 +1 );

    }
}

void bubbleSort(TYPE *cisla, int zacatek, int konec){   // pøedáme velké pole a vymezíme èas, kteýrm budeme tøídít
        for(int i = zacatek; i < konec; i++){
            for(int j = zacatek; j < konec - 1; j++){
                if(cisla[j] > cisla[j+1]){
                    TYPE pom = cisla[j+1];
                    cisla[j+1] = cisla[j];
                    cisla[j] = pom;
            }
        }
    }
}

void *vlaknoPlneni(void *void_arg){
    TYPE *ptr_data = ( TYPE * ) void_arg;       //pøetypování parametru funkce ptr_data je název pole, který se pøetypuje na TYPE*
    fillArrayRandom(ptr_data,POCET_CISEL);      //funkce fill ArarayRandom potøebuje znát dva parametry, pole na plnìní, a jeho velikost
}

void *vlaknoTrideni( void *void_arg ){              //funkce tøídìní dostane argument typu void
    structThread *ptr_data = ( structThread * ) void_arg;       //pøetypování ptr_data na structThread
    cout<<ptr_data->id<<" "<<ptr_data->from<<" "<<ptr_data->to<<endl;       //vypíše id vlákna, od, do
    bubbleSort(ptr_data->data, ptr_data->from, ptr_data->to);   //posíláme bubble sortu pole, index od, index do
}

void vypisPole(TYPE *cisla, int velikostPole){
    cout<<"Vypis pole: "<<endl;
    for (int i = 0; i < velikostPole; i++){
        cout<<" "<<cisla[i];
    }
    cout<<endl;
    cout<<"Konec vypisu pole"<<endl;
}


int timeval_to_ms(timeval *before, timeval *after){
    timeval res;
    timersub( after, before, &res );
    return 1000 * res.tv_sec + res.tv_usec / 1000;
}