From b679ddd4e647ac915febd0d5a5e488a1e8e48842 Mon Sep 17 00:00:00 2001 From: vnugent Date: Thu, 29 Feb 2024 21:23:26 -0500 Subject: Squashed commit of the following: commit 231e26e5c6731e6e156d7c0591518e84a3b82f5a Author: vnugent Date: Thu Feb 29 20:59:42 2024 -0500 fix: #5 find and patch Windows compression bug and some deployment commit d0bfe14e0a0e27172b8dd41f468265e651784837 Author: vnugent Date: Wed Feb 21 21:39:19 2024 -0500 fix: #4 fix readme licensing message for accuracy commit 6f37f152fcd105e40af6689192a36b87eda95f51 Author: vnugent Date: Wed Feb 21 21:37:55 2024 -0500 fix: jwt hashalg sizing and public api for hashalg sizes --- lib/Utils/src/IO/VnMemoryStream.cs | 18 +++++++++--- lib/Utils/src/Memory/Caching/IReusable.cs | 4 +-- lib/Utils/src/Memory/MemoryUtil.CopyUtilCore.cs | 7 ++--- lib/Utils/src/Memory/MemoryUtil.cs | 38 +++++++++++++------------ lib/Utils/src/Memory/ProcessHeap.cs | 14 +++------ lib/Utils/src/Native/SafeLibraryHandle.cs | 20 +++++++++---- 6 files changed, 57 insertions(+), 44 deletions(-) (limited to 'lib/Utils') diff --git a/lib/Utils/src/IO/VnMemoryStream.cs b/lib/Utils/src/IO/VnMemoryStream.cs index ed8ed5a..ada2c64 100644 --- a/lib/Utils/src/IO/VnMemoryStream.cs +++ b/lib/Utils/src/IO/VnMemoryStream.cs @@ -88,6 +88,7 @@ namespace VNLib.Utils.IO /// The readonly stream public static VnMemoryStream CreateReadonly(VnMemoryStream stream) { + ArgumentNullException.ThrowIfNull(stream); //Set the readonly flag stream._isReadonly = true; //Return the stream @@ -528,10 +529,19 @@ namespace VNLib.Utils.IO /// public byte[] ToArray() { - //Alloc a new array of the size of the internal buffer, may be 64 bit large block - byte[] data = new byte[_length]; - - //Copy the internal buffer to the new array + byte[] data; + + if (_length < Int32.MaxValue) + { + //Alloc uninialized, since were going to overwite it anyway + data = GC.AllocateUninitializedArray((int)_length, false); + } + else + { + //Use new opperator if larger than 32bit + data = new byte[_length]; + } + MemoryUtil.CopyArray(_buffer, 0, data, 0, (nuint)_length); return data; diff --git a/lib/Utils/src/Memory/Caching/IReusable.cs b/lib/Utils/src/Memory/Caching/IReusable.cs index 4472ad3..cf73fa0 100644 --- a/lib/Utils/src/Memory/Caching/IReusable.cs +++ b/lib/Utils/src/Memory/Caching/IReusable.cs @@ -1,5 +1,5 @@ /* -* Copyright (c) 2023 Vaughn Nugent +* Copyright (c) 2024 Vaughn Nugent * * Library: VNLib * Package: VNLib.Utils @@ -25,7 +25,7 @@ namespace VNLib.Utils.Memory.Caching { /// - /// Allows for use within a , this object is intended to be reused heavily + /// An interface that exposes event hooks for use within an , managment. /// public interface IReusable { diff --git a/lib/Utils/src/Memory/MemoryUtil.CopyUtilCore.cs b/lib/Utils/src/Memory/MemoryUtil.CopyUtilCore.cs index bcc5be9..f196597 100644 --- a/lib/Utils/src/Memory/MemoryUtil.CopyUtilCore.cs +++ b/lib/Utils/src/Memory/MemoryUtil.CopyUtilCore.cs @@ -74,7 +74,7 @@ namespace VNLib.Utils.Memory public static bool RequiresPinning(nuint byteSize, bool forceAcceleration) { /* - * Pinnin is required, if reflected memmove is not supported on the platform + * Pinning is required, if reflected memmove is not supported on the platform * AND the size of the data to copy is larger than 32 bit width. * * Otherwise if accleration is forced, pinning will always be required. @@ -94,9 +94,9 @@ namespace VNLib.Utils.Memory } /* - * Why does this function exist. For centralized memmove operations primarily. + * Why does this function exist? For centralized memmove operations primarily. * - * When the block is known to be small, all of the brances in memmove can be + * When the block is known to be small, all of the branches in memmove can be * alot of overhead including the possability of Avx2 being used for really * small blocks if they are aligned. If the block is known to be small, we * can just skip all of that and use the fastest method for small blocks, @@ -118,7 +118,6 @@ namespace VNLib.Utils.Memory Debug.Assert(!Unsafe.IsNullRef(in dstByte), "Null destination reference passed to MemmoveByRef"); _fallbackMemmove.Memmove(in srcByte, ref dstByte, byteCount); - return; } [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] diff --git a/lib/Utils/src/Memory/MemoryUtil.cs b/lib/Utils/src/Memory/MemoryUtil.cs index 774aca3..ba25104 100644 --- a/lib/Utils/src/Memory/MemoryUtil.cs +++ b/lib/Utils/src/Memory/MemoryUtil.cs @@ -32,7 +32,6 @@ using System.Runtime.InteropServices; using System.Runtime.CompilerServices; using System.Runtime.Intrinsics.X86; -using VNLib.Utils.Resources; using VNLib.Utils.Memory.Diagnostics; namespace VNLib.Utils.Memory @@ -86,6 +85,11 @@ namespace VNLib.Utils.Memory /// that will use the array pool before falling back to the . /// heap. /// + /// + /// This value is chosen to be just under the size the CLR will promote an array to the + /// LOH, we can assume any heap impl will have long-term performance than the LOH for + /// large allocations. + /// public const int MAX_UNSAFE_POOL_SIZE = 80 * 1024; //Cache the system page size @@ -314,7 +318,11 @@ namespace VNLib.Utils.Memory /// /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static void InitializeBlock(T[] array) where T : struct => InitializeBlock(array, (uint)array.Length); + public static void InitializeBlock(T[] array) where T : struct + { + ArgumentNullException.ThrowIfNull(array); + InitializeBlock(array, (uint)array.Length); + } /// /// Initializes the array with zeros up to the specified count @@ -327,7 +335,7 @@ namespace VNLib.Utils.Memory [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void InitializeBlock(T[] array, uint count) where T: struct { - ArgumentNullException.ThrowIfNull(array, nameof(array)); + ArgumentNullException.ThrowIfNull(array); //Check bounds CheckBounds(array, 0, count); @@ -348,7 +356,7 @@ namespace VNLib.Utils.Memory [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] public static void InitializeBlock(ref T block, int itemCount) where T : struct { - ThrowIfNullRef(ref block, nameof(block)); + ThrowIfNullRef(in block, nameof(block)); if (itemCount <= 0) { @@ -406,8 +414,7 @@ namespace VNLib.Utils.Memory public static void ZeroStruct(T* structPtr) where T : unmanaged { ArgumentNullException.ThrowIfNull(structPtr); - - ZeroStruct(ref *structPtr); + ZeroStruct(ref Unsafe.AsRef(structPtr)); } /// @@ -431,14 +438,6 @@ namespace VNLib.Utils.Memory #region Copy - /* - * Dirty little trick to access internal Buffer.Memmove method for - * large references. May not always be supported, so optional safe - * guards are in place. - */ - private delegate void BigMemmove(ref byte dest, ref readonly byte src, nuint len); - private static readonly BigMemmove? _clrMemmove = ManagedLibrary.TryGetStaticMethod(typeof(Buffer), "Memmove", System.Reflection.BindingFlags.NonPublic); - /// /// Copies structure data from a source byte reference that points to a sequence of /// of data to the target structure reference. @@ -626,8 +625,11 @@ namespace VNLib.Utils.Memory { ArgumentNullException.ThrowIfNull(source); ArgumentOutOfRangeException.ThrowIfLessThan(target.Length, sizeof(T), nameof(target)); - - CopyStruct(ref *source, target); + + CopyStruct( + ref Unsafe.AsRef(source), + target + ); } /// @@ -677,7 +679,7 @@ namespace VNLib.Utils.Memory Unsafe.CopyBlockUnaligned( ref Refs.AsByte(ref target, 0), - ref Refs.AsByteR(in source, 0), + in Refs.AsByteR(in source, 0), (uint)sizeof(T) ); } @@ -1354,7 +1356,7 @@ namespace VNLib.Utils.Memory /// The size of the span (the size of the block) /// A span over the block of memory pointed to by the handle of the specified size [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Span GetSpan(ref MemoryHandle handle, int size) => new(handle.Pointer, size); + public static Span GetSpan(ref readonly MemoryHandle handle, int size) => new(handle.Pointer, size); /// /// Gets a over the block of memory pointed to by the supplied handle. diff --git a/lib/Utils/src/Memory/ProcessHeap.cs b/lib/Utils/src/Memory/ProcessHeap.cs index 35a2a71..f13181b 100644 --- a/lib/Utils/src/Memory/ProcessHeap.cs +++ b/lib/Utils/src/Memory/ProcessHeap.cs @@ -54,10 +54,7 @@ namespace VNLib.Utils.Memory /// /// Initalizes a new global (cross platform) process heap /// - public ProcessHeap() - { - Trace.WriteLine($"Default heap instnace created {GetHashCode():x}"); - } + public ProcessHeap() => Trace.WriteLine($"Default heap instnace created {GetHashCode():x}"); /// /// @@ -78,13 +75,10 @@ namespace VNLib.Utils.Memory return true; } - + /// - protected override void Free() - { - Trace.WriteLine($"Default heap instnace disposed {GetHashCode():x}"); - } - + protected override void Free() => Trace.WriteLine($"Default heap instnace disposed {GetHashCode():x}"); + /// /// /// diff --git a/lib/Utils/src/Native/SafeLibraryHandle.cs b/lib/Utils/src/Native/SafeLibraryHandle.cs index 6b1af00..ed9dd16 100644 --- a/lib/Utils/src/Native/SafeLibraryHandle.cs +++ b/lib/Utils/src/Native/SafeLibraryHandle.cs @@ -150,11 +150,19 @@ namespace VNLib.Utils.Native private static string? GetLibraryFile(string dirPath, string libPath, SearchOption search) { - //slice the lib to its file name - libPath = Path.GetFileName(libPath); - libPath = Path.ChangeExtension(libPath, OperatingSystem.IsWindows() ? ".dll" : ".so"); - //Select the first file that matches the name - return Directory.EnumerateFiles(dirPath, libPath, search).FirstOrDefault(); + //If the library path already has an extension, just search for the file + if (Path.HasExtension(libPath)) + { + return Directory.EnumerateFiles(dirPath, libPath, search).FirstOrDefault(); + } + else + { + //slice the lib to its file name + libPath = Path.GetFileName(libPath); + libPath = Path.ChangeExtension(libPath, OperatingSystem.IsWindows() ? ".dll" : ".so"); + //Select the first file that matches the name + return Directory.EnumerateFiles(dirPath, libPath, search).FirstOrDefault(); + } } /// @@ -173,7 +181,7 @@ namespace VNLib.Utils.Native bool success = false; DangerousAddRef(ref success); - ObjectDisposedException.ThrowIf(success == false, "The libary has been released!"); + ObjectDisposedException.ThrowIf(success == false, this); try { -- cgit