Benchmark Probleme für die Prüfung Concurrency

StackOverflow https://stackoverflow.com/questions/327379

Andere Tipps

Sicherlich sollten Sie Hardware und Compiler testen anstatt eine Sprache für die Parallelität Leistung?

Ich würde aus der Sicht des in einer Sprache zu suchen, wie einfach und produktiv es in Bezug auf der Gleichzeitigkeit ist und wie viel es dämmt 'die Programmierer von Sperren, Fehler zu machen.

EDIT: aus den Erfahrungen der Vergangenheit als Forscher parallele Algorithmen entwerfen, ich glaube, Sie in den meisten Fällen die gleichzeitige Leistung weitgehend davon abhängen, finden, wie ein Algorithmus parallelisiert wird und wie es zielt auf die zugrunde liegende Hardware.

Auch Benchmarks sind notorisch ungleich; Dies gilt umso mehr in einer parallelen Umgebung. Zum Beispiel kann eine Benchmark, dass ‚Knirschen‘ sehr große Matrizen würden zu einem Vektorpipeline-Prozessor geeignet sein, wohingegen eine parallele Sortierung besser, mehr Allzweck mehradrige CPUs geeignet sein könnte.

Dies könnte nützlich sein:

Parallel Benchmarks

NAS Parallel Benchmarks

Nun, es gibt ein paar Klassiker, aber verschiedene Tests betonen unterschiedliche Funktionen. Einige verteilen Systeme robuster sein, müssen effizientes Message-Passing, etc. Höheren Nachrichten-Overhead kann Skalierbarkeit verletzt, da es der normale Weg, um mehr Maschinen, Scale-up ist eine größere Anzahl von kleinen Nachrichten zu senden. Einige klassische Probleme können Sie versuchen, sind ein verteiltes Sieb des Eratosthenes oder eine schlecht umgesetzt Fibonacci-Sequenz Rechner (das heißt die achte Nummer in der Reihe zu berechnen, Spin einer Maschine für den 7., und eine andere für den 6.). So ziemlich jeder Teil-und-Herrsche-Algorithmus kann gleichzeitig durchgeführt werden. Sie könnten auch eine gleichzeitige Umsetzung von Conways Spiel des Lebens oder Wärmeübertragung tun. Beachten Sie, dass alle diese Algorithmen unterschiedliche Schwerpunkte haben und so werden Sie wahrscheinlich ein verteiltes System nicht in allen von ihnen tun das Beste bekommen.

Ich würde sagen, die am einfachsten zu implementieren schnell die schlecht umgesetzt Fibonacci-Rechner ist, wenn es zu viel Wert legt Themen auf die Schaffung und zu wenig auf die Kommunikation zwischen den Threads.

  

Sicherlich sollten Sie testen Hardware   und Compiler statt einer Sprache   für Concurrency Leistung?

Nein, Hardware und Compiler sind irrelevant für meine Testzwecke. Ich suche nur für ein paar guten Probleme, die testen, wie gut Code, in einer Sprache geschrieben, gegen Code aus einer anderen Sprache konkurrieren. Ich teste wirklich die Konstrukte in den spezifischen Sprachen verfügbar gleichzeitige Programmierung zu tun. Und eines der Kriterien ist die Leistung (gemessen in Zeit).

Einige der anderen Prüfkriterien ich suche, sind:

  • wie einfach ist es richtig, Code zu schreiben; denn wie wir alle wissen, parallele Programmierung ist härter als Single-Threaded-Programme zu schreiben
  • , was die Technik verwendet, um die gleichzeitige Programmierung: ereignisgesteuert, Schauspieler basiert, Nachrichtenanalyse, ...
  • , wie viel Code muss sich vom Programmierer geschrieben werden und wie viel wird automatisch für ihn getan: dies kann auch mit den gegebenen Benchmark Probleme
    • getestet werden
  • Was ist der Grad der Abstraktion und wie viel Aufwand beteiligt ist, wenn wieder in Maschinencode übersetzt

Also eigentlich, ich bin nicht auf der Suche für die Leistung als die nur und besten Parameter (die in der Tat mich an die Hardware gesendet werden, und die Compiler anstelle der Sprache selbst), suche ich eigentlich von einem Programmierer Sicht zu überprüfen, welche Sprache für welche Art von Problemen am besten geeignet ist, was es Schwächen und Stärken sind und so weiter ...

Bare daran, dass dies nur ein kleines Projekt ist und die Tests sind daher auch klein gehalten werden. (Strenge Tests von allem ist daher nicht möglich)

Ich habe beschlossen, die Mandelbrot-Menge (die

Im Folgenden finden Sie den Code finden kann ich zusammen die Multi zu testen gehackt Gewinde Leistung von pthreads. Ich habe es nicht gereinigt und keine Optimierungen vorgenommen wurden; so dass der Code ist ein bisschen raw .

Sie den Code des berechneten mandel eingestellt als Bitmap zu speichern ist nicht mein, Sie es hier 

#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);
}

gute Ergebnisse lassen sich mit dem Programm mit den folgenden Argumenten erhalten:

  

mandel 5120 3840 256 3

auf diese Weise Sie ein Bild erhalten, das 5 * 1024 breit ist; 5 * 768 hoch mit 256 Farben (leider nur 1 erhalten wird oder 2) und 3 Fäden (1 Haupt-Thread, die keine Arbeit macht, außer die Worker-Threads erstellen und 2 Worker-Threads)

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top