Sortieralgorithmen unter 64-Bit

SeppJ

mulek schrieb:

ok, kannst du mir dann ein Sortierbeispiel zeigen bei dem man von den Registererweiterung profiert?

Normales Sortieren? Ohne diesen Pointerquatsch den du da machst? Erwarte aber nicht viel, der Unterschied dürfte kaum messbar sein.

Was sind sonst so typische Anwendungen bei den 64-Bit schneller ist?

Wo immer mit großen Zahlen gerechnet wird, ist 64-Bit erheblich schneller. Wo nur mit kleinen Zahlen gerechnet wird, kann 64 Bit etwas langsamer sein, daprinzipiell etwas mehr Aufwand, ohne konkreten Nutzen.

mulek

Wenn ich also einen vector<int> sortiere sollte also 64-Bit ein wenig schneller sein wegen der zusätzlichen Regiser bei 64-Bit? Hängt dann aber auch von Vectorlänge ab?

Ist eine Matrixmultiplikation eines 2dimensionalen Arrays mit int Werten eine geeignetes Beispiel um Laufzeitunterschiede zwischen 32-Bit und 64-Bit zu zeigen?

Sonst vl noch Ideen zu konkreteren Beispielen?

lg

SeppJ

mulek schrieb:

Wenn ich also einen vector<int> sortiere sollte also 64-Bit ein wenig schneller sein wegen der zusätzlichen Regiser bei 64-Bit? Hängt dann aber auch von Vectorlänge ab?

Nicht unbedingt. Wenn dein Sortieralgortihmus ohnehin nicht alle Register ausreizen sollte, gewinnt man auch nichts.

Ist eine Matrixmultiplikation eines 2dimensionalen Arrays mit int Werten eine geeignetes Beispiel um Laufzeitunterschiede zwischen 32-Bit und 64-Bit zu zeigen?

Wie wäre es mit verschiedenen Arten von Anwendungen? Du wirst feststellen, dass es bei vielen Anwendungen (fast) keinen Unterschied macht, auf welcher Architektur du rechnest.

Wenn du etwas suchst, wo man einen großen Unterschied sieht, multipliziere mal zwei 64-Bit Zahlen. Auf der 64-Bit Architektur ist das 1 Schritt, auf der 32-Bit Architektur mindestens 4. Ein realistisches Beispiel dafür ist Software die auf großen Datensätzen arbeitet, beispielsweise Verschlüsselungsprogramme und Grafikbearbeitung.

Wenn du etwas suchst, wo 32-Bit deutlich überlegen ist, musst du etwas nehmen, wo die Größe eines Pointers geschwindigkeitsrelevant ist. Mir fällt spontan kein realistisches Beispiel für eine solche Software ein.

Aber viele Programme die nicht von den Vorteilen von 64-Bit Systemen profitieren, sind etwas langsamer als wenn man sie im 32-Bit Modus betreibt. Das liegt daran, weil die Executables etwas größer sind und die Pointer etwas größer sind.

mulek

Ok danke mal soweit für die Infos.

Werd mal ein paar double Werte multiplizieren und Zeit messen.

SeppJ

mulek schrieb:

Ok danke mal soweit für die Infos.

Werd mal ein paar double Werte multiplizieren und Zeit messen.

doubles sind keine ints. Du wirst feststellen, dass bei doubles kein Unterschied besteht.

mulek

Wenn du etwas suchst, wo man einen großen Unterschied sieht, multipliziere mal zwei 64-Bit Zahlen. Auf der 64-Bit Architektur ist das 1 Schritt, auf der 32-Bit Architektur mindestens 4

double sind 8 Byte
integer bei mir unter 64-Bit nur 4 Byte
was soll ich dann bitte nehmen?

SideWinder

Wurde im Thread schon erwähnt -> long.

MfG SideWinder

mulek

So hab die Matrixmultiplikation mit verschiedenen Typen getestet unter anderem auch mit double.

int main(){

	double time = 0.0;
	double SumUpTime = 0.0;

	long test = 0;

	int const NumberOfMatrix = 1;

	double **matrixA;
	matrixA = new double* [size]; 

	double **matrixB;
	matrixB = new double* [size]; 

	double **matrixC;
	matrixC = new double* [size]; 

	for (int i=0;i<size; i++){
		matrixA[i] = new double[size]; 
		matrixB[i] = new double[size]; 
		matrixC[i] = new double[size]; 
	}

	for(int i=0;i<NumberOfMatrix;i++){
		RandomMatrix(matrixA);
		RandomMatrix(matrixB);
		RandomMatrix(matrixC);

		//Output(matrixA);
		//Output(matrixB);
		//Output(matrixC);

		time = 0.0;
		stw::Start();
		Multiplication(matrixA,matrixB,matrixC);
		//Multiplication_Loop_Blocking(matrixA,matrixB,matrixC);

		time = stw::Stop();

		SumUpTime = SumUpTime + time;
	}

		cout << "Die Matrixmultiplikation benötigt " << SumUpTime/NumberOfMatrix << " Sekunden!!" << endl;

	getchar();

	//Speicher freigeben
	for (int i=0;i<size; i++){
		delete matrixA[i]; matrixA[i]=0;
		delete matrixB[i]; matrixB[i]=0;
		delete matrixC[i]; matrixC[i]=0;
	}

	delete matrixA[size];
	delete matrixB[size];
	delete matrixC[size];

	return 0;
}

hab 1000x1000 - 4000x4000 gemessen,

Bei meinen Messungen stell ich fest das die Matrixmultiplikation ca. 4 % schneller ist bei 64-Bit, warum ist das so?

Hab dann auch in Erfahrung gebracht das ich mit LoopBlocking meine Multiplikation hinsichtlich des Caches optimieren kann. Nach dieser Optimierung ist 64-Bit ca. 45% schneller als 32-Bit. Nach der Optimerung werden die Register usw. ja viel besser genutzt. Aber warum ist bei der unoptimierten version64-Bit um ca. 4 % schneller, dass kann ich mir noch nicht erklären.

Shade Of Mine

mulek schrieb:

Bei meinen Messungen stell ich fest das die Matrixmultiplikation ca. 4 % schneller ist bei 64-Bit, warum ist das so?

Ohne den ganzen Code zu kennen schwer zu sagen, aber Prinzipiell ist 64bit code schneller als 32bit code. 4% fühlt sich da eigentlich ok an.

schau dir halt die assembler ausgabe an...

mulek

bin mit assembler ja nicht wirklich vertraut.
aber was mir im assembler code bei der 64-Bit Version gleich aufgefallen ist das hier die 128-Bit breiten xmm register verwendet werden.

bei 32-Bit kommen die ja irgendwie gar nicht zum einsatz, was irgendwie komisch ist weil für 32-Bit ja auch eine gewisse Anzahl an xmm Register zur verfügung steht?

Aber das erklärt mir ja trotzdem nicht die 4% Leistungssteigerung bei der unoptimierten version, da ich doch bei solch einer riesige datenmenge eine menge an cache - misses generiere?