배열에서 가장 큰 값 찾기 pthread 포함

#include <stdio.h>
#include <pthread.h>
#include <omp.h>
#include "timers.h"
#include <stdlib.h>
#include <time.h>

#define MAX_THREADS 32
#define NDIM 100000

typedef struct
{
    int *data;
    int from;
    int to;
    int *max;
} thread_args;

int num_threads = 0;

void* worker(void* arg)
{
    thread_args* args = (thread_args*) arg;
    int from = args->from;
    int to = args->to;
    int *ret = args->max;
    int *data = args->data;
    int max = 0;
    int i;

    for(i = from ; i < to ; i++)
    {
        if(max < data[i])
            max = data[i];
    }

    *ret = max;
}

int findmax_omp(int* data, int size, int num_threads)
{
    int i, total_max = 0;
    int tmp_max[num_threads];
    omp_set_num_threads(num_threads);
#pragma omp parallel
{
    int i;
    int max = 0;
    int tid = omp_get_thread_num();
    int from = (size * tid) / num_threads;
    int to = (size * (tid + 1) ) / num_threads;

    for(i = from; i < to; i++)
    {
        if(max < data[i])
            max = data[i];
    }
    tmp_max[tid] = max;
}
    for(i = 0; i < num_threads ; i++)
    {
        if(total_max < tmp_max[i])
            total_max = tmp_max[i];
    }
    return total_max;
}

int findmax_pthread(int* data, int size, int num_threads)
{
    thread_args arg[num_threads];
    pthread_t thr[num_threads];
    int ret[num_threads];
    int i, max=0;

    for(i = 0; i < num_threads ; i++)
    {
        arg[i].data = data;
        arg[i].from = (size * i) / num_threads;
        arg[i].to = (size * (i + 1)) / num_threads;
        printf("arg[%d] / from : %d / to : %d\n",i, arg[i].from, arg[i].to);
        arg[i].max = ret + i;
    }

    for(i = 0; i < num_threads ; i++)
        pthread_create(&thr[i], NULL, worker, (void*) (&arg[i]));

    worker((void*)(&arg[num_threads - 1]));

    for(i = 0; i < num_threads ; i++)
        pthread_join(thr[i],NULL);

    for(i = 0; i < num_threads ; i++)
    {
    //    printf("ret[%d] : %d\n",i,ret[i]);
        if(max < ret[i])
            max = ret[i];
    }
    return max;
}

int findmax(int* data, int size)
{
    int i, max = 0;

    for(i = 0; i < size ; i++)
        if(max < data[i])
            max = data[i];

    return max;
}

void init_array(int* data, int size)
{
    int i;

    for(i = 0; i < size ; i++)
        data[i] = rand()%100000+1;
}

int main(int argc, char** argv)
{
    int n1, n2, max=0;
    int *data = malloc(sizeof(int) * NDIM);
    int i;
    if(argc < 2)
    {
        printf("input 2 numbers [0,1,2] [1~512]\n");
        return 0;
    }
    n1 = atoi(argv[1]);
    n2 = atoi(argv[2]);
    num_threads = n2;

    srand(time(NULL));

    init_array(data,NDIM);

    timer_start(1);
    if(n1 == 0)
    {
        max = findmax(data, NDIM);
    }
    else if(n1 == 1)
    {
        max = findmax_pthread(data, NDIM, num_threads);
    }
    else if(n1 == 2)
    {
        max = findmax_omp(data, NDIM, num_threads);
    }
    else
    {
        printf("input correct number\n");
        return 0;
    }
    timer_stop(1);

/*    for(i = 0; i < NDIM ; i++)
    {
        printf("data[%d] : %d\n",i, data[i]);
    }
*/
    printf("Time : %lfsec\n",timer_read(1));
    printf("Max : %d\n",max);

    return 0;
}