HawtDispatch Event Based IO
My previous post promised a follow up to explain how network IO events are handled by HawtDispatch. Before I get into the details, I urge you to read Mark McGranaghan’s post on Threaded vs Evented Servers. He does an excellent job describing how event driven servers scale in comparison to threaded servers. This post will try to highlight how HawtDispatch provides an excellent framework for the implementation of event based servers.
When implementing event based servers, there are generally 2 patterns used, the reactor pattern and the proactor pattern. The reactor pattern can be though of as being a synchronous version of the proactor pattern. In a reactor pattern IO events are serviced by the thread in the IO handling loop. In a proactor pattern the thread processing the IO event loop passes off the the IO event to another thread for processing. HawtDispatch can support both styles of IO processing.
HawtDispatch uses a fixed sized thread pool sized to match the number of cores on your system. Each thread in the pool runs an IO handling loop. When a NIO event source is created, it gets assigned to one of the threads. When network events occur the source causes callbacks to occur against on the dispatch queue targeted in the event source. Typically that target dispatch queue is set to a serial queue which the application uses to handle the network protocol. Since it’s a serial queue, the handling of the event can be done in a thread safe way. The proactor pattern is being used since the serial queue can execute in any of the threads in the thread pool .
To use the reactor pattern, HawtDispatch supports ‘pinning’ the serial queue to a thread. When a dispatch source is created on a pinned dispatch queue, then the event source gets registered against the same ‘pinned’ thread. The benefit of the reactor pattern is that it avoids some of cross thread synchronization needed for the proactor pattern and provides cheaper GCs. The down side to the reactor pattern is that you may have to manage reblanacing network sources across all the available thread. Lucky HawtDispatch does support moving pinned dispatch queues and sources to different threads.