Request Queue

1. // ==++==
2. // 
3. //   
4. //    Copyright (c) 2002 Microsoft Corporation.  All rights reserved.
5. //   
6. //    The use and distribution terms for this software are contained in the file
7. //    named license.txt, which can be found in the root of this distribution.
8. //    By using this software in any fashion, you are agreeing to be bound by the
9. //    terms of this license.
10. //   
11. //    You must not remove this notice, or any other, from this software.
12. //   
13. // 
14. // ==--==
16. //
17. // Request Queue
18. //      queues up the requests to avoid thread pool starvation,
19. //      making sure that there are always available threads to process requests
21. namespace System.Runtime.Remoting.Channels {
22.     using System.Threading;
23.     using System.Collections;
25.     internal class RequestQueue {
26.         // configuration params
27.         private int _minExternFreeThreads;
28.         private int _minLocalFreeThreads;
29.         private int _queueLimit;
31.         // two queues -- one for local requests, one for external
32.         private Queue _localQueue = new Queue();
33.         private Queue _externQueue = new Queue();
35.         // total count
36.         private int _count;
38.         // work items queued to pick up new work
39.         private WaitCallback _workItemCallback;
40.         private int _workItemCount;
41.         private const int _workItemLimit = 2;
42.         private bool _draining;
45.         // helpers
46.         private static bool IsLocal(SocketHandler sh) {
47.             return sh.IsLocal();
48.         }
50.         private void QueueRequest(SocketHandler sh, bool isLocal) {
51.             lock (this) {
52.                 if (isLocal)
53.                     _localQueue.Enqueue(sh);
54.                 else 
55.                     _externQueue.Enqueue(sh);
57.                 _count++;
58.             }
59.         }
61.         private SocketHandler DequeueRequest(bool localOnly) {
62.             Object sh = null;
64.             if (_count > 0) {
65.                 lock (this) {
66.                     if (_localQueue.Count > 0) {
67.                         sh = _localQueue.Dequeue();
68.                         _count--;
69.                     }
70.                     else if (!localOnly && _externQueue.Count > 0) {
71.                         sh = _externQueue.Dequeue();
72.                         _count--;
73.                     }
74.                 }
75.             }
77.             return (SocketHandler)sh;
78.         }
80.         // ctor
81.         internal RequestQueue(int minExternFreeThreads, int minLocalFreeThreads, int queueLimit) {
82.             _minExternFreeThreads = minExternFreeThreads;
83.             _minLocalFreeThreads = minLocalFreeThreads;
84.             _queueLimit = queueLimit;
85.             
86.             _workItemCallback = new WaitCallback(this.WorkItemCallback);
87.         }
90.         // method called to process the next request
91.         internal void ProcessNextRequest(SocketHandler sh)
92.         {
93.             sh = GetRequestToExecute(sh);
95.             if (sh != null)
96.                 sh.ProcessRequestNow();
97.         } // ProcessNextRequest
98.         
100.         // method called when data arrives for incoming requests
101.         internal SocketHandler GetRequestToExecute(SocketHandler sh) {
102.             int workerThreads, ioThreads;
103.             ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
104.             int freeThreads = (ioThreads > workerThreads) ? workerThreads : ioThreads;
106.             // fast path when there are threads available and nothing queued
107.             if (freeThreads >= _minExternFreeThreads && _count == 0)
108.                 return sh;
110.             bool isLocal = IsLocal(sh);
112.             // fast path when there are threads for local requests available and nothing queued
113.             if (isLocal && freeThreads >= _minLocalFreeThreads && _count == 0)
114.                 return sh;
116.             // reject if queue limit exceeded
117.             if (_count >= _queueLimit) {
118.                 sh.RejectRequestNowSinceServerIsBusy();
119.                 return null;
120.             }
122.             // can't execute the current request on the current thread -- need to queue
123.             QueueRequest(sh, isLocal);
125.             // maybe can execute a request previously queued
126.             if (freeThreads >= _minExternFreeThreads) {
127.                 sh = DequeueRequest(false); // enough threads to process even external requests
128.             }
129.             else if (freeThreads >= _minLocalFreeThreads) {
130.                 sh = DequeueRequest(true);  // enough threads to process only local requests
131.             }
132.             else {
133.                 sh = null;                  // not enough threads -> do nothing on this thread
134.                 ScheduleMoreWorkIfNeeded(); // try to schedule to worker thread
135.             }
137.             return sh;
138.         }
140.         // method called from SocketHandler at the end of request
141.         internal void ScheduleMoreWorkIfNeeded() {
142.             // too late for more work if draining
143.             if (_draining)
144.                 return;
146.             // is queue empty?
147.             if (_count == 0)
148.                 return;
150.             // already scheduled enough work items
151.             if (_workItemCount >= _workItemLimit)
152.                 return;
154.             // queue the work item
155.             Interlocked.Increment(ref _workItemCount);
156.             ThreadPool.QueueUserWorkItem(_workItemCallback);
157.         }
159.         // is empty property
160.         internal bool IsEmpty {
161.             get { return (_count == 0); }
162.         }
164.         // method called to pick up more work
165.         private void WorkItemCallback(Object state) {
166.             Interlocked.Decrement(ref _workItemCount);
168.             // too late for more work if draining
169.             if (_draining)
170.                 return;
172.             // is queue empty?
173.             if (_count == 0)
174.                 return;
176.             int workerThreads, ioThreads;
177.             ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
179.             bool bHandledRequest = false;
180.             // service another request if enough worker threads are available
181.             if (workerThreads >= _minLocalFreeThreads)
182.             {
183.                 // pick up request from the queue
184.                 SocketHandler sh = DequeueRequest(workerThreads < _minExternFreeThreads);
185.                 if (sh != null)
186.                 {
187.                     sh.ProcessRequestNow();
188.                     bHandledRequest = true;
189.                 }
190.             }
192.             if (!bHandledRequest)            
193.                 ScheduleMoreWorkIfNeeded();
194.         }
196.         // reject all requests
197.         internal void Drain() {
198.             _draining = true;
199.             // wait for all work items to finish
200.             while (_workItemCount > 0)
201.                 Thread.Sleep(100);
203.             // is queue empty?
204.             if (_count == 0)
205.                 return;
207.             for (;;) {
208.                 SocketHandler sh = DequeueRequest(false);
209.                 if (sh == null)
210.                     break;
211.                 sh.RejectRequestNowSinceServerIsBusy();
212.             }
213.         }
214.     }
215. }