博客园_jiahaipeng

MPI并行编程系列之五：图的单源最短路径算法

2010-04-19T01:15:00Z

图的单源最短路径问题是指求一个从指定的顶点s到其他所有顶点i之间的最短距离。因为是从一点到其他顶点的距离，所以称谓单源。本文将介绍dijkstra算法：按路径长度递增次序的最短路径算法，并给出了对该算法MPI并行化算法。

一、算法思想

该算法的思想是：引入一个辅助向量D，它的每个分量D[i]为源顶点v到其他顶点v[i]的路径长度。初始态为：如有从v到vi的路径，则D[i]为弧[v,vi]的权值；否则D[i]为无穷大。显然

D[j] = min{D[i]}

为顶点v出发到其他顶点的一条最短路径的长度，其路径为（v，vj）。

那么下一条最短路径长度如何计算呢？其实很简单，下一条最短路径长度要么是源顶点v直接到某一顶点vk的长度，即{v，vk}。要么是源顶点v经过顶点vj到某一顶点的长度，即{v，vj，vk}。

我们假设S为已经求得最短路径的顶点的集合，那么下一条最短路径（设其终点为x），要么是弧{v， vx}，要么为中间只经过S中顶点而最后到达终点X的路径。

在一般情况下，下一条最短路径的长度为：

D[j] = min{D[i] | vi 属于 V-S}

其中V为图顶点的集合， D[i]为弧{v， vi}的权值，或者为D[k]和弧{vk， vi}权值之和。

二、算法描述

根据以上思想，我们得到算法描述如下：

输入：图G的邻接矩阵m[0...n-1][0...n-1]，源顶点 v

输出：最短路径值向量D[0...n-1], 最短路径矩阵p[0...n-1][0...n-2].其中D[i]为源顶点v到顶点vi的最短路径长度，向量p[i]为源顶点v到顶点vi的最短路径

1）初始化D[i]

D[i] = m[v][vi] == 无穷大 ? 无穷大 : m[v][vi]

2)计算当前最短路径值

min = min{D[i]}

final[i] = 1 //标记顶点i已经取得最短路径

3）更新最短路径值及最短路径

for(i = 0; i < n; i++)

if(!final[i])

if(D[i] > min + m[vk][vi])

D[i] = min + m[vk][vi];

end if

endif

for( j = 0; j < n-1 ; j++)

if(p[vk][j] != 无穷大)

p[vi][j] = p[vk][j];

end if

end for

p[vi][j] = vi

end for

4) 输出最短路径和最短路径值

三、算法实现

这里只给出算法的核心代码，如下：

   1:  void short_path_function(

   2:          int **matrix,

   3:          int vertex_num,

   4:          int vertex_source){

5:

   6:      int *short_path_value;

   7:      int *final;

8:

   9:      int *short_path_storage;

  10:      int **short_path;

11:

  12:      int min;

  13:      int vertex;

14:

  15:      int i,j,k;

16:

  17:      //分配空间

  18:      short_path_value = my_malloc(sizeof(int) * vertex_num);

  19:      final = my_malloc(sizeof(int) * vertex_num);

  20:      dynamic_allocate_matrix((void *)&short_path, (void *)&short_path_storage, vertex_num,

  21:              vertex_num-1, sizeof(int));

22:

  23:      //初始化

  24:      for(i = 0; i < vertex_num; i++){

  25:          final[i] = 0;

  26:          short_path_value[i] = matrix[vertex_source][i];

27:

  28:          //设置空路径

  29:          for(j = 0; j < vertex_num-1; j++)

  30:              short_path[i][j] = -1;

31:

  32:          //初始化路径

  33:          if(short_path_value[i] < MAX_VAULE)

  34:              short_path[i][0] = i;

  35:      }

36:

  37:      final[vertex_source] = 1;

  38:      for(i = 1; i < vertex_num; i++){

  39:          //找出从源顶点出发的一条最短路径长度顶点

  40:          min =MAX_VAULE ;

  41:          for(j = 0; j < vertex_num; j++)

  42:              if(!final[j])

  43:                  if(short_path_value[j] < min){

  44:                      min = short_path_value[j];

  45:                      vertex = j;

  46:                  }

47:

  48:          final[vertex] = 1;

49:

  50:          //跟新最短路径

  51:          for(j = 0; j < vertex_num; j++){

  52:              if(!final[j])

  53:                  if(min + matrix[vertex][j] < short_path_value[j]){

  54:                      //跟新最短路径长度

  55:                      short_path_value[j] = min + matrix[vertex][j];

56:

  57:                      //更新路径

  58:                      k = 0;

  59:                      while(short_path[vertex][k] != -1){

  60:                          short_path[j][k] = short_path[vertex][k];

  61:                          k++;

  62:                      }

63:

  64:                      short_path[j][k] = j;

  65:                  }

  66:          }

  67:      }

68:

  69:      //打印结果

  70:      array_int_print(vertex_num, short_path_value);

  71:      print_int_matrix(short_path, vertex_num-1, vertex_num);

  72:  }

四、并行算法描述

我们对这个算法进行并行化分析，显然初始化向量D（对应于算法的第一步），更新最短路径值和最短路径（对应于算法的第三步）是可以并行化实现的，因为只要有了当前最短路径和最短路径值，各个顶点的最短路径的算法是相互独立的。在本并行化算法中，如何求得当前的最短路径和最短路径值成为关键。

我们假设一共用P个进程，图右n个顶点，我们让每个进程负责n/p个顶点，每个进程都有自己的向量D和最短路径p，我们如何求得当前的最短路径长度和最短路径呢？首先，我们可以计算出各个进程的当前最短路径，并将局部最短路径发往进程0，进程0对这些进程的最短路径进行比较，取得当前的全局最短路径，并将这一结果广播到所有的进程。

其算法描述如下：

我们假设总共有p个进程

输入：图G的邻接矩阵m[0...n-1][0...n-1]，源顶点 v

输出：最短路径值向量D[0...n-1], 最短路径矩阵p[0...n-1][0...n-2].

1）进程0读取邻接矩阵m和源节点v，并将m，v广播到其他所有的进程

2）各进程并行初始化各自的局部D和P

3）求最短路径

1）各进程并行计算出各自的局部最短路径值，并将其发送0号进程

2）0号进程求出全局最短路径值和对应的进程号，并将其广播到其他所有的进程。

3）拥有全局最短路径值的进程将其对应的最短路径广播到其他进程（用于更新各个进程的最短路径）

4）各进程并行跟新各自的D和P

五、并行算法实现

我们这里只给出算法中第三步的具体实现：

   1:  int get_short_path_value(

   2:          int *final,

   3:          int *vertex,

   4:          int **short_path,

   5:          int *short_path_value,

   6:          int *short_path_copy,

   7:          int *shortest,

   8:          int vertex_num,

   9:          int local_vertex_num,

  10:          int process_id,

  11:          int process_size,

  12:          MPI_Comm comm){

13:

  14:      int min;

  15:      int local_vertex;

16:

  17:      int shortest_process_id;

18:

  19:      MPI_Status status;

20:

  21:      int j;

22:

  23:      //取到每个进程的路径的最小值

  24:      min = MAX_VAULE;

  25:      for(j = 0; j < local_vertex_num; j++)

  26:          if(!final[j])

  27:              if(short_path_value[j] < min){

  28:                  min = short_path_value[j];

  29:                  local_vertex = j;

  30:              }

31:

  32:      //各进程将自己的最小路径值发往0号进程

  33:      if(process_id)

  34:           MPI_Send(&min, 1, MPI_INT, 0, DATA_MESSAGE, comm);

  35:      else{

  36:          //0号进程收集所有进程的最小值

  37:          shortest[0] = min;

  38:          for(j = 1; j < process_size; j++)

  39:              MPI_Recv(shortest+j, 1, MPI_INT, j, DATA_MESSAGE, comm, &status);

40:

  41:           //0号进程计算出全局最小值，并广播到其他各个进程

  42:            min = shortest[0];

  43:            shortest_process_id = 0;

  44:            for(j = 1; j < process_size; j++)

  45:               if(shortest[j] < min){

  46:                   min = shortest[j];

  47:                   shortest_process_id = j;

  48:                }

  49:      }

  50:      //0号进程将最小值广播到所有进程,如果最小值为无穷大，则返回

  51:      MPI_Bcast(&min, 1, MPI_INT, 0, comm);

  52:      if(min == MAX_VAULE)

  53:          return min;

54:

  55:      //0号进程将最小值所属的进程广播到所有的进程

  56:      MPI_Bcast(&shortest_process_id, 1, MPI_INT, 0, comm);

57:

  58:      //拥有最小值的进程，将其对应的标志位标1，并计算该坐标的全局坐标

  59:      if(process_id == shortest_process_id){

  60:          final[local_vertex] = 1;

  61:          *vertex = BLOCK_LOW(shortest_process_id, process_size, vertex_num) + local_vertex;

62:

  63:          //复制最短路径

  64:          for(j = 0; j < vertex_num -1; j++)

  65:              short_path_copy[j] = short_path[local_vertex][j];

  66:      }

67:

  68:      //广播最短路径

  69:      MPI_Bcast(short_path_copy, vertex_num-1, MPI_INT, shortest_process_id,comm);

  70:      MPI_Bcast(vertex, 1, MPI_INT, shortest_process_id, comm);

71:

  72:      return min;

  73:  }

六、MPI函数说明

本并行算法用到的MPI函数主要为点对点通信函数MPI_Send和MPI_Recv，全局通信函数MPI_Bcast。MPI名字起的真好，消息传递编程，我觉得ＭＰＩ算法的核心就是任务的划分和任务间的通信。

下篇将介绍图的最下生成树及其并行算法。

本文链接

MPI并行编程系列之四：KMP算法及并行化

2010-04-15T01:31:00Z

串匹配问题是计算机科学中的一个基本问题，在文字编辑、图像处理等利于都得到了广泛的应用，串匹配算法在这些应用中起到至关重要的作用。因此研究快速的串匹配算法具有重要的理论和实际意义。

KMP是一种改进的字符串模式匹配的算法，他能够在o(m+n)时间复杂度内完成字符串的模式匹配算法。本文将详细的介绍KMP算法的思想，串行及并行实现。

一、KMP算法思想

1、问题描述

给定主串S[0...n-1]、模式串T[0...m-1]，其中m<=n。在主串S中找出所有模式串T的起始位置。

2、算法思想

令指针i指向主串S，指针j指向模式串T中当前正在比较的位置。令指针i和指针j指向的字符比较之，如两字符相等，则顺次比较后面的字符；如不相等，则指针i不动，回溯指针j，令其指向模式串T的第pos个字符，使T[0...pos-1] == S[i-pos, i-1],然后，指针i和指针j所指向的字符按此种方法继续比较，知道j == m-1，即在主串S中找到模式串T为止。

从算法的思想思想中我们可以看出，其算法的难点在于如何求出指针j的回溯值，即：当指针j回溯时，j将指向的位置，我们几位next[j]。下面我们首先对kmp的算法做出详细的描述。

二、KMP算法描述

输入：主串S[0...n-1], 模式串T[0...m-1]

输出：m[0...n-1],当m[i] = 1时，则主串S中匹配到模式串，且i为起始位置

begin

i = 0； j = 0;

while(i < n)

if(S[i] != T[j])

j = next[j]

if( j == -1)

i++ j++

endif;

contiue;

endif

if (j == m-1)

m[i-j+1] = 1

j = -1

i = i-j+1

endif

i++ j++

end while

end

在上面的算法描述中，next函数的编写为整个算法的核心，设计出快速正确的next函数也为KMP算法的重中之重。如何设计我们的next函数呢，我们利用递推思想：

1）令next[0] = -1，（为什么要等于-1呢，从上面的算法可以看出，当next[j] == -1时，证明字符串匹配要从模式串的第0个字符开始,且第0个字符并不和主串的第i个字符相等，i指针向前移动。）

2）假设next[j] = k ,说明T[0..k-1] == T[j-k...j-1]

3) 现在我们来求next[j+1]

3.1 当T[j] == T[k]时,说明T[0..k] == T[j-k..j],这时分为两种情况讨论：

3.1.1 当T[j+1] != T[k+1]，显然

next[j+1] = k+1;

3.1.2 当T[j+1] == T[k+1]，当这两个字符相等时，说明T[k+1]和T[j+1]一样，都不和主串的字符相匹配，因此：

m = k+1, j=next[m] 直到T[m] != t[j+1]

next[j+1] = m

3.2 当T[j] != T[k]时,我们必须在T[0..k-1]中找到next[j+1],这时：

k = next[k],直到T[j] ==T[k]

next[j+1] = next[k]

这样我们就通过数学中递推的方式求得了匹配串T的next函数。

三、串行实现

有了以上的算法描述，我们可以编写我们的kmp串行实现，本文不想黏贴过多的代码，仅仅给出next函数的实现：

   1:  int *get_next(char *match_string, int match_string_length){

2:

   3:      int *next;

   4:      int next_index;

5:

   6:      int i;

7:

   8:      next = (int *)my_malloc(sizeof(int) * match_string_length);

9:

  10:      next[0] = -1;

  11:      i =0;

  12:      next_index = -1 ;

13:

  14:      while(i < match_string_length){

15:

  16:          if(next_index == -1 || match_string[next_index] == match_string[i]){//对应于3.1

  17:              i++;

  18:              next_index++;

19:

  20:              if(match_string[i] != match_string[next_index])//对应于3.1.1

  21:                  next[i] = next_index;

  22:              else//对应于3.1.2

  23:                  next[i] = next[next_index];

  24:          }

  25:          else//对应于3.2

  26:              next_index = next[next_index];

  27:      }

28:

  29:      return next;

  30:  }

四：并行算法

现在我们考虑如何将KMP算法并行化，我们很容易考虑到得是将主串S平均分成P段（假设有p个处理器），每个处理器处理其中的一段。但这时要考虑一个问题，那就是如何处理每段字符串最后m-1个子字符串的匹配问题，因为这m-1个字符可能会和其后一段的前t个字符共同构成模式串。我们首先考虑到得是每个处理器将其负责字符串的后m-1个字符的字串发送给其后面的处理器，但这样会造成通信过大的问题，每个处理器都要发送m-1个字符。如何减少处理器间的通信呢？起始我们只需发送和模式串前t个字符想匹配的t个字符就可以了。这样就减少了进程间的通信。其算法描述如下：

输入:主串T[0...n-1],模式串S[0...m-1]

输出：m[0...n-1],当m[i] = 1时，则主串S中匹配到模式串，且i为起始位置

条件：t个处理器

1）p0读取主串和模式串，将模式串广播到起到所有的处理器中，并将主串分段发送到其对应的处理器中

2）处理器并行计算next函数，这样每个处理器都有统一的next函数和模式串

3）处理器p0 ,p1,...,pt-1并行计算各自负责字符串的后m-1个字符的字串和模式串的最小匹配串，并将最小匹配串发往下一个处理器

4）处理器接收上个处理器发送的字符串，并和本身的字符串合并成一个新的字符串

5）各处理器并行计算匹配结果m

6）处理器p0对各处理器的匹配结果进行整合，得到最终结果。

因为kmp并行算法相对简单，也没有用到新的MPI函数，这里不列出其并行实现代码。

下一篇：图论：单源最短路径的并行算法

本文链接

MPI并行编程系列三：并行正则采样排序PSRS

2010-04-10T02:32:00Z

快速排序算法的效率相对较高，并行算法在理想的情况下时间复杂度可达到o(n)，但并行快速排序算法有一个严重的问题：会造成严重的负载不平衡，最差情况下算法的复杂度可达o(n^2)。本篇我们介绍一种基于均匀划分的负载平衡的并行排序算法------并行正则采样排序（Parallel Sorting by Regular Sampling）。

一、算法的基本思想

假设待排序的元素n个，处理器p个。

首先将这n个元素均匀的分成p部分，每部分包含n/p个元素。每个处理器负责其中的一部分，并对其进行局部排序。为确定局部有序序列在整个序列中的位置，每个处理器从各自的局部有序序列中选取几个代表元素，将这些代表元素进行排序后选出p-1个主元。每个处理器根据这p-1个主元将自己的局部有序序列分成p段。然后通过全局交换的方式，将p段有序序列分发给对应的处理器，使第i个处理器都拥有各个处理器的第i段，共p段有序序列。每个处理器对着p段有序序列进行排序。最后，将各个处理器的有序段依次汇合起来，就是全局有序序列了。

二、算法描述

根据算法的基本思想，我们对算法的描述如下：

输入：n个待排序的序列

输出：分布在各个处理器上，得到全局有序的数据序列

1）无序序列的划分及局部排序

根据数据快的划分方法（请看系列一），将无序序列划分成p部分，每个处理器对其中的一部分进行串行快速排序，这样每个处理器就会拥有一个局部有序序列。

2）选取代表元素

每个处理器从局部有序序列中选取第w,2w,...,(p-1)w共p-1个代表元素。其中w = n/p^2。

3）确定主元

每个处理器都将自己选取好的代表元素发送给处理器p0。p0对这p段有序序列做多路归并排序，再从这排序后的序列中选取第p-1,2(p-1), ...,(p-1)(p-1)共p-1个元素作为主元。

4）分发主元

p0将这p-1个主元分发给各个处理器。

5）局部有序序列划分

每个处理器在接收到主元后，根据主元将自己的局部有序序列划分成p段。

6）p段有序序列的分发

每个处理器将自己的第i段发送给第i个处理器，是处理器i都拥有所有处理器的第i段。

7）多路排序

每个处理器将上一步得到的p段有序序列做多路归并。

经过这7步后，一次将每个处理器的数据取出，这些数据是有序的。

三、算法分析

1）负载均衡分析：

因为这个算法是一个负载平衡的算法，者从第1）步中就可以看出来，但却不是完美的，因为在第6）步的划分很可能会引起负载的不平衡。

2）时间复杂度分析

PSRS算法适合处理大批量的数据（呵呵，数据量不大，何必并行乎）。当n>p^3时，算法的时间复杂度可达n/p*logn。具体每一步的时间复杂度的分析在这里就不一一描述了，因为每一步的排序都是普通的串行排序算法。

四、算法实现

因为算法比较复杂，代码较长，本文仅仅列出主代码，代码如下：

   1:  void psrs_mpi(int *argc, char ***argv){

2:

   3:      int process_id;

   4:      int process_size;

5:

   6:      int *init_array;             //初始数组

   7:      int init_array_length;         //初始数组长度

8:

   9:      int *local_sample;             //每个进程选取的代表元素数组

  10:      int local_sample_length;    //代表元素数组长度

11:

  12:      int *sample;                 //代表元素集合（0号进程使用）

  13:      int *sorted_sample;         //排序后的代表元素的集合

  14:      int sample_length;             //代表预算的长度

15:

  16:      int *primary_sample;         //主元

17:

  18:      int *resp_array;             //偏移数组，主要用户指定个进程数组的各分段的长度

19:

  20:      int *section_resp_array;    //偏移数组,用于指定进程从其他进程获得的数组的长度

21:

  22:      int *section_array;             //从各个进程中获得分段数组的集合

  23:      int *sorted_section_array;

  24:      int section_array_length;     //总长

25:

  26:      int section_index;

27:

  28:      int i, j ;                     //循环变量

29:

  30:      MPI_Request handle;

  31:      MPI_Status  status;

32:

  33:      mpi_start(argc, argv, &process_size, &process_id, MPI_COMM_WORLD);

  34:      resp_array = (int *)my_mpi_malloc(process_id, sizeof(int) * process_size);

35:

  36:      //为每个进程构建一个数组

  37:      //并对改进型的数组进行串行快速排序

  38:      init_array_length = ARRAY_LENGTH;

  39:      init_array = (int *)my_mpi_malloc(process_id, sizeof(int) * init_array_length);

  40:      array_builder_seed(init_array, init_array_length, process_id);

41:

  42:      quick_sort(init_array, 0, init_array_length -1);

43:

  44:      //每个处理器从排序号的序列中选取process_size-1个元素

  45:      //并发送到0号进程中

  46:      local_sample_length = process_size - 1;

  47:      local_sample = array_sample(init_array, local_sample_length, init_array_length/process_size, process_id);

48:

  49:      if(process_id)

  50:           MPI_Send(local_sample, local_sample_length, MPI_INT, 0, SAMPLE_DATA, MPI_COMM_WORLD);

51:

52:

  53:      //0号进程接收各处理器发送过来的代表元素，并将这些元素做多路归并排序

  54:      if(!process_id){

  55:          sample = (int *)my_mpi_malloc(0, sizeof(int) * process_size * local_sample_length);

  56:          sorted_sample = (int *)my_mpi_malloc(0, sizeof(int) * process_size * local_sample_length);

  57:          array_copy(sample, local_sample, local_sample_length);

58:

  59:          for(i = 1; i < process_size; i++)

  60:              MPI_Irecv(sample + local_sample_length * i, local_sample_length, MPI_INT, i, SAMPLE_DATA,

  61:                      MPI_COMM_WORLD, &handle);

62:

  63:          MPI_Wait(&handle, &status);

64:

  65:          for(i = 0; i < process_size; i++)

  66:              resp_array[i] = local_sample_length;

67:

  68:          mul_merger(sample, sorted_sample, resp_array, process_size);

69:

  70:          //从排序好的代表元素中选取process_size-1个主元,并将这些主元广播道其他的处理器中

  71:          primary_sample = array_sample(sorted_sample, process_size -1, process_size -1, process_id);

  72:      }

  73:      if(process_id)

  74:          primary_sample = (int *)my_mpi_malloc(process_id, sizeof(int) * process_size -1);

75:

  76:      MPI_Bcast(primary_sample, process_size-1, MPI_INT, 0, MPI_COMM_WORLD);

77:

  78:      //将处理器上的数据根据主元分成process_size 端

  79:      get_array_sepator_resp(init_array, primary_sample, resp_array, init_array_length, process_size);

  80:      if(process_id == ID){

  81:          printf("process %d resp array is:" ,process_id);

  82:          array_int_print(process_size, resp_array);

  83:      }

84:

  85:      //每个处理器将自己的第i段发送给第i个处理器

  86:      section_resp_array = (int *)my_mpi_malloc(process_id, sizeof(int) * process_size);

  87:      section_resp_array[process_id] = resp_array[process_id];

88:

  89:      //每个进程将要发送的数据的个数发送给哥哥处理器

  90:      for(i = 0; i < process_size; i++){

  91:          if(i == process_id){

  92:              for(j = 0; j < process_size; j++)

  93:                 if(i != j)

  94:                        MPI_Send(&(resp_array[j]), 1, MPI_INT, j, SECTION_INDEX ,

  95:                             MPI_COMM_WORLD);

  96:          }

  97:          else

  98:              MPI_Recv(&(section_resp_array[i]), 1, MPI_INT, i, SECTION_INDEX,

  99:                      MPI_COMM_WORLD, &status);

 100:      }

 101:

 102:      MPI_Barrier(MPI_COMM_WORLD);

 103:

 104:      section_array_length = get_array_element_total(section_resp_array, 0, process_size - 1);

 105:      section_array = (int *)my_mpi_malloc(process_id, sizeof(int) * section_array_length);

 106:      sorted_section_array = (int *)my_mpi_malloc(process_id, sizeof(int) * section_array_length);

 107:      section_index = 0;

 108:

 109:      for(i = 0; i < process_size; i++){

 110:          if(i == process_id){

 111:              for(j = 0; j < process_size; j++){

 112:                  if(j)

 113:                      section_index = get_array_element_total(resp_array, 0 , j-1);

 114:                  if(i == j)

 115:                      array_int_copy(section_array, init_array, section_index, section_index+resp_array[j]);

 116:                  if(i != j){

 117:                      if(j)

 118:                          section_index = get_array_element_total(resp_array, 0 , j-1);

 119:                      MPI_Send(&(init_array[section_index]), resp_array[j], MPI_INT,

 120:                              j, SECTION_DATA, MPI_COMM_WORLD);

 121:                  }

 122:              }

 123:          }

 124:          else{

 125:              if(i)

 126:                  section_index = get_array_element_total(section_resp_array, 0, i-1);

 127:              MPI_Recv(&(section_array[section_index]), section_resp_array[i], MPI_INT,

 128:                      i, SECTION_DATA, MPI_COMM_WORLD, &status);

 129:          }

 130:      }

 131:      MPI_Barrier(MPI_COMM_WORLD);

 132:

 133:      //进行多路归并排序

 134:      mul_merger(section_array, sorted_section_array, section_resp_array, process_size);

 135:

 136:      array_int_print(section_array_length, sorted_section_array);

 137:

 138:      //释放内存

 139:      free(resp_array);

 140:      free(init_array);

 141:      free(local_sample);

 142:      free(primary_sample);

 143:      free(section_array);

 144:      free(sorted_section_array);

 145:      free(section_resp_array);

 146:

 147:      if(!process_id){

 148:          free(sample);

 149:          free(sorted_sample);

 150:      }

 151:

 152:      MPI_Finalize();

 153:  }

五、MPI函数分析

     在上述算法中，用到了MPI的非阻塞通信函数：MPI_IRecv，其对应的是MPI_Isend。这连个函数用于进程间的非阻塞通信，使通信和运算能够同时进行。有这两

个非阻塞通信函数，就不能不提MPI_Wait函数，该函数的作用是阻塞进程执行，直到想对应的所有进程操作都执行的这个地方为止。一般是这个三函数一起使用。

下篇，我们将介绍kmp字符串匹配算法及其并行化。

本文链接

MPI并行编程系列

2010-04-10T02:29:00Z

为提高自己的MPI编程水平，并能及时总结MPI编程的认识，特写此系列文章。欢迎各位高手积极指导，不吝赐教。

本系列是根据陈国良院士的《并行算法实践》一书进行学习和编写。

本系列中的所有程序都是自己用心编写，并测试通过。

程序编写环境：

操作系统：Ubuntu

语言： c

并行库： MPI

编译器： gcc

编写工具：vim

本系列主要包括一下内容

一、排序算法及并行化

二、字符串匹配

三、图

MPI并行编程系列二：快速排序

2010-04-06T01:00:00Z

在上一篇中对枚举排序的MPI并行算法进行了详细的描述和实现，算法相对简单，采用了并行编程模式中的单程序多数据流的并行编程模式。在本篇中，将对快速排序进行并行化分析和实现。本篇代码用到了上篇中的几个公用方法，在本篇中将不再做说明。

在本篇中，我们首先对快速排序算法进行描述和实现，并在此基础上分析此算法的并行性，确定并行编程模式，最后给出该算法的MPI实现。

一、快速排序算法说明

快速排序时一种最基本的排序算法，效率相对较高。其基本思想是：在当前无序数组R[1,n]中选取一个记录作为比较的“基准”，即作为排序中的“轴”。经过一趟排序后，当前无序数组R[1,n]就会以这个轴为核心划分为两个无序的子区r1[1,i-1],r2[i,n]。其中左边的无序子区都会比“轴”小，右边的无序子区都会比“轴”大。这样下一趟排序，我们就可以对这两个子区用同样的方法进行划分排序，知道所有的无序子区中的记录均排好为止。

根据算法的说明，快速排序时一个典型的递归算法，算法描述如下：

无序数组R[1], R[2], ... , R[n]

quick_sort(R, start, end)

if(start < end)

r = partion(R, start, end)

quick_sort(R, start, r-1)

quick_sort(R, r+1, end)

endif

end quick_sort

方法partion的作用就是选取“轴”，并将数组分为两个无序子区，并将该“轴”的最终位置返回，在这里我们选择数组的第一个元素为“轴”，其算法描述为：

partion(R, start, end)

r = R[start]

while(start < end)

while( (R[end] >= r) && (start < end))

end--

end ehile

R[start] = R[end]

while( (R[start] < r) && (start < end))

start++

end wile

R[end] = R[start]

end while

R[start] = r

return start

end partion

该排序算法的性能好坏主要取决于“轴”的选定，即无序数组的划分是否均衡。最好的情况下，无序数组每次都会被划为两个均等的无序子区，这是算法的负责度为o(nlogn)；最坏的情况，无序数组每次划分都是左边n-1个元素，右边0个元素，这时算法的复杂度为o(n^2)。在通常的情况下，该算法的复杂度会依然保持在o(nlogn)，上只不过具有更高的常数因子。因此，选定一个有效地“轴”，成为该算法的关键。一般情况下，会选定无序数组的第一个，中间或者是最后一个元素作为算法的“轴”，我们可以对着三个元素进行比较，取大小居中的那个元素作为该算法的“轴”。

二、快速排序算法的串行实现

快速排序很明显的是一个递归的程序。编写递归程序一个很重的要点就是确定在什么条件下终止递归操作。主函数代码如下：

   1:  void quick_sort_function(int *array, int start, int last){

2:

   3:      int part_position;

4:

   5:      if(start >= last)

   6:          return;

7:

   8:      part_position = part_array_head(array, start, last);

   9:      quick_sort_function(array, start, part_position-1);

  10:      quick_sort_function(array, part_position+1, last);

  11:  }

主函数代码很简单，一个终止递归的条件，一个递归方式。在主函数中，核心函数为part_array_head,其代码如下：

   1:  int part_array_head(int *array, int start, int last){

2:

   3:      int position_value = array[start];

4:

   5:      while(start < last){

   6:          while(start < last && array[last] >= position_value)

   7:              last--;

   8:          array[start] = array[last];

9:

  10:          while(start < last && array[start] <= position_value)

  11:              start++;

  12:          array[last] = array[start];

  13:      }

14:

  15:      array[start] = position_value;

16:

  17:      return start;

  18:  }

从代码可以看出，快速排序的代码相对姜丹，总共不过三十行代码。本人是非常喜欢递归操作的。下面我们将对快速排序进行并行化分析。

三、快速排序并行化分析

在并行编程策略中，有一种策略非常适合递归算法，自然也就成为我们快速排序并行化的首选策略。这种策略为“分治策略”，这种策略的核心思想就是将一个大而复杂的问题分解成若干个子问题分而治之。若分解后的子问题依然过大或者是过于复杂，则可反复利用分治策略，直到很容易的求解子问题未知。

有此看出，分治策略也符合递归的思想。要实现分治策略，主要分为三步：1、将大问题分解成小问题；2、求解小问题；3、归并小问题的解，得到最终结果。其中各个小问题的求解就是我们并行化的所在。分治策略的说明图如下：

在快速排序算法中，我们就是将原无序数组按照一定得规则拆分成一个个子数组，即上图中的“分解”过程，每个子数组的排序可并行执行。当各子数组排序完毕后，依此将结构传给其父数组，得到最终的结果，即上图中的“归并”过程。

基于以上的分析，我们给出快速排序算法MPI的实现如下：

四、快速排序的MPI并行实现

因为分治策略的特殊性，我们进行快速排序算法的进程数目为2^m个。我们依然用进程p0来读取原数组，最终的排序结果也会由进程p0打印出来。

在该算法中，我们如果知道进程数目为2^m个，就应该能够求出m。因此我写了一个实现函数，求一个整数的以2为底的对数的算法。该算法的具体实现为：

   1:  int log_int(int root, int num){

2:

   3:      int i, j;

4:

   5:      i = 1;

   6:      j = root;

7:

   8:      while(j < num){

   9:          j *= root;

  10:          i++;

  11:      }

12:

  13:      if(j > num)

  14:          i--;

15:

  16:      return i;

  17:  }

该并行算法的主函数为：

   1:  void quick_sort_mpi(int *argv, char ***argc){

2:

   3:      int process_id;

   4:      int process_size;

5:

   6:      int *init_array;

   7:      int array_length;

8:

   9:      int log_num;

  10:      int k;

11:

  12:      mpi_start(argv, argc, &process_size, &process_id, MPI_COMM_WORLD);

13:

  14:      if(process_size % 2 != 0){

  15:          if(!process_id)

  16:              printf("the size of the process must is the multipe of 2");

17:

  18:          MPI_Abort(MPI_COMM_WORLD, PROCESS_SIZE_ERROR);

  19:      }

20:

  21:      log_num = log_int(2, process_size);

  22:      array_length = ARRAY_LENGTH;

23:

  24:      if(!process_id){

  25:          init_array = (int *)my_mpi_malloc(0, sizeof(int) * array_length);

  26:          array_builder(init_array, array_length);

  27:          array_int_print(array_length, init_array);

  28:      }

29:

  30:      //对数组进行快速排序

  31:      quick_sort_mpi_function(init_array, array_length, log_num, process_id, 0, MPI_COMM_WORLD);

32:

  33:      if(!process_id)

  34:          array_int_print(array_length, init_array);

35:

  36:      MPI_Finalize();

  37:  }

在程序中出现的子函数在这里就不一一介绍了，其中主要的函数在上一篇枚举排序的MPI算法中都有所介绍。主函数的核心就是quic_sort_mpi_fuction函数，

该函数真正实现了快速排序，其代码如下：

   1:  void quick_sort_mpi_function(

   2:          int *init_array,             //待排序数组

   3:          int array_length,             //待排序数组长度

   4:          int log_num,                 //进程数取2为底的对数

   5:          int process_id,             //当前活动进程ID

   6:          int part_process_id,         //对数组进行拆分的进程ID

   7:          MPI_Comm comm){

8:

   9:      int *local_array;

  10:      int local_array_length = 0;

11:

  12:      int send_array_length;

13:

  14:      int partion_position;

15:

  16:      //取得要接收数据的进程号的进程号

  17:      int receive_process_id;

  18:      int j;

19:

  20:      MPI_Status status;

21:

  22:      if(log_num == 0){

  23:          if(process_id == part_process_id && array_length > 1)

  24:                  quick_sort_function(init_array, 0, array_length-1);

25:

  26:          return;

  27:      }

28:

  29:      receive_process_id = part_process_id + pow_int(2, log_num - 1);

30:

  31:      //当活动进程为数组拆分进程时，按照快速排序方法对数组分成两部分

  32:      if(process_id == part_process_id){

  33:          partion_position = part_array_head(init_array, 0, array_length-1);

  34:          send_array_length = array_length - partion_position -1;

  35:          local_array_length = partion_position;

36:

  37:          MPI_Send((void *)&send_array_length, 1, MPI_INT,

  38:                  receive_process_id, LENGTH_MESSAGE, comm);

39:

  40:          if(send_array_length > 0)

  41:              MPI_Send((void *)(init_array + partion_position +1), send_array_length,

  42:                      MPI_INT, receive_process_id, DATA_MESSAGE, comm);

  43:      }

44:

  45:      //当活动进程为待接收数据的进程时，接收从拆分进程发送过来的数据

  46:      if(process_id == receive_process_id){

47:

  48:          MPI_Recv((void *)&local_array_length, 1, MPI_INT, part_process_id,

  49:                  LENGTH_MESSAGE, comm, &status);

50:

  51:          if(local_array_length >0)

  52:          {

  53:              local_array = (int *)my_mpi_malloc(process_id, sizeof(int) * local_array_length);

  54:              MPI_Recv((void *)local_array, local_array_length, MPI_INT, part_process_id,

  55:                      DATA_MESSAGE, comm, &status);

56:

  57:          }

  58:      }

59:

  60:      j = local_array_length;

  61:      MPI_Bcast(&j, 1, MPI_INT, part_process_id, comm);

  62:      if(j > 1){

  64:          quick_sort_mpi_function(init_array, local_array_length, log_num -1,

  65:                  process_id, part_process_id, comm);

  66:      }

67:

  68:      j = local_array_length;

  69:      MPI_Bcast(&j, 1, MPI_INT, receive_process_id, MPI_COMM_WORLD);

  70:      if(j > 1)

  71:          quick_sort_mpi_function(local_array, local_array_length, log_num-1,

  72:                  process_id, receive_process_id, comm);

73:

  74:      if(process_id == receive_process_id && local_array_length >0)

  75:          MPI_Send((void *)local_array, local_array_length, MPI_INT,

  76:                  part_process_id, DATA_MESSAGE_SORT, MPI_COMM_WORLD);

77:

  78:      if(process_id == part_process_id && send_array_length > 0)

  79:          MPI_Recv((void *)(init_array + partion_position +1), send_array_length,

  80:                  MPI_INT, receive_process_id, DATA_MESSAGE_SORT, MPI_COMM_WORLD, &status);

  81:  }

该算法基本继承了并行编程策略的分治所发思想：分解 --- 求解 --- 归并。

五、MPI函数的说明

在该算法中，用到了MPI两个重要的通信函数MPI_Send和MPI_Recv，发送和接受函数。这两个函数实现了两个进程间的通信。同时，这两个函数是阻塞通信函数，即：

进程在没有接受到或发送完数据的情况下，将阻塞。

这样我们就完成了快速排序算法并行化得描述和实现，在这两篇中，分别介绍了并行编程策略的两个策略：单程序多数据流策略和分治策略。下篇将介绍并行正则采样

排序算法的设计和实现。

本文链接

MPI并行编程系列一：枚举排序

2010-04-05T00:06:00Z

前言

貌似有一年多的时间没有在博客园上发过随笔了。原因有三：1、懒，这是最主要的原因。哎，人老了，心和手也都老了。， 2、时间紧，也许这个理由这叫做借口。拿没时间作为任何事情的借口都是站不住脚的，我一直是这么认为的。但当时的确是特殊情况：原本计划一年完成的项目因为特殊原因必须在两个半月内完成。曾记得那时候从早上到晚上没有任何节假日的工作时的痛苦和激情，也忘不了项目成功上线后的喜悦和成就感。孙中山先生解释什么为革命的时候，说过：要享文明之幸福，不得不经文明之痛苦，这痛苦就是革命。我深有感触，同样要享成功之喜悦，不得不经成功之痛苦，这痛苦就是奋斗。3、转行。说转行也不太合适。从事了近两年的Web系统的开发后，导师让我研究并行计算，学好MPI编程，固最近一直在MPI中游荡。说实话，我并不确定这篇文章发在博客园中是否合适，因为博客园是.net社区。但我在别的技术社区中实在是找不到博客园的感觉，所以还是发在博客园中吧。希望博客园中的并行程序设计高手给指点一二。

以后我会从易到难写MPI程序设计的一系列的例子，开篇算法为枚举排序并行算法。

编程环境如下：操作系统：Ubuntu，编程语言 c，并行库 MPI，编译器 gcc

一、枚举排序算法说明：

枚举排序（Enumeration Sort）是一种最为简单的排序算法，通常也被叫做秩排序（Rank Sort）。

该算法的基本思想是：对每一个要排序的元素统计小于它的所有元素的个数，从而得到该元素在整个序列中的位置。其时间复杂度为o(n^2)。其伪代码为：

输入为：a[1], a[2] , ... , a[n]

输出为：b[1], b[2] , ..., b[n]

for i =1 to n do

1)k =1

2)for j = 1 to n do

if a[i] > a[j] then

k= k + 1

endif

endfor

3)b[k] = a[i]

endfor

算法思想很简单，现将其主要代码总结如下：

1、数组自动生成，随机生成长度为n的数组：

   1:  void array_builder(int *a, int n)

   2:  {

   3:      int i;

4:

   5:      srand((int)time(0));

6:

   7:      for(i = 0; i < n; i++)

   8:          a[i] = (int)rand() % 100;

9:

  10:      return;

  11:  }

2、取得每个元素在数组中的秩，即统计每个元素按小于它的其他所有元素的个数：

   1:  int *get_array_elem_position(int *init_array, int array_length, int start, int size){

2:

   3:      int i,j,k;

   4:      int *position;

5:

   6:      position = (int *)my_malloc(sizeof(int) * size);

   7:      for(i = start; i < start+size; i++){

   8:          k = 0;

   9:          for(j = 0; j < array_length; j++){

  10:              if(init_array[i] < init_array[j])

  11:                  k++;

  12:              if((init_array[i] == init_array[j]) && i >j)

  13:                  k++;

  14:          }

15:

  16:          position[i-start] = k;

  17:      }

18:

  19:      return position;

  20:  }

其中my_malloc函数的作用为动态分配大小为size的空间，如分配失败，则终止程序：

   1:  void *my_malloc(int malloc_size){

   2:      void *buffer;

3:

   4:      if((buffer = (void *)malloc((size_t)malloc_size)) == NULL){

   5:          printf("malloc failure");

   6:          exit(EXIT_FAILURE);

   7:      }

8:

   9:      return buffer;

  10:  }

3、 算法主函数：

   1:  void serial(){

2:

   3:      int i;

   4:      int array_length = ARRAY_LENGTH;

5:

   6:      int *init_array;

   7:      int *sort_array;

   8:      int *position;

9:

  10:  //    array_length = get_array_length(4);

11:

  12:      sort_array = (int *)my_malloc(sizeof(int) * array_length);

  13:      init_array = (int *)my_malloc(sizeof(int) * array_length);

14:

  15:      array_builder(init_array, array_length);

16:

  17:      position = get_array_elem_position(init_array, array_length, 0, array_length);

18:

  19:      for(i = 0; i < array_length; i++)

  20:          sort_array[position[i]] = init_array[i];

21:

  22:      printf("串行实行结果:\n");

  23:      init_sort_array_print(init_array, sort_array, array_length);

  24:  }

其中的数组打印函数就不列出来了。

二、枚举排序并行化分析

    该算法的并行化算法比较的简单，一般的并行化无非就为数据并行和功能并行。显然该算法适合数据并行算法。即：如果我们有n个处理器，则我们将数据平均

分为n份，让每个处理器来处理其中一份数据。该算法的描述为：

输入：a[1], ... , a[n]

输入：b[1], ... , b[n]

1)进程p0将数组广播到所有进程中

2)每个进程对其相应的数组分块计算其中每个元素的秩

3）p0收集各进程的中相应元素的秩，并给出最终的排序结果。

算法分析：假设我们在排序中用了m个处理器，则算法的复杂度为o（n^2/m),通信复杂度为o（mn）。

三、并行算法实现

并行程序设计中一般分为四步：划分，通信，聚集和映射。

1、划分是将一个大任务划分为一系列小任务的过程。在本例中，计算每个元素的秩是互不相关的，因此我们可以将该任务划分为n个小任务，每个任务的作用就是

计算其中一个元素的秩。

2、通信就是要确定个进程的通信模式。在本例中，进程间的通信主要是进程p0将原始数组广播到各个进程中，同时收集各个进程的计算结果。

3、聚集。如果有m个进程，我们可以将这n个小任务聚集为m个原始任务，每个进程执行其中的一个原始任务。

4、映射。映射是将原始任务映射到各处理器的过程。这里由于没有使用集群，固映射为系统自动。

该算法的一个重要问题就是如何对数据分块，即上面第三步中，如何经n个小任务聚集成m个原始任务。我们的数据分块策略为：按块数据分解，这就意味着我们将

数组分为m个连续的快，每个块的大小基本相等。在对数组进行分解的过程中，我们必须要确定两个问题：1、给出进程，能够算出该进程所负责的数据。2、给出数据，

能够计算出该数据被那个一进程所负责。我们将这两个问题定义在头文件中：

   1:  //n为数组长度，p为进程数，id为进城id

   2:  #define BLOCK_LOW(id, p, n) ((id)*(n)/(p))

   3:  #define BLOCK_HIGH(id, p, n) (BLOCK_LOW((id)+1, p, n)-1)

   4:  #define BLOCK_SIZE(id, p, n) (BLOCK_HIGH(id, p, n) - BLOCK_LOW(id, p, n) + 1)

   5:  #define BLOCK_OWNER(j, p, n) (((P) * ((j) +1)-1)/(n))

并行程序为：

   1:  #include <stdlib.h>

   2:  #include <stdio.h>

3:

   4:  #include "mpi.h"

   5:  #include "my_mpi.h"

   6:  #include "common.h"

   7:  #include "sort/enum_sort.h"

8:

   9:  void  mpi_sort(

  10:          int *argc,

  11:          char ***argv){

12:

  13:      int process_id;

  14:      int process_size;

15:

  16:      int *count;

  17:      int *resp;

18:

  19:      int array_low;

  20:      int array_size;

21:

  22:      int *local_position;

  23:      int *position;

24:

  25:      int *sort_array;

  26:      int *init_array;

  27:      int array_length = ARRAY_LENGTH;

28:

  29:      int i;

30:

  31:      my_mpi_struct mpi_struct;

32:

  33:      mpi_start(argc, argv, &process_size, &process_id, MPI_COMM_WORLD);

34:

  35:      if(!process_id){

  36:          position = (int *)my_mpi_malloc(0, sizeof(int) * array_length);

  37:          sort_array = (int *)my_mpi_malloc(0, sizeof(int) * array_length);

  38:      }

39:

  40:      init_array = (int *) my_mpi_malloc(process_id, sizeof(int) * array_length);

  41:      if(!process_id)

  42:          array_builder(init_array, array_length);

43:

  44:      MPI_Bcast(init_array, array_length, MPI_INT, 0, MPI_COMM_WORLD);

45:

  46:      array_low = BLOCK_LOW(process_id, process_size, array_length);

  47:      array_size = BLOCK_SIZE(process_id, process_size, array_length);

48:

  49:      get_my_mpi_struct(&mpi_struct, process_id, process_size, array_length);

  50:      get_resp_count_array(&resp, &count, mpi_struct);

51:

  52:      local_position = get_array_elem_position(init_array, array_length,

  53:              array_low, array_size);

54:

  55:      MPI_Gatherv(local_position, array_size, MPI_INT, position, count, resp,

  56:             MPI_INT, 0, MPI_COMM_WORLD);

57:

  58:      if(!process_id){

  59:          for(i = 0; i< array_length; i++)

  60:              sort_array[position[i]] = init_array[i];

61:

  62:          printf("the result of mpi:\n");

  63:          init_sort_array_print(init_array, sort_array, array_length);

64:

  65:          free(sort_array);

  66:          free(position);

  67:      }

68:

  69:      free(count);

  70:      free(resp);

  71:      free(local_position);

  72:      free(init_array);

73:

  74:      MPI_Finalize();

  75:  }

76:

  其中mpi_start函数就是将编写MPI程序时三个必须函数MPI_Init,MPI_Comm_rank和MPI_Comm_size给写在一个函数中了，方便调用。

函数get_resp_count_array的作用是计算MPI收集函数所需要的偏移和组大小数组，其代码如下：

   1:  void get_resp_count_array(

   2:          int **resp,                 //the resp array

   3:          int **count,                 //the count array

   4:          my_mpi_struct mpi_struct){ //my mpi struct

5:

   6:      int i;

7:

   8:      int process_id = mpi_struct -> process_id;

   9:      int process_size = mpi_struct -> process_size;

  10:      int number_count = mpi_struct -> number_count;

11:

  12:      *resp = (int *)my_mpi_malloc(process_id, sizeof(int) * process_size);

  13:      *count = (int *)my_mpi_malloc(process_id, sizeof(int) * process_size);

14:

  15:      (*resp)[0] = 0;

  16:      (*count)[0] = BLOCK_SIZE(0, process_size, number_count);

17:

  18:      for(i = 1; i < process_size; i++){

  19:          (*resp)[i] = (*resp)[i-1] + (*count)[i-1];

  20:          (*count)[i] = BLOCK_SIZE(i, process_size, number_count);

  21:      }

  22:  }

四、MPI主要函数说明

    在本例中一共用到了两个主要的MPI函数：MPI_Bcast和MPI_Gatherv。即一个广播函数和一个收集函数。

MPI_Bcast是一个组通信操作，用来完成一个进程向通信域中所有的进程广播消息

MPI_Gatherv是完成收集的组通信函数。跟进程从进程i收集count[i]个元素，并将手机的i个元素放在接收缓冲区的resp[i]个位置开始的地方。

五、后记

这个MPI程序中一个比较简单的例子，作为我下MPI并行程序的一个开端。还请各位高手积极拍砖。

下篇将对快速排序的并行算法进行简单的介绍和实现。

本文链接

c#基础（一）之内存管理

2008-12-22T14:19:00Z

C#基础之内存管理，我觉得基础很重要......

用Windows Live Writer 首发Blog

2008-12-17T09:41:00Z

首篇Windos Live Writer 博客，Windows live Writer 配置及其他

一个被我长期忽略的一个问题：验证控件与Button的OnClientClick事件

2008-12-15T11:57:00Z

一个被我长期忽略的一个问题：验证控件与Button的OnClientClick事件

远程数据自动导入的设计与实现

2008-12-10T02:33:00Z

远程数据自动导入的设计与实现