Memory leak in multithreaded program

[Danja91]

Hello,

A while ago I wrote a program to interface with a scientific instrument. The program works as intended but if I leave it on for long periods of time it behaves sluggishly, and task manager shows it using hundreds of MB of memory (it should use very little). I am wondering if someone could look at a stripped down version of my code showing the bare essentials and suggest what I could be doing incorrectly?

The basic strategy of the program is as follows:
- to send a command to the instrument, I have to send it a windows message
- to obtain a response from the instrument, I have to listen for a windows message
- I need to simultaneously listen for status updates while executing a function (the function depends on those status updates to execute correctly); therefore, I need to multithread
- I wrap the variables that I need in the new thread in a mutex to avoid access violations

The code looks as follows:

#includes here

// status updates
#define IDT_CHECKSTATUS 333
#define IDT_REFRESHSCREEN 334
bool receiving_data = false; // Flag indicates that next message from instrument will contain data rather than status update

HANDLE StatusMutex; // multithreading

// MAIN FUNCTION

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	// window initialization, etc is here
	
	// set timer for CheckStatus (function that asks instrument to report its status)
	TimerID = SetTimer(main_hwnd,IDT_CHECKSTATUS, (UINT) 0.01* 1000, NULL); 
	// set timer to refresh screen 
	SetTimer(main_hwnd, IDT_REFRESHSCREEN, 1 * 1000, NULL);

	while(GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return Msg.wParam;
}

// EVENT HANDLER
LRESULT CALLBACK WndProc(HWND main_hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
		// Omitting some standard messages such as WMCreate
		case WM_PAINT:
			// output the status to the window
			{
				RECT rcClient;
				PAINTSTRUCT ps;
				HDC hdc = BeginPaint(main_hwnd, &ps);

				GetClientRect(main_hwnd, &rcClient);

				DrawStatusUpdate(hdc, &rcClient, g_hfFont);

				EndPaint(main_hwnd, &ps);
			}
			break;
		
		case WM_TIMER: // Timer has ticked!
		{
			switch (wParam) 
			{ 
			case IDT_CHECKSTATUS: 
				{
					CheckStatus(main_hwnd); // asks instrument for its status using current thread (no new thread created)
					// Some other maintenance work here
					break;
				}

			case IDT_REFRESHSCREEN: 
				InvalidateRect(main_hwnd, NULL, FALSE); // cause a paint message
				break; 
			} 
		}
		break;
		
		case WM_COPYDATA: // CopyDataStruct incoming from the instrument!
		{
			// Some pre-processing to obtain string str from the WM_COPYDATA lpdata
			
			ParseStatus(str, main_hwnd); // interprets message as status update or data

		}
		break;
		
		case WM_COMMAND: // One of these (the one below) sends a command to the instrument IN A NEW THREAD
			switch(LOWORD(wParam))
			{
				case ID_FILE_EXECUTEPROCEDURE:
				{
					exec_Parms *To_Pass = new exec_Parms();
					To_Pass->hwnd = main_hwnd;
					To_Pass->parsed_Commands = parsed_Commands;
					CreateThread(NULL, 0,SendRequestToInstrument, To_Pass, 0, NULL); // SendRequestToInstrument is the function being executed in a new thread
				}
				break;
			}
		
	}
	return 0;
}

void ParseStatus(const char* status, HWND main_hwnd) 
{
	// Some string formatting here
	// create  a  vector<std:string> called "info", populate it with components of the status string
	
	if ( (PSEUDOCODE) status string actually contains a status, rather than data)
	{
		// mutex
		StatusMutex = CreateMutex( 
			NULL,              // default security attributes
			FALSE,             // initially not owned
			NULL);             // unnamed mutex

		if (StatusMutex == NULL) 
		{
			printf("CreateMutex error: %d\n", GetLastError());
			return;
		}

		DWORD dwWaitResult = WaitForSingleObject( 
			StatusMutex,    // handle to mutex
			INFINITE);  // no time-out interval
		
		switch (dwWaitResult) 
		{
			// The thread got ownership of the mutex
		case WAIT_OBJECT_0: 
		
			// Code here extracts information from the info vector & assigns it to global variables used elsewhere in the program
			
			// Release ownership of the mutex object
			if (! ReleaseMutex(StatusMutex)) 
			{ 
				// Handle error.
			} 
			break; 

			// The thread got ownership of an abandoned mutex
			// The database is in an indeterminate state
		case WAIT_ABANDONED: 
			return; 
		}
	}
	
	else // status string contains DATA rather than a status update
	{
		ParseData(info) // how this works not important
		receving_data = false; // flag: data reception is complete.
	}
	
	return;
}

void SendRequestToInstrument(string command)
{
	receiving_data = true; // Flag to expect incoming data and wait to receive it before continuing
	
	// code to send data to the instrument goes here
	
	while (receiving_data == true) { Sleep(100); } // Pause execution of this thread until event handler has acknowledged receipt of data
	
	// do things with the data
}

Is there anything apparently incorrect with this code?

[Codeplug]

Each call to CreateMutex() should have a corresponding CloseHandle() call.

I also don't see the "delete" of "exec_Parms".

gg