1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199using System;
using System.Collections.Concurrent;
using System.Threading;

namespace Xtremegaida.DataStructures;

public class DataBufferCache
{
	public static readonly DataBufferCache DefaultCache = new DataBufferCache();

	private readonly ConcurrentQueue<DataBuffer> bucket0 = new();
	private readonly ConcurrentQueue<DataBuffer> bucket1 = new();
	private readonly ConcurrentQueue<DataBuffer> bucket2 = new();
	private readonly ConcurrentQueue<DataBuffer>[] buckets;
	private long memReserve;
	private long memReserveMax = 32 << 20; // 32MiB
	private long memUsed;
	private int memMinSize = 256;
	private int memMaxSize = 262144;
	private int bucketMaxSize0 = 1024;
	private int bucketMaxSize1 = 32768;

	public int BufferMinSize
	{
		get { return memMinSize; }
		set
		{
			var size = value;
			if (size <= 16) { size = 16; }
			if (size > 65536) { size = 65536; }
			memMinSize = size;
			for (int i = buckets.Length - 1; i >= 0; i--)
			{
				var bucket = buckets[i];
				var itemCount = bucket.Count;
				while (--itemCount >= 0 && bucket.TryDequeue(out var buffer))
				{
					if (buffer.Buffer.Length >= size) { bucket.Enqueue(buffer); }
					else { Interlocked.Add(ref memReserve, -buffer.Buffer.Length); }
				}
			}
		}
	}

	public int BufferMaxSize
	{
		get { return memMaxSize; }
		set
		{
			var size = value;
			if (size <= 256) { size = 256; }
			memMaxSize = size;
			for (int i = buckets.Length - 1; i >= 0; i--)
			{
				var bucket = buckets[i];
				var itemCount = bucket.Count;
				while (--itemCount >= 0 && bucket.TryDequeue(out var buffer))
				{
					if (buffer.Buffer.Length <= size) { bucket.Enqueue(buffer); }
					else { Interlocked.Add(ref memReserve, -buffer.Buffer.Length); }
				}
			}
		}
	}

	public long BufferMemoryReserveBytes => Interlocked.Read(ref memReserve);
	public long BufferMemoryUsedBytes => Interlocked.Read(ref memUsed);
	public long BufferMemoryMaxBytes
	{
		get { return Interlocked.Read(ref memReserveMax); }
		set
		{
			Interlocked.Exchange(ref memReserveMax, value);
			if (BufferMemoryUsedBytes > BufferMemoryMaxBytes)
			{
				for (int i = buckets.Length - 1; i >= 0 && BufferMemoryUsedBytes > BufferMemoryMaxBytes; i--)
				{
					while (BufferMemoryUsedBytes > BufferMemoryMaxBytes && buckets[i].TryDequeue(out var buffer))
					{
						Interlocked.Add(ref memReserve, -buffer.Buffer.Length);
					}
				}
			}
		}
	}

	public DataBufferCache()
	{
		buckets = new ConcurrentQueue<DataBuffer>[] { bucket0, bucket1, bucket2 };
	}

	internal void _PushInternal(DataBuffer buffer)
	{
		if (buffer.References != 0) { throw new InvalidOperationException(); }
		var length = buffer.Buffer.Length;
		if (length < memMinSize || length > memMaxSize) { return; }
		if ((BufferMemoryUsedBytes + length) > BufferMemoryMaxBytes) { return; }
		buffer.ReadOffset = 0;
		buffer.WriteOffset = 0;
		if (length > bucketMaxSize1) { bucket2.Enqueue(buffer); }
		else if (length > bucketMaxSize0) { bucket1.Enqueue(buffer); }
		else { bucket0.Enqueue(buffer); }
		Interlocked.Add(ref memReserve, length);
		Interlocked.Add(ref memUsed, -length);
	}

	public DataBuffer Pop(int minLength)
	{
		var bucket = minLength >= bucketMaxSize1 ? bucket2 : minLength >= bucketMaxSize0 ? bucket1 : bucket0;
		var itemCount = bucket.Count;
		while (--itemCount >= 0 && bucket.TryDequeue(out var buffer))
		{
			var length = buffer.Buffer.Length;
			if (length < minLength)
			{
#if DEBUG
				System.Diagnostics.Debug.Assert(buffer.WriteOffset == 0);
				System.Diagnostics.Debug.Assert(buffer.ReadOffset == 0);
				System.Diagnostics.Debug.Assert(buffer.References == 0);
#endif
				bucket.Enqueue(buffer);
			}
			else
			{
				Interlocked.Add(ref memReserve, -length);
				Interlocked.Add(ref memUsed, length);
#if DEBUG
				System.Diagnostics.Debug.Assert(buffer.WriteOffset == 0);
				System.Diagnostics.Debug.Assert(buffer.ReadOffset == 0);
				System.Diagnostics.Debug.Assert(buffer.References == 0);
#endif
				buffer._ResetInternal();
				return buffer;
			}
		}
		if (minLength < memMinSize) { minLength = memMinSize; }
		Interlocked.Add(ref memUsed, minLength);
		return new DataBuffer(this, new byte[minLength]);
	}

	public void Clear()
	{
		for (int i = buckets.Length - 1; i >= 0; i--)
		{
			var bucket = buckets[i];
			while (bucket.TryDequeue(out var buffer))
			{
				Interlocked.Add(ref memReserve, -buffer.Buffer.Length);
			}
		}
	}
}

public sealed class DataBuffer : IDisposable
{
	public readonly DataBufferCache Owner;
	public readonly byte[] Buffer;
	public int ReadOffset;
	public int WriteOffset;

	private int refCount;

	public int References => refCount;
	public int UnreadSize => WriteOffset - ReadOffset;
	public int SpaceLeft => Buffer.Length - WriteOffset;
	public Span<byte> ReadSpan => new Span<byte>(Buffer, ReadOffset, WriteOffset - ReadOffset);
	public Span<byte> WriteSpan => new Span<byte>(Buffer, WriteOffset, Buffer.Length - WriteOffset);
	public ReadOnlyMemory<byte> ReadMemory => new ReadOnlyMemory<byte>(Buffer, ReadOffset, WriteOffset - ReadOffset);
	public Memory<byte> WriteMemory => new Memory<byte>(Buffer, WriteOffset, Buffer.Length - WriteOffset);

	public DataBuffer(DataBufferCache owner, byte[] buffer)
	{
		Owner = owner;
		Buffer = buffer;
		refCount = 1;
	}

	public void AddReference()
	{
		Interlocked.Increment(ref refCount);
	}

	internal void _ResetInternal()
	{
		ReadOffset = 0;
		WriteOffset = 0;
		refCount = 1;
	}

	public void Dispose()
	{
		if (Interlocked.Decrement(ref refCount) <= 0)
		{
			ReadOffset = 0;
			WriteOffset = 0;
			Owner?._PushInternal(this);
		}
	}
}