Master-Worker 资源隔离分析#

一、当前架构的资源隔离现状#

1
                                                                                                                                                                                                                    ┌─────────────────────────────────────────────────────────────────┐
2
  │                        Master (8082)                             │                                                                                                                                              │  ┌───────────────────────────────────────────────────────────┐  │
3
  │  │  SchedulerService  ───▶  StringRedisTemplate  ───▶  Redis│  │
4
  │  │  LogManager          ───▶  WebSocket (SimpMessagingTemplate)│  │
5
  │  │  MasterNettyServer   ───▶  NioEventLoopGroup (Port 9000)  │  │
6
  │  └───────────────────────────────────────────────────────────┘  │
7
  │                              │                                   │
8
  │  内存：JVM Heap (Spring Boot)                                    │
9
  │  CPU：独立线程池 (NioEventLoop)                                   │
10
  └─────────────────────────────────────────────────────────────────┘
11
                                 │
12
            ┌────────────────────┼────────────────────┐
13
            │                    │                    │
14
            ▼                    ▼                    ▼
15
     ┌────────────┐       ┌────────────┐       ┌────────────┐
16
     │  Worker-1  │       │  Worker-2  │       │  Worker-N  │
17
     │ Java Agent │       │ Java Agent │       │ Java Agent │
18
     │  ────────  │       │  ────────  │       │  ────────  │
19
     │ train.py   │       │ train.py   │       │ train.py   │
20
     │ GPU: 1     │       │ GPU: 1     │       │ GPU: 1     │
21
     └────────────┘       └────────────┘       └────────────┘
22
            │                    │                    │
23
            └────────────────────┼────────────────────┘
24
                                 │
25
                                 ▼
26
                          ┌────────────┐
27
                          │   Redis    │
28
                          │ (共享数据) │
29
                          └────────────┘

二、已实现的隔离#

1. 进程级隔离 ✅#

WorkerAgent 是独立 JVM 进程 ├── 每个 Worker 有独立的 Java Heap ├── 每个 Worker 有独立的 Python 进程 └── Worker 之间完全进程隔离

优点：

一个 Worker 崩溃不影响其他 Worker
内存不共享，无法相互影响
可部署在不同机器上实现物理隔离

2. 任务抢占原子性 ✅#

1
  // SchedulerService.tryPreemptWorker() 使用 Lua 脚本保证原子性
2
  String script =
3
      "if redis.call('get', KEYS[1]) == 'alive' and redis.call('exists', KEYS[2]) == 0 then " +
4
      "  redis.call('set', KEYS[2], ARGV[1], 'EX', 120); " +  // 2分钟过期
5
      "  return 1; " +
6
      "else " +
7
      "  return 0; " +
8
      "end";
9

10
  // KEYS[1] = worker:{workerId}:hb    (心跳存活检查)
11
  // KEYS[2] = worker:{workerId}:task  (任务锁)
12
  // ARGV[1] = taskId

防止：

同一 Worker 被多个任务同时抢占
任务分发重复

3. 心跳租约隔离 ✅#

1
  Worker ──▶ Redis Key ──▶ 独占
2
  worker:1:hb      ──▶ 仅 Worker-1 的心跳
3
  worker:1:task    ──▶ 仅 Worker-1 的任务
4
  task:xxx:workerId ──▶ 任务所有权

Worker 间资源状态完全隔离

三、缺失的隔离（风险点）#

1. GPU 资源隔离 ❌#

1
  # WorkerAgent.runPythonTask() 直接启动 train.py
2
  # 无 GPU 隔离配置
3

4
  ProcessBuilder pb = new ProcessBuilder();
5
  pb.command("uv", "run", "python", "scripts/train.py", ...);
6
  // 问题：如果同一 GPU 被多个任务占用，会 OOM
7

8
  问题：
9
  Worker-1: 运行 task-A (占用 GPU 0)
10
  Worker-2: 运行 task-B (也尝试用 GPU 0)
11
                      ↓
12
                GPU 内存竞争 → OOM

解决方案：

1
  # train.py 应该用 CUDA_VISIBLE_DEVICES 限制 GPU
2
  import os
3
  os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 指定 GPU
4

5
  # 或者用 NVIDIA Container Toolkit
6
  # 或者用 nvidia-docker GPU 隔离

2. 内存/CPU 限制 ❌#

1
  // WorkerAgent 启动 Python 进程时无资源限制
2
  ProcessBuilder pb = new ProcessBuilder();
3
  pb.directory(new File(System.getProperty("user.dir")));
4
  // 问题：Python 进程可能无限占用内存
5

6
  应该使用：
7
  // 方案1: ProcessBuilder 限制
8
  ProcessBuilder pb = new ProcessBuilder();
9
  pb.command("python", "train.py", ...);
10

11
  // 设置资源限制 (Linux)
12
  new ProcessBuilder("prlimit", "--mem=4096000", "--pid", pid); // 4GB 内存
13

14
  // 方案2: Docker 容器隔离
15
  // docker run --memory=4g --cpus=2 train.py
16

17
  // 方案3: cgroups (Kubernetes)

3. 任务并发数限制 ❌#

1
  // 当前：Worker 同时只能运行 1 个任务
2
  // 但没有机制强制这个限制
3

4
  // MasterHandler 接收 EXECUTE_TASK 后直接启动线程
5
  new Thread(() -> runPythonTask(ctx, req), "Task-Executor-" + taskId).start();
6

7
  改进方案：
8

9
  // Worker 端信号量控制并发
10
  private static final Semaphore TASK_SEMAPHORE = new Semaphore(1);
11

12
  private void handleExecuteTask(ChannelHandlerContext ctx, ExecuteTaskRequest req) {
13
      if (!TASK_SEMAPHORE.tryAcquire()) {
14
          // 拒绝任务，让 Master 重新调度
15
          sendRejection(ctx, req.getTaskId(), "Worker busy");
16
          return;
17
      }
18
      try {
19
          // 执行任务
20
      } finally {
21
          TASK_SEMAPHORE.release();
22
      }
23
  }

4. 任务间文件系统隔离 ❌#

1
  // 所有任务共享同一个工作目录
2
  File workerLogDir = new File("server_log");
3
  File workerLogFile = new File(workerLogDir, taskId + ".log");
4

5
  // 问题：如果任务同名文件会冲突

改进：

1
// 每个任务独立的目录
2
File taskDir = new File("server_log/" + taskId);
3
taskDir.mkdirs();
4
File workerLogFile = new File(taskDir, "output.log");

四、完整资源隔离矩阵

1
  ┌────────────┬──────────────┬─────────────────────────┬──────────┐
2
  │  资源类型  │   隔离方式   │        当前状态         │ 风险等级 │
3
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
4
  │ 进程内存   │ JVM 进程隔离 │ ✅ Worker 进程级隔离    │ 低       │
5
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
6
  │ GPU 显存   │ 无           │ ❌ 多任务可能 GPU 冲突  │ 高       │
7
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
8
  │ CPU 时间   │ 无           │ ❌ 任务可能 CPU 垄断    │ 中       │
9
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
10
  │ 磁盘空间   │ 无           │ ❌ 日志可能撑爆磁盘     │ 中       │
11
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
12
  │ 网络带宽   │ 无           │ ❌ 任务日志可能打爆网络 │ 中       │
13
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
14
  │ 任务并发   │ 无           │ ❌ Worker 可接受多任务  │ 中       │
15
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
16
  │ 文件路径   │ 无           │ ❌ 同名文件可能冲突     │ 低       │
17
  ├────────────┼──────────────┼─────────────────────────┼──────────┤
18
  │ Redis 连接 │ 独立连接     │ ✅ 每 Worker 独立连接   │ 低       │
19
  └────────────┴──────────────┴─────────────────────────┴──────────┘

五、生产级隔离架构

1
  ┌─────────────────────────────────────────────────────────────────────┐
2
  │                        推荐的 Worker 资源隔离                         │
3
  └─────────────────────────────────────────────────────────────────────┘
4

5
  ┌─────────────────────────────────────────────────────────────────────┐
6
  │  Worker Agent (JVM)                                                  │
7
  │  ┌────────────────────────────────────────────────────────────────┐ │
8
  │  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │ │
9
  │  │  │ TaskSlot-1 │  │ TaskSlot-2  │  │ TaskSlot-N  │  ← Semaphore│ │
10
  │  │  │  ┌───────┐  │  ┌───────┐  │  │  ┌───────┐  │            │ │
11
  │  │  │  │Python │  │  │Python │  │  │  │Python │  │            │ │
12
  │  │  │  │Process│  │  │Process│  │  │  │Process│  │            │ │
13
  │  │  │  │cgroup │  │  │cgroup │  │  │  │cgroup │  │            │ │
14
  │  │  │  │memory │  │  │memory │  │  │  │memory │  │            │ │
15
  │  │  │  │ cpu   │  │  │ cpu   │  │  │  │ cpu   │  │            │ │
16
  │  │  │  │ gpu   │  │  │ gpu   │  │  │  │ gpu   │  │            │ │
17
  │  │  │  └───────┘  │  └───────┘  │  │  └───────┘  │            │ │
18
  │  │  └─────────────┘  └─────────────┘  └─────────────┘            │ │
19
  │  └────────────────────────────────────────────────────────────────┘ │
20
  └─────────────────────────────────────────────────────────────────────┘

资源隔离技术栈：

1
┌─────────────────────────────────────────────────────────────────────┐
2
│                        隔离层                                       │
3
├─────────────────────────────────────────────────────────────────────┤
4
│  GPU隔离  │ NVIDIA Device Plugin (K8s) / CUDA_VISIBLE_DEVICES     │
5
├─────────────────────────────────────────────────────────────────────┤
6
│  内存隔离  │ cgroups memory.limit / Docker --memory                  │
7
├─────────────────────────────────────────────────────────────────────┤
8
│  CPU隔离  │ cgroups cpu.shares / Docker --cpus                      │
9
├─────────────────────────────────────────────────────────────────────┤
10
│  IO隔离   │ cgroups blkio.throttle / Docker --device-read-bps       │
11
├─────────────────────────────────────────────────────────────────────┤
12
│  进程隔离  │ Linux Namespace / Docker container                     │
13
└─────────────────────────────────────────────────────────────────────┘

六、快速改进建议#

1. 最小改进：GPU 绑定#

1
  // 根据 workerId 绑定不同 GPU
2
  private String getGpuForWorker(String workerId) {
3
      // 简单哈希：确保同一 Worker 永远用同一 GPU
4
      int gpuIndex = Math.abs(workerId.hashCode() % availableGpuCount);
5
      return String.valueOf(gpuIndex);
6
  }
7

8
  // 启动 Python 时设置环境变量
9
  ProcessBuilder pb = new ProcessBuilder();
10
  pb.environment().put("CUDA_VISIBLE_DEVICES", getGpuForWorker(workerId));

2. 中等改进：cgroups 资源限制#

1
  # 启动 Worker 前创建 cgroup
2
  sudo cgcreate -g memory,cpu:/worker-1
3
  sudo cgset -r memory.limit_in_bytes=4G /worker-1
4
  sudo cgset -r cpu.shares=1024 /worker-1
5

6
  # 在 cgroup 中启动进程
7
  sudo cgexec -g memory,cpu:/worker-1 java -jar worker.jar

3. 最佳改进：Kubernetes + Docker#

1
  apiVersion: apps/v1
2
  kind: Deployment
3
  spec:
4
    template:
5
      spec:
6
        containers:
7
        - name: worker
8
          resources:
9
            limits:
10
              nvidia.com/gpu: 1
11
              memory: "4Gi"
12
              cpu: "2"
13
            requests:
14
              memory: "2Gi"
15
              cpu: "1"
16
          env:
17
          - name: CUDA_VISIBLE_DEVICES
18
            value: "0"

七、总结#

1
  ┌────────────┬─────────────────┬───────────────────────────┐
2
  │    方面    │    当前实现     │           建议            │
3
  ├────────────┼─────────────────┼───────────────────────────┤
4
  │ 进程隔离   │ ✅ JVM 进程独立 │ 保持                      │
5
  ├────────────┼─────────────────┼───────────────────────────┤
6
  │ 任务原子性 │ ✅ Lua 脚本保证 │ 保持                      │
7
  ├────────────┼─────────────────┼───────────────────────────┤
8
  │ GPU 隔离   │ ❌ 完全缺失     │ 添加 CUDA_VISIBLE_DEVICES │
9
  ├────────────┼─────────────────┼───────────────────────────┤
10
  │ 内存限制   │ ❌ 无限制       │ 添加 cgroups/docker limit │
11
  ├────────────┼─────────────────┼───────────────────────────┤
12
  │ 并发控制   │ ❌ 无限制       │ 添加 Semaphore            │
13
  ├────────────┼─────────────────┼───────────────────────────┤
14
  │ 文件隔离   │ ❌ 共享目录     │ 改为任务独立目录          │
15
  ├────────────┼─────────────────┼───────────────────────────┤
16
  │ 网络 QoS   │ ❌ 无           │ 限流 + 异步日志           │
17
  └────────────┴─────────────────┴───────────────────────────┘

当前系统适合：

单机单 GPU 少量任务
任务负载可控的环境

不适合：

多租户环境
大规模多任务并行
关键业务（无资源保障）