TornadoVM: Skill for Claude Code

NCCL with TornadoVM

tornado-nccl runs NCCL operations as library tasks on TornadoVM device buffers, so a multi-GPU step (kernel → collective → kernel) stays on the GPUs. Read tornado-nccl/ARCHITECTURE.md for the design and full API, and tornado-nccl/README.md for a short tour. This skill is the working recipe.

The model in four rules

1. One rank = one TornadoExecutionPlan on one GPU. Build one task graph per local GPU (same code, rank-specific data), each plan withDevice(gpu r).
2. The collective is a libraryTask in every rank's graph, in the same order on every rank: .libraryTask("sum", Nccl::allReduceInPlace, comm, grads, NcclRedOp.SUM).
3. Run the ranks together with NcclPlanGroup. Never call plan.execute() rank by rank on one thread: the first collective waits for the others forever.
4. Close in reverse order: group → plans → communicator. Closing the communicator before plans that captured CUDA graphs hangs in ncclCommDestroy.

Template (follow the user's kernel rules)

Kernels use KernelContext only, never @Parallel. Each kernel bounds-checks explicitly, and every kernel task gets a WorkerGrid with an explicit local size in a GridScheduler.

public static void scale(KernelContext ctx, FloatArray a, float f) {
    int id = ctx.globalIdx;
    if (id < a.getSize()) {
        a.set(id, a.get(id) * f);
    }
}

TornadoDevice[] gpus = { TornadoExecutionPlan.getDevice(0, 0), TornadoExecutionPlan.getDevice(0, 1) };
TornadoExecutionPlan[] plans = new TornadoExecutionPlan[gpus.length];
try (NcclCommunicator comm = NcclCommunicator.create(gpus)) {
    try {
        for (int r = 0; r < gpus.length; r++) {
            TaskGraph g = new TaskGraph("rank" + r)
                    .transferToDevice(DataTransferMode.FIRST_EXECUTION, data[r])
                    .task("pre", Kernels::scale, new KernelContext(), data[r], 2.0f)
                    .libraryTask("sum", Nccl::allReduceInPlace, comm, data[r], NcclRedOp.SUM)
                    .task("post", Kernels::scale, new KernelContext(), data[r], 0.5f)
                    .transferToHost(DataTransferMode.EVERY_EXECUTION, data[r]);
            WorkerGrid w = new WorkerGrid1D(n);
            w.setLocalWork(256, 1, 1);
            GridScheduler s = new GridScheduler();
            s.addWorkerGrid("rank" + r + ".pre", w);     // one entry per kernel task: count them
            s.addWorkerGrid("rank" + r + ".post", w);
            plans[r] = new TornadoExecutionPlan(g.snapshot()).withDevice(gpus[r]).withGridScheduler(s);
        }
        try (NcclPlanGroup ranks = new NcclPlanGroup(plans).withStepTimeout(Duration.ofSeconds(30))) {
            for (int step = 0; step < steps; step++) {
                ranks.execute();
            }
        }
    } finally {
        for (TornadoExecutionPlan p : plans) { if (p != null) p.close(); }   // plans before comm
    }
}