3. Zu viel Speicherverbrauch

Zu viel Speicherverbrauch

  • S

    Hey,
    ich hoffe ihr könnt mir helfen, ich such schon seit Tagen nach nem fehler in meinem Code. Ich hab einen Binärbaum, von dem ich in einem Array 1024 stück speicher. Ich hab das Gefühl es gibt irgendwo n Memory Leak oderso, weil ich laut Taskmanager etwa 119MB speicher für das Array brauch. Ich hab mal nachgerechnet, eigentlich müssten es "nur" so 24MB sein, da jeder Node des Trees 24byte groß sein müsste, jeder Tree 1022 Nodes haben sollte und es 1024 Trees gibt. Ich muss leider alles speichern, da ich die Daten sonst immer wieder neu erstellen müsste und das kostet Performance, die ich dringend brauche. Ich werd euch mal die Stellen ausem Code zeigen, die das Problem zu sein scheinen.

    //hier wird das Array geüllt, bt = new BinTree[1024] wird natürlich vorher //ausgeführt

for(int x1 = 0; x1 < 32; x1++)
{
     for(int y1 = 0; y1 < 32; y1++)
     {  
         bt[x1*32+y1] = BinTree(x1 * 16,y1 * 16);
     }
}

    //BinTree Constructor

BinTree::BinTree(int ox, int oy)
{
	int x[3] = {0,32,16};
	int y[3] = {0,0 ,16};
	NodeNull = BTNode(2,2,0,x,y,ox,oy);
	int x2[3] = {0,16,0};
	int y2[3] = {0,16,32};
	NodeOne = BTNode(2,0,2,x2,y2,ox,oy);
}

    //BTNode constructor alles was nicht vorher deklariert ist kommt aus BTNode

BTNode::BTNode(int nTris, char hyp,int ohyp, int x[3], int y[3],int ox, int oy)
{
	inds = new unsigned int[3];
	Hyp = hyp;

	int i1 = hyp;
	int i2 = (hyp+1)%3;
	inds[hyp] = (x[i1]+ox) * 513 + (y[i1]+oy);
	inds[i2] = (x[i2]+ox) * 513 + (y[i2]+oy);

	int nx = ((x[ohyp]+x[(ohyp+1)%3]) /2);
	int ny = ((y[ohyp]+y[(ohyp+1)%3]) /2);

	int i3 = (hyp+2)%3; 
	inds[i3] = (nx+ox) * 513 + (ny+oy);

	int nx2[3]; 
	int ny2[3]; 

	nx2[i1] = x[i1];
	nx2[i2] = x[i2];
	nx2[i3] = nx;

	ny2[i1] = y[i1];
	ny2[i2] = y[i2];
	ny2[i3] = ny;

	if(nTris < 512)
	{
		Childs = new BTNode[2];
		Childs[0] = BTNode(nTris*2,(hyp+1)%3,hyp,nx2,ny2,ox,oy);
		Childs[1] = BTNode(nTris*2,(hyp+2)%3,hyp,nx2,ny2,ox,oy);
	}
	else
	{
		Childs = NULL;
	}

	isActive = false;
}

    Ich hoffe ihr könnt was entdecken, ich fürchte schon wieder, dass es was ganz blödes ist, woran ich garnicht gedacht hab 😃 Wenn ihr noch was sehen wollt, sagt bescheid.

    m.f.g Luis

    0
  • V

    ohne jetzt irgendwas genaueres zu sehen, warum benutzt du keine smart pointer? dann hättest du kein problem mit irgendwelchen leaks.

    0
  • O

    wäre cool, zumidnest mal die Strukturen zu kennen...Code ohne Variablendefinition ist jetzt nicht so spannend.

    0
  • P

    Um MemLeaks zu sehen, wäre auch noch der Destruktor interessant. Z. B. hast du ein inds = new unsigned int[3]; Gibst du das später wieder frei? Und warum machst du da new? Du weißt doch die Anzahl: 3. Und die ist nicht gerade groß, mache dir doch einfach ein unsigned int inds[3] als Membervariable, oder gleich ein std::array<unsigned int,3> inds.

    0
  • M

    Hallo

    Als Hilfestellung, wenn du ein VC++ benutzt, könntest du folgenden Code am Anfang deiner main-Funktion einfügen, dann gibt der Debugger dir am Ende die nicht freigegebenen Blöcke aus, sowie ein bisschen Inhalt dazu:

    #if defined(_DEBUG)
  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_ALWAYS_DF); // | _CRTDBG_CHECK_CRT_DF);
#endif

    Danach musst du dann noch versuchen anhand des Inhalts die passenden Stellen zu finden. Ist zwar nicht so einfach, aber man weiß zumindest ob Speicher verloren geht.

    Eine Einschränkung ist zu nennen: Wenn der Speicher in einer externen Bibliothek erzeugt wird, und man vergisst diese freizugeben, kann der VC++ dies nicht erkennen.

    Mfg Marco

    0
Anmelden zum Antworten