using System;

using System.Runtime.CompilerServices;

using System.Threading;

namespace JDWTaskSystem

{

    /// <summary>

    /// SchedulerNode는 스케줄러에서 사용되는 작업 단위를 나타냄

    /// (예: 작업(Action)과 작업 소스(Source)를 포함)

    /// </summary>

    public class SchedulerNode

    {

        public ITaskCompletionAction Action;

        public ITaskSource Source;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        public void Reset()

        {

            Action = null;

            Source = null;

        }

    }

    /// <summary>

    /// NUMA(Non-Uniform Memory Access) 최적화 기반 락-프리(Lock-Free) 클래스 풀

    /// SchedulerNode 객체를 미리 할당된 배열에서 관리하여 메모리 할당을 최소화하고 성능을 향상시킴

    /// NUMA 노드에 따라 객체를 분산하여 메모리 접근 병목을 줄임

    /// </summary>

    public class SchedulerNodePool

    {

        private SchedulerNode[][] pools;       // NUMA 노드별 객체 풀 (2차원 배열)

        private int[] poolIndices;             // 각 NUMA 노드에서 현재 사용 가능한 객체의 인덱스

        private int numaNodes;                 // NUMA 노드 개수

        private int poolSize;                  // 풀의 초기 크기

        [ThreadStatic]

        private static bool isNumaInitialized;

        [ThreadStatic]

        private static int threadNumaNode;

        /// <summary>

        /// NUMA 기반 클래스 풀을 생성함

        /// </summary>

        /// <param name="numaNodes">

        /// NUMA 노드 개수 (보통 CPU 코어 수의 절반 정도로 설정)

        /// </param>

        /// <param name="poolSize">풀의 초기 크기</param>

        public SchedulerNodePool(int numaNodes, int poolSize)

        {

            this.numaNodes = numaNodes;

            this.poolSize = poolSize;

            pools = new SchedulerNode[numaNodes][];

            poolIndices = new int[numaNodes];

            for (int i = 0; i < numaNodes; i++)

            {

                pools[i] = new SchedulerNode[poolSize];

                poolIndices[i] = -1; // 초기에는 아무 객체도 대여되지 않음 (-1)

            }

            isNumaInitialized = false;

            threadNumaNode = 0;

        }

        /// <summary>

        /// 현재 NUMA 노드에서 SchedulerNode 객체를 대여함

        /// 락-프리 방식으로 작동하여 성능을 최적화함

        /// </summary>

        /// <returns>대여된 SchedulerNode 객체</returns>

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        public SchedulerNode Rent()

        {

            int numaNode = GetNumaNode();

            int index = Interlocked.Increment(ref poolIndices[numaNode]);

            // 풀의 크기를 초과하면 풀 확장 (동기화 필요)

            if (index >= poolSize)

            {

                ResizePool(numaNode, poolSize * 2);

                index = 0;

            }

            SchedulerNode obj = pools[numaNode][index];

            pools[numaNode][index] = null;

            return obj ?? new SchedulerNode();

        }

        /// <summary>

        /// 사용한 SchedulerNode 객체를 다시 풀에 반환하여 재사용할 수 있도록 함

        /// </summary>

        /// <param name="item">반환할 SchedulerNode 객체</param>

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        public void Return(SchedulerNode item)

        {

            item.Reset();

            int numaNode = GetNumaNode();

            int index = Interlocked.Decrement(ref poolIndices[numaNode]);

            if (index >= 0)

            {

                pools[numaNode][index] = item;

            }

        }

        /// <summary>

        /// 특정 NUMA 노드의 풀 크기를 확장함

        /// 배열을 새 크기로 복사하여 공간을 확보함

        /// </summary>

        /// <param name="numaNode">확장할 NUMA 노드</param>

        /// <param name="newSize">새로운 풀 크기</param>

        private void ResizePool(int numaNode, int newSize)

        {

            lock (pools)

            {

                if (newSize <= poolSize) return;

                SchedulerNode[] newPool = new SchedulerNode[newSize];

                Array.Copy(pools[numaNode], newPool, poolSize);

                pools[numaNode] = newPool;

                poolSize = newSize;

            }

        }

        /// <summary>

        /// 현재 실행 중인 스레드의 NUMA 노드를 결정함

        /// ThreadStatic 변수를 사용하여 NUMA 노드를 캐싱함

        /// </summary>

        /// <returns>현재 스레드의 NUMA 노드 인덱스</returns>

        [MethodImpl(MethodImplOptions.AggressiveInlining)]

        private int GetNumaNode()

        {

            if (!isNumaInitialized)

            {

                threadNumaNode = Thread.CurrentThread.ManagedThreadId % numaNodes;

                isNumaInitialized = true;

            }

            return threadNumaNode;

        }

        /// <summary>

        /// 현재 풀의 크기를 반환함

        /// </summary>

        /// <returns>풀 크기</returns>

        public int GetPoolSize()

        {

            return poolSize;

        }

    }

}