public static void RentAndReturnManyOfTheSameSize_NoneAreSame(ArrayPool<byte> pool) { foreach (int length in new[] { 1, 16, 32, 64, 127, 4096, 4097 }) { for (int iter = 0; iter < 2; iter++) { var buffers = new HashSet<byte[]>(); for (int i = 0; i < 100; i++) { buffers.Add(pool.Rent(length)); } Assert.Equal(100, buffers.Count); foreach (byte[] buffer in buffers) { pool.Return(buffer); } } } }
public void Dispose() { byte[]? data = Interlocked.Exchange(ref _data, null !); if (data == null) { return; } // The data in this rented buffer only conveys the positions and // lengths of tags in a document, but no content; so it does not // need to be cleared. _pool?.Return(data); ByteLength = 0; }
/// <inheritdoc/> public void Dispose() { if (_data is null) { return; } _arrayPool?.Return(_data); _data = null; }
/// <summary> /// Releases all resources used by this stream. /// </summary> /// <param name="disposing"><see langword="true"/> to release both managed and unmanaged resources; <see langword="false"/> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing) { pool?.Return(GetBuffer()); pool = null; } base.Dispose(disposing); }
/// <summary> /// Dispose the buffer. This is extremely important if buffer pooling is used /// </summary> public void Dispose() { if (_isDisposed) { return; } _isDisposed = true; _arrayPool?.Return(Buffer); Buffer = null; }
public void Dispose() { if (!disposedValue) { arrayPool?.Return(Array); RealLength = 0; Array = System.Array.Empty <T> (); disposedValue = true; } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { while (!stoppingToken.IsCancellationRequested) { try { var ctx = await channel.Reader.ReadAsync(stoppingToken); vmewblock(ctx.Buffer, ctx.Address, ctx.Length); pool?.Return(ctx.Buffer); // use a object pool and return here? } catch (OperationCanceledException) { break; } } }
public static void CanRentManySizedBuffers(ArrayPool<byte> pool) { for (int i = 1; i < 10000; i++) { byte[] buffer = pool.Rent(i); Assert.Equal(i <= 16 ? 16 : RoundUpToPowerOf2(i), buffer.Length); pool.Return(buffer); } }
public static void CallingReturnWithoutClearingDoesNotClearTheBuffer(ArrayPool<byte> pool) { byte[] buffer = pool.Rent(4); FillArray(buffer); pool.Return(buffer, clearArray: false); CheckFilledArray(buffer, (byte b1, byte b2) => Assert.Equal(b1, b2)); }
protected override void Dispose(bool disposing) { _pool?.Return(_buffer.Array); }
public static void CallingReturnBufferWithNullBufferThrows(ArrayPool <byte> pool) { AssertExtensions.Throws <ArgumentNullException>("array", () => pool.Return(null)); }
public void Encrypt( Stream reader, Stream writer, ReadOnlySpan <byte> privateKey = default, ReadOnlySpan <byte> symmetricKey = default, IEncryptionProvider symmetricKeyEncryptionProvider = null) { Check.ArgNotNull(reader, nameof(reader)); Check.ArgNotNull(writer, nameof(writer)); byte[] symmetricKeyRental = null; byte[] ivRental = null; byte[] headerRental = null; byte[] signingKeyRental = null; byte[] buffer = null; ArrayPool <byte> pool = ArrayPool <byte> .Shared; try { buffer = pool.Rent(4096); using (var header = this.GenerateHeader(this.options, symmetricKey, privateKey, null, symmetricKeyEncryptionProvider)) { symmetricKeyRental = pool.Rent(header.SymmetricKey.Memory.Length); ivRental = pool.Rent(header.IvSize); header.SymmetricKey.Memory.CopyTo(symmetricKeyRental); header.IV.Memory.CopyTo(ivRental); this.algorithm ??= CreateSymmetricAlgorithm(this.options); using (var encryptor = this.algorithm.CreateEncryptor(symmetricKeyRental, ivRental)) { var cs = new CryptoStream(writer, encryptor, CryptoStreamMode.Write); using (var bw = new BinaryWriter(writer, Utf8Options.NoBom, true)) { bw.Write(new byte[header.HeaderSize]); bw.Flush(); } long bytesLeft = reader.Length; while (bytesLeft > 0) { int read = reader.Read(buffer, 0, buffer.Length); bytesLeft -= read; cs.Write(buffer, 0, read); } cs.Flush(); cs.FlushFinalBlock(); writer.Flush(); } headerRental = pool.Rent(header.HeaderSize); header.Bytes.Memory.CopyTo(headerRental); if (!this.options.SkipSigning && header.SigningKey != null && !header.SigningKey.Memory.IsEmpty) { signingKeyRental = pool.Rent(header.SigningKey.Memory.Length); header.SigningKey.CopyTo(signingKeyRental); using (var signer = CreateSigningAlgorithm(this.options)) { signer.Key = signingKeyRental; writer.Seek(header.HeaderSize, SeekOrigin.Begin); var hash = signer.ComputeHash(writer); Array.Copy(hash, 0, headerRental, header.Position, hash.Length); hash.Clear(); } } writer.Seek(0, SeekOrigin.Begin); using (var bw = new BinaryWriter(writer, Utf8Options.NoBom, true)) { bw.Write(headerRental, 0, header.HeaderSize); writer.Flush(); writer.Seek(0, SeekOrigin.End); } } } finally { if (buffer != null) { pool.Return(buffer, true); } if (symmetricKeyRental != null) { pool.Return(symmetricKeyRental, true); } if (ivRental != null) { pool.Return(ivRental, true); } if (headerRental != null) { pool.Return(headerRental, true); } if (signingKeyRental != null) { pool.Return(signingKeyRental, true); } } }
/// <inheritdoc/> public override int Read(Span <byte> buffer) { ThrowIfDisposed(); if (_buffer.Position < _buffer.Length || _completelyBuffered) { // Just read from the buffer return(_buffer.Read(buffer)); } var read = _inner.Read(buffer); if (_bufferLimit.HasValue && _bufferLimit - read < _buffer.Length) { throw new IOException("Buffer limit exceeded."); } // We're about to go over the threshold, switch to a file if (_inMemory && _memoryThreshold - read < _buffer.Length) { _inMemory = false; var oldBuffer = _buffer; _buffer = CreateTempFile(); if (_rentedBuffer == null) { // Copy data from the in memory buffer to the file stream using a pooled buffer oldBuffer.Position = 0; var rentedBuffer = _bytePool.Rent(Math.Min((int)oldBuffer.Length, _maxRentedBufferSize)); try { var copyRead = oldBuffer.Read(rentedBuffer); while (copyRead > 0) { _buffer.Write(rentedBuffer.AsSpan(0, copyRead)); copyRead = oldBuffer.Read(rentedBuffer); } } finally { _bytePool.Return(rentedBuffer); } } else { _buffer.Write(_rentedBuffer.AsSpan(0, (int)oldBuffer.Length)); _bytePool.Return(_rentedBuffer); _rentedBuffer = null; } } if (read > 0) { _buffer.Write(buffer.Slice(0, read)); } else { _completelyBuffered = true; } return(read); }
public static void ReturningANonPooledBufferOfDifferentSizeToThePoolThrows(ArrayPool <byte> pool) { AssertExtensions.Throws <ArgumentException>("array", () => pool.Return(new byte[1])); }
/// <summary> /// Encrypts the data and returns the encrypted bytes. /// </summary> /// <param name="blob">The data to encrypt.</param> /// <param name="privateKey"> /// A password or phrase used to generate the key for the symmetric algorithm. /// </param> /// <param name="symmetricKey"> /// The key for the symmetric algorithm. If used, the private key is ignored /// and the symmetric key is stored with the message. /// </param> /// <param name="symmetricKeyEncryptionProvider"> /// The encryption provider used to encrypt/decrypt the symmetric key when it is /// stored with the message. /// </param> /// <returns>Encrypted bytes.</returns> public ReadOnlySpan <byte> Encrypt( ReadOnlySpan <byte> blob, ReadOnlySpan <byte> privateKey = default, ReadOnlySpan <byte> symmetricKey = default, IEncryptionProvider symmetricKeyEncryptionProvider = null) { if (blob == null) { throw new ArgumentNullException(nameof(blob)); } byte[] symmetricKeyRental = null; byte[] ivRental = null; byte[] headerRental = null; byte[] signingKeyRental = null; ArrayPool <byte> pool = ArrayPool <byte> .Shared; try { using (var header = this.GenerateHeader(this.options, symmetricKey, privateKey, null, symmetricKeyEncryptionProvider)) { byte[] encryptedBlob = null; symmetricKeyRental = pool.Rent(header.SymmetricKey.Memory.Length); ivRental = pool.Rent(header.IvSize); header.SymmetricKey.Memory.CopyTo(symmetricKeyRental); header.IV.Memory.CopyTo(ivRental); this.algorithm = this.algorithm ?? CreateSymmetricAlgorithm(this.options); using (var encryptor = this.algorithm.CreateEncryptor(symmetricKeyRental, ivRental)) using (var ms = new MemoryStream()) using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { #if NET461 || NET451 var next = ArrayPool <byte> .Shared.Rent(blob.Length); blob.CopyTo(next); cs.Write(next, 0, next.Length); next.Clear(); ArrayPool <byte> .Shared.Return(next); #else cs.Write(blob); #endif cs.Flush(); cs.FlushFinalBlock(); ms.Flush(); encryptedBlob = ms.ToArray(); } headerRental = pool.Rent(header.HeaderSize); header.Bytes.Memory.CopyTo(headerRental); if (!this.options.SkipSigning && header.SigningKey != null && !header.SigningKey.Memory.IsEmpty) { signingKeyRental = pool.Rent(header.SigningKey.Memory.Length); this.signingAlgorithm = this.signingAlgorithm ?? CreateSigningAlgorithm(this.options); header.SigningKey.Memory.CopyTo(signingKeyRental); this.signingAlgorithm.Key = signingKeyRental; var hash = this.signingAlgorithm.ComputeHash(encryptedBlob); Array.Copy(hash, 0, headerRental, header.Position, hash.Length); hash.Clear(); hash = null; } using (var ms = new MemoryStream()) { using (var writer = new BinaryWriter(ms, Utf8Options.NoBom, true)) { writer.Write(headerRental, 0, header.HeaderSize); } #if NET461 || NET451 ms.Write(encryptedBlob, 0, encryptedBlob.Length); #else ms.Write(encryptedBlob.AsMemory()); #endif encryptedBlob.Clear(); ms.Flush(); return(ms.ToArray()); } } } finally { if (symmetricKeyRental != null) { pool.Return(symmetricKeyRental, true); } if (ivRental != null) { pool.Return(ivRental, true); } if (headerRental != null) { pool.Return(headerRental, true); } if (signingKeyRental != null) { pool.Return(signingKeyRental, true); } } }
public void Dispose() { _pool.Return(_buffer.Items); _buffer.Count = 0; }
public void Return(char[] array) { _arrayPool.Return(array); }
public static void Return(T[] array, bool clearArray = false) { ArrayPoolImpl.Return(array, clearArray); }
public HttpResponseStreamWriter( Stream stream, Encoding encoding, int bufferSize, ArrayPool <byte> bytePool, ArrayPool <char> charPool) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (!stream.CanWrite) { throw new ArgumentException(Resources.HttpResponseStreamWriter_StreamNotWritable, nameof(stream)); } if (encoding == null) { throw new ArgumentNullException(nameof(encoding)); } if (bytePool == null) { throw new ArgumentNullException(nameof(bytePool)); } if (charPool == null) { throw new ArgumentNullException(nameof(charPool)); } _stream = stream; Encoding = encoding; _charBufferSize = bufferSize; _encoder = encoding.GetEncoder(); _bytePool = bytePool; _charPool = charPool; _charBuffer = charPool.Rent(bufferSize); try { var requiredLength = encoding.GetMaxByteCount(bufferSize); _byteBuffer = bytePool.Rent(requiredLength); } catch { charPool.Return(_charBuffer); _charBuffer = null; if (_byteBuffer != null) { bytePool.Return(_byteBuffer); _byteBuffer = null; } throw; } }
public void ReturnPools() { _dreamValuePool.Return(LocalVariables, true); _stackPool.Return(_stack); }
public static void Renting0LengthArrayReturnsSingleton(ArrayPool<byte> pool) { byte[] zero0 = pool.Rent(0); byte[] zero1 = pool.Rent(0); byte[] zero2 = pool.Rent(0); byte[] one = pool.Rent(1); Assert.Same(zero0, zero1); Assert.Same(zero1, zero2); Assert.NotSame(zero2, one); pool.Return(zero0); pool.Return(zero1); pool.Return(zero2); pool.Return(one); Assert.Same(zero0, pool.Rent(0)); }
public void Return(char[] buffer) { bufferPool.Return(buffer); }
/// <summary> /// Buffers a portion of the given stream, returning the buffered stream partition. /// </summary> /// <param name="stream"> /// Stream to buffer from. /// </param> /// <param name="minCount"> /// Minimum number of bytes to buffer. This method will not return until at least this many bytes have been read from <paramref name="stream"/> or the stream completes. /// </param> /// <param name="maxCount"> /// Maximum number of bytes to buffer. /// </param> /// <param name="absolutePosition"> /// Current position of the stream, since <see cref="Stream.Position"/> throws if not seekable. /// </param> /// <param name="arrayPool"> /// Pool to rent buffer space from. /// </param> /// <param name="maxArrayPoolRentalSize"> /// Max size we can request from the array pool. /// </param> /// <param name="async"> /// Whether to perform this operation asynchronously. /// </param> /// <param name="cancellationToken"> /// Cancellation token. /// </param> /// <returns> /// The buffered stream partition with memory backed by an array pool. /// </returns> internal static async Task <PooledMemoryStream> BufferStreamPartitionInternal( Stream stream, long minCount, long maxCount, long absolutePosition, ArrayPool <byte> arrayPool, int?maxArrayPoolRentalSize, bool async, CancellationToken cancellationToken) { long totalRead = 0; var streamPartition = new PooledMemoryStream(arrayPool, absolutePosition, maxArrayPoolRentalSize ?? DefaultMaxArrayPoolRentalSize); // max count to write into a single array int maxCountIndividualBuffer; // min count to write into a single array int minCountIndividualBuffer; // the amount that was written into the current array int readIndividualBuffer; do { // buffer to write to byte[] buffer; // offset to start writing at int offset; BufferPartition latestBuffer = streamPartition.GetLatestBufferWithAvailableSpaceOrDefault(); // whether we got a brand new buffer to write into bool newbuffer; if (latestBuffer != default) { buffer = latestBuffer.Buffer; offset = latestBuffer.DataLength; newbuffer = false; } else { buffer = arrayPool.Rent((int)Math.Min(maxCount - totalRead, streamPartition.MaxArraySize)); offset = 0; newbuffer = true; } // limit max and min count for this buffer by buffer length maxCountIndividualBuffer = (int)Math.Min(maxCount - totalRead, buffer.Length - offset); // definitionally limited by max; we won't ever have a swapped min/max range minCountIndividualBuffer = (int)Math.Min(minCount - totalRead, maxCountIndividualBuffer); readIndividualBuffer = await ReadLoopInternal( stream, buffer, offset : offset, minCountIndividualBuffer, maxCountIndividualBuffer, async, cancellationToken).ConfigureAwait(false); // if nothing was placed in a brand new array if (readIndividualBuffer == 0 && newbuffer) { arrayPool.Return(buffer); } // if brand new array and we did place data in it else if (newbuffer) { streamPartition.BufferSet.Add(new BufferPartition { Buffer = buffer, DataLength = readIndividualBuffer }); } // added to an existing array that was not entirely filled else { latestBuffer.DataLength += readIndividualBuffer; } totalRead += readIndividualBuffer; /* If we filled the buffer this loop, then quitting on min count is pointless. The point of quitting * on min count is when the source stream doesn't have available bytes and we've reached an amount worth * sending instead of blocking on. If we filled the available array, we don't actually know whether more * data is available yet, as we limited our read for reasons outside the stream state. We should therefore * try another read regardless of whether we hit min count. */ } while ( // stream is done if this value is zero; no other check matters readIndividualBuffer != 0 && // stop filling the partition if we've hit the max size of the partition totalRead < maxCount && // stop filling the partition if we've reached min count and we know we've hit at least a pause in the stream (totalRead < minCount || readIndividualBuffer == maxCountIndividualBuffer)); return(streamPartition); }
internal const byte ReservedEscapeMessageBytes = 5; // 2 characters total, escape one '\' of 1 byte and real one of up to 4 bytes internal static async IAsyncEnumerable <string> GetMessageParts(string message, string?steamMessagePrefix = null, bool isAccountLimited = false) { if (string.IsNullOrEmpty(message)) { throw new ArgumentNullException(nameof(message)); } int prefixBytes = 0; int prefixLength = 0; if (!string.IsNullOrEmpty(steamMessagePrefix)) { // We must escape our message prefix if needed // ReSharper disable once RedundantSuppressNullableWarningExpression - required for .NET Framework steamMessagePrefix = Escape(steamMessagePrefix !); prefixBytes = GetMessagePrefixBytes(steamMessagePrefix); if (prefixBytes > MaxMessagePrefixBytes) { throw new ArgumentOutOfRangeException(nameof(steamMessagePrefix)); } prefixLength = steamMessagePrefix.Length; } int maxMessageBytes = (isAccountLimited ? MaxMessageBytesForLimitedAccounts : MaxMessageBytesForUnlimitedAccounts) - ReservedContinuationMessageBytes; // We must escape our message prior to sending it message = Escape(message); int messagePartBytes = prefixBytes; StringBuilder messagePart = new(steamMessagePrefix); Decoder decoder = Encoding.UTF8.GetDecoder(); ArrayPool <char> charPool = ArrayPool <char> .Shared; using StringReader stringReader = new(message); string?line; while ((line = await stringReader.ReadLineAsync().ConfigureAwait(false)) != null) { // Special case for empty newline if (line.Length == 0) { if (messagePart.Length > prefixLength) { messagePartBytes += NewlineWeight; messagePart.AppendLine(); } // Check if we reached the limit for one message if (messagePartBytes + NewlineWeight + ReservedEscapeMessageBytes > maxMessageBytes) { if (stringReader.Peek() >= 0) { messagePart.Append(ParagraphCharacter); } yield return(messagePart.ToString()); messagePartBytes = prefixBytes; messagePart.Clear(); messagePart.Append(steamMessagePrefix); } // Move on to the next line continue; } byte[] lineBytes = Encoding.UTF8.GetBytes(line); for (int lineBytesRead = 0; lineBytesRead < lineBytes.Length;) { if (messagePart.Length > prefixLength) { if (messagePartBytes + NewlineWeight + lineBytes.Length > maxMessageBytes) { messagePart.Append(ParagraphCharacter); yield return(messagePart.ToString()); messagePartBytes = prefixBytes; messagePart.Clear(); messagePart.Append(steamMessagePrefix); } else { messagePartBytes += NewlineWeight; messagePart.AppendLine(); } } int bytesToTake = Math.Min(maxMessageBytes - messagePartBytes, lineBytes.Length - lineBytesRead); // We can never have more characters than bytes used, so this covers the worst case of 1-byte characters exclusively char[] lineChunk = charPool.Rent(bytesToTake); try { // We have to reset the decoder prior to using it, as we must discard any amount of bytes read from previous incomplete character decoder.Reset(); int charsUsed = decoder.GetChars(lineBytes, lineBytesRead, bytesToTake, lineChunk, 0, false); switch (charsUsed) { case <= 0: throw new InvalidOperationException(nameof(charsUsed)); case >= 2 when(lineChunk[charsUsed - 1] == '\\') && (lineChunk[charsUsed - 2] != '\\'): // If our message is of max length and ends with a single '\' then we can't split it here, because it escapes the next character // Instead, we'll cut this message one char short and include the rest in the next iteration charsUsed--; break; } int bytesUsed = Encoding.UTF8.GetByteCount(lineChunk, 0, charsUsed); if (lineBytesRead > 0) { messagePartBytes += ContinuationCharacterBytes; messagePart.Append(ContinuationCharacter); } lineBytesRead += bytesUsed; messagePartBytes += bytesUsed; messagePart.Append(lineChunk, 0, charsUsed); } finally { charPool.Return(lineChunk); } bool midLineSplitting = false; if (lineBytesRead < lineBytes.Length) { midLineSplitting = true; messagePartBytes += ContinuationCharacterBytes; messagePart.Append(ContinuationCharacter); } // Check if we still have room for one more line if (messagePartBytes + NewlineWeight + ReservedEscapeMessageBytes <= maxMessageBytes) { continue; } if (!midLineSplitting && (stringReader.Peek() >= 0)) { messagePart.Append(ParagraphCharacter); } yield return(messagePart.ToString()); messagePartBytes = prefixBytes; messagePart.Clear(); messagePart.Append(steamMessagePrefix); } } if (messagePart.Length <= prefixLength) { yield break; } yield return(messagePart.ToString()); }
/// <summary> /// Returns a previously rented pooled buffer, optionally without clearing it. /// </summary> /// <param name="buffer"> /// The rented buffer. /// </param> /// <param name="clearBuffer"> /// Whether to clear the data held in the buffer. /// </param> protected void ReturnBuffer(byte[] buffer, bool clearBuffer = true) { bufferPool.Return(buffer, clearBuffer); }
static void Main(string[] args) { AdjustPrivileges(); Console.Clear(); Console.WindowWidth = 50; Console.WindowHeight = 5; Console.BufferWidth = Console.WindowWidth; Console.BufferHeight = Console.WindowHeight; do { Console.Title = "Demon's Souls Trainer"; Console.CursorLeft = 0; Console.Write("Searching for the process..."); var procList = Process.GetProcesses() .Where(p => p.MainWindowTitle.Contains("Demon's Souls", StringComparison.InvariantCultureIgnoreCase) && p.MainModule.ModuleName.Contains("rpcs3", StringComparison.InvariantCultureIgnoreCase) ).ToList(); if (procList.Count == 1) { var des = procList[0]; Console.Clear(); Console.WriteLine($"Opened process {des.Id}: {des.MainModule.ModuleName}"); Console.Title += " (Active)"; Console.CursorVisible = false; var ptrBuf = ArrayPool.Rent(4); var valBuf = ArrayPool.Rent(valueLength); var nameBuf = ArrayPool.Rent(2 * 16); using (var pmr = ProcessMemoryReader.OpenProcess(des)) { var rpcs3Base = pmr.GetMemoryRegions().First(r => r.offset >= 0x1_0000_0000 && (r.offset % 0x1000_0000 == 0)).offset; // should be either 0x1_0000_0000 or 0x3_0000_0000 Console.WriteLine($"Guest memory base: 0x{rpcs3Base:x8}"); const int statsPointer = 0x01B4A5EC; // 4 const int characterName = 0x202E80B0; // 16*2 const int currentSouls = 0x202E8098; // 4 const int offsetHp = 0x3c4; var pBase = (IntPtr)(rpcs3Base + statsPointer); do { pmr.ReadProcessMemory(pBase, 4, ptrBuf, out var readBytes); if (readBytes == 4) { var ptr = (IntPtr)(rpcs3Base + EndianBitConverter.BigEndian.ToUInt32(ptrBuf, 0) + offsetHp); pmr.ReadProcessMemory(ptr, valueLength, valBuf, out readBytes); if (readBytes == valueLength) { var hp = EndianBitConverter.BigEndian.ToUInt32(valBuf, 4); var mp = EndianBitConverter.BigEndian.ToUInt32(valBuf, 12); var st = EndianBitConverter.BigEndian.ToUInt32(valBuf, 20); if (hp < 9999 && mp < 9999 & st < 9999) { Buffer.BlockCopy(valBuf, 4, valBuf, 0, 4); Buffer.BlockCopy(valBuf, 12, valBuf, 8, 4); Buffer.BlockCopy(valBuf, 20, valBuf, 16, 4); pmr.WriteProcessMemory(ptr, valBuf, out _); pmr.ReadProcessMemory((IntPtr)(rpcs3Base + characterName), 2 * 16, nameBuf, out readBytes); var name = readBytes > 0 ? Encoding.BigEndianUnicode.GetString(nameBuf, 0, readBytes / 2) : ""; name = name.TrimEnd('\0', ' '); if (!string.IsNullOrEmpty(name)) { name += " "; } pmr.ReadProcessMemory((IntPtr)(rpcs3Base + currentSouls), 4, ptrBuf, out readBytes); var souls = rpcs3Base == 0x1_0000_0000 && readBytes == 4 ? EndianBitConverter.BigEndian.ToInt32(ptrBuf, 0).ToString() : ""; Console.CursorLeft = 0; Console.Write(name); Console.ForegroundColor = ConsoleColor.Red; Console.Write($"{hp} "); Console.ForegroundColor = ConsoleColor.Blue; Console.Write($"{mp} "); Console.ForegroundColor = ConsoleColor.Green; Console.Write($"{st} "); Console.ResetColor(); Console.Write($"{souls} "); } } } #if DEBUG else { var error = Marshal.GetLastWin32Error(); var msg = new Win32Exception(error).Message; Console.CursorLeft = 0; Console.Write(msg); } #endif Thread.Sleep(100); } while (!des.HasExited); } ArrayPool.Return(nameBuf); ArrayPool.Return(valBuf); ArrayPool.Return(ptrBuf); Console.Clear(); Console.CursorVisible = false; } else { Thread.Sleep(1000); } } while (true); }
public void FreeBuffer() { _pool.Return(_buffer); }
public void Dispose() => Pool.Return(Value);
public HttpRequestStreamReader( Stream stream, Encoding encoding, int bufferSize, ArrayPool<byte> bytePool, ArrayPool<char> charPool) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (!stream.CanRead) { throw new ArgumentException(Resources.HttpRequestStreamReader_StreamNotReadable, nameof(stream)); } if (encoding == null) { throw new ArgumentNullException(nameof(encoding)); } if (bytePool == null) { throw new ArgumentNullException(nameof(bytePool)); } if (charPool == null) { throw new ArgumentNullException(nameof(charPool)); } if (bufferSize <= 0) { throw new ArgumentOutOfRangeException(nameof(bufferSize)); } _stream = stream; _encoding = encoding; _byteBufferSize = bufferSize; _bytePool = bytePool; _charPool = charPool; _decoder = encoding.GetDecoder(); _byteBuffer = _bytePool.Rent(bufferSize); try { var requiredLength = encoding.GetMaxCharCount(bufferSize); _charBuffer = _charPool.Rent(requiredLength); } catch { _bytePool.Return(_byteBuffer); _byteBuffer = null; if (_charBuffer != null) { _charPool.Return(_charBuffer); _charBuffer = null; } } }
public static CompressionResult Compress(AssemblyData data, string outputDirectory) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (String.IsNullOrEmpty(outputDirectory)) { throw new ArgumentException("must not be null or empty", nameof(outputDirectory)); } Directory.CreateDirectory(outputDirectory); var fi = new FileInfo(data.SourcePath); if (!fi.Exists) { throw new InvalidOperationException($"File '{data.SourcePath}' does not exist"); } // if ((ulong)fi.Length > InputAssemblySizeLimit) { // return CompressionResult.InputTooBig; // } data.DestinationPath = Path.Combine(outputDirectory, $"{Path.GetFileName (data.SourcePath)}.lz4"); data.SourceSize = (uint)fi.Length; byte[] sourceBytes = null; byte[] destBytes = null; try { sourceBytes = bytePool.Rent(checked ((int)fi.Length)); using (var fs = File.Open(data.SourcePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { fs.Read(sourceBytes, 0, (int)fi.Length); } destBytes = bytePool.Rent(LZ4Codec.MaximumOutputSize(sourceBytes.Length)); int encodedLength = LZ4Codec.Encode(sourceBytes, 0, checked ((int)fi.Length), destBytes, 0, destBytes.Length, LZ4Level.L09_HC); if (encodedLength < 0) { return(CompressionResult.EncodingFailed); } data.DestinationSize = (uint)encodedLength; using (var fs = File.Open(data.DestinationPath, FileMode.Create, FileAccess.Write, FileShare.Read)) { using (var bw = new BinaryWriter(fs)) { bw.Write(CompressedDataMagic); // magic bw.Write(data.DescriptorIndex); // index into runtime array of descriptors bw.Write(checked ((uint)fi.Length)); // file size before compression bw.Write(destBytes, 0, encodedLength); bw.Flush(); } } } finally { if (sourceBytes != null) { bytePool.Return(sourceBytes); } if (destBytes != null) { bytePool.Return(destBytes); } } return(CompressionResult.Success); }
public static void CallingReturnBufferWithNullBufferThrows(ArrayPool<byte> pool) { Assert.Throws<ArgumentNullException>("array", () => pool.Return(null)); }
public void Return(T[] array) { _inner.Return(array); }
public static void CallingReturnWithClearingDoesClearTheBuffer(ArrayPool<byte> pool) { byte[] buffer = pool.Rent(4); FillArray(buffer); // Note - yes this is bad to hold on to the old instance but we need to validate the contract pool.Return(buffer, clearArray: true); CheckFilledArray(buffer, (byte b1, byte b2) => Assert.Equal(b1, default(byte))); }
/// <summary> /// Internal part of the DHT processor, whatever does it mean /// </summary> /// <param name="inputProcessor">The decoder instance</param> /// <param name="defineHuffmanTablesData">The temporal buffer that holds the data that has been read from the Jpeg stream</param> /// <param name="remaining">Remaining bits</param> public void ProcessDefineHuffmanTablesMarkerLoop( ref InputProcessor inputProcessor, byte[] defineHuffmanTablesData, ref int remaining) { // Read nCodes and huffman.Valuess (and derive h.Length). // nCodes[i] is the number of codes with code length i. // h.Length is the total number of codes. this.Length = 0; int[] ncodes = new int[MaxCodeLength]; for (int i = 0; i < ncodes.Length; i++) { ncodes[i] = defineHuffmanTablesData[i + 1]; this.Length += ncodes[i]; } if (this.Length == 0) { throw new ImageFormatException("Huffman table has zero length"); } if (this.Length > MaxNCodes) { throw new ImageFormatException("Huffman table has excessive length"); } remaining -= this.Length + 17; if (remaining < 0) { throw new ImageFormatException("DHT has wrong length"); } byte[] values = null; try { values = BytePool256.Rent(MaxNCodes); inputProcessor.ReadFull(values, 0, this.Length); for (int i = 0; i < values.Length; i++) { this.Values[i] = values[i]; } } finally { BytePool256.Return(values, true); } // Derive the look-up table. for (int i = 0; i < this.Lut.Length; i++) { this.Lut[i] = 0; } int x = 0, code = 0; for (int i = 0; i < LutSizeLog2; i++) { code <<= 1; for (int j = 0; j < ncodes[i]; j++) { // The codeLength is 1+i, so shift code by 8-(1+i) to // calculate the high bits for every 8-bit sequence // whose codeLength's high bits matches code. // The high 8 bits of lutValue are the encoded value. // The low 8 bits are 1 plus the codeLength. int base2 = code << (7 - i); int lutValue = (this.Values[x] << 8) | (2 + i); for (int k = 0; k < 1 << (7 - i); k++) { this.Lut[base2 | k] = lutValue; } code++; x++; } } // Derive minCodes, maxCodes, and indices. int c = 0, index = 0; for (int i = 0; i < ncodes.Length; i++) { int nc = ncodes[i]; if (nc == 0) { this.MinCodes[i] = -1; this.MaxCodes[i] = -1; this.Indices[i] = -1; } else { this.MinCodes[i] = c; this.MaxCodes[i] = c + nc - 1; this.Indices[i] = index; c += nc; index += nc; } c <<= 1; } }
public static void ReturningANonPooledBufferOfDifferentSizeToThePoolThrows(ArrayPool<byte> pool) { Assert.Throws<ArgumentException>("array", () => pool.Return(new byte[1])); }
public void Clear() { Default.Numbers.Return(buckets); Slots.Return(slots); }
public static void UsePoolInParallel(ArrayPool<byte> pool) { int[] sizes = new int[] { 16, 32, 64, 128 }; Parallel.For(0, 250000, i => { foreach (int size in sizes) { byte[] array = pool.Rent(size); Assert.NotNull(array); Assert.InRange(array.Length, size, int.MaxValue); pool.Return(array); } }); }
public HttpResponseStreamWriter( Stream stream, Encoding encoding, int bufferSize, ArrayPool<byte> bytePool, ArrayPool<char> charPool) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (!stream.CanWrite) { throw new ArgumentException(Resources.HttpResponseStreamWriter_StreamNotWritable, nameof(stream)); } if (encoding == null) { throw new ArgumentNullException(nameof(encoding)); } if (bytePool == null) { throw new ArgumentNullException(nameof(bytePool)); } if (charPool == null) { throw new ArgumentNullException(nameof(charPool)); } _stream = stream; Encoding = encoding; _charBufferSize = bufferSize; _encoder = encoding.GetEncoder(); _bytePool = bytePool; _charPool = charPool; _charBuffer = charPool.Rent(bufferSize); try { var requiredLength = encoding.GetMaxByteCount(bufferSize); _byteBuffer = bytePool.Rent(requiredLength); } catch { charPool.Return(_charBuffer); _charBuffer = null; if (_byteBuffer != null) { bytePool.Return(_byteBuffer); _byteBuffer = null; } throw; } }
internal void ReturnRentedArrays(ArrayPool <byte> pool, bool clearArray) { pool.Return(RentedArray, clearArray); LinkedSerializedRequest?.ReturnRentedArrays(pool, clearArray); }
/// <summary> /// 保持应答 /// </summary> /// <param name="listenSocket">监听Socket</param> /// <returns></returns> private async Task KeepAccept(Socket listenSocket) { while (!_cancellationTokenSource.IsCancellationRequested) { var buffer = default(byte[]); try { var bufferSize = ChannelOptions.MaxPackageLength; buffer = _bufferPool.Rent(bufferSize); var result = await listenSocket .ReceiveFromAsync(new ArraySegment <byte>(buffer, 0, buffer.Length), SocketFlags.None, _acceptRemoteEndPoint) .ConfigureAwait(false); var packageData = new ArraySegment <byte>(buffer, 0, result.ReceivedBytes); var remoteEndPoint = result.RemoteEndPoint as IPEndPoint; var sessionID = _udpSessionIdentifierProvider.GetSessionIdentifier(remoteEndPoint, packageData); var session = await _sessionContainer.GetSessionByIDAsync(sessionID); IVirtualChannel channel = null; if (session != null) { channel = session.Channel as IVirtualChannel; } else { channel = await CreateChannel(_listenSocket, remoteEndPoint, sessionID); if (channel == null) { return; } OnNewClientAccept(channel); } await channel.WritePipeDataAsync(packageData.AsMemory(), _cancellationTokenSource.Token); } catch (Exception e) { if (e is ObjectDisposedException || e is NullReferenceException) { break; } if (e is SocketException se) { var errorCode = se.ErrorCode; //The listen socket was closed if (errorCode == 125 || errorCode == 89 || errorCode == 995 || errorCode == 10004 || errorCode == 10038) { break; } } _logger.LogError(e, $"Listener[{this.ToString()}] failed to receive udp data"); } finally { _bufferPool.Return(buffer); } } _stopTaskCompletionSource.TrySetResult(true); }