Seeking CSS Enlightenment

Nowadays it is hard to find software developer or web-designer that doesn't know what CSS is all about.

I must say that until recently, I didn't realize what potential CSS has. I found a place in the web that helps people become Enlightened with CSS power.

Please, welcome to the Zen Garden.

In the above mentioned CSS garden the layout of the same markup or content is changed via different styles applied.

Sample code for TCP server using completion ports

As I have promised in my previous post I'm presenting sample code of TCP server that is receiving variable length messages in specific format. Data transfer protocol implies that network messages consist of prefix holding body size and body part.

At first, code defines application state object

/// 

/// Server state holds current state of the client socket
/// 
class AsyncServerState
{
   public byte[] Buffer = new byte[512]; //buffer for network i/o
   public int DataSize = 0; //data size to be received by the server
  
   //flag that indicates whether prefix was received
   public bool DataSizeReceived = false;

   public MemoryStream Data = new MemoryStream(); //place where data is stored
   public SocketAsyncEventArgs ReadEventArgs = new SocketAsyncEventArgs();
   public Socket Client;
}

To preserve application state between async operations SocketAsyncEventArgs.UserToken is used.

/// 

/// Async server sample, demonstates usage of XxxAsync methods
/// 
class AsyncServer
{
  Socket listeningSocket;
  List messages = new List();
  const int PrefixSize = 4;
      
  SocketAsyncEventArgs acceptEvtArgs;
        
  public AsyncServer()
  {
     this.listeningSocket = new Socket(AddressFamily.InterNetwork,
              SocketType.Stream, ProtocolType.Tcp);
     this.acceptEvtArgs = new SocketAsyncEventArgs();
  }
      
  public void Start(IPEndPoint listeningAddress)
  {
     acceptEvtArgs.Completed += new EventHandler(
                                        Accept_Completed);

     listeningSocket.Bind(listeningAddress);
     listeningSocket.Listen(1);

     ProcessAccept(acceptEvtArgs);
  }

  /// 

  /// Accept completion handler
  /// 
  void Accept_Completed(object sender, SocketAsyncEventArgs e)
  {
     if (e.SocketError == SocketError.Success)
     {
        Socket client = e.AcceptSocket;
        AsyncServerState state = new AsyncServerState();
        state.ReadEventArgs.AcceptSocket = client;
        state.ReadEventArgs.Completed += new EventHandler(
                                                 IO_Completed);
        state.ReadEventArgs.UserToken = state;
        state.Client = client;
        state.ReadEventArgs.SetBuffer(state.Buffer, 0, state.Buffer.Length);

        if (!client.ReceiveAsync(state.ReadEventArgs))
        {   //call completed synchonously
            ProcessReceive(state.ReadEventArgs);
        }
     }
     ProcessAccept(e);
  }

  private void ProcessAccept(SocketAsyncEventArgs e)
  {
      e.AcceptSocket = null;
      if (!listeningSocket.AcceptAsync(acceptEvtArgs))
      {   //operation completed synchronously
          Accept_Completed(null, acceptEvtArgs);
      }
  }

  /// 

  /// Genereic I/O completion handler
  /// 
  void IO_Completed(object sender, SocketAsyncEventArgs e)
  {
      switch (e.LastOperation)
      {
          case SocketAsyncOperation.Receive:
              ProcessReceive(e);
              break;
          case SocketAsyncOperation.Send:
              ProcessSend(e);
              break;
          default:
              throw new NotImplementedException("The code will "
                   +"handle only receive and send operations");
      }
  }

  /// 

  /// In future will process server send operations
  /// 
  private void ProcessSend(SocketAsyncEventArgs e) { }

  /// 

  /// Implements server receive logic
  /// 
  private void ProcessReceive(SocketAsyncEventArgs e)
  {
      //single message can be received using several receive operation
      AsyncServerState state = e.UserToken as AsyncServerState;

      if (e.BytesTransferred <= 0 || e.SocketError != SocketError.Success)        {            CloseConnection(e);        }        int dataRead = e.BytesTransferred;        int dataOffset = 0;        int restOfData = 0;         while (dataRead > 0)
      {
          if (!state.DataSizeReceived)
          {
              //there is already some data in the buffer
              if (state.Data.Length > 0)
              {
                  restOfData = PrefixSize - (int)state.Data.Length;
                  state.Data.Write(state.Buffer, dataOffset, restOfData);
                  dataRead -= restOfData;
                  dataOffset += restOfData;
              }
              else if (dataRead >= PrefixSize)
              {   //store whole data size prefix
                  state.Data.Write(state.Buffer, dataOffset, PrefixSize);
                  dataRead -= PrefixSize;
                  dataOffset += PrefixSize;
              }
              else
              {   // store only part of the size prefix
                  state.Data.Write(state.Buffer, dataOffset, dataRead);
                  dataOffset += dataRead;
                  dataRead = 0;
              }

              if (state.Data.Length == PrefixSize)
              {   //we received data size prefix
                  state.DataSize = BitConverter.ToInt32(state.Data.GetBuffer(), 0);
                  state.DataSizeReceived = true;

                  state.Data.Position = 0;
                  state.Data.SetLength(0);
              }
              else
              {   //we received just part of the headers information
                  //issue another read
                  if (!state.Client.ReceiveAsync(state.ReadEventArgs))
                      ProcessReceive(state.ReadEventArgs);
                      return;
              }
          }

          //at this point we know the size of the pending data
          if ((state.Data.Length + dataRead) >= state.DataSize)
          {   //we have all the data for this message

              restOfData = state.DataSize - (int)state.Data.Length;

              state.Data.Write(state.Buffer, dataOffset, restOfData);
              Console.WriteLine("Data message received. Size: {0}",
                                    state.DataSize);

              dataOffset += restOfData;
              dataRead -= restOfData;

              state.Data.SetLength(0);
              state.Data.Position = 0;
              state.DataSizeReceived = false;
              state.DataSize = 0;

              if (dataRead == 0)
              {
                  if (!state.Client.ReceiveAsync(state.ReadEventArgs))
                      ProcessReceive(state.ReadEventArgs);
                      return;
              }
              else
                  continue;
          }
          else
          {   //there is still data pending, store what we've
              //received and issue another BeginReceive
              state.Data.Write(state.Buffer, dataOffset, dataRead);

              if (!state.Client.ReceiveAsync(state.ReadEventArgs))
                  ProcessReceive(state.ReadEventArgs);

              dataRead = 0;
          }
      }
  }

  private void CloseConnection(SocketAsyncEventArgs e)
  {
      AsyncServerState state = e.UserToken as AsyncServerState;

      try
      {
          state.Client.Shutdown(SocketShutdown.Send);
      }
      catch (Exception) { }
          
      state.Client.Close();
  }
}

Code sample above gives basic idea how completion ports asynchronous pattern can be used in TCP server development.

High peformance TCP server using completion ports

Completion ports were first introduced in Windows NT 4.0. This technology makes simultaneous asynchronous I/O possible and extremely effective. When building high performance network software one has to think of effective threading model. Having too many or too little server threads in the system can result in poor server performance.

The goal of a server is to incur as few context switches as possible by having its threads avoid unnecessary blocking, while at the same time maximizing parallelism by using multiple threads. The ideal is for there to be a thread actively servicing a client request on every processor and for those threads not to block if there are additional requests waiting when they complete a request. For this to work correctly however, there must be a way for the application to activate another thread when one processing a client request blocks on I/O (like when it reads from a file as part of the processing). (read more...)

Smart reader may admit that I/O completion ports (IOCP) are not directly available in .NET. Well, that was pure truth until SP1 of .NET 2.0. From .NET 2.0 SP1 this marvelous technology can be accessed using following Socket class methods:

• AcceptAsync
• ConnectAsync
• DisconnectAsync
• ReceiveAsync
• SendAsync
• and other XxxAsync methods

In one of my previous posts about receiving variable length messages I used BeginXXX/EndXXX asynchronous approach. Main drawback of this approach is presence of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. That is because BeginXXX/EndXXX design pattern currently implemented by the System.Net.Sockets.Socket class requires a System.IAsyncResult object be allocated for each asynchronous socket operation.

Completion port approach on the other hands avoids the above mentioned problems altogether. Asynchronous operations are described by instances of SocketAsyncEventArgs. These objects can be reused by the application, more over, application can create as many SocketAsyncEventArgs objects that it needs to perform well under sustainable load.

The pattern for performing an asynchronous socket operation with this class consists of the following steps:

1. Allocate a new SocketAsyncEventArgs context object, or get a free one from an application defined pool
2. Set properties on the context object to the operation about to be performed (the completion callback method, the data buffer, the offset into the buffer, and the maximum amount of data to transfer, for example).
3. Call the appropriate socket method (XxxAsync) to initiate the asynchronous operation
4. If the asynchronous socket method (XxxAsync) returns true, in the callback, query the context properties for completion status
5. If the asynchronous socket method (XxxAsync) returns false, the operation completed synchronously. The context properties may be queried for the operation result
6. Reuse the context for another operation, put it back in the pool, or discard it

In How to Transfer Fixed Sized Data With Async Sockets I've presented server code that uses BeginXXX/EndXXX model for data receive handling. In the next post I'll show how that code can be rewritten to use IOCP server model.
Sample code of IOCP based TCP server