6.7 - Potentially faster code, in some circumstances...
I hinted at the end of the last post that the 6.7 release might increase performance a little. Well, whilst the bulk of the changes in 6.7 are purely code cleaning and the removal of legacy support there is a fairly major functional change as well.
In most situations references or pointers to I/O buffers have been replaced with smart pointers. This change may cause some issues during an upgrade as you need to change some function signatures from
IBuffer refs to
CSmartBuffers. The advantage is that in many servers there will no longer be any need for buffer reference counting during normal I/O operations.
The Server Framework relies on reference counting to keep the objects that are used during the asynchronous operations alive until those operations complete. So we increment a counter on the socket object and also on the buffer object when we initiate an operation and then decrement the counters when the operation completes. I’m sure there are other ways to manage the object lifetime but this has worked well for us.
The problem is that these increments, although they look like cheap operations, can be quite expensive, especially on NUMA hardware.
Whilst there’s not much we can do about the reference count on the socket object, the buffer doesn’t really need to be reference counted most of the time. Or, more’s the point. The initial reference can (and should) be passed along rather than each stage taking and releasing its own reference. With a buffer you generally only want to be accessing it from one thread at a time and so you allocate it and then issue an operation and pass the reference you have off to the operation. When the operation completes the code captures the reference and takes ownership of it and then the buffer can be processed. If you’re lucky you can then use the same buffer for a response to the operation and pass it back to the framework again.
This requires a few changes to your code but it’s fairly straight forward. Your
OnReadCompleted() handler will give you a
CSmartBuffer and if you want to retain ownership of it after the handler returns then you simply need to detach the buffer from the
CSmartBuffer you were given.
This is only “potentially faster” as it really depends on the structure of your server and how you deal with our I/O buffers but the framework is no longer standing in the way of this kind of optimisation, and we’ve removed a couple of reference adjustments in the normal operation flow.