多核開發入門指南 – 純月部落 – CSDNBlog

一、為什麼需要多核開發？

        答案很簡單，目前的晶片製造技術對CPU主頻的提升已經達到一個極限了，也就是說效能的垂直伸縮已經不太可能了。因此通過多核的方法，可以讓程式橫向的伸縮，這就類似於用多台伺服器實現負載平衡（水平伸縮），而不是簡單的靠將伺服器升級成小型機來提供處理能力（垂直伸縮）。

        雖然多核並行計算的概念已經存在了幾十年了，但直到最近多核CPU在PC上的普及，多核開發才不得不提引起程式員的重視。

        多核開發的本質就是使用多線程進行程式開發，我們在學資料結構和演算法的時候，寫的所有的演算法都是面向單線程的。而多核開發的目的就是將這些演算法改造成多線程的支援，然後系統運行時將這些多線程平均分配到多核處理器上，以實現啟動並執行加速。

 

二、如何進行多核開發

      如果你很熟悉POSIX threads (pthreads) 或者 WinAPI threads，你就可以自己進行開發。
      如果你不想設計過多底層的線程操作，那就選擇一個並發開發平台，由平台來自動協調，調度和管理多核資源。並發開發平台包括各種線程池的庫，例如
          .NET的ThreadPool類
          Java的Concurrent類
          訊息傳遞環境，例如MPI
          data-parallel編程環境，例如NESL, RapidMind, ZPL
          task-parallel編程環境, 例如Intel的Threading Building Blocks (TBB) 和 Microsoft的Task Parallel Library (TPL)
          動態編程環境,例如Cilk or Cilk++或者業界標準OpenMP. 
    這些並發平台通過提供語言抽象，擴充注釋或者提供庫函數的方式來支援多核開發。

 

三、使用並發開發平台具體有哪些好處

      我們從下面幾個方面來看：

      軟體開發中最重要的三個考慮的要素就是
              程式的效能 （使用多核就是為了提升程式的效能的）
              開發的時間
              程式的可靠性

      而其中影響開發時間的三個要素是

                 伸縮性：如果你自己編寫線程，你必須考慮使用者是雙核，四核還是八核。如何將線程自動適應使用者的核心數，並且在多核上將線程均衡的負載。
                 代碼簡潔：直接使用底層線程庫作業碼是十分複雜的
                 模組化：直接使用底層線程庫操作還會破壞代碼的模組化

四、具體執行個體

          下面以Fibonacci的例子來示範：它的遞迴演算法經常被用來作為多核開發的例子。

          單核時代，我們寫Fibonacci代碼的方法如下：

1. int fib(int n) 
2. {
3.   if (n < 2) return n;
4.  else {
5.       int x = fib(n-1);
6.       int y = fib(n-2);
7.       return x + y;
8.      }
9. }       
10.                 
11. int main(int argc, char *argv[])
12. {       
13.   int n = atoi(argv[1]);
14.  int result = fib(n);
15.  printf("Fibonacci of %d is %d./n", n, result);
16.  return 0;
17. }

       這個演算法的核心就是f(n) = f(n-1) + f(n-2),當n很大時，我們希望計算f(n-1)和f(n-2)這兩個任務能否分攤在一個雙核處理器上同時執行。

 

       如果直接使用WinAPI-threaded操作的代碼如下：

  

1.       int fib(int n)
2.  {
3.    if (n < 2) return n;
4.    else {
5.     int x = fib(n-1);
6.     int y = fib(n-2);
7.      return x + y;
8.      }
9.  }
10.      
11.  typedef struct {
12.        int input;
13.        int output;
14.      } thread_args;
15.      
16.   void *thread_func ( void *ptr )
17.   {
18.     int i = ((thread_args *) ptr)->input;
19.     ((thread_args *) ptr)->output = fib(i);
20.     return NULL;
21.   }
22.       
23.  int main(int argc, char *argv[])
24.      {
25.        pthread_t thread;
26.        thread_args args;
27.        int status;
28.        int result;
29.        int thread_result;
30.        if (argc < 2) return 1;
31.        int n = atoi(argv[1]);
32.        if (n < 30) result = fib(n);
33.        else {
34.          args.input = n-1;
35.          status = pthread_create(thread,
36.      NULL, thread_func,
37.      (void*) &args );
38.         // main can continue executing while the thread executes.
39.          result = fib(n-2);
40.         // Wait for the thread to terminate.
41.          pthread_join(thread, NULL);
42.          result += args.output;
43.        }
44.  printf("Fibonacci of %d is %d./n", n, result);
45.  return 0;
46.  }

       注意main裡面的if(n<30)，當n在30以內時，計算非常快，就不需要使用多線程，當n大於30之後，我們產生一個線程用來計算f(n-1)，而main的主線程將繼續計算f(n-2)，這樣等兩個線程都結束以後（pthread_join(thread, NULL);），我們將他們的結果相加。

從這個例子就可以看出，自己實現線程的缺點：

        1 這個例子正好可以用兩個線程分配在兩個核上來實現，可如果一個任務需要16個線程同時執行，我們又不知道用戶端到底是幾核的CPU時，這個任務如何分配就成為一個問題。

        2 這段代碼非常不簡潔

        3 額外的結構和函數也破壞了演算法本身的完整性。

 

下面我們使用多核支援庫來實現該代碼：

使用OpenMP

 

1. int fib(int n) {
2.   int i, j;
3.   if (n<2)
4.      return n;
5.   else {
6.     #pragma omp task shared(i)
7.     i=fib(n-1);
8.     #pragma omp task shared(j)
9.     j=fib(n-2);
10.     #pragma omp taskwait
11.     return i+j;
12.   }
14. }

使用Cilk++

1. int fib(int n) 
2. {
3.   if (n < 2) return n;
4.  else {
5.       int x = cilk_spawn fib(n-1);
6.       int y = fib(n-2);
7.       cilk_sync;
8.       return x + y;
9.      }
10. }       
11.                 
12. int main(int argc, char *argv[])
13. {       
14.   int n = atoi(argv[1]);
15.  int result = fib(n);
16.  printf("Fibonacci of %d is %d./n", n, result);
17.  return 0;
18. }

.NET Task Parallel Library中相應的例子

1.   Private Function FiboFullParallel(ByVal N As Long) As Long
2.        If N <= 0 Then Return 0
3.        If N = 1 Then Return 1
4.    
5.        Dim t1 As Tasks.Future(Of Long) = Tasks.Future(Of Long).Create( Function() FiboFullParallel(N - 1))
6.        Dim t2 As Tasks.Future(Of Long) = Tasks.Future(Of Long).Create( Function() FiboFullParallel(N - 2))
7.    
8.        Return t1.Value + t2.Value
9.    End Function

     可以看到無論使用哪種並發平台，代碼都非常簡潔，沒有破壞原有的演算法封裝，僅僅通過簡單的改造就可以實現自動任務的指派。

五、什麼情況下該使用多核編程呢？

        如果一個任務的執行時間在10-100毫秒，那麼就無需使用多核，因為將任務通過多線程分解到多核上計算，然後再將結果集合起來的開銷大致需要100毫秒(當然具體多少依據機器的效能以及你所使用的編譯器的效能),而且還需要消耗記憶體的空間。

        在OpenMP裡面我們可以使用"if clause"來給雙核配置增加條件，例如下面的代碼很明顯，當n小於100000的時候，不使用多核，當n大於的時候再使用

1. #pragma omp parallel for if(n > 100000)
2. for (i = 0; i < n;, i++) {
3. ...
4. }

六、後記

       本文旨在告訴你為何要進行多核開發，以及簡單展示了多核開發平台的使用。實際的多核開發要複雜的多，而且我們知道目前的PC機的多核系統都是基於共用記憶體的，雖然每個核都有自己的一級緩衝。因此不同核上的線程在運行時就涉及到對資源競爭使用的問題。除此以外如果應用需要用到IO（硬碟，網路）的時候，也存在同樣的問題。因此多核的設計的痛點就在於需要具體情況具體分析，找出多核應用的瓶頸，通過改進資料結構或演算法，消除或最佳化這個瓶頸。

轉自http://www.360doc.com/content/08/1123/14/7635_1984923.shtml