[muscle] Re: Growing Win32 HANDLE count with repetive connection attempts

I have written a massive server<->client file transfer app using MFC and 
have not run into any problem... seems like you may not be freeing 
resources properly?

At 12:45 AM 10/6/2004, you wrote:
>We are using MUSCLE in a Windows XP environment. Our setup have a
>"Teacher PC" which holds the server. This computer will connect to one
>or more client "Student PC's" when the teacher want to start an
>exercise. The computers often resides in different rooms, and are not
>reachable for the teacher from where he sits. So for each exercise start
>we want all the clients to connect automatically. Technically starting
>the exercise means to start the server and connect the clients.
>
>Our current solution is that the clients will try to connect when they
>start up, eventually give up after a timeout (for example 2 seconds),
>and then try again. Like this they will connect automatically when the
>server starts, and when the server stop they will go back to the "try to
>connect" state.
>
>Problem is that after about 30 minutes with no connection (the teacher
>is having lunch and have stopped the exercise for example) the client
>hangs. Inspecting the task manager shows that the number of handles the
>client application holds grows for each connection attempt (about 2
>handles extra per attempt), and it seems that the application freezes
>when it reaches about 10 000 handles.
>
>Pseudo code for what the client do when it tries to connect is as follows:
>
>// This loop goes in the main client application, and will run from the
>application start to we have an
>// connection. When the server shuts down, the client will again enter
>this loop and try to connect.
>while ( bConnected ) {
>    bConnected = client->start( timeout = 2000 ); // Blocking
>}
>
>bool Client::start( timeout ) {
>
>     if ( ! _messageTranceiverThread ) {
>        _dataSignalHandle = CreateEvent( 0, 0, 0, 0);
>        _messageTranceiverThread = new Win32MessageTranceiverThread(
>_dataSignalHandle, true );
>     }
>
>     StartInternalThread( );
>
>     do {
>        check for connection
>        check for timeout
>     } while ( notConnected && time < timeout )
>
>     // We timed out. Stop the thread.
>     if ( timeout ) {
>        stop( );
>        return false;
>     }
>     // We have an connection
>     else {
>        return true;
>     }
>}
>
>Client::stop( ) {
>
>     SetEvent( _shutdownSignalHandle );
>
>     WaitForInternalThreadToExit( );
>}
>
>I have tried to check all the HANDLES we explicitly create. For the
>client there is only two HANDLES, the _shutdownSignalHandle (created in
>constructor and deleted in destructor of the Client), and the
>_dataSignalHandle (created each time we create the
>Win32MessageTranceiverThread, and passed to this thread with true as the
>second argument, which I believe mean that the thread will close the
>HANDLE).
>
>Have anyone experienced similar problems? Or is there some obvious
>mistake we do that causes this to happen? Or is there some other way to
>achieve the same automatic connect without starting and stopping the
>thread each time?
>
>Regards, Raymond.
>
>--
>Raymond Dahlberg
>Software Engineer Poseidon Simulation AS

Other related posts: