Question

我一直在使用Mac OS gcc 4.2.1和Eclipse编写一个程序，使用简单的合并排序对数字进行排序。我已经广泛测试了这种类型，我知道它有效，我想，也许有些天真，因为算法划分列表的方式，我可以简单地让一个线程排序一半，主线程排序一半，然后它需要一半的时间，但不幸的是，它似乎没有起作用。

这是主要代码：

    float x = clock(); //timing
    int half = (int)size/2; // size is the length of the list

    status = pthread_create(thready,NULL,voidSort,(void *)datay); //start the thread sorting

    sortStep(testArray,tempList,half,0,half); //sort using the main thread 

    int join = pthread_join(*thready,&someptr); //wait for the thread to finish

    mergeStep(testArray,tempList,0,half,half-1); //merge the two sublists

    if (status != 0) { std::cout << "Could not create thread.\nError: " << status << "\n";  }

    if (join != 0) { std::cout << "Could not create thread.\nError: " << status << "\n";  }

    float y = clock() - x; //timing

sortStep是主要的排序函数，mergeStep用于合并一个数组中的两个子列表（它使用占位符数组来切换数字），voidSort是一个函数我用来将包含sortStep的所有参数的结构传递给线程。我觉得主线程可能要等到新线程完成，但我不知道如何克服这个问题。对于任何和所有的帮助，我都非常，无法想象，感谢先进！

编辑：这是合并步骤

void mergeStep (int *array,int *tempList,int start, int lengthOne, int lengthTwo) //the merge step of a merge sort
{
int i = start;
int j = i+lengthOne;
int k = 0; // index for the entire templist

while (k < lengthOne+lengthTwo) // a C++ while loop
{
    if (i - start == lengthOne)
    { //list one exhausted
        for (int n = 0; n+j < lengthTwo+lengthOne+start;n++ ) //add the rest
        {
            tempList[k++] = array[j+n];
        }
        break;
    }

    if (j-(lengthOne+lengthTwo)-start == 0)
    {//list two exhausted
        for (int n = i; n < start+lengthOne;n++ ) //add the rest
        {
            tempList[k++] = array[n];
        }
        break;
    }

    if (array[i] > array[j]) // figure out which variable should go first
    {
        tempList[k] = array[j++];
    }

    else
    {
        tempList[k] = array[i++];
    }
    k++;
}

for (int s = 0; s < lengthOne+lengthTwo;s++) // add the templist into the original
{
    array[start+s] = tempList[s];
}
}

- 将会

Answer 1

创建线程的开销非常大，所以除非你有大量（待确定的）数据，否则最好在主线程中对它进行排序。

mergeStep也会计入无法码垛的代码部分，请记住Amdahl's law。

如果你没有粗略的步骤作为sortStep的最后一部分，当你得到低于8-16元素时，你的大部分表现将会在函数调用中上升。粗化步骤必须通过更简单的排序，插入排序或排序网络来完成。

除非你有足够大的分类，否则在测量不确定性时可能会淹没实际时间。

从p_thread c ++中可以忽略不计的性能提升

1 个答案: