Exception in der metode

[Gregor]

mal rechnen...

du hast 14000000 Vectoren mit jeweils 10 Elementen. Dafür brauchst du mindestens folgenden Speicherplatz:

14000000 * (4+8+4+8+10*4) = 14000000 * 64 = 896.000.000 Byte.

...und da stehen noch keine Zahlen in den Vectoren drin, du brauchst also noch deutlich mehr.

Mit anderen Worten: Du gehst einfach viel zu verschwenderisch mit dem Speicherplatz um. Da geschieht dir ein OutOfMemoryError ganz recht.

[Gast]

Sei doch nicht so gemein zu ihm.

[Gregor]

Optimizer schrieb:

Sei doch nicht so gemein zu ihm.

Meinste, das war zu deutlich gesagt? ...dann gibt es als Wiedergutmachung eine kleine Notlösung, um den Speicherverbrauch zu mindern:

Statt den 14000000 Vectoren nimmst du einfach 14000000 byte-Arrays der Länge 6. Dann benötigst du noch ungefähr folgenden Speicherplatz (in der obigen Rechnung habe ich übrigens eine 4 zu wenig):

14000000 * (4+8+4+6*1) = 308.000.000 Byte.

Dann sollte dein -Xmx500m eigentlich klappen. ...naja, vielleicht auch nicht, probier es einfach aus.

[JavaNewbie]

Hallo, ich kann euch nur eins sagen was ich schon öfters gesagt habe. ich habe das ganze in c++ implementiert und es läuft einwandfrei. ohne jeglichen mist von xmx500. Das kann doch nicht wahr sein dass java mit sowas nicht klar kommt. wofür soll dann das gut sein. um das kleine 1x1 zu berechnen. dafür brauche ich keine computer und schon gar nicht eine programmiersprache wie java.
in c++ deklariere ich folgendes:

struct zahl{
   int zahl1;
   int zahl2;
   int zahl3;
};

std::vector<zahl> vVollSys;

Somit kann ich meinen Vector so zuknalle wie es nur geht. Ganz nebenbei gesagt berechne ich all 13... milionen kombinationen in c++ in ein paar sekunden.
Da ich aber das ganze in java brauche wollte ich dafür eine lösung haben aber es geht leider nicht. So wie es aussieht kann man sowas nicht mit java lösen. Ich bin schon von der Gui und dem tempo von java echt enttäuscht aber jetzt noch das.
Kann es vieleicht sein, dass ich das ganze anders programmieren sollte?

[Sgt. Nukem]

Gregor schrieb:

14000000 * (4+8+4+8+10*4) = 14000000 * 64 = 896.000.000 Byte.

Auch wenn ich die Rechnung nicht verstehe, das sind ja 850 MB!!

Da müßte unser Kollege also min. 1 GB RAM sein eigen nennen!

Wieviel Platz nimmt denn Dein C++ Prog ein?! Mal im TaskMan geschaut?!

EDIT: Vielleicht postest Du zum Vergleich mal Deinen C++ Code?

[JavaNewbie]

Hi, hier ist mein c++ code:
header:

struct zahl{
		int z1;
		int z2;
		int z3;
		int z4;
		int z5;
		int z6;
	};

cpp:

#include ".\garantie.h"

#include <stdio.h>
#include <vector>

void main(){
	printf("Beginne mit Rechnen\n");
	using namespace std;

	std::vector<zahl> vVollSys;
	std::vector<int> vZahl;
	vVollSys.reserve(14000000);

	for(int i=1;i<50;i++){
		vZahl.push_back(i);
	}
	int a=0;
	int b=1;
	int c=2;
	int d=3;
	int e=4;
	int f=5;

	zahl z;

	z.z1 = vZahl[a];
	z.z2 = vZahl[b];
	z.z3 = vZahl[c];
	z.z4 = vZahl[d];
	z.z5 = vZahl[e];
	z.z6 = vZahl[f];
	vVollSys.push_back(z);

	while(vZahl[a] != vZahl[vZahl.size()-6]){

		if(vZahl[f]<vZahl[vZahl.size()-1])
               f=f+1;
            else
            {
				if(vZahl[e]<vZahl[vZahl.size()-2])
               {
                  e=e+1;
                  f=e+1;
               }
               else
               {
				   if(vZahl[d]<vZahl[vZahl.size()-3])
                  {
                     d=d+1;
                     e=d+1;
                     f=e+1;
                  }
                  else
                  {
					  if(vZahl[c]<vZahl[vZahl.size()-4])
                     {
                        c=c+1;
                        d=c+1;
                        e=d+1;
                        f=e+1;
                     }
                     else
                     {
						 if(vZahl[b]<vZahl[vZahl.size()-5])
                        {
                           b=b+1;
                           c=b+1;
                           d=c+1;
                           e=d+1;
                           f=e+1;
                        }
                        else
                        {
                           a=a+1;
                           b=a+1;
                           c=b+1;
                           d=c+1;
                           e=d+1;
                           f=e+1;
                        }
                     }
                  }
               }
            }

			z.z1 = vZahl[a];
	z.z2 = vZahl[b];
	z.z3 = vZahl[c];
	z.z4 = vZahl[d];
	z.z5 = vZahl[e];
	z.z6 = vZahl[f];
	vVollSys.push_back(z);
	}
	printf("Rechnen Fertig\n");
	printf("Das Ergebnis lautet: %d",vVollSys.size());
	getchar();

So, wenn ich das starte habe ich in ein paar sekunden das ergebnis. Was habe ich denn nur in java falsch gemacht, dass es nicht gehen will. Ist wirklich java für sowas die falsche programmiersprache ?

[JavaNewbie]

Und noch ganz nebenbei. Mein Taskmanager zeigt mit eine Speicherauslastung von 329.508K

[Gregor]

In C++ bist du geringfügig besser an die Sache herangegangen. Da hast du keinen Vektor von Vektoren, die alle viel zu lang sind, genommen, sondern du hast einen Vektor, in dem deine "zahl"-structs abgespeichert sind. Das ist zwar auch nicht gerade eine optimale Lösung (Warum sind da zum Beispiel lauter ints im struct? Das ist totale Platzverschwendung.), aber eine bessere, als mit den Vektoren.

Hättest du in Java etwas äquivalentes gemacht, nämlich statt dem struct eine Klasse geschrieben, die in etwa so aussieht:

public class Zahl
{
   public int z1;
   public int z2;
   public int z3;
   public int z4;
   public int z5;
   public int z6;
}

...dann würde der Speicherverbrauch bei etwa

14000000 * (4+8+6*4) = 504.000.000 Byte liegen. Der Speicherverbrauch käme deinen 329MB von der C++-Version also schon näher. Wenn du dir Gedanken bezüglich des Speicherverbrauchs machen würdest, dann könntest du nochmal ein ganzes Stück Speicherplatz einsparen, habe ich dir ja weiter oben in einer Rechnung demonstriert.

Du wirst in Java aber normalerweise etwas mehr Speicherverbrauch als in C++ haben, das bringt das Prinzip der Sprache mit sich. Dafür bekommst du Sprachmittel, wie Reflection, die du so in C++ erstmal nicht hast.

[Gregor]

Sgt. Nukem schrieb:

Gregor schrieb:

14000000 * (4+8+4+8+10*4) = 14000000 * 64 = 896.000.000 Byte.

Auch wenn ich die Rechnung nicht verstehe, das sind ja 850 MB!!

Ich gebe mal an, was was bei der Rechnung ist:

14000000 - Elemente hat das interne Array des äußeren Vektors.
4 - 4 Byte werden jeweils für die Referenz auf einen inneren Vektor benötigt.
8 - 8 Byte (in denen Informationen über die Klasse gespeichert werden) bringt in Java jedes Objekt als Overhead mit. Dies ist der Overhead der inneren Vektoren.
4 - Jeder innere Vektor hat intern ein Array. Dies ist die Referenz auf das Array.
8 - Dies ist der Objekt-Overhead des internen Arrays jedes inneren Vektors.
(vergessen: 4 - 4 Byte werden für die Speicherung der Länge jedes internen Arrays benötigt.)
10*4 - Das Array jedes inneren Vektors hat 10 Elemente, die jeweils Referenzen enthalten, also jeweils 4 Byte groß sind.

Das war's... alles klar jetzt?

[Gregor]

JavaNewbie schrieb:

Kann es vieleicht sein, dass ich das ganze anders programmieren sollte?

Gut möglich. Das kommt drauf an, was das Programm eigentlich leisten soll. Gib mal die Aufgabenstellung an.

[JavaNewbie]

Hallo an alle, erstmal vielen dank dass ihr mir versucht zu helfen.
Mein problem ist einfach folgendes. ich will von 49 zahlen alle möglichen 6er kombinationen haben. also: 1,2,3,4,5,6 dann 1,2,3,4,5,7 und so weiter. dann sind bei 49 zahlen fast 14000000 kombinationen. Jetzt brauche ich halt eine lösung um diese zu berechnen und irgendwo abzulegen. Ein Array oder sonst etwas. Jedoch muß es variabel sein da ich vieleicht morgen schon nur 30 zahlen testen will. Das ergebnis will ich dann ausdrucken oder analysieren. mehr nicht. Gibt es da eine schönere lösung als meine?

@Gregor
Das ich das in c++ besser gelöst habe, liegt daran dass ich c++ ein bißchen besser kann als Java. In java kannte ich nur so eine lösung für einen mehrdimensionalen Vektor. Du sagst aber dass man dass noch besser lösen könnte. Ich wäre echt neugierig wie man dass noch besser machen kann. Kannst du mir einen Tip geben?

[Sgt. Nukem]

JavaNewbie schrieb:

sind [...] fast 14000000 kombinationen.
[...]
Das ergebnis will ich dann ausdrucken

Ich hoffe Du hast schonmal bei einer Zeitungsdruckerei eine dieser 2-Tonnen-Papier-Rollen bestellt...

[Gast]

Schriftgröße 1

[JavaNewbie]

Hallo,
wie schön dass ihr auf so ein blödsinn immer eine antwort habt. Alles will ich nicht ausdrucken. Ich wollte es nur deshalb hinschreiben damit später nicht dummer antworten kommen wieso ich dass nicht direkt in eine datei ablege. Ich brauche es im speicher damit ich damit arbeiten kann. Mein problem ist nicht das papier sondern dass ich es zum laufen bekomme.

[Gregor]

JavaNewbie schrieb:

Hallo an alle, erstmal vielen dank dass ihr mir versucht zu helfen.
Mein problem ist einfach folgendes. ich will von 49 zahlen alle möglichen 6er kombinationen haben. also: 1,2,3,4,5,6 dann 1,2,3,4,5,7 und so weiter. dann sind bei 49 zahlen fast 14000000 kombinationen. Jetzt brauche ich halt eine lösung um diese zu berechnen und irgendwo abzulegen. Ein Array oder sonst etwas. Jedoch muß es variabel sein da ich vieleicht morgen schon nur 30 zahlen testen will. Das ergebnis will ich dann ausdrucken oder analysieren. mehr nicht. Gibt es da eine schönere lösung als meine?

@Gregor
Das ich das in c++ besser gelöst habe, liegt daran dass ich c++ ein bißchen besser kann als Java. In java kannte ich nur so eine lösung für einen mehrdimensionalen Vektor. Du sagst aber dass man dass noch besser lösen könnte. Ich wäre echt neugierig wie man dass noch besser machen kann. Kannst du mir einen Tip geben?

1. Ich habe schon längst angegeben, wie du deinen Speicherverbrauch auf etwa 300MB runterkriegst. Realisieren mußt du das schon selbst, ich bin nicht dein "Coder".

2. Ob es eine wirklich bessere Lösung gibt, hängt sehr davon ab, was genau du mit den Daten machen möchtest. Zum Beispiel wäre es interessant zu wissen, ob du deine "Analyse" vielleicht durchführen kannst, bevor die Zahlen in den Vektor kommen. Angenommen, du willst zum Beispiel in der Analyse Kombinationen herausfiltern, die von Lottospielern häufig genommen werden: Dann könntest du die Analyse für eine Kombination durchführen, bevor du sie in einem Vektor oder so speicherst. Die Kombinationen, die übrigbleiben würden, könntest du nach der Analyse abspeichern (oder drucken oder was auch immer). Das würde den Speicherverbrauch vermutlich um Größenordnungen senken.

[Sgt. Nukem]

JavaNewbie schrieb:

wie schön dass ihr auf so ein blödsinn immer eine antwort habt.

JavaNewbie schrieb:

Mein problem ist nicht das papier sondern dass ich es zum laufen bekomme.

Du willst das Papier zum Laufen bekommen..?!

[Codehure]

Hallo Leute!

Tja einen Speicher Überlauf muss man einfach in Java mal geschaft haben! Nur dann weiß man das man einen Fehler im Aufbau des Programmes hat.

Du benötigt nach meiner Rechnung ein Array, zum berechnen der Kominationen, ein Array für die Zuordung Ziffern zu den abzubildente Ziffern und einen Vektor für die Endablage.

Die Brute Fore Erzeugung der Kombinationen erledigen einige Schleifen und gut ist.

Der Speicher wird hauptsächlich nur zum Endlagern benutzt und das wars.

cu Codehure

PS: Code? Nö keine Lust. Aber denke doch mal an einen Tacho!

[Sgt. Nukem]

Hi.

Hatte gerade Langeweile und da ist mir Dein Problem nochmal eingefallen.

Hab' mir Deinen C++-Code geschnappt und versucht 1:1 nach Java umzusetzen.

Also bei mir läuft das ohne irgendwelche Heap-Tricksereien.

import java.util.ArrayList;

public class Permutation
{

	static class Zahl
	{
		int z1;
    	int z2;
    	int z3;
    	int z4;
    	int z5;
    	int z6;
    }

    public static void main(String[] args) throws Exception
    {
    	long Start = System.currentTimeMillis();

    	System.out.println("Beginne mit Rechnen\n");

		ArrayList<Zahl> vVollSys = new ArrayList<Zahl>(14000000);
		ArrayList<Integer> vZahl = new ArrayList<Integer>();

		for(int i = 1; i < 50; i++) vZahl.add(i);

		int a = 0;
 	    int b = 1;
    	int c = 2;
  		int d = 3;
  		int e = 4;
  	  	int f = 5;

  		Zahl z = new Zahl();

    	z.z1 = ((Integer)vZahl.get(a)).intValue();
    	z.z2 = ((Integer)vZahl.get(b)).intValue();
    	z.z3 = ((Integer)vZahl.get(c)).intValue();
    	z.z4 = ((Integer)vZahl.get(d)).intValue();
    	z.z5 = ((Integer)vZahl.get(e)).intValue();
    	z.z6 = ((Integer)vZahl.get(f)).intValue();
    	vVollSys.add(z);

    while(vZahl.get(a) != vZahl.get(vZahl.size()-6)){

        if((Integer)vZahl.get(f)<(Integer)vZahl.get(vZahl.size()-1))
               f=f+1;
            else
            {
                if((Integer)vZahl.get(e)<(Integer)vZahl.get(vZahl.size()-2))
               {
                  e=e+1;
                  f=e+1;
               }
               else
               {
                   if((Integer)vZahl.get(d)<(Integer)vZahl.get(vZahl.size()-3))
                  {
                     d=d+1;
                     e=d+1;
                     f=e+1;
                  }
                  else
                  {
                      if((Integer)vZahl.get(c)<(Integer)vZahl.get(vZahl.size()-4))
                     {
                        c=c+1;
                        d=c+1;
                        e=d+1;
                        f=e+1;
                     }
                     else
                     {
                         if((Integer)vZahl.get(b)<(Integer)vZahl.get(vZahl.size()-5))
                        {
                           b=b+1;
                           c=b+1;
                           d=c+1;
                           e=d+1;
                           f=e+1;
                        }
                        else
                        {
                           a=a+1;
                           b=a+1;
                           c=b+1;
                           d=c+1;
                           e=d+1;
                           f=e+1;
                        }
                     }
                  }
               }
            }

    z.z1 = ((Integer)vZahl.get(a)).intValue();
    z.z2 = ((Integer)vZahl.get(b)).intValue();
    z.z3 = ((Integer)vZahl.get(c)).intValue();
    z.z4 = ((Integer)vZahl.get(d)).intValue();
    z.z5 = ((Integer)vZahl.get(e)).intValue();
    z.z6 = ((Integer)vZahl.get(f)).intValue();
    vVollSys.add(z);
    }

    	System.out.println("Rechnen Fertig\n");
    	System.out.println("Das Ergebnis lautet: " + vVollSys.size());

    	long Ende = System.currentTimeMillis();

    	System.out.println("\nBenoetigt: " + (Ende - Start) + " Millisekunden");
	    System.in.read();

	}

}

Bei C++ hab' ich auch mal ein "long Start = timeGetTime()" eingebunden.

Ergebnis:

C++: (einfaches cl.exe)

Beginne mit Rechnen
Rechnen Fertig
Das Ergebnis lautet: 13983816
Benoetigt: 14260 Millisekunden

Speicherauslastung: 329.300 KByte (laut TaskManager)

Mit Optimierungen (/Ox /O2):
1346 Millisekunden

Am Speicherverbrauch ändert sich quasi nichts.

Java:
C:\Tools\JCreator\MyProjects\Permutation>java Permutation
Beginne mit Rechnen

Rechnen Fertig

Das Ergebnis lautet: 13983816

Benoetigt: 3685 Millisekunden

Speicherverbrauch: 63.056 KByte

[JavaNewbi]

Viele Vielen Dank Sgt. Nukem. Du hast mir das Leben gerettet. Ich habe das Theman fast schon abgeschrieben und haben es mit C++ weitergemacht. Jetzt hast du mich aber auf etwas neugierig gemacht. Wie hast du es denn geschafft den C++ code so zu optimieren dass du so eine wahnsinnsgeschwindigkeit bekommen hast. Das ist ja enorm an zeit die du sparst. Könntest du mir einen tip geben wir du das gemacht hast?

[JavaNewbi]

Hi,
da fällt mir ein. Wie komme ich denn an die Werte ran in dem Vektor. Wie soll ich zum beispiel aus der ersten Zeile den Wert der zahl2 bekommen?