Tài liệu gốc 35 10 phútTiếng Việt + English

docs/notes/parallelization-via-sandboxes.mdXem bản gốc

Ngôn ngữ bài đọc

Bản dịch tiếng Việt

Bản dịch đầy đủ theo đúng cấu trúc tài liệu; code, liên kết và định danh kỹ thuật được giữ nguyên.

Song song hóa thông qua hộp cát

Câu hỏi: Một harness đơn có thể quản lý nhiều công việc song song bằng cách điều khiển nhiều công việc không? hộp cát - thay vì mô hình một hộp cát mỗi phiên hiện tại?

Câu trả lời ngắn gọn: Về mặt cơ học là có. Hộp cát nguyên thủy đã hỗ trợ N bị cô lập hộp cát. Kết nối thì không - người thực thi là một đơn vị toàn cầu quy trình và Không gian làm việc đường dẫn đã được cố định, vì vậy ngày nay một quy trình = một hộp cát, về mặt cấu trúc. Hai con đường đưa bạn đến sự song song công việc: A) sắp xếp các hoạt động thực thi N Kitaru (với trình tự thiết kế, trình tái cấu trúc hộp cát bằng 0) hoặc B) tái cấu trúc trình thực thi vào AgentDeps và loại bỏ N hộp cát trong một quy trình (chống lại hạt, kiểm soát nhiều hơn).

Ngày nay mọi thứ đang ở đâu

Đường may có một làn do thi công

bash và các công cụ tìm kiếm/tập tin chạy qua one CommandExecutor, được chọn một lần cho mỗi quá trình và được ghi nhớ trong một mô-đun toàn cầu:

src/decode/tools/bash.py
  43   _EXECUTOR: CommandExecutor = LocalExecutor()   # module-global singleton
  44   _executor_selected = False
  63   _get_executor()      # memoizes exactly ONE executor for the whole process
 158   active_backend(cwd)  # file tools bridge to the SAME memo

SandboxExecutor và cả hai chương trình phụ trợ rõ ràng không an toàn cho việc sử dụng đồng thời exec/run trên một ví dụ (sandbox/executor.py:116, docker_backend.py:77, modal_backend.py:107). Một phiên = một container/một sandbox từ xa = một làn nối tiếp.

Một nơi đã thành công — và chia sẻ hộp cát duy nhất

các agent công cụ (tools/agent.py:375) đã chạy đồng thời N phần tử con thông qua một harness: asyncio.gather trên N lần sinh sản, được giới hạn bởi một đèn hiệu trên mỗi vòng lặp (subagent_max_parallel). Nhưng mỗi đứa trẻ nhận được phạm vi của cha mẹ:

src/decode/tools/agent.py
 475   cwd=ctx.deps.cwd,               # SAME as parent
 476   harness_home=ctx.deps.harness_home,

Trẻ em chỉ đọc (read/glob/grep/lsp, không bash), tất cả đều đọc hộp cát phiên một. Vì vậy, số lượng người hâm mộ ra ngày hôm nay = N đồng thời người đọc, MỘT không gian làm việc. Không phải N công việc bị cô lập.

Ba khối bê tông chặn tới N hộp cát cách ly trong một quy trình

Người thực thi là một đơn vị toàn cầu quy trình (bash.py:43). Mỗi bash + tập tin op tuyến đường thông qua một bản ghi nhớ. Một quy trình ⇒ một hộp cát.
Đường dẫn vùng làm việc đã được sửa (workspace.py:27): workspace_dir(harness_home) = harness_home/.decode/sandbox, một đường đi duy nhất N công việc liên kết gắn kết cùng một thư mục máy chủ xung đột.
Chế độ áp dụng cho toàn bộ quy trình: settings.sandbox_mode được đọc một lần và áp dụng cho mọi thứ.

Nhưng những người nguyên thủy đã hỗ trợ N hộp cát

Phần cuối là các đối tượng đơn giản theo từng phiên bản; kết cấu trơ, không có trạng thái chia sẻ giữa trường hợp (executor.py:121, docker_backend.py:80). SandboxExecutor(DockerBackend()) × N là ổn.
Mỗi .create() là của riêng nó docker run container/hộp cát Modal từ xa của riêng mình — cách ly thực sự.
Quy tắc "không an toàn cho việc thực thi đồng thời trên MỘT phiên bản" được thỏa mãn bằng cách giao cho mỗi công việc của nó ví dụ riêng: tuần tự hóa trong một công việc, song song hóa trên các công việc - chính xác là gather hình dạng agent.py đã sử dụng rồi.
Tiền lệ: active_executor() (bash.py:83) tồn tại đặc biệt nên harness eval có thể làm ấm và điều khiển một trình thực thi mỗi lần chạy từ bên ngoài đường dẫn công cụ (mặc dù vẫn thông qua toàn cầu, vì vậy nó tuần tự hóa).

Mô hình hiện tại so với mục tiêu

 TODAY — one sandbox per harness process
 ┌──────────────────────────── harness process ────────────────────────────┐
 │                                                                          │
 │   agent loop ──▶ bash / files / lsp ──▶ _get_executor()  (module global) │
 │                                              │                           │
 │                                              ▼                           │
 │                                    ONE SandboxExecutor                    │
 │                                              │                           │
 │                                              ▼                           │
 │                                   ONE Workspace  (.decode/sandbox)        │
 │                                              │                           │
 │                                              ▼                           │
 │                                   ONE container / remote sandbox          │
 └──────────────────────────────────────────────────────────────────────────┘


 TARGET — one harness, N isolated jobs
 ┌──────────────────────────── harness process ────────────────────────────┐
 │                          orchestrator / gather                            │
 │            ┌───────────────────┼───────────────────┐                     │
 │            ▼                   ▼                   ▼                      │
 │        job A deps          job B deps          job C deps                 │
 │      (own executor)      (own executor)      (own executor)               │
 │            │                   │                   │                      │
 │            ▼                   ▼                   ▼                      │
 │      Workspace A           Workspace B          Workspace C               │
 │   .decode/sandbox/A     .decode/sandbox/B     .decode/sandbox/C           │
 │            │                   │                   │                      │
 │            ▼                   ▼                   ▼                      │
 │      container A           container B          container C               │
 └──────────────────────────────────────────────────────────────────────────┘

Khoảng cách giữa hai hình ảnh chính xác là các phần chặn 1–2: di chuyển người thực thi ra khỏi mô-đun toàn cầu vào trạng thái của mỗi công việc và cung cấp cho mỗi công việc một thư mục Workspace riêng biệt.

Đường A — sắp xếp N hành quyết Kitaru (bằng hạt)

Mỗi decode run đã là một quá trình thực thi luồng bền vững khép kín (runtime/flow.py:298 run_agent_task) sẽ tạo ra hộp cát của chính nó và bản sao Workspace. Song song hóa = một bộ điều khiển gửi N lần thực thi và thu thập kết quả. Không có công cụ tái cấu trúc hộp cát nào cả.

                        ┌─────────────────────────┐
                        │   controller / harness  │
                        │   (submit + gather)     │
                        └────────────┬────────────┘
             ┌───────────────────────┼───────────────────────┐
             ▼                       ▼                       ▼
      ┌────────────┐          ┌────────────┐          ┌────────────┐
      │  flow exec │          │  flow exec │          │  flow exec │
      │  (proc /   │          │  (proc /   │          │  (proc /   │
      │  Modal ctr)│          │  Modal ctr)│          │  Modal ctr)│
      │            │          │            │          │            │
      │  sandbox A │          │  sandbox B │          │  sandbox C │
      │  ws clone  │          │  ws clone  │          │  ws clone  │
      └─────┬──────┘          └─────┬──────┘          └─────┬──────┘
            │  checkpoints           │  checkpoints           │
            ▼                        ▼                        ▼
        durable state            durable state            durable state
        (replay / fork)          (replay / fork)          (replay / fork)

Trên một ngăn xếp từ xa, đây đã là hai lớp Ứng dụng Modal lồng nhau (runtime/modal_app.py:32): decode-<env> cho các thùng chứa dòng chảy, decode-sandbox-<env> cho các hộp cát bash mỗi luồng sinh ra bên trong chính nó.

Ưu điểm

Công cụ tái cấu trúc hộp cát bằng không — tính năng cách ly, Không gian làm việc cho mỗi công việc và bản sao đã có sẵn.
Độ bền miễn phí — mỗi điểm kiểm tra công việc, do đó một sự cố sẽ phát lại các lượt đã hoàn thành (flow.py:325); fork/replay/cohort đã là một bề mặt vận hành (flow.py:558, kỹ năng kitaru-replay-ops).
Cách ly cứng — các quy trình/thùng chứa riêng biệt; một công việc gặp sự cố hoặc OOM không thể chạm vào anh chị em (ZenML chấm dứt hộp cát theo id, không bao giờ chấm dứt Ứng dụng được chia sẻ — modal_app.py:14).
Quy mô qua một máy — quạt ngăn xếp từ xa đến Modal; không bị giới hạn bởi lõi/RAM của một máy chủ.
HITL, chuyển giao, các bí mật đã được nối dây mỗi lần thực hiện (flow.py:190, ADR-0016).

Nhược điểm

Không có trạng thái chia sẻ trong quá trình — công việc không thể chia sẻ ứng dụng khách mô hình ấm, bộ đệm trong bộ nhớ hoặc Biểu đồ đối tượng Python. Sự phối hợp nằm ngoài phạm vi (hiện vật, cửa hàng Kitaru).
Chi phí cho mỗi công việc — mỗi lần thực thi sẽ trả tiền cho việc khởi động luồng + xây dựng/tái sử dụng hình ảnh + hộp cát mới tạo (cài đặt git+gh, ~ 20 giây trên docker mỗi phiên - docker_backend.py:290).
Bề mặt hoạt động nặng hơn — bạn đang chạy ngăn xếp Kitaru/Modal (DECODE_ENV != local), không phải là một quá trình máy tính xách tay duy nhất; nhiều bộ phận chuyển động hơn để đứng lên và xem.
Độ chi tiết thô — đơn vị của tính song song là toàn bộ quá trình chạy, không phải là một nhiệm vụ bên trong một lần chạy. Tốt cho "chạy 20 nhiệm vụ", gây khó xử cho "một agent phân chia nội bộ 3 công nhân và hợp nhất họ".

Tốt nhất cho: công việc hàng loạt/độc lập — đánh giá, xếp hàng nhiệm vụ, nhóm những gì-nếu-nếu — mỗi công việc nằm ở đâu vận hành toàn bộ agent và bạn muốn độ bền + cân trên nhiều máy.

Đường B — thi hành trên `AgentDeps`, quạt ra bên trong một quy trình (ngược lại với hạt)

Di chuyển người thi hành ra khỏi mô-đun toàn cầu và vào AgentDeps (ở đâu cwd, gate, đã có giải pháp rồi live), đặt cho mỗi công việc một thư mục Workspace riêng biệt, sau đó gather agent N chạy trong một vòng lặp sự kiện.

Phác thảo sự thay đổi

# tools/exec.py / agent/deps.py — carry the executor as per-job state
@dataclass
class AgentDeps:
    cwd: Path
    harness_home: Path
    executor: CommandExecutor          # NEW: per-job, not a module global
    workspace: Path                    # NEW: per-job .decode/sandbox/<job-id>
    ...

# tools/bash.py — read the executor from deps, not the memo
async def bash(ctx, command, timeout=None):
    ...
    result = await ctx.deps.executor.run(command, cwd=ctx.deps.cwd, timeout_s=timeout_s)

# workspace.py — parametrize the path per job
def workspace_dir(harness_home: Path, job_id: str) -> Path:
    return (harness_home / settings.sandbox_workspace_dir / job_id)

Một cuộc chạy trông như thế nào

  one asyncio event loop
  ────────────────────────────────────────────────────────────
   gather([ run(job A), run(job B), run(job C) ])
        │            │            │
        ▼            ▼            ▼
   deps.executor  deps.executor  deps.executor     ← three distinct instances
        │            │            │
        ▼            ▼            ▼
   Workspace/A    Workspace/B    Workspace/C        ← distinct paths, no collision
        │            │            │
        ▼            ▼            ▼
   container A    container B    container C         ← "not safe concurrent on ONE
                                                        instance" holds: each job has
                                                        its own instance, serial inside

Bộ máy xử lý đồng thời đã được chứng minh trong agent.py - semaphore trên mỗi vòng lặp, gather, dep tươi mỗi đứa trẻ. Sự thay đổi là người thực hiện mà những đứa trẻ đó tiếp cận: của chính chúng chứ không phải của toàn cầu chung.