基准问题进行测试concurency

https://stackoverflow.com/questions/327379

11-07-2019
|

题

对于其中一个项目，我现在正在做的，我需要看表演(除其他事项)的不同并启用了编程语言。

在那一刻，我找到进行比较 stackless蟒蛇和 C++测, ，因此重点是这两种语言，但其他语言可能会被测试以后。当然比较，必须作为代表可能跟上情况变化，并尽可能准确，因此我首先想到的是开始寻找一些标准 并行/多线程的基准问题, 可惜我没找到任何体面的或标准、检测/问题/基准。

所以我的问题如下： 你有一个建议，为一个很好的，很容易或快速的问题的性能测试的编程语言 (并且让它的强势和弱点的过程)?

解决方案

由于基准游戏移动到四核机2008年9月，在不同的编程语言很多程序已经重新编写，利用四核 - 的例如，前10个曼德尔布罗活动。

其他提示

当然，你应该测试硬件和编译器，而不是为了并发性能语言？

我会在看但从它是并发的方面，又有多少是“隔离”作出锁定的错误程序员如何方便，生产点的语言。

编辑：从过去的经验，研究设计并行算法，我想你会在同时执行将在很大程度上取决于算法是如何并行化多数情况下发现，以及如何针对底层硬件。

此外，基准是出了名不等;这更是让在并行环境。例如，一个基准，“仰卧起坐”非常大矩阵将是适合于矢量流水线处理器，而并行排序可能更适合于多个通用多核心处理器。

这些可能是有用的：

并行基准

NAS并行基准测试

好了，有几个经典的，但不同的测试，强调不同的特点。一些分布式系统可能会更强劲，具有更高效的信息传递等更高的消息开销可以伤害的可扩展性，因为它扩展到更多的机器以正常的方式是发送小消息的数量较多。一些经典的问题，你可以尝试是埃拉托色尼的分布式筛或执行不力的斐波那契序列计算器（即计算出该系列的第6第8号，第7届机器的旋转，另一个）。几乎所有的分而治之算法，可以同时进行。你也可以做生活或传热的康威的游戏的同时实现。请注意，所有的这些算法有不同的侧重点，因此你可能不会得到一个分布式系统在做所有他们的最好的。

我想说快速实现一个最简单的是执行不力的斐波那契数的计算器，但它把太多的重点放在那些线程间的通信创建线程太少。

当然，你应该试验的硬件和编译器而不是语言并发性能吗？

不，硬件和编译器是无关紧要我测试的目的。我只是在寻找一些很好的问题，可以测试的代码,写一种语言，能够竞争对代码从另一种语言。我真的测试的结构可以在特定语言的要做的并行程序。和一个标准是性能(以时间)。

其他一些测试标准我要找的是：

如何 容易的 它是编写正确的代码；因为我们都知道并行的程是很难的后编写的单一程程序
什么是技术用于并行程序：事件驱动、演员基于信息进行解析，...
多少代码必须是书面通过的程序员自己多少，是自动完成的，他说：这也可以进行测试的定基准的问题
什么是抽象的级别和多少开销是涉及时翻译回机的代码

因此，实际上，我不是在寻找的性能的只有和最佳参数(这将确实把我送到硬件和编译器而不是语言本身)，实际上，我从程序的观点来检查什么样的语言是最适合什么样的问题，它的弱点和长处是等等...

裸记住，这只是一个小项目，并测试因此应保持较小。(严格的测试的一切都是因此不可行的)

我已经决定使用 Mandelbrot集 (的逃生的时间算法为了更加精确)基准的不同的语言。
它符合我很及原来的算法可以很容易地实现和创造多螺纹变从这并不是说多的工作。

下面是代码，我目前有。它仍然是一个单一的螺纹的变型，但是我会更新它尽快，我很满意的结果。

#include <cstdlib> //for atoi
#include <iostream>
#include <iomanip> //for setw and setfill
#include <vector>


int DoThread(const double x, const double y, int maxiter) {
    double curX,curY,xSquare,ySquare;
    int i;

    curX = x + x*x - y*y;
    curY = y + x*y + x*y;
    ySquare = curY*curY;
    xSquare = curX*curX;

    for (i=0; i<maxiter && ySquare + xSquare < 4;i++) {
      ySquare = curY*curY;
      xSquare = curX*curX;
      curY = y + curX*curY + curX*curY;
      curX = x - ySquare + xSquare;
    }
    return i;
}

void SingleThreaded(int horizPixels, int vertPixels, int maxiter, std::vector<std::vector<int> >&  result) {
    for(int x = horizPixels; x > 0; x--) {
        for(int y = vertPixels; y > 0; y--) {
            //3.0 -> so we always have -1.5 -> 1.5 as the window; (x - (horizPixels / 2) will go from -horizPixels/2 to +horizPixels/2
            result[x-1][y-1] = DoThread((3.0 / horizPixels) * (x - (horizPixels / 2)),(3.0 / vertPixels) * (y - (vertPixels / 2)),maxiter);
        }
    }
}

int main(int argc, char* argv[]) {
    //first arg = length along horizontal axis
    int horizPixels = atoi(argv[1]);

    //second arg = length along vertical axis
    int vertPixels = atoi(argv[2]);

    //third arg = iterations
    int maxiter = atoi(argv[3]);

    //fourth arg = threads
    int threadCount = atoi(argv[4]);

    std::vector<std::vector<int> > result(horizPixels, std::vector<int>(vertPixels,0)); //create and init 2-dimensional vector
    SingleThreaded(horizPixels, vertPixels, maxiter, result);

    //TODO: remove these lines
    for(int y = 0; y < vertPixels; y++) {
      for(int x = 0; x < horizPixels; x++) {
            std::cout << std::setw(2) << std::setfill('0') << std::hex << result[x][y] << " ";
        }
        std::cout << std::endl;
    }
}

我测试过它与海湾合作委员会在Linux，但我确信它的工作根据其他编译器/操作系统。得到它的工作，你必须进入一些命令行参数如下所示：

mandelbrot106 500 255 1

第一个参数的宽度(x轴)
第二个论点是高度(y-轴)
第三个参数的数量最大的迭代(数的颜色)
最后一项是多线程的(但这一个目前没有使用)

在我的分辨率，上述的例子给了我一个很好的ASCII-艺术表示Mandelbrot集。但是尝试它对自己有不同的参数(第一次将是最重要的一项，因为这将宽度)

下面你可以找到代码我砍死在一起测试 多螺纹 性能的测.我还没清理了，没有优化已经作出；这样的代码是一位原.

代码保存的计算mandelbrot集，作为一位不是我的，你可以找到它在这里，

#include <cstdlib> //for atoi
#include <iostream>
#include <iomanip> //for setw and setfill
#include <vector>

#include "bitmap_Image.h" //for saving the mandelbrot as a bmp

#include <pthread.h>

pthread_mutex_t mutexCounter;
int sharedCounter(0);
int percent(0);

int horizPixels(0);
int vertPixels(0);
int maxiter(0);

//doesn't need to be locked
std::vector<std::vector<int> > result; //create 2 dimensional vector

void *DoThread(void *null) {
    double curX,curY,xSquare,ySquare,x,y;
    int i, intx, inty, counter;
    counter = 0;

    do {
        counter++;
        pthread_mutex_lock (&mutexCounter); //lock
            intx = int((sharedCounter / vertPixels) + 0.5);
            inty = sharedCounter % vertPixels;
            sharedCounter++;
        pthread_mutex_unlock (&mutexCounter); //unlock

        //exit thread when finished
        if (intx >= horizPixels) {
            std::cout << "exited thread - I did " << counter << " calculations" << std::endl;
            pthread_exit((void*) 0);
        }

        //set x and y to the correct value now -> in the range like singlethread
        x = (3.0 / horizPixels) * (intx - (horizPixels / 1.5));
        y = (3.0 / vertPixels) * (inty - (vertPixels / 2));

        curX = x + x*x - y*y;
        curY = y + x*y + x*y;
        ySquare = curY*curY;
        xSquare = curX*curX;

        for (i=0; i<maxiter && ySquare + xSquare < 4;i++){
          ySquare = curY*curY;
          xSquare = curX*curX;
          curY = y + curX*curY + curX*curY;
          curX = x - ySquare + xSquare;
        }
        result[intx][inty] = i;
     } while (true);
}

int DoSingleThread(const double x, const double y) {
    double curX,curY,xSquare,ySquare;
    int i;

    curX = x + x*x - y*y;
    curY = y + x*y + x*y;
    ySquare = curY*curY;
    xSquare = curX*curX;

    for (i=0; i<maxiter && ySquare + xSquare < 4;i++){
      ySquare = curY*curY;
      xSquare = curX*curX;
      curY = y + curX*curY + curX*curY;
      curX = x - ySquare + xSquare;
    }
    return i;

}

void SingleThreaded(std::vector<std::vector<int> >&  result) {
    for(int x = horizPixels - 1; x != -1; x--) {
        for(int y = vertPixels - 1; y != -1; y--) {
            //3.0 -> so we always have -1.5 -> 1.5 as the window; (x - (horizPixels / 2) will go from -horizPixels/2 to +horizPixels/2
            result[x][y] = DoSingleThread((3.0 / horizPixels) * (x - (horizPixels / 1.5)),(3.0 / vertPixels) * (y - (vertPixels / 2)));
        }
    }
}

void MultiThreaded(int threadCount, std::vector<std::vector<int> >&  result) {
    /* Initialize and set thread detached attribute */
    pthread_t thread[threadCount];
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);


    for (int i = 0; i < threadCount - 1; i++) {
        pthread_create(&thread[i], &attr, DoThread, NULL);
    }
    std::cout << "all threads created" << std::endl;

    for(int i = 0; i < threadCount - 1; i++) {
        pthread_join(thread[i], NULL);
    }
    std::cout << "all threads joined" << std::endl;
}

int main(int argc, char* argv[]) {
    //first arg = length along horizontal axis
    horizPixels = atoi(argv[1]);

    //second arg = length along vertical axis
    vertPixels = atoi(argv[2]);

    //third arg = iterations
    maxiter = atoi(argv[3]);

    //fourth arg = threads
    int threadCount = atoi(argv[4]);

    result = std::vector<std::vector<int> >(horizPixels, std::vector<int>(vertPixels,21)); // init 2-dimensional vector
    if (threadCount <= 1) {
        SingleThreaded(result);
    } else {
        MultiThreaded(threadCount, result);
    }


    //TODO: remove these lines
    bitmapImage image(horizPixels, vertPixels);
    for(int y = 0; y < vertPixels; y++) {
      for(int x = 0; x < horizPixels; x++) {
            image.setPixelRGB(x,y,16777216*result[x][y]/maxiter % 256, 65536*result[x][y]/maxiter % 256, 256*result[x][y]/maxiter % 256);
            //std::cout << std::setw(2) << std::setfill('0') << std::hex << result[x][y] << " ";
        }
        std::cout << std::endl;
    }

    image.saveToBitmapFile("~/Desktop/test.bmp",32);
}

良好的结果，可以得到使用的程序与以下参数：

mandelbrot5120 3840 256 3

那样你会得到一个图像就是5*1024宽；5*768高256色(唉，你将只能得到1或2)和3螺纹(1主线，没有做任何工作，除非建立的工作线程，以及2的工作人员的线)

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow