Immer mehr private bytes :(

[Hello]

Ich bin mehr oder weniger Anfänger. Leider komme ich einfach nicht dahinter.

Vielleicht schaut sich jemand die Klassendefinition an.

Kann es an std::vector liegen? Jedoch mache ich alle 10 Sekunden .clear().

An was könnte es noch liegen?

[branleb]

Wenn du noch so ein anfänger bist, das du den debugger nicht mal
benutzten kannst/ willst?? dann wür dich auch net WinApi machen...

versuchs doch einfach mit nem Debugger..welche IDE/Compiler hastu denn ???

[Knuddlbaer]

Auf die schnelle sehe ich nichts in Deinem geposteten Code der Leaks verursachen könnte (überflogen). Es wird viel kopiert in der Klasse, eventuell versursacht der Client der Klasse die Leaks.

Aber generell solltest Du Dich mal mit der STL , referenzen und C++ ein wenig beschäftigen. Es gäbe einige dinge zu verbessern. Die FAQ und die Artikel (Forenübersicht, ziemlich weit unten) helfen Dir ideal für einen schnellen einstieg.

Memoryleaks lassen sich trotz Debugger nicht immer einfach finden und können auch für "nicht anfänger" problematisch zu finden sein.

[Hello]

Komisch ich finde es einfach nicht heraus. Der Debugger verwirrt mich. Leider stehe ich unter Zeitdruck (Ich möchte VC 1 retten :|)

Habe versucht, den Code zu optimieren.

#ifndef INCLUDED_SLOWBOB
#define INCLUDED_SLOWBOB

//// < I N C L U D E S > /////////////////////////
#include <windows.h>
#include <mmsystem.h>
#include <string>
#include <fstream>
#include <vector>

//// < C L A S S  SlowBob > //////////////////////
class SlowBob
{
	std::string windowTitle;

	HWND hWnd;
	HWND edit;
	HWND list;

	LRESULT currentRow;

	TCHAR        recvText[128];
	std::string  s;

	std::string kickText;

	short oldJoinedPlayers;
	short joinedPlayers;
	short bannedPlayers;

	struct oldJoinedPlayer
	{
		std::string ip;
		std::string id;
	}; oldJoinedPlayer oldJoinedPlayer[64];

	struct joinedPlayer
	{
		std::string ip;
		std::string id;
	}; joinedPlayer joinedPlayer[64];

	struct bannedPlayer
	{
		std::string ip;
	}; bannedPlayer bannedPlayer[1000];

	std::ifstream configFile;
	std::ifstream bannedFile;

	std::vector<std::string> configRow;
	std::vector<std::string> bannedRow;

	std::string row;

	std::vector<std::string> kickList;

	float interval;
	float current;
	float elapsed;
	float old;
public:
	SlowBob();
	~SlowBob();

	void Tick();
	void Check();
	void Kick();
	void SaveOld();
	void Clear();

	void getJoinedPlayers();
	void getJoinedPlayerIds();
	void getJoinedPlayerIps();
	void getBannedPlayerIps();

	void sendText(std::string);
	void kickPlayer(std::string);
};

#endif // INCLUDED_SLOWBOB

//// < I N C L U D E S > /////////////////////////
#include "SlowBob.h"

//// < C L A S S  SlowBob > //////////////////////
SlowBob::SlowBob()
{
	configFile.open("config.txt");
	bannedFile.open("banned.txt");

	// We need these files
	if(!configFile.is_open())
	{
		MessageBox(NULL, "Open config.txt failed!", "Error", MB_OK);
		PostQuitMessage(0);
		return;
	}
	if(!bannedFile.is_open())
	{
		MessageBox(NULL, "Open banned.txt failed!", "Error", MB_OK);
		PostQuitMessage(0);
		return;
	}

	// Read out all rows
	while(std::getline(configFile, row))
		configRow.push_back(row);

	windowTitle   = configRow[0];
	interval      = (float)atoi(configRow[1].c_str());
	if(interval < 1.0)
		interval = 1.0f;
	kickText      = configRow[2];

	// Get handles of vcded- window, its listbox and edit- field
	if(!(hWnd = FindWindow(0, windowTitle.c_str())))
	{
		MessageBox(NULL, "Window not found. Check server name!", "Error", MB_OK);
		PostQuitMessage(0);
		return;
	}
	edit = FindWindowEx(hWnd, 0, "Edit", 0);
	list = FindWindowEx(hWnd, 0, "ListBox", 0);

	currentRow = 98;

    Clear();

	getBannedPlayerIps();

	// Just spam a little so that we can begin with 99 rows, not very elegant
	for(int a = 0; a < 50; a++)
		sendText("fillup");
}

SlowBob::~SlowBob()
{
	configFile.close();
	bannedFile.close();
}

void SlowBob::Tick()
{
	current  = timeGetTime() / 1000.0f;
	elapsed  += (current - old);
	old      = timeGetTime() / 1000.0f;

	if(elapsed >= interval)
	{
		getJoinedPlayers();
		getJoinedPlayerIds();
		getJoinedPlayerIps();

		Check();

		if(kickList.size() > 0)
			Kick();

		SaveOld();
		Clear();

		elapsed = 0.0f;
	}

	Sleep(1);
}

void SlowBob::Check()
{
	// For every joined player
	for(int a = 0; a < joinedPlayers; a++)
	{
		// For every banned player
		for(int b = 0; b < bannedPlayers; b++)
		{
			// If joined player and banned player IP is the same
			if(!strcmp(joinedPlayer[a].ip.c_str(), bannedPlayer[b].ip.c_str()))
			{
				//if(b == (bannedPlayers - 1))
					// Add him to kick list
					kickList.push_back(joinedPlayer[a].id);
			}
			//else
				//b = bannedPlayers - 1;
		}
	}
}

void SlowBob::Kick()
{
	sendText("say \"{SlowBob} " + kickText + "\"");
	Sleep(1000);

	// For every player in kick- list
	for(unsigned int a = 0; a < kickList.size(); a++) 
		kickPlayer(kickList[a]);

	kickList.clear();
}

void SlowBob::SaveOld()
{
	memset(&oldJoinedPlayer, 0, sizeof(oldJoinedPlayer));

	// Save checked players for the next rounds to spare playerip commands
	for(int a = 0; a < 64; a++)
	{
		oldJoinedPlayer[a].ip = joinedPlayer[a].ip;
		oldJoinedPlayer[a].id = joinedPlayer[a].id;
	}

	oldJoinedPlayers = joinedPlayers;
}

void SlowBob::Clear()
{
	// Be sure to have a clean memory!
	memset(&recvText, 0, sizeof(recvText));
	memset(&joinedPlayer, 0, sizeof(joinedPlayer));
	memset(&row, 0, sizeof(row));

	configRow.clear();
	bannedRow.clear();
	kickList.clear();
}

void SlowBob::getJoinedPlayers()
{
	sendText("list");
	Sleep(1000);

	// Receive last row
	SendMessage(list, LB_GETTEXT, currentRow, (LPARAM)recvText);
	s = recvText;

	// If "Total players:" not found, jump a row higher and read out again
	while(s.find("Total players: ") == std::string::npos)
	{
		currentRow--;
		SendMessage(list, LB_GETTEXT, currentRow, (LPARAM)recvText);
		s = recvText;
	}

	// Save total players
	joinedPlayers = atoi((s.substr(15).c_str()));

	// Clear out to be on the save way
	memset(&recvText, 0, sizeof(recvText));

	// Set back to last row
	currentRow = 98;
}

void SlowBob::getJoinedPlayerIds()
{
	// For every joined player
	for(int a = 1, b = joinedPlayers - 1; a <= joinedPlayers, b >= 0; a++, b--)
	{
		// Get the row one above "Total players:" to begin readin' out player ID's
		SendMessage(list, LB_GETTEXT, currentRow - a, (LPARAM)recvText);
		s = recvText;

		// If "ping" is not found, it cannot be the right row
		while(s.find("ping") == std::string::npos)
		{
			currentRow--;
			SendMessage(list, LB_GETTEXT, currentRow - a, (LPARAM)recvText);
			s = recvText;
		}

		size_t pos = s.find("]");

		// Cut out the string from "[" + 1 till "]" - 1
		joinedPlayer[b].id  = s.substr(1, pos - 1);

		currentRow = 98;

		// Clear out to be on the save way
		memset(&recvText, 0, sizeof(recvText));
	}
}

void SlowBob::getJoinedPlayerIps()
{
	// For every joined player
	for(int a = 0; a < joinedPlayers; a++)
	{
		// For every old joined player
		for(int b = 0; b < oldJoinedPlayers; b++)
		{
			// If the player got checked already
			if(joinedPlayer[a].id == oldJoinedPlayer[b].id)
				joinedPlayer[a].ip = oldJoinedPlayer[b].ip;
		}

		if(strlen(joinedPlayer[a].ip.c_str()) < 7)
		{
			sendText("playerip " + joinedPlayer[a].id);
			Sleep(500);

		    SendMessage(list, LB_GETTEXT, currentRow, (LPARAM)recvText);
			s = recvText;

			// If all these strings are not found, we are definitely in the wrong row
			while(s.find("player #") == std::string::npos 
			   && s.find("]error:") == std::string::npos 
			   && s.find("playerip failed") == std::string::npos)
			{
				currentRow--;
				SendMessage(list, LB_GETTEXT, currentRow, (LPARAM)recvText);
				s = recvText;
			}

			if(s.find("playerip failed") != std::string::npos)
			{
				sendText("say \"{SlowBob} Could not seek IP. Penalty: Kick\"");
				Sleep(2000);
				kickPlayer(joinedPlayer[a].id);
			}
			// Finally, if we got the right row, save the god damned IP
			else if(s.find("player #") != std::string::npos)
				joinedPlayer[a].ip  = s.substr(s.find(":") + 2);
		}

		currentRow = 98;
	}
}

void SlowBob::getBannedPlayerIps()
{
	bannedPlayers = 0;

	while(std::getline(bannedFile, row))
	{
		bannedRow.push_back(row);
		bannedPlayers++;
	}

	for(unsigned int a = 0; a < bannedRow.size(); a++) 
		bannedPlayer[a].ip = bannedRow[a];
}

void SlowBob::sendText(std::string text)
{
	// Sends a string to the edit- field
	SendMessage(edit, WM_SETTEXT, 0, (LPARAM)text.c_str());
	// Don' t forget to simulate a keystroke
	SendMessage(edit, WM_KEYDOWN, VK_RETURN, 0);
}

void SlowBob::kickPlayer(std::string id)
{
	sendText("kick " + id);
	Sleep(200);
}

Ich wäre euch wirklich sehr dankbar. Ich hoffe einfach auf jemanden, der sich langweilt oder mir einfach helfen möchte ^^

(Bin auch für Verbesserungsvorschläge dankbar!)

MfG

[Spacelord]

Hi,
ohne mir das näher angeschaut zu haben.
Das muss nicht zwangsläufig nen Memory Leak sein.
Deine vectoren werden durch nen clear nicht kleiner.
Lass dir nach den 8 Stunden mal mit vector::capacity ausgeben wieviel Platz deine vectoren sich bis dahin schon reserviert haben.(oder lass es regelmässig in nen Logfile schreiben).

Gruß Spacelord

[Plotzenhotz]

Oder lass mal einfach laufen und guck was passiert. Ob sich der Wert irgendwo einpendelt nach ein paar Tagen. 2.4MB in 8 Stunden sind eigentlich nix.

[Hello]

Mhh ok mal sehn.

Dachte, durch .clear() wird die Liste gelöscht? Ich möchte ja nicht immer mehr hinzupushen, wäre ja kein Wunder, wenn dann der speicher hochgeht...

[Plotzenhotz]

@Hello: ja, durch .clear() wird "die Liste gelöscht", das stimmt schon. Danach ist der vector/die list/... "leer". Das heisst aber nicht notwendigerweise dass dort Speicher freigegeben wird. Wenn du 1 Million chars in einen vector tust, dann wird der >= 1MB Speicher brauchen. Wenn du den vector dann mit .clear() leer machst wird dieser Speicher nicht zurückgegeben. Wenn du dann allerdings nochmal bis zu 1 Million neue chars reintust wird der "alte Speicher" wiederverwendet - der Speicherverbrauch wächst also nicht unendlich an sondern stabilisiert sich wenn das max. an Elementen erreicht ist welches jemals *gleichzeitig* in diesem vector steckt.

Wenn du einen std::vector<T> wirklich leer machen willst, so dass auch der Speicher freigegeben wird, dann kannst du das normalerweise recht einfach so machen:

void foo()
{
    //...
    {
        std::vector<T> tmp(0);
        m_vector.swap(tmp);
    } // hier wird der Speicher zurückgegeben
    //...
}

Ich weiss nicht ob der Standard explizit garantiert dass dabei der Speicher freigegeben wird, aber ich weiss ganz sicher dass es in einigen Implementierungen funktioniert, und ich vermute in allen. Und diverse Garantien die der Standard vorschreibt (vector::swap muss in O(1) laufen, gleiche allocator vorausgesetzt) sprechen dafür dass es überall so ist.

[Hello]

Dankesehr!

Habe nur 3 std::vector im Programm und die werden immer wieder .clear() habs auch überprüft da is nix falsch.

Schaut euch doch mal bitte meine Klassendefinition an.

Was könnte noch so viel Speicher fressen?

Sind heute knapp 4MB geworden nach nur 6 Stunden. Sehr seltsam

[Simon2]

Solange Du nicht liest, was die Leute hier antworten, wirst Du Dein Problem wohl auch nicht gelöst bekommen.

.... aber für wen schreibe ich das hier eigentlich ? ...

Gruß,

Simon2.

[Hello]

Ich habe doch gelesen!

Es kann eigentlich nur bei std::vector zu viel Speicher verbraucht werden, oder? Wo sonst? Die nicht-arrays werden überschrieben... Und alle 3 vectoren cleare ich alle 10 Sekunden.

Ich verstehs einfach ned........

[Spacelord]

Du kannst deinen vector auch jede Sekunde clearen und er belegt trotzdem noch den gleichen Speicher!!
Nach oben hin verändert nen vector seine Größe dynamisch,nach unten hin nicht.Da musst du schon mit nem swap nachhelfen wie es dir Plotzenhotz schon gezeigt hat.
Was sagt dir capacity wenn dein Programm 8 Stunden gelaufen ist?
Lass das doch einfach in eine Datei schreiben.

Gruß Spacelord

[Hello]

Ja, aber, es ist doch so:

Zwei von 3 vectoren werden nur im Konstruktor aufgefüllt und danach nicht mehr "gepusht". (configRow und bannedRow, das sind die Zeilen der Textdateien)

kickList wird bei Bedarf mit bis zu maximal 64 Elementen gepusht. Danach wird .clear() aufgerufen. Und nach 10 Sekunden werden wieder maximal 64 Elemente gepusht.

Was also reserviert sich den ganzen Speicher...

[Knuddlbaer]

Nun, es wird ja auch jemanden geben, der Deine Klasse einsetzt. Hast Du diese Umgebung abgesucht ?

@Plotzenhotz registrier Dich doch mal bitte, dann weiss man wenigstens das immer der gleiche schreibt =o)

[Hello]

Hello!

Nein, bis jetzt habe nur ich das Programm so lange am laufen.
Wird auf nem anderen PC aber ned anders sein, denke ich.

Leider muss ich des öfteren die Anwendung neu starten, wenn ich IP's zur Textdatei adde. Aber ich werde versuchen, das Teil mal wirklich lange laufen zu lassen. Wiegesagt, an den vectoren liegt es nicht. kickList fasst maximal 64 Player-ID's.

Ach, noch eine kleine Frage: Wie lange läuft Windows XP Prof. ohne Absturz? Hab mal gehört, das soll Begrenzt sein. Was für'n Beschiss!

[Knuddlbaer]

Der von Dir gezeigte Quellcode hat keinen gültigen Einstiegspunkt. Also wird es noch etwas drum herum geben was die Klasse benutzt.

Generell kann man nur jemanden helfen, der auch hilfe haben will.

[Hello]

Sorry!

Aber da passiert nichts besonderes.

//// < M A I N  F U N C T I O N > ////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int)
{
	Window& window = Window::getInstance();
	window.Init(hInstance);
	window.Create();

	SlowBob slowBob;

	MSG msg = {0};

	while(msg.message != WM_QUIT)
	{
	    if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
        }
		else
			slowBob.Tick();
    }

	window.Destroy();

	return 0;
}

[idefix]

kann es sein das dein ListCtrl den Speicher 'frist' , weil nach 6 oder 8 Stunden tausende Zeilen drin stehen?

[Nanyuki]

Wenn ein Programm immer mehr Speicher verbraucht, dann ist es in der Regel eine gute Idee, sich mal anzuschauen, was im Speicher nach einer Weile so drinsteht.
Mach einfach ein Memory Dump mit einem Programm wie T-Search.

[Hello]

Damit hab ich nix am Hut. Ich werd's dennoch probieren.

Wiegesagt, ich habe nur 3 std::vector's. Es kann ja nur an denen liegen, alles andere wird überschrieben!

configRow für alle Zeilen in config.txt
bannedRow für alle Zeilen in banned.txt

ABER: Diese vectoren werden nur im Konstruktor aufgefüllt, danach passiert mit denen KEIN push_back mehr.

Der letzte vector ist kickList, diese wird bis zu maximal 64x gepusht, und alle 10 Sekunden werden die Elemente wieder entfernt.

Unverständlich