Is this a scaleable named pipe server implementation?

Question

Looking at this example of named pipes using Overlapped I/O from MSDN, I am wondering how scaleable it is? If you spin up a dozen clients and have them hit the server 10x/sec, with each batch of 10 being immediately after the other, before sleeping for a full second, it seems that eventually some of the instances of the client are starved.

Server implementation: http://msdn.microsoft.com/en-us/library/aa365603%28VS.85%29.aspx

Client implementation (assuming call is made 10x/sec, and there are a dozen instances). http://msdn.microsoft.com/en-us/library/aa365603%28VS.85%29.aspx

Answer 1

The fact that the web page points out that:

• The pipe server creates a fixed number of pipe instances.

and

• Although the example shows simultaneous operations on different pipe instances, it avoids simultaneous operations on a single pipe instance by using the event object in the OVERLAPPED structure. Because the same event object is used for read, write, and connect operations for each instance, there is no way to know which operation's completion caused the event to be set to the signaled state for simultaneous operations using the same pipe instance

you can probably safely assume that it's not as scalable as it could be; it's an API usage example after all; demonstration of functionality is usually the most important design constraint for such code.

If you need 12 clients making 10 connections per second then I'd personally have the server able to handle MORE than just 12 clients to allow for the period when the server is preparing for a new client to connect... Personally I'd switch to using sockets but that's just me (and I'm skewed that way because I've done lots of high performance socket's work and so have all the code)...