oxicuda-graph 0.4.0

OxiCUDA Graph — CUDA Graph execution engine with operator fusion, buffer lifetime analysis, stream partitioning, and optimized execution planning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# oxicuda-graph

Part of the [OxiCUDA](https://github.com/cool-japan/oxicuda) ecosystem — Pure Rust CUDA replacement for the COOLJAPAN ecosystem.

## Overview

`oxicuda-graph` is a high-level CUDA Graph execution engine that models GPU workloads as directed acyclic graphs (DAGs) of operations. It applies analysis and optimisation passes — operator fusion, buffer lifetime colouring, and multi-stream partitioning — and lowers the result to an `oxicuda_driver::graph::Graph` for low-overhead CUDA Graph submission.

## Features

- Ergonomic `GraphBuilder` API for constructing kernel, memcpy, and memset nodes with explicit buffer dependencies
- **Analysis passes**: topological ordering (ASAP/ALAP scheduling, slack, levels), buffer liveness intervals, and a Lengauer–Tarjan dominator tree
- **Optimisation passes**: element-wise kernel fusion, interval-graph buffer colouring (minimises peak allocation), and multi-stream partitioning
- `ExecutionPlan` lowering to ordered `PlanStep` sequences ready for `SequentialExecutor` (CPU simulation) or `CudaGraphExecutor`
- Execution statistics: kernels launched, nodes visited, fused ops count
- `#![forbid(unsafe_code)]` — fully safe Rust

## Usage

Add to your `Cargo.toml`:

```toml
[dependencies]
oxicuda-graph = "0.4.0"
```

```rust
use oxicuda_graph::builder::GraphBuilder;
use oxicuda_graph::executor::{ExecutionPlan, SequentialExecutor};
use oxicuda_graph::node::MemcpyDir;

let mut b = GraphBuilder::new();
let buf_in  = b.alloc_buffer("input",  4096);
let buf_out = b.alloc_buffer("output", 4096);
let upload  = b.add_memcpy("upload", MemcpyDir::HostToDevice, 4096);
let kernel  = b.add_kernel("relu", 4, 256, 0)
               .fusible(true).inputs([buf_in]).outputs([buf_out]).finish();
let download = b.add_memcpy("download", MemcpyDir::DeviceToHost, 4096);
b.chain(&[upload, kernel, download]);

let graph = b.build().unwrap();
let plan  = ExecutionPlan::build(&graph, 4).unwrap();
let stats = SequentialExecutor::new(&plan).run().unwrap();
println!("kernels launched: {}", stats.kernels_launched);
```

## Status

**v0.3.0** (2026-06-25) — 299 tests passing

## License

Apache-2.0 — © 2026 COOLJAPAN OU (Team KitaSan)