多线程并发耗时测试

测试环境：24CPU 2.4GHz ，32G内存

实验数据：

mutex.c

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        pthread_mutex_lock(&mutex);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

　　SPIN_UPDATE:

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
pthread_spinlock_t mylock;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

int newlock(pthread_spinlock_t *lock){ 
__asm__(
//eax清零，记录当前lock次数
"xor %%eax,%%eax\n\t"
//ecx清零，记录总的lock次数
"xor %%ecx,%%ecx\n\t"
//记录加锁次数
"1:incl %%ecx\n\t"
//记录当前加锁次数
"incl %%eax\n\t"
//锁总线，开始加锁，rdi寄存器存储的是lock变量的地址
"lock decl (%%rdi)\n\t"
//加锁不成功
"jne 2f\n\t"
//加锁成功，将锁总线次数作为返回值返回
"movl %%ecx,%%eax\n\t"
"leave\n\t"
"retq\n\t"
"nop\n\t"
"nop\n\t"
//pause跳转标签
"5:pause\n\t"
"4:pause\n\t"
"3:pause\n\t"
"2:pause\n\t"
//探测锁是否可用
"cmpl $0x0,(%%rdi)\n\t"
//锁可用，重新加锁
"jg 1b\n\t"
//加锁次数与4取模
"and $0x3,%%eax\n\t"
//根据结果进行跳转
"cmpl $0x0,%%eax\n\t"
"je 2b\n\t"
"cmpl $0x1,%%eax\n\t"
"je 3b\n\t"
"cmpl $0x2,%%eax\n\t"
"je 4b\n\t"
"je 5b\n\t"
"nop\n\t"
"nop\n\t"
:
:"D"(lock)
:"%eax","%ecx","%edx");
}

int sim_spin_lock(pthread_spinlock_t *lock){
__asm__(
//eax清零，记录当前lock次数
"xor %%eax,%%eax\n\t"
//ecx清零，记录总的lock次数
"xor %%ecx,%%ecx\n\t"
//记录加锁次数
"1:incl %%ecx\n\t"
//记录当前加锁次数
"incl %%eax\n\t"
//锁总线，开始加锁，rdi寄存器存储的是lock变量的地址
"lock decl (%%rdi)\n\t"
//加锁不成功
"jne 2f\n\t"
//加锁成功，将锁总线次数作为返回值返回
"movl %%ecx,%%eax\n\t"
"leave\n\t"
"retq\n\t"
"nop\n\t"
"nop\n\t"
//pause跳转标签
"2:pause\n\t"
//探测锁是否可用
"cmpl $0x0,(%%rdi)\n\t"
//锁可用，重新加锁
"jg 1b\n\t"
"jmp 2b\n\t"
"nop\n\t"
"nop\n\t"
:
:"D"(lock)
:"%eax","%ecx","%edx");
}

/*
int spinlock_internal(pthread_spinlock_t *lock)
{

int ret = 0;
__asm__ ("n"
"1:lock; decl %0nt"
"jne 2fnt"
"movl $0, %1nt"
"jmp 4fnt"
"n"
".subsection 2nt"
".align 16nt"
"2:tmovl $5, %%ecxnt"
"3:trep; nopnt"
"cmpl $0, %0nt"
"jg 1bnt"
"decl %%ecxnt"
"jnz 3bnt"
"jmp 5fnt"
".previousnt"
"5:tmovl $1, %1nt"
"4:tnop"
: "=m" (*lock), "=r"(ret) : "m" (*lock) : "%ecx");

return ret;

}

int nongreedy_spinlock(pthread_spinlock_t *lock)
{

int rc = 0;

rc = spinlock_internal(lock);
while (rc) {
sched_yield();
rc = spinlock_internal(lock);
}
return 0;

}
*/
void *func(void *arg){
        int i,j, k, m,t;
        for( i=0; i< loop_count; i++){
        newlock(&mylock);
                g_count++;
                //下面这几句代码之间有很强的依赖性，流水hazard比较多
                //每句代码都要依赖上一句的执行结果，而且都是store操作
                //用于模仿实际情况中的临界区代码
                for( t=0; t< code_len; t++){
                        j = k;
                        m = j;
                        k = m;
                        m = j+1;
                        k = m+2;
                        j = m+k;
                }
                pthread_spin_unlock(&mylock);
        }
        return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
        struct timeval tvEnd;
        gettimeofday(&tvEnd,NULL);
        return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
        if(argc < 3){
                return 0;
        }
        int i;
        unsigned long ms_time = 0;
        struct timeval tvStart;
        thread_count = atoi(argv[1]);
        loop_count = atoi(argv[2]);
        code_len = atoi(argv[3]);
        pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
        pthread_spin_init(&mylock, 0);
        gettimeofday(&tvStart,NULL);
        for(i=0; i<thread_count; i++){
                pthread_create(&tid[i], NULL, func, NULL);
        }
 void *tret;
        for(i=0; i<thread_count; i++){
                int ret = pthread_join(tid[i], &tret);
                if(ret != 0){
                printf("cannot join thread1");
                }
        }
        ms_time = get_process_time(&tvStart);
        fprintf(stderr, "time:%ld\n",  ms_time);
        return 0;
}

　　sem：

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#include<semaphore.h>

#define MAX_LOOP 1000000
#define CODE_LEN 10
sem_t sems;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        sem_wait(&sems);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        sem_post(&sems);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    sem_init(&sems,0,0);
        sem_post(&sems);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}
　　spin:

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
pthread_spinlock_t mylock;
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
        pthread_spin_lock(&mylock);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
        pthread_spin_unlock(&mylock);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    pthread_spin_init(&mylock, 0);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

　　rwlock:

View Code 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/time.h>
#define MAX_LOOP 1000000
#define CODE_LEN 10
long g_count = 0;
int thread_count = 20;
int lock_count = 0;
int loop_count = 1000000;
int code_len = 1;
pthread_rwlock_t mutex = PTHREAD_RWLOCK_INITIALIZER;

void *func(void *arg){
    int i,j, k, m,t;
    for( i=0; i< loop_count; i++){
         pthread_rwlock_wrlock(&mutex);
        g_count++;
        //下面这几句代码之间有很强的依赖性，流水hazard比较多
        //每句代码都要依赖上一句的执行结果，而且都是store操作
        //用于模仿实际情况中的临界区代码
        for( t=0; t< code_len; t++){
            j = k;
            m = j;
            k = m;
            m = j+1;
            k = m+2;
            j = m+k;
        }
         pthread_rwlock_unlock(&mutex);
    }
    return NULL;
}

unsigned long get_process_time(struct timeval *ptvStart)
{
    struct timeval tvEnd;
    gettimeofday(&tvEnd,NULL);
    return ((tvEnd.tv_sec - ptvStart->tv_sec)*1000+(tvEnd.tv_usec - ptvStart->tv_usec)/1000);
}

int main(int argc, char *argv[]){
    if(argc < 3){
        return 0;
    }
    int i;
    unsigned long ms_time = 0;
    struct timeval tvStart;
    thread_count = atoi(argv[1]);
    loop_count = atoi(argv[2]);
    code_len = atoi(argv[3]);
    pthread_t *tid = (pthread_t*)malloc(sizeof(pthread_t)*thread_count);
    gettimeofday(&tvStart,NULL);
    for(i=0; i<thread_count; i++){
        pthread_create(&tid[i], NULL, func, NULL);
    }

    void *tret;
    for(i=0; i<thread_count; i++){
        int ret = pthread_join(tid[i], &tret);
        if(ret != 0){
        printf("cannot join thread1");
        }
    }
    ms_time = get_process_time(&tvStart);
    fprintf(stderr, "time:%ld\n",  ms_time);
    return 0;
}

　　

实验结果：   

　　loop循环1000000，code_len：10次，线程数量：1,4,8,16,20,24,30,40,50； 时间单位：ms

               

1.00  4.00  8.00  16.00  20.00  24.00  30.00  40.00  50.00   
81.00  1660.00  3177.00  6090.00  6720.00  8180.00  11396.00  14798.00  18253.00  mutex
93.00  2951.00  3644.00  9904.00  13312.00  20219.00  33122.00  44787.00  52194.00  rwlock
82.00  1447.00  3076.00  7543.00  8998.00  10895.00  13797.00  21466.00  31165.00  spin
85.00  2536.00  4672.00  12793.00  16704.00  19105.00  24624.00  28932.00  33452.00  sem
91.00  1125.00  3173.00  7224.00  9099.00  10742.00  13860.00  22162.00  30361.00  spin_update-sim
82.00  1448.00  2749.00  5478.00  4410.00  4585.00  6059.00  6924.00  8545.00  spin_update-new

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/gogly/p/2704967.html