youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hlsf goes bad

Browse Source
This commit is contained in:
Youmu Liu
2026-05-08 18:09:12 +08:00
parent 8aa319a120
commit d1aca8f745
47 changed files with 5020 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Common/HighPerformance/Memory/SlabAllocator.cs
+24 -28
View File
@@ -56,29 +56,25 @@ namespace StgSharp.HighPerformance.Memory
/// </exception>
/// <remarks>
/// <para><strong> Important Threading Considerations: </strong></para> <para> While SLAB
/// /// /// /// allocators themselves may be designed for single-threaded use,
/// allocated /// objects /// are /// frequently shared across multiple threads in
/// real-world /// applications. Due to /// the /// special implementation of
/// expandable concurrent /// sequential SLAB allocators, /// they rely /// on
/// internal expansion locks to /// ensure that memory buffer expansions /// (which
/// involve /// copying the entire /// buffer to a new location) do not occur while
/// /// other threads are /// reading /// from allocated regions.</para>
/// <para><strong> /// Sequential Layout Limitations: /// /// </strong><br />
/// Sequential layout SLAB allocators /// cannot provide a single- /// threaded ///
/// version because:<list /// type="bullet"><item><description> They use ///
/// contiguous memory /// layout that requires /// buffer expansion when capacity is
/// /// exceeded /// /// </description></item><item><description> Buffer expansion
/// involves /// copying all /// /// existing data to a new memory /// location
/// </description></item><item><description>/// /// Without proper ///
/// synchronization, concurrent access to allocated objects during /// /// expansion
/// /// would cause memory corruption </description></item><item><description> The ///
/// /// /// expansion lock mechanism is essential even if allocation itself is
/// single- /// /// /// threaded</description></item></list></para> <para><strong>
/// Chunked Layout: /// /// /// </strong><br /> Chunked layout allocators can
/// optionally provide single-threaded /// /// /// versions since they don't
/// require buffer expansion and copying. Each /// chunk is /// /// allocated
/// independently, avoiding the memory relocation issues /// present in ///
/// sequential /// layouts.</para>
/// allocators themselves may be designed for single-threaded use, allocated objects are
/// frequently shared across multiple threads in real-world applications. Due to the
/// special implementation of expandable concurrent sequential SLAB allocators, they rely
/// on internal expansion locks to ensure that memory buffer expansions (which involve
/// copying the entire buffer to a new location) do not occur while other threads are
/// reading from allocated regions.</para> <para><strong>Sequential Layout
/// Limitations:</strong><br /> Sequential layout SLAB allocators cannot provide a single-
/// threaded version because:<list type="bullet"><item><description>They use contiguous
/// memory layout that requires buffer expansion when capacity is
/// exceeded</description></item><item><description>Buffer expansion involves copying all
/// existing data to a new memory location</description></item><item><description> Without
/// proper synchronization, concurrent access to allocated objects during synchronization,
/// concurrent access to allocated objects during expansion would cause memory corruption
/// </description></item><item><description> The expansion lock mechanism is essential
/// even if allocation itself is single- threaded</description></item></list></para>
/// <para><strong> Chunked Layout: </strong><br /> Chunked layout allocators can
/// optionally provide single-threaded versions since they don't require buffer expansion
/// and copying. Each chunk is allocated independently, avoiding the memory relocation
/// issues present in sequential layouts.</para>
/// </remarks>
public static SlabAllocator<T> Create<T>(
nuint count,
@@ -89,12 +85,12 @@ namespace StgSharp.HighPerformance.Memory
return layout switch
{
SlabBufferLayout.Sequential => concurrentSupport ?
(new ConcurrentSequentialSlabAllocator<T>(count)) :
(throw new NotSupportedException("Non-concurrent version of sequential layout SLAB is not supported due to expansion lock requirements for memory safety during buffer expansion.")),
new ConcurrentSequentialSlabAllocator<T>(count) :
throw (new NotSupportedException("Non-concurrent version of sequential layout SLAB is not supported due to expansion lock requirements for memory safety during buffer expansion.")),
SlabBufferLayout.Chunked => concurrentSupport ?
(new ConcurrentChunkedSlabAllocator<T>(count)) :
(new ChunkedSlabAllocator<T>(count)),
_ => throw new ArgumentOutOfRangeException(nameof(layout), layout, null)
new ConcurrentChunkedSlabAllocator<T>(count) :
new ChunkedSlabAllocator<T>(count),
_ => throw (new ArgumentOutOfRangeException(nameof(layout), layout, null))
};
}