Question

所以我正在使用Cilk在C语言中实现并行快速排序，我遇到了一个奇怪的问题。我的代码的相关部分，供参考（并提前道歉）：

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>
#include <cilk/cilk.h>
#include <cilk/cilk_api.h>

void prefixSum(int* input,int* output, int length){
   if(length == 1){
      output[0] = input[0];
      return;
   }
   int i;
   int nPairs = (int) floor(((double)length)/2);
   int pairs = (int) ceil(((double)length)/2);
   int z[pairs];
   int w[pairs];
   cilk_for(i=0;i<nPairs;i++){
      z[i] = input[2*i]+input[2*i+1];
   }

   if(pairs>nPairs){
      z[pairs-1] = input[length-1];
   }
   prefixSum(z,w,pairs);
   cilk_for(i=0;i<length;i++){
      if(i==0){
         output[i] = input[i];
      } 
      else if((i-1)%2==0){
         output[i] = w[(i-1)/2];
      }
      else{
         output[i] = w[(i-2)/2] + input[i];
      }
   }
   return;
}

void prefixScan(int* input, int length){
   int i;
   for(i=length-1;i>0;i--){
      input[i] = input[i-1];
   }
   input[0] = 0;
}

void paraSort(double* array, int length){
   if(length==1){
      return;
   }
   int pivot = rand() % length;
   int lowSet[length];
   int highSet[length];
   int equalSet[length];
   int i;
   cilk_for(i=0;i<length;i++){
      if(array[i]==array[pivot]){
         lowSet[i] = 0;
         highSet[i] = 0;
         equalSet[i] = 1;
      } else if(array[i]<array[pivot]){
         lowSet[i] = 1;
         highSet[i] = 0;
         equalSet[i] = 0;
      } else {
         lowSet[i] = 0;
         highSet[i] = 1;
         equalSet[i] = 0;
      }
   }
   int lowIndex[length];
   int highIndex[length];
   int equalIndex[length];
   prefixSum(lowSet,lowIndex,length);
   int numLow = lowIndex[length-1];
   prefixScan(lowIndex,length);

   prefixSum(highSet,highIndex,length);
   int numHigh = highIndex[length-1];
   prefixScan(highIndex,length);

   prefixSum(equalSet,equalIndex,length);
   int numEqual = equalIndex[length-1];
   prefixScan(equalIndex,length);

   double lowList[imin(numLow,1)];
   double highList[imin(numHigh,1)];
   double equalList[numEqual];

   cilk_for(i=0;i<length;i++){
      if(lowSet[i]==1){
         lowList[lowIndex[i]] = array[i];
      } else if(highSet[i]==1){ 
         highList[highIndex[i]] = array[i];
      } else if(equalSet[i]==1){
         equalList[equalIndex[i]] = array[i];
      }
   }

   if(numLow>0 && numHigh>0){
      cilk_spawn paraSort(lowList,numLow);
      paraSort(highList,numHigh);
      cilk_sync;
   } else if(numLow==0 && numHigh>0){
      paraSort(highList,numHigh);
   } else if(numLow>0 && numHigh==0){
      paraSort(lowList,numLow);
   }
   cilk_for(i=0;i<length;i++){
      if(i<numLow){
         array[i] = lowList[i];
      } else if(i<numLow+numEqual){
         array[i] = equalList[i-numLow];
      } else {
         array[i] = highList[i-(numLow+numEqual)];
      }
   }
   return;
}

现在，当我在50个元素的测试用例上运行时（为了便于调试，顺序进行调试），我在递归中得到一层深度，然后遇到一个分段错误，这个错误似乎是由一个以外的错误引起的行equalList[equalIndex[i]] = array[i];中的边界索引。

在分配equalIndex之后立即进一步检查，其中的值完全是任意的。这是可以预料的;我还没有分配任何东西。在元素列表上调用prefixSum，除了倒数第二个元素（即1）之外，它都是零。（这是一个标记元素等于pivot的位图。）它将前缀sum操作的结果放入equalIndex中，我将其作为指向数组的指针传入，以便结果在调用之外保持不变。

执行此操作后，调试printf命令显示，对于最后两个元素，equalIndex现在全部为零，这两个元素都是一个。这是预期的前缀和结果;到现在为止还挺好。 prefixScan是一个简单的帮助函数，可以帮助我处理从零开始的索引;它将给定数组中的所有元素向右移动一个空格，用零填充第一个元素。在传递equalIndex之后，调试语句显示equalIndex全为零，除了最后一个元素，即1。

问题出现的地方紧随其后，在cilk_for循环中将每个元素复制到正确的数组中。在这个循环的主体中，printf语句现在显示的值与之前的那些不匹配 - 有些正确为零，有些是我在初始化此数组之前看到的那种非常大的正整数或负整数with prefixSum。一旦它遇到其中一个极端值并尝试将其用作数组索引，程序就会崩溃。

我最好的猜测是，equIndex中的值不能正确分配（因此奇怪的行为好像我没有初始化数组），但我遇到了很多麻烦确切地知道出了什么问题以及在哪里。

Answer 1

你自相矛盾。有一点你说

除了最后一个元素（
）之外，
equalIndex全为零

但后来你推测

以某种方式没有正确分配equalIndex中的值

。你无法双管齐下。

我不知道Cilk，但从C推断，我倾向于认为你在诋毁自己的数据。特别考虑这段代码，这似乎是麻烦的地方：

double lowList[imin(numLow,1)];
double highList[imin(numHigh,1)];
double equalList[numEqual];

cilk_for(i=0;i<length;i++){
    if(lowSet[i]==1){
       lowList[lowIndex[i]] = array[i];
    } else if(highSet[i]==1){ 
       highList[highIndex[i]] = array[i];
    } else if(equalSet[i]==1){
       equalList[equalIndex[i]] = array[i];
    }
}

数组lowList和highList有多长？在回答之前研究他们的声明。现在，如果您尝试将值分配给超出其边界的那些数组的元素，您认为可能会发生什么？

看似随意改变的数组元素[parallel quicksort / prefix sum]

1 个答案: