/// <summary> /// Converts the span, which encodes binary data as hex characters, to an equivalent 8-bit unsigned integer array. /// </summary> /// <param name="chars">The span to convert.</param> /// <returns>An array of 8-bit unsigned integers that is equivalent to <paramref name="chars"/>.</returns> /// <exception cref="FormatException">The length of <paramref name="chars"/>, ignoring white-space characters, is not zero or a multiple of 2.</exception> /// <exception cref="FormatException">The format of <paramref name="chars"/> is invalid. <paramref name="chars"/> contains a non-hex character.</exception> public static byte[] FromHexString(ReadOnlySpan <char> chars) { if (chars.Length == 0) { return(Array.Empty <byte>()); } unsafe { fixed(char *inPtr = &MemoryMarshal.GetReference(chars)) { var resultLength = FromHex_ComputeResultLength(inPtr, chars.Length); #if GC_ALLOC_UNINIT var result = GC.AllocateUninitializedArray <byte>(resultLength); #else var result = new byte[resultLength]; #endif fixed(byte *outPtr = result) { var res = ConvertFromHexArray(outPtr, result.Length, inPtr, chars.Length); if (res < 0) { throw new FormatException(SR.Format_BadHexChar); } Debug.Assert(res == result.Length); } return(result); } } }
internal SpriteDataSet(bool aligned, ReadOnlyMemory2D <byte> data) { Data = data; Reference = GC.AllocateUninitializedArray <byte>((int)Data.Length); Data.CopyTo(Reference); Aligned = aligned; }
private static void AddErrorCases(Random random) { { // error case Vector2I outerDimensions = (704, 2256); uint[] data = GC.AllocateUninitializedArray <uint>(outerDimensions.Area); random.NextBytes(data.AsSpan().AsBytes()); Bounds innerBounds = new((703, 1912), (1, 264)); ReadOnlySpan <byte> dataBytes = data.AsSpan().AsBytes(); var format = SurfaceFormat.Color; var actualWidth = format.SizeBytes(innerBounds.Extent.X); var rawStride = format.SizeBytes(outerDimensions.Width); var rawOffset = (rawStride * innerBounds.Top) + format.SizeBytes(innerBounds.Left); SpriteDataSet set = new( false, new( array : dataBytes.ToArray(), offset : rawOffset, width : actualWidth, height : innerBounds.Extent.Y, pitch : rawStride - actualWidth ) ); DataSets.Add(set); } }
private static IEnumerable <object> CreateObjectsInDifferentGenerations() { // This object should go into LOH yield return(new DumpSampleClass[50000]); #if NET5_0_OR_GREATER // This object should go into POH yield return(GC.AllocateUninitializedArray <byte>(10000, pinned: true)); #endif for (var i = 0; i < 5; i++) { yield return(new DumpSampleClass()); } GC.Collect(); for (var i = 0; i < 3; i++) { yield return(new DumpSampleClass()); } GC.Collect(); for (var i = 0; i < 10; i++) { yield return(new DumpSampleClass()); } }
public RawB2Sieve(int sieveSize) { SieveSize = sieveSize; data = GC.AllocateUninitializedArray <byte>((SieveSize >> (dataBitsShift + 1)) + 1, pinned: true); data.AsSpan().Fill(byte.MaxValue); }
public MemoryLender(int segmentSize, int segmentCount) { if (segmentSize <= 0) { throw new ArgumentOutOfRangeException(nameof(segmentSize)); } if (segmentCount <= 0) { throw new ArgumentOutOfRangeException(nameof(segmentCount)); } _segmentSize = segmentSize; if (RuntimeHelpers.IsReferenceOrContainsReferences <T>()) { _array = new T[segmentSize * segmentCount]; } else { #if NET5_0_OR_GREATER _array = GC.AllocateUninitializedArray <T>(segmentSize * segmentCount, pinned: true); #else _array = new T[segmentSize * segmentCount]; #endif } _segmentState = new BitArray(segmentCount); _availableHead = 0; _maxCount = segmentCount; var availableIDStack = new int[segmentCount]; for (int i = 0; i < availableIDStack.Length; i++) { availableIDStack[i] = i; } _availableIDStack = availableIDStack; }
public int GetOrAddId(T value) { if (!typeof(T).IsValueType) { ArgumentNullException.ThrowIfNull(value, nameof(value)); } // Get int valueId = value !.GetHashCode(); if (TryGetIdImpl(valueId, out int id)) { return(id); } // Add if (IsFull) { BitCount++; int[] newArray = GC.AllocateUninitializedArray <int>(1 << BitCount); Array.Copy(Values, newArray, Values.Length); Values = newArray; } var newId = Count; Values[Count++] = valueId; return(newId); }
public int[] CollectionCopyTo() { var result = GC.AllocateUninitializedArray <int>(Count); ((ICollection <int>)array !).CopyTo(result, 0); return(result); }
public int[] SpanCopyTo() { var result = GC.AllocateUninitializedArray <int>(Count); array.AsSpan().CopyTo(result); return(result); }
public static void Configure() { var enabled = ServerConfiguration.GetOrUpdateSetting("connectuo.enabled", true); var token = ServerConfiguration.GetOrUpdateSetting("connectuo.token", ""); if (enabled) { try { if (!string.IsNullOrWhiteSpace(token)) { if (token.Length != _connectUOTokenLength * 2) { throw new Exception("Invalid length for ConnectUO token"); } _token = GC.AllocateUninitializedArray <byte>(_connectUOTokenLength); token.ToUpperInvariant().GetBytes(_token); } } catch { logger.Warning("ConnectUO token could not be parsed. Make sure modernuo.json is properly configured"); _token = null; } FreeshardProtocol.Register(0xC0, false, PollInfo); } }
/// <summary> /// Creates a new page-locked 1D array. /// </summary> /// <param name="accelerator">The parent accelerator.</param> /// <param name="extent">The number of elements to allocate.</param> /// <param name="uninitialized">True, to allocate an uninitialized array.</param> internal unsafe PageLockedArray1D( Accelerator accelerator, LongIndex1D extent, bool uninitialized) { if (extent < 0L) { throw new ArgumentOutOfRangeException(nameof(extent)); } #if NET5_0_OR_GREATER array = uninitialized ? GC.AllocateUninitializedArray <T>(extent.ToIntIndex(), pinned: true) : GC.AllocateArray <T>(extent.ToIntIndex(), pinned: true); fixed(T *ptr = array) Initialize(accelerator, new IntPtr(ptr), extent); #else Trace.WriteLineIf( uninitialized, RuntimeErrorMessages.NotSupportedUninitalizedArrayInitialization); array = new T[extent]; handle = GCHandle.Alloc(array, GCHandleType.Pinned); Initialize(accelerator, handle.AddrOfPinnedObject(), extent); #endif }
protected override unsafe byte[] UncheckedTransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { if (SymmetricPadding.DepaddingRequired(PaddingMode)) { byte[] rented = CryptoPool.Rent(inputCount + InputBlockSize); int written = 0; fixed(byte *pRented = rented) { try { written = UncheckedTransformFinalBlock(inputBuffer.AsSpan(inputOffset, inputCount), rented); return(rented.AsSpan(0, written).ToArray()); } finally { CryptoPool.Return(rented, clearSize: written); } } } else { byte[] buffer = GC.AllocateUninitializedArray <byte>(inputCount); int written = UncheckedTransformFinalBlock(inputBuffer.AsSpan(inputOffset, inputCount), buffer); Debug.Assert(written == buffer.Length); return(buffer); } }
private static void RunRemoteHost(string ip, int port) { byte[] buffer = GC.AllocateUninitializedArray <byte>(64 * 1024, pinned: true); using var listenSocket = new Socket(SocketType.Stream, ProtocolType.Tcp); listenSocket.Bind(new IPEndPoint(IPAddress.Parse(ip), port)); Console.WriteLine($"Remote host bound on {listenSocket.LocalEndPoint}"); listenSocket.Listen(); while (true) { try { while (true) { using Socket socket = listenSocket.Accept(); while (socket.Receive(buffer, SocketFlags.None) != 0) { ; } } } catch (SocketException ex) when(ex.SocketErrorCode == SocketError.ConnectionReset) { // do nothing. } } }
private static void AllocateArrayNegativeSize(int negValue) { Assert.Throws <OverflowException>(() => GC.AllocateUninitializedArray <byte>(-1)); Assert.Throws <OverflowException>(() => GC.AllocateUninitializedArray <byte>(negValue)); Assert.Throws <OverflowException>(() => GC.AllocateUninitializedArray <byte>(-1, pinned: true)); Assert.Throws <OverflowException>(() => GC.AllocateUninitializedArray <byte>(negValue, pinned: true)); }
public static void Deserialize(string path, Action <IGenericReader> deserializer, bool ensure = true) { AssemblyHandler.EnsureDirectory(Path.GetDirectoryName(path)); if (!File.Exists(path)) { if (ensure) { new FileInfo(path).Create().Close(); } return; } using FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); // TODO: Support files larger than 2GB var buffer = GC.AllocateUninitializedArray <byte>((int)fs.Length); try { deserializer(new BufferReader(buffer)); } catch (Exception e) { Console.WriteLine("[Persistence]: Failed to deserialize"); Console.WriteLine(e); } }
private unsafe static void AllocateArrayCheckPinning() { var list = new List <long[]>(); var r = new Random(1234); for (int i = 0; i < 10000; i++) { int size = r.Next(2, 100); var arr = i % 2 == 1 ? GC.AllocateArray <long>(size, pinned: true) : GC.AllocateUninitializedArray <long>(size, pinned: true); fixed(long *pElem = &arr[0]) { *pElem = (long)pElem; } if (r.Next(100) % 2 == 0) { list.Add(arr); } } GC.Collect(); foreach (var arr in list) { fixed(long *pElem = &arr[0]) { Assert.Equal(*pElem, (long)pElem); } } }
private void Resize(int amount) { var newBuffer = GC.AllocateUninitializedArray <byte>(amount); _buffer.AsSpan(0, Math.Min(amount, _buffer.Length)).CopyTo(newBuffer); _buffer = newBuffer; }
protected override unsafe byte[] UncheckedTransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { if (DepaddingRequired) { byte[] rented = CryptoPool.Rent(inputCount + InputBlockSize); int written = 0; fixed(byte *pRented = rented) { try { written = UncheckedTransformFinalBlock(inputBuffer.AsSpan(inputOffset, inputCount), rented); return(rented.AsSpan(0, written).ToArray()); } finally { CryptoPool.Return(rented, clearSize: written); } } } else { #if NETSTANDARD || NETFRAMEWORK || NETCOREAPP3_0 byte[] buffer = new byte[inputCount]; #else byte[] buffer = GC.AllocateUninitializedArray <byte>(inputCount); #endif int written = UncheckedTransformFinalBlock(inputBuffer.AsSpan(inputOffset, inputCount), buffer); Debug.Assert(written == buffer.Length); return(buffer); } }
public static void DoWork() { // Allocate POH objects var arr0 = GC.AllocateUninitializedArray <int>(100000, true); var arr1 = GC.AllocateArray <int>(200000, true); int k = 0; while (k < 3) { Console.WriteLine("{0}: Restarting run {1}", Thread.CurrentThread.Name, k); int[] largeArray = new int[1000000]; for (int i = 0; i <= 100; i++) { int[] saveArray = largeArray; largeArray = new int[largeArray.Length + 100000]; saveArray = null; //Console.WriteLine("{0} at size {1}",Thread.CurrentThread.Name,largeArray.Length.ToString()); } k++; } GC.KeepAlive(arr0); GC.KeepAlive(arr1); }
public override T[] Rent(int minimumLength) { // Arrays can't be smaller than zero. We allow requesting zero-length arrays (even though // pooling such an array isn't valuable) as it's a valid length array, and we want the pool // to be usable in general instead of using `new`, even for computed lengths. if (minimumLength < 0) { throw new ArgumentOutOfRangeException(nameof(minimumLength)); } else if (minimumLength == 0) { // No need to log the empty array. Our pool is effectively infinite // and we'll never allocate for rents and never store for returns. return(Array.Empty <T>()); } T[]? buffer; // Get the bucket number for the array length int bucketIndex = Utilities.SelectBucketIndex(minimumLength); // If the array could come from a bucket... if (bucketIndex < _buckets.Length) { // First try to get it from TLS if possible. T[]?[]? tlsBuckets = t_tlsBuckets; if (tlsBuckets != null) { buffer = tlsBuckets[bucketIndex]; if (buffer != null) { tlsBuckets[bucketIndex] = null; return(buffer); } } // We couldn't get a buffer from TLS, so try the global stack. PerCoreLockedStacks?b = _buckets[bucketIndex]; if (b != null) { buffer = b.TryPop(); if (buffer != null) { return(buffer); } } // No buffer available. Allocate a new buffer with a size corresponding to the appropriate bucket. buffer = GC.AllocateUninitializedArray <T>(_bucketArraySizes[bucketIndex]); } else { // The request was for a size too large for the pool. Allocate an array of exactly the requested length. // When it's returned to the pool, we'll simply throw it away. buffer = GC.AllocateUninitializedArray <T>(minimumLength); } return(buffer); }
public static void FixArgs(ref string[] args) { var old = args; args = GC.AllocateUninitializedArray <string>(args.Length - 1); Array.Copy(old, 1, args, 0, args.Length); }
public static void FixSetString(ref string[] args, int index) { var old = args; args = GC.AllocateUninitializedArray <string>(index); Array.Copy(old, 0, args, 0, index); }
public static byte[] AllocArray(int size) { #if NET5_0 return(GC.AllocateUninitializedArray <byte>(size, false)); #else return(new byte[size]); #endif }
/// <summary> /// Create a buffer with the specified data. /// </summary> /// <param name="data">The data to be contained in this buffer.</param> public Buffer(ReadOnlySpan <byte> data) { InnerBuffer = GC.AllocateUninitializedArray <byte>(data.Length); if (!data.IsEmpty) { data.CopyTo(InnerBuffer); } }
protected override byte[] UncheckedTransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount) { byte[] buffer = GC.AllocateUninitializedArray <byte>(GetCiphertextLength(inputCount)); int written = UncheckedTransformFinalBlock(inputBuffer.AsSpan(inputOffset, inputCount), buffer); Debug.Assert(written == buffer.Length); return(buffer); }
private static BufferedStreamReader Decompress_Internal_Init(Stream stream, ArchiveCompressorOptions options, out byte[] decompressedBuffer) { var endianByteStream = GetStreamFromEndian(stream, options.BigEndian, options.BufferSize, out var bufferedStreamReader); endianByteStream.Seek(_decompSizeOffset, SeekOrigin.Current); decompressedBuffer = GC.AllocateUninitializedArray <byte>(endianByteStream.Read <int>()); return(bufferedStreamReader); }
public static MemoryPoolSlab Create(int length) { // allocate requested memory length from the pinned memory heap var pinnedArray = GC.AllocateUninitializedArray <byte>(length, pinned: true); // allocate and return slab tracking object return(new MemoryPoolSlab(pinnedArray)); }
internal static T[] AllocatePinnedUninitializedArray <T>(int count) where T : unmanaged { #if NET5_0_OR_GREATER || NET5_0 return(GC.AllocateUninitializedArray <T>(count, true)); #else return(new T[count]); #endif }
internal MemoryPoolBlock(SlabMemoryPool pool, int length) { Pool = pool; var pinnedArray = GC.AllocateUninitializedArray <byte>(length, pinned: true); Memory = MemoryMarshal.CreateFromPinnedArray(pinnedArray, 0, pinnedArray.Length); }
internal void DoEnlargeArray(int needArraySize) { const int EXTRA_ALLOC_MOVES = 8; // allocate more than bare minimum to reduce number of times we have to expand MGMove[] newMoveArray = GC.AllocateUninitializedArray <MGMove>(needArraySize + EXTRA_ALLOC_MOVES); Array.Copy(MovesArray, newMoveArray, NumMovesUsed); MovesArray = newMoveArray; }