ich sitze gerade an einem Programm, das für mich eine Reihe von unterschiedlichen Rechnungen für Punkte in einem Volumen durchführt. Insgesamt möchte ich ca. 10.000*10.000*8 Punkte und damit Daten berechnen. Diese Daten sollen später in eine Datei geschrieben werden.

Ich habe das mit kleinen Punktemengen getestet und es hat sich als erheblich schneller erwiesen, die Daten in einem Array zwischen zu speichern und dann komplett in eine Datei zu schreiben. Allerdings habe ich jetzt das Problem, dass ein float-Array normal keine 10.000*10.000*8 Daten abspeichern kann.

Weiß jemand von euch wie ich das umgehen kann, oder hat vielleicht jemand eine bessere Idee, um diese Menge an Daten weiter zu verarbeiten? Ich suche nach einer Lösung, die möglichst wenig Zeit braucht, da die Rechnungen so schon sehr lange brauchen.

Danke.

Im Moment sieht mein Programm quasi so aus:

float Ergebnis[10000][10000][8]; //Das gewünschte Array

for(int counter1=0; counter1<10000; counter1++)
{
    for(int counter2=0; counter2<10000; counter2++)
    {
        for(int counter3=0; counter3<8; counter3++)
        {
            Ergebnis[counter1][counter2][counter3] = Rechnung(counter1, counter2, counter3); 
            //Da hier kein Problem vorliegt einfach nur eine kleine fiktive Rechnung, die für jeden einzelnen Punkt gemacht wird
        }
    }
}

float Ergebnis[10000][8]; //Das gewünschte Array

for(int counter1=0; counter1<10000; counter1++)
{
    for(int counter2=0; counter2<10000; counter2++)
    {
        for(int counter3=0; counter3<8; counter3++)
        {
            Ergebnis[counter2][counter3] = Rechnung(counter1, counter2, counter3);
            //Da hier kein Problem vorliegt einfach nur eine kleine fiktive Rechnung, die für jeden einzelnen Punkt gemacht wird
        }
    }
	WriteToFile(Ergebnis);
}

Wie komme ich denn an so einen Vektor ran?
bzw. wie würde die Initialisierung, das zwischenspeichern und das auslesen aussehen?

Wenn du alles im Speicher halten willst sind das ca. 3 GB, das dürfte auf einem handelsüblichen 32-Bit-System schon knapp werden.
Wenn du auf einem 64-Bit System mit ausreichend Speicher arbeitest, nimm einen std::vector<float> der Größe 10000*10000*8.
Ansonsten halt kleinere Teile laden, verarbeiten, speichern.

Wie komme ich denn an so einen Vektor ran?
bzw. wie würde die Initialisierung, das zwischenspeichern und das auslesen aussehen?

#include <vector>
std::vector<float> Ergebnisse(10000 * 10000 * 8);
float &wert = Ergebnisse[c1 * 10000 * 8 + c2 * 8 + c3]

Wie komme ich denn an so einen Vektor ran?
bzw. wie würde die Initialisierung, das zwischenspeichern und das auslesen aussehen?

#include <vector>
using namespace std;

int main ()
{
   vector<int> Vektor; // Int Vektor
   Vektor.push_back(12); // Vektor[0] ist 12
}

http://de.wikibooks.org/wiki/C%2B%2B-Programmierung:_Vector
(www.cplusplus.com/ war bei mir offline )

Danke.

Wenn du alles im Speicher halten willst sind das ca. 3 GB, das dürfte auf einem handelsüblichen 32-Bit-System schon knapp werden.
Wenn du auf einem 64-Bit System mit ausreichend Speicher arbeitest, nimm einen std::vector<float> der Größe 10000*10000*8.
Ansonsten halt kleinere Teile laden, verarbeiten, speichern.

Ich würde jedoch trotzdem std::deque nehmen - vor allem, weil du nicht davon ausgehen kannst, 3GB Speicher am Stück zu bekommen - auf nem 32bit OS würde ich von _MAX_ 1-1.5GB ausgeben. Aber selbst auf nem 64bit OS würde ich mich nicht auf über 2-2.5GB verlassen.
Und std::deque ist ja nun nicht so viel langsamer als vector...
Du kannst auch erst mal vector über nen typedef nutzen, damit du es dann ändern kannst, wenn du merkst, dass du die 3GB idR nicht bekommst:

#if 1
# include <vector>
  typedef std::vector<float> container_t;
#else
# include <deque>
  typedef std::deque<float> container_t;
#endif

#include <iostream>
#include <cstdlib>

int main()
{
	try
	{
		container_t container(/*10*/4*1000*10000*8);
		container.push_back( container.size() );
		std::cout << container.size() << std::endl;
	}
	catch(std::exception& e)
	{
		std::cout << e.what();
	}

	system("PAUSE");
}

btw: bad_alloc wurde bei mir nicht geworfen(allerdings waren beide Varianten ab 5*.... mit ner Ewigkeit des Wartens(und du brauchst ja 10*....) verbunden(und das ganze System hat nicht mehr reagiert - hab halt nur 4GB RAM - und wenn die voll sind, wirds düster^^ wenn du nicht mind. 8GB RAM hast, kannst du das eh vergessen).
mit der vollen Größe hab ichs dann auch nicht mehr versucht - hab auch nur 4GB an auslagerungsdatei - danach wirds also noch mal langsamer, wenn zu der langsamen festplatte auch noch defragmentierung kommt, weil Windows wohl kaum >4GB SPeicher am Stück (zumindest hier^^) finden wird

Da kannst du gleich mal gucken, ob du performance-technisch überhaupt Unterschiede spüren kannst - wenn ja, kannst du sie messen und dich dann noch immer entscheiden.

bb

PS: war ja schon ein wenig enttäuscht, dass der MSVC(10) das hier nicht mehr wegoptimieren kann... War fest davon ausgegangen, dass ich eh noch x Zeilen einbauen muss, nur damit er den vector/die deque nicht wegoptimiert^.