Code-Bin #781

untitled C# Code
Posted by: Vitali Fomine | August 9, 2010 @ 11:25am

C# Code

// Copyright (C) 2010 OfficeSIP Communications
// This source is subject to the GNU General Public License.
// Please see Notice.txt for details.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;

namespace SocketServers
{
	static class ByteArraySegmentHelpers
	{
		public static bool IsValid(this ArraySegment<byte> segment)
		{
			return segment.Array != null && segment.Offset >= 0 && segment.Count > 0;
		}

public static bool IsInvalid(this ArraySegment<byte> segment)
		{
			return segment.Array == null || segment.Offset < 0 || segment.Count <= 0;
		}
	}

public class BufferManager1
	{
		private InternalBufferManager[] buffers;
		private SafeDictionary<byte[], int> buffersIndexes;
		private int maxIndex;
		private int currentIndex;
		private const int segments = 128;
		private const int segmentSize = 8192;

public BufferManager1()
		{
			buffers = new InternalBufferManager[2000];
			buffersIndexes = new SafeDictionary<byte[], int>();
			buffers[0] = new InternalBufferManager(segments, segmentSize);
			currentIndex = 0;
			maxIndex = 0;
		}

public void Allocate(IList<ArraySegment<byte>> list, int size)
		{
			int index = currentIndex;

for (; ; )
			{
				do
				{
					int segmentsCount = (size + segmentSize - 1) / segmentSize;

if (buffers[index].FreeCount > segmentsCount)
					{
						var segment = buffers[index].Allocate(size);
						if (segment.IsValid())
						{
							list.Add(segment);
							size -= segment.Count;
						}

if (currentIndex != index &&
							buffers[index].FreeCount > buffers[currentIndex].FreeCount)
						{
							Interlocked.Exchange(ref currentIndex, index);
						}

if (size == 0)
							return;
					}

index = (index < maxIndex) ? index + 1 : 0;
				}
				while (index != currentIndex);

index = AddInternalBuffer();
			}
		}

public void Free(IList<ArraySegment<byte>> list)
		{
			int length = list.Count;
			for (int i = 0; i < length; i++)
				Free(list[i]);
		}

public void Free(ArraySegment<byte> segment)
		{
			buffers[buffersIndexes.GetValue(segment.Array)].Free(segment);
		}

public void AddRef(ArraySegment<byte> segment)
		{
			buffers[buffersIndexes.GetValue(segment.Array)].AddRef(segment);
		}

public int SegmentSize
		{
			get { return segmentSize; }
		}

private int AddInternalBuffer()
		{
			var buffer = new InternalBufferManager(segments, segmentSize);

for (; ; )
			{
				int index = maxIndex + 1;
				if (Interlocked.CompareExchange(ref buffers[index], buffer, null) == null)
				{
					buffersIndexes.Add(buffer.Buffer, index);
					return Interlocked.Increment(ref maxIndex);
				}
			}
		}

class InternalBufferManager
		{
			private byte[] _buffer;
			private int[] _lockCounters;
			private int _freeCount;
			private int _segmentSize;
			private int _segments;

public InternalBufferManager(int segments, int segmentSize)
			{
				_segmentSize = segmentSize;
				_buffer = new byte[segments * segmentSize];
				_lockCounters = new int[segments];
				_freeCount = segments;
				_segments = segments;
			}

public ArraySegment<byte> Allocate(int size)
			{
				int startIndex = 0;

while (_freeCount > 0)
				{
					if (Interlocked.CompareExchange(ref _lockCounters[startIndex], 1, 0) == 0)
					{
						Interlocked.Decrement(ref _freeCount);

int allocatedSize = 0;
						int endIndex = startIndex + 1;

while (size > allocatedSize && _freeCount > 0 && endIndex < _segments)
						{
							if (Interlocked.CompareExchange(ref _lockCounters[endIndex], 1, 0) != 0)
								break;
						
							Interlocked.Decrement(ref _freeCount);
							endIndex += 1;
							allocatedSize += _segmentSize;
						}

return new ArraySegment<byte>(_buffer, (endIndex - startIndex) * _segmentSize,
							(size < allocatedSize) ? size : allocatedSize);
					}

startIndex = (startIndex + 1) % _segments;
				}

return new ArraySegment<byte>();
			}

public void Free(ArraySegment<byte> segment)
			{
				int startIndex = GetSegmentIndex(segment.Offset);
				int endIndex = GetSegmentIndex(segment.Offset + segment.Count - 1);

for (; startIndex < endIndex; startIndex++)
				{
					switch (Interlocked.Decrement(ref _lockCounters[startIndex]))
					{
						case 0:
							Interlocked.Increment(ref _freeCount);
							break;
#if DEBUG
						case -1:
							throw new InvalidOperationException("Buffer segment was freed before.");
#endif
					}
				}
			}

public void AddRef(ArraySegment<byte> segment)
			{
				int startIndex = GetSegmentIndex(segment.Offset);
				int endIndex = GetSegmentIndex(segment.Offset + segment.Count - 1);

for (; startIndex < endIndex; startIndex++)
				{
#if DEBUG
					if (_lockCounters[startIndex] == 0)
						throw new InvalidOperationException("Buffer segment was not allocated yet.");
#endif
					Interlocked.Increment(ref _lockCounters[startIndex]);
				}
			}

public int FreeCount
			{
				get { return _freeCount; }
			}

public byte[] Buffer
			{
				get { return _buffer; }
			}

private int GetSegmentIndex(int offset)
			{
				return offset / _segmentSize;
			}
		}
	}

#region List1

class List1<T>
		: IList<T>
	{
		private T item;
		private Enumerator1 enumerator;

public List1(T item)
		{
			this.item = item;
		}

void ICollection<T>.Add(T item)
		{
		}

void ICollection<T>.Clear()
		{
		}

bool ICollection<T>.Contains(T item)
		{
			return false;
		}

void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			array[arrayIndex] = item;
		}

bool ICollection<T>.Remove(T item)
		{
			return false;
		}

int ICollection<T>.Count
		{
			get { return 1; }
		}

bool ICollection<T>.IsReadOnly
		{
			get { return true; }
		}

int IList<T>.IndexOf(T item)
		{
			return -1;
		}

void IList<T>.Insert(int index, T item)
		{
		}

void IList<T>.RemoveAt(int index)
		{
		}

T IList<T>.this[int index]
		{
			get { return item; }
			set { }
		}

IEnumerator IEnumerable.GetEnumerator()
		{
			if (enumerator == null)
				enumerator = new Enumerator1(this);
			return enumerator;
		}

IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (enumerator == null)
				enumerator = new Enumerator1(this);
			return enumerator;
		}

class Enumerator1
			: IEnumerator<T>
		{
			List1<T> list1;

public Enumerator1(List1<T> list1)
			{
				this.list1 = list1;
			}

public void Reset()
			{
			}

public bool MoveNext()
			{
				return false;
			}

public Object Current
			{
				get { return list1.item; }
			}

T IEnumerator<T>.Current
			{
				get { return list1.item; }
			}

void IDisposable.Dispose()
			{
			}
		}
	}

#endregion
}

Syntax Highlighting

[Open in new window]

Author Comments

not tested

Rating

4.52 / 8
50 Votes