다영역 유무인 복합체계(MUM-T) 드론 편대 전술 메시 통신망 적 전자전 교란 대응 비잔틴 결함 포용(BFT) 분산 합의 C# SIMD 서보

3. Zero-Allocation C# SIMD BFT 분산 합의 서보 구현

인접 노드들의 RF 신호 세기(RSSI)와 암호화된 투표 벡터를 수신하여 악성 이상치를 필터링하고 공통 표적 락온 명령을 200 Hz로 확정하는 C# .NET 9.0 엔진입니다.

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

namespace ZeliDesk.Defense.SwarmBFT
{
    public readonly ref struct SwarmNodeTelemetry
    {
        public readonly int NodeId;
        public readonly int TotalNodesInMesh;           // N
        public readonly float LinkQualityRssiDb;        // Datalink signal
        public readonly float LocalThreatScore;         // 0.0 ~ 1.0
        public readonly float NeighborMaxDiscrepancy;   // Inconsistency metric

        public SwarmNodeTelemetry(int id, int n, float rssi, float score, float disc)
        {
            NodeId = id;
            TotalNodesInMesh = n;
            LinkQualityRssiDb = rssi;
            LocalThreatScore = score;
            NeighborMaxDiscrepancy = disc;
        }
    }

    public ref struct BftConsensusDecision
    {
        public float AgreedThreatScore;
        public int ActiveByzantineFaultsExcluded;
        public float NetworkAlgebraicConnectivityLambda2;
        public bool QuorumAchieved;
        public bool FireCommitAuthorized;
    }

    public static class TacticalSwarmBftConsensusEngine
    {
        private const float ConsensusConvergenceThreshold = 0.05f;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ExecuteConsensusStep(
            in SwarmNodeTelemetry telemetry,
            ReadOnlySpan neighborScores,
            ref BftConsensusDecision output)
        {
            int n = telemetry.TotalNodesInMesh;
            int maxFaultyNodes = (n - 1) / 3; // f = (N-1)/3
            int neighborCount = neighborScores.Length;

            if (neighborCount < 2 * maxFaultyNodes + 1)
            {
                output.QuorumAchieved = false;
                output.FireCommitAuthorized = false;
                return;
            }

            // 1. Sort Neighbor Scores to Apply MSR (Mean-Subsequence-Reduced) BFT Filter
            Span sorted = stackalloc float[neighborCount];
            neighborScores.CopyTo(sorted);

            // Fast Insertion Sort for small swarm (N < 64)
            for (int i = 1; i < neighborCount; i++)
            {
                float key = sorted[i];
                int j = i - 1;
                while (j >= 0 && sorted[j] > key)
                {
                    sorted[j + 1] = sorted[j];
                    j--;
                }
                sorted[j + 1] = key;
            }

            // 2. Trim Top 'f' and Bottom 'f' extreme suspicious outliers
            int trimCount = Math.Min(maxFaultyNodes, neighborCount / 3);
            output.ActiveByzantineFaultsExcluded = trimCount * 2;

            float sum = 0.0f;
            int validCount = 0;
            for (int i = trimCount; i < neighborCount - trimCount; i++)
            {
                sum += sorted[i];
                validCount++;
            }

            float robustMean = (validCount > 0) ? (sum / validCount) : telemetry.LocalThreatScore;

            // Blend with local score using consensus step
            float consensusStep = 0.35f;
            float newLocalScore = telemetry.LocalThreatScore + consensusStep * (robustMean - telemetry.LocalThreatScore);
            output.AgreedThreatScore = newLocalScore;

            // 3. Algebraic Connectivity Lambda_2 Estimation
            float meanRssi = telemetry.LinkQualityRssiDb;
            float normalizedLink = Math.Clamp((meanRssi + 85.0f) / 45.0f, 0.0f, 1.0f);
            float lambda2 = normalizedLink * (float)neighborCount / (float)n;
            output.NetworkAlgebraicConnectivityLambda2 = lambda2;

            // 4. Quorum & Fire Authorization
            bool isQuorum = (validCount >= (2 * maxFaultyNodes));
            output.QuorumAchieved = isQuorum;
            output.FireCommitAuthorized = (isQuorum && newLocalScore > 0.82f && lambda2 > 0.15f);
        }
    }
}