• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>

    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>

            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            

    
            

            




            







												


        


            
	
            
		
			


            

            posts - 200, comments - 8, trackbacks - 0, articles - 0
            


            		
	
            
	
            
		
			
		
		
			
            
				
					
	
            
		
		
            實驗環境：

            CPU: 雙核 Intel(R) Xeon(R) CPU 5130  @ 2.00GHz，內存：1G
            系統：Red Hat Enterprise Linux ES release 4 (Nahant Update 4)
            內核：2.6.9-42.ELsmp

            實驗程序：

            singlethread.c
            1. #include <stdio.h>
            2. #include <sys/types.h>
            3. #include <sys/time.h>
            4. #include <pthread.h>
            5. #include <unistd.h>

            7. #define ORANGE_MAX_VALUE 1000000
            8. #define APPLE_MAX_VALUE 100000000
            9. #define MSECOND 1000000

            11. struct apple
            12. {
            13.     unsigned long long a;
            14.     unsigned long long b;
            15. };

            17. struct orange
            18. {
            19.     int a[ORANGE_MAX_VALUE];
            20.     int b[ORANGE_MAX_VALUE];
            21. };

            23. int main()
            24. {
            25.     struct apple test;
            26.     struct orange test1={{0},{0}};
            27.     
            28.     unsigned long long sum=0,index=0;
            29.     struct timeval tpstart,tpend;
            30.     float timeuse;
            31.     
            32.     test.a=0;
            33.     test.b=0;
            34.         
            35.     gettimeofday(&tpstart,NULL);
            36.     
            37.     for(sum=0;sum<APPLE_MAX_VALUE;sum++)
            38.     {
            39.         test.a+=sum;
            40.         test.b+=sum;
            41.     }
            42.     
            43.     sum=0;
            44.     for(index=0;index<ORANGE_MAX_VALUE;index++)
            45.     {
            46.         sum+=test1.a[index]+test1.b[index];
            47.     }
            48.     
            49.     gettimeofday(&tpend,NULL);
            50.     
            51.     timeuse=MSECOND*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
            52.     timeuse/=MSECOND;
            53.     printf("main thread Used Time:%f\n",timeuse); 
            54.     
            55.   printf("a = %llu,b = %llu,sum=%llu\n",test.a,test.b,sum);
            56.     
            57.   return 0;
            58. }
            dualrhread.c
            1. #include <sys/time.h>
            2. #include <pthread.h>


            5. #include<stdlib.h>
            6. #include<stdio.h>
            7. #include<sys/types.h>
            8. #include<sys/sysinfo.h>
            9. #include<unistd.h>

            11. #define __USE_GNU
            12. #include<sched.h>
            13. #include<ctype.h>
            14. #include<string.h> 

            16. #include <sys/syscall.h> /*此頭必須帶上*/

            18. pid_t gettid()
            19. {
            20.     return syscall(SYS_gettid);
            21. }


            24. #define ORANGE_MAX_VALUE 1000000
            25. #define APPLE_MAX_VALUE 100000000
            26. #define MSECOND 1000000

            28. struct apple
            29. {
            30.     unsigned long long a;
            31.     unsigned long long b;
            32. };

            34. struct orange
            35. {
            36.     int a[ORANGE_MAX_VALUE];
            37.     int b[ORANGE_MAX_VALUE];
            38. };

            40. struct apple test;
            41. struct orange test1;

            43. int cpu_nums;
            44. cpu_set_t mask;
            45. //cpu_set_t get;
            46.      
            47. inline int set_cpu(int i)
            48. {
            49.     __CPU_ZERO(&mask);
            50.     
            51.     if(2 <= cpu_nums)
            52.     {
            53.         __CPU_SET(i,&mask);
            54.         
            55.         if(-1 == sched_setaffinity(gettid(),sizeof(&mask),&mask))
            56.         {
            57.             return -1;
            58.         }
            59.     }
            60.     return 0;
            61. }

            63. void* add(void* x)
            64. {
            65.     int i;    
            66.     if(-1 == set_cpu(1))
            67.     {
            68.         return NULL;
            69.     } 
            70. /*    
            71.     __CPU_ZERO(&get);
            72.     if (sched_getaffinity(0, sizeof(get), &get) == -1)//獲取線程CPU親和力
            73.     {
            74.         printf("warning: cound not get thread affinity, continuing...\n");
            75.     }
            76.     
            77.     for (i = 0; i < 2; i++)
            78.     {
            79.         if (__CPU_ISSET(i, &get))//判斷線程與哪個CPU有親和力
            80.         {
            81.             printf("this thread %d is running processor : %d\n", i,i);
            82.         }
            83.     }
            84. */ 
            85.     unsigned long long sum=0,index=0;    
            86.     for(sum=0;sum<APPLE_MAX_VALUE;sum++)
            87.     {
            88.         ((struct apple *)x)->a += sum;
            89.         ((struct apple *)x)->b += sum;    
            90.     }
            91.         
            92.     return NULL;
            93. }
            94.     
            95. int main () 
            96. {
            97.     
            98.     pthread_t ThreadA;
            99.     unsigned long long sum=0,index=0;
            100.     struct timeval tpstart,tpend;
            101.     float timeuse;
            102.     int i;
            103.     
            104.     test.a=0;
            105.     test.b=0;
            106.     
            107.     cpu_nums = sysconf(_SC_NPROCESSORS_CONF);
            108.     
            109.     if(-1 == set_cpu(0))
            110.     {
            111.         return -1;
            112.     } 
            113.     
            114.     gettimeofday(&tpstart,NULL);
            115.         
            116.     pthread_create(&ThreadA,NULL,add,&test);
            117.     
            118. /*
            119.     __CPU_ZERO(&get);
            120.     if (sched_getaffinity(0, sizeof(get), &get) == -1)//獲取線程CPU親和力
            121.     {
            122.         printf("warning: cound not get thread affinity, continuing...\n");
            123.     }
            124.     
            125.     for (i = 0; i < 2; i++)
            126.     {
            127.         if (__CPU_ISSET(i, &get))//判斷線程與哪個CPU有親和力
            128.         {
            129.             printf("this thread %d is running processor : %d\n", i,i);
            130.         }
            131.     }    
            132. */
            133.     for(index=0;index<ORANGE_MAX_VALUE;index++)
            134.     {
            135.         sum += test1.a[index]+test1.b[index];
            136.     }        
            137.    
            138.     pthread_join(ThreadA,NULL);

            140.     gettimeofday(&tpend,NULL);
            141.     
            142.     timeuse=MSECOND*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
            143.     timeuse/=MSECOND;
            144.     printf("dual thread Used Time:%f\n",timeuse); 
            145.     
            146.     printf("a = %llu,b = %llu,sum=%llu\n",test.a,test.b,sum);
            147.     
            148.     return 0;
            149. }
            threethread.c
            1. #include <sys/time.h>
            2. #include <pthread.h>

            4. #include<stdlib.h>
            5. #include<stdio.h>
            6. #include<sys/types.h>
            7. #include<sys/sysinfo.h>
            8. #include<unistd.h>

            10. #define __USE_GNU
            11. #include<sched.h>
            12. #include<ctype.h>
            13. #include<string.h> 

            15. #include <sys/syscall.h> /*此頭必須帶上*/

            17. pid_t gettid()
            18. {
            19.     return syscall(SYS_gettid); 
            20. }

            22. #define ORANGE_MAX_VALUE 1000000
            23. #define APPLE_MAX_VALUE 100000000
            24. #define MSECOND 1000000

            26. struct apple
            27. {
            28.     unsigned long long a;
            29.     //char c[128]; /*32,64,128*/
            30.     unsigned long long b;
            31.     //pthread_rwlock_t rwLock;
            32. };

            34. struct orange
            35. {
            36.     int a[ORANGE_MAX_VALUE];
            37.     int b[ORANGE_MAX_VALUE];
            38. };

            40. struct apple test;
            41. struct orange test1;

            43. int cpu_nums;
            44. cpu_set_t mask;
            45.      
            46. inline int set_cpu(int i)
            47. {
            48.     __CPU_ZERO(&mask);
            49.     
            50.     if(2 <= cpu_nums)
            51.     {
            52.         __CPU_SET(i,&mask);
            53.         
            54.         if(-1 == sched_setaffinity(gettid(),sizeof(&mask),&mask))
            55.         {
            56.             return -1;
            57.         }
            58.     }
            59.     return 0;
            60. }

            62. void* addx(void* x)
            63. {
            64. /*
            65.     if(-1 == set_cpu(0))
            66.     {
            67.         return NULL;
            68.     }
            69. */ 
            70.     unsigned long long sum=0,index=0;
            71.     //pthread_rwlock_wrlock(&((struct apple *)x)->rwLock);
            72.     for(sum=0;sum<APPLE_MAX_VALUE;sum++)
            73.     {
            74.         ((struct apple *)x)->a += sum;
            75.     }
            76.     //pthread_rwlock_unlock(&((struct apple *)x)->rwLock);
            77.     
            78.     return NULL;
            79. }

            81. void* addy(void* y)
            82. {
            83. /*  
            84.   if(-1 == set_cpu(1))
            85.     {
            86.         return NULL;
            87.     }
            88. */ 
            89.     unsigned long long sum=0,index=0;
            90.     //pthread_rwlock_wrlock(&((struct apple *)y)->rwLock);
            91.     for(sum=0;sum<APPLE_MAX_VALUE;sum++)
            92.     {
            93.         ((struct apple *)y)->b += sum;
            94.     }
            95.     //pthread_rwlock_unlock(&((struct apple *)y)->rwLock);
            96.     
            97.     return NULL;
            98. }

            100. int main () 
            101. {
            102.     pthread_t ThreadA,ThreadB;
            103.     unsigned long long sum=0,index=0;
            104.     struct timeval tpstart,tpend;
            105.     float timeuse;
            106. /*    
            107.     cpu_nums = sysconf(_SC_NPROCESSORS_CONF);
            108.     
            109.     if(-1 == set_cpu(0))
            110.     {
            111.         return -1;
            112.     } 
            113.  */   
            114.     gettimeofday(&tpstart,NULL);
            115.     
            116.     pthread_create(&ThreadA,NULL,addx,&test);
            117.     pthread_create(&ThreadB,NULL,addy,&test);

            119.     for(index=0;index<ORANGE_MAX_VALUE;index++)
            120.     {
            121.         sum+=test1.a[index]+test1.b[index];
            122.     }
            123.     
            124.     pthread_join(ThreadA,NULL);
            125.     pthread_join(ThreadB,NULL);
            126.     
            127.     gettimeofday(&tpend,NULL);
            128.     
            129.     timeuse=MSECOND*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;
            130.     timeuse/=MSECOND;
            131.     printf("thread thread,Used Time:%f\n",timeuse); 
            132.     
            133.     printf("a = %llu,b = %llu,sum=%llu\n",test.a,test.b,sum);
            134.   
            135.     return 0;
            136. }
            本文采用采用 gettimeofday() 來獲取系統時鐘（system clock）時間，可以精確到微秒。
            本文平均值算法采用的是去掉一個最大值去掉一個最小值，然后平均

            一、單核 單、多線程效率比較
            單核
             
            第1次
            第2次
            第3次
            第4次
            第5次
            第6次
            第7次
            第8次
            第9次
            第10次
            平均
            單線程
            0.951274
            0.951883
            0.951347
            0.950893
            0.810648
            0.810705
            0.951196
            0.951343
            0.811413
            0.950892
            0,916133
            雙線程
            0.989287
            0.986391
            0.986576
            0.985043
            0.986335
            0.985320
            0.986790
            0.986837
            0.985602
            0.986535
            0.986298
            三線程加鎖
            1.318721
            1.318701
            1.319036
            1.318652
            1.318614
            1.318923
            1.318636
            1.318687
            1.319026
            1.318933
            1.318785
            三線程不加鎖
            1.318658
            1.318766
            1.318570
            1.318894
            1.318588
            1.318658
            1.318958
            1.318709
            1.318689
            1.319020
            1.318740


            為什么多線程會比單線程更耗時呢？其原因就在于，線程啟停以及線程上下文切換都會引起額外的開銷，所以消耗的時間比單線程多。


            二、雙核---單線程、多線程、優化后多線程效率比較

            雙核三線程不加鎖
             
            第1次
            第2次
            第3次
            第4次
            第5次
            第6次
            第7次
            第8次
            第9次
            第10次
            Best
            單線程
            0.947490
            0.948153
            0.950648
            0.950412
            0.950422
            0.950407
            0.810345
            0.950386
            0.947501
            0.947513
            0.949036
             
            雙線程
            0.983432
            0.980912
            0.976860
            0.975621
            0.976582
            0.978240
            0.975736
            0.981523
            0.979724
            0.981337
            0.978864
             
            三線程加鎖
            1.310762
            1.309590
            1.308914
            1.309287
            1.310924
            1.310837
            1.307147
            1.311698
            1.311861
            1.309007
            1.310127
            三線程不加鎖
            1.431863
            1.422951
            1.472916
            1.482321
            1.477823
            1.477272
            1.423854
            1.423412
            1.422267
            1.423243
            1.444167
            三線程加鎖Cache32
            1.310174
            1.308985
            1.311462
            1.311574
            1.309590
            1.311329
            1.311602
            1.311154
            1.307573
            1.310447
            1.310589
            三線程不加鎖Cache32
            0.664234
            0.664244
            0.664186
            0.664264
            0.664317
            0.664234
            0.662658
            0.662176
            0.662164
            0.662159
            0.663520

            為什么三線程不加鎖比三線程加鎖還慢呢？
            當兩個線程寫入同一個 cache 的不同部分時，會互相競爭該 cache 行，也就是寫后寫的問題。下文會詳細分析。
            為什么三線程加鎖Cache32比三線程不加鎖Cache32比慢幾乎一倍呢？
            其原因也很簡單，那把讀寫鎖就是罪魁禍首。實際情況并不是并行執行，反而成了串行執行。

            三、針對 Cache 的優化
            在串行程序設計過程中，為了節約帶寬或者存儲空間，比較直接的方法，就是對數據結構做一些針對性的設計，將數據壓縮 (pack) 的更緊湊，減少數據的移動，以此來提高程序的性能。但在多核多線程程序中，這種方法往往有時會適得其反。
            數據不僅在執行核和存儲器之間移動，還會在執行核之間傳輸。根據數據相關性，其中有兩種讀寫模式會涉及到數據的移動：寫后讀和寫后寫 ，因為這兩種模式會引發數據的競爭，表面上是并行執行，但實際只能串行執行，進而影響到性能。
            處理器交換的最小單元是 cache 行，或稱 cache 塊。在多核體系中，對于不共享 cache 的架構來說，兩個獨立的 cache 在需要讀取同一 cache 行時，會共享該 cache 行，如果在其中一個 cache 中，該 cache 行被寫入，而在另一個 cache 中該 cache 行被讀取，那么即使讀寫的地址不相交，也需要在這兩個 cache 之間移動數據，這就被稱為 cache 偽共享，導致執行核必須在存儲總線上來回傳遞這個 cache 行，這種現象被稱為“乒乓效應”。
            同樣地，當兩個線程寫入同一個 cache 的不同部分時，也會互相競爭該 cache 行，也就是寫后寫的問題。上文曾提到，不加鎖的方案反而比加鎖的方案更慢，就是互相競爭 cache 的原因。
            在 X86 機器上，某些處理器的一個 cache 行是64字節，具體可以參看 Intel 的參考手冊。
            既然不加鎖三線程方案的瓶頸在于 cache，那么讓 apple 的兩個成員 a 和 b 位于不同的 cache 行中，效率會有所提高嗎？
            修改后的代碼片斷如下：
            1. struct apple
            2. {
            3.     unsigned long long a;
            4.     char c[128]; /*32,64,128*/
            5.     unsigned long long b;
            6. };
            小小的一行代碼，盡然帶來了如此高的收益，不難看出，我們是用空間來換時間。當然讀者也可以采用更簡便的方法： __attribute__((__aligned__(L1_CACHE_BYTES))) 來確定 cache 的大小。

            參考http://www.ibm.com/developerworks/cn/linux/l-cn-optimization/index.html

            轉自：http://blog.chinaunix.net/uid-20556054-id-3070826.html
            
	
            


            
	    
    




            






            

				
			
            
		            		
	
            
	
            
		
			

		
	
            

            

    
    







            
	   
	



精品久久久久久无码中文字幕一区
|
精品久久久无码21p发布|
老司机国内精品久久久久|
午夜久久久久久禁播电影|
亚洲综合久久久|
欧美亚洲国产精品久久久久|
久久久久久久综合狠狠综合|
久久亚洲AV成人无码|
97久久国产综合精品女不卡|
亚洲国产精品无码久久久不卡|
中文字幕热久久久久久久|
国产色综合久久无码有码|
亚洲国产美女精品久久久久∴|
久久久久亚洲精品日久生情|
亚洲精品无码久久千人斩|
狠狠色丁香久久婷婷综合图片|
久久久久久曰本AV免费免费|
久久久一本精品99久久精品88|
97久久综合精品久久久综合|
一本久久a久久精品综合夜夜|
99久久人人爽亚洲精品美女|
久久夜色精品国产亚洲av|
久久人人爽人人爽人人片AV麻烦|
色综合久久中文字幕无码|
久久青草国产手机看片福利盒子|
日韩久久久久中文字幕人妻
|
伊人久久成人成综合网222|
亚洲欧美日韩中文久久|
国产精品免费久久久久电影网|
四虎久久影院|
国产精品久久波多野结衣|
久久精品中文字幕有码|
一本久久a久久精品vr综合|
亚洲国产精品热久久|
久久久久亚洲av综合波多野结衣|
精品国产一区二区三区久久|
亚洲精品国精品久久99热|
久久九九青青国产精品|
天堂久久天堂AV色综合|
欧美性猛交xxxx免费看久久久|
国产精品一久久香蕉产线看|