Java 8 fois plus rapide avec les tableaux que std :: vector en C ++. Qu'est-ce que j'ai fait de mal?
J'ai le code Java Java avec plusieurs grands tableaux qui ne changent jamais leur taille. Il fonctionne en 1100 ms sur mon ordinateur.
J'ai implémenté le même code en C++ et utilisé std::vector.
Le temps de l'implémentation C++ qui exécute exactement le même code est de 8800 ms sur mon ordinateur. Qu'est-ce que j'ai fait de mal, pour que ça fonctionne si lentement?
Fondamentalement, le code fait ce qui suit:
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;
}
Il itère à travers différents tableaux d'une taille d'environ 20000.
Vous pouvez trouver les deux implémentations sous les liens suivants:
(Sur ideone, je ne pouvais exécuter la boucle que 400 fois au lieu de 2000 fois en raison de la limitation de temps. Mais même ici, il y a une différence de trois fois)
Voici la version C++ avec les données par nœud rassemblées dans une structure, et un seul vecteur de cette structure utilisé:
#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";
}
Le temps est maintenant 2x la vitesse de la Java. (846 vs 1631).
Les chances sont que le JIT a remarqué la gravure du cache d'accès aux données partout, et a transformé votre code en un ordre logiquement similaire mais plus efficace.
J'ai également désactivé la synchronisation stdio, car cela n'est nécessaire que si vous mélangez printf/scanf avec C++ std::cout et std::cin. En l'occurrence, vous n'imprimez que quelques valeurs, mais le comportement par défaut de C++ pour l'impression est trop paranoïaque et inefficace.
Si nEdges n'est pas une valeur constante réelle, alors les 3 valeurs de "tableau" devront être supprimées de struct. Cela ne devrait pas entraîner un énorme impact sur les performances.
Vous pourriez être en mesure d'obtenir une autre amélioration des performances en triant les valeurs dans ce struct en diminuant la taille, réduisant ainsi l'empreinte mémoire (et en triant l'accès également lorsque cela n'a pas d'importance). Mais je ne suis pas sûr.
En règle générale, un seul échec de cache est 100 fois plus cher qu'une instruction. Organiser vos données pour avoir une cohérence de cache a beaucoup de valeur.
S'il est impossible de réorganiser les données dans un struct, vous pouvez modifier votre itération pour qu'elle se trouve sur chaque conteneur à son tour.
Soit dit en passant, notez que les versions Java et C++ présentaient quelques différences subtiles. Celui que j'ai repéré était que la version Java a 3 variables "pour chaque Edge", alors que le C++ n'en avait que 2. J'ai fait correspondre le mien au Java. Je ne sais pas s'il y en a d'autres.
Oui, le cache dans la version c ++ prend un coup de marteau. Il semble que le JIT soit mieux équipé pour gérer cela.
Si vous modifiez le for externe dans isUpdateNeeded () en extraits plus courts. La différence disparaît.
L'exemple ci-dessous produit une accélération 4x.
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;
}
}
}
Cela montre à un degré raisonnable que les échecs de cache sont la raison du ralentissement. Il est également important de noter que les variables ne sont pas dépendantes, de sorte qu'une solution filetée est facilement créée.
Ordre rétabli
Selon les commentaires de Stefans, j'ai essayé de les regrouper dans une structure en utilisant les tailles d'origine. Cela supprime la pression immédiate du cache d'une manière similaire. Le résultat est que la version c ++ (CCFLAG -O3) est environ 15% plus rapide que la version Java.
Varning ni court ni joli.
#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";
}
Mon résultat diffère légèrement de Jerry Coffins pour les tailles originales. Pour moi, les différences demeurent. Ce pourrait bien être mon Java, 1.7.0_75.
Comme @Stefan l'a deviné dans un commentaire sur la réponse de @ CaptainGiraffe, vous gagnez beaucoup en utilisant un vecteur de structures au lieu d'une structure de vecteurs. Le code corrigé ressemble à ceci:
#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";
}
Compilé avec le compilateur de VC++ 2015 CTP, en utilisant -EHsc -O2b2 -GL -Qpar, J'obtiens des résultats comme:
0
100
200
300
Time: 0.135
Compiler avec g ++ produit un résultat légèrement plus lent:
0
100
200
300
Time: 0.156
Sur le même matériel, en utilisant le compilateur/JVM de Java 8u45, j'obtiens des résultats comme:
0
100
200
300
Time: 181
C'est environ 35% plus lent que la version de VC++, et environ 16% plus lent que la version de g ++.
Si nous augmentons le nombre d'itérations aux 2000 souhaités, la différence tombe à seulement 3%, suggérant qu'une partie de l'avantage du C++ dans ce cas est tout simplement un chargement plus rapide (un problème permanent avec Java), pas vraiment dans l'exécution elle-même. Cela ne me semble pas surprenant dans ce cas - le calcul mesuré (dans le code publié) est si trivial que je doute que la plupart des compilateurs puissent faire beaucoup pour l'optimiser.
Je soupçonne qu'il s'agit d'allocation de mémoire.
Je pense que Java saisit un gros bloc contigu au démarrage du programme alors que C++ demande au système d'exploitation des morceaux au fur et à mesure.
Pour mettre cette théorie à l'épreuve, j'ai apporté une modification au C++ version et il a soudainement commencé à fonctionner légèrement plus vite que la version Java:
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";
}
Runtime sans le vecteur de préallocation:
0
100
200
300
Time: 1250.31
Runtime with le vecteur de préallocation:
0
100
200
300
Time: 331.214
Runtime pour la version Java:
0
100
200
300
Time: 407