초·중·고 정보 과학(실시간 스케줄링·우선순위 큐·다중 자원 최적화)·물리(전자기파 주파수 대역·레이다 단면적 RCS·도플러 필터) 교육과 국방 해군 KDDX 한국형 차기 구축함 통합 마스트(I-MAST) S-대역(광역 탐색/탄도탄 조기경보) + X-대역(초정밀 사격통제/저고도 순항유도탄 요격) 능동위상배열(AESA) 동시 운용: ZeliDesk의 온디바이스 순수 C# 실시간 시간 분할 다중 빔 방사 스케줄러(Time-Budget Beam Scheduling), 0-Alloc SIMD 가속 다표적 위협도 동적 가중치 산출 및 K-SAAM(해궁)/SM-2 유도 펄스 인터리빙 엔진 아키텍처

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

namespace ZeliDesk.Core.NavalRadar
{
    public enum RadarBand : byte { SBandVolumeSearch, XBandFireControl }
    public enum TaskTier : byte { Tier1MissileGuidance = 0, Tier2PrecisionTrack = 1, Tier3Confirmation = 2, Tier4VolumeSearch = 3 }

    /// <summary>
    /// 단일 빔 방사 요청 태스크 (16바이트 정렬 구조체)
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 16)]
    public struct AesaBeamTask
    {
        public float AzimuthDeg;       // 방위각 (0 ~ 360)
        public float ElevationDeg;     // 앙각 (-10 ~ +85)
        public ushort DurationMicroSec;// 방사 시간 (us, 예: 200us)
        public TaskTier Tier;          // 우선순위
        public RadarBand Band;         // S 또는 X 밴드
        public float ThreatScore;      // 동적 위협도 가중치

        public AesaBeamTask(float az, float el, ushort durationUs, TaskTier tier, RadarBand band, float threat)
        {
            AzimuthDeg = az; ElevationDeg = el; DurationMicroSec = durationUs;
            Tier = tier; Band = band; ThreatScore = threat;
        }
    }

    /// <summary>
    /// 0-Alloc 시간 예산(Time-Budget) 빔 스케줄러 엔진
    /// 100ms 타임 프레임 내 수백 개 빔 작업 실시간 인터리빙 패킹
    /// </summary>
    public sealed class DualBandAesaScheduler
    {
        private const int MaxTasksPerFrame = 256;
        private readonly AesaBeamTask[] _taskQueue;
        private int _taskCount;
        private readonly ushort _totalTimeBudgetUs; // 100,000 us (100ms)

        public DualBandAesaScheduler(ushort frameDurationMs = 100)
        {
            _totalTimeBudgetUs = (ushort)(frameDurationMs * 1000);
            _taskQueue = new AesaBeamTask[MaxTasksPerFrame];
            _taskCount = 0;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void EnqueueTask(in AesaBeamTask task)
        {
            if (_taskCount < MaxTasksPerFrame)
            {
                _taskQueue[_taskCount++] = task;
            }
        }

        /// <summary>
        /// 시간 예산 내에서 Tier 및 위협도 기준 빔 스케줄링 및 인터리빙 실행 (0-Alloc 루프)
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public int ScheduleFrame(Span<AesaBeamTask> outScheduledTimeline, out ushort outUsedTimeUs)
        {
            // 1. 0-Alloc 단순 삽입 정렬 (Tier 우선, 위협도 내림차순)
            for (int i = 1; i < _taskCount; i++)
            {
                var key = _taskQueue[i];
                int j = i - 1;

                while (j >= 0 && CompareTasks(in _taskQueue[j], in key) > 0)
                {
                    _taskQueue[j + 1] = _taskQueue[j];
                    j--;
                }
                _taskQueue[j + 1] = key;
            }

            // 2. 시간 예산(Time-Budget) 패킹 (Bin-Packing)
            ushort currentTimelineUs = 0;
            int scheduledCount = 0;

            for (int i = 0; i < _taskCount; i++)
            {
                ref readonly var task = ref _taskQueue[i];
                if (currentTimelineUs + task.DurationMicroSec <= _totalTimeBudgetUs)
                {
                    if (scheduledCount < outScheduledTimeline.Length)
                    {
                        outScheduledTimeline[scheduledCount++] = task;
                        currentTimelineUs += task.DurationMicroSec;
                    }
                }
            }

            outUsedTimeUs = currentTimelineUs;
            _taskCount = 0; // 다음 프레임을 위한 큐 클리어
            return scheduledCount;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static int CompareTasks(in AesaBeamTask a, in AesaBeamTask b)
        {
            if (a.Tier != b.Tier) return a.Tier.CompareTo(b.Tier);
            return b.ThreatScore.CompareTo(a.ThreatScore); // 위협도 높은 순
        }
    }

    /// <summary>
    /// AVX2 SIMD 가속 다표적 위협도 벡터 평가기
    /// </summary>
    public static class SimdThreatEvaluator
    {
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public static void EvaluateThreatScores(ReadOnlySpan<float> ranges, ReadOnlySpan<float> radialVelocities, Span<float> outScores)
        {
            const float maxRange = 100000.0f; // 100km
            const float maxVelocity = 1500.0f; // 마하 4.5+

            if (Avx2.IsSupported && ranges.Length >= 8)
            {
                var vMaxRange = Vector256.Create(maxRange);
                var vInvMaxRange = Vector256.Create(1.0f / maxRange);
                var vInvMaxVel = Vector256.Create(1.0f / maxVelocity);
                var vWeightR = Vector256.Create(0.4f);
                var vWeightV = Vector256.Create(0.6f);

                for (int i = 0; i <= ranges.Length - 8; i += 8)
                {
                    var vR = Vector256.Create(ranges.Slice(i, 8));
                    var vV = Vector256.Create(radialVelocities.Slice(i, 8));

                    // 거리 항: (maxRange - R) / maxRange
                    var vRScore = Avx.Multiply(Avx.Subtract(vMaxRange, vR), vInvMaxRange);
                    // 속도 항: V / maxVelocity
                    var vVScore = Avx.Multiply(vV, vInvMaxVel);

                    var vTotal = Avx.Add(Avx.Multiply(vRScore, vWeightR), Avx.Multiply(vVScore, vWeightV));
                    vTotal.CopyTo(outScores.Slice(i, 8));
                }
            }
            else
            {
                for (int i = 0; i < ranges.Length; i++)
                {
                    float rScore = (maxRange - ranges[i]) / maxRange;
                    float vScore = radialVelocities[i] / maxVelocity;
                    outScores[i] = 0.4f * rScore + 0.6f * vScore;
                }
            }
        }
    }
}