define-Makro mit großen Werte

butze

Hallo zusammen,

im Rahmen meines Studiums arbeite ich an einem Portfolio, wo ich Laufzeiten von bestimmten Sortieralgorithmen (Bubble-, Quick- ,Heapsort) analysieren und vergleichen soll.
Die Algorithmen habe ich in C++ umgesetzt und das klappt soweit auch alles.
Allerdings genügen mir die Datenmengen die ich sortieren lassen will nicht.
Ich hatte vor den Arbeitsspeicher mit einer Kapazität von 512 MB komplett mit signed integer-Daten zu füllen.
Meines Wissens hat ein signed-int 4 Byte, somit bräuchte ich eine Anzahl von ( 512*8*10^6 Byte / 4 Byte ) 1 024 000 000 ~ 10^9 Daten. Der Sinn dabei ist es, denn Computer an seine Grenzen zu führen um herauszufinden was dann passiert und natürlich die Laufzeiten auszureizen.

Momentan bestimme ich über #define ANZAHL wert die Anzahl der Daten die über int daten[ANZAHL] dann ja eigentlich reserviert werden. (oder ist es besser den Speicher dynamisch zu reservieren, wenn ja wie am besten, für Tipps bin ich dankbar :))

Das Problem ist aber nur, dass mein Editor (oder vielleicht schon der Compiler) bei der define-Anweisung meckert, wenn ich circa 1 Millionen Werte (glaube ich sowas um den Dreh) dafür eintrage.

Ich habe von jemanden gehört, dass dies eventuell im Compiler so eingestellt ist, allerdings habe ich keine Ahnung wie ich das da ändern könnte.

Ich hoffe ihr könnt mir weiterhelfen. Zum Schluss noch die Daten meiner Entwicklungsumgebung:
OS: Suse Linux 10.2
Compiler: gcc
Editor: gVim

Gruß

Butze
-----
PS: Ich bin noch unerfahren mit dem Umgang von C++ und hoffe ihr drückt eine Auge zu falls meine Fragen dämlich oder trivial sein sollten
PPS: Ich hoffe ich bin jetzt hier im richtigen Teil des Forums mit meinem Thread gelandet. Wenn nicht, entschuldige ich mich für die Umstände.

Martin G

Also zunächst mal ist Deine Rechnung falsch. Um 512 MB mit 4-Byte-Werten zu füllen bedarf es 512*1024*1024/4 = 134.217.728 Werte und nicht 10^9.
Außerdem wird mit einer DEFINE-Anweisung lediglich ein Text definiert, der von dem Präprozessor an den entsprechenden Stellen eingetragen wird. So liefert selbst

# define ANZAHL 1000000000000000000000000000000000000000000

bei mir keine Fehlermeldung!
Wenn Du den Wert allerdings in einer for()-Schleife einsetzt, muss Deine Laufvariable auch vom Typ "long int" sein! Außerdem sollte am Ende der Zahl in der DEFINE-Anweisung ein "L" für long int stehen:

# define ANZAHL 134217728L

Last but not least ist Dein Test auf einem System mit virtuellem Speicher ohnehin Unsinn!

C++ Forumbot

Dieser Thread wurde von Moderator/in rüdiger aus dem Forum Linux/Unix in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

LordJaxom

In C++ würde ich zudem immer eine Konstante einem Makro vorziehen. So ist Typsicherheit gewährleistet und der Compiler kann bei der Definition schon meckern, wenn der Wert nicht hineinpasst:

const size_t ANZAHL = 1000000000;

Was die Speicherallokation angeht: Wenn Dein int daten[ANZAHL] nicht selbst in einem Objekt liegt, welches auf dem Heap allokiert wurde, wird Dir ohnehin der Stack um die Ohren fliegen. Hier wäre tatsächlich sinnig, den entsprechenden Platz dynamisch zu reservieren.

Last but not least hat Martin G natürlich vollkommen Recht, wenn er sagt dass ein solcher Test bei einem System mit virtuellem Speicher wenig Sinn macht, da hier die Laufzeit durch swappen beeinträchtigt wird, eh eine Wirkung durch Speichermangel auftaucht. Sprich Du kannst gleich Dein Benchmark und den Belastungstest in die Tonne werfen.

butze

Vielen Dank erstmal für die Antworten.

Irgendwie hatte ich schon vermutet, dass der Prof. mir einiges mehr abverlangt, als mein Kenntnisstand erlaubt. (2.Semester )

Aus euren Beiträgen ziehe ich dann folgendes Resümee:
- Ein blöder Fehler hat sich bei meiner Rechnung eingeschlichen (ich weiß nicht warum ich Byte in Bit umgewandelt habe *peinlich*) und natürlich ist Kilo 1024 und Mega dementsprechend 1024^2 *danke für den Hinweis*
- werde ich eine Konstante für die Anzahl verwenden
-

Last but not least hat Martin G natürlich vollkommen Recht, wenn er sagt dass ein solcher Test bei einem System mit virtuellem Speicher wenig Sinn macht, da hier die Laufzeit durch swappen beeinträchtigt wird, eh eine Wirkung durch Speichermangel auftaucht.

Daraufhin habe ich mir den Wikipedia-Artikel Virtueller Speicher angeschaut.
[ Quelle: http://de.wikipedia.org/wiki/Virtueller_Speicher ]
Das habe ich so verstanden, dass eine virtuelle Adresse der Daten im Arbeitsspeicher liegt, aber die eigentlichen Daten evtl. auf der Festplatte ausgelagert sein können. Somit macht es wohl keinen Sinn zu versuchen den Arbeitsspeicher vollzumachen.
Interessant kann es ja trotzdem sein, zu analysieren wie sich das Swapping dann auf die Laufzeit auswirkt.

Was die Speicherallokation angeht: Wenn Dein int daten[ANZAHL] nicht selbst in einem Objekt liegt, welches auf dem Heap allokiert wurde, wird Dir ohnehin der Stack um die Ohren fliegen. Hier wäre tatsächlich sinnig, den entsprechenden Platz dynamisch zu reservieren.

Momentan habe ich mein int daten[ANZAHL] in der main-Function stehen. Von dort aus wird Heapsort aufgerufen, dabei wird die Adresse auf daten(auf das erste Feldelement) und die Größe des Feldes übergeben.

heapsort(daten, ANZAHL);

Bisher kenne ich nur folgenden Befehl für die Speicherreservierung von Feldern, zB:

int *daten = new int[feldgroesse];
// ... zum schluss ...
delete[] daten;

Sollte ich dies so praktizieren, damit "nichts" mehr schief gehen kann?

Ich nehme mir eure Hilfe zu Herzen und werde gleich versuchen, dies umzusetzen.
Trotzdem würde ich nicht sagen, dass ich das Programm in die Tonne werfen sollte.

Noch einmal vielen Dank für eure schnellen Antworten.

Gruß
butze