# 典型大型会议场景画像示例
scenario: "万人直播课"
dimensions:
  - join_pattern: "spike"          # 入会模式：尖峰/平滑/阶梯
  - peak_concurrency: 50000        # 峰值并发
  - avg_session_duration: 3600     # 平均会话时长(秒)
  - role_distribution:             # 角色分布
      host: 0.001
      co_host: 0.005
      audience: 0.994
  - media_profile:                 # 媒体特征
      video_up: {resolution: "1080p", fps: 30, codec: "H.264", bitrate: "4Mbps"}
      video_down: {layers: 3, simulcast: true}
      audio: {codec: "Opus", bitrate: "64kbps", fec: true, dtx: true}
  - interaction_events:            # 交互事件频率
      chat_msg_per_min: 200
      raise_hand_per_min: 50
      poll_vote_per_session: 3

{
  "scenario_id": "webinar_10k_spike",
  "phases": [
    {"name": "warmup", "duration": 300, "arrival_rate": {"type": "const", "value": 50}},
    {"name": "spike", "duration": 120, "arrival_rate": {"type": "nhpp", "lambda_func": "1000*sin(pi*t/60)+2000"}},
    {"name": "steady", "duration": 1800, "arrival_rate": {"type": "const", "value": 8000}},
    {"name": "rampdown", "duration": 300, "arrival_rate": {"type": "linear", "from": 8000, "to": 0}}
  ],
  "client_profile": {
    "media_capabilities": ["h264", "vp8", "opus"],
    "network_profile": "office_wifi_50ms_2pct_loss",
    "behavior_tree": "attendee_passive_v1"
  }
}

┌─────────────────────────────────────────────────────────────┐
│                    media-load-simulator                       │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │  Scenario    │  │  Connection  │  │  Media Engine      │  │
│  │  Scheduler   │──│  Pool        │──│  (Pipeline)        │  │
│  │  (DSL VM)    │  │  (Lock-free) │  │  ┌──────────────┐  │  │
│  └──────────────┘  └──────────────┘  │  │ Codec Sim    │  │  │
│         │               │            │  │ (H.264/VP8/  │  │  │
│         ▼               ▼            │  │  Opus/Simul) │  │  │
│  ┌─────────────────────────────────┐ │  ├──────────────┤  │  │
│  │      Signaling Protocol Stack   │ │  │ Network Emu  │  │  │
│  │  (WebRTC/SIP/Private over QUIC) │ │  │ (NetEm/TC)   │  │  │
│  └─────────────────────────────────┘ │  ├──────────────┤  │  │
│         │               │            │  │ Stats Collector│  │  │
│         ▼               ▼            │  │ (eBPF/Perf)  │  │  │
│  ┌─────────────────────────────────┐ │  └──────────────┘  │  │
│  │      Transport Abstraction      │ └────────────────────┘  │
│  │  (UDP/TCP/QUIC/WebTransport)    │                          │
│  └─────────────────────────────────┘                          │
└─────────────────────────────────────────────────────────────┘

// 连接池核心数据结构：分片 + 原子操作
struct ConnectionPool {
    shards: Box<[Shard]>,           // 64 个分片，避免伪共享
    global_state: AtomicU64,        // 全局状态位图
    recycler: CrossbeamQueue<Conn>, // 连接复用队列
}

struct Shard {
    conns: ArrayVec<[Conn; SHARD_CAP]>,  // 栈式分配，无堆开销
    free_list: AtomicUsize,              // 空闲索引链表
    waker: AtomicWaker,                  // 异步唤醒
}

// 单次获取/释放仅 2-3 条 CAS 指令，延迟 < 50ns
impl ConnectionPool {
    fn acquire(&self) -> Option<Conn> { /* ... */ }
    fn release(&self, conn: Conn) { /* ... */ }
}

// signaling.dsl
state_machine WebRTCSignaling {
    initial = Idle;
    
    state Idle {
        on RecvOffer(sdp) -> Negotiating { 
            validate_sdp(sdp); 
            send_answer(create_answer(sdp)) 
        }
    }
    
    state Negotiating {
        on RecvIceCandidate(cand) -> Negotiating { 
            add_ice_candidate(cand) 
        }
        on IceConnected -> Connected { start_media() }
        on Timeout(10s) -> Failed { emit_event(SignalTimeout) }
    }
    
    state Connected {
        on RecvReOffer(sdp) -> Renegotiating { ... }
        on RecvBye -> Idle { cleanup() }
    }
}

struct MediaPipeline {
    video: VideoStreamSimulator,
    audio: AudioStreamSimulator,
    network: NetworkEmulator,
}

impl VideoStreamSimulator {
    fn next_packet(&mut self, now: Instant) -> RtpPacket {
        // 1. 基于 GOP 结构生成帧大小序列（Pareto 分布拟合 I/P/B 帧）
        // 2. 按码率控制算法（如 GCC）计算发包间隔
        // 3. 注入丢包、乱序、抖动（MMPP 模型）
        // 4. 生成 RTP 头 + 负载占位符（仅填充特征字节）
    }
}

# 伪代码：多指标联合异常检测
def detect_anomaly(metrics: DataFrame, baseline: BaselineModel) -> List[Anomaly]:
    anomalies = []
    for metric_name, series in metrics.items():
        # 1. 单指标变点检测 (RuLSIF + CUSUM)
        changepoints = rulsif_cusum(series, baseline[metric_name])
        
        # 2. 多指标相关性突变 (PCPCA 降维 + Mahalanobis 距离)
        if len(changepoints) > 0:
            correlated = pcpca_mahalanobis(metrics, changepoints)
            anomalies.extend(correlated)
    
    # 3. 拓扑感知聚合：按服务/实例/可用区聚合，抑制噪声
    return topological_aggregate(anomalies, service_topology)

根因定位流程：
1. 异常触发 → 2. 因果图回溯 (Top-K 疑似节点) → 3. 差分剖析 (对比基线 Profile) → 4. 证据链生成

[根因] media-gateway:worker_pool_exhaustion (置信度 0.94)
├─ 现象: join_meeting_latency_p99 从 800ms 升至 12s
├─ 指标: worker_queue_depth > 10000 (阈值 1000), task_wait_time_p99 8.2s
├─ 代码热点: media_gateway/src/ice.rs:234 `gather_candidates()` 占用 67% CPU
│   └─ 原因: 并发 ICE gather 触发大量系统调用 `getifaddrs()`，内核锁竞争
├─ 对比基线: 同代码路径在 10 万并发下 CPU 仅 12%，当前 67%
└─ 建议修复: 缓存网络接口列表、异步化 ICE gather、引入连接池复用

# .github/workflows/perf-regression.yml
name: Performance Regression Gate
on: [pull_request]

jobs:
  perf-test:
    runs-on: self-hosted-perf-cluster
    steps:
      - uses: actions/checkout@v4
      - name: Deploy Canary
        run: helm upgrade --install canary ./chart --set image.tag=${{ github.sha }}
      - name: Run Pressure Scenario
        run: |
          mls-cli run 
            --scenario webinar_10k_spike 
            --target canary.media.svc.cluster.local 
            --baseline-ref main 
            --thresholds "join_latency_p99<2s,error_rate<0.1%,cpu_p95<70%"
      - name: Generate Report
        if: always()
        run: mls-cli report --format html --output perf-report.html
      - name: Comment PR
        uses: actions/github-script@v7
        with:
          script: |
            // 发布性能对比报告到 PR 评论

// xdp_prog_kern.c 核心逻辑：仅做五元组哈希分发到对应 UMem 队列
SEC("xdp")
int xdp_dispatch(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return XDP_PASS;
    if (eth->h_proto != bpf_htons(ETH_P_IP)) return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;
    if (ip->protocol != IPPROTO_UDP) return XDP_PASS;

    struct udphdr *udp = (void *)ip + (ip->ihl << 2);
    if ((void *)(udp + 1) > data_end) return XDP_PASS;

    // 关键：基于目的端口哈希映射到模拟器实例的 AF_XDP 队列组
    __u32 queue_id = bpf_get_hash_recalc((void *)udp) % MAX_QUEUES;
    return bpf_redirect_map(&xsks_map, queue_id, 0);
}

# chaos-experiment-webinar.yaml
apiVersion: chaos-mesh.org/v1alpha1
kind: PodChaos
metadata:
  name: media-gateway-pod-kill-during-peak
spec:
  action: pod-failure
  mode: one
  duration: "30s"
  selector:
    namespaces: ["prod-media"]
    labelSelectors:
      app: media-gateway
  scheduler:
    cron: "@once"  # 由压测编排器动态触发
---
# 稳态判定规则 (嵌入压测编排 DSL)
steady_state_validation:
  metrics_source: "victoriametrics"
  evaluation_window: "5m"  # 故障注入后观测窗口
  ss_vector:
    - name: "join_success_rate"
      query: 'sum(rate(meeting_join_total{result="success"}[1m])) / sum(rate(meeting_join_total[1m]))'
      baseline: 0.999
      tolerance: 0.005  # 允许跌至 99.4%
      recovery_time_max: "60s"  # 必须在 60s 内恢复基线
    - name: "media_gateway_cpu_p95"
      query: 'histogram_quantile(0.95, rate(container_cpu_usage_seconds_total{pod=~"media-gateway-.*"}[1m]))'
      baseline: 0.7
      tolerance: 0.2  # 允许飙升至 90%
    - name: "ice_nomination_latency_p99"
      query: 'histogram_quantile(0.99, rate(ice_nomination_duration_seconds_bucket[1m]))'
      baseline: 2.0
      tolerance: 3.0  # 允许降级至 5s

# 性能基线仓库结构
perf-baselines/
├── main/                    # 主分支基线 (自动更新)
│   ├── webinar_10k_spike/
│   │   ├── metrics.json     # 核心指标快照 (P50/P95/P99/Error Rate/CPU/Mem)
│   │   ├── profile.tar.gz   # 采样 Profile (fgprof/pprof)
│   │   ├── trace_sample.json # 典型 Trace 样本
│   │   └── baseline.lock    # 基线版本锁 (Git SHA + Timestamp + Operator)
│   └── ...
├── release/v2.4.0/          # 发布版本基线快照 (只读归档)
└── pr/                      # PR 临时基线 (自动清理)
    └── pr-12345/

def compare_baseline(current: Metrics, baseline: Metrics, thresholds: dict) -> Verdict:
    # 1. 统计显著性检验 (Mann-Whitney U Test, p < 0.01)
    # 2. 业务阈值硬性判定 (SLA 红线)
    # 3. 趋势漂移检测 (EWMA 趋势斜率 > 阈值报警)
    # 4. 多维向量距离 (Mahalanobis Distance) 综合评分
    return Verdict(PASS/WARN/FAIL, evidence_chain)

# 压测启动时自动注入采样参数
# Java: -XX:StartFlightRecording=duration=1800s,settings=profile,filename=profile.jfr
# Go:   import _ "github.com/uber-go/automaxprocs"; go tool pprof -http=:0 http://localhost:6060/debug/fgprof

# 流水线后处理步骤
generate_differential_flamegraph() {
    # 1. 下载当前与基线 Profile
    # 2. 使用 speedscope / flamegraph.pl 生成差分 SVG
    # 3. 关键函数增量 > 5% 且绝对耗时 > 1% 总采样 -> 标记为 "Regression Hotspot"
    # 4. 自动关联 Git Blame 定位提交者、关联 Jira Ticket
}

┌─────────────┐    ┌──────────────────┐    ┌─────────────────┐    ┌──────────────┐
│  生产脱敏   │───▶│  特征分布提取    │───▶│  合成数据生成器  │───▶│  压测专用数据湖 │
│  审计日志   │    │  (差分隐私 + GAN)│    │  (Faker + 自定义)│    │  (MinIO + Iceberg)│
└─────────────┘    └──────────────────┘    └─────────────────┘    └──────────────┘
       │                   │                       │                      │
       ▼                   ▼                       ▼                      ▼
  - 字段级掩码        - 统计分布不变性      - 语义约束满足         - 版本化管理
  - K-匿名化 (k=50)   - 隐私预算 ε=0.5      - 业务规则校验         - 审计日志留存 3 年
  - 敏感词过滤        - 重识别风险评估      - 规模无限扩展         - 访问 RBAC 管控