MSDN Magazine - October 2007 - (Page 55)

class application that is trying to process numerous client requests, the thread pool enables the preferred server concurrency model for the Windows platform, which is to process as many requests concurrently as there are processors in the system. One alternative model I’ve seen developers try is to dedicate one thread for each client being serviced, but this model does not scale well with a large number of clients. Not only do the large number of threads consume significant resources, but the cost of context switching between them becomes significant and impacts the overall quality of service each client receives. The new thread pool component addresses a number of limitations of the legacy thread pool. For example, the new thread pool lets you create multiple thread pools per process, while the old model allowed only one. This lets you isolate the tasks the application performs by some chosen criteria. For example, suppose you’re writing a distributed server application that is going to use the thread pool to process asynchronous I/O completions on network connections. The network connections are of two types, one from a client application and the second from other instances of the server application running on different computers. Let’s further assume that you have to support a large number of simultaneous client connections per server and that the number of client requests is much greater than server-to-server connections, but the server-to-server connections have a higher priority. When both client and server network connections are processed on a single thread pool, there is a single queue to which all the completion notifications are queued. This means that an I/O completion from a server connection will not be processed until all I/O completions in front of it in the queue are processed, including those from any clients. This can result in significant delays in processing server connections when the system is under heavy client load. Dedicating a thread pool to client connections and another to server connections allows for isolation because each thread pool has its own queue and set of worker threads. The scheduler in the operating system will ensure that the processors are shared fairly between the threads in both pools. However, it’s important to use multiple thread pools judiciously as creating too many per process can hurt performance and reduce throughput. The legacy thread pool used two types of worker threads: I/O and non-I/O, which at times caused confusion. If the developer didn’t understand the distinction, the result could be limited performance or incorrect behavior. Moreover, having two distinct thread groupings meant that the thread pool implementation itself was less efficient since it couldn’t share threads between callback functions of different types. In the new thread pool, this distinction is removed and all worker threads are the same. In the legacy API, QueueUserWorkItem was used to queue a function to be called asynchronously on a thread pool worker thread. The legacy API provided no way for the application to determine when the worker thread had finished executing the callback function. If the callback function was located in a DLL, it was virtually impossible to guarantee that it was safe to unload the DLL. This meant that unloading a DLL occasionally caused the hosting process to crash. There was also no way to cancel callbacks that Figure 1 Thread Pool Object Types Object Type TP_POOL TP_TIMER TP_WAIT TP_WORK TP_IO TP_CLEANUP_GROUP TP_CALLBACK_ENVIRON Description Pool of threads used to execute callbacks. Invoke a callback function at a due time. Invoke a callback function when a kernel object is signaled or the wait times out. Invoke a callback function asynchronously. Invoke a callback function when an asynchronous I/O completes. Track one or more thread pool callback objects. Bind a thread pool to its callback objects, and optionally a cleanup group. were in the thread pool’s queue awaiting execution, so there was no choice but to wait for all requests to drain, which could introduce significant delays. Finally, the legacy API does not separate resource allocation from resource use. Since these resource allocations can and do fail, the legacy API makes it hard to develop systems that have reliability guarantees. The new thread pool API makes the separation between resource allocation and usage distinct, so that once a resource has been successfully allocated, there is virtually no posAll the objects created sibility of failure for wellby the thread pool, and all written code when those the worker threads resources are put to use. The new thread pool managed by it, become API is object-based, where part of the application each type of object has a set process using them. of functions for creation, cleanup, and modifying properties. Figure 1 summarizes the object types exposed by the API. It’s important to understand that all the objects created by the thread pool, and all the worker threads managed by it, become part of the application process using them. Thread Pool Objects The first step in preparing a thread pool for use is to create one using the CreateThreadpool function, which is shown in Figure 2. The function takes a reserved parameter that must be NULL. If the function succeeds, it returns a PTP_POOL representing the newly Figure 2 Thread Pool Object API PTP_POOL WINAPI CreateThreadpool(PVOID reserved); BOOL WINAPI SetThreadpoolThreadMinimum(PTP_POOL ptpp, DWORD cthrdMin); VOID WINAPI SetThreadpoolThreadMaximum(PTP_POOL ptpp, DWORD cthrdMost); VOID WINAPI CloseThreadpool(PTP_POOL ptpp); october2007 55

Table of Contents Feed for the Digital Edition of MSDN Magazine - October 2007

Cover Contents Toolbox CLR Inside Out Basic Instincts Data Points Cutting Edge Pooled Threads WPF Threads Parallel Linq Parallel Performance Mobile Apps Test Run Foundations Windows with C++ Netting C++ .NET Matters { End Bracket } Net Nuptials

MSDN Magazine - October 2007

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.