초·중·고 정보 과학(분산 메시지 브로커·프로토콜 버퍼·RPC)·물리(전자파 전파·도플러 천이) 교육과 국방 기무/합동참모본부 전술 공통작전상황도(COP) 실시간 데이터 분배 서비스(DDS, Data Distribution Service) 및 QoS 정책 기반 킬체인 동기화: ZeliDesk의 온디바이스 순수 C# 실시간 RTPS(Real-Time Publish-Subscribe) 제로-카피 직렬화, 네트워크 파티션 자가 복구, 0-Alloc SIMD 다중 도메인 전술 텔레메트리 스트리밍 엔진 아키텍처

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

namespace ZeliDesk.Defense.C4I.DDS
{
    /// <summary>
    /// RTPS 프로토콜 헤더 (20바이트 고정)
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 20)]
    public readonly struct RtpsHeader
    {
        public readonly uint Magic;            // "RTPS" (0x53505452)
        public readonly byte MajorVersion;     // 2
        public readonly byte MinorVersion;     // 4
        public readonly ushort VendorId;       // 0x011A (ZeliDesk Defense)
        public readonly ulong GuidPrefixHigh;  // 송신 노드 12바이트 GUID 접두부 상위
        public readonly uint GuidPrefixLow;    // 송신 노드 GUID 접두부 하위

        public const uint ExpectedMagic = 0x53505452;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool IsValid() => Magic == ExpectedMagic;
    }

    /// <summary>
    /// RTPS 시퀀스 번호 구조체 (64비트 정수)
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public readonly struct SequenceNumber : IComparable<SequenceNumber>
    {
        public readonly int High;
        public readonly uint Low;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public SequenceNumber(long value)
        {
            High = (int)(value >> 32);
            Low = (uint)value;
        }

        public long Value => ((long)High << 32) | Low;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public int CompareTo(SequenceNumber other) => Value.CompareTo(other.Value);
    }

    /// <summary>
    /// 32비트 비트맵 시퀀스 집합 (0-Alloc stackalloc)
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct SequenceNumberSet
    {
        public SequenceNumber BaseSeq;
        public int NumBits;
        public uint Bitmap; // 32개 패킷 손실 상태 비트 (1 = 손실 누락)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public readonly bool IsMissing(int bitIndex)
        {
            if (bitIndex < 0 || bitIndex >= NumBits) return false;
            return ((Bitmap >> bitIndex) & 1U) != 0;
        }
    }

    /// <summary>
    /// 전술 킬체인 전문 텔레메트리 구조체
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct TacticalTelemetryPayload
    {
        public uint TargetId;
        public float Latitude;
        public float Longitude;
        public float Altitude;
        public float Speed;
        public byte ThreatLevel;    // 1~5
        public byte WeaponAssignee; // 슈터 노드 ID
    }

    /// <summary>
    /// 온디바이스 순수 C# 0-Alloc RTPS 제로-카피 디스패처
    /// </summary>
    public sealed class KillChainTelemetryBroker
    {
        public const byte SubmsgIdData = 0x15;
        public const byte SubmsgIdHeartbeat = 0x07;
        public const byte SubmsgIdAckNack = 0x06;

        private long _lastReceivedSeq = 0;

        /// <summary>
        /// 수신 UDP 버퍼로부터 RTPS 패킷을 힙 할당 없이 즉시 검증 및 디스패치
        /// </summary>
        public bool ProcessIncomingPacket(ReadOnlySpan<byte> packetBuffer, ref TacticalTelemetryPayload outPayload)
        {
            if (packetBuffer.Length < 20) return false;

            // 1. 제로-카피 헤더 검증
            ref readonly var header = ref MemoryMarshal.AsRef<RtpsHeader>(packetBuffer);
            if (!header.IsValid()) return false;

            int offset = 20;

            // 2. 서브메시지 연속 파싱 (0-Alloc 루프)
            while (offset + 4 <= packetBuffer.Length)
            {
                byte submsgId = packetBuffer[offset];
                byte flags = packetBuffer[offset + 1];
                ushort submsgLength = BinaryPrimitives.ReadUInt16LittleEndian(packetBuffer.Slice(offset + 2, 2));

                int payloadOffset = offset + 4;
                if (payloadOffset + submsgLength > packetBuffer.Length) break;

                if (submsgId == SubmsgIdData)
                {
                    // 전술 DATA 서브메시지 파싱
                    if (submsgLength >= 24)
                    {
                        long seqNum = BinaryPrimitives.ReadInt64LittleEndian(packetBuffer.Slice(payloadOffset + 8, 8));
                        if (seqNum > _lastReceivedSeq)
                        {
                            _lastReceivedSeq = seqNum;

                            // 페이로드 제로-카피 추출
                            int userPayloadOffset = payloadOffset + 16;
                            if (userPayloadOffset + Unsafe.SizeOf<TacticalTelemetryPayload>() <= packetBuffer.Length)
                            {
                                outPayload = MemoryMarshal.Read<TacticalTelemetryPayload>(packetBuffer.Slice(userPayloadOffset));
                                return true;
                            }
                        }
                    }
                }

                offset += (4 + submsgLength);
            }

            return false;
        }
    }
}