per thread context loading is ok, working on global context

StgSharp.Mathematics/Numeric/MatrixParallel.cs

@@ -2,8 +2,8 @@
 // -----------------------------------------------------------------------
 // file="MatrixParallel"
 // Project: StgSharp
-// AuthorGroup: Nitload
-// Copyright (c) Nitload. All rights reserved.
+// 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
@@ -27,10 +27,14 @@
 // -----------------------------------------------------------------------
 using StgSharp.Collections;
 using StgSharp.HighPerformance.Memory;
+using StgSharp.Internal;
 using StgSharp.Internal.Intrinsic;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -43,6 +47,8 @@ namespace StgSharp.Mathematics.Numeric
 
         private static CapacityFixedStack<MatrixParallelThread> _threads;
 
+        private static ConcurrentDictionary<SIMDID, nint> contextMap;
+
         private static SlabAllocator<IntrinsicContext> contextAllocator;
 
         public static bool IsParallelSupported { get; } = Environment.ProcessorCount > 6;
@@ -51,6 +57,22 @@ namespace StgSharp.Mathematics.Numeric
 
         private static bool IsInitialized { get; set; } = false;
 
+        internal static unsafe IntrinsicContext* GetContext(SIMDID simd)
+        {
+            if (!IsParallelSupported) {
+                return null;
+            }
+            if (contextMap.TryGetValue(simd, out nint handle))
+            {
+                return (IntrinsicContext*)handle;
+            } else
+            {
+                IntrinsicContext* context = (IntrinsicContext*)contextAllocator.Allocate();
+
+                return context;
+            }
+        }
+
         internal static void Init()
         {
             if (IsInitialized) {
@@ -63,16 +85,32 @@ namespace StgSharp.Mathematics.Numeric
             }
             MatrixParallelFactory.Init();
             contextAllocator = SlabAllocator<IntrinsicContext>.Create(4, SlabBufferLayout.Chunked, false);
-            int count = Environment.ProcessorCount - 4;
+            contextMap = [];
+            int count = Environment.ProcessorCount;
             _threads = new(count);
             for (int i = 0; i < count; i++)
             {
                 MatrixParallelThread thread = new MatrixParallelThread(i);
                 _threads.Push(thread);
             }
+            if (contextMap.Keys.Count == 1)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    MatrixParallelThread thread = _threads.Pop();
+                    thread.Dispose();
+                }
+            } else
+            {
+                // TODO 排序并丢弃四个能力最弱线程
+            }
             _awaitingLeaderHandle = new AwaitingQueue();
             IsInitialized = true;
         }
 
+        [LibraryImport(Native.LibName, EntryPoint = "load_intrinsic_function")]
+        [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+        private static unsafe partial void LoadIntrinsicFunction(IntrinsicContext* context, ulong id);
+
     }
 }