ByteBufferPool.cs

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. // ==--==
15. //==========================================================================
16. //  File:       ByteBufferPool.cs
17. //
18. //  Summary:    Stream used for reading from a socket by remoting channels.
19. //
20. //==========================================================================
22. using System;
23. using System.Threading;
26. namespace System.IO
27. {
29.     internal interface IByteBufferPool
30.     {
31.         byte[] GetBuffer();
32.         void ReturnBuffer(byte[] buffer);
33.     }
36.     // This isn't actually a buffer pool. It always creates a new byte buffer.
37.     internal class ByteBufferAllocator : IByteBufferPool
38.     {
39.         private int _bufferSize;
41.         public ByteBufferAllocator(int bufferSize)
42.         {
43.             _bufferSize = bufferSize;
44.         }
46.         public byte[] GetBuffer()
47.         {
48.             return new byte[_bufferSize];
49.         }
51.         public void ReturnBuffer(byte[] buffer)
52.         {
53.         }
54.         
55.     } // ByteBufferAllocator
58.     internal class ByteBufferPool : IByteBufferPool
59.     {
60.         private byte[][] _bufferPool = null;
61.     
62.         private int _current; // -1 for none
63.         private int _last;
64.         private int _max;     // maximum number of buffers to pool
66.         private int _bufferSize;
68.         private Object _controlCookie = "cookie object";
71.         public ByteBufferPool(int maxBuffers, int bufferSize)
72.         {
73.             _max = maxBuffers;        
74.             _bufferPool = new byte[_max][];
75.             _bufferSize = bufferSize;
77.             _current = -1;
78.             _last = -1;
79.         } // ByteBufferPool        
80.         
82.         public byte[] GetBuffer()
83.         {
84.             Object cookie = null;
86.             try
87.             {
88.                 // If a ThreadAbortException gets thrown after the exchange,
89.                 //   but before the result is assigned to cookie, then the
90.                 //   control cookie is lost forever. However, the buffer pool
91.                 //   will still function normally and return everybody a new
92.                 //   buffer each time (that isn't very likely to happen,
93.                 //   so we don't really care).
94.                 cookie = Interlocked.Exchange(ref _controlCookie, null);
96.                 if (cookie != null)
97.                 {
98.                     // we have the control cookie, so take a buffer
99.                 
100.                     if (_current == -1)
101.                     {
102.                         _controlCookie = cookie;
103.                         // no pooled buffers available
104.                         return new byte[_bufferSize];
105.                     }
106.                     else
107.                     {
108.                         // grab next available buffer
109.                         byte[] buffer = _bufferPool[_current];
110.                         _bufferPool[_current] = null;      
112.                         // update "current" index
113.                         if (_current == _last)
114.                         {
115.                             // this is the last free buffer
116.                             _current = -1;
117.                         }
118.                         else
119.                         {
120.                             _current = (_current + 1) % _max;
121.                         }
122.     
123.                         _controlCookie = cookie;
124.                         return buffer;
125.                     }              
126.                 }
127.                 else
128.                 {
129.                     // we don't have the control cookie, so just create a new buffer since
130.                     //   there will probably be a lot of contention anyway.
131.                     return new byte[_bufferSize];
132.                 }            
133.             } 
134.             catch (ThreadAbortException)
135.             {
136.                 if (cookie != null)
137.                 {
138.                     // This should be rare, so just reset
139.                     //   everything to the initial state.
140.                     _current = -1;
141.                     _last = -1;
143.                     // restore cookie
144.                     _controlCookie = cookie;
145.                 }
146.             
147.                 throw;
148.             }                            
149.         } // GetBuffer
152.         public void ReturnBuffer(byte[] buffer)
153.         {
154.             if (buffer == null)
155.                 throw new ArgumentNullException("buffer");
156.                 
157.         
158.             // The purpose of the buffer pool is to try to reduce the 
159.             //   amount of garbage generated, so it doesn't matter  if
160.             //   the buffer gets tossed out. Since we don't want to
161.             //   take the perf hit of taking a lock, we only return
162.             //   the buffer if we can grab the control cookie.
163.             
164.             Object cookie = null;
166.             try
167.             {
168.                 // If a ThreadAbortException gets thrown after the exchange,
169.                 //   but before the result is assigned to cookie, then the
170.                 //   control cookie is lost forever. However, the buffer pool
171.                 //   will still function normally and return everybody a new
172.                 //   buffer each time (that isn't very likely to happen,
173.                 //   so we don't really care).
174.                 cookie = Interlocked.Exchange(ref _controlCookie, null);
175.                 
176.                 if (cookie != null)
177.                 {
178.                     if (_current == -1)
179.                     {
180.                         _bufferPool[0] = buffer;
181.                         _current = 0;
182.                         _last = 0;
183.                     }
184.                     else
185.                     {
186.                         int newLast = (_last + 1) % _max;
187.                         if (newLast != _current)
188.                         {
189.                             // the pool isn't full so store this buffer
190.                             _last = newLast;
191.                             _bufferPool[_last] = buffer;
192.                         }
193.                     }
195.                     _controlCookie = cookie;
196.                 }            
197.             }
198.             catch (ThreadAbortException)
199.             {
200.                 if (cookie != null)
201.                 {
202.                     // This should be rare, so just reset
203.                     //   everything to the initial state.
204.                     _current = -1;
205.                     _last = -1;
207.                     // restore cookie
208.                     _controlCookie = cookie;
209.                 }
211.                 throw;            
212.             }
213.         } // ReturnBuffer
215.         
217.     } // ByteBufferPool
220. } // namespace System.IO