企业级 AI Agent 私有化部署 GPU 资源池化与弹性切分架构实战：破解 vGPU/MIG 显存隔离、冷启动延迟与并发吞吐瓶颈

/**
 * 生产级企业 AI Agent GPU 资源池化与自适应调度引擎
 * 职责：纳管异构 GPU 节点、支持 MIG 与 MPS 混合切分、基于显存与算力双维度装箱调度并执行防 OOM 反压
 */

export type GpuPartitionType = 'MIG_HARDWARE' | 'MPS_VIRTUAL' | 'EXCLUSIVE_PHYSICAL';
export type TaskPriority = 'P0_CRITICAL_AGENT' | 'P1_ONLINE_EMBEDDING' | 'P2_OFFLINE_BATCH';

/**
 * GPU 切片实例描述
 */
export interface GpuInstanceSlice {
  sliceId: string;
  nodeName: string;
  physicalGpuIndex: number;
  partitionType: GpuPartitionType;
  totalVramMb: number;
  allocatedVramMb: number;
  computeCapacityPercent: number;
  allocatedComputePercent: number;
  activeLeases: Map<string, GpuLease>;
  isHealthy: boolean;
}

/**
 * 算力租约申请定义
 */
export interface GpuAllocationRequest {
  requestId: string;
  modelName: string;
  priority: TaskPriority;
  requiredVramMb: number;
  requiredComputePercent: number;
  preferredPartition?: GpuPartitionType;
  timeoutMs: number;
}

/**
 * 已分配的算力租约
 */
export interface GpuLease {
  leaseId: string;
  sliceId: string;
  requestId: string;
  modelName: string;
  priority: TaskPriority;
  allocatedVramMb: number;
  allocatedComputePercent: number;
  createdAt: number;
  expiresAt: number;
}

/**
 * 调度决策结果
 */
export interface SchedulingDecision {
  success: boolean;
  lease?: GpuLease;
  assignedSlice?: GpuInstanceSlice;
  backpressureTriggered?: boolean;
  rejectionReason?: string;
}

export class GpuResourcePoolScheduler {
  // 维护所有纳管的 GPU 切片拓扑
  private slices: Map<string, GpuInstanceSlice> = new Map();
  // 显存安全水位线阈值（超过此阈值触发 P2 任务反压）
  private readonly backpressureVramRatio = 0.85;

  /**
   * 注册物理或虚拟切片节点
   */
  public registerSlice(slice: Omit<GpuInstanceSlice, 'activeLeases' | 'allocatedVramMb' | 'allocatedComputePercent'>): void {
    const fullSlice: GpuInstanceSlice = {
      ...slice,
      allocatedVramMb: 0,
      allocatedComputePercent: 0,
      activeLeases: new Map(),
      isHealthy: true
    };
    this.slices.set(fullSlice.sliceId, fullSlice);
  }

  /**
   * 核心调度入口：执行双维度筛选、Bin-packing 装箱评分与配额锁定
   */
  public allocate(request: GpuAllocationRequest): SchedulingDecision {
    const now = Date.now();
    this.cleanupExpiredLeases(now);

    // 1. 过滤出健康且满足基础约束的候选切片
    const candidates = Array.from(this.slices.values()).filter(slice => {
      if (!slice.isHealthy) return false;
      if (request.preferredPartition && slice.partitionType !== request.preferredPartition) {
        return false;
      }
      const availableVram = slice.totalVramMb - slice.allocatedVramMb;
      const availableCompute = slice.computeCapacityPercent - slice.allocatedComputePercent;
      return availableVram >= request.requiredVramMb && availableCompute >= request.requiredComputePercent;
    });

    // 2. 如果候选集为空，评估是否需要对低优先级任务执行反压与抢占
    if (candidates.length === 0) {
      if (request.priority === 'P0_CRITICAL_AGENT') {
        const evicted = this.attemptEvictP2Tasks(request.requiredVramMb, request.requiredComputePercent);
        if (evicted) {
          // 抢占成功后递归尝试二次分配
          return this.allocate(request);
        }
      }
      return {
        success: false,
        rejectionReason: `GPU 算力池不足：当前无切片可满足 ${request.requiredVramMb}MB 显存与 ${request.requiredComputePercent}% 算力请求`
      };
    }

    // 3. 基于最优装箱（Best-Fit Bin-packing）打分：优先选择分配后碎片最小的切片
    candidates.sort((a, b) => {
      const remainingVramA = (a.totalVramMb - a.allocatedVramMb) - request.requiredVramMb;
      const remainingVramB = (b.totalVramMb - b.allocatedVramMb) - request.requiredVramMb;
      return remainingVramA - remainingVramB;
    });

    const selectedSlice = candidates[0];

    // 4. 检查是否触发安全水位线反压警报
    const projectedUsage = (selectedSlice.allocatedVramMb + request.requiredVramMb) / selectedSlice.totalVramMb;
    const isBackpressure = projectedUsage >= this.backpressureVramRatio;

    // 5. 生成租约并原子更新切片状态
    const lease: GpuLease = {
      leaseId: `lease_${now}_${Math.random().toString(36).substring(2, 7)}`,
      sliceId: selectedSlice.sliceId,
      requestId: request.requestId,
      modelName: request.modelName,
      priority: request.priority,
      allocatedVramMb: request.requiredVramMb,
      allocatedComputePercent: request.requiredComputePercent,
      createdAt: now,
      expiresAt: now + request.timeoutMs
    };

    selectedSlice.allocatedVramMb += request.requiredVramMb;
    selectedSlice.allocatedComputePercent += request.requiredComputePercent;
    selectedSlice.activeLeases.set(lease.leaseId, lease);

    return {
      success: true,
      lease,
      assignedSlice: selectedSlice,
      backpressureTriggered: isBackpressure
    };
  }

  /**
   * 释放已分配租约
   */
  public releaseLease(leaseId: string): boolean {
    for (const slice of this.slices.values()) {
      const lease = slice.activeLeases.get(leaseId);
      if (lease) {
        slice.allocatedVramMb = Math.max(0, slice.allocatedVramMb - lease.allocatedVramMb);
        slice.allocatedComputePercent = Math.max(0, slice.allocatedComputePercent - lease.allocatedComputePercent);
        slice.activeLeases.delete(leaseId);
        return true;
      }
    }
    return false;
  }

  /**
   * 自动回收超时超期租约，防止孤儿连接泄漏显存
   */
  private cleanupExpiredLeases(currentTime: number): void {
    for (const slice of this.slices.values()) {
      for (const [leaseId, lease] of slice.activeLeases.entries()) {
        if (currentTime > lease.expiresAt) {
          slice.allocatedVramMb = Math.max(0, slice.allocatedVramMb - lease.allocatedVramMb);
          slice.allocatedComputePercent = Math.max(0, slice.allocatedComputePercent - lease.allocatedComputePercent);
          slice.activeLeases.delete(leaseId);
        }
      }
    }
  }

  /**
   * 针对 P0 级实时在线智能体任务，驱逐运行中的 P2 离线批处理任务
   */
  private attemptEvictP2Tasks(neededVram: number, neededCompute: number): boolean {
    let freedVram = 0;
    let freedCompute = 0;
    const leasesToEvict: string[] = [];

    for (const slice of this.slices.values()) {
      for (const [leaseId, lease] of slice.activeLeases.entries()) {
        if (lease.priority === 'P2_OFFLINE_BATCH') {
          leasesToEvict.push(leaseId);
          freedVram += lease.allocatedVramMb;
          freedCompute += lease.allocatedComputePercent;
          if (freedVram >= neededVram && freedCompute >= neededCompute) {
            break;
          }
        }
      }
      if (freedVram >= neededVram && freedCompute >= neededCompute) {
        break;
      }
    }

    if (freedVram >= neededVram && freedCompute >= neededCompute) {
      for (const id of leasesToEvict) {
        this.releaseLease(id);
      }
      return true;
    }
    return false;
  }
}