工信部发布"AI+通信"三年路线图：城域1ms时延圈覆盖75%意味着什么

"""
city_latency_circle.py
测量城域内计算节点间时延，估算1ms时延圈覆盖率
"""

import subprocess
import statistics
import json
from collections import defaultdict

# 城域内计算节点列表（替换为实际IP）
NODES = {
    "central-dc": "10.0.1.10",      # 中心数据中心
    "district-a": "10.0.2.20",      # A区边缘节点
    "district-b": "10.0.3.30",      # B区边缘节点
    "district-c": "10.0.4.40",      # C区边缘节点
    "district-d": "10.0.5.50",      # D区边缘节点
}

PING_COUNT = 20  # 每对节点探测次数，取均值更稳定
LATENCY_THRESHOLD_MS = 1.0  # 1ms时延圈判定阈值


def ping_latency(src: str, dst: str, count: int = PING_COUNT) -> float:
    """用ping测量src→dst的平均时延（ms），失败返回-1"""
    try:
        result = subprocess.run(
            ["ping", "-c", str(count), "-W", "1", dst],
            capture_output=True, text=True, timeout=30,
        )
        lines = result.stdout.strip().split("\n")
        # 解析最后一行: "rtt min/avg/max/mdev = 0.021/0.032/0.045/0.005 ms"
        last = lines[-1]
        avg_str = last.split("=")[-1].strip().split("/")[1]
        return float(avg_str)
    except Exception as e:
        print(f"[WARN] ping {src}→{dst} failed: {e}")
        return -1.0


def measure_all_pairs():
    """测量所有节点对之间的时延"""
    results = defaultdict(dict)
    names = list(NODES.keys())
    for i, n1 in enumerate(names):
        for n2 in names[i + 1:]:
            lat = ping_latency(NODES[n1], NODES[n2])
            results[n1][n2] = lat
            results[n2][n1] = lat  # 对称存储
            status = "✓ ≤1ms" if lat > 0 and lat <= LATENCY_THRESHOLD_MS else "✗ >1ms"
            print(f"  {n1} → {n2}: {lat:.3f}ms  {status}")
    return results


def estimate_coverage(results):
    """估算1ms时延圈覆盖率：能从任意节点在1ms内到达的节点比例"""
    names = list(NODES.keys())
    total_pairs = len(names) * (len(names) - 1)
    within_circle = 0

    for n1 in names:
        for n2 in names:
            if n1 == n2:
                continue
            lat = results.get(n1, {}).get(n2, -1)
            if lat > 0 and lat <= LATENCY_THRESHOLD_MS:
                within_circle += 1

    coverage = within_circle / total_pairs * 100
    print(f"\n1ms时延圈覆盖率: {coverage:.1f}%  (达标线: 75%)")
    print(f"  达标: {'✓ 是' if coverage >= 75 else '✗ 否，需继续下沉边缘节点'}")
    return coverage


if __name__ == "__main__":
    print("=== 城域算力时延圈测量 ===")
    print(f"节点数: {len(NODES)}, 阈值: {LATENCY_THRESHOLD_MS}ms\n")
    results = measure_all_pairs()
    coverage = estimate_coverage(results)

    # 输出JSON供后续分析
    report = {
        "nodes": NODES,
        "threshold_ms": LATENCY_THRESHOLD_MS,
        "coverage_pct": round(coverage, 1),
        "pair_latency": {
            f"{n1}->{n2}": v
            for n1, inner in results.items()
            for n2, v in inner.items()
        },
    }
    with open("latency_report.json", "w") as f:
        json.dump(report, f, indent=2)
    print("\n报告已写入 latency_report.json")

# 在任一节点上执行（需能ping通其他节点）
python3 city_latency_circle.py

=== 城域算力时延圈测量 ===
节点数: 5, 阈值: 1.0ms

  central-dc → district-a: 0.420ms  ✓ ≤1ms
  central-dc → district-b: 0.380ms  ✓ ≤1ms
  central-dc → district-c: 1.250ms  ✗ >1ms
  central-dc → district-d: 2.100ms  ✗ >1ms
  district-a → district-b: 0.650ms  ✓ ≤1ms
  district-a → district-c: 1.800ms  ✗ >1ms
  ...

1ms时延圈覆盖率: 60.0%  (达标线: 75%)
  达标: ✗ 否，需继续下沉边缘节点

# edge-inference-node-deployment.yaml
# 城域边缘推理节点最小部署清单
apiVersion: apps/v1
kind: Deployment
metadata:
  name: edge-inference-server
  namespace: ai-compute
spec:
  replicas: 2  # 每个区至少2副本，保证单点故障不超1ms切换
  selector:
    matchLabels:
      app: edge-inference
  template:
    metadata:
      labels:
        app: edge-inference
        district: district-c  # 替换为目标区
    spec:
      nodeSelector:
        node-type: edge-gpu   # 只调度到边缘GPU节点
      containers:
      - name: inference
        image: your-org/inference-server:v2.1  # 替换为实际镜像
        resources:
          limits:
            nvidia.com/gpu: 1   # 每副本1张GPU
            memory: "8Gi"
          requests:
            nvidia.com/gpu: 1
            memory: "4Gi"
        env:
        - name: MODEL_PATH
          value: "/models/chat-7b"  # 替换为实际模型路径
        - name: MAX_BATCH_SIZE
          value: "8"
        ports:
        - containerPort: 8000
          protocol: TCP
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 10
          periodSeconds: 5
          failureThreshold: 3  # 15秒内不健康则摘除，保证路由切换速度
---
# 对应Service，集群内可达
apiVersion: v1
kind: Service
metadata:
  name: edge-inference-district-c
  namespace: ai-compute
spec:
  selector:
    app: edge-inference
    district: district-c
  ports:
  - port: 8000
    targetPort: 8000
  type: ClusterIP