Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Web/BufferAllocator.cs

@@ -0,0 +1,159 @@
+//------------------------------------------------------------------------------
+// <copyright file="BufferAllocator.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * Buffer Allocators with recycling
+ * 
+ * Copyright (c) 1999 Microsoft Corporation
+ */
+namespace System.Web {
+
+    using System.Collections;
+    using System.IO;
+    using System.Globalization;
+
+    using System.Web.Util;
+
+    //////////////////////////////////////////////////////////////////////////////
+    // Generic buffer recycling
+
+    /*
+     * Base class for allocator doing buffer recycling
+     */
+    internal abstract class BufferAllocator {
+        private int _maxFree;
+        private int _numFree;
+        private Stack _buffers;
+
+        private static int s_ProcsFudgeFactor;
+
+        static BufferAllocator() {
+            s_ProcsFudgeFactor = SystemInfo.GetNumProcessCPUs();
+            if (s_ProcsFudgeFactor < 1) 
+                s_ProcsFudgeFactor = 1;
+
+            if (s_ProcsFudgeFactor > 4)
+                s_ProcsFudgeFactor = 4;
+        }
+
+
+        internal BufferAllocator(int maxFree) {
+            _buffers = new Stack();
+            _numFree = 0;
+            _maxFree = maxFree * s_ProcsFudgeFactor;
+        }
+
+        internal void ReleaseAllBuffers() {
+            if (_numFree > 0) {
+                lock (this) {
+                    _buffers.Clear();
+                    _numFree = 0;
+                }
+            }
+        }
+
+        internal /*public*/ Object GetBuffer() {
+            Object buffer = null;
+
+            if (_numFree > 0) {
+                lock(this) {
+                    if (_numFree > 0) {
+                        buffer = _buffers.Pop();
+                        _numFree--;
+                    }
+                }
+            }
+
+            if (buffer == null)
+                buffer = AllocBuffer();
+
+            return buffer;
+        }
+
+        internal void ReuseBuffer(Object buffer) {
+            if (_numFree < _maxFree) {
+                lock(this) {
+                    if (_numFree < _maxFree) {
+                        _buffers.Push(buffer);
+                        _numFree++;
+                    }
+                }
+            }
+        }
+
+        /*
+         * To be implemented by a derived class
+         */
+        abstract protected Object AllocBuffer();
+    }
+
+    /*
+     * Concrete allocator class for ubyte[] buffer recycling
+     */
+    internal class UbyteBufferAllocator : BufferAllocator {
+        private int _bufferSize;
+
+        internal UbyteBufferAllocator(int bufferSize, int maxFree) : base(maxFree) {
+            _bufferSize = bufferSize;
+        }
+
+        protected override Object AllocBuffer() {
+            return new byte[_bufferSize];
+        }
+    }
+
+    /*
+     * Concrete allocator class for char[] buffer recycling
+     */
+    internal class CharBufferAllocator : BufferAllocator {
+        private int _bufferSize;
+
+        internal CharBufferAllocator(int bufferSize, int maxFree)
+
+        : base(maxFree) {
+            _bufferSize = bufferSize;
+        }
+
+        protected override Object AllocBuffer() {
+            return new char[_bufferSize];
+        }
+    }
+
+    /*
+     * Concrete allocator class for int[] buffer recycling
+     */
+    internal class IntegerArrayAllocator : BufferAllocator {
+        private int _arraySize;
+
+        internal IntegerArrayAllocator(int arraySize, int maxFree)
+
+        : base(maxFree) {
+            _arraySize = arraySize;
+        }
+
+        protected override Object AllocBuffer() {
+            return new int[_arraySize];
+        }
+    }
+
+    /*
+     * Concrete allocator class for IntPtr[] buffer recycling
+     */
+    internal class IntPtrArrayAllocator : BufferAllocator {
+        private int _arraySize;
+
+        internal IntPtrArrayAllocator(int arraySize, int maxFree)
+
+        : base(maxFree) {
+            _arraySize = arraySize;
+        }
+
+        protected override Object AllocBuffer() {
+            return new IntPtr[_arraySize];
+        }
+    }
+
+}