pthread를 이용한 병렬처리 시 속도 저하 문제

#include <stdio.h>
#include <iostream>
#include <pthread.h>
#include <time.h>
#include <cpuid.h>
 
#define MULTITHREAD_NUM 4
#define SIZE_OF_DATA 4000*3000
#define SIZE_OF_ONETHR SIZE_OF_DATA/MULTITHREAD_NUM
 
#define CPUID(INFO, LEAF, SUBLEAF) __cpuid_count(LEAF, SUBLEAF, INFO[0], INFO[1], INFO[2], INFO[3])
 
#define GETCPU(CPU) {                              \
    uint32_t CPUInfo[4];                           \
    CPUID(CPUInfo, 1, 0);                          \
    /* CPUInfo[1] is EBX, bits 24-31 are APIC ID */ \
    if ( (CPUInfo[3] & (1 << 9)) == 0) {           \
        CPU = -1;  /* no APIC on chip */             \
    }                                              \
    else {                                         \
        CPU = (unsigned)CPUInfo[1] >> 24;                    \
    }                                              \
        if (CPU < 0) CPU = 0;                          \
    }
 
 
struct threadwork_arg
{
    unsigned char* src;
    unsigned char* dst;
    unsigned char* gain;
    int i_start;
    int i_end;
    int thread_id;
};
 
void* test_func(void* arg)
{
    clock_t begin_t, end_t;
 
    threadwork_arg* param = (threadwork_arg*)arg;
 
    int i;
    unsigned char* src = param->src;
    unsigned char* dst = param->dst;
    unsigned char* gain = param->gain;
    int i_start = param->i_start;
    int i_end = param->i_end;
    int loop_size = i_end - i_start;
    int cnt = 0;
    int cpu_id;
    unsigned int temp_data_dst;
    unsigned int temp_data_src;
    unsigned int temp_data_gain;
 
    GETCPU(cpu_id);
 
    begin_t = clock();
    printf("thread%d start %lu\n", param->thread_id, begin_t);
    for(i=0; i<loop_size; i++)
    {
        temp_data_src = (unsigned int)*src;
        temp_data_gain = (unsigned int)*gain;
        temp_data_dst = temp_data_src*temp_data_gain>>8;
        *dst = (unsigned char)(temp_data_dst&0xFF);
        dst++;src++;gain++;cnt++;
    }
    end_t = clock();
    printf("thread%d end %lu\n", param->thread_id, end_t);
    printf("thread%d %d loop processing time %4.5fms cpu[%d]\n", param->thread_id, cnt, (double)(end_t - begin_t)*1000/CLOCKS_PER_SEC, cpu_id);
 
    return arg;
}
 
int main(int argc, const char * argv[])
{
    clock_t begin_t, end_t;
    threadwork_arg thread_param[MULTITHREAD_NUM];
    pthread_t threadwork_hello[MULTITHREAD_NUM];
 
    int idx = 0;
    int thr_id[MULTITHREAD_NUM];
    int status[MULTITHREAD_NUM];
 
    unsigned char* src_data[MULTITHREAD_NUM];
    unsigned char* dst_data[MULTITHREAD_NUM];
    unsigned char* gain_data[MULTITHREAD_NUM];
 
    int cpu_id;
    GETCPU(cpu_id);
    printf("%s cpu[%d]\n", __func__, cpu_id);
 
    for(int i=0; i<MULTITHREAD_NUM; i++)
    {
        src_data[i] = new unsigned char[SIZE_OF_DATA];
        dst_data[i] = new unsigned char[SIZE_OF_DATA];
        gain_data[i] = new unsigned char[SIZE_OF_DATA];
 
        memset(src_data[i], 64, SIZE_OF_DATA);
        memset(dst_data[i], 0, SIZE_OF_DATA);
        memset(gain_data[i], 128, SIZE_OF_DATA);
    }
 
    begin_t = clock();
    printf("whole loop start %lu\n", begin_t);
    for(idx=0; idx<MULTITHREAD_NUM; idx++)
    {
        thread_param[idx].src = src_data[idx];
        thread_param[idx].dst = dst_data[idx];
        thread_param[idx].gain = gain_data[idx];
        thread_param[idx].i_start = 0;
        thread_param[idx].i_end = thread_param[idx].i_start + SIZE_OF_ONETHR;
        thread_param[idx].thread_id = idx;
    }
 
    for(idx=0; idx<MULTITHREAD_NUM; idx++)
    {
        GETCPU(cpu_id);
        printf("%s create thread%d cpu[%d]\n", __func__, idx, cpu_id);
        thr_id[idx] = pthread_create(&threadwork_hello[idx], NULL, test_func, (void*)&thread_param[idx]);
        if (thr_id[idx] < 0)
        {
            perror("thread create error : ");
            exit(0);
        }
    }
 
    for(idx=0; idx<MULTITHREAD_NUM; idx++)
    {
        pthread_join(threadwork_hello[idx], (void **)&status);
    }
    end_t = clock();
    printf("whole loop end %lu\n", end_t);
    printf("whole loop time %4.5fms\n", (double)(end_t - begin_t)*1000/CLOCKS_PER_SEC);
 
 
 
    begin_t = clock();
    printf("no thread loop start %lu\n", begin_t);
    for(idx=0; idx<MULTITHREAD_NUM; idx++)
    {
        thread_param[idx].thread_id = idx - MULTITHREAD_NUM;
        test_func((void*)&thread_param[idx]);
    }
    end_t = clock();
    printf("no thread loop end %lu\n", end_t);
    printf("no thread loop time %4.5fms\n", (double)(end_t - begin_t)*1000/CLOCKS_PER_SEC);
 
 
    for(int i=0; i<MULTITHREAD_NUM; i++)
    {
        delete[] src_data[i];
        delete[] dst_data[i];
        delete[] gain_data[i];
    }
 
    return 0;
}

main cpu[4]
whole loop start 97671
main create thread0 cpu[4]
main create thread1 cpu[4]
thread0 start 97736
main create thread2 cpu[4]
thread1 start 97761
main create thread3 cpu[4]
thread2 start 97927
thread3 start 98037
thread2 end 104471
thread2 3000000 loop processing time 6.54400ms cpu[5]
thread0 end 107325
thread0 3000000 loop processing time 9.58900ms cpu[0]
thread3 end 108334
thread3 3000000 loop processing time 10.29700ms cpu[7]
thread1 end 108485
thread1 3000000 loop processing time 10.72400ms cpu[3]
whole loop end 108530
whole loop time 10.85900ms
no thread loop start 108538
thread-4 start 108539
thread-4 end 109466
thread-4 3000000 loop processing time 0.92700ms cpu[2]
thread-3 start 109479
thread-3 end 110503
thread-3 3000000 loop processing time 1.02400ms cpu[6]
thread-2 start 110517
thread-2 end 111441
thread-2 3000000 loop processing time 0.92400ms cpu[6]
thread-1 start 111451
thread-1 end 112356
thread-1 3000000 loop processing time 0.90500ms cpu[6]
no thread loop end 112370
no thread loop time 3.83200ms