| | | 1 | | // Licensed to the .NET Foundation under one or more agreements. |
| | | 2 | | // The .NET Foundation licenses this file to you under the MIT license. |
| | | 3 | | |
| | | 4 | | using System.Buffers; |
| | | 5 | | using System.Diagnostics; |
| | | 6 | | using System.Runtime.CompilerServices; |
| | | 7 | | using System.Runtime.InteropServices; |
| | | 8 | | |
| | | 9 | | namespace System.Net |
| | | 10 | | { |
| | | 11 | | // Warning: Mutable struct! |
| | | 12 | | // The purpose of this struct is to simplify buffer management. |
| | | 13 | | // It manages a sliding buffer where bytes can be added at the end and removed at the beginning. |
| | | 14 | | // [ActiveSpan/Memory] contains the current buffer contents; these bytes will be preserved |
| | | 15 | | // (copied, if necessary) on any call to EnsureAvailableBytes. |
| | | 16 | | // [AvailableSpan/Memory] contains the available bytes past the end of the current content, |
| | | 17 | | // and can be written to in order to add data to the end of the buffer. |
| | | 18 | | // Commit(byteCount) will extend the ActiveSpan by [byteCount] bytes into the AvailableSpan. |
| | | 19 | | // Discard(byteCount) will discard [byteCount] bytes as the beginning of the ActiveSpan. |
| | | 20 | | |
| | | 21 | | [StructLayout(LayoutKind.Auto)] |
| | | 22 | | internal struct ArrayBuffer : IDisposable |
| | | 23 | | { |
| | | 24 | | private readonly bool _usePool; |
| | | 25 | | private byte[] _bytes; |
| | | 26 | | private int _activeStart; |
| | | 27 | | private int _availableStart; |
| | | 28 | | |
| | | 29 | | // Invariants: |
| | | 30 | | // 0 <= _activeStart <= _availableStart <= bytes.Length |
| | | 31 | | |
| | | 32 | | public ArrayBuffer(int initialSize, bool usePool = false) |
| | 0 | 33 | | { |
| | 0 | 34 | | Debug.Assert(initialSize > 0 || usePool); |
| | | 35 | | |
| | 0 | 36 | | _usePool = usePool; |
| | 0 | 37 | | _bytes = initialSize == 0 |
| | 0 | 38 | | ? Array.Empty<byte>() |
| | 0 | 39 | | : usePool ? ArrayPool<byte>.Shared.Rent(initialSize) : new byte[initialSize]; |
| | 0 | 40 | | _activeStart = 0; |
| | 0 | 41 | | _availableStart = 0; |
| | 0 | 42 | | } |
| | | 43 | | |
| | | 44 | | public ArrayBuffer(byte[] buffer) |
| | | 45 | | { |
| | | 46 | | Debug.Assert(buffer.Length > 0); |
| | | 47 | | |
| | | 48 | | _usePool = false; |
| | | 49 | | _bytes = buffer; |
| | | 50 | | _activeStart = 0; |
| | | 51 | | _availableStart = 0; |
| | | 52 | | } |
| | | 53 | | |
| | | 54 | | public void Dispose() |
| | 0 | 55 | | { |
| | 0 | 56 | | DiscardAll(); |
| | | 57 | | |
| | 0 | 58 | | byte[] array = _bytes; |
| | 0 | 59 | | _bytes = null!; |
| | | 60 | | |
| | 0 | 61 | | if (array is not null) |
| | 0 | 62 | | { |
| | 0 | 63 | | ReturnBufferIfPooled(array); |
| | 0 | 64 | | } |
| | 0 | 65 | | } |
| | | 66 | | |
| | | 67 | | // This is different from Dispose as the instance remains usable afterwards (_bytes will not be null). |
| | | 68 | | public void ClearAndReturnBuffer() |
| | 0 | 69 | | { |
| | 0 | 70 | | Debug.Assert(_usePool); |
| | 0 | 71 | | Debug.Assert(_bytes is not null); |
| | | 72 | | |
| | 0 | 73 | | DiscardAll(); |
| | | 74 | | |
| | 0 | 75 | | byte[] bufferToReturn = _bytes; |
| | 0 | 76 | | _bytes = Array.Empty<byte>(); |
| | 0 | 77 | | ReturnBufferIfPooled(bufferToReturn); |
| | 0 | 78 | | } |
| | | 79 | | |
| | 0 | 80 | | public int ActiveLength => _availableStart - _activeStart; |
| | 0 | 81 | | public Span<byte> ActiveSpan => new Span<byte>(_bytes, _activeStart, _availableStart - _activeStart); |
| | | 82 | | public ReadOnlySpan<byte> ActiveReadOnlySpan => new ReadOnlySpan<byte>(_bytes, _activeStart, _availableStart - _ |
| | 0 | 83 | | public Memory<byte> ActiveMemory => new Memory<byte>(_bytes, _activeStart, _availableStart - _activeStart); |
| | | 84 | | |
| | 0 | 85 | | public int AvailableLength => _bytes.Length - _availableStart; |
| | 0 | 86 | | public Span<byte> AvailableSpan => _bytes.AsSpan(_availableStart); |
| | 0 | 87 | | public Memory<byte> AvailableMemory => _bytes.AsMemory(_availableStart); |
| | | 88 | | public Memory<byte> AvailableMemorySliced(int length) => new Memory<byte>(_bytes, _availableStart, length); |
| | | 89 | | |
| | 0 | 90 | | public int Capacity => _bytes.Length; |
| | | 91 | | public int ActiveStartOffset => _activeStart; |
| | | 92 | | |
| | | 93 | | public byte[] DangerousGetUnderlyingBuffer() => _bytes; |
| | | 94 | | |
| | | 95 | | public void Discard(int byteCount) |
| | | 96 | | { |
| | | 97 | | Debug.Assert(byteCount <= ActiveLength, $"Expected {byteCount} <= {ActiveLength}"); |
| | | 98 | | _activeStart += byteCount; |
| | | 99 | | |
| | | 100 | | if (_activeStart == _availableStart) |
| | | 101 | | { |
| | | 102 | | _activeStart = 0; |
| | | 103 | | _availableStart = 0; |
| | | 104 | | } |
| | | 105 | | } |
| | | 106 | | |
| | | 107 | | public void DiscardAll() |
| | 0 | 108 | | { |
| | 0 | 109 | | _activeStart = 0; |
| | 0 | 110 | | _availableStart = 0; |
| | 0 | 111 | | } |
| | | 112 | | |
| | | 113 | | public void Commit(int byteCount) |
| | 0 | 114 | | { |
| | 0 | 115 | | Debug.Assert(byteCount <= AvailableLength); |
| | 0 | 116 | | _availableStart += byteCount; |
| | 0 | 117 | | } |
| | | 118 | | |
| | | 119 | | // Ensure at least [byteCount] bytes to write to. |
| | | 120 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 121 | | public void EnsureAvailableSpace(int byteCount) |
| | 0 | 122 | | { |
| | 0 | 123 | | if (byteCount > AvailableLength) |
| | 0 | 124 | | { |
| | 0 | 125 | | EnsureAvailableSpaceCore(byteCount); |
| | 0 | 126 | | } |
| | 0 | 127 | | } |
| | | 128 | | |
| | | 129 | | private void EnsureAvailableSpaceCore(int byteCount) |
| | 0 | 130 | | { |
| | 0 | 131 | | Debug.Assert(AvailableLength < byteCount); |
| | | 132 | | |
| | 0 | 133 | | if (_bytes.Length == 0) |
| | 0 | 134 | | { |
| | 0 | 135 | | Debug.Assert(_usePool && _activeStart == 0 && _availableStart == 0); |
| | 0 | 136 | | _bytes = ArrayPool<byte>.Shared.Rent(byteCount); |
| | 0 | 137 | | return; |
| | | 138 | | } |
| | | 139 | | |
| | 0 | 140 | | int totalFree = _activeStart + AvailableLength; |
| | 0 | 141 | | if (byteCount <= totalFree) |
| | 0 | 142 | | { |
| | | 143 | | // We can free up enough space by just shifting the bytes down, so do so. |
| | 0 | 144 | | Buffer.BlockCopy(_bytes, _activeStart, _bytes, 0, ActiveLength); |
| | 0 | 145 | | _availableStart = ActiveLength; |
| | 0 | 146 | | _activeStart = 0; |
| | 0 | 147 | | Debug.Assert(byteCount <= AvailableLength); |
| | 0 | 148 | | return; |
| | | 149 | | } |
| | | 150 | | |
| | 0 | 151 | | int desiredSize = ActiveLength + byteCount; |
| | | 152 | | |
| | 0 | 153 | | if ((uint)desiredSize > Array.MaxLength) |
| | 0 | 154 | | { |
| | 0 | 155 | | throw new OutOfMemoryException(); |
| | | 156 | | } |
| | | 157 | | |
| | | 158 | | // Double the existing buffer size (capped at Array.MaxLength). |
| | 0 | 159 | | int newSize = Math.Max(desiredSize, (int)Math.Min(Array.MaxLength, 2 * (uint)_bytes.Length)); |
| | | 160 | | |
| | 0 | 161 | | byte[] newBytes = _usePool ? |
| | 0 | 162 | | ArrayPool<byte>.Shared.Rent(newSize) : |
| | 0 | 163 | | new byte[newSize]; |
| | 0 | 164 | | byte[] oldBytes = _bytes; |
| | | 165 | | |
| | 0 | 166 | | if (ActiveLength != 0) |
| | 0 | 167 | | { |
| | 0 | 168 | | Buffer.BlockCopy(oldBytes, _activeStart, newBytes, 0, ActiveLength); |
| | 0 | 169 | | } |
| | | 170 | | |
| | 0 | 171 | | _availableStart = ActiveLength; |
| | 0 | 172 | | _activeStart = 0; |
| | | 173 | | |
| | 0 | 174 | | _bytes = newBytes; |
| | 0 | 175 | | ReturnBufferIfPooled(oldBytes); |
| | | 176 | | |
| | 0 | 177 | | Debug.Assert(byteCount <= AvailableLength); |
| | 0 | 178 | | } |
| | | 179 | | |
| | | 180 | | public void Grow() |
| | | 181 | | { |
| | | 182 | | EnsureAvailableSpaceCore(AvailableLength + 1); |
| | | 183 | | } |
| | | 184 | | |
| | | 185 | | [MethodImpl(MethodImplOptions.AggressiveInlining)] |
| | | 186 | | private void ReturnBufferIfPooled(byte[] buffer) |
| | 0 | 187 | | { |
| | | 188 | | // The buffer may be Array.Empty<byte>() |
| | 0 | 189 | | if (_usePool && buffer.Length > 0) |
| | 0 | 190 | | { |
| | 0 | 191 | | ArrayPool<byte>.Shared.Return(buffer); |
| | 0 | 192 | | } |
| | 0 | 193 | | } |
| | | 194 | | } |
| | | 195 | | } |