Ich habe den folgenden Java-Code mit mehreren großen Arrays, deren Größe sich nie ändert. Es läuft in 1100 ms auf meinem Computer.

Ich habe den gleichen Code in C ++ implementiert und verwendet std::vector.

Die Zeit der C ++ - Implementierung, in der genau derselbe Code ausgeführt wird, beträgt auf meinem Computer 8800 ms. Was habe ich falsch gemacht, damit es so langsam läuft?

Grundsätzlich macht der Code Folgendes:

for (int i = 0; i < numberOfCells; ++i) {
        h[i] =  h[i] + 1;
        floodedCells[i] =  !floodedCells[i];
        floodedCellsTimeInterval[i] =  !floodedCellsTimeInterval[i];
        qInflow[i] =  qInflow[i] + 1;
}

Es durchläuft verschiedene Arrays mit einer Größe von ca. 20000.

Sie finden beide Implementierungen unter den folgenden Links:

• Java: https://ideone.com/R8KqjT
• C ++: https://ideone.com/Lu7RpE

(Auf ideone konnte ich die Schleife aufgrund der zeitlichen Begrenzung nur 400-mal statt 2000-mal ausführen. Aber auch hier gibt es einen dreifachen Unterschied.)

Hier ist die C ++ - Version mit den in einer Struktur gesammelten Daten pro Knoten und einem einzelnen verwendeten Vektor dieser Struktur:

#include <vector>
#include <cmath>
#include <iostream>



class FloodIsolation {
public:
  FloodIsolation() :
      numberOfCells(20000),
      data(numberOfCells)
  {
  }
  ~FloodIsolation(){
  }

  void isUpdateNeeded() {
    for (int i = 0; i < numberOfCells; ++i) {
       data[i].h = data[i].h + 1;
       data[i].floodedCells = !data[i].floodedCells;
       data[i].floodedCellsTimeInterval = !data[i].floodedCellsTimeInterval;
       data[i].qInflow = data[i].qInflow + 1;
       data[i].qStartTime = data[i].qStartTime + 1;
       data[i].qEndTime = data[i].qEndTime + 1;
       data[i].lowerFloorCells = data[i].lowerFloorCells + 1;
       data[i].cellLocationX = data[i].cellLocationX + 1;
       data[i].cellLocationY = data[i].cellLocationY + 1;
       data[i].cellLocationZ = data[i].cellLocationZ + 1;
       data[i].levelOfCell = data[i].levelOfCell + 1;
       data[i].valueOfCellIds = data[i].valueOfCellIds + 1;
       data[i].h0 = data[i].h0 + 1;
       data[i].vU = data[i].vU + 1;
       data[i].vV = data[i].vV + 1;
       data[i].vUh = data[i].vUh + 1;
       data[i].vVh = data[i].vVh + 1;
       data[i].vUh0 = data[i].vUh0 + 1;
       data[i].vVh0 = data[i].vVh0 + 1;
       data[i].ghh = data[i].ghh + 1;
       data[i].sfx = data[i].sfx + 1;
       data[i].sfy = data[i].sfy + 1;
       data[i].qIn = data[i].qIn + 1;


      for(int j = 0; j < nEdges; ++j) {
        data[i].flagInterface[j] = !data[i].flagInterface[j];
        data[i].typeInterface[j] = data[i].typeInterface[j] + 1;
        data[i].neighborIds[j] = data[i].neighborIds[j] + 1;
      }
    }

  }

private:

  const int numberOfCells;
  static const int nEdges = 6;
  struct data_t {
    bool floodedCells = 0;
    bool floodedCellsTimeInterval = 0;

    double valueOfCellIds = 0;
    double h = 0;

    double h0 = 0;
    double vU = 0;
    double vV = 0;
    double vUh = 0;
    double vVh = 0;
    double vUh0 = 0;
    double vVh0 = 0;
    double ghh = 0;
    double sfx = 0;
    double sfy = 0;
    double qInflow = 0;
    double qStartTime = 0;
    double qEndTime = 0;
    double qIn = 0;
    double nx = 0;
    double ny = 0;
    double floorLevels = 0;
    int lowerFloorCells = 0;
    bool floorCompleteleyFilled = 0;
    double cellLocationX = 0;
    double cellLocationY = 0;
    double cellLocationZ = 0;
    int levelOfCell = 0;
    bool flagInterface[nEdges] = {};
    int typeInterface[nEdges] = {};
    int neighborIds[nEdges] = {};
  };
  std::vector<data_t> data;

};

int main() {
  std::ios_base::sync_with_stdio(false);
  FloodIsolation isolation;
  clock_t start = clock();
  for (int i = 0; i < 400; ++i) {
    if(i % 100 == 0) {
      std::cout << i << "\n";
    }
    isolation.isUpdateNeeded();
  }
  clock_t stop = clock();
  std::cout << "Time: " << difftime(stop, start) / 1000 << "\n";
}

Live-Beispiel

Die Zeit ist jetzt 2x so schnell wie die Java-Version. (846 gegen 1631).

Wahrscheinlich hat die JIT das Brennen des Cache beim Zugriff auf Daten überall bemerkt und Ihren Code in eine logisch ähnliche, aber effizientere Reihenfolge umgewandelt.

Ich habe auch die stdio-Synchronisation deaktiviert, da dies nur benötigt wird, wenn Sie printf/ scanfmit C ++ std::coutund mischen std::cin. Zwar drucken Sie nur wenige Werte aus, aber das Standardverhalten von C ++ beim Drucken ist zu paranoid und ineffizient.

Wenn nEdgeses sich nicht um einen tatsächlichen konstanten Wert handelt, müssen die 3 "Array" -Werte aus dem entfernt werden struct. Das sollte keinen großen Leistungseinbruch verursachen.

Möglicherweise können Sie eine weitere Leistungssteigerung erzielen, indem Sie die Werte sortieren, structindem Sie die Größe verringern und so den Speicherbedarf verringern (und den Zugriff auch sortieren, wenn dies keine Rolle spielt). Aber ich bin mir nicht sicher.

Als Faustregel gilt, dass ein einzelner Cache-Fehler 100-mal teurer ist als eine Anweisung. Das Anordnen Ihrer Daten zur Cache-Kohärenz hat viel Wert.

Wenn eine Neuanordnung der Daten in a nicht möglich structist, können Sie Ihre Iteration so ändern, dass sie sich nacheinander über jedem Container befindet.

Beachten Sie außerdem, dass die Java- und C ++ - Versionen einige geringfügige Unterschiede aufwiesen. Die eine, die ich entdeckte, war, dass die Java-Version 3 Variablen in der "für jede Kante" -Schleife hat, während die C ++ - nur 2 hatte. Ich habe meine mit Java übereinstimmen lassen. Ich weiß nicht, ob es noch andere gibt.

Ja, der Cache in der C ++ - Version muss gehämmert werden. Es scheint, dass die JIT besser dafür gerüstet ist.

Wenn Sie das Äußere forin isUpdateNeeded () in kürzere Snippets ändern . Der Unterschied verschwindet.

Das folgende Beispiel führt zu einer 4-fachen Beschleunigung.

void isUpdateNeeded() {
    for (int i = 0; i < numberOfCells; ++i) {
        h[i] =  h[i] + 1;
        floodedCells[i] =  !floodedCells[i];
        floodedCellsTimeInterval[i] =  !floodedCellsTimeInterval[i];
        qInflow[i] =  qInflow[i] + 1;
        qStartTime[i] =  qStartTime[i] + 1;
        qEndTime[i] =  qEndTime[i] + 1;
    }

    for (int i = 0; i < numberOfCells; ++i) {
        lowerFloorCells[i] =  lowerFloorCells[i] + 1;
        cellLocationX[i] =  cellLocationX[i] + 1;
        cellLocationY[i] =  cellLocationY[i] + 1;
        cellLocationZ[i] =  cellLocationZ[i] + 1;
        levelOfCell[i] =  levelOfCell[i] + 1;
        valueOfCellIds[i] =  valueOfCellIds[i] + 1;
        h0[i] =  h0[i] + 1;
        vU[i] =  vU[i] + 1;
        vV[i] =  vV[i] + 1;
        vUh[i] =  vUh[i] + 1;
        vVh[i] =  vVh[i] + 1;
    }
    for (int i = 0; i < numberOfCells; ++i) {
        vUh0[i] =  vUh0[i] + 1;
        vVh0[i] =  vVh0[i] + 1;
        ghh[i] =  ghh[i] + 1;
        sfx[i] =  sfx[i] + 1;
        sfy[i] =  sfy[i] + 1;
        qIn[i] =  qIn[i] + 1;
        for(int j = 0; j < nEdges; ++j) {
            neighborIds[i * nEdges + j] = neighborIds[i * nEdges + j] + 1;
        }
        for(int j = 0; j < nEdges; ++j) {
            typeInterface[i * nEdges + j] = typeInterface[i * nEdges + j] + 1;
        }
    }

}

Dies zeigt in angemessenem Maße, dass Cache-Fehler der Grund für die Verlangsamung sind. Es ist auch wichtig zu beachten, dass die Variablen nicht abhängig sind, sodass leicht eine Thread-Lösung erstellt werden kann.

Ordnung wiederhergestellt

Gemäß dem Kommentar von stefans habe ich versucht, sie in einer Struktur unter Verwendung der Originalgrößen zu gruppieren. Dies entfernt den unmittelbaren Cache-Druck auf ähnliche Weise. Das Ergebnis ist, dass die c ++ (CCFLAG -O3) -Version etwa 15% schneller ist als die Java-Version.

Varning weder kurz noch hübsch.

#include <vector>
#include <cmath>
#include <iostream>
 
 
 
class FloodIsolation {
    struct item{
      char floodedCells;
      char floodedCellsTimeInterval;
      double valueOfCellIds;
      double h;
      double h0;
      double vU;
      double vV;
      double vUh;
      double vVh;
      double vUh0;
      double vVh0;
      double sfx;
      double sfy;
      double qInflow;
      double qStartTime;
      double qEndTime;
      double qIn;
      double nx;
      double ny;
      double ghh;
      double floorLevels;
      int lowerFloorCells;
      char flagInterface;
      char floorCompletelyFilled;
      double cellLocationX;
      double cellLocationY;
      double cellLocationZ;
      int levelOfCell;
    };
    struct inner_item{
      int typeInterface;
      int neighborIds;
    };

    std::vector<inner_item> inner_data;
    std::vector<item> data;

public:
    FloodIsolation() :
            numberOfCells(20000), inner_data(numberOfCells * nEdges), data(numberOfCells)
   {

    }
    ~FloodIsolation(){
    }
 
    void isUpdateNeeded() {
        for (int i = 0; i < numberOfCells; ++i) {
            data[i].h = data[i].h + 1;
            data[i].floodedCells = !data[i].floodedCells;
            data[i].floodedCellsTimeInterval = !data[i].floodedCellsTimeInterval;
            data[i].qInflow = data[i].qInflow + 1;
            data[i].qStartTime = data[i].qStartTime + 1;
            data[i].qEndTime = data[i].qEndTime + 1;
            data[i].lowerFloorCells = data[i].lowerFloorCells + 1;
            data[i].cellLocationX = data[i].cellLocationX + 1;
            data[i].cellLocationY = data[i].cellLocationY + 1;
            data[i].cellLocationZ = data[i].cellLocationZ + 1;
            data[i].levelOfCell = data[i].levelOfCell + 1;
            data[i].valueOfCellIds = data[i].valueOfCellIds + 1;
            data[i].h0 = data[i].h0 + 1;
            data[i].vU = data[i].vU + 1;
            data[i].vV = data[i].vV + 1;
            data[i].vUh = data[i].vUh + 1;
            data[i].vVh = data[i].vVh + 1;
            data[i].vUh0 = data[i].vUh0 + 1;
            data[i].vVh0 = data[i].vVh0 + 1;
            data[i].ghh = data[i].ghh + 1;
            data[i].sfx = data[i].sfx + 1;
            data[i].sfy = data[i].sfy + 1;
            data[i].qIn = data[i].qIn + 1;
            for(int j = 0; j < nEdges; ++j) {
                inner_data[i * nEdges + j].neighborIds = inner_data[i * nEdges + j].neighborIds + 1;
                inner_data[i * nEdges + j].typeInterface = inner_data[i * nEdges + j].typeInterface + 1;
            }
        }
 
    }
 
    static const int nEdges;
private:
 
    const int numberOfCells;

};
 
const int FloodIsolation::nEdges = 6;

int main() {
    FloodIsolation isolation;
    clock_t start = clock();
    for (int i = 0; i < 4400; ++i) {
        if(i % 100 == 0) {
            std::cout << i << "\n";
        }
        isolation.isUpdateNeeded();
    }

    clock_t stop = clock();
    std::cout << "Time: " << difftime(stop, start) / 1000 << "\n";
}
                                                                              

Mein Ergebnis unterscheidet sich geringfügig von Jerry Coffins für die Originalgrößen. Für mich bleiben die Unterschiede. Es könnte durchaus meine Java-Version 1.7.0_75 sein.

Wie @Stefan in einem Kommentar zur Antwort von @ CaptainGiraffe vermutet hat, gewinnen Sie einiges, wenn Sie einen Vektor von Strukturen anstelle einer Struktur von Vektoren verwenden. Der korrigierte Code sieht folgendermaßen aus:

#include <vector>
#include <cmath>
#include <iostream>
#include <time.h>

class FloodIsolation {
public:
    FloodIsolation() :
            h(0),
            floodedCells(0),
            floodedCellsTimeInterval(0),
            qInflow(0),
            qStartTime(0),
            qEndTime(0),
            lowerFloorCells(0),
            cellLocationX(0),
            cellLocationY(0),
            cellLocationZ(0),
            levelOfCell(0),
            valueOfCellIds(0),
            h0(0),
            vU(0),
            vV(0),
            vUh(0),
            vVh(0),
            vUh0(0),
            vVh0(0),
            ghh(0),
            sfx(0),
            sfy(0),
            qIn(0),
            typeInterface(nEdges, 0),
            neighborIds(nEdges, 0)
    {
    }

    ~FloodIsolation(){
    }

    void Update() {
        h =  h + 1;
        floodedCells =  !floodedCells;
        floodedCellsTimeInterval =  !floodedCellsTimeInterval;
        qInflow =  qInflow + 1;
        qStartTime =  qStartTime + 1;
        qEndTime =  qEndTime + 1;
        lowerFloorCells =  lowerFloorCells + 1;
        cellLocationX =  cellLocationX + 1;
        cellLocationY =  cellLocationY + 1;
        cellLocationZ =  cellLocationZ + 1;
        levelOfCell =  levelOfCell + 1;
        valueOfCellIds =  valueOfCellIds + 1;
        h0 =  h0 + 1;
        vU =  vU + 1;
        vV =  vV + 1;
        vUh =  vUh + 1;
        vVh =  vVh + 1;
        vUh0 =  vUh0 + 1;
        vVh0 =  vVh0 + 1;
        ghh =  ghh + 1;
        sfx =  sfx + 1;
        sfy =  sfy + 1;
        qIn =  qIn + 1;
        for(int j = 0; j < nEdges; ++j) {
            ++typeInterface[j];
            ++neighborIds[j];
        }       
    }

private:

    static const int nEdges = 6;
    bool floodedCells;
    bool floodedCellsTimeInterval;

    std::vector<int> neighborIds;
    double valueOfCellIds;
    double h;
    double h0;
    double vU;
    double vV;
    double vUh;
    double vVh;
    double vUh0;
    double vVh0;
    double ghh;
    double sfx;
    double sfy;
    double qInflow;
    double qStartTime;
    double qEndTime;
    double qIn;
    double nx;
    double ny;
    double floorLevels;
    int lowerFloorCells;
    bool flagInterface;
    std::vector<int> typeInterface;
    bool floorCompleteleyFilled;
    double cellLocationX;
    double cellLocationY;
    double cellLocationZ;
    int levelOfCell;
};

int main() {
    std::vector<FloodIsolation> isolation(20000);
    clock_t start = clock();
    for (int i = 0; i < 400; ++i) {
        if(i % 100 == 0) {
            std::cout << i << "\n";
        }

        for (auto &f : isolation)
            f.Update();
    }
    clock_t stop = clock();
    std::cout << "Time: " << difftime(stop, start) / 1000 << "\n";
}

Mit dem Compiler aus VC ++ 2015 CTP kompiliert -EHsc -O2b2 -GL -Qpar, erhalte ich folgende Ergebnisse:

0
100
200
300
Time: 0.135

Das Kompilieren mit g ++ führt zu einem etwas langsameren Ergebnis:

0
100
200
300
Time: 0.156

Auf derselben Hardware erhalte ich mit dem Compiler / JVM von Java 8u45 folgende Ergebnisse:

0
100
200
300
Time: 181

Dies ist ungefähr 35% langsamer als die Version von VC ++ und ungefähr 16% langsamer als die Version von g ++.

Wenn wir die Anzahl der Iterationen auf das gewünschte Jahr 2000 erhöhen, sinkt die Differenz auf nur 3%, was darauf hindeutet, dass ein Teil des Vorteils von C ++ in diesem Fall einfach ein schnelleres Laden ist (ein beständiges Problem mit Java), das nicht wirklich in der Ausführung selbst liegt. Dies überrascht mich in diesem Fall nicht - die gemessene Berechnung (im veröffentlichten Code) ist so trivial, dass ich bezweifle, dass die meisten Compiler eine ganze Menge tun können, um sie zu optimieren.

Ich vermute, es geht um die Zuweisung von Speicher.

Ich denke, dass Javabeim Programmstart ein großer zusammenhängender Block erfasst wird, während C++das Betriebssystem im Laufe der Zeit nach Kleinigkeiten gefragt wird.

Um diese Theorie auf den Prüfstand zu stellen, habe ich eine Änderung an der C++Version vorgenommen und sie lief plötzlich etwas schneller als die JavaVersion:

int main() {
    {
        // grab a large chunk of contiguous memory and liberate it
        std::vector<double> alloc(20000 * 20);
    }
    FloodIsolation isolation;
    clock_t start = clock();
    for (int i = 0; i < 400; ++i) {
        if(i % 100 == 0) {
            std::cout << i << "\n";
        }
        isolation.isUpdateNeeded();
    }
    clock_t stop = clock();
    std::cout << "Time: " << (1000 * difftime(stop, start) / CLOCKS_PER_SEC) << "\n";
}

Laufzeit ohne Vorbelegungsvektor:

0
100
200
300
Time: 1250.31

Laufzeit mit dem Vorbelegungsvektor:

0
100
200
300
Time: 331.214

Laufzeit für JavaVersion:

0
100
200
300
Time: 407