Working on L4, now on swiss. FMA_TILE is re arranged.

2026-03-03 18:02:31 +08:00
parent ae1a49d6fb
commit 91e136f81f
12 changed files with 1083 additions and 477 deletions
@@ -26,34 +26,170 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
+using System.Runtime.Intrinsics.Arm;
+using System.Runtime.Intrinsics.X86;

 namespace StgSharp.Collections
 {
-    public unsafe class SwissTable
+    /// <summary>
+    ///
+    /// </summary>
+    public unsafe partial class SwissTable
    {
-        public bool TryGet(nint key, out nint value)
+
+        private const int BucketCount = 1 << EntryMaskWidth;
+        private const int BucketSize = 256;
+        private const int EntryMaskWidth = 10; // 1024 entries total, 256 per bucket
+        public const int MaxCapacity = 1024 * BucketSize;   // 256 entries per bucket, 1024 buckets
+
+        private readonly Entry* _entries;
+
+        private SwissTable(
+                Entry* buffer
+        )
+        {
+            _entries = buffer;
+            for (int i = 0; i < BucketCount; i++)
+            {
+                // Set all control bytes to 0xFF (empty)
+                Unsafe.InitBlock(&_entries[i].Bucket.Control, 0xFF, BucketSize);
+            }
+        }
+
+        public bool TryAddOrSet(
+                    nint key,
+                    nint value
+        )
        {
            throw new NotImplementedException();
+        }
+
+        public bool TryAddOrSet(
+                    nint key,
+                    ref nint value,
+                    out bool isNewKey
+        )
+        {
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
+            short entry = (short)(hash & ((1 << 11) - 1));
+            Bucket* bucket = &_entries[entry].Bucket;
+            return IBucketScanner.Current.TrySet(key, hash, bucket, value, out isNewKey);
+        }
+
+        public bool TryGet(
+                    nint key,
+                    out nint value
+        )
+        {
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
+            short entry = (short)(hash & ((1 << 11) - 1));
+            Bucket* bucket = &_entries[entry].Bucket;
+            return IBucketScanner.Current.TryFind(key, hash, bucket, out value);
            /*
            * hash = CRC32 of key
            * entry = low 8 of hash
            * ctrl  = 8-15 of hash
            * index = rest of hash
            * find value of hash
-            */ 
+            */
        }

+        public bool TryRemove(
+                    nint key,
+                    out nint value
+        )
+        {
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
+            short entry = (short)(hash & ((1 << 11) - 1));
+            Bucket* bucket = &_entries[entry].Bucket;
+            return IBucketScanner.Current.TryRemove(key, hash, bucket, out value);
+        }
+
+        [InlineArray(BucketCount)]
        private struct Entry
        {
-            public fixed byte entry[256];   //entry is fully occupied, or empty, or deleted
-            // array of ctrl array
-            // array of value array
-            // array of hash array
+
+            public Bucket Bucket;
+
        }
+
+        private unsafe struct Bucket
+        {
+
+            public BucketControl Control;
+            public BucketKeyStorage Keys;
+            public BucketValueStorage Values;
+
+        }
+
+        private interface IBucketScanner
+        {
+
+            static IBucketScanner Current { get; } = Create();
+
+            bool TryFind(
+                 nint key,
+                 uint Hash,
+                 Bucket* bucket,
+                 out nint value
+            );
+
+            unsafe bool TryRemove(
+                        nint key,
+                        uint hash,
+                        Bucket* bucket,
+                        out nint value
+            );
+
+            bool TrySet(
+                 nint key,
+                 uint hash,
+                 Bucket* bucket,
+                 nint value,
+                 out bool isNewKey
+            );
+
+            private static IBucketScanner Create()
+            {
+                if (X86Base.IsSupported)
+                {
+                    return new BucketScannerX86();
+                } else if (ArmBase.IsSupported)
+                {
+                    throw new NotSupportedException("ARM architecture is currently not supported for bucket scanning. Please use an x86 platform.");
+                } else
+                {
+                    throw new NotSupportedException("No suitable bucket scanner implementation found for the current platform.");
+                }
+            }
+
+        }
+
+        [InlineArray(BucketSize)]
+        private struct BucketControl
+        {
+
+            public byte Control;
+
+        }
+
+        [InlineArray(BucketSize)]
+        private struct BucketKeyStorage
+        {
+
+            public nint value;
+
+        }
+
+        [InlineArray(BucketSize)]
+        private struct BucketValueStorage
+        {
+
+            public nint value;
+
+        }
+
    }
-}
+}