초·중·고 운영체제·시스템 프로그래밍 교육과 국방 고신뢰 임베디드 실시간 운영체제(RTOS): ZeliDesk의 온디바이스 순수 C# 마이크로커널(Microkernel) 아키텍처, 0-Alloc 무잠금 IPC 메시지 패싱, 및 0.1μs 결정론적 실시간 태스크 스케줄러 아키텍처

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading;

namespace ZeliDesk.Core.System.Microkernel
{
    [StructLayout(LayoutKind.Sequential, Pack = 8)]
    public struct TaskControlBlock
    {
        public int TaskId;
        public int BasePriority;
        public int CurrentPriority;
        public long NextReleaseTimeNs;
        public long AbsoluteDeadlineNs;
        public long PeriodNs;
        public nint ContextPointer; // 태스크 실행 컨텍스트 포인터
    }

    [StructLayout(LayoutKind.Sequential, Pack = 8)]
    public struct IpcMessage
    {
        public int SenderId;
        public int ReceiverId;
        public int MessageCode;
        public fixed byte Payload[48]; // 64바이트 캐시라인 정렬 고정 슬롯
    }

    public sealed unsafe class LockFreeIpcChannel
    {
        private const int Capacity = 1024;
        private const int Mask = Capacity - 1;
        private readonly IpcMessage* _ring;
        private long _head = 0;
        private long _tail = 0;

        public LockFreeIpcChannel()
        {
            _ring = (IpcMessage*)NativeMemory.AllocZeroed((nuint)(Capacity * sizeof(IpcMessage)));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool TrySend(in IpcMessage msg)
        {
            long currentTail = Volatile.Read(ref _tail);
            long currentHead = Volatile.Read(ref _head);

            if (currentTail - currentHead >= Capacity) return false; // 버퍼 가득 참

            _ring[currentTail & Mask] = msg;
            Interlocked.Increment(ref _tail);
            return true;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool TryReceive(out IpcMessage msg)
        {
            long currentHead = Volatile.Read(ref _head);
            long currentTail = Volatile.Read(ref _tail);

            if (currentHead >= currentTail)
            {
                msg = default;
                return false; // 버퍼 비어 있음
            }

            msg = _ring[currentHead & Mask];
            Interlocked.Increment(ref _head);
            return true;
        }
    }

    public sealed class DeterministicRtosScheduler
    {
        private const int MaxTasks = 32;
        private readonly TaskControlBlock[] _tasks = new TaskControlBlock[MaxTasks];
        private int _taskCount = 0;

        public void RegisterTask(int id, int priority, long periodNs)
        {
            if (_taskCount >= MaxTasks) throw new InvalidOperationException("Max tasks reached");
            _tasks[_taskCount++] = new TaskControlBlock
            {
                TaskId = id,
                BasePriority = priority,
                CurrentPriority = priority,
                PeriodNs = periodNs,
                NextReleaseTimeNs = 0,
                AbsoluteDeadlineNs = periodNs
            };
        }

        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public int PickNextTask(long currentNs)
        {
            int bestIdx = -1;
            long earliestDeadline = long.MaxValue;

            for (int i = 0; i < _taskCount; i++)
            {
                ref readonly var task = ref _tasks[i];
                if (task.NextReleaseTimeNs <= currentNs && task.AbsoluteDeadlineNs < earliestDeadline)
                {
                    earliestDeadline = task.AbsoluteDeadlineNs;
                    bestIdx = i;
                }
            }

            return bestIdx >= 0 ? _tasks[bestIdx].TaskId : -1; // Idle
        }
    }
}