Good, glad you are getting somewhere.

Yes your book is half right - it is 5 pending requests max on Workstation
class OS - including XP Pro. One of the ways Microsoft forces you to buy a
server OS if you want to do high capacity server stuff. Of course if your
clients connect and then stay connected (even if there are 1000's of them)
it might not be the issue you think - as long as they don't all try to
connect simultaneously.

You really should try the threadpool as soon as possible - to see how it
reacts to your large workload. Like I mentioned before, you can not use
BeginAccept in combination with a large workload - you have to use a
dedicated thread to do the Accepting, then pass it off into the Threadpool
via BeginReceive. If your connection requests are even burstier, you might
find you need to use a dedicated thread on Accept, and put the accepted
sockets into a queue where another thread pulls them out and puts them into
the Threadpool - there is a bit of overhead on calling BeginReceive compared
to just adding an object into a queue. This might sound like a lot of work
but it enables you to keep up with a flood of requests. Of course, given
enough requests you can still overwhelm the server. At that point more
hardware is needed - dual processor or more servers with a load balancer in
front.

As far as garbage collection killing things, I have done some (soft)
realtime (100ms cycle) on XP with .NET to error-proof a manufacturing
process. I am handling hundreds of packets/sec of data going in/out to
physical I/O on ethernet, running logic to make decisions, logging to
database etc - runs about 4% CPU usage on a P4-2.4. Due to the large volume
of small objects (buffers etc), a Generation 0 collection occurs every
single second!!! This takes about 0.07ms. A full Garbage collection occurs
every 17 seconds. It takes about 0.7ms. That said, my data size is only
about 26MB total and remains constant. Note that I don't ever call the
Garbage Collector myself - its running this often on its own. This is up
for months at a time, only down for changes - no crashes :-), I have had no
issues with memory leaks or failing to collect garbage or the garbage
collector stalling this process. It doesn't happen.

As long as you don't hang onto object longer than needed I don't think it
will be an issue for you. If you are going to make lots of garbage you need
to have it be short-lived where its cheap to get rid of (Gen 0). The
alternative is to reuse buffers - which end up in Gen 2 eventually. I have
mixed feelings on the buffer reuse idea since Gen 2 collections are so much
more expensive than Gen 0 ones.

That's about it for my thoughts.
Tom








[quoted text, click to view]
problem:

Dear All,


I developed Asynchronous socket programme with C#. It listens the network
at specific ports and handle IP message requests coming from that port and
the hardware that is used to deploy this application is quite strong.It has
4 IBM processor and 2 GB memory. At the begining i checked the task
manager and the memory usage was 7.100 K . So far, everything is OK. But
after 2 hours , i get 7600 requests , i checked the task manager again and
i was shocked ! The memory usage was about to 38.000 K ! And the response
time had increased so much (around 20 sec).
I have got serious performance problem and I haven't found source of
this problem. I close the connections and database objects and sockets
when they are carefully. Is it about memory retention ? Are CLR and
garbage collection suspicious ? What do i have to do ?


Here is the code that i implemented based on microsoft advices.

Best regards,
Onder OZCAN
Ankara, TURKEY






// Begin to listen
protected void StartListening()
{
try
{
// Bind the socket to the local endpoint and listen for incoming
connections.
m_listenerSocket.Bind(m_localEndPoint);
m_listenerSocket.Listen(m_pendingConnection);

statusBar1.Text="... Waiting for a connection at port: " +
m_port.ToString();

while (true)
{
// Set the event to nonsignaled state.
allDone.Reset();

// Start an asynchronous socket to listen for connections.
m_listenerSocket.BeginAccept(new
AsyncCallback(this.BeginAcceptCallback),m_listenerSocket);

// Blocks current thread until the current WaitHandle receives a
signal.
// Moreover, this statement ensures to avoid infinite loop
allDone.WaitOne();
}
}
catch (Exception e)
{
oLog.logError("Error in StartListening(): " + e.Message,
CCnfgMain.APPNAME, EventLogEntryType.Error);
m_listenerSocket.Shutdown(SocketShutdown.Both);
m_listenerSocket.Close();
MessageBox.Show("Socket Başlatma Hatası: " + e.Message + "\n
ATM Listener Yeniden Başlatılmalıdır !..." , " -
StartListening - ");
}
}


// Accept incoming socket connection requests asynchronously
protected void BeginAcceptCallback(IAsyncResult p_IAsyncResult)
{
Socket v_listenerSocket=null ;
Socket v_handlerSocket=null ;
StateObject state=null ;

try
{
// Signal the main thread to continue.
allDone.Set();

// Get the socket that handles the client request.
v_listenerSocket = (Socket) p_IAsyncResult.AsyncState;
v_handlerSocket = v_listenerSocket.EndAccept(p_IAsyncResult);

// Create the state object.
state = new StateObject();
state.workSocket = v_handlerSocket;

if (v_handlerSocket.Connected)
{
//Begin to receive client's data
v_handlerSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize,
0,
new AsyncCallback(this.BeginReceiveCallback), state);
}
else
{
// remote device is not connected
v_handlerSocket.Shutdown(SocketShutdown.Both);
v_handlerSocket.Close();
}
}
catch (Exception e)
{
oLog.logError("Error in BeginAcceptCallback(): " + e.Message
,CCnfgMain.APPNAME, EventLogEntryType.Error);
// v_handlerSocket.Shutdown(SocketShutdown.Both);
v_handlerSocket.Close();
MessageBox.Show("BeginAcceptCallback Error: " + e.Message , " -
BeginAcceptCallback - " );
}
}


// Read incoming socket connection requests asynchronously
protected void BeginReceiveCallback(IAsyncResult p_IAsyncResult)
{
string content ="";
string strResponse ="";
int bytesRead;
string v_msgIn;
string v_msgID;

StateObject state=null ;
Socket v_handlerSocket=null ;

try
{
// Retrieve the state object and the handler socket
// from the asynchronous state object.
state = (StateObject) p_IAsyncResult.AsyncState;
v_handlerSocket = state.workSocket;

// Read data from the client socket.
// return value : The number of bytes received
bytesRead = v_handlerSocket.EndReceive(p_IAsyncResult);

if (bytesRead > 0)
{
#region "Pozitif Data Stream (bytesRead >0)"

// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));

// Check for end-of-file tag. If it is not there, read more data.
content = state.sb.ToString();

// pure incoming mesaage
v_msgIn = state.sb.ToString().Trim(new
char[]{'\x02','\x00','\x03'});
v_msgIn = v_msgIn.TrimStart(new char[]{'.'});
v_msgIn = v_msgIn.TrimEnd(new char[]{'.'});
txtReceived.Text += v_msgIn + "\n";

// get the msgid
v_msgID =
v_msgIn.Substring(CCnfgMain.MSG_ID_OFF,CCnfgMain.MSG_ID_OFFLNG).ToUpper();

//if client data contains "<EOF>" string , it is clear that the data
is totally received
if ( true )
{
// just echo incoming message
strResponse = v_msgIn ;

if (v_handlerSocket.Connected)
{
txtSent.Text +=strResponse + "\n";

if (v_msgID=="001" || v_msgID=="002")
{
strResponse ='.'.ToString() + strResponse + '.'.ToString() +
'.'.ToString();
}
else
{
strResponse ='\x02'.ToString() + strResponse +
'\x03'.ToString();
}

// Echo the data back to the client.
Send(v_handlerSocket,strResponse);
}
else
{
// not connected
v_handlerSocket.Shutdown(SocketShutdown.Both);
v_handlerSocket.Close();
}
}
else
{
if (v_handlerSocket.Connected)
{
// Not all data received. Get more.
v_handlerSocket.BeginReceive(state.buffer, 0,
StateObject.BufferSize, 0,
new AsyncCallback(this.BeginReceiveCallback), state);
}
else
{
// not connected
v_handlerSocket.Shutdown(SocketShutdown.Both);
v_handlerSocket.Close();
}
}
#endregion
}
}
catch (Exception e)
{
oLog.logError("Error in BeginReceiveCallback(): " +
e.Message,CCnfgMain.APPNAME , EventLogEntryType.Error);
// v_handlerSocket.Shutdown(SocketShutdown.Both);
v_handlerSocket.Close();
MessageBox.Show("BeginReceiveCallback Error: " + e.Message , " -
BeginReceiveCallback - ");
}
}


// Send the response to the caller
protected void Send(Socket p_handler, String p_data)
{
byte[] byteData ;

try
{
// Convert the string data to byte data using ASCII encoding.
byteData = Encoding.ASCII.GetBytes(p_data);

if (p_handler.Connected)
{
// Begin sending the data to the remote device.