vlakna

#include<iostream>
#include<time.h>
#include <windows.h>

using namespace std;

const int N = 10;
const int R = 10;
const int S = 10;
char pole2[R][S];
char pole[N];
char novePole[S*2];
//naplneni jednorozmerneho pole
void naplnPole(int velikost)
{
    srand(time(0));
    for(int i = 0; i < velikost; i++)
    {
        char r = rand() % 70 - 60;
        pole[i] = r;
    }
}
//tisk jednorozmerneho pole
void tiskPole( int velikost)
{
    for(int i = 0; i < velikost; i++)
    {
        printf("%d ", pole[i]);
    }
}
//naplneni dvourozmerneho pole
void naplnPole2(int velikostRadek, int velikostSloupec)
{
    srand(time(0));
    for(int i = 0; i < velikostRadek; i++)
    {
        for(int j = 0; j < velikostSloupec; j++)
        {
            char r = rand() % 200 - 100;
            pole2[i][j] = r;
        }
    }
}

//tisk dvourozmerneho pole
void tiskPole2(int velikostRadek, int velikostSloupec)
{
    for(int i = 0; i < velikostRadek; i++)
    {
        for(int j = 0; j < velikostSloupec; j++)
        {
            printf("%d ", pole2[i][j]);
        }
        cout << endl;
    }
}

//bublinkove razeni
void bubbleSort(int od, int konec){
    for(int i = od; i < konec; i++){
        for(int j = od; j < konec - (i - od) - 1; j++){
            if(pole[j+1] > pole[j]){
                int tmp = pole[j + 1];
                pole[j + 1] = pole[j];
                pole[j] = tmp;
            }
        }
    }
}

void bubbleSortD(int od, int konec){
    for(int i = od; i < konec; i++){
        for(int j = od; j < konec - i - 1; j++){
            if(novePole[j+1] > novePole[j]){
                int tmp = novePole[j + 1];
                novePole[j + 1] = novePole[j];
                novePole[j] = tmp;
            }
        }
    }
}


//bublinkove razeni pro dvourozmerne pole
void bubbleSort2(int od, int konec, int sloupec){
    for(int r = od; r < konec; r++) {
    for(int i = 0; i < sloupec - 1; i++){
        for(int j = 0; j < sloupec - i - 1; j++){
            if(pole2[r][j+1] > pole2[r][j]){
                int tmp = pole2[r][j + 1];
                pole2[r][j+1] = pole2[r][j];
                pole2[r][j] = tmp;
            }
        }
    }
    }
}

//razeni vyberem
void selectionSort(int od, int konec) {
     for (int i = od; i < konec - 1; i++) {
         int maxIndex = i;
         for (int j = i + 1; j < konec; j++) {
             if (pole[j] > pole[maxIndex]) maxIndex = j;
         }
         int tmp = pole[i];
         pole[i] = pole[maxIndex];
         pole[maxIndex] = tmp;
     }
 }

//razeni vyberem pro dvourozmerne pole
void selectionSort2(int od, int konec, int sloupec) {
    for(int r = od; r < konec; r++) {
     for (int i = 0; i < sloupec - 1; i++) {
         int maxIndex = i;
         for (int j = i + 1; j < sloupec; j++) {
             if (pole2[r][j] > pole2[r][maxIndex]) maxIndex = j;
         }
         int tmp = pole2[r][i];
         pole2[r][i] = pole2[r][maxIndex];
         pole2[r][maxIndex] = tmp;
     }
    }
 }


//razeni vkladanim
void insertionSort(int od, int konec) {
    for (int i = 0; i < konec - 1; i++) {
        int j = i + 1;
        int tmp = pole[j];
        while (j > 0 && tmp > pole[j-1]) {
            pole[j] = pole[j-1];
            j--;
        }
        pole[j] = tmp;
    }
}

//razeni vkladanim pro dvourozmerne pole
void insertionSort2(int od, int konec, int sloupec) {
    for(int r = od; r < konec; r++) {
    for (int i = 0; i < sloupec - 1; i++) {
        int j = i + 1;
        int tmp = pole2[r][j];
        while (j > 0 && tmp > pole2[r][j-1]) {
            pole2[r][j] = pole2[r][j-1];
            j--;
        }
        pole2[r][j] = tmp;
    }
    }
}
void otoceniPole(int velikost)
{
    for(int i = 0; i < velikost; i++)
    {
        if(i < N/2)
        {
            char pom = pole[i];
            pole[i] = pole[N - i - 1];
            pole[N - i - 1] = pom;
        }
    }
}


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 );
}

DWORD WINAPI vlaknoA( LPVOID r1)
{
    int *pom = (int*)r1;
    printf( "Startuje vlakno A\n" );
    bubbleSort(pom[0],pom[1]);
    return 0;
}

void funkce(int a, int b)
{

    for(int i = 0; i < S*2; i++)
    {
        if(i < S)
            novePole[i] = pole2[a][i];
        else
            novePole[i] = pole2[b][i - S];
    }
    bubbleSortD(0,S*2);
}

void tisk()
{
    for(int i = 0; i < S*2; i++)
    {
        printf("%d ", novePole[i]);
    }
}


int main()
{
    //int pole[N];
    FILETIME cas_pred, cas_po;
    //---------------------------------------------------------------------------------
    /*
    naplnPole(N);
    tiskPole(N);
    GetSystemTimeAsFileTime( &cas_pred );
    bubbleSort(0,N);
    GetSystemTimeAsFileTime( &cas_po );
    cout << endl;
    tiskPole(N);
    cout << "Cas byl: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    */
    //--------------------------------------------------------------------------------------
    /*
    naplnPole(N);
    HANDLE p1,p2;
    int v1[] = {0,N/2};
    int v2[] = {N/2,N};
    GetSystemTimeAsFileTime( &cas_pred );
    p1 = CreateThread( 0, 0, vlaknoA, v1, 0, 0 );
    p2 = CreateThread( 0, 0, vlaknoA, v2, 0, 0 );
    WaitForSingleObject( p1, INFINITE );
    WaitForSingleObject( p2, INFINITE );
    GetSystemTimeAsFileTime( &cas_po );
    tiskPole(N);
    cout << "Cas byl: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    */
    //---------------------------------------------------------------------------------------
    /*
    HANDLE p1,p2,p3,p4;
    naplnPole(N);
    //tiskPole(N);
    cout << endl;
    int v1[] = {0,N/2};
    int v2[] = {N/2,N};
    GetSystemTimeAsFileTime( &cas_pred );
    p1 = CreateThread( 0, 0, vlaknoA, v1, 0, 0 );
    p2 = CreateThread( 0, 0, vlaknoA, v2, 0, 0 );
    WaitForSingleObject( p1, INFINITE );
    WaitForSingleObject( p2, INFINITE );
    GetSystemTimeAsFileTime( &cas_po );
    //tiskPole(N);
    cout << "Cas byl: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    otoceniPole(N);
    cout << endl;
    cout << "Otacim pole\n";
    //tiskPole(N);
    */
    //--------------------------------------------------------------------------------------
    /*
    cout << endl;
    GetSystemTimeAsFileTime( &cas_pred );
    p3 = CreateThread( 0, 0, vlaknoA, v1, 0, 0 );
    p4 = CreateThread( 0, 0, vlaknoA, v2, 0, 0 );
    WaitForSingleObject( p3, INFINITE );
    WaitForSingleObject( p4, INFINITE );
    GetSystemTimeAsFileTime( &cas_po );
    cout << endl;
    //tiskPole(N);
    cout << "Cas byl: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    */

    //-------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------
    /*
    naplnPole2(R,S);
    tiskPole2(R,S);
    bubbleSort2(0,R,S);
    cout << "\nSetrizene\n";
    tiskPole2(R,S);
    */
    //--------------------------------------------------------------------------------
    /*
    naplnPole2(R,S);
    GetSystemTimeAsFileTime( &cas_pred );
    selectionSort2(0,R,S);
    GetSystemTimeAsFileTime( &cas_po );
    tiskPole2(R,S);
    cout << "Cas srotovani: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    */
    //--------------------------------------------------------------------------------
    /*
    HANDLE v[R];
    naplnPole2(R,S);
    GetSystemTimeAsFileTime( &cas_pred );
    int par[] = {0,1};
    int par1[] = {1,2};
    int par2[] = {2,3};
    int par3[] = {3,4};
    int par4[] = {4,5};
    int par5[] = {5,6};
    int par6[] = {6,7};
    int par7[] = {7,8};
    int par8[] = {8,9};
    int par9[] = {9,10};

    v[0] = CreateThread( 0, 0, vlaknoA, par, 0, 0 );
    v[1] = CreateThread( 0, 0, vlaknoA, par1, 0, 0 );
    v[2] = CreateThread( 0, 0, vlaknoA, par2, 0, 0 );
    v[3] = CreateThread( 0, 0, vlaknoA, par3, 0, 0 );
    v[4] = CreateThread( 0, 0, vlaknoA, par4, 0, 0 );
    v[5] = CreateThread( 0, 0, vlaknoA, par5, 0, 0 );
    v[6] = CreateThread( 0, 0, vlaknoA, par6, 0, 0 );
    v[7] = CreateThread( 0, 0, vlaknoA, par7, 0, 0 );
    v[8] = CreateThread( 0, 0, vlaknoA, par8, 0, 0 );
    v[9] = CreateThread( 0, 0, vlaknoA, par9, 0, 0 );

    WaitForSingleObject( v[0], INFINITE );
    WaitForSingleObject( v[1], INFINITE );
    WaitForSingleObject( v[2], INFINITE );
    WaitForSingleObject( v[3], INFINITE );
    WaitForSingleObject( v[4], INFINITE );
    WaitForSingleObject( v[5], INFINITE );
    WaitForSingleObject( v[6], INFINITE );
    WaitForSingleObject( v[7], INFINITE );
    WaitForSingleObject( v[8], INFINITE );
    WaitForSingleObject( v[9], INFINITE );

    GetSystemTimeAsFileTime( &cas_po );
    tiskPole2(R,S);
    cout << "Cas srotovani: " << kolik_ms(&cas_pred, &cas_po) << "ms" << endl;
    cout << endl;
    funkce(0,9);
    tisk();

    */
    //------------------------------------------------------------------------------------



    return 0;
}