public void Allocate(int size)
{
var stats = new BufferManagerStats();
var manager = CreateManager(stats);
var alloc = manager.Allocate(size);
Assert.True(size <= alloc.Sum(a => a.Length));
Assert.Equal(CalculateAllocated(size), stats.Allocated.Allocated);
}
public void Allocate(int size)
{
var stats = new BufferManagerStats();
using (var manager = CreateManager(stats))
{
var alloc = manager.Allocate(size);
Assert.Equal(CalculateAllocated(size), alloc.Sum(a => a.Size));
Assert.Equal(CalculateAllocated(size), stats.Allocated.Allocated);
}
Assert.Equal(0, stats.Allocated.Allocated);
Assert.Equal(0, stats.Cached.Allocated);
}
public void MultipleAllocAndFree(int size, int count)
{
var stats = new BufferManagerStats();
var manager = CreateManager(stats);
for (int i = 0; i < count; i++)
{
var alloc = manager.Allocate(size);
Assert.True(size <= alloc.Sum(a => a.Length));
manager.Free(alloc);
}
//nothing allocated, 1 buffer cached
Assert.Equal(0, stats.Allocated.Allocated);
Assert.Equal(CalculateAllocated(size), stats.Cached.Allocated);
var allocs = Enumerable.Range(1, count).Select(i => manager.Allocate(size)).ToList();
//all count allocated, nothing cached
Assert.Equal(CalculateAllocated(size) * count, stats.Allocated.Allocated);
Assert.Equal(0, stats.Cached.Allocated);
var first = allocs.Take(count / 2).ToArray();
foreach (var b in first)
{
manager.Free(b);
allocs.Remove(b);
}
//half and half allocated and cached
Assert.Equal(CalculateAllocated(size) * count / 2, stats.Allocated.Allocated);
Assert.Equal(CalculateAllocated(size) * count / 2, stats.Cached.Allocated);
foreach (var b in allocs)
{
manager.Free(b);
}
//nothing allocated, all count cached
Assert.Equal(0, stats.Allocated.Allocated);
Assert.Equal(CalculateAllocated(size) * count, stats.Cached.Allocated);
}
public void ParallelAllocAndFree(int size, int count)
{
var stats = new BufferManagerStats();
var manager = CreateManager(stats);
var randomize = new Random((int)DateTime.Now.Ticks);
Parallel.ForEach(Enumerable.Range(1, count), i =>
{
var alloc = manager.Allocate(size);
Assert.True(size <= alloc.Sum(a => a.Length));
manager.Free(alloc);
});
Assert.Equal(0, stats.Allocated.Allocated);
Assert.True(stats.Cached.Allocated >= CalculateAllocated(size));
Assert.True(stats.Cached.Allocated <= CalculateAllocated(size) * count);
}
public void AllocateSingleAndFree(int suggestedSize)
{
var stats = new BufferManagerStats();
using (var manager = CreateManager(stats))
{
var alloc = manager.AllocateSingle(suggestedSize);
Assert.Equal(BufferSize, alloc.Size);
Assert.Equal(BufferSize, stats.Allocated.Allocated);
manager.Free(alloc);
Assert.Equal(0, stats.Allocated.Allocated);
Assert.Equal(BufferSize, stats.Cached.Allocated);
}
Assert.Equal(0, stats.Allocated.Allocated);
Assert.Equal(0, stats.Cached.Allocated);
}
protected abstract IBufferManager <byte> CreateManager(BufferManagerStats stats);
protected IUnmanagedBufferManager CreateManager(BufferManagerStats stats)
{
return new ConcurrentProxy(new Standard(false, BufferSize, stats.Allocated, stats.Cached));
}
protected override IBufferManager <byte> CreateManager(BufferManagerStats stats)
{
return(new ConcurrentProxy <byte>(new Standard <byte>(true, BufferSize, stats.Allocated, stats.Cached)));
}
