clear merging conflict

.editorconfig

@@ -1,12 +1,4 @@
-# 禁用所有“代码样式”规则
-dotnet_analyzer_diagnostic.category-Style.severity = none
-
-# 禁用所有“命名”规则
-dotnet_analyzer_diagnostic.category-Naming.severity = none
-
-
-
-[*.cs]
+[*.cs]
 
 # CS1591: 缺少对公共可见类型或成员的 XML 注释
 dotnet_diagnostic.CS1591.severity = suggestion

.gitignore

@@ -1,18 +1,21 @@
-.vs
-/StgSharp.Common/bin
-/StgSharp.Common/obj
-/TestResults
-/STgSharpTest/bin
-/STgSharpTest/obj
-/StgSharp.Script/obj
-/StgSharp.Script/bin
-/StgSharp.TerminalDialogue/build
-/StgSharp.TerminalDialogue/obj
+
 /build
-/StgSharp.Model/bin
-/StgSharp.Model/obj
 /.cr
 /.idea
+/.vs
 /.vscode
+/StgSharp.Common/obj
+/StgSharp.Common/bin
+/StgSharp.Model/obj
+/StgSharp.Model/bin
+/StgSharp.Script/obj
+/StgSharp.Script/bin
+/StgSharp.TerminalDialogue/obj
+/StgSharp.TerminalDialogue/build
 /StgSharpDebug/obj
 /StgSharpDebug/bin
+/STgSharpTest/obj
+/STgSharpTest/bin
+/TestResults
+/StgSharp.Native/x64
+/StgSharp.Native/x64

DvlErrLog.txt

@@ -0,0 +1,3 @@
+System.Exception: Driver Verification Log needs to be created on a 'Release' configuration. The current selected configuration is ''.
+   在 Microsoft.SdvMenuCommand.DriverVerificationLicense..ctor()
+   在 Microsoft.SdvMenuCommand.SdvMenuCommandPackage.StaticToolsLogoMenuItemCallback(Object sender, EventArgs e)

StgSgharp.Generator/Blueprint/BlueprintNodeAttribute.cs

@@ -0,0 +1,39 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BlueprintNodeAttribute.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Blueprint
+{
+    [AttributeUsage( AttributeTargets.Method, AllowMultiple = false )]
+    public class BlueprintNodeExecutionAttribute : Attribute { }
+}

StgSgharp.Generator/Collections/PartialDictionary.cs

@@ -0,0 +1,165 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PartialDictionary.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace StgSharp.Collections
+{
+    public partial class PartialDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+
+        private readonly Dictionary<TKey, TValue> _source;
+        private readonly HashSet<TKey> _keys;
+        private readonly PartialDictionaryValues _values;
+
+        public PartialDictionary(
+                       Dictionary<TKey, TValue> source,
+                       TKey[] index )
+        {
+            _source = source;
+            _keys = new HashSet<TKey>( index );
+            foreach( TKey item in _keys ) {
+                if( !_source.ContainsKey( item ) ) {
+                    _source.Add( item, default! );
+                }
+            }
+            _values = new PartialDictionaryValues( this );
+        }
+
+        public PartialDictionary(
+                       Dictionary<TKey, TValue> source,
+                       HashSet<TKey> keys )
+        {
+            _source = source;
+            _keys = keys;
+            foreach( TKey item in _keys ) {
+                if( !_source.ContainsKey( item ) ) {
+                    _source.Add( item, default! );
+                }
+            }
+            _values = new PartialDictionaryValues( this );
+        }
+
+        public TValue this[ TKey key ]
+        {
+            get
+            {
+                if( _keys.Contains( key ) ) {
+                    return _source[ key ];
+                }
+                throw new KeyNotFoundException();
+            }
+            set
+            {
+                if( _keys.Contains( key ) ) {
+                    _source[ key ] = value;
+                }
+                throw new KeyNotFoundException();
+            }
+        }
+
+        public ICollection<TKey> Keys => _keys;
+
+        public ICollection<TValue> Values => _values;
+
+        public int Count => _keys.Count;
+
+        public bool Contains( KeyValuePair<TKey, TValue> item )
+        {
+            return _keys.Contains( item.Key ) && _source.Contains( item );
+        }
+
+        public bool ContainsKey( TKey key )
+        {
+            return _keys.Contains( key );
+        }
+
+        public void CopyTo( KeyValuePair<TKey, TValue>[] array, int arrayIndex )
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            foreach( TKey item in _keys ) {
+                yield return new KeyValuePair<TKey, TValue>(item, _source[item]);
+            }
+        }
+
+        public bool TryGetValue( TKey key, out TValue value )
+        {
+            if( _keys.Contains( key ) ) {
+                value = _source[ key ];
+                return true;
+            }
+            value = default!;
+            return false;
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(
+                                                             KeyValuePair<TKey, TValue> item )
+        {
+            return;
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(
+                                                             KeyValuePair<TKey, TValue> item )
+        {
+            throw new NotSupportedException();
+        }
+
+        void IDictionary<TKey, TValue>.Add( TKey key, TValue value )
+        {
+            return;
+        }
+
+        bool IDictionary<TKey, TValue>.Remove( TKey key )
+        {
+            throw new NotSupportedException();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+    }
+}

StgSgharp.Generator/Collections/PartialDictionaryValues.cs

@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PartialDictionaryValues.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Collections
+{
+    public partial class PartialDictionary<TKey, TValue>
+    {
+
+        internal sealed class PartialDictionaryValues : ICollection<TValue>
+        {
+
+            private readonly PartialDictionary<TKey, TValue> _values;
+
+            public PartialDictionaryValues(
+                           PartialDictionary<TKey, TValue> value )
+            {
+                _values = value;
+            }
+
+            public bool IsReadOnly => true;
+
+            public int Count => _values.Count;
+
+            void ICollection<TValue>.Add( TValue item )
+            {
+                return;
+            }
+
+            void ICollection<TValue>.Clear()
+            {
+                return;
+            }
+
+            public bool Contains( TValue item )
+            {
+                foreach (var kvp in _values) 
+                {
+                    if (kvp.Value != null && kvp.Value.Equals(item))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public void CopyTo( TValue[] array, int arrayIndex )
+            {
+                foreach (var kvp in _values)
+                {
+                    array[arrayIndex] = kvp.Value;
+                    arrayIndex++;
+                }
+            }
+
+            public IEnumerator<TValue> GetEnumerator()
+            {
+                foreach (var key in _values._keys)
+                {
+                    yield return _values._source[key];
+                }
+            }
+
+            bool ICollection<TValue>.Remove( TValue item )
+            {
+                throw new NotSupportedException();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+        }
+
+    }
+}

StgSgharp.Generator/ExpCodeGenerator.cs

@@ -0,0 +1,20 @@
+using Microsoft.CodeAnalysis;
+
+using System;
+
+namespace StgSgharp.Generator.Expression
+{
+    [Generator]
+    public class ExpCodeGenerator : ISourceGenerator
+    {
+        public void Execute(GeneratorExecutionContext context)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Initialize(GeneratorInitializationContext context)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

StgSgharp.Generator/ExpReader.cs

@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpReader.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.MemoryMappedFiles;
+using System.Text;
+
+namespace StgSgharp.Generator.Expression
+{
+    internal class ExpFileReader:IDisposable
+    {
+        private FileStream _expFileStream;
+        private MemoryMappedFile _expMemoryMappedFile;
+        private bool disposedValue;
+
+        public ExpFileReader( string path )
+        {
+            if( !File.Exists( path ) ) {
+                throw new FileNotFoundException();
+            }
+            _expFileStream = new FileStream(
+                path, FileMode.Open, FileAccess.Read );
+            _expMemoryMappedFile = MemoryMappedFile.CreateFromFile(
+                _expFileStream, null, 0, MemoryMappedFileAccess.Read,
+                HandleInheritability.None, true );
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (disposing)
+                {
+                    _expFileStream.Dispose();
+                    _expMemoryMappedFile.Dispose();
+                }
+
+                disposedValue = true;
+            }
+        }
+
+        // ~ExpFileReader()
+        // {
+        //     Dispose(disposing: false);
+        // }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+
+        public MemoryMappedViewStream CreateMemoryStram()
+        {
+            return _expMemoryMappedFile.CreateViewStream();
+        }
+    }
+}

StgSgharp.Generator/ExpressionReader/ExpReader.cs

@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpReader.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.MemoryMappedFiles;
+using System.Text;
+
+namespace StgSharp.Expression
+{
+    internal class ExpFileReader : IDisposable
+    {
+
+        private bool disposedValue;
+        private FileStream _expFileStream;
+        private MemoryMappedFile _expMemoryMappedFile;
+
+        public ExpFileReader( string path )
+        {
+            if( !File.Exists( path ) ) {
+                throw new FileNotFoundException();
+            }
+            _expFileStream = new FileStream(
+                path, FileMode.Open, FileAccess.Read );
+            _expMemoryMappedFile = MemoryMappedFile.CreateFromFile(
+                _expFileStream, null, 0, MemoryMappedFileAccess.Read,
+                HandleInheritability.None, true );
+        }
+
+        public MemoryMappedViewStream CreateMemoryStram()
+        {
+            return _expMemoryMappedFile.CreateViewStream();
+        }
+
+        // ~ExpFileReader()
+        // {
+        //     Dispose(disposing: false);
+        // }
+
+        public void Dispose()
+        {
+            Dispose( disposing: true );
+            GC.SuppressFinalize( this );
+        }
+
+        protected virtual void Dispose( bool disposing )
+        {
+            if( !disposedValue ) {
+                if( disposing ) {
+                    _expFileStream.Dispose();
+                    _expMemoryMappedFile.Dispose();
+                }
+
+                disposedValue = true;
+            }
+        }
+
+    }
+}

StgSgharp.Generator/FakeType/PartialDictionary.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+//[assembly: InternalsVisibleTo("StgSharp.Generator")]
+namespace StgSharp.Generator.FakeType
+{
+    internal class PartialDictionary<TKey,TValue>
+    {
+    }
+}

StgSgharp.Generator/SourceGenerator/BpNodeGenerator.cs

@@ -0,0 +1,119 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BpNodeGenerator.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+
+using StgSharp.Blueprint;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace StgSharp.Generator
+{
+    internal class BpNodeSyntaxReceiver : ISyntaxReceiver
+    {
+        private static readonly string _indexTypeName = typeof( PartialDictionary<string, object> ).Name;
+        private static BpNodeSyntaxReceiver receiver = new BpNodeSyntaxReceiver();
+
+        public List<MethodDeclarationSyntax> ValidMethod { get; private set; } = new List<MethodDeclarationSyntax>();
+        public List<MethodDeclarationSyntax> InvalidMethod { get; private set; } = new List<MethodDeclarationSyntax>();
+
+        public BpNodeSyntaxReceiver()
+        {
+            
+        }
+
+        public BpNodeSyntaxReceiver(SyntaxNode node)
+        {
+            OnVisitSyntaxNode(node);
+        }
+
+        public void OnVisitSyntaxNode( SyntaxNode syntaxNode )
+        {
+            if( syntaxNode is MethodDeclarationSyntax mds && mds.AttributeLists
+                    .SelectMany( list => list.Attributes )
+                    .Any( syntax => syntax.Name.ToString() ==
+                                  typeof( BlueprintNodeExecutionAttribute ).Name ) ) {
+                SeparatedSyntaxList<ParameterSyntax> paramList = mds.ParameterList.Parameters;
+                if( mds.Modifiers.Any( SyntaxKind.StaticKeyword ) && paramList.Count ==
+                    2 && paramList[ 0 ].Type!.ToString() == _indexTypeName && paramList[
+                    1 ].Type!.ToString() ==
+                    _indexTypeName ) {
+                    ValidMethod.Add(mds);
+                }
+                else
+                {
+                    InvalidMethod.Add(mds);
+                }
+            }
+        }
+
+        public static void BuildNode(SourceProductionContext context, MethodDeclarationSyntax mds)
+        {
+            if (mds.AttributeLists
+                    .SelectMany(list => list.Attributes)
+                    .Any(syntax => syntax.Name.ToString() ==
+                                  typeof(BlueprintNodeExecutionAttribute).Name))
+            {
+                SeparatedSyntaxList<ParameterSyntax> paramList = mds.ParameterList.Parameters;
+                if (mds.Modifiers.Any(SyntaxKind.StaticKeyword) && paramList.Count ==
+                    2 && paramList[0].Type!.ToString() == _indexTypeName && paramList[
+                    1].Type!.ToString() ==
+                    _indexTypeName)
+                {
+                    var methodName = mds.Identifier.Text;
+                    var sourceText = SourceText.From( """
+                        
+                        """,encoding:Encoding.UTF8);
+                    context.AddSource("GeneratedBlueprintNode.cs", sourceText);
+                }
+                else
+                {
+                    var diagnostic = Diagnostic.Create(
+                        new DiagnosticDescriptor(
+                            id:"SSE0001",
+                            title: "Invalid Blueprint Node Method",
+                            messageFormat: "Blueprint Node Method must be static and have two parameters of type PartialDictionary<string, object>",
+                            category: "Blueprint Node",
+                            DiagnosticSeverity.Error,
+                            isEnabledByDefault: true),
+                        mds.GetLocation(),mds.Identifier.Text);
+                    
+                    context.ReportDiagnostic(diagnostic);
+                }
+            }
+        }
+    }
+}

StgSgharp.Generator/SourceGenerator/MainGenerator.cs

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpCodeGenerator.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using System;
+
+namespace StgSharp.Generator
+{
+    [Generator]
+    public partial class MainGenerator : IIncrementalGenerator
+    {
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            var declaration =
+                context.SyntaxProvider.CreateSyntaxProvider(
+                    predicate: static (s,_) => s is MethodDeclarationSyntax,
+                    transform: static (cds,_) => (MethodDeclarationSyntax)cds.Node
+                    ).Where(static m=>m!=null);
+
+            context.RegisterSourceOutput(declaration, BpNodeSyntaxReceiver.BuildNode);
+        }
+    }
+}

StgSgharp.Generator/StgSgharp.Generator.Expression.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
+    <EnforceExtendedAnalyzerRules>True</EnforceExtendedAnalyzerRules>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" />
+  </ItemGroup>
+
+</Project>

StgSgharp.Generator/StgSharp.Generator.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
+    <EnforceExtendedAnalyzerRules>True</EnforceExtendedAnalyzerRules>
+    <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.12.0" PrivateAssets="all" />
+  </ItemGroup>
+
+</Project>

StgSgharp.Generator/bin/x64/Debug/net8.0/StgSharp.Generator.deps.json

@@ -0,0 +1,177 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v8.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v8.0": {
+      "StgSharp.Generator/1.0.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.CSharp": "4.12.0"
+        },
+        "runtime": {
+          "StgSharp.Generator.dll": {}
+        }
+      },
+      "Microsoft.CodeAnalysis.Analyzers/3.3.4": {},
+      "Microsoft.CodeAnalysis.Common/4.12.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.CodeAnalysis.dll": {
+            "assemblyVersion": "4.12.0.0",
+            "fileVersion": "4.1200.24.57207"
+          }
+        },
+        "resources": {
+          "lib/net8.0/cs/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net8.0/de/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net8.0/es/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net8.0/fr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net8.0/it/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net8.0/ja/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net8.0/ko/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net8.0/pl/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net8.0/pt-BR/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net8.0/ru/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net8.0/tr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net8.0/zh-Hans/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net8.0/zh-Hant/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp/4.12.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
+          "Microsoft.CodeAnalysis.Common": "4.12.0",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.CodeAnalysis.CSharp.dll": {
+            "assemblyVersion": "4.12.0.0",
+            "fileVersion": "4.1200.24.57207"
+          }
+        },
+        "resources": {
+          "lib/net8.0/cs/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net8.0/de/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net8.0/es/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net8.0/fr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net8.0/it/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net8.0/ja/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net8.0/ko/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net8.0/pl/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net8.0/pt-BR/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net8.0/ru/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net8.0/tr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net8.0/zh-Hans/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net8.0/zh-Hant/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "System.Collections.Immutable/8.0.0": {},
+      "System.Reflection.Metadata/8.0.0": {
+        "dependencies": {
+          "System.Collections.Immutable": "8.0.0"
+        }
+      }
+    }
+  },
+  "libraries": {
+    "StgSharp.Generator/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Microsoft.CodeAnalysis.Analyzers/3.3.4": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AxkxcPR+rheX0SmvpLVIGLhOUXAKG56a64kV9VQZ4y9gR9ZmPXnqZvHJnmwLSwzrEP6junUF11vuc+aqo5r68g==",
+      "path": "microsoft.codeanalysis.analyzers/3.3.4",
+      "hashPath": "microsoft.codeanalysis.analyzers.3.3.4.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Common/4.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-c1kNYihL2gdcuU1dqm8R8YeA4YkB43TpU3pa2r66Uooh6AAhRtENzj9A4Kj0a+H8JDDyuTjNZql9XlVUzV+UjA==",
+      "path": "microsoft.codeanalysis.common/4.12.0",
+      "hashPath": "microsoft.codeanalysis.common.4.12.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.CSharp/4.12.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-30vVQ1MizeC22iEdEvI2w0eTIYG43/L20yBzuQH01xKzJgHAoWehzI2F8u07o4mXh4DGMOjQF7aEm0zzvsG3Mg==",
+      "path": "microsoft.codeanalysis.csharp/4.12.0",
+      "hashPath": "microsoft.codeanalysis.csharp.4.12.0.nupkg.sha512"
+    },
+    "System.Collections.Immutable/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AurL6Y5BA1WotzlEvVaIDpqzpIPvYnnldxru8oXJU2yFxFUy3+pNXjXd1ymO+RA0rq0+590Q8gaz2l3Sr7fmqg==",
+      "path": "system.collections.immutable/8.0.0",
+      "hashPath": "system.collections.immutable.8.0.0.nupkg.sha512"
+    },
+    "System.Reflection.Metadata/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ptvgrFh7PvWI8bcVqG5rsA/weWM09EnthFHR5SCnS6IN+P4mj6rE1lBDC4U8HL9/57htKAqy4KQ3bBj84cfYyQ==",
+      "path": "system.reflection.metadata/8.0.0",
+      "hashPath": "system.reflection.metadata.8.0.0.nupkg.sha512"
+    }
+  }
+}

StgSgharp.Generator/global.cs

@@ -0,0 +1,5 @@
+global using StgSharp.Generator.FakeType;
+
+using System;
+using System.Collections.Generic;
+using System.Text;

StgSgharp.Generator/obj/Debug/net8.0/.NETCoreApp,Version=v8.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]

StgSgharp.Generator/obj/Debug/net8.0/StgSharp.Generator.AssemblyInfo.cs

@@ -0,0 +1,22 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+ccef0de6f686f94da655b0e7d854d0acaf907d04")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

StgSgharp.Generator/obj/Debug/net8.0/StgSharp.Generator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+ca176cd5c61d2dc85f29a7103c4d4591277128a58e3ae9a0f9404b3db20450b2

StgSgharp.Generator/obj/Debug/net8.0/StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,21 @@
+is_global = true
+build_property.TargetFramework = net8.0
+build_property.TargetFramework = net8.0
+build_property.TargetPlatformMinVersion = 
+build_property.TargetPlatformMinVersion = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = True
+build_property.EnforceExtendedAnalyzerRules = True
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp.Generator
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

StgSgharp.Generator/obj/Debug/netstandard2.0/.NETStandard,Version=v2.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]

StgSgharp.Generator/obj/Debug/netstandard2.0/StgSharp.Generator.AssemblyInfo.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+e687473132786f419a48170313782d6779890c3d")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

StgSgharp.Generator/obj/Debug/netstandard2.0/StgSharp.Generator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+507d0d80fe4bf532ef6f4152e1c0274456709eeaf88b7cd0eff97aa75d6b6d89

StgSgharp.Generator/obj/Debug/netstandard2.0/StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,13 @@
+is_global = true
+build_property.TargetFramework = netstandard2.0
+build_property.TargetPlatformMinVersion = 7.0
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = True
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp.Generator
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

StgSgharp.Generator/obj/Release/netstandard2.0/.NETStandard,Version=v2.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]

StgSgharp.Generator/obj/Release/netstandard2.0/StgSharp.Generator.AssemblyInfo.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+e687473132786f419a48170313782d6779890c3d")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

StgSgharp.Generator/obj/Release/netstandard2.0/StgSharp.Generator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+59be71384a64c08c0d97414b957b3c19dad4e0c90fb7132416c556cc8ca21e76

StgSgharp.Generator/obj/Release/netstandard2.0/StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,13 @@
+is_global = true
+build_property.TargetFramework = netstandard2.0
+build_property.TargetPlatformMinVersion = 7.0
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = True
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp.Generator
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

StgSgharp.Generator/obj/StgSharp.Generator.csproj.nuget.dgspec.json

@@ -0,0 +1,81 @@
+{
+  "format": 1,
+  "restore": {
+    "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\StgSharp.Generator.csproj": {}
+  },
+  "projects": {
+    "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\StgSharp.Generator.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\StgSharp.Generator.csproj",
+        "projectName": "StgSharp.Generator",
+        "projectPath": "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\StgSharp.Generator.csproj",
+        "packagesPath": "C:\\Users\\Youmu\\.nuget\\packages\\",
+        "outputPath": "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\obj\\",
+        "projectStyle": "PackageReference",
+        "fallbackFolders": [
+          "C:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+        ],
+        "configFilePaths": [
+          "C:\\Users\\Youmu\\AppData\\Roaming\\NuGet\\NuGet.Config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config",
+          "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+        ],
+        "originalTargetFrameworks": [
+          "net8.0"
+        ],
+        "sources": {
+          "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+          "C:\\Program Files\\dotnet\\library-packs": {},
+          "D:\\Programmer\\NugetLocal": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net8.0": {
+            "targetAlias": "net8.0",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "warnAsError": [
+            "NU1605"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "direct"
+        }
+      },
+      "frameworks": {
+        "net8.0": {
+          "targetAlias": "net8.0",
+          "dependencies": {
+            "Microsoft.CodeAnalysis.CSharp": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[4.12.0, )"
+            }
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\8.0.400/PortableRuntimeIdentifierGraph.json"
+        }
+      }
+    }
+  }
+}

StgSgharp.Generator/obj/StgSharp.Generator.csproj.nuget.g.props

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
+    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
+    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\Youmu\.nuget\packages\;C:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.11.0</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="C:\Users\Youmu\.nuget\packages\" />
+    <SourceRoot Include="C:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages\" />
+  </ItemGroup>
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.4\buildTransitive\Microsoft.CodeAnalysis.Analyzers.props" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.4\buildTransitive\Microsoft.CodeAnalysis.Analyzers.props')" />
+  </ImportGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgMicrosoft_CodeAnalysis_Analyzers Condition=" '$(PkgMicrosoft_CodeAnalysis_Analyzers)' == '' ">C:\Users\Youmu\.nuget\packages\microsoft.codeanalysis.analyzers\3.3.4</PkgMicrosoft_CodeAnalysis_Analyzers>
+  </PropertyGroup>
+</Project>

StgSgharp.Generator/obj/StgSharp.Generator.csproj.nuget.g.targets

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.4\buildTransitive\Microsoft.CodeAnalysis.Analyzers.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.analyzers\3.3.4\buildTransitive\Microsoft.CodeAnalysis.Analyzers.targets')" />
+  </ImportGroup>
+</Project>

StgSgharp.Generator/obj/project.nuget.cache

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "dgSpecHash": "M4+jwtEt0Jc=",
+  "success": true,
+  "projectFilePath": "D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\StgSgharp.Generator\\StgSharp.Generator.csproj",
+  "expectedPackageFiles": [
+    "C:\\Users\\Youmu\\.nuget\\packages\\microsoft.codeanalysis.analyzers\\3.3.4\\microsoft.codeanalysis.analyzers.3.3.4.nupkg.sha512",
+    "C:\\Users\\Youmu\\.nuget\\packages\\microsoft.codeanalysis.common\\4.12.0\\microsoft.codeanalysis.common.4.12.0.nupkg.sha512",
+    "C:\\Users\\Youmu\\.nuget\\packages\\microsoft.codeanalysis.csharp\\4.12.0\\microsoft.codeanalysis.csharp.4.12.0.nupkg.sha512",
+    "C:\\Users\\Youmu\\.nuget\\packages\\system.collections.immutable\\8.0.0\\system.collections.immutable.8.0.0.nupkg.sha512",
+    "C:\\Users\\Youmu\\.nuget\\packages\\system.reflection.metadata\\8.0.0\\system.reflection.metadata.8.0.0.nupkg.sha512"
+  ],
+  "logs": []
+}

StgSgharp.Generator/obj/x64/Debug/net8.0/.NETCoreApp,Version=v8.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.AssemblyInfo.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+ccef0de6f686f94da655b0e7d854d0acaf907d04")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+ca176cd5c61d2dc85f29a7103c4d4591277128a58e3ae9a0f9404b3db20450b2

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,21 @@
+is_global = true
+build_property.TargetFramework = net8.0
+build_property.TargetFramework = net8.0
+build_property.TargetPlatformMinVersion = 
+build_property.TargetPlatformMinVersion = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = True
+build_property.EnforceExtendedAnalyzerRules = True
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp.Generator
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.csproj.CoreCompileInputs.cache

@@ -0,0 +1 @@
+afa1b1a9352ed44b12e962cfd8520ff4e6ef5d54d99232294685245ea111c904

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.csproj.FileListAbsolute.txt

@@ -0,0 +1,13 @@
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\bin\x64\Debug\net8.0\StgSharp.Generator.deps.json
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\bin\x64\Debug\net8.0\StgSharp.Generator.dll
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\bin\x64\Debug\net8.0\StgSharp.Generator.pdb
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.csproj.AssemblyReference.cache
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.AssemblyInfoInputs.cache
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.AssemblyInfo.cs
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.csproj.CoreCompileInputs.cache
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.sourcelink.json
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.dll
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\refint\StgSharp.Generator.dll
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\StgSharp.Generator.pdb
+D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\obj\x64\Debug\net8.0\ref\StgSharp.Generator.dll

StgSgharp.Generator/obj/x64/Debug/net8.0/StgSharp.Generator.sourcelink.json

@@ -0,0 +1 @@
+{"documents":{"D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\*":"https://raw.githubusercontent.com/Nitload-NSI/CCD_Github/ae94c265ae77870ea6498b624b6f71b78fb94e51/*"}}

StgSgharp.Generator/obj/x64/Debug/netstandard2.0/.NETStandard,Version=v2.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]

StgSgharp.Generator/obj/x64/Release/netstandard2.0/.NETStandard,Version=v2.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]

StgSgharp.Generator/obj/x64/Release/netstandard2.0/StgSharp.Generator.AssemblyInfo.cs

@@ -0,0 +1,23 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本:4.0.30319.42000
+//
+//     对此文件的更改可能会导致不正确的行为，并且如果
+//     重新生成代码，这些更改将会丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+e687473132786f419a48170313782d6779890c3d")]
+[assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Generator")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+

StgSgharp.Generator/obj/x64/Release/netstandard2.0/StgSharp.Generator.AssemblyInfoInputs.cache

@@ -0,0 +1 @@
+59be71384a64c08c0d97414b957b3c19dad4e0c90fb7132416c556cc8ca21e76

StgSgharp.Generator/obj/x64/Release/netstandard2.0/StgSharp.Generator.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,13 @@
+is_global = true
+build_property.TargetFramework = netstandard2.0
+build_property.TargetPlatformMinVersion = 7.0
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = True
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = StgSharp.Generator
+build_property.ProjectDir = D:\NitloadIndustry\研究项目\1-Flagship\TH2020\ProjectFile\内核源代码\StgSgharp.Generator\
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 

StgSharp.Common/.vs/StgSharp/v17/DocumentLayout.backup.json

@@ -0,0 +1,12 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "D:\\NitloadIndustry\\\u7814\u7A76\u9879\u76EE\\1-Flagship\\TH2020\\ProjectFile\\\u5185\u6838\u6E90\u4EE3\u7801\\StgSharp\\",
+  "Documents": [],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": []
+    }
+  ]
+}

StgSharp.Common/.vs/StgSharp/v17/DocumentLayout.json

@@ -0,0 +1,12 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "D:\\NitloadIndustry\\\u7814\u7A76\u9879\u76EE\\1-Flagship\\TH2020\\ProjectFile\\\u5185\u6838\u6E90\u4EE3\u7801\\StgSharp\\",
+  "Documents": [],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": []
+    }
+  ]
+}

StgSharp.Common/Collections/CachePool.cs

@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CachePool.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using StgSharp.Graphics.OpenGL;
+
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Commom.Collections
+{
+    /*
+    public interface IPoolItem<TSignature>
+    {
+
+        public int ID
+        {
+            get;
+            init;
+        }
+
+    }
+
+    public class CacheIndexPool<TSignature, TItem> : IEnumerable<TItem>
+        where TItem: IPoolItem<TSignature>
+    {
+
+        public CacheIndexPool(
+                       Func<TSignature> 
+ ) { }
+
+    }
+    /**/
+}

StgSharp.Common/Geometries/SpaceGeometry/Class1.cs

@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Class1.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Geometries.SpaceGeometry
+{
+    internal class Class1 { }
+}

StgSharp.Common/Graphics/IGraphicAPIs.cs

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IGraphicAPIs.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IGraphicAPIs
+    {
+
+        public IntPtr GraphicApiPackageHandle
+        {
+            get;
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/IRegisterType.cs

@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IRegisterType.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance
+{
+    public interface IRegisterType
+    {
+
+        public ref T AsRef<T>() where T: unmanaged, INumber<T>;
+
+        public ref T Member<T>(int index) where T: unmanaged, INumber<T>;
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/BufferStack.cs

@@ -0,0 +1,167 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="BufferStack.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    [CollectionBuilder(typeof(BufferStackBuilder), nameof(BufferStackBuilder.Create))]
+    public unsafe class BufferStack<T> : IDisposable where T: unmanaged
+    {
+
+        private byte* _buffer;
+        private ulong _count;
+
+        public BufferStack(int capacity)
+        {
+            if (capacity <= 0) {
+                throw new ArgumentOutOfRangeException(nameof(capacity));
+            }
+
+            AllocateBuffer(capacity);
+        }
+
+        public int Count
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (int)_count;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear()
+        {
+            ((Header*)_buffer)->Top = 0;
+            _count = 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Dispose()
+        {
+            Marshal.FreeHGlobal((nint)_buffer);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T Pop()
+        {
+            Header* header = (Header*)_buffer;
+            if (header->Top == 0) {
+                throw new InvalidOperationException("Stack underflow");
+            }
+
+            header->Top--;
+            _count--;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+            return dataStart[header->Top];
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Push(T item)
+        {
+            Header* header = (Header*)_buffer;
+            if (header->Top >= header->Capacity) {
+                Expand();
+            }
+
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+            dataStart[header->Top] = item;
+            header->Top++;
+            _count++;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryPop(out T value)
+        {
+            Header* header = (Header*)_buffer;
+            if (header->Top == 0)
+            {
+                value = default;
+                return false;
+            }
+            header->Top--;
+            _count--;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+            value = dataStart[header->Top];
+            return true;
+        }
+
+        // Internal method for efficient bulk initialization
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void InitializeFromSpan(ReadOnlySpan<T> span)
+        {
+            if (span.IsEmpty) {
+                return;
+            }
+
+            Header* header = (Header*)_buffer;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+
+            fixed (T* sourcePtr = span) {
+                Buffer.MemoryCopy(sourcePtr, dataStart, 
+                    header->Capacity * (nuint)sizeof(T), 
+                    (nuint)span.Length * (nuint)sizeof(T));
+            }
+
+            header->Top = (nuint)span.Length;
+            _count = (ulong)span.Length;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void AllocateBuffer(int capacity)
+        {
+            nuint size = (nuint)sizeof(Header) + ((nuint)capacity * (nuint)sizeof(T));
+            _buffer = (byte*)NativeMemory.Alloc(size);
+            Header* header = (Header*)_buffer;
+            header->Top = 0;
+            header->Capacity = (nuint)capacity;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void Expand()
+        {
+            Header* header = (Header*)_buffer;
+            nuint newCap = header->Capacity * 2;
+            nuint newSize = (nuint)sizeof(Header) + newCap * (nuint)sizeof(T);
+            _buffer = (byte*)NativeMemory.Realloc(_buffer, newSize);
+            header = (Header*)_buffer;
+            header->Capacity = newCap;
+        }
+
+        private struct Header
+        {
+
+            public nuint Capacity;
+            public nuint Top;
+
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/ConcurrentBufferStack.cs

@@ -0,0 +1,291 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ConcurrentBufferStack.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Threading;
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public static class BufferStackBuilder
+    {
+
+        // For BufferStack collection builder
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static BufferStack<T> Create<T>(ReadOnlySpan<T> span) where T: unmanaged
+        {
+            if (span.IsEmpty)
+            {
+                return new BufferStack<T>(4); // Default small capacity
+            }
+
+            BufferStack<T> stack = new BufferStack<T>(span.Length);
+
+
+            // Use internal method for efficient bulk initialization
+            stack.InitializeFromSpan(span);
+
+            return stack;
+        }
+
+        // For ConcurrentBufferStack collection builder
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ConcurrentBufferStack<T> CreateConcurrent<T>(ReadOnlySpan<T> span) where T: unmanaged
+        {
+            if (span.IsEmpty)
+            {
+                return new ConcurrentBufferStack<T>(4); // Default small capacity
+            }
+
+            ConcurrentBufferStack<T> stack = new ConcurrentBufferStack<T>(span.Length);
+
+
+            // Use internal method for efficient bulk initialization
+            stack.InitializeFromSpan(span);
+
+            return stack;
+        }
+
+    }
+
+    [CollectionBuilder(builderType: typeof(BufferStackBuilder), methodName: nameof(BufferStackBuilder.CreateConcurrent))]
+    public unsafe class ConcurrentBufferStack<T> : IDisposable where T: unmanaged
+    {
+
+        private byte* _buffer;
+        private readonly BufferExpansionLock _lock = new();
+        private ulong _count;
+
+        public ConcurrentBufferStack(int capacity)
+        {
+            if (capacity <= 0) {
+                throw new ArgumentOutOfRangeException(nameof(capacity));
+            }
+
+            AllocateBuffer(capacity);
+        }
+
+        public ulong Count
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => Volatile.Read(ref _count);
+        }
+
+        public void Clear()
+        {
+            Header* header = (Header*)_buffer;
+            _lock.EnterExpansionProcess();
+            try
+            {
+                header->Top = 0;
+                Volatile.Write(ref _count, 0);
+            }
+            finally
+            {
+                _lock.ExitExpansionProcess();
+            }
+        }
+
+        public void Dispose()
+        {
+            _lock.Dispose();
+            Marshal.FreeHGlobal((nint)_buffer);
+        }
+
+        public T Pop()
+        {
+            Header* header = (Header*)_buffer;
+            while (true)
+            {
+                nuint oldTop = Volatile.Read(ref header->Top);
+                if (oldTop <= 0) {
+                    throw new InvalidOperationException("Stack underflow");
+                }
+
+                if (Interlocked.CompareExchange(ref header->Top, oldTop - 1, oldTop) == oldTop)
+                {
+                    _lock.EnterBufferRead();
+                    try
+                    {
+                        T* dataStart = (T*)(_buffer + sizeof(Header));
+                        _ = Interlocked.Decrement(ref _count);
+                        return dataStart[oldTop - 1];
+                    }
+                    finally
+                    {
+                        _lock.ExitBufferRead();
+                    }
+                }
+                Thread.Sleep(0); // Yield to avoid busy waiting
+            }
+        }
+
+        public void Push(T item)
+        {
+            while (true)
+            {
+                _lock.EnterMetaDataRead();
+                try
+                {
+                    Header* header = (Header*)_buffer;
+                    nuint oldTop = Volatile.Read(ref header->Top);
+                    nuint cap = Volatile.Read(ref header->Capacity);
+                    if (oldTop >= cap)
+                    {
+                        _lock.ExitMetaDataRead();
+                        _lock.EnterExpansionProcess();
+                        try
+                        {
+                            header = (Header*)_buffer;
+                            if (header->Top >= header->Capacity)
+                            {
+                                nuint newCap = header->Capacity * 2;
+                                nuint newSize = (nuint)sizeof(Header) + (newCap * (nuint)sizeof(T));
+
+                                _lock.EnterBufferCopy();
+                                try
+                                {
+                                    _buffer = (byte*)NativeMemory.Realloc(_buffer, newSize);
+                                    ((Header*)_buffer)->Capacity = newCap;
+                                }
+                                finally
+                                {
+                                    _lock.ExitBufferCopy();
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            _lock.ExitExpansionProcess();
+                        }
+                        continue;
+                    }
+
+                    if (Interlocked.CompareExchange(ref header->Top, oldTop + 1, oldTop) == oldTop)
+                    {
+                        _lock.EnterBufferRead();
+                        try
+                        {
+                            T* dataStart = (T*)(_buffer + sizeof(Header));
+                            dataStart[oldTop] = item;
+                            _ = Interlocked.Increment(ref _count);
+                            return;
+                        }
+                        finally
+                        {
+                            _lock.ExitBufferRead();
+                        }
+                    }
+                }
+                finally
+                {
+                    if (_lock.IsThreadReadingMetaData) {
+                        _lock.ExitMetaDataRead();
+                    }
+                }
+                Thread.Sleep(0); // Yield to avoid busy waiting
+            }
+        }
+
+        public bool TryPop(out T value)
+        {
+            Header* header = (Header*)_buffer;
+            while (true)
+            {
+                nuint oldTop = Volatile.Read(ref header->Top);
+                if (oldTop <= 0)
+                {
+                    value = default;
+                    return false;
+                }
+
+                if (Interlocked.CompareExchange(ref header->Top, oldTop - 1, oldTop) == oldTop)
+                {
+                    _lock.EnterBufferRead();
+                    try
+                    {
+                        T* dataStart = (T*)(_buffer + sizeof(Header));
+                        value = dataStart[oldTop - 1];
+                        _ = Interlocked.Decrement(ref _count);
+                    }
+                    finally
+                    {
+                        _lock.ExitBufferRead();
+                    }
+                    return true;
+                }
+                Thread.Sleep(0); // Yield to avoid busy waiting
+            }
+        }
+
+        // Internal method for efficient bulk initialization
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal unsafe void InitializeFromSpan(ReadOnlySpan<T> span)
+        {
+            if (span.IsEmpty) {
+                return;
+            }
+
+            Header* header = (Header*)_buffer;
+            T* dataStart = (T*)(_buffer + sizeof(Header));
+
+            fixed (T* sourcePtr = span) {
+                Buffer.MemoryCopy(sourcePtr, dataStart, 
+                    header->Capacity * (nuint)sizeof(T), 
+                    (nuint)span.Length * (nuint)sizeof(T));
+            }
+
+            header->Top = (nuint)span.Length;
+            Volatile.Write(ref _count, (ulong)span.Length);
+        }
+
+        private void AllocateBuffer(int capacity)
+        {
+            nuint size = (nuint)sizeof(Header) + ((nuint)capacity * (nuint)sizeof(T));
+            _buffer = (byte*)NativeMemory.Alloc(size);
+            Header* header = (Header*)_buffer;
+            header->Top = 0;
+            header->Capacity = (nuint)capacity;
+        }
+
+        private struct Header
+        {
+
+            public nuint Capacity;   // max capacity of the stack (number of elements)
+            public nuint Top;        // next available index in the stack
+
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Alloc.cs

@@ -61,6 +61,7 @@ namespace StgSharp.HighPerformance.Memory
                 return new hlsfHandle(handle, size);
             }
 
+            fallback:
             i = level;
             s = segmentIndex;
             while (!TryPopLevelForAllocation(i, s, out handle))
@@ -76,7 +77,8 @@ namespace StgSharp.HighPerformance.Memory
                         throw new OverflowException("Out of memory: Unable to allocate new 16MB block or find suitable bucket for allocation.");
                     }
 
-                    break;
+                    Thread.Sleep(0);
+                    goto fallback;
                 }
             }
 
@@ -84,23 +86,26 @@ namespace StgSharp.HighPerformance.Memory
                 SliceMemory(handle, (segmentIndex + 1) * levelSizeArray[level]);
             }
 
-            return new hlsfHandle(handle, size);
+                return new hlsfHandle(handle, size);
+            }
+            finally
+            {
+                ReleaseEntryNextLock(handle);
+            }
         }
 
         private void SliceMemory(Entry* e, int offset)
         {
             Entry* current = e;
             ulong n = e->NextNear;
-            Entry* next = (Entry*)n;
+            Entry* next = e;
 
             ulong originOffset = e->Position - (ulong)m_Buffer;
             ulong finalOffset = originOffset + (ulong)offset;
-            ulong end = e->Position + e->Size - (ulong)m_Buffer;
             int remainSize = (int)(e->Size - offset);
 
-            if ((originOffset & 63) != 0) {
-                throw new InvalidOperationException("Entry position offset is not aligned to 64 bytes.");
-            }
+            AcquireEntryNextLock(e);
+            AcquireEntryPrevLock(next);
 
             int minLevel = Math.Max((BitOperations.TrailingZeroCount(finalOffset) - 6) / 2, 0);
             int i = minLevel >= levelSizeArray.Length ? levelSizeArray.Length - 1 : minLevel;
@@ -112,9 +117,13 @@ namespace StgSharp.HighPerformance.Memory
                 int blockCount = (int)((ulong.Min(board, end) - board) / (ulong)levelSize);
                 if (blockCount == 0)
                 {
-                    break;
-                }
-                int s = blockCount * levelSize;
+                    int levelSize = levelSizeArray[i];
+                    int blockCount = remainSize / levelSize % 4;
+                    if (blockCount == 0)
+                    {
+                        break;
+                    }
+                    int s = blockCount * levelSize;
 
                 // create and init new entry
                 Entry* newEntry = (Entry*)_entries.Allocate();
@@ -123,12 +132,24 @@ namespace StgSharp.HighPerformance.Memory
                 BucketNode* bucket = (BucketNode*)newEntry->Position;
                 bucket->EntryRef = newEntry;
 
-                // link new entry
-                newEntry->PreviousNear = (ulong)current;
-                newEntry->NextNear = n;
-                current->NextNear = (ulong)newEntry;
-                if (next != null) {
+                    // link new entry
+                    newEntry->PreviousNear = (ulong)current;
+                    newEntry->NextNear = n;
+                    current->NextNear = (ulong)newEntry;
                     next->PreviousNear = (ulong)newEntry;
+
+                    newEntry->Level = i;
+                    PushLevel(i, blockCount - 1, bucket);
+
+                    // set new entry
+                    Entry* old = current;
+                    current = newEntry;
+
+                    // update lock and data
+                    finalOffset += (ulong)s;
+                    remainSize -= s;
+                    ReleaseEntryNextLock(old);
+                    AcquireEntryNextLock(current);
                 }
 
                 newEntry->Level = i;
@@ -183,8 +204,63 @@ namespace StgSharp.HighPerformance.Memory
                 remainSize -= s;
                 if (remainSize <= 0)
                 {
-                    break;
+                    ReleaseEntryNextLock(current);
+                    ReleaseEntryPrevLock(next);
+                    return;
                 }
+                for (; i >= 0; i--)
+                {
+                    int levelSize = levelSizeArray[i];
+                    int blockCount = remainSize / levelSize % 4;
+                    if (blockCount == 0)
+                    {
+                        continue;
+                    }
+                    int s = blockCount * levelSize;
+
+                    // create and init new entry
+                    Entry* newEntry = (Entry*)_entries.Allocate();
+                    newEntry->LockBuffer = 0;
+                    newEntry->Position = (nuint)((ulong)m_Buffer + finalOffset);
+                    newEntry->Size = (uint)s;
+                    BucketNode* bucket = (BucketNode*)newEntry->Position;
+                    bucket->EntryRef = newEntry;
+                    bucket->LockBuffer = 0;
+                    newEntry->State = EntryState.ThreadOccupied;
+
+                    // link new entry
+                    newEntry->PreviousNear = (ulong)current;
+                    current->NextNear = (ulong)newEntry;
+                    newEntry->NextNear = n;
+                    next->PreviousNear = (ulong)newEntry;
+
+                    newEntry->Level = i;
+                    PushLevel(i, blockCount - 1, bucket);
+
+                    // set new entry
+                    Entry* old = current;
+                    current = newEntry;
+
+                    // update lock and data
+                    finalOffset += (ulong)s;
+                    remainSize -= s;
+                    ReleaseEntryNextLock(old);
+                    AcquireEntryNextLock(current);
+                    if (remainSize <= 0)
+                    {
+                        break;
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+            finally
+            {
+                // Release locks in reverse order
+                ReleaseEntryNextLock(current);
+                ReleaseEntryPrevLock(next);
             }
         }
 
@@ -199,13 +275,22 @@ namespace StgSharp.HighPerformance.Memory
         /// </returns>
         private bool TryAllocateNew16MBBlock(out Entry* handle)
         {
-            nuint pos = _spareMemory->Position;
+            nuint pos = Volatile.Read(ref _spareMemory->Position);
             nuint blockSize = (nuint)levelSizeArray[^1] * 2; // Use last level size (16MB)
             nuint newPos = pos + blockSize;
 
-            ulong p = _spareMemory->PreviousNear;
-            Entry* previous = (Entry*)p;
-
+            ulong p;
+            Entry* previous;
+            do
+            {
+                p = Volatile.Read(ref _spareMemory->PreviousNear);
+                previous = (Entry*)p;
+                if (previous != null) {
+                    AcquireEntryNextLock(previous);
+                }
+                AcquireEntryPrevLock(_spareMemory);
+                break;
+            } while (true);
             if (_spareMemory->Size <= 0)
             {
                 handle = null;
@@ -225,20 +310,34 @@ namespace StgSharp.HighPerformance.Memory
             handle->Size = (uint)blockSize;
             handle->Level = GetLevelFromSize((uint)blockSize);
 
-            // Update spare memory position
-            _spareMemory->Position = newPos;
-            BucketNode* b = (BucketNode*)handle->Position;
-            b->EntryRef = handle;
-            PushLevel(handle->Level, DetermineSegmentIndex((uint)blockSize, handle->Level), b);
+                handle->PrevLock = 0;
+                handle->NextLock = 0;
 
-            // update position linked list
-            handle->NextNear = (ulong)_spareMemory;
-            handle->PreviousNear = p;
-            _spareMemory->PreviousNear = (ulong)handle;
-            if (previous != null) {
-                previous->NextNear = (ulong)handle;
+                // Update spare memory position
+                _spareMemory->Position = newPos;
+                BucketNode* b = (BucketNode*)handle->Position;
+                b->EntryRef = handle;
+                PushLevel(handle->Level, DetermineSegmentIndex((uint)blockSize, handle->Level), b);
+
+                // update position linked list
+                handle->NextNear = (ulong)_spareMemory;
+                handle->PreviousNear = p;
+                _spareMemory->PreviousNear = (ulong)handle;
+                if (previous != null) {
+                    previous->NextNear = (ulong)handle;
+                }
+                return true;
+            }
+            catch
+            {
+                handle = null;
+                return false;
+            }
+            finally
+            {
+                ReleaseEntryNextLock(previous);
+                ReleaseEntryPrevLock(_spareMemory);
             }
-            return true;
         }
 
         /// <summary>

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.BucketNode.cs

@@ -39,6 +39,12 @@ namespace StgSharp.HighPerformance.Memory
     public unsafe partial class HybridLayerSegregatedFitAllocator
     {
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void AcquireBucketNodeSpinLock(BucketNode* node)
+        {
+            AcquireBucketNodeBothLocks(node);
+        }
+
         /// <summary>
         ///   Initialize bucket system (called in constructor)
         /// </summary>
@@ -47,16 +53,6 @@ namespace StgSharp.HighPerformance.Memory
             _bucketHeads = new ulong[levelSizeArray.Length * 3];
         }
 
-        #region BucketNode Operations
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static bool IsNullOrEmpty(BucketNode* node)
-        {
-            return node == null || node->Magic != BucketNode.MAGIC_NUMBER;
-        }
-
-            #endregion
-
         private void PushLevel(int levelIndex, int sizeIndex, BucketNode* node)
         {
             if (node == null || node->EntryRef == null) {
@@ -64,112 +60,269 @@ namespace StgSharp.HighPerformance.Memory
             }
 
             int index = (3 * levelIndex) + sizeIndex;
-            if (_bucketHeads[index] == EmptyHandle)
+            if (Interlocked.CompareExchange(ref _bucketHeads[index], (nuint)node, EmptyHandle) == EmptyHandle)
             {
-                _bucketHeads[index] = (nuint)node;
                 node->IsInBucket = true;
                 node->Magic = BucketNode.MAGIC_NUMBER;
-                node->NextLevel = EmptyHandle;
-                node->PreviousLevel = EmptyHandle;
                 return;
+            } else
+            {
+                while (true)
+                {
+                    AcquireBucketNodeNextLock(node);
+                    ulong head = Volatile.Read(ref _bucketHeads[index]);
+                    node->NextLevel = head;
+                    BucketNode* headNode = (BucketNode*)head;
+
+                    try
+                    {
+                        if (Interlocked.CompareExchange(ref _bucketHeads[index], (nuint)node, head) == head)
+                        {
+                            if (headNode != null && !TryAcquireBucketNodePrevLock(headNode))
+                            {
+                                // reset state and retry
+                                _ = Interlocked.CompareExchange(ref _bucketHeads[index], head, (nuint)node);
+                                Thread.Sleep(0);
+                                continue;
+                            }
+                            try
+                            {
+                                node->IsInBucket = true;
+                                node->Magic = BucketNode.MAGIC_NUMBER;
+                                if (headNode != null) {
+                                    headNode->PreviousLevel = (ulong)node;
+                                }
+                                return;
+                            }
+                            finally
+                            {
+                                if (headNode != null) {
+                                    ReleaseBucketNodePrevLock(headNode);
+                                }
+                            }
+                        } else
+                        {
+                            Thread.Sleep(0);
+                            continue;
+                        }
+                    }
+                    finally
+                    {
+                        ReleaseBucketNodeNextLock(node);
+                    }
+                }
             }
+        }
 
-
-            // Add to head of linked list
-            ulong head = _bucketHeads[index];
-            BucketNode* headNode = (BucketNode*)head;
-
-            node->NextLevel = head;
-            node->PreviousLevel = EmptyHandle;
-            node->IsInBucket = true;
-            node->Magic = BucketNode.MAGIC_NUMBER;
-
-            if (headNode != null) {
-                headNode->PreviousLevel = (ulong)node;
+        /// <summary>
+        ///   根据锁类型释放BucketNode锁
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseBucketNodeLockByType(BucketNode* node, byte lockType)
+        {
+            switch (lockType)
+            {
+                case 0:
+                    ReleaseBucketNodePrevLock(node);
+                    return;  // PrevLock
+                case 1:
+                    ReleaseBucketNodeBothLocks(node);
+                    return; // BothLocks
+                case 2:
+                    ReleaseBucketNodeNextLock(node);
+                    return;  // NextLock
+                default:
+                    return;
             }
+        }
 
-            _bucketHeads[index] = (nuint)node;
+        /// <summary>
+        ///   按地址顺序释放BucketNode锁
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseOrderedBucketLocks(BucketNode* previous, BucketNode* node, BucketNode* next)
+        {
+            if (previous != null) {
+                ReleaseBucketNodeNextLock(previous);
+            }
+            if (node != null) {
+                ReleaseBucketNodeBothLocks(node);
+            }
+            if (next != null) {
+                ReleaseBucketNodePrevLock(next);
+            }
         }
 
         private void RemoveFromBucket(int levelIndex, int sizeIndex, BucketNode* node)
         {
             int index = (3 * levelIndex) + sizeIndex;
-
-            if ((BucketNode*)_bucketHeads[index] == node)
+            while (true)
             {
-                _bucketHeads[index] = EmptyHandle;
-                return;
-            }
+                if ((BucketNode*)Volatile.Read(ref _bucketHeads[index]) == node)
+                {
+                    if (TryPopLevel(levelIndex, sizeIndex, out _)) {
+                        return;
+                    }
+                    Thread.Sleep(0);
+                    continue;
+                }
 
-            ulong p = node->PreviousLevel;
-            ulong n = node->NextLevel;
-            BucketNode* previous = (BucketNode*)p;
-            BucketNode* next = (BucketNode*)n;
+                ulong p = Volatile.Read(ref node->PreviousLevel);
+                ulong n = Volatile.Read(ref node->NextLevel);
+                BucketNode* previous = (BucketNode*)p;
+                BucketNode* next = (BucketNode*)n;
 
-            if (previous != null) {
-                previous->NextLevel = n;
-            }
-            if (next != null) {
-                next->PreviousLevel = p;
-            }
+                if (!TryAcquireOrderedBucketLocks(previous, node, next))
+                {
+                    Thread.Sleep(0);
+                    continue;
+                }
 
-            node->NextLevel = EmptyHandle;
-            node->PreviousLevel = EmptyHandle;
-            node->IsInBucket = false;
+                try
+                {
+                    if (Volatile.Read(ref node->PreviousLevel) != p || Volatile.Read(ref node->NextLevel) != n)
+                    {
+                        Thread.Sleep(0);
+                        continue;
+                    }
+
+                    if (previous != null) {
+                        previous->NextLevel = n;
+                    }
+                    if (next != null) {
+                        next->PreviousLevel = p;
+                    }
+
+                    node->NextLevel = EmptyHandle;
+                    node->PreviousLevel = EmptyHandle;
+                    node->IsInBucket = false;
+                    return;
+                }
+                finally
+                {
+                    ReleaseOrderedBucketLocks(previous, node, next);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireBucketNodeSpinLock(BucketNode* node)
+        {
+            return TryAcquireBucketNodeBothLocks(node);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireOrderedBucketLocks(BucketNode* previous, BucketNode* node, BucketNode* next)
+        {
+            if (previous != null && node != null && next != null)
+            {
+                // previous -> node -> next
+                return TryAcquireBucketNodeNextLock(previous) &&
+                       TryAcquireBucketNodeBothLocks(node) &&
+                       TryAcquireBucketNodePrevLock(next);
+            } else if (previous != null && node != null) {
+                return TryAcquireBucketNodeNextLock(previous) && TryAcquireBucketNodeBothLocks(node);
+            }
+            return true;
         }
 
         private bool TryPopLevel(int levelIndex, int sizeIndex, out BucketNode* node)
         {
             int index = (3 * levelIndex) + sizeIndex;
-            ulong h = _bucketHeads[index];
-            BucketNode* head = (BucketNode*)h;
-
-            if (head == null)
+            while (true)
             {
-                node = null;
-                return false;
+                ulong h = Volatile.Read(ref _bucketHeads[index]);
+                BucketNode* head = (BucketNode*)h;
+
+                if (head == null)
+                {
+                    node = null;
+                    return false;
+                }
+
+                if (!TryAcquireBucketNodeNextLock(head))
+                {
+                    Thread.Sleep(0);
+                    continue;
+                }
+
+                ulong n = Volatile.Read(ref head->NextLevel);
+                BucketNode* next = (BucketNode*)n;
+
+                if (next == null)
+                {
+                    if (Interlocked.CompareExchange(ref _bucketHeads[index], EmptyHandle, h) == h)
+                    {
+                        node = head;
+                        return true;
+                    }
+                    node = null;
+                    return false;
+                }
+                try
+                {
+                    if (!TryAcquireBucketNodePrevLock(next))
+                    {
+                        Thread.Sleep(0);
+                        continue;
+                    }
+
+                    try
+                    {
+                        if (Interlocked.CompareExchange(ref _bucketHeads[index], head->NextLevel, h) == h)
+                        {
+                            node = head;
+                            node->IsInBucket = false;
+                            node->NextLevel = EmptyHandle;
+                            if (next != null) {
+                                next->PreviousLevel = EmptyHandle;
+                            }
+                            return true;
+                        } else
+                        {
+                            Thread.Sleep(0);
+                            continue;
+                        }
+                    }
+                    finally
+                    {
+                        if (next != null) {
+                            ReleaseBucketNodePrevLock(next);
+                        }
+                    }
+                }
+                finally
+                {
+                    ReleaseBucketNodeNextLock(head);
+                }
             }
-
-            ulong n = head->NextLevel;
-            BucketNode* next = (BucketNode*)n;
-
-            if (next == null)
-            {
-                _bucketHeads[index] = EmptyHandle;
-                node = head;
-                node->IsInBucket = false;
-                node->NextLevel = EmptyHandle;
-                node->PreviousLevel = EmptyHandle;
-                return true;
-            }
-
-            _bucketHeads[index] = head->NextLevel;
-            node = head;
-            node->IsInBucket = false;
-            node->NextLevel = EmptyHandle;
-
-            if (next != null) {
-                next->PreviousLevel = EmptyHandle;
-            }
-
-            return true;
         }
 
         private bool TryRemoveFromBucket(int levelIndex, int sizeIndex, BucketNode* node)
         {
             int index = (3 * levelIndex) + sizeIndex;
-            if ((BucketNode*)_bucketHeads[index] == node)
+            if ((BucketNode*)Volatile.Read(ref _bucketHeads[index]) == node)
             {
-                _bucketHeads[index] = EmptyHandle;
-                return true;
+                if (TryPopLevel(levelIndex, sizeIndex, out _)) {
+                    return true;
+                }
+                return false;
+            }
+
+            ulong p = Volatile.Read(ref node->PreviousLevel);
+            ulong n = Volatile.Read(ref node->NextLevel);
+            BucketNode* previous = (BucketNode*)p;
+            BucketNode* next = (BucketNode*)n;
+
+            if (!TryAcquireOrderedBucketLocks(previous, node, next)) {
+                return false;
             }
 
             try
             {
-                ulong p = node->PreviousLevel;
-                ulong n = node->NextLevel;
-                BucketNode* previous = (BucketNode*)p;
-                BucketNode* next = (BucketNode*)n;
+                if (Volatile.Read(ref node->PreviousLevel) != p || Volatile.Read(ref node->NextLevel) != n) {
+                    return false;
+                }
 
                 if (previous != null) {
                     previous->NextLevel = n;
@@ -183,9 +336,9 @@ namespace StgSharp.HighPerformance.Memory
                 node->IsInBucket = false;
                 return true;
             }
-            catch
+            finally
             {
-                return false;
+                ReleaseOrderedBucketLocks(previous, node, next);
             }
         }
 
@@ -193,7 +346,7 @@ namespace StgSharp.HighPerformance.Memory
         ///   BucketNode structure - specialized node for bucket linked lists Stored in main
         ///   allocation area (user-overwritable region)
         /// </summary>
-        [StructLayout(LayoutKind.Explicit, Size = 32)]
+        [StructLayout(LayoutKind.Explicit, Size = 40)]
         internal struct BucketNode
         {
 
@@ -201,12 +354,149 @@ namespace StgSharp.HighPerformance.Memory
 
             [FieldOffset(16)] internal Entry* EntryRef;     // Pointer to corresponding Entry
             [FieldOffset(28)] internal bool IsInBucket;     // Whether in bucket
+            [FieldOffset(36)] internal int NextLock;
+            [FieldOffset(32)] internal int PrevLock;
             [FieldOffset(24)] internal uint Magic;          // Magic number verification
+            [FieldOffset(32)] internal ulong LockBuffer;
 
             [FieldOffset(0)]  internal ulong NextLevel;     // Bucket stack linked list: next pointer
             [FieldOffset(8)]  internal ulong PreviousLevel; // Bucket stack linked list: previous pointer
 
         }
 
+        #region BucketNode Operations
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool IsNullOrEmpty(BucketNode* node)
+        {
+            return node == null || node->Magic != BucketNode.MAGIC_NUMBER;
+        }
+
+        // BucketNode 前驱锁操作（控制PreviousLevel字段）
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireBucketNodePrevLock(BucketNode* node)
+        {
+            if (node == null) {
+                return true;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            return Interlocked.CompareExchange(ref node->PrevLock, thread, 0) == 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void AcquireBucketNodePrevLock(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            if (Volatile.Read(ref node->PrevLock) != thread)
+            {
+                while (Interlocked.CompareExchange(ref node->PrevLock, thread, 0) != 0) {
+                    Thread.Sleep(0);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseBucketNodePrevLock(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            if (Volatile.Read(ref node->PrevLock) == thread) {
+                Volatile.Write(ref node->PrevLock, 0);
+            }
+        }
+
+        // BucketNode 后继锁操作（控制NextLevel字段）
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireBucketNodeNextLock(BucketNode* node)
+        {
+            if (node == null) {
+                return true;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            return Interlocked.CompareExchange(ref node->NextLock, thread, 0) == 0;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void AcquireBucketNodeNextLock(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            if (Volatile.Read(ref node->NextLock) != thread)
+            {
+                while (Interlocked.CompareExchange(ref node->NextLock, thread, 0) != 0) {
+                    Thread.Sleep(0);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseBucketNodeNextLock(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            int thread = Environment.CurrentManagedThreadId;
+            if (Volatile.Read(ref node->NextLock) == thread) {
+                Volatile.Write(ref node->NextLock, 0);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireBucketNodeBothLocks(BucketNode* node)
+        {
+            if (node == null) {
+                return true;
+            }
+
+            if (TryAcquireBucketNodePrevLock(node))
+            {
+                if (TryAcquireBucketNodeNextLock(node))
+                {
+                    return true;
+                } else
+                {
+                    ReleaseBucketNodePrevLock(node); // 回滚
+                    return false;
+                }
+            }
+            return false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseBucketNodeBothLocks(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            ReleaseBucketNodePrevLock(node);
+            ReleaseBucketNodeNextLock(node);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void AcquireBucketNodeBothLocks(BucketNode* node)
+        {
+            if (node == null) {
+                return;
+            }
+
+            AcquireBucketNodePrevLock(node);
+            AcquireBucketNodeNextLock(node);
+        }
+
+        #endregion
     }
 }

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Debug.cs

@@ -41,44 +41,6 @@ namespace StgSharp.HighPerformance.Memory
 
         private object _lock = new object();
 
-        public void DisplayAllocatedEntryLayout(bool singleStep)
-        {
-            lock (_lock)
-            {
-                Entry* cur = _spareMemory;
-                while (cur != null)
-                {
-                    if (cur->State == EntryState.Allocated)
-                    {
-                        Console.WriteLine(EntryToString(cur));
-                        if (singleStep) {
-                            Console.ReadKey();
-                        }
-                    }
-                    cur = (Entry*)cur->PreviousNear;
-                }
-            }
-        }
-
-        public void DisplayEmptyEntryLayout(bool singleStep)
-        {
-            lock (_lock)
-            {
-                Entry* cur = _spareMemory;
-                while (cur != null)
-                {
-                    if (cur->State == EntryState.Empty)
-                    {
-                        Console.WriteLine(EntryToString(cur));
-                        if (singleStep) {
-                            Console.ReadKey();
-                        }
-                    }
-                    cur = (Entry*)cur->PreviousNear;
-                }
-            }
-        }
-
         public void DisplayEntryLayout(bool singleStep)
         {
             lock (_lock)

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.Free.cs

@@ -28,6 +28,13 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
 using hlsfHandle = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
 
 namespace StgSharp.HighPerformance.Memory
@@ -47,6 +54,13 @@ namespace StgSharp.HighPerformance.Memory
             if (e == null) {
                 return;
             }
+            AcquireEntrySpinLock(e);
+            try
+            {
+                if (GetEntryState(e) != EntryState.Allocated) {
+                    return;
+                }
+                SetEntryState(e, EntryState.ThreadOccupied);
 
             if (e->State != EntryState.Allocated) {
                 return;

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.SegmentEntry.cs

@@ -41,18 +41,24 @@ namespace StgSharp.HighPerformance.Memory
     public unsafe partial class HybridLayerSegregatedFitAllocator
     {
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void AcquireEntrySpinLock(Entry* entry)
+        {
+            AcquireEntryBothLocks(entry);
+        }
+
         private bool AssertBackwardBoundary(ulong current, Entry* target, int level)
         {
-            ulong align = (ulong)levelSizeArray[level + 1];
-            ulong targetOffset = target->Position - (ulong)m_Buffer;
-            return current / align == targetOffset / align;
+            int size = (level * 2) + 6;
+            ulong align = current >> size;
+            return align == target->Position >> size && align == (current + target->Size) >> size;
         }
 
         private bool AssertForwardBoundary(ulong current, Entry* target, int level)
         {
-            ulong align = (ulong)levelSizeArray[level + 1];
-            ulong targetOffset = target->Position + target->Size - (ulong)m_Buffer;
-            return current / align == targetOffset / align;
+            int size = (level * 2) + 6;
+            ulong align = current >> size;
+            return align == target->Position >> size && align == (current - target->Size) >> size;
         }
 
         /// <summary>
@@ -77,7 +83,8 @@ namespace StgSharp.HighPerformance.Memory
 
         /// <summary>
         ///   Used in Free operations, efficiently remove from buckets and merge adjacent blocks.
-        ///   Current Entry will serve as the final merged block.
+        ///   Current Entry will serve as the final merged block. The Merge will be in lazy
+        ///   strategy, any fail in acquiring spin lock will end a merging process.
         /// </summary>
         private void MergeAndRemoveFromBuckets(Entry* entry)
         {
@@ -85,6 +92,7 @@ namespace StgSharp.HighPerformance.Memory
                 return;
             }
 
+            Entry* result = entry;
             uint size = entry->Size;
             int originLevel = GetLevelFromSize(size);
             int segment = DetermineSegmentIndex(size, originLevel);
@@ -154,7 +162,7 @@ namespace StgSharp.HighPerformance.Memory
 
         private void RecycleEntry(Entry* entry)
         {
-            if (entry == null) {
+            if (entry is null) {
                 return;
             }
 
@@ -163,29 +171,45 @@ namespace StgSharp.HighPerformance.Memory
             _entries.Free((nuint)entry);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ReleaseEntrySpinLock(Entry* entry)
+        {
+            ReleaseEntryBothLocks(entry);
+        }
+
         /// <summary>
         ///   Remove node from position linked list
         /// </summary>
         private void RemoveFromPositionChain(Entry* entry)
         {
-            if (entry == null) {
-                return;
-            }
+            AcquireEntrySpinLock(entry);
+            try
+            {
+                Entry* prev = (Entry*)entry->PreviousNear;
+                Entry* next = (Entry*)entry->NextNear;
 
-            Entry* prev = (Entry*)entry->PreviousNear;
-            Entry* next = (Entry*)entry->NextNear;
+                if (prev != null) {
+                    prev->NextNear = entry->NextNear;
+                }
+                if (next != null) {
+                    next->PreviousNear = entry->PreviousNear;
+                }
 
-            if (prev != null) {
-                prev->NextNear = entry->NextNear;
+                // Clear node pointers
+                entry->NextNear = EmptyHandle;
+                entry->PreviousNear = EmptyHandle;
+                _entries.Free((nuint)entry);
             }
-            if (next != null) {
-                next->PreviousNear = entry->PreviousNear;
+            finally
+            {
+                ReleaseEntrySpinLock(entry);
             }
+        }
 
-            // Clear node pointers
-            entry->NextNear = EmptyHandle;
-            entry->PreviousNear = EmptyHandle;
-            _entries.Free((nuint)entry);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool TryAcquireEntrySpinLock(Entry* entry)
+        {
+            return TryAcquireEntryBothLocks(entry);
         }
 
         /// <summary>
@@ -198,6 +222,7 @@ namespace StgSharp.HighPerformance.Memory
 
             [FieldOffset(28)] internal int Level;           // Level of the block in the allocator
             [FieldOffset(24)] internal uint Size;           // Block size information
+            [FieldOffset(32)] internal ulong LockBuffer;
             [FieldOffset(8)]  internal ulong NextNear;      // Position linked list: next pointer
             [FieldOffset(16)] internal ulong PreviousNear;  // Position linked list: previous pointer
             [FieldOffset(32)] public EntryState State;

StgSharp.Common/HighPerformance/Memory/HLSFAllocator.cs

@@ -66,6 +66,8 @@ namespace StgSharp.HighPerformance.Memory
             _spareMemory->PreviousNear = EmptyHandle;
             _spareMemory->NextNear = EmptyHandle;
             _spareMemory->Position = (nuint)m_Buffer;
+            _spareMemory->PrevLock = 0;
+            _spareMemory->NextLock = 0;
             _spareMemory->Size = (uint)byteSize;
         }
 
@@ -87,6 +89,8 @@ namespace StgSharp.HighPerformance.Memory
             _spareMemory->PreviousNear = EmptyHandle;
             _spareMemory->NextNear = EmptyHandle;
             _spareMemory->Position = (nuint)m_Buffer;
+            _spareMemory->PrevLock = 0;
+            _spareMemory->NextLock = 0;
             _spareMemory->Size = (uint)byteSize;
         }
 

StgSharp.Common/HighPerformance/Memory/ISlabAllocatable.cs

@@ -0,0 +1,40 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ISlabAllocatable.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public interface ISlabAllocatable { }
+}

StgSharp.Common/HighPerformance/Memory/InroductionToHLSF.md

@@ -0,0 +1,271 @@
+# HLSF (Hybrid Layer Segregated Fit) Allocator
+
+A high-performance, O(1) memory allocator designed for real-time applications that demand predictable allocation and deallocation performance.
+
+## Overview
+
+The Hybrid Layer Segregated Fit (HLSF) allocator is a sophisticated memory management system that combines the benefits of segregated free lists with layered size classification. It provides constant-time allocation and deallocation operations while maintaining excellent memory utilization and low fragmentation.
+
+## Key Features
+
+### Performance Characteristics
+- **O(1) Time Complexity**: Both allocation and deallocation operations execute in constant time
+- **High Throughput**: Capable of handling millions of operations per second
+- **Low Latency**: Predictable performance suitable for real-time applications
+- **Excellent Deallocation Speed**: Superior free performance compared to traditional allocators
+
+### Memory Management
+- **External Metadata Storage**: All allocation metadata is stored in external SLAB allocators, keeping the main allocation area clean
+- **Native Byte Alignment Control**: Configurable alignment (minimum 16 bytes) with hardware-optimized defaults
+- **Large Block Support**: Single allocation limit of 32MB per request
+- **Efficient Memory Utilization**: Low overhead with intelligent block merging
+
+### Architecture
+- **10-Level Hierarchy**: Size classes from 64 bytes to 16MB (64, 256, 1KB, 4KB, 16KB, 64KB, 256KB, 1MB, 4MB, 16MB)
+- **3-Segment Segregation**: Each level is divided into 3 segments for better size distribution
+- **Hybrid Approach**: Combines best aspects of segregated fit and layered allocation strategies
+
+## Architecture Details
+
+### Size Classification System
+
+The allocator uses a logarithmic size classification system with 10 levels:
+
+```
+Level 0: 64 bytes      (2^6)
+Level 1: 256 bytes     (2^8)  
+Level 2: 1KB           (2^10)
+Level 3: 4KB           (2^12)
+Level 4: 16KB          (2^14)
+Level 5: 64KB          (2^16)
+Level 6: 256KB         (2^18)
+Level 7: 1MB           (2^20)
+Level 8: 4MB           (2^22)
+Level 9: 16MB          (2^24)
+```
+
+Each level follows the pattern: `size = 64 * 4^level`
+
+### Bucket Organization
+
+Each size level is further divided into 3 segments based on exact size requirements:
+- **Segment 0**: 1x level size
+- **Segment 1**: 2x level size  
+- **Segment 2**: 3x level size
+
+This provides fine-grained size matching while maintaining O(1) lookup performance.
+
+### External Metadata Design
+
+Unlike traditional allocators that embed metadata within allocated blocks, HLSF stores all metadata externally:
+
+- **Entry Structure (36 bytes)**: Contains position, size, level, and linkage information
+- **BucketNode Structure (32 bytes)**: Manages free block organization with integrity verification
+- **SLAB Storage**: Both structures are allocated from separate SLAB allocators for optimal cache performance
+
+This design provides several advantages:
+- Clean allocation areas free from metadata corruption
+- Better cache locality for metadata operations
+- Simplified debugging and memory inspection
+- No metadata overhead in allocated blocks
+
+## Performance Benchmarks
+
+*Note: The following results are from informal testing and should be considered preliminary.*
+
+### Single-threaded Performance (65,536 operations)
+
+| Operation | Average Time | Throughput | Performance Rating |
+|-----------|--------------|------------|-------------------|
+| Allocation | 31-40ms | ~2M allocs/sec | Good |
+| Free | 2-3ms | ~25M frees/sec | Excellent |
+
+**Test Configuration:**
+- Pool Size: 16MB
+- Block Sizes: 64-1024 bytes (mixed)
+- Platform: x64, .NET 8
+- Iterations: 5 rounds
+
+### Memory Efficiency
+
+- **Metadata Overhead**: ~2.8% of total allocation
+- **Alignment**: 16-byte default (configurable)
+- **Fragmentation**: Low due to intelligent merging algorithms
+
+## Usage Examples
+
+### Basic Allocation
+
+```csharp
+// Create allocator with 64MB pool
+using var allocator = new HybridLayerSegregatedFitAllocator(64 * 1024 * 1024);
+
+// Allocate 1KB block
+var handle = allocator.Alloc(1024);
+
+// Use the allocated memory
+Span<byte> memory = handle.BufferHandle;
+memory[0] = 42;
+
+// Free the block
+allocator.Free(handle);
+```
+
+### Custom Alignment
+
+```csharp
+// Create allocator with 32-byte alignment
+using var allocator = new HybridLayerSegregatedFitAllocator(
+    byteSize: 32 * 1024 * 1024,
+    align: 32
+);
+
+var handle = allocator.Alloc(256);
+// Memory is guaranteed to be 32-byte aligned
+```
+
+### Bulk Operations
+
+```csharp
+var handles = new List<HybridLayerSegregatedFitAllocationHandle>();
+
+// Allocate multiple blocks
+for (int i = 0; i < 1000; i++)
+{
+    handles.Add(allocator.Alloc((uint)(64 + i % 960))); // 64-1023 bytes
+}
+
+// Free all blocks
+foreach (var handle in handles)
+{
+    allocator.Free(handle);
+}
+```
+
+## API Reference
+
+### HybridLayerSegregatedFitAllocator
+
+Main allocator class providing memory management functionality.
+
+#### Constructors
+
+```csharp
+public HybridLayerSegregatedFitAllocator(nuint byteSize)
+public HybridLayerSegregatedFitAllocator(nuint byteSize, int align)
+```
+
+#### Methods
+
+```csharp
+public HybridLayerSegregatedFitAllocationHandle Alloc(uint size)
+public void Free(HybridLayerSegregatedFitAllocationHandle handle)
+public void Dispose()
+```
+
+### HybridLayerSegregatedFitAllocationHandle
+
+Handle representing an allocated memory block.
+
+#### Properties
+
+```csharp
+public readonly byte* Pointer { get; }
+public readonly Span<byte> BufferHandle { get; }
+public readonly uint AllocSize { get; }
+public readonly ref byte this[int index] { get; }
+```
+
+## Thread Safety
+
+The current implementation is **single-threaded**. For multi-threaded applications, external synchronization is required. A concurrent version is planned for future releases.
+
+## Comparison with Other Allocators
+
+### vs TLSF (Two-Level Segregated Fit)
+
+| Aspect | HLSF | TLSF | Notes |
+|--------|------|------|-------|
+| Allocation Speed | ~2M ops/sec | ~3-5M ops/sec | HLSF has optimization potential |
+| Deallocation Speed | ~25M ops/sec | ~10-15M ops/sec | **HLSF advantage** |
+| Memory Overhead | ~2.8% | ~1-2% | HLSF uses external metadata |
+| Time Complexity | O(1) | O(1) | Equal |
+| Code Complexity | Moderate | Low | HLSF more sophisticated |
+
+### Strengths
+- Superior deallocation performance
+- Clean separation of data and metadata
+- Configurable alignment support
+- Excellent for allocation-heavy workloads
+
+### Areas for Improvement
+- Allocation speed optimization
+- Memory overhead reduction
+- Concurrent implementation
+
+## Implementation Notes
+
+### Alignment Guarantees
+
+- Minimum alignment: 16 bytes
+- All allocations respect specified alignment
+- Internal blocks aligned to 64-byte boundaries for optimal cache performance
+
+### Merging Strategy
+
+The allocator employs an aggressive merging strategy:
+
+1. **Immediate Merging**: Adjacent free blocks are merged during deallocation
+2. **Boundary Checking**: Ensures merging respects level boundaries
+3. **Bidirectional Merging**: Checks both forward and backward neighbors
+4. **Level Promotion**: Merged blocks may be promoted to higher levels
+
+## Future Roadmap
+
+### Planned Optimizations
+
+1. **Performance Enhancements**
+   - Lookup table optimization for size classification
+   - Bucket operation improvements
+   - SIMD utilization for bulk operations
+
+2. **Concurrent Support**
+   - Thread-local caches
+   - Lock-free bucket operations
+   - NUMA-aware allocation
+
+3. **Advanced Features**
+   - Adaptive size level adjustment
+   - Memory pressure handling
+   - Statistics and profiling support
+
+### Target Performance Goals
+
+- Allocation Speed: 4-6M ops/sec (single-threaded)
+- Memory Overhead: <1.5%
+- Fragmentation Rate: <3%
+- Concurrent Scaling: Linear up to 16 threads
+
+## Building and Testing
+
+The HLSF allocator is part of the StgSharp.Common library and requires:
+
+- .NET 8 or later
+- x64 architecture (no x86 support planned)
+- Windows/Linux
+
+### Running Benchmarks
+
+```csharp
+// See StgSharpDebug/Program.cs for comprehensive benchmark suite
+var allocator = new HybridLayerSegregatedFitAllocator(16 * 1024 * 1024);
+// Run allocation/deallocation cycles...
+```
+
+## License
+
+This implementation is part of the StgSharp project and follows the project's licensing terms.
+
+## Contributing
+
+Performance improvements, bug fixes, and documentation enhancements are welcome. Please ensure all changes maintain the O(1) performance guarantees and include appropriate benchmarks.

StgSharp.Common/HighPerformance/Memory/SlabAllocator.ChunkedConcurrent.cs

@@ -0,0 +1,153 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SlabAllocator.ChunkedConcurrent.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Threading;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    internal sealed unsafe class ConcurrentChunkedSlabAllocator<T> : SlabAllocator<T> where T: unmanaged
+    {
+
+        private readonly BufferExpansionLock _lock = new();
+        private ConcurrentBufferStack<nuint> _buffers;
+        private ConcurrentBufferStack<nuint> _recycle;
+        private readonly int _elementSize = Unsafe.SizeOf<T>();
+
+        private nuint _currentBuffer;
+        private nuint _currentCapacity, _currentIndex;
+
+        public ConcurrentChunkedSlabAllocator(nuint count)
+        {
+            _currentBuffer = (nuint)NativeMemory.Alloc(count * (nuint)_elementSize);
+            _currentCapacity = count;
+            int initCount = count switch
+            {
+                <= 4 => 4,
+                > 64 => 64,
+                _ => (int)count
+            };
+            Span<nuint> span = stackalloc nuint[initCount];
+            for (int i = 0; i < initCount; i++) {
+                span[i] = _currentBuffer + (nuint)(i * _elementSize);
+            }
+            _buffers = new(4);
+            _recycle = BufferStackBuilder.CreateConcurrent(span);
+            _currentCapacity = count;
+            _currentIndex = (nuint)initCount;
+        }
+
+        public override nuint Allocate()
+        {
+            if (_recycle.TryPop(out nuint handle)) {
+                return handle;
+            }
+            while (true)
+            {
+                nuint bufferHandle = Volatile.Read(ref _currentBuffer);
+                nuint curIndex = Volatile.Read(ref _currentIndex);
+                _lock.EnterMetaDataRead();
+                try
+                {
+                    if (curIndex >= _currentCapacity)
+                    {
+                        _lock.ExitMetaDataRead();
+                        _lock.EnterExpansionProcess();
+                        try
+                        {
+                            nuint cap = Volatile.Read(ref _currentCapacity);
+                            nuint newBuffer = (nuint)NativeMemory.Alloc(cap * (nuint)_elementSize);
+                            _buffers.Push(bufferHandle);
+                            _ = Interlocked.Exchange(ref _currentBuffer, newBuffer);
+                            _ = Interlocked.Exchange(ref _currentIndex, 0);
+                        }
+                        finally
+                        {
+                            _lock.ExitExpansionProcess();
+                        }
+                    }
+                    curIndex = Volatile.Read(ref _currentIndex);
+                    _ = Interlocked.Add(
+                        ref Unsafe.As<nuint, ulong>(ref _currentIndex), (ulong)_elementSize);
+                    return _currentBuffer + ((nuint)_elementSize * curIndex);
+                }
+                finally
+                {
+                    if (_lock.IsThreadReadingMetaData) {
+                        _lock.ExitMetaDataRead();
+                    }
+                }
+            }
+        }
+
+        public override void Dispose()
+        {
+            NativeMemory.Free((void*)_currentBuffer);
+            while (_buffers.TryPop(out nuint buffer)) {
+                NativeMemory.Free((void*)buffer);
+            }
+            _lock.Dispose();
+            _buffers.Dispose();
+            _recycle.Dispose();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void EnterBufferReading() { }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void ExitBufferReading() { }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void Free(nuint index)
+        {
+            _recycle.Push(index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override SlabAllocationHandle<T> ReadAllocation()
+        {
+            return new SlabAllocationHandle<T>(this, false);
+        }
+
+        ~ConcurrentChunkedSlabAllocator()
+        {
+            Dispose();
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/SlabAllocator.SequencialConcurrent.cs

@@ -0,0 +1,161 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SlabAllocator.SequencialConcurrent.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Threading;
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public sealed unsafe class ConcurrentSequentialSlabAllocator<T> : SlabAllocator<T> where T: unmanaged
+    {
+
+        private T* _buffer;
+
+        private readonly BufferExpansionLock _lock = new();
+        private readonly ConcurrentBufferStack<nuint> _stack;
+        private readonly int _elementSize;
+        private nuint _highestAllocated;
+        private ulong _capacity;
+
+        public ConcurrentSequentialSlabAllocator(nuint initialCapacity)
+        {
+            _elementSize = Unsafe.SizeOf<T>();
+            _capacity = initialCapacity;
+            _highestAllocated = 0;
+
+            _buffer = (T*)NativeMemory.Alloc((nuint)_capacity * (nuint)_elementSize);
+            int initCount = _capacity switch
+            {
+                <= 4 => 4,
+                > 64 => 64,
+                _ => (int)_capacity / 4
+            };
+            Span<nuint> span = stackalloc nuint[initCount];
+            for (int i = 0; i < initCount; i++) {
+                span[i] = (nuint)i;
+            }
+            _stack = BufferStackBuilder.CreateConcurrent(span);
+            _highestAllocated += (nuint)initCount;
+        }
+
+        internal T* BasePointer
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _buffer;
+        }
+
+        public override nuint Allocate()
+        {
+            if (_stack.TryPop(out nuint index)) {
+                return index;
+            }
+            while (true)
+            {
+                index = Volatile.Read(ref _highestAllocated);
+                _lock.EnterMetaDataRead();
+                try
+                {
+                    if (index >= _capacity)
+                    {
+                        _lock.ExitMetaDataRead();
+                        _lock.EnterExpansionProcess();
+                        try
+                        {
+                            _capacity = Volatile.Read(ref _capacity) * 2;
+                            nuint newSize = (nuint)_capacity * (nuint)_elementSize;
+                            _lock.EnterBufferCopy();
+                            try
+                            {
+                                _buffer = (T*)NativeMemory.Realloc(_buffer, newSize);
+                            }
+                            finally
+                            {
+                                _lock.ExitBufferCopy();
+                            }
+                        }
+                        finally
+                        {
+                            _lock.ExitExpansionProcess();
+                        }
+                    }
+                    _ = Interlocked.Increment(ref Unsafe.As<nuint, ulong>(ref _highestAllocated));
+                    return index;
+                }
+                finally
+                {
+                    if (_lock.IsThreadReadingMetaData) {
+                        _lock.ExitMetaDataRead();
+                    }
+                }
+            }
+        }
+
+        public override void Dispose()
+        {
+            _stack.Dispose();
+            NativeMemory.Free(_buffer);
+            _lock.Dispose();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void EnterBufferReading()
+        {
+            _lock.EnterBufferRead();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void ExitBufferReading()
+        {
+            _lock.ExitBufferRead();
+        }
+
+        public override void Free(nuint index)
+        {
+            _stack.Push(index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override SlabAllocationHandle<T> ReadAllocation()
+        {
+            EnterBufferReading();
+            return new SlabAllocationHandle<T>(this, true);
+        }
+
+        ~ConcurrentSequentialSlabAllocator()
+        {
+            Dispose();
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/UnmanagedMemoryHandle.cs

@@ -0,0 +1,100 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="UnmanagedMemoryHandle.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public unsafe struct UnmanagedMemoryHandle
+    {
+
+        public readonly byte* BufferHandle, AllocatorHandle;
+        public readonly nuint Size;
+
+        public UnmanagedMemoryHandle(byte* pointer, byte* handle, nuint s)
+        {
+            BufferHandle = pointer;
+            AllocatorHandle = handle;
+            Size = s;
+        }
+
+        public readonly ref byte this[nuint index]
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref Unsafe.AddByteOffset(ref Unsafe.AsRef<byte>(BufferHandle), index);
+        }
+
+        public readonly Enumerator GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        public ref struct Enumerator : IEnumerator<byte>
+        {
+
+            private nuint _index = nuint.MaxValue;
+
+            private UnmanagedMemoryHandle _handle;
+
+            internal Enumerator(UnmanagedMemoryHandle span)
+            {
+                _handle = span;
+            }
+
+            public ref byte RefCurrent => ref _handle[_index];
+
+            public readonly void Dispose() { }
+
+            public bool MoveNext()
+            {
+                _index++;
+                return _index < _handle.Size;
+            }
+
+            public void Reset()
+            {
+                _index = 0;
+            }
+
+            object IEnumerator.Current => RefCurrent;
+
+            byte IEnumerator<byte>.Current => RefCurrent;
+
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/UnmanagedMemoryPool.BucketTLSF.cs

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="UnmanagedMemoryPool.BucketTLSF.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.HighPerformance.Memory;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public unsafe partial class UnmanagedMemoryPool
+    {
+
+        private struct Entry : ISlabAllocatable
+        {
+
+            public Entry* NextNear, PreviousNear;
+
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/Memory/UnmanagedMemoryPool.cs

@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="UnmanagedMemoryPool.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Concurrent;
+using System.Drawing;
+using System.Net.Security;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Transactions;
+
+namespace StgSharp.HighPerformance.Memory
+{
+    public unsafe partial class UnmanagedMemoryPool
+    {
+
+        private byte* m_Buffer;
+        private SlabAllocator<Entry> _nodes = new(64);
+
+        public
+
+    }
+}

StgSharp.Common/HighPerformance/UnmanagedMemoryHandle.cs

@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="UnmanagedMemoryHandle.cs"
+//     Project: StgSharp
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance
+{
+    public ref struct UnmanagedMemoryHandle
+    {
+
+        public nuint Postion;
+        public Span<byte> Buffer;
+
+        public UnmanagedMemoryHandle() { }
+
+        public ref byte this[int index]
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref Buffer[index];
+        }
+
+        public Span<byte>.Enumerator GetEnumerator()
+        {
+            return Buffer.GetEnumerator();
+        }
+
+    }
+}

StgSharp.Common/HighPerformance/UnmanagedMemoryPool.IndexNode.cs

@@ -0,0 +1,144 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="UnmanagedMemoryPool.IndexNode.cs"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person 
+// obtaining a copy of this software and associated documentation 
+// files (the “Software”), to deal in the Software without restriction, 
+// including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, 
+// and to permit persons to whom the Software is furnished to do so, 
+// subject to the following conditions:
+//     
+// The above copyright notice and 
+// this permission notice shall be included in all copies 
+// or substantial portions of the Software.
+//     
+// THE SOFTWARE IS PROVIDED “AS IS”, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.HighPerformance
+{
+    public unsafe partial class UnmanagedMemoryPool
+    {
+
+        private const int
+            LevelOf4096 = 4,
+            LevelOf1024 = 3,
+            LevelOf256 = 2,
+            LevelOf64 = 1;
+
+        internal readonly ref struct NextIndexNode
+        {
+
+            private readonly Span<M64> _layout;
+
+            public readonly nuint this[int level]
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => Position - _layout[level].Member<uint>(0);
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                set => _layout[level].Member<uint>(0) = (uint)(Position - value);
+            }
+
+            private readonly ref nuint Position
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => ref _layout[0].Member<nuint>(0);
+            }
+
+        }
+
+        internal readonly ref struct PreviousIndexNode
+        {
+
+            private readonly Span<M64> _layout;
+
+            public readonly nuint this[int level]
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => Position - _layout[level].Member<uint>(1);
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                set => _layout[level].Member<uint>(1) = (uint)(Position - value);
+            }
+
+            private readonly ref nuint Position
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => ref _layout[0].Member<nuint>(0);
+            }
+
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        internal readonly ref struct IndexNode
+        {
+
+            private static readonly uint[] _sizeArr = [16, 64, 256, 1024, 4096];
+            [FieldOffset(0)] private readonly NextIndexNode nxt;
+            [FieldOffset(0)] private readonly PreviousIndexNode pre;
+            [FieldOffset(0)] private readonly Span<M64> _layout;
+
+            public IndexNode(ref byte span)
+            {
+                _layout = MemoryMarshal.CreateSpan(ref Unsafe.As<byte, M64>(ref span), 8);
+            }
+
+            public readonly ref nuint Position => ref _layout[0].Member<nuint>(0);
+
+            public readonly ref uint Size => ref _layout[5].Member<uint>(0);
+
+            public readonly ref int Level => ref _layout[5].Member<int>(1);
+
+            public readonly ref nuint Segment => ref _layout[6].Member<nuint>(0);
+
+            public readonly uint BlockSize => LevelToSize(Level);
+
+            public static uint LevelToSize(int level)
+            {
+                return level switch
+                {
+                    < 0 or > 4 => throw new ArgumentOutOfRangeException(
+                        nameof(level), "Level must be from 1 to 4."),
+                    _ => _sizeArr[level]
+                };
+            }
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+            public readonly ref readonly NextIndexNode Next
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => ref nxt;
+            }
+
+            public readonly ref readonly PreviousIndexNode Previous
+            {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => ref pre;
+            }
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        }
+
+    }
+}