diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index cf9a33179b..65fa016743 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -68,6 +68,11 @@ jobs: # tests that cover the configuration actually built. - package: oxide-artifacts test_args: --all-targets --features object + # `#[tile_export]` descriptions and their validation rules, shared + # by cuda-macros, the backend and cargo-oxide. Pure Rust, no CUDA. + - package: oxide-tile-export + # The Tile IR bytecode writer for those descriptions. Pure Rust. + - package: oxide-tilebc - package: reserved-oxide-symbols # launch_requires_unsafe trybuild fixture dev-depends on # cuda-host/cuda-core, which transitively pull cuda-bindings diff --git a/cuda-oxide/Cargo.lock b/cuda-oxide/Cargo.lock index 2436a0edbf..cdef05af07 100644 --- a/cuda-oxide/Cargo.lock +++ b/cuda-oxide/Cargo.lock @@ -212,6 +212,8 @@ dependencies = [ "libnvvm-sys", "nvjitlink-sys", "oxide-artifacts 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", + "oxide-tile-export", + "oxide-tilebc", "ptx-parse", "ptx-schedule", "reserved-oxide-symbols", @@ -466,6 +468,7 @@ dependencies = [ "cuda-core", "cuda-device", "cuda-host", + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -1101,6 +1104,22 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.21", +] + +[[package]] +name = "oxide-tilebc" +version = "0.2.1" +dependencies = [ + "thiserror 2.0.21", +] + [[package]] name = "parking_lot_core" version = "0.9.12" diff --git a/cuda-oxide/Cargo.toml b/cuda-oxide/Cargo.toml index 1e296a90a7..6aeea9929e 100644 --- a/cuda-oxide/Cargo.toml +++ b/cuda-oxide/Cargo.toml @@ -24,6 +24,8 @@ members = [ "crates/nvvm-transforms", "crates/cargo-oxide", "crates/oxide-artifacts", + "crates/oxide-tile-export", + "crates/oxide-tilebc", # FFI bindings "crates/libnvvm-sys", "crates/nvjitlink-sys", @@ -97,6 +99,13 @@ reserved-oxide-symbols = { path = "crates/reserved-oxide-symbols" } # publish, then move this line. # scripts/check-oxide-artifacts-parity.sh keeps them equal. oxide-artifacts = "0.2.1" +# Tile export descriptions shared by `#[tile_export]`, the backend, and +# `cargo oxide tilelib`. +oxide-tile-export = { path = "crates/oxide-tile-export" } +# Tile IR bytecode for those descriptions: `cargo oxide tilelib` writes a +# tile library's interface and implementation halves with it. Pure Rust, so +# cargo-oxide stays toolkit-free. +oxide-tilebc = { path = "crates/oxide-tilebc" } ptx-parse = { path = "crates/ptx-parse" } ptx-schedule = { path = "crates/ptx-schedule" } diff --git a/cuda-oxide/Justfile b/cuda-oxide/Justfile index 36d083ba5c..ac37ec18d3 100644 --- a/cuda-oxide/Justfile +++ b/cuda-oxide/Justfile @@ -61,7 +61,7 @@ test: -p cuda-intrinsics-gen -p cuda-target-spec -p cuda-intrinsics -p llvm-export \ -p dialect-mir -p dialect-nvvm -p mir-importer -p mir-lower \ -p mir-transforms -p nvvm-transforms -p reserved-oxide-symbols \ - -p cuda-device -p libnvvm-sys -p nvjitlink-sys \ + -p oxide-tile-export -p oxide-tilebc -p cuda-device -p libnvvm-sys -p nvjitlink-sys \ -p cuda-artifact-finalizer -p cargo-oxide \ -p dialect-iket -p iket-lower -p ptx-parse -p dialect-ptx \ -p ptx-schedule diff --git a/cuda-oxide/README.md b/cuda-oxide/README.md index 586f936a72..57ee3befa0 100644 --- a/cuda-oxide/README.md +++ b/cuda-oxide/README.md @@ -139,6 +139,9 @@ cargo oxide test # Compile a crate's device code to a binary LTOIR artifact in one step cargo oxide emit-ltoir +# Package a crate's #[tile_export] functions as a cuTile tile library +cargo oxide tilelib + # Refresh the cached codegen backend cargo oxide update ``` @@ -335,6 +338,8 @@ cargo oxide run gemm_sol_final | `cuda-intrinsics-gen` | Extractor and deterministic source generator for the intrinsics | | `cuda-artifact-finalizer` | Driver-independent NVVM IR, LTOIR, and PTX finalization | | `oxide-artifacts` | Architecture-neutral embedded device artifact metadata | +| `oxide-tile-export` | `#[tile_export]` descriptions shared by the macro, the backend and `cargo oxide tilelib` | +| `oxide-tilebc` | Tile IR bytecode writer for the tile library descriptions `cargo oxide tilelib` emits | | `reserved-oxide-symbols` | Workspace-private `cuda_oxide_*` symbol-name contract | | `fuzzer` | Differential codegen fuzzer support (rustlantis adapter) | | `ptx-schedule` | PTX schedule-perturbation fuzzing (nanosleep injection campaigns) | diff --git a/cuda-oxide/crates/cargo-oxide/Cargo.toml b/cuda-oxide/crates/cargo-oxide/Cargo.toml index 7c34766a0c..45e2a16cbe 100644 --- a/cuda-oxide/crates/cargo-oxide/Cargo.toml +++ b/cuda-oxide/crates/cargo-oxide/Cargo.toml @@ -23,6 +23,8 @@ cuda-artifact-finalizer = { workspace = true } libnvvm-sys = { workspace = true } nvjitlink-sys = { workspace = true } oxide-artifacts = { workspace = true } +oxide-tile-export = { workspace = true } +oxide-tilebc = { workspace = true } ptx-parse = { workspace = true } ptx-schedule = { workspace = true } reserved-oxide-symbols = { workspace = true } diff --git a/cuda-oxide/crates/cargo-oxide/README.md b/cuda-oxide/crates/cargo-oxide/README.md index 75d4c914d6..f1e01c8c48 100644 --- a/cuda-oxide/crates/cargo-oxide/README.md +++ b/cuda-oxide/crates/cargo-oxide/README.md @@ -28,6 +28,7 @@ cargo oxide build vecadd # compile only (no run) cargo oxide build vecadd --debug-assertions # keep release optimization, compile debug assertions cargo oxide build vecadd --materialize-cubin --arch sm_120 # embed native cubin cargo oxide emit-ltoir vecadd --arch sm_100 # device code -> .ltoir (Tile/SIMT interop) +cargo oxide tilelib tilelib_relu --arch sm_120 # #[tile_export] crate -> cuTile tile library cargo oxide build -- -p my_app # arbitrary cargo build through cuda-oxide cargo oxide test # cargo test with cuda-oxide defaults cargo oxide test -- -p my_app # arbitrary cargo test through cuda-oxide @@ -53,20 +54,22 @@ cargo oxide update --force # inside the workspace, run setup via update |------------------------------|----------------------------------|-------------------------------------------------| | `--materialize-cubin` | run, sanitize, build, test, pipeline, debug | Finalize and embed target-specific native GPU code during the host build | | `--emit-nvvm-ir` | run, build, pipeline | Generate NVVM IR for libNVVM | -| `--arch ` | run, sanitize, build, test, pipeline, emit-ltoir, inspect, debug | Target architecture override | -| `--features ` | run, sanitize, debug, build, build passthrough, emit-ltoir, inspect | Comma-separated cargo features to enable | +| `--arch ` | run, sanitize, build, test, pipeline, emit-ltoir, tilelib, inspect, debug | Target architecture override | +| `--features ` | run, sanitize, debug, build, build passthrough, emit-ltoir, tilelib, inspect | Comma-separated cargo features to enable | | `--device-features ` | run, build | Comma-separated features for metadata-declared device crates only | | `--bin ` | run, sanitize, debug | Specific binary target to build/run | | `--tool ` | sanitize | Compute Sanitizer tool: `memcheck`, `racecheck`, `initcheck`, or `synccheck` | -| `-o, --output

` | emit-ltoir | Output path for the `.ltoir` artifact | +| `-o, --output

` | emit-ltoir, tilelib | Output path for the `.ltoir` or `.tilelib` artifact | +| `--library-optional` | tilelib | Succeed when the installed tileiras cannot build the `.tilelib`; the descriptions and LTOIR are still written | +| `--print` | tilelib | Print the readable form of the interface and implementation modules | | `--cargo-target-dir ` | build/test passthrough | Cargo target directory | | `--device-codegen-crate ` | build/test passthrough | Comma-separated device owner crate filter | | `--device-cfg ` | build/test passthrough | Append `--cfg NAME` to rustflags | -| `-v, --verbose` | run, sanitize, build, test, emit-ltoir, inspect | Show detailed compilation output | -| `--no-fmad` | run, sanitize, build, test, emit-ltoir, pipeline, inspect | Keep ordinary multiply and add/subtract operations separate | -| `--unchecked-indexing` | run, sanitize, build, test, emit-ltoir, pipeline, inspect | Elide device slice/array bounds checks (UB on OOB) | -| `--lineinfo` | run, sanitize, build, test, emit-ltoir, pipeline, inspect | Emit device line-number info for profilers (nvcc `-lineinfo`) | -| `--device-debug` | run, sanitize, build, test, emit-ltoir, pipeline, inspect | Emit full device debug info; disables libNVVM optimization (nvcc `-G`) | +| `-v, --verbose` | run, sanitize, build, test, emit-ltoir, tilelib, inspect | Show detailed compilation output | +| `--no-fmad` | run, sanitize, build, test, emit-ltoir, tilelib, pipeline, inspect | Keep ordinary multiply and add/subtract operations separate | +| `--unchecked-indexing` | run, sanitize, build, test, emit-ltoir, tilelib, pipeline, inspect | Elide device slice/array bounds checks (UB on OOB) | +| `--lineinfo` | run, sanitize, build, test, emit-ltoir, tilelib, pipeline, inspect | Emit device line-number info for profilers (nvcc `-lineinfo`) | +| `--device-debug` | run, sanitize, build, test, emit-ltoir, tilelib, pipeline, inspect | Emit full device debug info; disables libNVVM optimization (nvcc `-G`) | | `--debug-assertions` | build | Compile `debug_assert!` / `cfg(debug_assertions)` with release-like optimization and overflow checks disabled | | `--force` | update | Inside the workspace, run `setup` instead of advising it | | `--async` | new | Use the async template | @@ -75,8 +78,8 @@ cargo oxide update --force # inside the workspace, run setup via update | `--check` | fmt | Check formatting only | | `--json` | list | Emit stable machine-readable output | -`--arch` is required for `emit-ltoir` and explicit NVVM IR output because those -artifacts are architecture-specific. Without an override, `run` detects the +`--arch` is required for `emit-ltoir`, `tilelib` and explicit NVVM IR output +because those artifacts are architecture-specific. Without an override, `run` detects the local GPU, while `build` and `pipeline` use the compiler's feature-based target so they remain useful for cross-compilation. @@ -124,8 +127,8 @@ multi-artifact linking is not yet represented by this single-cubin path. Metadata-interop projects keep rejecting this global flag; they can instead request one independently finalized cubin per declared device crate with `artifact-kind = "cubin"`, as described below. Materialization is also a -final-output mode, so it cannot be combined with `--emit-nvvm-ir` or -`emit-ltoir`. +final-output mode, so it cannot be combined with `--emit-nvvm-ir`, +`emit-ltoir` or `tilelib`. ## Commands @@ -314,6 +317,64 @@ Pre-Blackwell targets use LLVM 7 typed pointers; `compute_100` and newer targets use modern opaque pointers. The target is checked before export and recorded alongside the artifact so the runtime uses the same format. +### `cargo oxide tilelib ` + +Packages a crate's `#[tile_export]` functions as a cuTile tile library: the +other direction of the interop, where a cuTile program calls Rust device +functions through `foreign_call`. + +```text +emit-ltoir ──> .ltoir .ll .tileexports.json + │ │ + define @(...) checked against the ABI table + │ + descriptions ──> oxide-tilebc Declaration + Implementation + │ + .iface.tilebc .impl.tilebc .tilelib.mlir + │ + tileiras --preview-create-tile-lib (lists 13.5 or newer) ──> .tilelib +``` + +The command runs `emit-ltoir` for the device half, then checks that the +emitted NVVM IR defines every implementation symbol the descriptions name +with the parameter list the native SIMT ABI predicts (`in` scalars by value, +everything else a pointer, `void` return), because the assembler never looks +inside the code payload and a missing symbol would otherwise surface only +when a cuTile program is compiled against the library. The descriptions then +become the two halves of the library through the `oxide-tilebc` crate: the +interface (`preview$func extern` declarations with tile-typed arguments) and +the implementation catalog (`preview$extern_impl` entries whose fragments +describe each parameter's buffer and its map onto the tile). Both are +written as Tile IR bytecode with the preview tag, at the version the resolved +assembler calls current (its newest listed version, 13.5 when none can read +them yet), next to a readable `.tilelib.mlir`; `--print` shows that +text. + +`tileiras --preview-create-tile-lib` exists from the CUDA 13.5 assembler on, +the first one whose `--list-versions` names bytecode 13.5. An assembler reads +preview content only at its current version, which is why the descriptions +are written at that version. When the resolved tileiras lists 13.5 or newer, +the library is assembled from the interface, the implementation catalog and +the LTOIR into `.tilelib` (or `-o`). +Otherwise the command explains what the installed assembler can read, points +at the files a newer one needs, and exits 2; `--library-optional` makes that +outcome exit 0, for toolkits that can build the descriptions but not the +library yet. The summary ends with one of two lines a script can read instead +of probing tileiras itself: `Tile library written to ` or +`Tile library skipped: lists bytecode versions ...`. The assembler +is resolved from `CUTILE_TILEIRAS_PATH` (cuTile's own override), then like +every other toolkit tool: PATH, the configured CUDA toolkit root, the standard +install locations. A tileiras that is configured but cannot be run is an +error (exit 1) naming the path and the OS error; only an assembler that runs +and lists no bytecode versions is treated as one that predates +`--list-versions`. + +```bash +cargo oxide tilelib tilelib_relu --arch sm_120 --print +cargo oxide tilelib tilelib_relu --arch sm_120 --library-optional # CUDA 13.4: descriptions and LTOIR +cargo oxide tilelib my_lib --arch sm_120 -o build/my_lib.tilelib +``` + ### `cargo oxide test` Runs `cargo test` through the cuda-oxide backend. With no extra arguments it diff --git a/cuda-oxide/crates/cargo-oxide/src/commands/artifacts.rs b/cuda-oxide/crates/cargo-oxide/src/commands/artifacts.rs index 85ddd2eaf1..94e2caaa36 100644 --- a/cuda-oxide/crates/cargo-oxide/src/commands/artifacts.rs +++ b/cuda-oxide/crates/cargo-oxide/src/commands/artifacts.rs @@ -112,6 +112,15 @@ pub(super) const GENERATED_ARTIFACT_SUFFIXES: &[&str] = &[ "target", "options", "cubin.target", + // `#[tile_export]` descriptions the backend writes next to the `.ll` + // (`oxide_tile_export::DESCRIPTIONS_SUFFIX`). + "tileexports.json", + // What `cargo oxide tilelib` writes from those descriptions: the two + // Tile IR bytecode halves, their readable dump, and the library itself. + TILELIB_INTERFACE_SUFFIX, + TILELIB_IMPLEMENTATION_SUFFIX, + TILELIB_DUMP_SUFFIX, + TILELIB_LIBRARY_SUFFIX, ]; pub(super) fn generated_artifact_paths(project_dir: &Path, package_name: &str) -> Vec { diff --git a/cuda-oxide/crates/cargo-oxide/src/commands/mod.rs b/cuda-oxide/crates/cargo-oxide/src/commands/mod.rs index f0a94b187d..10bc374ee6 100644 --- a/cuda-oxide/crates/cargo-oxide/src/commands/mod.rs +++ b/cuda-oxide/crates/cargo-oxide/src/commands/mod.rs @@ -28,6 +28,7 @@ mod scaffold; mod setup_update; #[cfg(test)] mod tests; +mod tilelib; mod toolkit; use artifacts::*; @@ -47,4 +48,5 @@ pub use passthrough::*; pub use pipeline_debug::*; pub use scaffold::*; pub use setup_update::*; +pub use tilelib::*; use toolkit::*; diff --git a/cuda-oxide/crates/cargo-oxide/src/commands/tests.rs b/cuda-oxide/crates/cargo-oxide/src/commands/tests.rs index 49d11a1e52..30cb03e83a 100644 --- a/cuda-oxide/crates/cargo-oxide/src/commands/tests.rs +++ b/cuda-oxide/crates/cargo-oxide/src/commands/tests.rs @@ -34,6 +34,7 @@ const COMMANDS_SOURCE: &str = concat!( include_str!("scaffold.rs"), include_str!("setup_update.rs"), include_str!("tests.rs"), + include_str!("tilelib.rs"), include_str!("toolkit.rs"), ); @@ -5189,3 +5190,664 @@ fn doctor_backend_source_check_covers_every_branch() { ); } } + +// ============================================================================= +// cargo oxide tilelib +// ============================================================================= + +/// The three exports of the `tilelib_relu` example, as the backend's +/// descriptions file records them. +fn tilelib_relu_descriptions() -> Vec { + use oxide_tile_export::{TileAccess, TileElem, TileExportDesc, TileParamDesc, TileSync}; + let param = |name: &str, access: TileAccess, by_value: bool| TileParamDesc { + name: name.to_string(), + elem: TileElem::F32, + access, + footprint: 1, + by_value, + }; + vec![ + TileExportDesc { + version: oxide_tile_export::CURRENT_VERSION, + decl: "relu".into(), + symbol: "relu_impl".into(), + shape: vec![128], + params: vec![ + param("x", TileAccess::In, true), + param("relu_out", TileAccess::Out, false), + ], + sync: TileSync::None, + arch: Vec::new(), + }, + TileExportDesc { + version: oxide_tile_export::CURRENT_VERSION, + decl: "scale_in_place".into(), + symbol: "scale_in_place_impl".into(), + shape: vec![128], + params: vec![ + param("x", TileAccess::InOut, false), + param("factor", TileAccess::In, true), + ], + sync: TileSync::None, + arch: Vec::new(), + }, + TileExportDesc { + version: oxide_tile_export::CURRENT_VERSION, + decl: "warp_sum".into(), + symbol: "warp_sum_impl".into(), + shape: vec![128], + params: vec![ + param("x", TileAccess::In, true), + param("warp_sum_out", TileAccess::Out, false), + ], + sync: TileSync::Warp, + arch: Vec::new(), + }, + ] +} + +/// Whitespace-insensitive form of a Tile IR text, the rule the upstream +/// fixture tests apply: a whitespace run survives, as one space, only between +/// two word characters, so the hand-written multi-line layout below compares +/// equal to the printer's one-line form while a missing space between two +/// words still differs. +fn normalize_tile_ir(text: &str) -> String { + let is_word = |c: char| c.is_alphanumeric() || "_$.@%!#\"?".contains(c); + let mut out = String::new(); + let mut pending_space = false; + for c in text.chars() { + if c.is_whitespace() { + pending_space = true; + continue; + } + if pending_space { + if let Some(prev) = out.chars().last() + && is_word(prev) + && is_word(c) + { + out.push(' '); + } + pending_space = false; + } + out.push(c); + } + out +} + +/// The interface of `tilelib_relu` in the upstream textual syntax: one +/// extern declaration per export, every argument carrying its access, the +/// results being the out/inout tiles. +const TILELIB_RELU_INTERFACE: &str = r#" +cuda_tile.module @tilelib_relu { + cuda_tile.preview$func extern @relu( + %x: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %relu_out: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + -> !cuda_tile.tile<128xf32> + cuda_tile.preview$func extern @scale_in_place( + %x: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %factor: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + -> !cuda_tile.tile<128xf32> + cuda_tile.preview$func extern @warp_sum( + %x: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %warp_sum_out: !cuda_tile.tile<128xf32> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + -> !cuda_tile.tile<128xf32> +} +"#; + +/// The implementation catalog of `tilelib_relu`: by-value scalars are the +/// rank-0 `():()` buffer, pointers the contiguous `(1):(1)` one; the two +/// elementwise exports map one invocation per element and `warp_sum` one +/// element per lane with a whole warp per invocation, which is what its +/// `synchronization = warp` clause requires. +const TILELIB_RELU_IMPLEMENTATION: &str = r#" +cuda_tile.module @tilelib_relu { + cuda_tile.preview$extern_impl @relu_impl implements @relu + (%x: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<():()>, + fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %relu_out: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<(1):(1)>, + fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + cuda_tile.preview$extern_impl @scale_in_place_impl implements @scale_in_place + (%x: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<(1):(1)>, + fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %factor: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<():()>, + fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + cuda_tile.preview$extern_impl @warp_sum_impl implements @warp_sum + (%x: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<():()>, + fragmap = #cuda_tile.preview$layout<(4, 32, 1):(32, 1, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}, + %warp_sum_out: !cuda_tile.preview$fragment<1xf32, local, + mem_layout = #cuda_tile.preview$layout<(1):(1)>, + fragmap = #cuda_tile.preview$layout<(4, 32, 1):(32, 1, 0)>> + {cuda_tile.preview$access = #cuda_tile.preview$access}) + synchronization = #cuda_tile.preview$synchronization +} +"#; + +#[test] +fn tilelib_relu_descriptions_print_as_the_upstream_modules() { + let library = TileLibrary::from_descriptions(&tilelib_relu_descriptions()) + .unwrap() + .library("tilelib_relu"); + library.verify().unwrap(); + let interface = library.interface_text(); + assert_eq!( + normalize_tile_ir(&interface), + normalize_tile_ir(TILELIB_RELU_INTERFACE), + "printed interface:\n{interface}" + ); + let implementation = library.implementation_text(); + assert_eq!( + normalize_tile_ir(&implementation), + normalize_tile_ir(TILELIB_RELU_IMPLEMENTATION), + "printed implementation:\n{implementation}" + ); + // Both halves are preview content, written at the version the + // assembler calls current with the header tag set. + let version = oxide_tilebc::BytecodeVersion::PREVIEW_FIRST; + for bytes in [ + library.interface_bytecode(version).unwrap(), + library.implementation_bytecode(version).unwrap(), + ] { + assert_eq!(&bytes[8..12], &[13, 5, 1, 0]); + } + // The readable dump names the file each module ends up in. + let dump = library_dump(&library, "tilelib_relu"); + assert!(dump.starts_with("// tilelib_relu.iface.tilebc"), "{dump}"); + assert!(dump.contains("\n// tilelib_relu.impl.tilebc"), "{dump}"); + assert_eq!(dump.matches("cuda_tile.module @tilelib_relu {").count(), 2); +} + +#[test] +fn fragmaps_follow_the_synchronization_and_the_footprint() { + use oxide_tile_export::TileSync; + use oxide_tilebc::Layout; + // One invocation per element; a footprint of F gives N/F invocations of + // F contiguous elements. + assert_eq!( + fragmap(TileSync::None, 128, 1).unwrap(), + Layout::flat(&[128, 1, 1], &[1, 0, 0]) + ); + assert_eq!( + fragmap(TileSync::None, 128, 4).unwrap(), + Layout::flat(&[32, 1, 4], &[4, 0, 1]) + ); + // A warp per invocation: 32 participants, one element each, or F + // contiguous elements each with adjacent lanes adjacent in the tile. + assert_eq!( + fragmap(TileSync::Warp, 128, 1).unwrap(), + Layout::flat(&[4, 32, 1], &[32, 1, 0]) + ); + assert_eq!( + fragmap(TileSync::Warp, 256, 4).unwrap(), + Layout::flat(&[2, 32, 4], &[128, 4, 1]) + ); + // The footprint must divide the tile size. + assert!( + fragmap(TileSync::None, 128, 3) + .unwrap_err() + .contains("does not divide") + ); + assert!( + fragmap(TileSync::Warp, 64, 4) + .unwrap_err() + .contains("multiple of 128") + ); + assert!( + fragmap(TileSync::None, 128, 0) + .unwrap_err() + .contains("positive") + ); + + // Footprints above one verify against the declaration's tile like the + // one-element case does, when every parameter shares them: `fn + // scale4(x: &mut [f32; 4], factor: &[f32; 4])`. + let mut descriptions = tilelib_relu_descriptions(); + let scale = &mut descriptions[1]; + for param in &mut scale.params { + param.footprint = 4; + param.by_value = false; + } + let library = TileLibrary::from_descriptions(&descriptions) + .unwrap() + .library("lib"); + library.verify().unwrap(); + let text = library.implementation_text(); + assert!( + text.contains( + "%x: !cuda_tile.preview$fragment<4xf32, local, mem_layout = \ + #cuda_tile.preview$layout<(4):(1)>, fragmap = \ + #cuda_tile.preview$layout<(32, 1, 4):(4, 0, 1)>>" + ), + "{text}" + ); + assert!( + text.contains( + "%factor: !cuda_tile.preview$fragment<4xf32, local, mem_layout = \ + #cuda_tile.preview$layout<(4):(1)>, fragmap = \ + #cuda_tile.preview$layout<(32, 1, 4):(4, 0, 1)>>" + ), + "{text}" + ); + // A window beside a scalar cannot share one invocation count, so the + // description is refused before the verifier would reject the fragmaps. + descriptions[1].params[1].footprint = 1; + descriptions[1].params[1].by_value = true; + let error = TileLibrary::from_descriptions(&descriptions).unwrap_err(); + assert!( + error.contains("`x` (footprint 4) and `factor` (footprint 1) differ"), + "{error}" + ); +} + +#[test] +fn a_bf16_scalar_passed_by_value_adds_the_frontend_abi_entry() { + use oxide_tile_export::TileElem; + // cuda-device's bf16 is a u16 wrapper, so the LLVM parameter is i16 + // while the tile element is bf16: the implementation has to say so. + let mut descriptions = tilelib_relu_descriptions(); + let relu = &mut descriptions[0]; + for param in &mut relu.params { + param.elem = TileElem::BF16; + } + let (_, implementation) = describe_export(relu).unwrap(); + assert_eq!( + implementation.frontend_abi, + vec![("bf16".to_string(), "i16".to_string())] + ); + // No `sync` means no clause at all, not an explicit `synchronization`. + assert_eq!(implementation.synchronization, None); + let library = TileLibrary::from_descriptions(&descriptions[..1]) + .unwrap() + .library("lib"); + library.verify().unwrap(); + let text = library.implementation_text(); + assert!( + normalize_tile_ir(&text).contains("{frontendABI={bf16=\"i16\"}}"), + "{text}" + ); + assert!(text.contains("preview$fragment<1xbf16, local"), "{text}"); + + // A bf16 behind a pointer travels as a pointer and needs no entry. + let scale = &mut descriptions[1]; + scale.params[0].elem = TileElem::BF16; + let (_, implementation) = describe_export(scale).unwrap(); + assert!(implementation.frontend_abi.is_empty()); + + // Unsigned Rust integers are the signless Tile IR integers. + let warp_sum = &mut descriptions[2]; + for param in &mut warp_sum.params { + param.elem = TileElem::U32; + } + let (func, implementation) = describe_export(warp_sum).unwrap(); + assert_eq!(func.args[0].ty.element, oxide_tilebc::ScalarType::I32); + assert_eq!( + implementation.args[1].fragment.element, + oxide_tilebc::ScalarType::I32 + ); + assert_eq!( + implementation.synchronization, + Some(oxide_tilebc::Synchronization::Warp) + ); +} + +/// The NVVM IR the backend emits for `tilelib_relu` on a modern target, +/// reduced to its function definitions. +const TILELIB_RELU_LL: &str = "\ +; ModuleID = 'builtin.module' +source_filename = \"tilelib_relu\" +target triple = \"nvptx64-nvidia-cuda\" + +define void @relu_impl(float %v0, ptr %v1) #0 { +entry: + ret void +} + +define void @scale_in_place_impl(ptr %v0, float %v1) #0 { +entry: + ret void +} + +define void @warp_sum_impl(float %v0, ptr %v1) #0 { +entry: + ret void +} + +declare float @llvm.nvvm.shfl.sync.bfly.f32(i32, float, i32, i32) #0 + +define float @tilelib_relu__warp_sum(float %v0) #0 { +entry: + ret float %v0 +} +"; + +#[test] +fn ll_defines_are_read_with_their_return_and_parameter_types() { + let defines = ll_defines(TILELIB_RELU_LL); + assert_eq!( + defines.keys().collect::>(), + [ + "relu_impl", + "scale_in_place_impl", + "tilelib_relu__warp_sum", + "warp_sum_impl" + ] + ); + assert_eq!( + defines["relu_impl"], + LlDefine { + ret: "void".into(), + params: vec!["float".into(), "ptr".into()], + local_linkage: None, + } + ); + assert_eq!(defines["tilelib_relu__warp_sum"].ret, "float"); + // `declare` lines are not definitions. + assert!(!defines.contains_key("llvm.nvvm.shfl.sync.bfly.f32")); + + // Linkage, calling convention and parameter attributes do not change + // the types; address spaces and legacy typed pointers survive intact. A + // linkage that keeps the symbol out of the module's exports is kept + // aside for the symbol check to report. + let defines = ll_defines( + "define internal fastcc void @k(ptr noundef %a, i64 %n, ptr addrspace(3) %s, i8* %p, { ptr, i64 } %slice) #0 {\n\ + define dso_local weak_odr void @w() {\n\ + define private void @p() {\n\ + define linkonce_odr void @l() {\n\ + define ptx_kernel void @\"quoted name\"() {\n", + ); + assert_eq!( + defines["k"], + LlDefine { + ret: "void".into(), + params: vec![ + "ptr".into(), + "i64".into(), + "ptr addrspace(3)".into(), + "i8*".into(), + "{ ptr, i64 }".into(), + ], + local_linkage: Some("internal".into()), + } + ); + assert_eq!(defines["w"].ret, "void"); + assert_eq!(defines["w"].local_linkage, None); + assert_eq!(defines["p"].local_linkage.as_deref(), Some("private")); + assert_eq!(defines["l"].local_linkage.as_deref(), Some("linkonce_odr")); + assert_eq!(defines["quoted name"].params, Vec::::new()); + assert_eq!(defines["quoted name"].local_linkage, None); +} + +#[test] +fn implementation_symbols_are_checked_against_the_abi_table() { + let descriptions = tilelib_relu_descriptions(); + check_implementation_symbols(TILELIB_RELU_LL, &descriptions).unwrap(); + + // The legacy LLVM 7 dialect spells every pointer `i8*`. + let legacy = TILELIB_RELU_LL.replace("ptr %v", "i8* %v"); + check_implementation_symbols(&legacy, &descriptions).unwrap(); + + // A missing symbol names what the module does define. + let renamed = TILELIB_RELU_LL.replace("@relu_impl(", "@relu("); + let problems = check_implementation_symbols(&renamed, &descriptions).unwrap_err(); + assert_eq!(problems.len(), 1, "{problems:?}"); + assert!( + problems[0].contains("no `define ... @relu_impl(`"), + "{problems:?}" + ); + assert!(problems[0].contains("@scale_in_place_impl"), "{problems:?}"); + + // Every mismatch is reported, symbol by symbol: a wrong scalar type, a + // by-value parameter where a pointer is predicted, a non-void return. + let wrong = TILELIB_RELU_LL + .replace( + "@relu_impl(float %v0, ptr %v1)", + "@relu_impl(double %v0, ptr %v1)", + ) + .replace( + "void @scale_in_place_impl(ptr %v0, float %v1)", + "float @scale_in_place_impl(float %v0, float %v1)", + ); + let problems = check_implementation_symbols(&wrong, &descriptions).unwrap_err(); + assert_eq!(problems.len(), 3, "{problems:?}"); + assert!( + problems[0].contains("`relu_impl`: parameter 0 (`x`) is `double`") + && problems[0].contains("predicts `float`"), + "{problems:?}" + ); + assert!( + problems[1].contains("`scale_in_place_impl`: returns `float`"), + "{problems:?}" + ); + assert!( + problems[2].contains("`scale_in_place_impl`: parameter 0 (`x`) is `float`") + && problems[2].contains("predicts `ptr"), + "{problems:?}" + ); + + // A parameter count mismatch is one problem with both lists. + let short = TILELIB_RELU_LL.replace( + "@warp_sum_impl(float %v0, ptr %v1)", + "@warp_sum_impl(float %v0)", + ); + let problems = check_implementation_symbols(&short, &descriptions).unwrap_err(); + assert_eq!(problems.len(), 1, "{problems:?}"); + assert!( + problems[0].contains("`warp_sum_impl`: 1 parameter(s) in the module (float), 2 in the description (float, ptr"), + "{problems:?}" + ); + + // A definition the module does not export cannot be linked as + // `.extern .func`, however right its signature is. + let hidden = TILELIB_RELU_LL + .replace( + "define void @relu_impl(", + "define internal void @relu_impl(", + ) + .replace( + "define void @warp_sum_impl(", + "define linkonce_odr void @warp_sum_impl(", + ); + let problems = check_implementation_symbols(&hidden, &descriptions).unwrap_err(); + assert_eq!(problems.len(), 2, "{problems:?}"); + assert!( + problems[0].contains("`relu_impl`: defined with `internal` linkage") + && problems[0].contains("not externally visible") + && problems[0].contains(".extern .func"), + "{problems:?}" + ); + assert!( + problems[1].contains("`warp_sum_impl`: defined with `linkonce_odr` linkage"), + "{problems:?}" + ); +} + +/// The capability decision reads `tileiras --list-versions` through +/// the command's own lookup, so the stand-ins here are executables, not +/// listings: that is the seam the command uses. +#[cfg(unix)] +#[test] +fn tileiras_capability_follows_the_listed_bytecode_versions() { + use super::tilelib::list_bytecode_versions; + use oxide_tilebc::BytecodeVersion; + use std::os::unix::fs::PermissionsExt; + + let root = unique_temp_dir("cargo_oxide_tileiras"); + fs::create_dir_all(&root).unwrap(); + let stand_in = |name: &str, body: &str| -> PathBuf { + let path = root.join(name); + fs::write(&path, format!("#!/bin/sh\n{body}\n")).unwrap(); + fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap(); + path + }; + + // CUDA 13.4's assembler. + let old = stand_in("tileiras-13.4", "printf '13.1\\n13.2\\n13.3\\n13.4\\n'"); + let versions = list_bytecode_versions(&old).unwrap(); + assert_eq!( + versions.iter().map(ToString::to_string).collect::>(), + ["13.1", "13.2", "13.3", "13.4"] + ); + assert!(super::tilelib::description_version(&versions).is_none()); + // The first assembler that reads the preview content; the header tag + // bits are not part of a release. + let new = stand_in( + "tileiras-13.5", + "printf '13.1\\n13.2\\n13.3\\n13.4\\n13.5\\n'", + ); + assert_eq!( + super::tilelib::description_version(&list_bytecode_versions(&new).unwrap()), + Some(BytecodeVersion::PREVIEW_FIRST) + ); + assert_eq!(BytecodeVersion::PREVIEW_FIRST.to_string(), "13.5"); + // The descriptions are written at the assembler's current version, the + // newest numbered one it lists: a newer assembler gets its own version + // (a named build such as `internal` is not a version), a 13.5.1 listing + // names 13.5, and a 13.4 listing names nothing. + let dev = stand_in( + "tileiras-newer", + "printf '13.1\\n13.2\\n13.3\\n13.4\\n13.5\\n13.6\\ninternal\\n'", + ); + assert_eq!( + super::tilelib::description_version(&list_bytecode_versions(&dev).unwrap()) + .map(|version| version.to_string()), + Some("13.6".to_string()) + ); + assert_eq!( + super::tilelib::description_version(&[BytecodeVersion::new(13, 5)]), + Some(BytecodeVersion::PREVIEW_FIRST) + ); + assert_eq!( + super::tilelib::description_version(&list_bytecode_versions(&old).unwrap()), + None + ); + // An assembler without the flag prints a usage message and exits 1: it + // lists nothing, which is not an error. + let legacy = stand_in( + "tileiras-13.1", + "echo 'tileiras: unknown option --list-versions' >&2; exit 1", + ); + assert_eq!(list_bytecode_versions(&legacy).unwrap(), Vec::new()); + assert!(super::tilelib::description_version(&[]).is_none()); + // A configured tileiras that cannot be run is an error naming the path + // and the OS error, not an old assembler. + let missing = root.join("no-such-tileiras"); + let error = list_bytecode_versions(&missing).unwrap_err(); + assert_eq!(error.kind(), std::io::ErrorKind::NotFound); + let message = error.to_string(); + assert!( + message.contains(&missing.display().to_string()) + && message.contains("--list-versions") + && message.contains("os error"), + "{message}" + ); + // The exit policy when no library was created. + assert_eq!(no_library_exit_code(true), 0); + assert_eq!(no_library_exit_code(false), 2); + fs::remove_dir_all(root).unwrap(); +} + +#[test] +fn tilelib_paths_and_the_tileiras_invocation_follow_the_crate_stem() { + let dir = Path::new("/tmp/cargo-oxide-tilelib"); + let paths = TileLibraryPaths::new(dir, "my-lib", None); + assert_eq!(paths.ll, dir.join("my_lib.ll")); + assert_eq!(paths.descriptions, dir.join("my_lib.tileexports.json")); + assert_eq!(paths.ltoir, dir.join("my_lib.ltoir")); + assert_eq!(paths.interface, dir.join("my_lib.iface.tilebc")); + assert_eq!(paths.implementation, dir.join("my_lib.impl.tilebc")); + assert_eq!(paths.dump, dir.join("my_lib.tilelib.mlir")); + assert_eq!(paths.library, dir.join("my_lib.tilelib")); + let custom = TileLibraryPaths::new(dir, "my-lib", Some(Path::new("out/lib.tilelib"))); + assert_eq!(custom.library, PathBuf::from("out/lib.tilelib")); + + // The invocation the Tile IR repository documents for creating a + // library: interface, implementation catalog, code payload, output. + assert_eq!( + create_tile_lib_command(Path::new("/opt/cuda/bin/tileiras"), &custom), + [ + "/opt/cuda/bin/tileiras", + "--preview-create-tile-lib", + "--preview-interface=/tmp/cargo-oxide-tilelib/my_lib.iface.tilebc", + "--preview-implementation=/tmp/cargo-oxide-tilelib/my_lib.impl.tilebc", + "--preview-implementation=/tmp/cargo-oxide-tilelib/my_lib.ltoir", + "-o", + "out/lib.tilelib", + ] + ); + // tileiras resolves like every other toolkit tool. + for path in TILEIRAS_FALLBACK_PATHS { + assert_eq!( + Path::new(path).file_name().and_then(|n| n.to_str()), + Some("tileiras") + ); + } +} + +#[test] +fn tilelib_artifacts_are_cleaned_between_builds() { + // A stale library or description must not outlive the build that + // produced it, so every suffix the command writes is a generated + // artifact. + for suffix in [ + TILELIB_INTERFACE_SUFFIX, + TILELIB_IMPLEMENTATION_SUFFIX, + TILELIB_DUMP_SUFFIX, + TILELIB_LIBRARY_SUFFIX, + ] { + assert!(GENERATED_ARTIFACT_SUFFIXES.contains(&suffix), "{suffix}"); + } + let root = unique_temp_dir("cargo_oxide_tilelib_clean"); + std::fs::create_dir_all(&root).unwrap(); + let files: Vec<_> = ["iface.tilebc", "impl.tilebc", "tilelib.mlir", "tilelib"] + .iter() + .map(|suffix| root.join(format!("my_lib.{suffix}"))) + .collect(); + for file in &files { + std::fs::write(file, b"stale").unwrap(); + } + clean_generated_files(&root, "my-lib"); + for file in &files { + assert!(!file.exists(), "{} survived the clean", file.display()); + } + std::fs::remove_dir_all(root).unwrap(); +} + +/// The smoketest's tilelib lane greps the summary lines: the descriptions +/// marker for proof that the descriptions were written before the host +/// program ran, and the two library markers to decide whether a `.tilelib` +/// is required, instead of probing tileiras itself. The script and the +/// command have to name the same text. +#[test] +fn the_smoketest_greps_the_summary_markers_this_command_prints() { + const SMOKETEST: &str = include_str!("../../../../scripts/smoketest.sh"); + for marker in [ + DESCRIPTIONS_WRITTEN_MARKER, + LIBRARY_WRITTEN_MARKER, + LIBRARY_SKIPPED_MARKER, + ] { + assert!( + SMOKETEST.contains(&format!("grep -qF '{marker}'")), + "scripts/smoketest.sh no longer greps {marker:?}" + ); + } + // Each grep must hit only its own line: the library markers must not be + // substrings of the descriptions line, which every run prints. + assert!(!DESCRIPTIONS_WRITTEN_MARKER.contains(LIBRARY_WRITTEN_MARKER)); + assert!(!DESCRIPTIONS_WRITTEN_MARKER.contains(LIBRARY_SKIPPED_MARKER)); + assert!(!LIBRARY_WRITTEN_MARKER.contains(LIBRARY_SKIPPED_MARKER)); +} diff --git a/cuda-oxide/crates/cargo-oxide/src/commands/tilelib.rs b/cuda-oxide/crates/cargo-oxide/src/commands/tilelib.rs new file mode 100644 index 0000000000..025d33dbc8 --- /dev/null +++ b/cuda-oxide/crates/cargo-oxide/src/commands/tilelib.rs @@ -0,0 +1,928 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! `cargo oxide tilelib`: package a crate's `#[tile_export]` functions as a +//! cuTile tile library. +//! +//! ```text +//! emit-ltoir ──> .ltoir .ll .tileexports.json +//! │ │ +//! define @(...) checked against abi_params() +//! │ +//! TileExportDesc ──> oxide-tilebc Declaration + Implementation +//! │ +//! .iface.tilebc .impl.tilebc .tilelib.mlir +//! │ +//! tileiras --preview-create-tile-lib (lists 13.5 or newer) ──> .tilelib +//! ``` +//! +//! The descriptions are Tile IR public-preview content, which exists from +//! bytecode 13.5 on and which an assembler reads only at the version it +//! calls current, the newest numbered version its `--list-versions` prints. +//! The command therefore asks the installed tileiras first and writes the +//! descriptions at that version (13.5 for the CUDA 13.5 assembler, and the +//! newer version a newer one names), or at 13.5 when no assembler can read +//! them yet. An older +//! assembler stops the command after the descriptions with an explanation; +//! `--library-optional` makes that outcome a success. Either way the summary +//! ends with one of two lines scripts can read: [`LIBRARY_WRITTEN_MARKER`] +//! or [`LIBRARY_SKIPPED_MARKER`]. + +use std::collections::BTreeMap; +use std::path::{Path, PathBuf}; +use std::process::Command; + +use oxide_tile_export::{ + AbiParamKind, DESCRIPTIONS_SUFFIX, TileAccess, TileElem, TileExportDesc, TileSync, +}; +use oxide_tilebc::{ + Access, BytecodeVersion, Declaration, FragmentArg, FragmentType, Implementation, Layout, + Library, MemorySpace, ScalarType, Synchronization, TileArg, TileType, +}; + +use super::*; + +/// cuTile's own override for the assembler, honoured here so one variable +/// selects the same `tileiras` for both tools. +pub(super) const TILEIRAS_PATH_ENV: &str = "CUTILE_TILEIRAS_PATH"; + +/// Suffix of the interface bytecode (`preview$func extern` declarations). +pub(super) const TILELIB_INTERFACE_SUFFIX: &str = "iface.tilebc"; +/// Suffix of the implementation catalog bytecode (`preview$extern_impl`). +pub(super) const TILELIB_IMPLEMENTATION_SUFFIX: &str = "impl.tilebc"; +/// Suffix of the readable dump of both modules. +pub(super) const TILELIB_DUMP_SUFFIX: &str = "tilelib.mlir"; +/// Suffix of the library `tileiras` assembles from the three inputs. +pub(super) const TILELIB_LIBRARY_SUFFIX: &str = "tilelib"; + +/// Fallback locations probed for `tileiras`, in the idiom of the other +/// toolkit tools. It ships in the toolkit's `bin/` beside `nvcc`. +pub(super) const TILEIRAS_FALLBACK_PATHS: &[&str] = &[ + "/usr/local/cuda/bin/tileiras", + "/opt/cuda/bin/tileiras", + "/usr/bin/tileiras", +]; + +/// The line the summary prints once both bytecode halves exist. Scripts +/// grep for it (the smoketest's tilelib lane), so it is a constant here. +pub(super) const DESCRIPTIONS_WRITTEN_MARKER: &str = "Tile library descriptions written"; + +/// The line the summary ends with when tileiras wrote the `.tilelib`; the +/// path and size follow it. The smoketest requires the library when it +/// sees this line, so the script and the command share the text. +pub(super) const LIBRARY_WRITTEN_MARKER: &str = "Tile library written to"; + +/// The line the summary ends with when no library was written, followed by +/// the tileiras that was found and the bytecode versions it lists (or that +/// none was found). The smoketest accepts the lane without a `.tilelib` only +/// when it sees this line. +pub(super) const LIBRARY_SKIPPED_MARKER: &str = "Tile library skipped"; + +// ============================================================================= +// tilelib command +// ============================================================================= + +/// Package a crate's `#[tile_export]` functions as a cuTile tile library. +/// +/// Runs [`emit_ltoir`] for the device half, checks that the emitted NVVM IR +/// defines every implementation symbol with the parameter list the ABI table +/// predicts, maps the descriptions to oxide-tilebc's model, writes the +/// interface and implementation bytecode plus a readable dump, and asks +/// `tileiras --preview-create-tile-lib` for the library when the installed +/// assembler lists bytecode 13.5 or newer, writing the descriptions at its +/// current version. Exits 1 on any error, including a tileiras that cannot +/// be run; exits 2 when no library could be created and `library_optional` +/// was not passed. +#[allow(clippy::too_many_arguments)] +pub fn tilelib( + ctx: &Context, + example: &str, + arch: &str, + features: Option<&str>, + output: Option<&Path>, + library_optional: bool, + print: bool, + verbose: bool, + no_fmad: bool, + unchecked_indexing: bool, + device_debug: DeviceDebug, +) { + let example_dir = if ctx.is_workspace { + resolve_example_dir(ctx, example) + } else { + ctx.workspace_root.clone() + }; + + // Step 1: the device half. Exits on a build or libNVVM failure, and + // clears stale descriptions and libraries before building. + emit_ltoir( + ctx, + example, + arch, + features, + None, + verbose, + no_fmad, + unchecked_indexing, + device_debug, + ); + + let paths = TileLibraryPaths::new(&example_dir, example, output); + let descriptions = read_descriptions(&paths.descriptions, example).unwrap_or_else(|error| { + eprintln!("Error: {error}"); + std::process::exit(1); + }); + + // Step 2: the LTOIR must define what the descriptions promise. The + // producer side of tileiras never looks inside the code payload, so a + // missing or misdeclared symbol would otherwise surface only when a + // cuTile program is compiled against the library. + let ll = std::fs::read_to_string(&paths.ll).unwrap_or_else(|error| { + eprintln!( + "Error: could not read the emitted NVVM IR at {}: {error}", + paths.ll.display() + ); + std::process::exit(1); + }); + if let Err(problems) = check_implementation_symbols(&ll, &descriptions) { + eprintln!( + "Error: {} does not define every implementation the descriptions name:", + paths.ll.display() + ); + for problem in problems { + eprintln!(" {problem}"); + } + std::process::exit(1); + } + + // Step 3: descriptions to Tile IR, verified the way the consumer will. + let stem = artifact_stem(example); + let library = TileLibrary::from_descriptions(&descriptions) + .unwrap_or_else(|error| { + eprintln!("Error: {error}"); + std::process::exit(1); + }) + .library(&stem); + library.verify().unwrap_or_else(|error| { + eprintln!("Error: the tile library does not verify: {error}"); + std::process::exit(1); + }); + + // The assembler decides the bytecode version. Preview content is read + // only at the version an assembler calls current (the newest numbered + // version it lists), so the descriptions are written at that version + // when the installed tileiras can build a library, and at 13.5, the + // first version with preview content, when no assembler can read them + // yet. A tileiras that was named (CUTILE_TILEIRAS_PATH, the toolkit + // root) or found but cannot be started is a configuration error, not an + // old assembler: only a run that lists nothing means "predates + // --list-versions". The error names the path and the OS error. + let tileiras = find_tileiras(ctx); + let versions = match &tileiras { + Some(tileiras) => list_bytecode_versions(tileiras).unwrap_or_else(|error| { + eprintln!("Error: {error}"); + std::process::exit(1); + }), + None => Vec::new(), + }; + let library_version = description_version(&versions); + let version = library_version.unwrap_or(BytecodeVersion::PREVIEW_FIRST); + let interface_bytes = library.interface_bytecode(version).unwrap_or_else(|error| { + eprintln!("Error: could not serialize the interface module: {error}"); + std::process::exit(1); + }); + let implementation_bytes = library + .implementation_bytecode(version) + .unwrap_or_else(|error| { + eprintln!("Error: could not serialize the implementation module: {error}"); + std::process::exit(1); + }); + let dump = library_dump(&library, &stem); + for (path, bytes) in [ + (&paths.interface, interface_bytes.as_slice()), + (&paths.implementation, implementation_bytes.as_slice()), + (&paths.dump, dump.as_bytes()), + ] { + std::fs::write(path, bytes).unwrap_or_else(|error| { + eprintln!("Error: could not write {}: {error}", path.display()); + std::process::exit(1); + }); + } + if print { + println!(); + print!("{dump}"); + } + + println!(); + println!( + "✓ {DESCRIPTIONS_WRITTEN_MARKER}: {} export(s), Tile IR {version} with the preview tag", + descriptions.len(), + ); + println!( + " {} ({} bytes)", + paths.interface.display(), + interface_bytes.len() + ); + println!( + " {} ({} bytes)", + paths.implementation.display(), + implementation_bytes.len() + ); + println!(" {} (readable form of both)", paths.dump.display()); + + // Step 4: the library itself, when the installed assembler can build one. + let (Some(tileiras), Some(version)) = (tileiras.as_deref(), library_version) else { + explain_no_library(&paths, tileiras.as_deref(), &versions); + std::process::exit(no_library_exit_code(library_optional)); + }; + + let command = create_tile_lib_command(tileiras, &paths); + println!(); + println!( + "tileiras {} lists bytecode {version} as its current version; creating the tile library:", + tileiras.display(), + ); + println!(" {}", render_command(&command)); + let output = Command::new(&command[0]) + .args(&command[1..]) + .output() + .unwrap_or_else(|error| { + eprintln!("Error: could not run {}: {error}", tileiras.display()); + std::process::exit(1); + }); + if !output.status.success() { + eprintln!( + "Error: tileiras --preview-create-tile-lib exited with {}", + output.status + ); + eprint!("{}", String::from_utf8_lossy(&output.stderr)); + std::process::exit(1); + } + let size = std::fs::metadata(&paths.library) + .map(|meta| meta.len()) + .unwrap_or(0); + println!(); + println!( + "✓ {LIBRARY_WRITTEN_MARKER} {} ({size} bytes)", + paths.library.display() + ); +} + +/// Every file the command reads or writes for one crate. +pub(super) struct TileLibraryPaths { + /// The NVVM IR the backend emitted, checked for the implementation symbols. + pub(super) ll: PathBuf, + /// The `#[tile_export]` descriptions the backend wrote next to the `.ll`. + pub(super) descriptions: PathBuf, + /// The LTOIR `emit_ltoir` wrote; the code payload of the library. + pub(super) ltoir: PathBuf, + /// The interface bytecode. + pub(super) interface: PathBuf, + /// The implementation catalog bytecode. + pub(super) implementation: PathBuf, + /// The readable dump of both modules. + pub(super) dump: PathBuf, + /// The library `tileiras` writes; `-o` overrides the default. + pub(super) library: PathBuf, +} + +impl TileLibraryPaths { + pub(super) fn new(example_dir: &Path, example: &str, library: Option<&Path>) -> Self { + let stem = artifact_stem(example); + Self { + ll: emitted_ll_path(example_dir, example), + descriptions: example_dir.join(format!("{stem}.{DESCRIPTIONS_SUFFIX}")), + ltoir: default_ltoir_path(example_dir, example), + interface: example_dir.join(format!("{stem}.{TILELIB_INTERFACE_SUFFIX}")), + implementation: example_dir.join(format!("{stem}.{TILELIB_IMPLEMENTATION_SUFFIX}")), + dump: example_dir.join(format!("{stem}.{TILELIB_DUMP_SUFFIX}")), + library: library + .map(Path::to_path_buf) + .unwrap_or_else(|| example_dir.join(format!("{stem}.{TILELIB_LIBRARY_SUFFIX}"))), + } + } +} + +/// The descriptions the backend wrote, validated. A crate without +/// `#[tile_export]` functions has no descriptions file at all, which is the +/// common mistake and gets the direct message. +fn read_descriptions(path: &Path, example: &str) -> Result, String> { + let text = match std::fs::read_to_string(path) { + Ok(text) => text, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + return Err(format!( + "no #[tile_export] functions in {example}: the build wrote no {} (a tile \ + library needs at least one exported function)", + path.display() + )); + } + Err(error) => return Err(format!("could not read {}: {error}", path.display())), + }; + let descriptions = oxide_tile_export::descriptions_from_json(&text) + .map_err(|error| format!("could not parse {}: {error}", path.display()))?; + if descriptions.is_empty() { + return Err(format!( + "no #[tile_export] functions in {example}: {} describes no exports", + path.display() + )); + } + for description in &descriptions { + description.validate().map_err(|error| { + format!( + "description of `{}` in {}: {error}", + description.decl, + path.display() + ) + })?; + } + Ok(descriptions) +} + +// ============================================================================= +// Descriptions to Tile IR +// ============================================================================= + +/// A crate's exports as the two halves of a tile library. +#[derive(Debug)] +pub(super) struct TileLibrary { + /// One `preview$func extern` declaration per export. + pub(super) funcs: Vec, + /// One `preview$extern_impl` per export. + pub(super) impls: Vec, +} + +impl TileLibrary { + /// Map every description; the first one that cannot be described stops + /// the command with its reason. + pub(super) fn from_descriptions(descriptions: &[TileExportDesc]) -> Result { + let mut funcs = Vec::with_capacity(descriptions.len()); + let mut impls = Vec::with_capacity(descriptions.len()); + for description in descriptions { + let (func, implementation) = describe_export(description) + .map_err(|error| format!("export `{}`: {error}", description.decl))?; + funcs.push(func); + impls.push(implementation); + } + Ok(Self { funcs, impls }) + } + + /// Both halves under one module name, ready to verify and write. + pub(super) fn library(&self, name: &str) -> Library { + Library::new(name, self.funcs.clone(), self.impls.clone()) + } +} + +/// One export as its declaration and its implementation. +/// +/// Every parameter becomes a tile of the export's shape on the declaration +/// and a fragment on the implementation: a by-value scalar is the rank-0 +/// `():()` buffer, everything else a contiguous footprint `(F):(1)`. The +/// fragmap is shared by all parameters, see [`fragmap`]. A `bf16` scalar +/// passed by value needs the `bf16 = i16` frontend ABI entry because +/// cuda-device's bf16 is a `u16` wrapper, so the LLVM parameter is `i16` +/// while the tile element is `bf16`. +pub(super) fn describe_export( + desc: &TileExportDesc, +) -> Result<(Declaration, Implementation), String> { + desc.validate().map_err(|error| error.to_string())?; + let tile_size = desc.shape[0]; + // Every parameter is a fragment of a tile of the same shape and the + // fragmaps of one implementation share their invocation count, so the + // footprints have to agree: a 4-element window beside a scalar would + // need 32 invocations for one argument and 128 for the other. + let footprint = desc.params[0].footprint; + if let Some(other) = desc + .params + .iter() + .find(|param| param.footprint != footprint) + { + return Err(format!( + "parameters `{}` (footprint {}) and `{}` (footprint {}) differ; every parameter \ + of one export shares the invocation count, so all footprints must be equal", + desc.params[0].name, footprint, other.name, other.footprint + )); + } + let mut args = Vec::with_capacity(desc.params.len()); + let mut fragments = Vec::with_capacity(desc.params.len()); + for param in &desc.params { + let element = scalar_type(param.elem); + let access = access(param.access); + args.push(TileArg::new( + param.name.clone(), + TileType::new(desc.shape.clone(), element), + access, + )); + let footprint = i64::from(param.footprint); + let fragmap = fragmap(desc.sync, tile_size, footprint) + .map_err(|error| format!("parameter `{}`: {error}", param.name))?; + let (shape, mem_layout) = if param.by_value { + (vec![1], Layout::scalar_mem()) + } else { + (vec![footprint], Layout::contiguous_mem(footprint)) + }; + fragments.push(FragmentArg::new( + param.name.clone(), + FragmentType::new(shape, element, MemorySpace::Local, mem_layout, fragmap), + access, + )); + } + let mut implementation = Implementation::new(desc.symbol.clone(), desc.decl.clone(), fragments); + implementation.synchronization = synchronization(desc.sync); + implementation.arch = desc.arch.clone(); + if desc + .params + .iter() + .any(|param| param.by_value && param.elem == TileElem::BF16) + { + implementation.frontend_abi = vec![("bf16".to_string(), "i16".to_string())]; + } + Ok((Declaration::new(desc.decl.clone(), args), implementation)) +} + +/// How one invocation's footprint maps onto the tile. +/// +/// Without synchronization every invocation owns `footprint` contiguous +/// elements: `(N, 1, 1):(1, 0, 0)` for a footprint of one, `(N/F, 1, F):(F, +/// 0, 1)` otherwise. With `sync = warp` the 32 lanes of a warp are the +/// participants of one invocation: `(N/32, 32, 1):(32, 1, 0)` for a footprint +/// of one, and `(N/(32F), 32, F):(32F, F, 1)` for a footprint of `F`, so each +/// lane keeps a contiguous footprint and adjacent lanes are adjacent in the +/// tile. The footprint must divide the tile size in either case. +pub(super) fn fragmap(sync: TileSync, tile_size: i64, footprint: i64) -> Result { + if footprint <= 0 { + return Err(format!("footprint {footprint} must be positive")); + } + if tile_size % footprint != 0 { + return Err(format!( + "footprint {footprint} does not divide the tile size {tile_size}" + )); + } + match sync { + TileSync::None if footprint == 1 => Ok(Layout::elementwise(tile_size)), + TileSync::None => Ok(Layout::footprint_blocks(tile_size, footprint)), + TileSync::Warp => { + let per_warp = 32 * footprint; + if tile_size % per_warp != 0 { + return Err(format!( + "sync = warp with footprint {footprint} needs a tile size that is a \ + multiple of {per_warp}, found {tile_size}" + )); + } + if footprint == 1 { + Ok(Layout::warp_lanes(tile_size)) + } else { + Ok(Layout::flat( + &[tile_size / per_warp, 32, footprint], + &[per_warp, footprint, 1], + )) + } + } + } +} + +/// Tile IR has no unsigned integers; the unsigned Rust types are the signless +/// `iN` of the same width. +fn scalar_type(elem: TileElem) -> ScalarType { + match elem { + TileElem::F16 => ScalarType::F16, + TileElem::BF16 => ScalarType::BF16, + TileElem::F32 => ScalarType::F32, + TileElem::F64 => ScalarType::F64, + TileElem::I8 | TileElem::U8 => ScalarType::I8, + TileElem::I16 | TileElem::U16 => ScalarType::I16, + TileElem::I32 | TileElem::U32 => ScalarType::I32, + TileElem::I64 | TileElem::U64 => ScalarType::I64, + } +} + +fn access(access: TileAccess) -> Access { + match access { + TileAccess::In => Access::In, + TileAccess::Out => Access::Out, + TileAccess::InOut => Access::InOut, + } +} + +/// The implementation's `synchronization` clause. An export without `sync` +/// gets no clause at all rather than an explicit `synchronization`: +/// the two mean the same thing, and leaving it out keeps the printed and +/// written form identical to an upstream module parsed without the clause. +fn synchronization(sync: TileSync) -> Option { + match sync { + TileSync::None => None, + TileSync::Warp => Some(Synchronization::Warp), + } +} + +/// The readable form of both modules, one dump so a reader sees the +/// declaration and its implementation together. Lines starting with `//` +/// are comments in the Tile IR textual syntax. +pub(super) fn library_dump(library: &Library, stem: &str) -> String { + format!( + "// {stem}.{TILELIB_INTERFACE_SUFFIX}: the interface a cuTile program calls\n{}\ + // {stem}.{TILELIB_IMPLEMENTATION_SUFFIX}: the implementations the LTOIR defines\n{}", + library.interface_text(), + library.implementation_text() + ) +} + +/// The bytecode versions `tileiras --list-versions` names, one per line. +/// +/// A launch failure is returned as the error it is, with the path in the +/// message. An assembler that ran but predates the flag exits non-zero or +/// prints a usage message instead of versions; both give an empty list. +/// Lines that are not versions (an assembler may list a named build next +/// to the numbers) are skipped. +pub(super) fn list_bytecode_versions(tileiras: &Path) -> std::io::Result> { + let output = Command::new(tileiras) + .arg("--list-versions") + .output() + .map_err(|error| { + std::io::Error::new( + error.kind(), + format!( + "could not run {} --list-versions: {error}", + tileiras.display() + ), + ) + })?; + if !output.status.success() { + return Ok(Vec::new()); + } + Ok(String::from_utf8_lossy(&output.stdout) + .lines() + .filter_map(BytecodeVersion::parse) + .collect()) +} + +// ============================================================================= +// Implementation symbols in the emitted NVVM IR +// ============================================================================= + +/// One `define` of an LLVM IR module, reduced to what the ABI check reads. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(super) struct LlDefine { + /// The return type, with linkage and calling-convention keywords removed. + pub(super) ret: String, + /// One type per parameter, names and parameter attributes removed. + pub(super) params: Vec, + /// A linkage keyword from [`LL_LOCAL_LINKAGE`] on the define, if any. + pub(super) local_linkage: Option, +} + +/// Linkages that keep a definition out of what the module exports. The Tile +/// compiler reaches an implementation as `.extern .func`, so a definition +/// with one of these is a reported problem, not a stripped keyword. +const LL_LOCAL_LINKAGE: &[&str] = &["private", "internal", "linkonce", "linkonce_odr"]; + +/// Keywords that can sit between `define` and the return type without +/// changing whether the symbol can be linked. +const LL_DEFINE_KEYWORDS: &[&str] = &[ + "available_externally", + "weak", + "common", + "appending", + "extern_weak", + "weak_odr", + "external", + "dso_local", + "dso_preemptable", + "default", + "hidden", + "protected", + "ptx_kernel", + "ptx_device", + "fastcc", + "coldcc", + "ccc", +]; + +/// Every `define ... @name(params)` of `ll`, keyed by symbol. Textual IR is +/// the robust place to check symbols: the LTOIR is an NVVM bitcode container +/// with no stable public reader, and the `.ll` beside it is what libNVVM +/// compiled. +pub(super) fn ll_defines(ll: &str) -> BTreeMap { + let mut defines = BTreeMap::new(); + for line in ll.lines() { + let Some(rest) = line.trim_start().strip_prefix("define ") else { + continue; + }; + let Some(at) = rest.find('@') else { + continue; + }; + let (prefix, after_at) = rest.split_at(at); + let after_at = &after_at[1..]; + let Some(open) = after_at.find('(') else { + continue; + }; + let name = after_at[..open].trim().trim_matches('"').to_string(); + let Some(params) = balanced_parameter_list(&after_at[open..]) else { + continue; + }; + let local_linkage = prefix + .split_whitespace() + .find(|token| LL_LOCAL_LINKAGE.contains(token)) + .map(str::to_string); + let ret = prefix + .split_whitespace() + .filter(|token| { + !LL_DEFINE_KEYWORDS.contains(token) && !LL_LOCAL_LINKAGE.contains(token) + }) + .collect::>() + .join(" "); + defines.insert( + name, + LlDefine { + ret, + params: split_top_level(params) + .into_iter() + .map(parameter_type) + .collect(), + local_linkage, + }, + ); + } + defines +} + +/// The text inside the parentheses that open `text`, honoring nesting. +fn balanced_parameter_list(text: &str) -> Option<&str> { + let mut depth = 0i32; + for (index, c) in text.char_indices() { + match c { + '(' | '[' | '{' | '<' => depth += 1, + ')' | ']' | '}' | '>' => { + depth -= 1; + if depth == 0 { + return Some(&text[1..index]); + } + } + _ => {} + } + } + None +} + +/// Split on commas outside any bracket pair. +fn split_top_level(text: &str) -> Vec<&str> { + let mut parts = Vec::new(); + let mut depth = 0i32; + let mut start = 0; + for (index, c) in text.char_indices() { + match c { + '(' | '[' | '{' | '<' => depth += 1, + ')' | ']' | '}' | '>' => depth -= 1, + ',' if depth == 0 => { + parts.push(&text[start..index]); + start = index + 1; + } + _ => {} + } + } + let last = &text[start..]; + if !last.trim().is_empty() { + parts.push(last); + } + parts +} + +/// The type of one parameter: its tokens without the `%name` and without +/// parameter attributes. +fn parameter_type(param: &str) -> String { + const ATTRIBUTES: &[&str] = &[ + "noundef", + "nonnull", + "noalias", + "nocapture", + "readonly", + "writeonly", + "readnone", + "signext", + "zeroext", + "inreg", + "returned", + "nofree", + "nest", + "immarg", + ]; + param + .split_whitespace() + .filter(|token| !token.starts_with('%')) + .filter(|token| !ATTRIBUTES.contains(token)) + .filter(|token| !token.starts_with("align") && !token.starts_with("dereferenceable")) + .collect::>() + .join(" ") +} + +/// Whether an LLVM parameter type is the one the ABI predicts. A pointer is +/// the opaque `ptr` on the modern NVVM path and a typed pointer (`i8*`) in +/// the legacy LLVM 7 dialect of pre-Blackwell targets; the pointee type +/// carries no ABI information, so any typed pointer passes. +fn llvm_type_matches(actual: &str, kind: AbiParamKind) -> bool { + match kind { + AbiParamKind::Scalar(elem) => actual == elem.llvm_name(), + AbiParamKind::Pointer(_) => actual == "ptr" || actual.ends_with('*'), + } +} + +/// The type text the message quotes for an expected parameter. +fn expected_type_text(kind: AbiParamKind) -> String { + match kind { + AbiParamKind::Scalar(elem) => elem.llvm_name().to_string(), + AbiParamKind::Pointer(_) => "ptr (i8* on the legacy path)".to_string(), + } +} + +/// Check that `ll` defines every description's implementation symbol as a +/// `void` function whose parameters are the ones [`TileExportDesc::abi_params`] +/// predicts. Every mismatch is reported, symbol by symbol. +pub(super) fn check_implementation_symbols( + ll: &str, + descriptions: &[TileExportDesc], +) -> Result<(), Vec> { + let defines = ll_defines(ll); + let mut problems = Vec::new(); + for desc in descriptions { + let Some(define) = defines.get(&desc.symbol) else { + let defined: Vec<_> = defines.keys().map(|name| format!("@{name}")).collect(); + problems.push(format!( + "`{}` (implementation of `{}`): no `define ... @{}(` in the module; it defines {}", + desc.symbol, + desc.decl, + desc.symbol, + if defined.is_empty() { + "no functions".to_string() + } else { + defined.join(", ") + } + )); + continue; + }; + if let Some(linkage) = &define.local_linkage { + problems.push(format!( + "`{}`: defined with `{linkage}` linkage, so it is not externally visible; \ + the Tile compiler links it as .extern .func", + desc.symbol + )); + } + if define.ret != "void" { + problems.push(format!( + "`{}`: returns `{}`, but a tile library implementation returns void and \ + writes its result through the trailing out pointer", + desc.symbol, define.ret + )); + } + let expected = desc.abi_params(); + if define.params.len() != expected.len() { + problems.push(format!( + "`{}`: {} parameter(s) in the module ({}), {} in the description ({})", + desc.symbol, + define.params.len(), + define.params.join(", "), + expected.len(), + expected + .iter() + .map(|param| expected_type_text(param.kind)) + .collect::>() + .join(", ") + )); + continue; + } + for (index, (actual, param)) in define.params.iter().zip(&expected).enumerate() { + if !llvm_type_matches(actual, param.kind) { + problems.push(format!( + "`{}`: parameter {index} (`{}`) is `{actual}` in the module, but the \ + description predicts `{}`", + desc.symbol, + param.name, + expected_type_text(param.kind) + )); + } + } + } + if problems.is_empty() { + Ok(()) + } else { + Err(problems) + } +} + +// ============================================================================= +// tileiras +// ============================================================================= + +/// `tileiras` from cuTile's override variable (also honoured as +/// [`TILEIRAS_PATH_ENV`], so one variable selects the same assembler for +/// both products), then the toolkit lookup every other CUDA tool uses +/// (PATH, the configured toolkit root, the standard install roots). An +/// override is returned as given: whether it runs is for +/// [`list_bytecode_versions`] to report. +pub(super) fn find_tileiras(ctx: &Context) -> Option { + if let Some(path) = std::env::var_os(TILEIRAS_PATH_ENV).filter(|value| !value.is_empty()) { + return Some(PathBuf::from(path)); + } + find_cuda_toolkit_executable(ctx, "tileiras", TILEIRAS_FALLBACK_PATHS) +} + +/// The bytecode version to write the descriptions at for an assembler that +/// lists `versions`: its current version, the newest numbered one it lists, +/// when that is 13.5 or newer. An assembler reads preview content only at +/// its current version, so an older listing (CUDA 13.4 and before) means no +/// library can be built. The header tag bits are not part of a release, so +/// `13.5` and `13.5.1` both name 13.5. +pub(super) fn description_version(versions: &[BytecodeVersion]) -> Option { + versions + .iter() + .copied() + .filter(|version| *version >= BytecodeVersion::PREVIEW_FIRST) + .max() +} + +/// Exit status when no library was created because the installed assembler +/// cannot build one: a success when the caller said the library is optional, +/// and a shortfall otherwise. +pub(super) fn no_library_exit_code(library_optional: bool) -> i32 { + if library_optional { 0 } else { 2 } +} + +/// The `tileiras --preview-create-tile-lib` invocation, argv form. +pub(super) fn create_tile_lib_command(tileiras: &Path, paths: &TileLibraryPaths) -> Vec { + vec![ + tileiras.display().to_string(), + "--preview-create-tile-lib".to_string(), + format!("--preview-interface={}", paths.interface.display()), + format!( + "--preview-implementation={}", + paths.implementation.display() + ), + format!("--preview-implementation={}", paths.ltoir.display()), + "-o".to_string(), + paths.library.display().to_string(), + ] +} + +fn render_command(command: &[String]) -> String { + command.join(" ") +} + +/// The [`LIBRARY_SKIPPED_MARKER`] line naming the assembler that was found +/// and what it lists, then why that is not enough and everything a reader +/// needs to finish the job on a newer toolkit. +fn explain_no_library( + paths: &TileLibraryPaths, + tileiras: Option<&Path>, + versions: &[BytecodeVersion], +) { + let needed = BytecodeVersion::PREVIEW_FIRST; + println!(); + match tileiras { + Some(tileiras) => { + let lists = if versions.is_empty() { + "no bytecode versions (it predates --list-versions)".to_string() + } else { + format!( + "bytecode versions {}", + versions + .iter() + .map(ToString::to_string) + .collect::>() + .join(", ") + ) + }; + println!( + "{LIBRARY_SKIPPED_MARKER}: {} lists {lists}; the descriptions need {needed} or newer", + tileiras.display() + ); + println!( + "The installed tileiras cannot create tile libraries: the descriptions are \ + Tile IR public-preview content, which exists from bytecode {needed} on and \ + needs the CUDA 13.5 or newer assembler." + ); + } + None => { + println!("{LIBRARY_SKIPPED_MARKER}: no tileiras found"); + println!( + "No tileiras was found on PATH, under {TILEIRAS_PATH_ENV}, the configured CUDA \ + toolkit root or the standard install roots; creating a tile library needs the \ + CUDA 13.5 or newer assembler, the first one that lists bytecode {needed}." + ); + } + } + println!( + "The LTOIR and the descriptions were written to {}; a capable tileiras turns them \ + into {} with:", + paths + .interface + .parent() + .unwrap_or_else(|| Path::new(".")) + .display(), + paths.library.display() + ); + let placeholder = Path::new("tileiras"); + println!( + " {}", + render_command(&create_tile_lib_command(placeholder, paths)) + ); +} diff --git a/cuda-oxide/crates/cargo-oxide/src/main.rs b/cuda-oxide/crates/cargo-oxide/src/main.rs index 292bed15cd..f962661ea1 100644 --- a/cuda-oxide/crates/cargo-oxide/src/main.rs +++ b/cuda-oxide/crates/cargo-oxide/src/main.rs @@ -19,6 +19,7 @@ //! cargo oxide debug vecadd --tui # build + cuda-gdb //! cargo oxide inspect vecadd # build + print generated PTX //! cargo oxide fuzz-schedule barrier # perturb generated PTX and watchdog it +//! cargo oxide tilelib relu --arch sm_120 # #[tile_export] crate -> cuTile tile library //! cargo oxide new my_kernel # scaffold a standalone project //! cargo oxide new my_kernel --async # scaffold with async template //! cargo oxide list # list bundled examples @@ -344,6 +345,60 @@ enum Commands { #[arg(long)] unchecked_indexing: bool, }, + /// Package a crate's `#[tile_export]` functions as a cuTile tile library. + /// + /// Runs `emit-ltoir`, checks that the LTOIR defines every implementation + /// symbol with the parameters the native SIMT ABI predicts, writes the + /// Tile IR 13.5 interface and implementation bytecode + /// (`.iface.tilebc`, `.impl.tilebc`) plus a readable + /// `.tilelib.mlir`, and asks `tileiras --preview-create-tile-lib` + /// for `.tilelib` when the installed assembler lists bytecode 13.5 + /// (CUDA 13.5 or newer). An older assembler stops the command after the + /// descriptions with exit code 2 unless `--library-optional` is passed. + Tilelib { + /// Crate name (required in workspace, optional for standalone projects) + example: Option, + /// Target architecture (e.g. sm_90, sm_100, sm_120). Required: the + /// LTOIR inside the library is architecture-specific. + #[arg(long)] + arch: String, + /// Comma-separated list of features to enable + #[arg(long)] + features: Option, + /// Output path for the `.tilelib` file (default: `/.tilelib`) + #[arg(long, short)] + output: Option, + /// Succeed when the installed tileiras cannot build the .tilelib; + /// the descriptions and LTOIR are still written (without this flag + /// that case exits 2) + #[arg(long)] + library_optional: bool, + /// Print the readable form of the interface and implementation modules + #[arg(long)] + print: bool, + /// Show verbose compilation output + #[arg(short, long)] + verbose: bool, + /// Disable implicit FMA contraction in both libNVVM and nvJitLink. + /// Also settable via CUDA_OXIDE_NO_FMA=1. + #[arg(long)] + no_fmad: bool, + /// Emit device line-number information for profilers and Compute + /// Sanitizer, leaving optimization intact (nvcc `-lineinfo`). + /// Also settable via CUDA_OXIDE_DEBUG=line. + #[arg(long)] + lineinfo: bool, + /// Emit full device debug information; libNVVM finalization runs + /// unoptimized (nvcc `-G`). Supersedes --lineinfo. + /// Also settable via CUDA_OXIDE_DEBUG=full. + #[arg(long)] + device_debug: bool, + /// Elide slice/array bounds checks in every device kernel + /// (out-of-bounds indexing becomes UB, like get_unchecked). + /// Also settable via CUDA_OXIDE_UNCHECKED_INDEXING=1. + #[arg(long)] + unchecked_indexing: bool, + }, /// Show the full compilation pipeline (MIR -> PTX/NVVM IR) with verbose output Pipeline { /// Example name (required in workspace, optional for standalone projects) @@ -585,6 +640,10 @@ fn validate_materialization_cli(cli: &Cli) -> Result<(), String> { "--materialize-cubin cannot be combined with emit-ltoir; one emits a final cubin and the other emits linkable LTOIR" .to_string(), ), + Commands::Tilelib { .. } => Err( + "--materialize-cubin cannot be combined with tilelib; a tile library carries linkable LTOIR, not a final cubin" + .to_string(), + ), Commands::List { .. } => Err( "--materialize-cubin cannot be used with list because list does not compile device code" .to_string(), @@ -985,6 +1044,35 @@ fn main() { commands::DeviceDebug::from_flags(lineinfo, device_debug), ); } + Commands::Tilelib { + example, + arch, + features, + output, + library_optional, + print, + verbose, + no_fmad, + unchecked_indexing, + lineinfo, + device_debug, + } => { + let ctx = commands::resolve_context(); + let example = resolve_example_name(example, &ctx, "tilelib"); + commands::tilelib( + &ctx, + &example, + &arch, + features.as_deref(), + output.as_deref(), + library_optional, + print, + verbose, + no_fmad, + unchecked_indexing, + commands::DeviceDebug::from_flags(lineinfo, device_debug), + ); + } Commands::Pipeline { example, emit_nvvm_ir, @@ -1326,6 +1414,14 @@ mod tests { "--materialize-cubin", ], &["cargo-oxide", "inspect", "demo", "--materialize-cubin"], + &[ + "cargo-oxide", + "tilelib", + "demo", + "--arch", + "sm_120", + "--materialize-cubin", + ], ] { let cli = Cli::try_parse_from(args).expect("global flag should parse first"); let error = validate_materialization_cli(&cli) @@ -1679,6 +1775,65 @@ mod tests { assert!(!device_debug, "--device-debug must default off"); } + #[test] + fn tilelib_parser_requires_arch_and_accepts_its_flags() { + assert!( + Cli::try_parse_from(["cargo-oxide", "tilelib", "relu"]).is_err(), + "the LTOIR inside a tile library is architecture-specific, so --arch is required" + ); + + let cli = Cli::try_parse_from([ + "cargo-oxide", + "tilelib", + "relu", + "--arch", + "sm_120", + "--library-optional", + "--print", + "-o", + "out/relu.tilelib", + ]) + .expect("tilelib command should parse"); + let Commands::Tilelib { + example, + arch, + output, + library_optional, + print, + verbose, + no_fmad, + lineinfo, + device_debug, + .. + } = cli.command + else { + panic!("expected tilelib command"); + }; + assert_eq!(example.as_deref(), Some("relu")); + assert_eq!(arch, "sm_120"); + assert_eq!(output, Some(PathBuf::from("out/relu.tilelib"))); + assert!(library_optional); + assert!(print); + assert!(!verbose); + assert!(!no_fmad); + assert!(!lineinfo, "--lineinfo must default off"); + assert!(!device_debug, "--device-debug must default off"); + + // Without the two flags the command insists on a library. + let cli = Cli::try_parse_from(["cargo-oxide", "tilelib", "relu", "--arch", "sm_120"]) + .expect("tilelib command should parse"); + let Commands::Tilelib { + library_optional, + print, + .. + } = cli.command + else { + panic!("expected tilelib command"); + }; + assert!(!library_optional); + assert!(!print); + } + #[test] fn parser_accepts_device_debug_flags() { let cli = Cli::try_parse_from(["cargo-oxide", "build", "vecadd", "--lineinfo"]) diff --git a/cuda-oxide/crates/cuda-device/README.md b/cuda-oxide/crates/cuda-device/README.md index 9b43073eb6..0dbfe22e22 100644 --- a/cuda-oxide/crates/cuda-device/README.md +++ b/cuda-oxide/crates/cuda-device/README.md @@ -223,6 +223,7 @@ convenience. The table is the whole `pub use cuda_macros::{...}` list in | `#[pure]` | Mark as pure (no side effects) | | `#[readonly]` | Mark as read-only | | `#[constant]` | Place a `ConstantMemory` static in constant memory, plus a host `set_` setter | +| `#[tile_export]` | Export a device function to cuTile through a tile library | | `gpu_printf!` | Device-side printf | | `ptx_asm!` | Unsafe CUDA inline PTX | diff --git a/cuda-oxide/crates/cuda-device/src/lib.rs b/cuda-oxide/crates/cuda-device/src/lib.rs index a3171afbcf..a0b85677ce 100644 --- a/cuda-oxide/crates/cuda-device/src/lib.rs +++ b/cuda-oxide/crates/cuda-device/src/lib.rs @@ -12,7 +12,7 @@ extern crate self as cuda_device; pub use cuda_macros::{ cluster_launch, constant, convergent, cooperative_launch, cuda_module, device, gpu_printf, - kernel, launch_bounds, launch_contract, ptx_asm, pure, readonly, + kernel, launch_bounds, launch_contract, ptx_asm, pure, readonly, tile_export, }; // Re-export for convenience diff --git a/cuda-oxide/crates/cuda-macros/Cargo.toml b/cuda-oxide/crates/cuda-macros/Cargo.toml index a4cc3fbf4c..16a25c8459 100644 --- a/cuda-oxide/crates/cuda-macros/Cargo.toml +++ b/cuda-oxide/crates/cuda-macros/Cargo.toml @@ -40,6 +40,9 @@ quote = { workspace = true } syn = { workspace = true } proc-macro2 = { workspace = true } reserved-oxide-symbols = { workspace = true } +# `#[tile_export]` builds its description with the shared vocabulary and embeds +# it as JSON at expansion time; the serialization goes through that crate. +oxide-tile-export = { workspace = true } [dev-dependencies] trybuild = "1" diff --git a/cuda-oxide/crates/cuda-macros/src/common.rs b/cuda-oxide/crates/cuda-macros/src/common.rs index 5634dd9ec2..86602f5a6b 100644 --- a/cuda-oxide/crates/cuda-macros/src/common.rs +++ b/cuda-oxide/crates/cuda-macros/src/common.rs @@ -82,6 +82,12 @@ pub(crate) fn call_site_ident_avoiding_item(name: &str, item: &ItemFn) -> Ident /// Returns `Some(compile_error)` to be returned from the macro entry point, /// or `None` if the name is safe. pub(crate) fn reject_reserved_name(name: &Ident) -> Option { + reserved_name_error(name).map(|err| err.to_compile_error().into()) +} + +/// [`reject_reserved_name`] as a `syn::Error`, for macros that compose their +/// diagnostics before converting to a token stream. +pub(crate) fn reserved_name_error(name: &Ident) -> Option { let name_str = name.to_string(); if name_str.starts_with(RESERVED_ROOT) { let msg = format!( @@ -90,7 +96,7 @@ pub(crate) fn reject_reserved_name(name: &Ident) -> Option { is reserved for cuda-oxide internal symbol mangling \ (see cuda-oxide/crates/reserved-oxide-symbols)" ); - Some(syn::Error::new(name.span(), msg).to_compile_error().into()) + Some(syn::Error::new(name.span(), msg)) } else { None } diff --git a/cuda-oxide/crates/cuda-macros/src/lib.rs b/cuda-oxide/crates/cuda-macros/src/lib.rs index f7f1ac29ae..4c7d086d3b 100644 --- a/cuda-oxide/crates/cuda-macros/src/lib.rs +++ b/cuda-oxide/crates/cuda-macros/src/lib.rs @@ -39,6 +39,7 @@ mod launch; mod launch_attrs; mod printf; mod ptx_asm; +mod tile_export; #[cfg(test)] mod tests; @@ -872,6 +873,110 @@ pub fn device(_attr: TokenStream, item: TokenStream) -> TokenStream { device::device_entry(_attr, item) } +/// Exports a device function to cuTile programs through a tile library. +/// +/// A cuTile kernel calls the function with `foreign_call`, naming the +/// declaration; `cargo oxide tilelib` packages a crate's exports into the +/// `.tilelib` that call resolves against. The attribute leaves the annotated +/// function unchanged, so other device code keeps calling it, and generates +/// two items next to it: +/// +/// 1. `#[device] pub unsafe extern "C" fn (...)`: the implementation +/// the Tile IR call resolves to, on the native SIMT ABI below. It turns the +/// pointer parameters back into the references the function takes, calls +/// the function, and stores the return value through the trailing out +/// pointer. +/// 2. A host-only `#[no_mangle]` metadata function that returns the export's +/// JSON description. The codegen backend reads the string out of its MIR, +/// compiles the wrapper as a device root even when the crate also has +/// kernels, and writes `.tileexports.json` next to the device +/// artifact. The metadata function itself is never compiled for the device. +/// +/// # Arguments +/// +/// | Argument | Meaning | Default | +/// |-----------------------------|-------------------------------------------------|-------------------| +/// | `tile_shape = N` | 1-D tile extent (required) | none | +/// | `name = "..."` | declaration name the cuTile caller uses | the function name | +/// | `symbol = "..."` | implementation symbol in the device artifact | `_impl` | +/// | `sync = "none"` / `"warp"` | threads that must call the function together | `"none"` | +/// | `arch = ["sm_120", ...]` | compute capabilities the implementation supports| every architecture| +/// +/// `tile_shape` is required because this version ships concrete implementations: +/// a parametric one would need one mangled symbol per specialization in the +/// device artifact. `sync = "warp"` needs a tile shape that is a multiple of 32 +/// times the parameter footprint, so every invocation group fills whole +/// warps. `arch` is normally omitted, which matches every target; when given, +/// names are compared after stripping `_` and lowercasing, and a portable name +/// such as `"sm_120"` also matches the arch-conditional `sm_120a` the Tile +/// compiler builds for. +/// +/// # Signature +/// +/// The function cannot be generic or take `self`, and every parameter is a +/// plain identifier with one of these types, where `T` is one of `f16`, +/// `f32`, `f64`, `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`: +/// +/// | Rust parameter | access | footprint | ABI parameter | +/// |------------------|---------|-----------|---------------| +/// | `x: T` | `in` | 1 | `T` by value | +/// | `x: &T` | `in` | 1 | `*const T` | +/// | `x: &[T; N]` | `in` | N | `*const T` | +/// | `x: &mut T` | `inout` | 1 | `*mut T` | +/// | `x: &mut [T; N]` | `inout` | N | `*mut T` | +/// +/// The footprint is the number of contiguous tile elements one invocation +/// owns, and every parameter of one export has the same footprint: the +/// fragmaps of one implementation share their invocation count, so +/// `fn window(acc: &mut [i32; 4], bias: &i32)` is rejected and +/// `bias: &[i32; 4]` is the accepted form. +/// +/// A scalar return type `-> T` becomes an appended `out` parameter named +/// `_out`, passed as `*mut T`. Returning nothing is accepted only when some +/// parameter is `&mut`, because a declaration's results are its `out` and +/// `inout` arguments. Slices, raw pointers, tuples, structs, and `bool` are +/// not accepted. `bf16` is not an accepted element type either: `cuda-device` +/// carries bf16 values as `u16` bit patterns, so pass such tiles as `u16`. +/// +/// Thread identity inside the function is the hardware `threadIdx.x`. The +/// function may not allocate shared memory; a scratch buffer is not part of +/// this version of the description. +/// +/// # Example +/// +/// ```ignore +/// use cuda_device::tile_export; +/// +/// #[tile_export(tile_shape = 128)] +/// pub fn relu(x: f32) -> f32 { +/// if x > 0.0 { x } else { 0.0 } +/// } +/// +/// #[tile_export(tile_shape = 128, name = "scale_in_place", symbol = "scale_in_place_impl")] +/// pub fn scale(x: &mut f32, factor: f32) { +/// *x *= factor; +/// } +/// +/// #[tile_export(tile_shape = 128, sync = "warp", arch = ["sm_120"])] +/// pub fn warp_sum(x: f32) -> f32 { +/// // 32 lanes call this together, so shuffles are legal here. +/// let mut total = x; +/// let mut offset = 16; +/// while offset > 0 { +/// total += cuda_device::warp::shuffle_xor_f32_sync(u32::MAX, total, offset); +/// offset /= 2; +/// } +/// total +/// } +/// ``` +/// +/// `relu` becomes `define void @relu_impl(float, ptr)` and `scale` becomes +/// `define void @scale_in_place_impl(ptr, float)` in the device artifact. +#[proc_macro_attribute] +pub fn tile_export(attr: TokenStream, item: TokenStream) -> TokenStream { + tile_export::tile_export_entry(attr, item) +} + // ============================================================================ // NVVM Attributes for Device FFI // ============================================================================ diff --git a/cuda-oxide/crates/cuda-macros/src/tests/mod.rs b/cuda-oxide/crates/cuda-macros/src/tests/mod.rs index 8e7851e3b5..819c2218f1 100644 --- a/cuda-oxide/crates/cuda-macros/src/tests/mod.rs +++ b/cuda-oxide/crates/cuda-macros/src/tests/mod.rs @@ -6,3 +6,4 @@ mod cuda_module; mod kernel; mod launch; +mod tile_export; diff --git a/cuda-oxide/crates/cuda-macros/src/tests/tile_export.rs b/cuda-oxide/crates/cuda-macros/src/tests/tile_export.rs new file mode 100644 index 0000000000..cbc39bb858 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/src/tests/tile_export.rs @@ -0,0 +1,385 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +use crate::tile_export::{TileExportArgs, expand_tile_export}; +use oxide_tile_export::{TileAccess, TileElem, TileExportDesc, TileSync}; +use proc_macro2::TokenStream as TokenStream2; +use quote::quote; +use reserved_oxide_symbols::tile_export_meta_symbol; +use syn::{ItemFn, parse_quote}; + +fn expand(args: TokenStream2, func: ItemFn) -> syn::Result { + let args: TileExportArgs = syn::parse2(args)?; + expand_tile_export(args, func).map(|tokens| tokens.to_string().replace(' ', "")) +} + +fn expand_err(args: TokenStream2, func: ItemFn) -> String { + match expand(args, func) { + Ok(expanded) => panic!("expected an error, got {expanded}"), + Err(err) => err.to_string(), + } +} + +/// Pull the embedded JSON back out of the expansion through the metadata +/// function's string literal. +fn embedded_desc(expanded: &str, symbol: &str) -> TileExportDesc { + let meta = tile_export_meta_symbol(symbol); + let start = expanded + .find(&format!("fn{meta}()")) + .unwrap_or_else(|| panic!("no metadata function `{meta}` in {expanded}")); + let rest = &expanded[start..]; + let open = rest.find('"').expect("string literal"); + let json: String = syn::parse_str::( + &rest[open..rest[open..].find("\"}").map(|end| open + end + 1).unwrap()], + ) + .expect("the metadata body is a string literal") + .value(); + TileExportDesc::from_json(&json).expect("embedded JSON parses") +} + +#[test] +fn scalar_in_and_returned_out_follow_the_table() { + let func: ItemFn = parse_quote! { + pub fn relu(x: f32) -> f32 { if x > 0.0 { x } else { 0.0 } } + }; + let expanded = expand(quote! { tile_shape = 128 }, func).unwrap(); + + // The original function survives unchanged. + assert!(expanded.contains("pubfnrelu(x:f32)->f32"), "{expanded}"); + // The wrapper is a `#[device]` extern "C" function on the native ABI. + assert!( + expanded.contains("#[::cuda_device::device]pubunsafeextern\"C\"fnrelu_impl("), + "{expanded}" + ); + assert!(expanded.contains(":f32,"), "{expanded}"); + assert!(expanded.contains(":*mutf32)"), "{expanded}"); + assert!(expanded.contains("=relu("), "{expanded}"); + + let desc = embedded_desc(&expanded, "relu_impl"); + desc.validate().unwrap(); + assert_eq!(desc.decl, "relu"); + assert_eq!(desc.symbol, "relu_impl"); + assert_eq!(desc.shape, vec![128]); + assert_eq!(desc.sync, TileSync::None); + assert!(desc.arch.is_empty()); + assert_eq!(desc.params.len(), 2); + assert_eq!(desc.params[0].name, "x"); + assert_eq!(desc.params[0].access, TileAccess::In); + assert!(desc.params[0].by_value); + assert_eq!(desc.params[1].name, "relu_out"); + assert_eq!(desc.params[1].access, TileAccess::Out); + assert_eq!(desc.params[1].elem, TileElem::F32); + assert!(!desc.params[1].by_value); +} + +#[test] +fn name_symbol_sync_and_arch_override_the_defaults() { + let func: ItemFn = parse_quote! { + pub fn scale(x: &mut f32, factor: f32) { *x *= factor; } + }; + let expanded = expand( + quote! { tile_shape = 128, name = "scale_in_place", symbol = "scale_impl_v2", sync = "warp", arch = ["sm_100", "sm_120"] }, + func, + ) + .unwrap(); + assert!( + expanded.contains("pubunsafeextern\"C\"fnscale_impl_v2("), + "{expanded}" + ); + assert!(expanded.contains(":*mutf32,"), "{expanded}"); + assert!(expanded.contains(":f32)"), "{expanded}"); + // `&mut T` is rebuilt from the pointer before the call. + assert!(expanded.contains("&mut*"), "{expanded}"); + + let desc = embedded_desc(&expanded, "scale_impl_v2"); + desc.validate().unwrap(); + assert_eq!(desc.decl, "scale_in_place"); + assert_eq!(desc.symbol, "scale_impl_v2"); + assert_eq!(desc.sync, TileSync::Warp); + assert_eq!(desc.arch, vec!["sm_100".to_string(), "sm_120".to_string()]); + assert_eq!(desc.params[0].access, TileAccess::InOut); + assert!(!desc.params[0].by_value); + assert_eq!(desc.params[1].access, TileAccess::In); + assert!(desc.params[1].by_value); +} + +#[test] +fn symbol_defaults_to_the_declaration_name() { + let func: ItemFn = parse_quote! { + pub fn scale(x: &mut f32) { *x *= 2.0; } + }; + let expanded = expand(quote! { tile_shape = 64, name = "double" }, func).unwrap(); + let desc = embedded_desc(&expanded, "double_impl"); + assert_eq!(desc.decl, "double"); + assert_eq!(desc.symbol, "double_impl"); +} + +#[test] +fn array_parameters_carry_their_footprint() { + let func: ItemFn = parse_quote! { + pub fn window(acc: &mut [i32; 4], bias: &[i32; 4]) { + let _ = (acc, bias); + } + }; + let expanded = expand(quote! { tile_shape = 64 }, func).unwrap(); + assert!(expanded.contains(":*muti32,"), "{expanded}"); + assert!(expanded.contains(":*consti32)"), "{expanded}"); + // Both arrays are rebuilt from their pointers before the call. + assert!(expanded.contains("as*mut[i32;4]"), "{expanded}"); + assert!(expanded.contains("as*const[i32;4]"), "{expanded}"); + + let desc = embedded_desc(&expanded, "window_impl"); + desc.validate().unwrap(); + let shapes: Vec<_> = desc + .params + .iter() + .map(|p| (p.name.as_str(), p.elem, p.access, p.footprint, p.by_value)) + .collect(); + assert_eq!( + shapes, + vec![ + ("acc", TileElem::I32, TileAccess::InOut, 4, false), + ("bias", TileElem::I32, TileAccess::In, 4, false), + ] + ); +} + +#[test] +fn scalar_references_and_halves_carry_footprint_one() { + let func: ItemFn = parse_quote! { + pub fn mix(scale: &'_ u16, half: f16, out: &mut u16) { + let _ = (scale, half, out); + } + }; + let expanded = expand(quote! { tile_shape = 64 }, func).unwrap(); + assert!(expanded.contains(":*constu16,"), "{expanded}"); + assert!(expanded.contains(":f16,"), "{expanded}"); + assert!(expanded.contains(":*mutu16)"), "{expanded}"); + + let desc = embedded_desc(&expanded, "mix_impl"); + desc.validate().unwrap(); + let shapes: Vec<_> = desc + .params + .iter() + .map(|p| (p.name.as_str(), p.elem, p.access, p.footprint, p.by_value)) + .collect(); + assert_eq!( + shapes, + vec![ + ("scale", TileElem::U16, TileAccess::In, 1, false), + ("half", TileElem::F16, TileAccess::In, 1, true), + ("out", TileElem::U16, TileAccess::InOut, 1, false), + ] + ); +} + +#[test] +fn mixed_footprints_are_rejected_at_the_differing_parameter() { + // The window needs 16 invocations of a 64-element tile, the scalar 64: + // one implementation cannot have both. + let func: ItemFn = parse_quote! { + pub fn window(acc: &mut [i32; 4], bias: &i32) { + let _ = (acc, bias); + } + }; + let err = expand_err(quote! { tile_shape = 64 }, func); + assert!( + err.contains("`acc` (footprint 4) and `bias` (footprint 1) differ"), + "{err}" + ); + // A by-value scalar is footprint 1 too, so it cannot sit beside a window. + let func: ItemFn = parse_quote! { + pub fn scale4(x: &mut [f32; 4], factor: f32) { + let _ = (x, factor); + } + }; + let err = expand_err(quote! { tile_shape = 128 }, func); + assert!( + err.contains("`x` (footprint 4) and `factor` (footprint 1) differ"), + "{err}" + ); +} + +#[test] +fn warp_sync_with_a_footprint_needs_whole_warps_of_footprints() { + let func: ItemFn = parse_quote! { + pub fn scale4(x: &mut [f32; 4]) { + let _ = x; + } + }; + // 64 is a multiple of 32, but a warp of 4-element footprints owns 128. + let err = expand_err(quote! { tile_shape = 64, sync = "warp" }, func.clone()); + assert!( + err.contains("footprint 4") && err.contains("multiple of 128") && err.contains("64"), + "{err}" + ); + expand(quote! { tile_shape = 128, sync = "warp" }, func.clone()).unwrap(); + // Without synchronization the footprint only has to divide the shape. + expand(quote! { tile_shape = 64 }, func).unwrap(); +} + +#[test] +fn primitive_module_paths_are_element_types() { + let func: ItemFn = parse_quote! { + pub fn add(a: core::primitive::f64, b: ::std::primitive::f64) -> f64 { a + b } + }; + let desc = embedded_desc( + &expand(quote! { tile_shape = 32 }, func).unwrap(), + "add_impl", + ); + assert!(desc.params.iter().all(|p| p.elem == TileElem::F64)); +} + +#[test] +fn the_out_parameter_avoids_a_user_parameter_of_the_same_name() { + let func: ItemFn = parse_quote! { + pub fn f(f_out: f32) -> f32 { f_out } + }; + let desc = embedded_desc(&expand(quote! { tile_shape = 32 }, func).unwrap(), "f_impl"); + assert_eq!(desc.params[1].name, "f_out_"); + desc.validate().unwrap(); +} + +#[test] +fn generics_self_and_async_are_rejected() { + let generic: ItemFn = parse_quote! { pub fn relu(x: T) -> T { x } }; + assert!(expand_err(quote! { tile_shape = 128 }, generic).contains("cannot be generic")); + + let lifetime: ItemFn = parse_quote! { pub fn relu<'a>(x: &'a f32) -> f32 { *x } }; + assert!(expand_err(quote! { tile_shape = 128 }, lifetime).contains("cannot be generic")); + + let method: ItemFn = parse_quote! { pub fn relu(self, x: f32) -> f32 { x } }; + assert!(expand_err(quote! { tile_shape = 128 }, method).contains("cannot take self")); + + let asynchronous: ItemFn = parse_quote! { pub async fn relu(x: f32) -> f32 { x } }; + assert!(expand_err(quote! { tile_shape = 128 }, asynchronous).contains("cannot be async")); +} + +#[test] +fn shape_is_required_positive_and_literal() { + let func: ItemFn = parse_quote! { pub fn relu(x: f32) -> f32 { x } }; + assert!(expand_err(quote! {}, func.clone()).contains("requires `tile_shape = N`")); + assert!(expand_err(quote! { tile_shape = 0 }, func.clone()).contains("positive integer")); + let err = syn::parse2::(quote! { tile_shape = N }) + .err() + .expect("a non-literal shape is a parse error") + .to_string(); + assert!(err.contains("integer literal"), "{err}"); + let err = syn::parse2::(quote! { tile_shape = 128, tile_shape = 64 }) + .err() + .expect("duplicate keys are rejected") + .to_string(); + assert!(err.contains("duplicate"), "{err}"); +} + +#[test] +fn unknown_and_malformed_arguments_are_rejected() { + let err = syn::parse2::(quote! { tile_shape = 128, foo = 1 }) + .err() + .expect("unknown keys are rejected") + .to_string(); + assert!( + err.contains("unknown #[tile_export] argument `foo`") + && err.contains("shape, name, symbol, sync, arch"), + "{err}" + ); + let err = syn::parse2::(quote! { tile_shape = 128, arch = "sm_120" }) + .err() + .expect("arch must be a list") + .to_string(); + assert!(err.contains("list of string literals"), "{err}"); + let err = syn::parse2::(quote! { tile_shape = 128, name = relu }) + .err() + .expect("name must be a string literal") + .to_string(); + assert!(err.contains("string literal"), "{err}"); + + let func: ItemFn = parse_quote! { pub fn relu(x: f32) -> f32 { x } }; + assert!( + expand_err(quote! { tile_shape = 128, sync = "cta" }, func.clone()) + .contains("must be \"none\" or \"warp\"") + ); + assert!( + expand_err(quote! { tile_shape = 128, symbol = "re-lu" }, func.clone()) + .contains("must be an identifier") + ); + assert!( + expand_err( + quote! { tile_shape = 128, name = "cuda_oxide_relu" }, + func.clone() + ) + .contains("reserved cuda-oxide prefix") + ); + assert!(expand_err(quote! { tile_shape = 128, arch = [""] }, func).contains("non-empty")); +} + +#[test] +fn unsupported_parameter_and_return_types_say_what_is_accepted() { + for func in [ + parse_quote! { pub fn bad(x: &[f32]) -> f32 { x[0] } }, + parse_quote! { pub fn bad(x: *mut f32) -> f32 { 0.0 } }, + parse_quote! { pub fn bad(x: bool) -> f32 { 0.0 } }, + parse_quote! { pub fn bad(x: usize) -> f32 { 0.0 } }, + parse_quote! { pub fn bad(x: &mut [f32]) -> f32 { 0.0 } }, + parse_quote! { pub fn bad(x: &[bool; 4]) -> f32 { 0.0 } }, + parse_quote! { pub fn bad(x: (f32, f32)) -> f32 { x.0 } }, + ] { + let err = expand_err(quote! { tile_shape = 128 }, func); + assert!( + err.contains( + "parameters must be `x: T`, `x: &T`, `x: &mut T`, `x: &[T; N]`, or \ + `x: &mut [T; N]`" + ), + "{err}" + ); + assert!( + err.contains("f16, f32, f64, i8, i16, i32, i64, u8, u16, u32, u64"), + "{err}" + ); + } + + let pattern: ItemFn = parse_quote! { pub fn bad((a, b): (f32, f32)) -> f32 { a } }; + assert!(expand_err(quote! { tile_shape = 128 }, pattern).contains("plain identifiers")); + + let const_len: ItemFn = parse_quote! { pub fn bad(x: &mut [f32; N]) {} }; + assert!(expand_err(quote! { tile_shape = 128 }, const_len).contains("integer literal length")); + + for func in [ + parse_quote! { pub fn bad(x: f32) -> &'static f32 { &0.0 } }, + parse_quote! { pub fn bad(x: f32) -> (f32, f32) { (x, x) } }, + parse_quote! { pub fn bad(x: f32) -> bool { x > 0.0 } }, + ] { + let err = expand_err(quote! { tile_shape = 128 }, func); + assert!(err.contains("must return a scalar"), "{err}"); + } +} + +#[test] +fn an_export_needs_an_output() { + let sink: ItemFn = parse_quote! { pub fn sink(x: f32, y: &f32) { let _ = (x, y); } }; + let err = expand_err(quote! { tile_shape = 128 }, sink); + assert!(err.contains("has no output"), "{err}"); + + // `()` is fine once something is written in place. + let in_place: ItemFn = parse_quote! { pub fn scale(x: &mut f32) -> () { *x *= 2.0; } }; + expand(quote! { tile_shape = 128 }, in_place).unwrap(); +} + +#[test] +fn warp_sync_needs_a_multiple_of_32() { + let func: ItemFn = parse_quote! { pub fn s(x: f32) -> f32 { x } }; + let err = expand_err(quote! { tile_shape = 100, sync = "warp" }, func.clone()); + assert!( + err.contains("multiple of 32") && err.contains("100"), + "{err}" + ); + expand(quote! { tile_shape = 96, sync = "warp" }, func).unwrap(); +} + +#[test] +fn reserved_function_names_are_rejected() { + let func: ItemFn = parse_quote! { pub fn cuda_oxide_relu(x: f32) -> f32 { x } }; + assert!(expand_err(quote! { tile_shape = 128 }, func).contains("reserved cuda-oxide")); +} diff --git a/cuda-oxide/crates/cuda-macros/src/tile_export.rs b/cuda-oxide/crates/cuda-macros/src/tile_export.rs new file mode 100644 index 0000000000..491e7d87b0 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/src/tile_export.rs @@ -0,0 +1,679 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! `#[tile_export]`: export a device function to cuTile through a tile +//! library. +//! +//! The attribute leaves the annotated function alone and adds two items next +//! to it: a `#[device] extern "C"` wrapper on the native SIMT ABI, and a +//! host-only `#[no_mangle]` metadata function whose body is the JSON +//! [`TileExportDesc`] of the export. The ABI rules live in `oxide-tile-export`; +//! this module maps Rust signatures onto them and emits the wrapper body. + +use crate::common::{internal_ident, reserved_name_error, track_codegen_environment}; +use oxide_tile_export::{ + CURRENT_VERSION, TileAccess, TileElem, TileExportDesc, TileExportError, TileParamDesc, + TileSync, is_identifier, +}; +use proc_macro::TokenStream; +use proc_macro2::{Span, TokenStream as TokenStream2}; +use quote::{ToTokens, quote}; +use reserved_oxide_symbols::{RESERVED_ROOT, tile_export_meta_symbol}; +use syn::{ + Expr, ExprArray, ExprLit, FnArg, Ident, ItemFn, Lit, LitInt, LitStr, Pat, ReturnType, + Signature, Token, Type, + parse::{Parse, ParseStream}, + parse_macro_input, +}; + +/// The Rust element types `#[tile_export]` accepts, as the diagnostics list +/// them. +const ELEMENT_TYPES: &str = "f16, f32, f64, i8, i16, i32, i64, u8, u16, u32, u64"; + +/// The attribute's parsed arguments. Every field is optional at parse time; +/// `expand_tile_export` reports the missing `tile_shape`. +#[derive(Default)] +pub(crate) struct TileExportArgs { + pub(crate) tile_shape: Option, + pub(crate) name: Option, + pub(crate) symbol: Option, + pub(crate) sync: Option, + pub(crate) arch: Option>, +} + +fn set_once(slot: &mut Option, key: &Ident, value: T) -> syn::Result<()> { + if slot.is_some() { + return Err(syn::Error::new( + key.span(), + format!("duplicate #[tile_export] argument `{key}`"), + )); + } + *slot = Some(value); + Ok(()) +} + +fn string_argument(key: &Ident, value: Expr) -> syn::Result { + match value { + Expr::Lit(ExprLit { + lit: Lit::Str(lit), .. + }) => Ok(lit), + other => Err(syn::Error::new_spanned( + other, + format!("#[tile_export] `{key}` takes a string literal such as `{key} = \"...\"`"), + )), + } +} + +impl Parse for TileExportArgs { + fn parse(input: ParseStream) -> syn::Result { + let mut args = Self::default(); + while !input.is_empty() { + let key: Ident = input.parse()?; + input.parse::()?; + match key.to_string().as_str() { + "tile_shape" => { + let value: Expr = input.parse()?; + let lit = match value { + Expr::Lit(ExprLit { + lit: Lit::Int(lit), .. + }) => lit, + other => { + return Err(syn::Error::new_spanned( + other, + "#[tile_export] `tile_shape` must be an integer literal such as \ + `tile_shape = 128`; a static tile library cannot ship a \ + parametric implementation, so a constant or expression is \ + not accepted", + )); + } + }; + set_once(&mut args.tile_shape, &key, lit)?; + } + "name" => { + let value = string_argument(&key, input.parse()?)?; + set_once(&mut args.name, &key, value)?; + } + "symbol" => { + let value = string_argument(&key, input.parse()?)?; + set_once(&mut args.symbol, &key, value)?; + } + "sync" => { + let value = string_argument(&key, input.parse()?)?; + set_once(&mut args.sync, &key, value)?; + } + "arch" => { + let array: ExprArray = input.parse().map_err(|err| { + syn::Error::new( + err.span(), + "#[tile_export] `arch` takes a list of string literals such as \ + `arch = [\"sm_100\", \"sm_120\"]`", + ) + })?; + let mut entries = Vec::with_capacity(array.elems.len()); + for elem in array.elems { + match elem { + Expr::Lit(ExprLit { + lit: Lit::Str(lit), .. + }) => entries.push(lit), + other => { + return Err(syn::Error::new_spanned( + other, + "#[tile_export] `arch` entries must be string literals \ + such as \"sm_120\"", + )); + } + } + } + set_once(&mut args.arch, &key, entries)?; + } + other => { + return Err(syn::Error::new( + key.span(), + format!( + "unknown #[tile_export] argument `{other}`; accepted arguments \ + are tile_shape, name, symbol, sync, arch" + ), + )); + } + } + if input.is_empty() { + break; + } + input.parse::()?; + } + Ok(args) + } +} + +pub(crate) fn tile_export_entry(attr: TokenStream, item: TokenStream) -> TokenStream { + track_codegen_environment(); + let args = parse_macro_input!(attr as TileExportArgs); + let input = parse_macro_input!(item as ItemFn); + match expand_tile_export(args, input) { + Ok(tokens) => tokens.into(), + Err(err) => err.to_compile_error().into(), + } +} + +/// How one Rust parameter travels across the native ABI. +enum ParamShape { + /// `x: T`: `in`, by value. + Scalar(TileElem), + /// `x: &T`: `in`, behind `*const T`. + Ref(TileElem), + /// `x: &[T; F]`: `in` with footprint `F`, behind `*const T`. + RefArray(TileElem, u32, LitInt), + /// `x: &mut T`: `inout`, behind `*mut T`. + RefMut(TileElem), + /// `x: &mut [T; F]`: `inout` with footprint `F`, behind `*mut T`. + RefMutArray(TileElem, u32, LitInt), +} + +impl ParamShape { + fn elem(&self) -> TileElem { + match self { + ParamShape::Scalar(elem) + | ParamShape::Ref(elem) + | ParamShape::RefArray(elem, _, _) + | ParamShape::RefMut(elem) + | ParamShape::RefMutArray(elem, _, _) => *elem, + } + } + + fn access(&self) -> TileAccess { + match self { + ParamShape::Scalar(_) | ParamShape::Ref(_) | ParamShape::RefArray(..) => TileAccess::In, + ParamShape::RefMut(_) | ParamShape::RefMutArray(..) => TileAccess::InOut, + } + } + + fn footprint(&self) -> u32 { + match self { + ParamShape::RefArray(_, footprint, _) | ParamShape::RefMutArray(_, footprint, _) => { + *footprint + } + _ => 1, + } + } + + fn by_value(&self) -> bool { + matches!(self, ParamShape::Scalar(_)) + } +} + +/// A type as the user would write it, for diagnostics: token printing puts +/// spaces around `&`, `;`, and `::` that no one types. +fn type_text(ty: &Type) -> String { + ty.to_token_stream() + .to_string() + .replace("& mut ", "&mut ") + .replace("& ", "&") + .replace(" ;", ";") + .replace(" ::", "::") + .replace(":: ", "::") + .replace(" <", "<") + .replace("< ", "<") + .replace(" >", ">") + .replace(" ,", ",") +} + +/// Peel `(T)` and macro-generated groups so a type written through another +/// macro classifies like one written by hand. +fn unwrap_type(mut ty: &Type) -> &Type { + loop { + match ty { + Type::Paren(paren) => ty = &paren.elem, + Type::Group(group) => ty = &group.elem, + _ => return ty, + } + } +} + +/// The element type a scalar type path names, if it is one of the eleven. +/// +/// Accepts the bare name (`f32`) and the primitive module paths +/// (`core::primitive::f32`, `::std::primitive::f32`). Anything with generic +/// arguments or any other path is not an element type. +fn scalar_elem(ty: &Type) -> Option { + let Type::Path(path) = unwrap_type(ty) else { + return None; + }; + if path.qself.is_some() { + return None; + } + let segments = &path.path.segments; + if segments.iter().any(|segment| !segment.arguments.is_none()) { + return None; + } + let last = segments.last()?; + match segments.len() { + 1 => {} + 3 => { + let crate_name = segments[0].ident.to_string(); + if !matches!(crate_name.as_str(), "core" | "std") || segments[1].ident != "primitive" { + return None; + } + } + _ => return None, + } + TileElem::from_rust_name(&last.ident.to_string()) +} + +fn classify_param_type(ty: &Type) -> syn::Result { + let unsupported = || { + syn::Error::new_spanned( + ty, + format!( + "#[tile_export] parameters must be `x: T`, `x: &T`, `x: &mut T`, \ + `x: &[T; N]`, or `x: &mut [T; N]` with T one of {ELEMENT_TYPES} and N an \ + integer literal; found `{}`. Slices, raw pointers, tuples, structs, \ + generics, and other element types are not accepted", + type_text(ty) + ), + ) + }; + if let Some(elem) = scalar_elem(ty) { + return Ok(ParamShape::Scalar(elem)); + } + let Type::Reference(reference) = unwrap_type(ty) else { + return Err(unsupported()); + }; + let mutable = reference.mutability.is_some(); + let pointee = unwrap_type(&reference.elem); + if let Some(elem) = scalar_elem(pointee) { + return Ok(if mutable { + ParamShape::RefMut(elem) + } else { + ParamShape::Ref(elem) + }); + } + let Type::Array(array) = pointee else { + return Err(unsupported()); + }; + let Some(elem) = scalar_elem(&array.elem) else { + return Err(unsupported()); + }; + let Expr::Lit(ExprLit { + lit: Lit::Int(len), .. + }) = &array.len + else { + return Err(syn::Error::new_spanned( + &array.len, + "#[tile_export] array parameters need an integer literal length such as \ + `&[f32; 4]` or `&mut [f32; 4]`; the footprint must be known to the macro, so \ + a constant or expression is not accepted", + )); + }; + let footprint: u32 = len.base10_parse()?; + if footprint == 0 { + return Err(syn::Error::new_spanned( + len, + "#[tile_export] array parameters need at least one element", + )); + } + Ok(if mutable { + ParamShape::RefMutArray(elem, footprint, len.clone()) + } else { + ParamShape::RefArray(elem, footprint, len.clone()) + }) +} + +fn classify_return_type(output: &ReturnType) -> syn::Result> { + let ty = match output { + ReturnType::Default => return Ok(None), + ReturnType::Type(_, ty) => ty, + }; + if let Type::Tuple(tuple) = unwrap_type(ty) + && tuple.elems.is_empty() + { + return Ok(None); + } + scalar_elem(ty).map(Some).ok_or_else(|| { + syn::Error::new_spanned( + ty, + format!( + "#[tile_export] functions must return a scalar (one of {ELEMENT_TYPES}) or \ + nothing; found `{}`. References, pointers, arrays, tuples, and other \ + element types are not accepted as return types", + type_text(ty) + ), + ) + }) +} + +/// Reject a declaration or symbol name that cannot be a Tile IR symbol or +/// that lands in the reserved namespace. +fn check_symbol_literal(lit: &LitStr, what: &str) -> syn::Result { + let value = lit.value(); + if !is_identifier(&value) { + return Err(syn::Error::new_spanned( + lit, + format!( + "#[tile_export] {what} `{value}` must be an identifier (ASCII letters, digits \ + and `_`, not starting with a digit)" + ), + )); + } + if value.starts_with(RESERVED_ROOT) { + return Err(syn::Error::new_spanned( + lit, + format!( + "#[tile_export] {what} `{value}` starts with the reserved cuda-oxide prefix \ + `{RESERVED_ROOT}`; choose another name" + ), + )); + } + Ok(value) +} + +/// A shared-rule violation as a diagnostic, pointed at the part of the +/// signature that breaks the rule: the parameter whose footprint differs, the +/// shape a warp export cannot split, or the function name for the rest. +fn validation_error( + err: TileExportError, + sig: &Signature, + shape_lit: &LitInt, + fn_ident: &Ident, +) -> syn::Error { + let message = format!("#[tile_export]: {err}"); + match &err { + TileExportError::MixedFootprints { other, .. } => { + let offending = sig.inputs.iter().find_map(|arg| match arg { + FnArg::Typed(pat_type) => match &*pat_type.pat { + Pat::Ident(pat_ident) if pat_ident.ident == other => Some(&pat_type.ty), + _ => None, + }, + FnArg::Receiver(_) => None, + }); + match offending { + Some(ty) => syn::Error::new_spanned(ty, message), + None => syn::Error::new(fn_ident.span(), message), + } + } + TileExportError::WarpFootprintShape { .. } | TileExportError::WarpShape { .. } => { + syn::Error::new_spanned(shape_lit, message) + } + _ => syn::Error::new(fn_ident.span(), message), + } +} + +/// Expand `#[tile_export(args)] fn ...` into the original function, the +/// `#[device] extern "C"` wrapper, and the metadata function. +pub(crate) fn expand_tile_export(args: TileExportArgs, input: ItemFn) -> syn::Result { + let sig = &input.sig; + let fn_ident = sig.ident.clone(); + if let Some(err) = reserved_name_error(&fn_ident) { + return Err(err); + } + if !sig.generics.params.is_empty() || sig.generics.where_clause.is_some() { + return Err(syn::Error::new_spanned( + &sig.generics, + "#[tile_export] functions cannot be generic: lifetime, type, and const \ + parameters are not accepted because a static tile library needs one concrete \ + symbol per export", + )); + } + if let Some(asyncness) = &sig.asyncness { + return Err(syn::Error::new_spanned( + asyncness, + "#[tile_export] functions cannot be async; only plain `fn` items run on the device", + )); + } + if let Some(variadic) = &sig.variadic { + return Err(syn::Error::new_spanned( + variadic, + "#[tile_export] functions cannot be variadic", + )); + } + + let Some(shape_lit) = args.tile_shape else { + return Err(syn::Error::new( + fn_ident.span(), + "#[tile_export] requires `tile_shape = N`, the 1-D tile extent; a static tile library \ + cannot ship a parametric implementation, so every export names one extent", + )); + }; + let shape: i64 = shape_lit.base10_parse()?; + if shape <= 0 { + return Err(syn::Error::new_spanned( + &shape_lit, + format!("#[tile_export] `tile_shape` must be a positive integer, found {shape}"), + )); + } + let sync = match &args.sync { + None => TileSync::None, + Some(lit) => match lit.value().as_str() { + "none" => TileSync::None, + "warp" => TileSync::Warp, + other => { + return Err(syn::Error::new_spanned( + lit, + format!( + "#[tile_export] `sync` must be \"none\" or \"warp\", found \"{other}\"" + ), + )); + } + }, + }; + // The footprint-1 form of the warp rule, reported before the parameters + // are read so the message points at the shape. The footprint-aware form + // comes from `validate` once the parameters are known. + if sync == TileSync::Warp && shape % 32 != 0 { + return Err(syn::Error::new_spanned( + &shape_lit, + format!( + "#[tile_export] sync = \"warp\" needs a tile_shape that is a multiple of 32 so \ + every invocation group fills whole warps, found {shape}" + ), + )); + } + let decl = match &args.name { + Some(lit) => check_symbol_literal(lit, "name")?, + None => fn_ident.to_string(), + }; + let symbol = match &args.symbol { + Some(lit) => check_symbol_literal(lit, "symbol")?, + None => format!("{decl}_impl"), + }; + let arch: Vec = args + .arch + .iter() + .flatten() + .map(|lit| { + let value = lit.value(); + if value.trim().is_empty() { + Err(syn::Error::new_spanned( + lit, + "#[tile_export] `arch` entries must be non-empty names such as \"sm_120\"", + )) + } else { + Ok(value) + } + }) + .collect::>()?; + + // Parameters: plain identifiers with one of the four accepted types. + let mut shapes = Vec::with_capacity(sig.inputs.len()); + let mut params = Vec::with_capacity(sig.inputs.len() + 1); + let mut types = Vec::with_capacity(sig.inputs.len()); + for arg in &sig.inputs { + let FnArg::Typed(pat_type) = arg else { + return Err(syn::Error::new_spanned( + arg, + "#[tile_export] functions cannot take self; export a free function", + )); + }; + if let Some(attr) = pat_type.attrs.first() { + return Err(syn::Error::new_spanned( + attr, + "#[tile_export] parameters cannot carry attributes", + )); + } + let Pat::Ident(pat_ident) = &*pat_type.pat else { + return Err(syn::Error::new_spanned( + &pat_type.pat, + "#[tile_export] parameters must be plain identifiers such as `x: f32`; \ + patterns are not accepted because each parameter names one Tile IR argument", + )); + }; + if pat_ident.subpat.is_some() || pat_ident.by_ref.is_some() { + return Err(syn::Error::new_spanned( + pat_ident, + "#[tile_export] parameters must be plain identifiers such as `x: f32`; \ + `ref` bindings and subpatterns are not accepted", + )); + } + let name = pat_ident.ident.to_string(); + if !is_identifier(&name) { + return Err(syn::Error::new_spanned( + &pat_ident.ident, + format!( + "#[tile_export] parameter `{name}` must be an ASCII identifier without \ + the `r#` prefix; it names a Tile IR argument" + ), + )); + } + let shape = classify_param_type(&pat_type.ty)?; + params.push(TileParamDesc { + name, + elem: shape.elem(), + access: shape.access(), + footprint: shape.footprint(), + by_value: shape.by_value(), + }); + types.push((*pat_type.ty).clone()); + shapes.push(shape); + } + + let return_elem = classify_return_type(&sig.output)?; + if return_elem.is_none() && !params.iter().any(|param| param.access.is_output()) { + return Err(syn::Error::new_spanned( + sig, + "#[tile_export] function has no output: return a scalar value or take at least \ + one `&mut T` or `&mut [T; N]` parameter, because a tile library declaration's \ + results are its `out` and `inout` arguments", + )); + } + if let Some(elem) = return_elem { + // The declaration argument that carries the return value. Keep the + // conventional `_out` unless a parameter already took it. + let mut out_name = format!("{fn_ident}_out"); + while params.iter().any(|param| param.name == out_name) { + out_name.push('_'); + } + params.push(TileParamDesc { + name: out_name, + elem, + access: TileAccess::Out, + footprint: 1, + by_value: false, + }); + } + + let desc = TileExportDesc { + version: CURRENT_VERSION, + decl, + symbol, + shape: vec![shape], + params, + sync, + arch, + }; + desc.validate() + .map_err(|err| validation_error(err, sig, &shape_lit, &fn_ident))?; + + // The wrapper: pointer parameters are turned back into the references + // the original function takes, the return value is stored through the + // trailing out pointer. + let mut abi_inputs = Vec::with_capacity(shapes.len() + 1); + let mut call_args = Vec::with_capacity(shapes.len()); + for (index, (shape, ty)) in shapes.iter().zip(&types).enumerate() { + let ident = internal_ident(&format!("__cuda_oxide_tile_arg_{index}")); + match shape { + ParamShape::Scalar(_) => { + abi_inputs.push(quote! { #ident: #ty }); + call_args.push(quote! { #ident }); + } + ParamShape::Ref(_) => { + let Type::Reference(reference) = unwrap_type(ty) else { + unreachable!("classified as a reference"); + }; + let pointee = &reference.elem; + abi_inputs.push(quote! { #ident: *const #pointee }); + call_args.push(quote! { unsafe { &*#ident } }); + } + ParamShape::RefMut(_) => { + let Type::Reference(reference) = unwrap_type(ty) else { + unreachable!("classified as a reference"); + }; + let pointee = &reference.elem; + abi_inputs.push(quote! { #ident: *mut #pointee }); + call_args.push(quote! { unsafe { &mut *#ident } }); + } + ParamShape::RefArray(_, _, len) => { + let Type::Reference(reference) = unwrap_type(ty) else { + unreachable!("classified as a reference"); + }; + let Type::Array(array) = unwrap_type(&reference.elem) else { + unreachable!("classified as an array reference"); + }; + let elem_ty = &array.elem; + abi_inputs.push(quote! { #ident: *const #elem_ty }); + call_args.push(quote! { unsafe { &*(#ident as *const [#elem_ty; #len]) } }); + } + ParamShape::RefMutArray(_, _, len) => { + let Type::Reference(reference) = unwrap_type(ty) else { + unreachable!("classified as a reference"); + }; + let Type::Array(array) = unwrap_type(&reference.elem) else { + unreachable!("classified as an array reference"); + }; + let elem_ty = &array.elem; + abi_inputs.push(quote! { #ident: *mut #elem_ty }); + call_args.push(quote! { unsafe { &mut *(#ident as *mut [#elem_ty; #len]) } }); + } + } + } + let call = quote! { #fn_ident(#(#call_args),*) }; + let body = match &sig.output { + ReturnType::Type(_, ret_ty) if return_elem.is_some() => { + let out_ident = internal_ident("__cuda_oxide_tile_out"); + let result_ident = internal_ident("__cuda_oxide_tile_result"); + abi_inputs.push(quote! { #out_ident: *mut #ret_ty }); + quote! { + let #result_ident: #ret_ty = #call; + unsafe { *#out_ident = #result_ident; } + } + } + _ => quote! { #call; }, + }; + + let wrapper_ident = Ident::new(&desc.symbol, fn_ident.span()); + let meta_ident = Ident::new(&tile_export_meta_symbol(&desc.symbol), fn_ident.span()); + let json = LitStr::new(&desc.to_json(), Span::call_site()); + let wrapper_doc = format!( + "Tile library implementation of `{}`, on the native SIMT ABI.", + desc.decl + ); + + Ok(quote! { + #input + + #[doc = #wrapper_doc] + #[doc(hidden)] + #[allow(non_snake_case, clippy::missing_safety_doc, improper_ctypes_definitions)] + #[::cuda_device::device] + pub unsafe extern "C" fn #wrapper_ident(#(#abi_inputs),*) { + #body + } + + #[doc(hidden)] + #[allow(non_snake_case)] + #[unsafe(no_mangle)] + pub fn #meta_ident() -> &'static str { + #json + } + }) +} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.rs new file mode 100644 index 0000000000..aa9f403c35 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 128)] +pub fn relu(x: T) -> T { + x +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.stderr new file mode 100644 index 0000000000..2b3433b290 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_generic.stderr @@ -0,0 +1,5 @@ +error: #[tile_export] functions cannot be generic: lifetime, type, and const parameters are not accepted because a static tile library needs one concrete symbol per export + --> tests/compile_fail/tile_export_generic.rs:7:12 + | +7 | pub fn relu(x: T) -> T { + | ^^^^^^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.rs new file mode 100644 index 0000000000..d92422c42a --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export] +pub fn relu(x: f32) -> f32 { + x +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.stderr new file mode 100644 index 0000000000..c6bda38223 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_missing_shape.stderr @@ -0,0 +1,5 @@ +error: #[tile_export] requires `tile_shape = N`, the 1-D tile extent; a static tile library cannot ship a parametric implementation, so every export names one extent + --> tests/compile_fail/tile_export_missing_shape.rs:7:8 + | +7 | pub fn relu(x: f32) -> f32 { + | ^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.rs new file mode 100644 index 0000000000..9bb6edc906 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.rs @@ -0,0 +1,13 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 64)] +pub fn window(acc: &mut [i32; 4], bias: &i32) { + for value in acc.iter_mut() { + *value += *bias; + } +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.stderr new file mode 100644 index 0000000000..323f78f903 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_mixed_footprints.stderr @@ -0,0 +1,5 @@ +error: #[tile_export]: parameters `acc` (footprint 4) and `bias` (footprint 1) differ; every parameter of one export shares the invocation count, so all footprints must be equal + --> tests/compile_fail/tile_export_mixed_footprints.rs:7:41 + | +7 | pub fn window(acc: &mut [i32; 4], bias: &i32) { + | ^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.rs new file mode 100644 index 0000000000..a654191668 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 128)] +pub fn sink(x: f32, y: &f32) { + let _ = (x, y); +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.stderr new file mode 100644 index 0000000000..c58c08c60d --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_no_outputs.stderr @@ -0,0 +1,5 @@ +error: #[tile_export] function has no output: return a scalar value or take at least one `&mut T` or `&mut [T; N]` parameter, because a tile library declaration's results are its `out` and `inout` arguments + --> tests/compile_fail/tile_export_no_outputs.rs:7:5 + | +7 | pub fn sink(x: f32, y: &f32) { + | ^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.rs new file mode 100644 index 0000000000..e7220abc4b --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.rs @@ -0,0 +1,13 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +// [inout, in, out]: the appended return slot is separated from `a` by `b`. +#[tile_export(tile_shape = 128)] +pub fn split(a: &mut f32, b: f32) -> f32 { + *a *= b; + *a +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.stderr new file mode 100644 index 0000000000..a23ce382d6 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_outputs_split.stderr @@ -0,0 +1,5 @@ +error: #[tile_export]: `out` and `inout` parameters must be one contiguous run, but `b` is `in` and sits between `a` and `split_out`; move `in` parameters before the `&mut` ones + --> tests/compile_fail/tile_export_outputs_split.rs:8:8 + | +8 | pub fn split(a: &mut f32, b: f32) -> f32 { + | ^^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.rs new file mode 100644 index 0000000000..4db9fd79ef --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 128, shap = 64)] +pub fn relu(x: f32) -> f32 { + x +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.stderr new file mode 100644 index 0000000000..cac0df871b --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unknown_argument.stderr @@ -0,0 +1,5 @@ +error: unknown #[tile_export] argument `shap`; accepted arguments are tile_shape, name, symbol, sync, arch + --> tests/compile_fail/tile_export_unknown_argument.rs:6:33 + | +6 | #[tile_export(tile_shape = 128, shap = 64)] + | ^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.rs new file mode 100644 index 0000000000..9c7dd58627 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 128)] +pub fn first(x: &[f32]) -> f32 { + x[0] +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.stderr new file mode 100644 index 0000000000..bd7f56cfa5 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_unsupported_param.stderr @@ -0,0 +1,5 @@ +error: #[tile_export] parameters must be `x: T`, `x: &T`, `x: &mut T`, `x: &[T; N]`, or `x: &mut [T; N]` with T one of f16, f32, f64, i8, i16, i32, i64, u8, u16, u32, u64 and N an integer literal; found `&[f32]`. Slices, raw pointers, tuples, structs, generics, and other element types are not accepted + --> tests/compile_fail/tile_export_unsupported_param.rs:7:17 + | +7 | pub fn first(x: &[f32]) -> f32 { + | ^^^^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.rs new file mode 100644 index 0000000000..f52d1b2137 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.rs @@ -0,0 +1,13 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 64, sync = "warp")] +pub fn scale4(x: &mut [f32; 4]) { + for value in x.iter_mut() { + *value *= 2.0; + } +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.stderr new file mode 100644 index 0000000000..89fa47f5b3 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_footprint.stderr @@ -0,0 +1,5 @@ +error: #[tile_export]: sync = warp with footprint 4 needs a shape that is a multiple of 128 (32 lanes times the footprint), found 64 + --> tests/compile_fail/tile_export_warp_footprint.rs:6:28 + | +6 | #[tile_export(tile_shape = 64, sync = "warp")] + | ^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.rs b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.rs new file mode 100644 index 0000000000..cf98bcafec --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.rs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +use cuda_macros::tile_export; + +#[tile_export(tile_shape = 100, sync = "warp")] +pub fn partial_warp(x: f32) -> f32 { + x +} + +fn main() {} diff --git a/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.stderr b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.stderr new file mode 100644 index 0000000000..0987548c1e --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/compile_fail/tile_export_warp_shape.stderr @@ -0,0 +1,5 @@ +error: #[tile_export] sync = "warp" needs a tile_shape that is a multiple of 32 so every invocation group fills whole warps, found 100 + --> tests/compile_fail/tile_export_warp_shape.rs:6:28 + | +6 | #[tile_export(tile_shape = 100, sync = "warp")] + | ^^^ diff --git a/cuda-oxide/crates/cuda-macros/tests/device-only/Cargo.lock b/cuda-oxide/crates/cuda-macros/tests/device-only/Cargo.lock index f7fdc1eff6..4a78f429b9 100644 --- a/cuda-oxide/crates/cuda-macros/tests/device-only/Cargo.lock +++ b/cuda-oxide/crates/cuda-macros/tests/device-only/Cargo.lock @@ -13,10 +13,11 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", - "syn", + "syn 2.0.119", ] [[package]] @@ -27,6 +28,27 @@ dependencies = [ "cuda-macros", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "proc-macro2" version = "1.0.107" @@ -49,6 +71,49 @@ dependencies = [ name = "reserved-oxide-symbols" version = "0.2.1" +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "syn" version = "2.0.119" @@ -60,8 +125,45 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78c8dee4c7bf0e14673097256fed6142ce9d3b85a408189d07482442145823b" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.9", +] + [[package]] name = "unicode-ident" version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/cuda-macros/tests/pass/tile_export_forms.rs b/cuda-oxide/crates/cuda-macros/tests/pass/tile_export_forms.rs new file mode 100644 index 0000000000..38a53fc6db --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/pass/tile_export_forms.rs @@ -0,0 +1,70 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! Every parameter and return form `#[tile_export]` accepts, expanded +//! against the real `cuda_device::device` so the generated wrapper +//! type-checks. + +#![allow(dead_code)] +#![feature(f16)] + +use cuda_device::tile_export; + +#[tile_export(tile_shape = 128)] +pub fn relu(x: f32) -> f32 { + if x > 0.0 { x } else { 0.0 } +} + +#[tile_export(tile_shape = 128, name = "scale_in_place", symbol = "scale_in_place_impl")] +pub fn scale(x: &mut f32, factor: f32) { + *x *= factor; +} + +#[tile_export(tile_shape = 256, sync = "warp", arch = ["sm_100", "sm_120"])] +pub fn warp_sum(x: f32) -> f32 { + x +} + +// Every parameter of one export shares its footprint, so the bias is a +// 4-element window too. +#[tile_export(tile_shape = 64)] +pub fn window(acc: &mut [i32; 4], bias: &[i32; 4]) { + for (value, bias) in acc.iter_mut().zip(bias) { + *value += *bias; + } +} + +// A warp of 4-element footprints owns 128 elements; 256 holds two. +#[tile_export(tile_shape = 256, sync = "warp")] +pub fn warp_scale4(x: &mut [f32; 4], factor: &[f32; 4]) { + for (value, factor) in x.iter_mut().zip(factor) { + *value *= *factor; + } +} + +#[tile_export(tile_shape = 32)] +pub fn half_add(a: f16, b: f16) -> f16 { + a + b +} + +#[tile_export(tile_shape = 32)] +pub fn widen(x: u8, y: i64) -> u64 { + (x as u64).wrapping_add(y as u64) +} + +mod nested { + use cuda_device::tile_export; + + #[tile_export(tile_shape = 128, name = "nested_negate")] + pub fn negate(x: &mut f64) { + *x = -*x; + } +} + +fn main() { + // The original functions stay ordinary Rust functions. + assert_eq!(relu(-1.0), 0.0); + let mut value = 2.0; + scale(&mut value, 3.0); + assert_eq!(value, 6.0); +} diff --git a/cuda-oxide/crates/cuda-macros/tests/tile_export_guard.rs b/cuda-oxide/crates/cuda-macros/tests/tile_export_guard.rs new file mode 100644 index 0000000000..c220ffd819 --- /dev/null +++ b/cuda-oxide/crates/cuda-macros/tests/tile_export_guard.rs @@ -0,0 +1,21 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +//! `#[tile_export]` signature and argument contracts: every accepted form +//! expands against the real `cuda_device::device`, and each rejected form +//! fails with a macro diagnostic that says what is accepted instead. + +#[test] +fn tile_export_contracts() { + let t = trybuild::TestCases::new(); + t.pass("tests/pass/tile_export_forms.rs"); + t.compile_fail("tests/compile_fail/tile_export_generic.rs"); + t.compile_fail("tests/compile_fail/tile_export_missing_shape.rs"); + t.compile_fail("tests/compile_fail/tile_export_unsupported_param.rs"); + t.compile_fail("tests/compile_fail/tile_export_no_outputs.rs"); + t.compile_fail("tests/compile_fail/tile_export_warp_shape.rs"); + t.compile_fail("tests/compile_fail/tile_export_warp_footprint.rs"); + t.compile_fail("tests/compile_fail/tile_export_mixed_footprints.rs"); + t.compile_fail("tests/compile_fail/tile_export_unknown_argument.rs"); + t.compile_fail("tests/compile_fail/tile_export_outputs_split.rs"); +} diff --git a/cuda-oxide/crates/oxide-tile-export/Cargo.toml b/cuda-oxide/crates/oxide-tile-export/Cargo.toml new file mode 100644 index 0000000000..35058dd5bd --- /dev/null +++ b/cuda-oxide/crates/oxide-tile-export/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "oxide-tile-export" +version = "0.2.1" +edition.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true +description = "Descriptions of Rust device functions exported to cuTile tile libraries" +readme = "README.md" + +[dependencies] +serde = { workspace = true } +serde_json = { workspace = true } +thiserror = { workspace = true } + +[lints.rust] +missing_docs = { level = "deny" } diff --git a/cuda-oxide/crates/oxide-tile-export/README.md b/cuda-oxide/crates/oxide-tile-export/README.md new file mode 100644 index 0000000000..b94760e86d --- /dev/null +++ b/cuda-oxide/crates/oxide-tile-export/README.md @@ -0,0 +1,21 @@ +# oxide-tile-export + +`oxide-tile-export` defines the description of a Rust device function that a +cuTile program calls through a tile library. + +Three parts of cuda-oxide exchange these descriptions: + +- `#[tile_export]` in `cuda-macros` builds one `TileExportDesc` per exported + function at macro-expansion time and embeds its JSON in a host-only + metadata function. +- The `rustc-codegen-cuda` backend reads the JSON back out of that + function's MIR, validates it, compiles the exported wrapper as a device + root, and writes every description of a crate to + `.tileexports.json` next to the device artifact. +- `cargo oxide` turns that file into the Tile IR interface and implementation + modules of a tile library. + +The crate owns the vocabulary (element types, access modes, synchronization +levels), the validation rules, and the mapping from a description to the +native SIMT ABI that the exported function must have. It performs no file IO +and knows nothing about rustc or MIR. diff --git a/cuda-oxide/crates/oxide-tile-export/src/lib.rs b/cuda-oxide/crates/oxide-tile-export/src/lib.rs new file mode 100644 index 0000000000..dea32f95c1 --- /dev/null +++ b/cuda-oxide/crates/oxide-tile-export/src/lib.rs @@ -0,0 +1,1068 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! Descriptions of Rust device functions exported to cuTile tile libraries. +//! +//! `#[tile_export]` (in `cuda-macros`) serializes one [`TileExportDesc`] per +//! exported function at macro-expansion time and embeds it as the body of a +//! host-only metadata function. The codegen backend reads that JSON back out +//! of MIR, validates it, and writes every description of a crate to +//! `.tileexports.json` next to the device artifact. `cargo oxide` +//! turns the file into the Tile IR interface and implementation modules a +//! tile library needs. All three sides share this crate so the vocabulary and +//! the rules are defined once. +//! +//! # The native SIMT ABI +//! +//! A tile library implementation is a plain `void` function. Each declaration +//! argument becomes one parameter, in order, and the result of an exported +//! Rust function becomes a trailing `out` parameter (destination-passing +//! style). The implementation symbol is what the Tile IR call resolves to, so +//! the Rust wrapper must have this signature and no other: +//! +//! | Rust parameter | access | footprint | ABI parameter | +//! |-----------------------|---------|-----------|--------------------------| +//! | `x: T` | `in` | 1 | `T` by value | +//! | `x: &T` | `in` | 1 | `*const T` | +//! | `x: &[T; F]` | `in` | F | `*const T` | +//! | `x: &mut T` | `inout` | 1 | `*mut T` | +//! | `x: &mut [T; F]` | `inout` | F | `*mut T` | +//! | `-> T` (return value) | `out` | 1 | `*mut T`, appended last | +//! +//! Only `x: T` travels by value; every other parameter is a pointer to the +//! invocation's elements, and the function returns nothing. +//! [`TileExportDesc::abi_params`] applies these rules and nothing else. +//! +//! Every parameter of one export has the same footprint: the fragmaps of one +//! implementation share their invocation count, so a 4-element window beside +//! a scalar would need 32 invocations for one argument and 128 for the other. +//! With `sync = warp` the shape must be a multiple of `32 * footprint`, so +//! every invocation group fills whole warps. +//! +//! Thread identity inside the function is the hardware `threadIdx.x`. The +//! callee may not allocate shared memory; version 1 of the description has no +//! scratch buffer. + +#![forbid(unsafe_code)] + +use serde::{Deserialize, Serialize}; + +/// The description format version this crate reads and writes. +/// +/// Version 1 describes one-dimensional tiles, by-value or pointer parameters +/// with a per-invocation footprint, and the `none` and `warp` synchronization +/// levels. [`TileExportDesc::validate`] rejects any other version. +pub const CURRENT_VERSION: u32 = 1; + +/// File suffix of the per-crate description file the backend writes next to +/// the device artifact: `.tileexports.json` holds a JSON array of +/// [`TileExportDesc`]. +pub const DESCRIPTIONS_SUFFIX: &str = "tileexports.json"; + +/// Element type of a tile, named by its Rust type. +/// +/// Tile IR has no unsigned integer types, so the unsigned variants map to the +/// signless `i`-types of the same width in [`TileElem::tile_ir_name`] and to +/// the same LLVM integer types in [`TileElem::llvm_name`]. The Rust name is +/// kept in the description so the wrapper signature and the host-side +/// element interpretation stay recoverable. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum TileElem { + /// IEEE half precision, Rust `f16`, LLVM `half`. + F16, + /// Brain floating point. `cuda-device` carries bf16 values as `u16` bit + /// patterns, so a by-value bf16 is LLVM `i16` in the native ABI (see + /// [`TileElem::llvm_name`]). `#[tile_export]` does not accept `bf16` as + /// an element type; the variant is part of the vocabulary for + /// descriptions written by other tools. + BF16, + /// Rust `f32`, LLVM `float`. + F32, + /// Rust `f64`, LLVM `double`. + F64, + /// Rust `i8`. + I8, + /// Rust `i16`. + I16, + /// Rust `i32`. + I32, + /// Rust `i64`. + I64, + /// Rust `u8`; signless `i8` in Tile IR and LLVM. + U8, + /// Rust `u16`; signless `i16` in Tile IR and LLVM. + U16, + /// Rust `u32`; signless `i32` in Tile IR and LLVM. + U32, + /// Rust `u64`; signless `i64` in Tile IR and LLVM. + U64, +} + +impl TileElem { + /// Every element type, in declaration order. + pub const ALL: [TileElem; 12] = [ + TileElem::F16, + TileElem::BF16, + TileElem::F32, + TileElem::F64, + TileElem::I8, + TileElem::I16, + TileElem::I32, + TileElem::I64, + TileElem::U8, + TileElem::U16, + TileElem::U32, + TileElem::U64, + ]; + + /// The element type whose Rust name is `name`, if any. + /// + /// ``` + /// use oxide_tile_export::TileElem; + /// assert_eq!(TileElem::from_rust_name("f32"), Some(TileElem::F32)); + /// assert_eq!(TileElem::from_rust_name("usize"), None); + /// ``` + pub fn from_rust_name(name: &str) -> Option { + Self::ALL.into_iter().find(|elem| elem.rust_name() == name) + } + + /// The Rust name of the element type (`"f16"`, `"u32"`, ...). + pub fn rust_name(self) -> &'static str { + match self { + TileElem::F16 => "f16", + TileElem::BF16 => "bf16", + TileElem::F32 => "f32", + TileElem::F64 => "f64", + TileElem::I8 => "i8", + TileElem::I16 => "i16", + TileElem::I32 => "i32", + TileElem::I64 => "i64", + TileElem::U8 => "u8", + TileElem::U16 => "u16", + TileElem::U32 => "u32", + TileElem::U64 => "u64", + } + } + + /// The Tile IR name: floats keep their name, integers are signless. + pub fn tile_ir_name(self) -> &'static str { + match self { + TileElem::F16 => "f16", + TileElem::BF16 => "bf16", + TileElem::F32 => "f32", + TileElem::F64 => "f64", + TileElem::I8 | TileElem::U8 => "i8", + TileElem::I16 | TileElem::U16 => "i16", + TileElem::I32 | TileElem::U32 => "i32", + TileElem::I64 | TileElem::U64 => "i64", + } + } + + /// The LLVM IR type the element has in the native ABI. + /// + /// `bf16` is `i16`, not `bfloat`: `cuda-device` has no bf16 scalar type + /// and carries bf16 values as `u16` bit patterns, so that is what the + /// wrapper's parameter lowers to. The Tile IR element stays `bf16`, and + /// `cargo oxide tilelib` records the difference as the implementation's + /// `frontendABI` entry `{bf16 = i16}`. + pub fn llvm_name(self) -> &'static str { + match self { + TileElem::F16 => "half", + TileElem::BF16 => "i16", + TileElem::F32 => "float", + TileElem::F64 => "double", + TileElem::I8 | TileElem::U8 => "i8", + TileElem::I16 | TileElem::U16 => "i16", + TileElem::I32 | TileElem::U32 => "i32", + TileElem::I64 | TileElem::U64 => "i64", + } + } + + /// Width of one element in bits. + pub fn bit_width(self) -> u32 { + match self { + TileElem::I8 | TileElem::U8 => 8, + TileElem::F16 | TileElem::BF16 | TileElem::I16 | TileElem::U16 => 16, + TileElem::F32 | TileElem::I32 | TileElem::U32 => 32, + TileElem::F64 | TileElem::I64 | TileElem::U64 => 64, + } + } + + /// True for the floating-point element types. + pub fn is_float(self) -> bool { + matches!( + self, + TileElem::F16 | TileElem::BF16 | TileElem::F32 | TileElem::F64 + ) + } +} + +/// How the implementation touches one declaration argument. +/// +/// The declaration's results are the tile types of its `out` and `inout` +/// arguments, in order, so every export needs at least one of those. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum TileAccess { + /// Read only. + In, + /// Written, never read; the return value of a Rust function. + Out, + /// Read and written in place. + InOut, +} + +impl TileAccess { + /// The Tile IR name of the access mode (`in`, `out`, `inout`). + pub fn tile_ir_name(self) -> &'static str { + match self { + TileAccess::In => "in", + TileAccess::Out => "out", + TileAccess::InOut => "inout", + } + } + + /// True when the parameter is a result of the declaration. + pub fn is_output(self) -> bool { + matches!(self, TileAccess::Out | TileAccess::InOut) + } +} + +/// How many threads must call the implementation together. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum TileSync { + /// Every invocation is independent. + #[default] + None, + /// Whole warps participate; the shape must be a multiple of 32 times the + /// footprint. + Warp, +} + +impl TileSync { + /// The Tile IR name of the synchronization level. + pub fn tile_ir_name(self) -> &'static str { + match self { + TileSync::None => "none", + TileSync::Warp => "warp", + } + } +} + +/// One parameter of an exported function. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct TileParamDesc { + /// Parameter name; the Rust parameter name, or `_out` for the return + /// value. + pub name: String, + /// Element type of the tile this parameter is a fragment of. + pub elem: TileElem, + /// Read, write, or both. + pub access: TileAccess, + /// Number of contiguous elements one invocation owns; at least 1, and the + /// same for every parameter of the export. + pub footprint: u32, + /// True when the element travels by value instead of behind a pointer. + /// Only legal for `in` parameters with footprint 1. + pub by_value: bool, +} + +/// A `#[tile_export]` function as the tile library sees it. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct TileExportDesc { + /// Format version; see [`CURRENT_VERSION`]. + pub version: u32, + /// Declaration name: what the cuTile caller names in `foreign_call`. + pub decl: String, + /// Implementation symbol: the `extern "C"` device function the call + /// resolves to. + pub symbol: String, + /// Static tile extents; one positive entry in version 1. + pub shape: Vec, + /// Declaration arguments, in ABI order. + pub params: Vec, + /// Synchronization the implementation requires. + #[serde(default)] + pub sync: TileSync, + /// Compute capabilities the implementation supports (`sm_120`, ...). + /// Empty means every architecture. + #[serde(default)] + pub arch: Vec, +} + +/// What a description can get wrong. +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum TileExportError { + /// The description was written by a newer or older format. + #[error( + "tile export description version {found} is not supported; this build reads version {CURRENT_VERSION}" + )] + UnsupportedVersion { + /// The version found in the description. + found: u32, + }, + /// A name that must be an identifier is not one. + #[error( + "{field} `{value}` is not a valid identifier (ASCII letters, digits and `_`, not starting with a digit)" + )] + InvalidIdentifier { + /// Which name: `decl`, `symbol`, or `parameter name`. + field: &'static str, + /// The offending text. + value: String, + }, + /// The shape has the wrong number of dimensions. + #[error("shape must have one dimension in version {CURRENT_VERSION}, found {0}")] + ShapeRank(usize), + /// A shape extent is zero or negative. + #[error("shape extents must be positive, found {0}")] + ShapeNotPositive(i64), + /// The export has no parameters at all. + #[error("a tile export needs at least one parameter")] + NoParams, + /// Nothing is written: no `out` and no `inout` parameter. + #[error("a tile export needs at least one output: return a value or take an `inout` parameter")] + NoOutputs, + /// An `in` parameter sits between two written parameters. The Tile + /// compiler requires the `out` and `inout` arguments of a declaration to + /// be one contiguous run (PreviewOps.cpp, "out/inout fragment args must + /// form a single ..."). + #[error( + "`out` and `inout` parameters must be one contiguous run, but `{between}` is `in` and sits between `{first}` and `{last}`; move `in` parameters before the `&mut` ones" + )] + OutputsNotContiguous { + /// The first written parameter. + first: String, + /// The `in` parameter inside the run. + between: String, + /// The last written parameter (the appended return slot, when present). + last: String, + }, + /// Two parameters share a name. + #[error("parameter `{name}` is declared twice")] + DuplicateParam { + /// The repeated name. + name: String, + }, + /// A footprint of zero elements. + #[error( + "parameter `{name}` has footprint 0; a footprint counts elements and must be at least 1" + )] + ZeroFootprint { + /// The parameter. + name: String, + }, + /// By-value passing on something that is written. + #[error( + "parameter `{name}` is `{access}` and cannot travel by value; only `in` parameters are passed by value" + )] + ByValueNotIn { + /// The parameter. + name: String, + /// Its access mode. + access: &'static str, + }, + /// By-value passing of more than one element. + #[error( + "parameter `{name}` has footprint {footprint} and cannot travel by value; a footprint above 1 needs pointer passing" + )] + ByValueFootprint { + /// The parameter. + name: String, + /// Its footprint. + footprint: u32, + }, + /// Two parameters own a different number of elements per invocation. The + /// fragmaps of one implementation share their invocation count, so this + /// has no Tile IR form. + #[error( + "parameters `{first}` (footprint {first_footprint}) and `{other}` (footprint {other_footprint}) differ; every parameter of one export shares the invocation count, so all footprints must be equal" + )] + MixedFootprints { + /// The first parameter, whose footprint the others were compared to. + first: String, + /// Its footprint. + first_footprint: u32, + /// The first parameter with another footprint. + other: String, + /// That footprint. + other_footprint: u32, + }, + /// Warp synchronization over a shape that does not fill whole warps; the + /// footprint-1 case of [`TileExportError::WarpFootprintShape`]. + #[error("sync = warp needs a shape that is a multiple of 32, found {shape}")] + WarpShape { + /// The offending extent. + shape: i64, + }, + /// Warp synchronization over a shape that does not fill whole warps of + /// footprints: each lane owns `footprint` elements, so a warp owns + /// `32 * footprint` of them. + #[error( + "sync = warp with footprint {footprint} needs a shape that is a multiple of {} (32 lanes times the footprint), found {shape}", + 32 * i64::from(*.footprint) + )] + WarpFootprintShape { + /// The shared footprint. + footprint: u32, + /// The offending extent. + shape: i64, + }, + /// An empty architecture string. + #[error("arch entries must be non-empty names such as `sm_120`")] + EmptyArch, +} + +/// How one ABI parameter is passed. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum AbiParamKind { + /// The element itself, by value. + Scalar(TileElem), + /// A pointer to the invocation's buffer of this element type. + Pointer(TileElem), +} + +impl AbiParamKind { + /// The LLVM IR type of the parameter: the element type, or `ptr`. + pub fn llvm_type(self) -> &'static str { + match self { + AbiParamKind::Scalar(elem) => elem.llvm_name(), + AbiParamKind::Pointer(_) => "ptr", + } + } + + /// The element type behind the parameter. + pub fn elem(self) -> TileElem { + match self { + AbiParamKind::Scalar(elem) | AbiParamKind::Pointer(elem) => elem, + } + } +} + +/// One parameter of the implementation symbol. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct AbiParam { + /// The description parameter this ABI parameter carries. + pub name: String, + /// By value or by pointer. + pub kind: AbiParamKind, +} + +/// True for an ASCII identifier: `[A-Za-z_][A-Za-z0-9_]*`. +/// +/// Both Tile IR symbol names and the LLVM symbols the wrapper gets have this +/// form; a Rust raw identifier or a non-ASCII name would not survive the +/// trip. +pub fn is_identifier(text: &str) -> bool { + let mut chars = text.chars(); + match chars.next() { + Some(first) if first.is_ascii_alphabetic() || first == '_' => {} + _ => return false, + } + chars.all(|c| c.is_ascii_alphanumeric() || c == '_') +} + +impl TileExportDesc { + /// Check every rule of version 1. + /// + /// The rules, in the order they are checked: + /// + /// - `version` is [`CURRENT_VERSION`]; + /// - `decl`, `symbol`, and every parameter name are identifiers, and no + /// parameter name repeats; + /// - `shape` has one positive extent; + /// - there is at least one parameter and at least one `out` or `inout` + /// parameter, and the `out`/`inout` parameters are one contiguous run; + /// - every footprint is at least 1, and every parameter has the same + /// footprint; + /// - `by_value` appears only on `in` parameters with footprint 1; + /// - `sync = warp` needs a shape that is a multiple of `32 * footprint`; + /// - every `arch` entry is non-empty. + pub fn validate(&self) -> Result<(), TileExportError> { + if self.version != CURRENT_VERSION { + return Err(TileExportError::UnsupportedVersion { + found: self.version, + }); + } + for (field, value) in [("decl", &self.decl), ("symbol", &self.symbol)] { + if !is_identifier(value) { + return Err(TileExportError::InvalidIdentifier { + field, + value: value.clone(), + }); + } + } + if self.shape.len() != 1 { + return Err(TileExportError::ShapeRank(self.shape.len())); + } + let extent = self.shape[0]; + if extent <= 0 { + return Err(TileExportError::ShapeNotPositive(extent)); + } + if self.params.is_empty() { + return Err(TileExportError::NoParams); + } + let mut seen = std::collections::HashSet::new(); + for param in &self.params { + if !is_identifier(¶m.name) { + return Err(TileExportError::InvalidIdentifier { + field: "parameter name", + value: param.name.clone(), + }); + } + if !seen.insert(param.name.as_str()) { + return Err(TileExportError::DuplicateParam { + name: param.name.clone(), + }); + } + if param.footprint == 0 { + return Err(TileExportError::ZeroFootprint { + name: param.name.clone(), + }); + } + if param.by_value { + if param.access != TileAccess::In { + return Err(TileExportError::ByValueNotIn { + name: param.name.clone(), + access: param.access.tile_ir_name(), + }); + } + if param.footprint != 1 { + return Err(TileExportError::ByValueFootprint { + name: param.name.clone(), + footprint: param.footprint, + }); + } + } + } + // One invocation count per implementation: every fragmap of it maps + // `shape / footprint` invocations, so the footprints cannot differ. + let first = &self.params[0]; + if let Some(other) = self + .params + .iter() + .find(|param| param.footprint != first.footprint) + { + return Err(TileExportError::MixedFootprints { + first: first.name.clone(), + first_footprint: first.footprint, + other: other.name.clone(), + other_footprint: other.footprint, + }); + } + let footprint = first.footprint; + if !self.params.iter().any(|param| param.access.is_output()) { + return Err(TileExportError::NoOutputs); + } + // The written arguments must be adjacent: the Tile compiler ties a + // declaration's results to one contiguous run of out/inout arguments. + let written: Vec = self + .params + .iter() + .enumerate() + .filter(|(_, param)| param.access.is_output()) + .map(|(index, _)| index) + .collect(); + if let (Some(&first), Some(&last)) = (written.first(), written.last()) + && last - first + 1 != written.len() + { + let between = self.params[first + 1..last] + .iter() + .find(|param| !param.access.is_output()) + .expect("a gap in the written run holds an `in` parameter"); + return Err(TileExportError::OutputsNotContiguous { + first: self.params[first].name.clone(), + between: between.name.clone(), + last: self.params[last].name.clone(), + }); + } + // A warp is one invocation of 32 lanes, each owning `footprint` + // elements, so the tile must split into whole `32 * footprint` runs. + if self.sync == TileSync::Warp && extent % (32 * i64::from(footprint)) != 0 { + return Err(if footprint == 1 { + TileExportError::WarpShape { shape: extent } + } else { + TileExportError::WarpFootprintShape { + footprint, + shape: extent, + } + }); + } + if self.arch.iter().any(|arch| arch.trim().is_empty()) { + return Err(TileExportError::EmptyArch); + } + Ok(()) + } + + /// The implementation symbol's parameters, in order. + /// + /// Follows the ABI table in the crate documentation: an `in` parameter + /// marked `by_value` is passed as its element type, and everything else + /// (pointer inputs, `inout` buffers, and the trailing `out` result) is a + /// pointer to the element type. The description is assumed to have passed + /// [`TileExportDesc::validate`]. + pub fn abi_params(&self) -> Vec { + self.params + .iter() + .map(|param| { + let kind = if param.access == TileAccess::In && param.by_value { + AbiParamKind::Scalar(param.elem) + } else { + AbiParamKind::Pointer(param.elem) + }; + AbiParam { + name: param.name.clone(), + kind, + } + }) + .collect() + } + + /// The description as compact JSON, the form the macro embeds. + pub fn to_json(&self) -> String { + serde_json::to_string(self).expect("a tile export description always serializes") + } + + /// The description as indented JSON. + pub fn to_json_pretty(&self) -> String { + serde_json::to_string_pretty(self).expect("a tile export description always serializes") + } + + /// Parse one description. Syntax only; call [`TileExportDesc::validate`] + /// for the semantic rules. + pub fn from_json(text: &str) -> Result { + serde_json::from_str(text) + } +} + +/// Serialize a crate's descriptions as the indented JSON array the +/// description file holds. +pub fn descriptions_to_json_pretty(descs: &[TileExportDesc]) -> String { + serde_json::to_string_pretty(descs).expect("tile export descriptions always serialize") +} + +/// Parse a description file's JSON array. +pub fn descriptions_from_json(text: &str) -> Result, serde_json::Error> { + serde_json::from_str(text) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn param(name: &str, access: TileAccess, footprint: u32, by_value: bool) -> TileParamDesc { + TileParamDesc { + name: name.to_string(), + elem: TileElem::F32, + access, + footprint, + by_value, + } + } + + /// `fn relu(x: f32) -> f32` with `shape = 128`. + fn relu() -> TileExportDesc { + TileExportDesc { + version: CURRENT_VERSION, + decl: "relu".into(), + symbol: "relu_impl".into(), + shape: vec![128], + params: vec![ + param("x", TileAccess::In, 1, true), + param("relu_out", TileAccess::Out, 1, false), + ], + sync: TileSync::None, + arch: Vec::new(), + } + } + + /// `fn scale(x: &mut f32, factor: f32)` exported as `scale_in_place`. + fn scale_in_place() -> TileExportDesc { + TileExportDesc { + version: CURRENT_VERSION, + decl: "scale_in_place".into(), + symbol: "scale_in_place_impl".into(), + shape: vec![128], + params: vec![ + param("x", TileAccess::InOut, 1, false), + param("factor", TileAccess::In, 1, true), + ], + sync: TileSync::None, + arch: vec!["sm_120".into()], + } + } + + #[test] + fn the_examples_validate() { + relu().validate().unwrap(); + scale_in_place().validate().unwrap(); + let mut warp = relu(); + warp.sync = TileSync::Warp; + warp.validate().unwrap(); + } + + #[test] + fn version_is_pinned() { + assert_eq!(CURRENT_VERSION, 1); + let mut desc = relu(); + desc.version = 2; + assert_eq!( + desc.validate(), + Err(TileExportError::UnsupportedVersion { found: 2 }) + ); + } + + #[test] + fn names_must_be_identifiers() { + for (field, mutate) in [ + ( + "decl", + (|d: &mut TileExportDesc| d.decl = "re-lu".into()) as fn(&mut TileExportDesc), + ), + ("symbol", |d: &mut TileExportDesc| d.symbol = "1impl".into()), + ("parameter name", |d: &mut TileExportDesc| { + d.params[0].name = "x y".into() + }), + ] { + let mut desc = relu(); + mutate(&mut desc); + match desc.validate() { + Err(TileExportError::InvalidIdentifier { field: found, .. }) => { + assert_eq!(found, field) + } + other => panic!("{field}: expected an identifier error, got {other:?}"), + } + } + assert!(is_identifier("_x1")); + assert!(!is_identifier("")); + assert!(!is_identifier("9x")); + assert!(!is_identifier("r#type")); + } + + #[test] + fn duplicate_parameter_names_are_rejected() { + let mut desc = relu(); + desc.params[1].name = "x".into(); + assert_eq!( + desc.validate(), + Err(TileExportError::DuplicateParam { name: "x".into() }) + ); + } + + #[test] + fn shape_is_one_positive_extent() { + let mut desc = relu(); + desc.shape = vec![128, 1]; + assert_eq!(desc.validate(), Err(TileExportError::ShapeRank(2))); + desc.shape = Vec::new(); + assert_eq!(desc.validate(), Err(TileExportError::ShapeRank(0))); + desc.shape = vec![0]; + assert_eq!(desc.validate(), Err(TileExportError::ShapeNotPositive(0))); + desc.shape = vec![-4]; + assert_eq!(desc.validate(), Err(TileExportError::ShapeNotPositive(-4))); + } + + #[test] + fn every_export_has_a_parameter_and_an_output() { + let mut desc = relu(); + desc.params.clear(); + assert_eq!(desc.validate(), Err(TileExportError::NoParams)); + let mut desc = relu(); + desc.params.pop(); + assert_eq!(desc.validate(), Err(TileExportError::NoOutputs)); + } + + #[test] + fn written_parameters_form_one_contiguous_run() { + // `fn f(a: &mut f32, b: f32) -> f32` is [inout, in, out]: the Tile + // compiler ties results to one adjacent run of written arguments. + let mut desc = relu(); + desc.params = vec![ + param("a", TileAccess::InOut, 1, false), + param("b", TileAccess::In, 1, true), + param("f_out", TileAccess::Out, 1, false), + ]; + assert_eq!( + desc.validate(), + Err(TileExportError::OutputsNotContiguous { + first: "a".into(), + between: "b".into(), + last: "f_out".into(), + }) + ); + // Grouping the written parameters last is accepted. + desc.params = vec![ + param("b", TileAccess::In, 1, true), + param("a", TileAccess::InOut, 1, false), + param("f_out", TileAccess::Out, 1, false), + ]; + assert_eq!(desc.validate(), Ok(())); + // Written parameters first and `in` parameters after them are also + // one run. + desc.params = vec![ + param("a", TileAccess::InOut, 1, false), + param("c", TileAccess::InOut, 1, false), + param("b", TileAccess::In, 1, true), + ]; + assert_eq!(desc.validate(), Ok(())); + } + + #[test] + fn footprints_start_at_one() { + let mut desc = scale_in_place(); + desc.params[0].footprint = 0; + assert_eq!( + desc.validate(), + Err(TileExportError::ZeroFootprint { name: "x".into() }) + ); + // `fn scale4(x: &mut [f32; 4], factor: &[f32; 4])`. + for param in &mut desc.params { + param.footprint = 4; + param.by_value = false; + } + desc.validate().unwrap(); + } + + #[test] + fn footprints_are_the_same_for_every_parameter() { + // `fn window(acc: &mut [i32; 4], bias: &i32)`: the window needs 16 + // invocations of a 64-element tile, the scalar 64. + let mut desc = scale_in_place(); + desc.params[0].footprint = 4; + assert_eq!( + desc.validate(), + Err(TileExportError::MixedFootprints { + first: "x".into(), + first_footprint: 4, + other: "factor".into(), + other_footprint: 1, + }) + ); + let message = desc.validate().unwrap_err().to_string(); + assert!( + message.contains("`x` (footprint 4) and `factor` (footprint 1) differ"), + "{message}" + ); + // The comparison is against the first parameter, whichever it is. + desc.params[0].footprint = 1; + desc.params[1].footprint = 2; + desc.params[1].by_value = false; + assert_eq!( + desc.validate(), + Err(TileExportError::MixedFootprints { + first: "x".into(), + first_footprint: 1, + other: "factor".into(), + other_footprint: 2, + }) + ); + } + + #[test] + fn by_value_needs_in_and_footprint_one() { + let mut desc = scale_in_place(); + desc.params[0].by_value = true; + assert_eq!( + desc.validate(), + Err(TileExportError::ByValueNotIn { + name: "x".into(), + access: "inout", + }) + ); + let mut desc = relu(); + desc.params[1].by_value = true; + assert_eq!( + desc.validate(), + Err(TileExportError::ByValueNotIn { + name: "relu_out".into(), + access: "out", + }) + ); + let mut desc = relu(); + desc.params[0].footprint = 2; + assert_eq!( + desc.validate(), + Err(TileExportError::ByValueFootprint { + name: "x".into(), + footprint: 2, + }) + ); + } + + #[test] + fn warp_sync_needs_whole_warps() { + let mut desc = relu(); + desc.sync = TileSync::Warp; + desc.shape = vec![100]; + assert_eq!( + desc.validate(), + Err(TileExportError::WarpShape { shape: 100 }) + ); + desc.shape = vec![32]; + desc.validate().unwrap(); + // `none` has no shape rule. + desc.sync = TileSync::None; + desc.shape = vec![100]; + desc.validate().unwrap(); + } + + #[test] + fn warp_sync_with_a_footprint_needs_whole_warps_of_footprints() { + // `fn scale4(x: &mut [f32; 4], factor: &[f32; 4])` with `sync = + // warp`: a warp owns 128 elements, so a 64-element tile holds half + // a warp even though 64 is a multiple of 32. + let mut desc = scale_in_place(); + desc.sync = TileSync::Warp; + for param in &mut desc.params { + param.footprint = 4; + param.by_value = false; + } + desc.shape = vec![64]; + assert_eq!( + desc.validate(), + Err(TileExportError::WarpFootprintShape { + footprint: 4, + shape: 64, + }) + ); + let message = desc.validate().unwrap_err().to_string(); + assert!(message.contains("multiple of 128"), "{message}"); + desc.shape = vec![256]; + desc.validate().unwrap(); + // Footprint 1 keeps the plain multiple-of-32 rule and its message. + for param in &mut desc.params { + param.footprint = 1; + } + desc.shape = vec![100]; + assert_eq!( + desc.validate(), + Err(TileExportError::WarpShape { shape: 100 }) + ); + // Without synchronization only the footprint rules apply. + desc.sync = TileSync::None; + for param in &mut desc.params { + param.footprint = 4; + } + desc.shape = vec![64]; + desc.validate().unwrap(); + } + + #[test] + fn arch_entries_are_non_empty() { + let mut desc = relu(); + desc.arch = vec!["sm_120".into(), " ".into()]; + assert_eq!(desc.validate(), Err(TileExportError::EmptyArch)); + } + + #[test] + fn abi_params_follow_the_table() { + let abi = relu().abi_params(); + assert_eq!( + abi, + vec![ + AbiParam { + name: "x".into(), + kind: AbiParamKind::Scalar(TileElem::F32), + }, + AbiParam { + name: "relu_out".into(), + kind: AbiParamKind::Pointer(TileElem::F32), + }, + ] + ); + assert_eq!(abi[0].kind.llvm_type(), "float"); + assert_eq!(abi[1].kind.llvm_type(), "ptr"); + + let abi = scale_in_place().abi_params(); + assert_eq!(abi[0].kind, AbiParamKind::Pointer(TileElem::F32)); + assert_eq!(abi[1].kind, AbiParamKind::Scalar(TileElem::F32)); + + // `x: &[T; F]` is `in` behind a pointer, `x: &mut [T; F]` is `inout` + // behind a pointer; neither is by value. + let mut desc = relu(); + desc.params[0].by_value = false; + desc.params[0].footprint = 8; + desc.params[1].footprint = 8; + desc.params + .insert(1, param("window", TileAccess::InOut, 8, false)); + desc.validate().unwrap(); + let abi = desc.abi_params(); + assert_eq!(abi[0].kind, AbiParamKind::Pointer(TileElem::F32)); + assert_eq!(abi[1].kind, AbiParamKind::Pointer(TileElem::F32)); + assert_eq!(abi[1].name, "window"); + assert_eq!(abi[2].kind, AbiParamKind::Pointer(TileElem::F32)); + + // A by-value bf16 is the `u16` bit pattern cuda-device carries, so + // the ABI parameter is `i16`; the Tile IR element stays `bf16`. + let mut desc = relu(); + desc.params[0].elem = TileElem::BF16; + assert_eq!(desc.abi_params()[0].kind.llvm_type(), "i16"); + assert_eq!(TileElem::BF16.tile_ir_name(), "bf16"); + } + + #[test] + fn element_names_agree_across_rust_tile_ir_and_llvm() { + let expected = [ + (TileElem::F16, "f16", "f16", "half", 16), + (TileElem::BF16, "bf16", "bf16", "i16", 16), + (TileElem::F32, "f32", "f32", "float", 32), + (TileElem::F64, "f64", "f64", "double", 64), + (TileElem::I8, "i8", "i8", "i8", 8), + (TileElem::I16, "i16", "i16", "i16", 16), + (TileElem::I32, "i32", "i32", "i32", 32), + (TileElem::I64, "i64", "i64", "i64", 64), + (TileElem::U8, "u8", "i8", "i8", 8), + (TileElem::U16, "u16", "i16", "i16", 16), + (TileElem::U32, "u32", "i32", "i32", 32), + (TileElem::U64, "u64", "i64", "i64", 64), + ]; + assert_eq!(expected.len(), TileElem::ALL.len()); + for (elem, rust, tile_ir, llvm, bits) in expected { + assert_eq!(elem.rust_name(), rust); + assert_eq!(elem.tile_ir_name(), tile_ir); + assert_eq!(elem.llvm_name(), llvm); + assert_eq!(elem.bit_width(), bits); + assert_eq!(TileElem::from_rust_name(rust), Some(elem)); + assert_eq!( + elem.is_float(), + matches!(tile_ir, "f16" | "bf16" | "f32" | "f64") + ); + } + assert_eq!(TileElem::from_rust_name("usize"), None); + assert_eq!(TileElem::from_rust_name("bool"), None); + } + + #[test] + fn json_round_trips_and_uses_lowercase_vocabulary() { + let desc = scale_in_place(); + let json = desc.to_json(); + assert!(json.contains("\"access\":\"inout\""), "{json}"); + assert!(json.contains("\"elem\":\"f32\""), "{json}"); + assert!(json.contains("\"sync\":\"none\""), "{json}"); + assert!(json.contains("\"arch\":[\"sm_120\"]"), "{json}"); + assert_eq!(TileExportDesc::from_json(&json).unwrap(), desc); + + let mut warp = relu(); + warp.sync = TileSync::Warp; + warp.params[0].elem = TileElem::BF16; + let json = warp.to_json(); + assert!(json.contains("\"sync\":\"warp\""), "{json}"); + assert!(json.contains("\"elem\":\"bf16\""), "{json}"); + assert_eq!(TileExportDesc::from_json(&json).unwrap(), warp); + + // `sync` and `arch` default when absent. + let minimal = r#"{"version":1,"decl":"relu","symbol":"relu_impl","shape":[128], + "params":[{"name":"x","elem":"f32","access":"in","footprint":1,"by_value":true}, + {"name":"relu_out","elem":"f32","access":"out","footprint":1,"by_value":false}]}"#; + assert_eq!(TileExportDesc::from_json(minimal).unwrap(), relu()); + + let all = vec![relu(), scale_in_place()]; + let text = descriptions_to_json_pretty(&all); + assert!(text.starts_with('['), "{text}"); + assert_eq!(descriptions_from_json(&text).unwrap(), all); + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/Cargo.toml b/cuda-oxide/crates/oxide-tilebc/Cargo.toml new file mode 100644 index 0000000000..6b2cd1fc43 --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "oxide-tilebc" +version = "0.2.1" +edition.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true +description = "Tile IR bytecode writer for the tile library descriptions cuda-oxide ships" +readme = "README.md" + +[dependencies] +thiserror = { workspace = true } + +[lints.rust] +missing_docs = { level = "deny" } diff --git a/cuda-oxide/crates/oxide-tilebc/README.md b/cuda-oxide/crates/oxide-tilebc/README.md new file mode 100644 index 0000000000..ecc78100b0 --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/README.md @@ -0,0 +1,56 @@ +# oxide-tilebc + +Tile IR bytecode for the tile libraries cuda-oxide ships. + +A tile library lets a Tile kernel call a SIMT function. cuda-oxide is the +SIMT provider: it compiles the Rust function to LTOIR and describes it twice, +once as the declaration a Tile kernel calls (the interface) and once as the +native symbol with the fragment each parameter receives (the implementation). +`tileiras --preview-create-tile-lib` packs the three into one `.tilelib`. This +crate writes the two descriptions; nothing else in the Tile IR format. + +```text +#[tile_export] descriptions ──> Library { declarations, implementations } + │ + interface_bytecode(v) ───┼──> .iface.tilebc (preview$func extern ...) + implementation_bytecode(v)┴──> .impl.tilebc (preview$extern_impl ...) + │ + tileiras --preview-create-tile-lib + .ltoir ──> .tilelib +``` + +The descriptions are public-preview content, which exists from Tile IR 13.5 +on and which an assembler reads only at the version it calls current, the +newest numbered version its `--list-versions` prints. `BytecodeVersion::parse` +reads that listing; pass the newest version to the two writers. + +```rust +use oxide_tilebc::*; + +let tile = TileType::new(vec![128], ScalarType::F32); +let decl = Declaration::new("relu", vec![ + TileArg::new("x", tile.clone(), Access::In), + TileArg::new("relu_out", tile, Access::Out), +]); +let imp = Implementation::new("relu_impl", "relu", vec![ + FragmentArg::new("x", FragmentType::new(vec![1], ScalarType::F32, MemorySpace::Local, + Layout::scalar_mem(), Layout::elementwise(128)), Access::In), + FragmentArg::new("relu_out", FragmentType::new(vec![1], ScalarType::F32, MemorySpace::Local, + Layout::contiguous_mem(1), Layout::elementwise(128)), Access::Out), +]); +let library = Library::new("relu", vec![decl], vec![imp]); +library.verify()?; +let interface = library.interface_bytecode(BytecodeVersion::new(13, 5))?; +let implementation = library.implementation_bytecode(BytecodeVersion::new(13, 5))?; +println!("{}{}", library.interface_text(), library.implementation_text()); +# Ok::<(), oxide_tilebc::Error>(()) +``` + +`verify` applies the rules the Tile compiler's own verifier applies when the +two halves meet: one contiguous run of written arguments, one fragment per +argument with the same access and element type, fragmaps that cover the tile +with the participants the synchronization clause promises, and a rank-0 +buffer layout (a scalar passed by value) only for a read-only local fragment. + +The wire format was derived from the Tile IR compiler sources and checked +against an assembler that reads 13.5 content: its `--preview-create-tile-lib` +packs this crate's output into a library that a Tile C++ kernel then calls. diff --git a/cuda-oxide/crates/oxide-tilebc/src/encoding.rs b/cuda-oxide/crates/oxide-tilebc/src/encoding.rs new file mode 100644 index 0000000000..50816429bf --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/encoding.rs @@ -0,0 +1,201 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! The byte-level primitives of Tile IR bytecode: LEB128 varints, zigzag +//! signed varints, little-endian words, alignment padding and section +//! framing. These are the same primitives every Tile IR producer uses; the +//! reference reader documents them in its bytecode grammar. + +/// The eight magic bytes every Tile IR bytecode file starts with. +pub const MAGIC: [u8; 8] = [0x7F, b'T', b'i', b'l', b'e', b'I', b'R', 0x00]; + +/// Padding byte used to reach a section's alignment. +pub const ALIGNMENT_BYTE: u8 = 0xCB; + +/// Header tag bit set when a module carries public-preview content. +pub const CONTAINS_PREVIEW: u16 = 0x1; + +/// Section identifiers. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u8)] +pub enum Section { + /// Marks the end of the file. + EndOfBytecode = 0x00, + /// The string table. + String = 0x01, + /// The function table. + Func = 0x02, + /// Debug locations and attributes. + Debug = 0x03, + /// The type table. + Type = 0x05, +} + +/// An append-only byte buffer with the bytecode's integer encodings. +#[derive(Debug, Default)] +pub struct Writer { + buf: Vec, +} + +impl Writer { + /// An empty buffer. + pub fn new() -> Self { + Self::default() + } + + /// One raw byte. + pub fn byte(&mut self, value: u8) { + self.buf.push(value); + } + + /// Raw bytes. + pub fn bytes(&mut self, data: &[u8]) { + self.buf.extend_from_slice(data); + } + + /// An unsigned LEB128 varint: seven bits per byte, high bit set while + /// more bytes follow. Tags at or above 0x80 therefore take two bytes. + pub fn varint(&mut self, mut value: u64) { + loop { + let mut byte = (value & 0x7F) as u8; + value >>= 7; + if value != 0 { + byte |= 0x80; + } + self.buf.push(byte); + if value == 0 { + return; + } + } + } + + /// A zigzag-encoded signed varint, used for `int64_t` parameters. + pub fn signed_varint(&mut self, value: i64) { + self.varint(((value << 1) ^ (value >> 63)) as u64); + } + + /// A little-endian `u32`. + pub fn le_u32(&mut self, value: u32) { + self.buf.extend_from_slice(&value.to_le_bytes()); + } + + /// A little-endian `u64`. + pub fn le_u64(&mut self, value: u64) { + self.buf.extend_from_slice(&value.to_le_bytes()); + } + + /// `varint(count)` followed by each value as a little-endian `i64`: the + /// encoding of a shape. + pub fn le_var_size_i64(&mut self, values: &[i64]) { + self.varint(values.len() as u64); + for &value in values { + self.buf.extend_from_slice(&value.to_le_bytes()); + } + } + + /// Pad with [`ALIGNMENT_BYTE`] until the length is a multiple of + /// `alignment`. + pub fn align_to(&mut self, alignment: usize) { + if alignment < 2 { + return; + } + while !self.buf.len().is_multiple_of(alignment) { + self.buf.push(ALIGNMENT_BYTE); + } + } + + /// The current length. + #[allow(clippy::len_without_is_empty)] + pub fn len(&self) -> usize { + self.buf.len() + } + + /// Overwrite a little-endian `u32` written earlier (an offset table slot). + pub fn patch_u32(&mut self, offset: usize, value: u32) { + self.buf[offset..offset + 4].copy_from_slice(&value.to_le_bytes()); + } + + /// The bytes. + pub fn into_bytes(self) -> Vec { + self.buf + } +} + +/// Append a section to `out`: the id byte (bit 7 set when aligned), the +/// payload length, then for an aligned section the alignment and padding +/// relative to the whole file, then the payload. +pub fn write_section(out: &mut Vec, section: Section, payload: &[u8], alignment: usize) { + let mut id = section as u8; + if alignment > 1 { + id |= 0x80; + } + let mut header = Writer::new(); + header.byte(id); + header.varint(payload.len() as u64); + if alignment > 1 { + header.varint(alignment as u64); + } + out.extend_from_slice(&header.into_bytes()); + if alignment > 1 { + while !out.len().is_multiple_of(alignment) { + out.push(ALIGNMENT_BYTE); + } + } + out.extend_from_slice(payload); +} + +/// Write `count`, align to four, reserve `count` little-endian `u32` offset +/// slots and return the position of the first one. Tables of strings, types +/// and debug entries all start this way. +pub fn begin_offset_table(w: &mut Writer, count: usize) -> usize { + w.varint(count as u64); + w.align_to(4); + let first = w.len(); + for _ in 0..count { + w.le_u32(0); + } + first +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn varints_follow_leb128() { + let mut w = Writer::new(); + w.varint(0); + w.varint(127); + w.varint(128); + w.varint(0xD2); + w.varint(300); + assert_eq!( + w.into_bytes(), + [0x00, 0x7F, 0x80, 0x01, 0xD2, 0x01, 0xAC, 0x02] + ); + } + + #[test] + fn signed_varints_are_zigzag() { + let mut w = Writer::new(); + w.signed_varint(0); + w.signed_varint(1); + w.signed_varint(-1); + w.signed_varint(128); + assert_eq!(w.into_bytes(), [0x00, 0x02, 0x01, 0x80, 0x02]); + } + + #[test] + fn aligned_sections_pad_relative_to_the_file() { + let mut out = MAGIC.to_vec(); + out.extend_from_slice(&[13, 5, 1, 0]); + write_section(&mut out, Section::Func, &[0xAA; 3], 8); + // id, length, alignment at 12..15, then padding to 16. + assert_eq!(&out[12..16], &[0x82, 0x03, 0x08, ALIGNMENT_BYTE]); + assert_eq!(&out[16..19], &[0xAA; 3]); + write_section(&mut out, Section::EndOfBytecode, &[], 1); + assert_eq!(out.last(), Some(&0x00)); + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/src/lib.rs b/cuda-oxide/crates/oxide-tilebc/src/lib.rs new file mode 100644 index 0000000000..3d9300e197 --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/lib.rs @@ -0,0 +1,358 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! Tile IR bytecode for the tile libraries cuda-oxide ships. +//! +//! A tile library lets a Tile kernel call a SIMT function. cuda-oxide is the +//! SIMT provider: it compiles the function to LTOIR and describes it twice, +//! once as the declaration a Tile kernel calls (the interface) and once as +//! the native symbol with the fragment each parameter receives (the +//! implementation). `tileiras --preview-create-tile-lib` packs the three into +//! one `.tilelib`. This crate writes the two descriptions. +//! +//! ```text +//! Library { declarations, implementations } +//! |-- interface_bytecode(version) -> .iface.tilebc +//! |-- implementation_bytecode(version) -> .impl.tilebc +//! `-- interface_text(), implementation_text() readable form +//! ``` +//! +//! The descriptions are public-preview content (Tile IR 13.5 and newer). +//! An assembler reads such content only at the version it calls current, +//! the newest numbered version its `--list-versions` prints, so the caller +//! passes that version; [`BytecodeVersion::parse`] reads the listing. +//! +//! ``` +//! use oxide_tilebc::*; +//! +//! let tile = TileType::new(vec![128], ScalarType::F32); +//! let decl = Declaration::new("relu", vec![ +//! TileArg::new("x", tile.clone(), Access::In), +//! TileArg::new("relu_out", tile, Access::Out), +//! ]); +//! let by_value = FragmentType::new(vec![1], ScalarType::F32, MemorySpace::Local, +//! Layout::scalar_mem(), Layout::elementwise(128)); +//! let by_pointer = FragmentType::new(vec![1], ScalarType::F32, MemorySpace::Local, +//! Layout::contiguous_mem(1), Layout::elementwise(128)); +//! let imp = Implementation::new("relu_impl", "relu", vec![ +//! FragmentArg::new("x", by_value, Access::In), +//! FragmentArg::new("relu_out", by_pointer, Access::Out), +//! ]); +//! let library = Library::new("relu", vec![decl], vec![imp]); +//! library.verify().unwrap(); +//! let interface = library.interface_bytecode(BytecodeVersion::PREVIEW_FIRST).unwrap(); +//! assert_eq!(&interface[8..12], &[13, 5, 1, 0]); +//! ``` + +mod encoding; +mod model; +mod text; +mod verify; +mod writer; + +pub use model::{ + Access, BytecodeVersion, Declaration, FragmentArg, FragmentType, Implementation, Layout, + Library, MemorySpace, ScalarType, Synchronization, TileArg, TileType, +}; + +/// What can go wrong when describing a library. +#[derive(Debug, thiserror::Error, PartialEq, Eq)] +pub enum Error { + /// The library breaks a structural rule; the message names the part. + #[error("{0}")] + Verify(String), + /// Preview content needs bytecode 13.5 or newer. + #[error("bytecode version {0} is older than 13.5, the first with public-preview content")] + Version(BytecodeVersion), +} + +#[cfg(test)] +mod tests { + use super::*; + + /// `(section id, payload)` in file order, with the framing checked. + fn sections(bytes: &[u8]) -> Vec<(u8, Vec)> { + assert_eq!(&bytes[..8], b"\x7fTileIR\0"); + let mut pos = 12; + let mut out = Vec::new(); + loop { + let id_byte = bytes[pos]; + pos += 1; + if id_byte & 0x7F == 0 { + assert_eq!(pos, bytes.len()); + return out; + } + let len = read_varint(bytes, &mut pos) as usize; + if id_byte & 0x80 != 0 { + let alignment = read_varint(bytes, &mut pos) as usize; + while pos % alignment != 0 { + assert_eq!(bytes[pos], 0xCB); + pos += 1; + } + } + out.push((id_byte & 0x7F, bytes[pos..pos + len].to_vec())); + pos += len; + } + } + + fn read_varint(bytes: &[u8], pos: &mut usize) -> u64 { + let mut value = 0u64; + let mut shift = 0; + loop { + let byte = bytes[*pos]; + *pos += 1; + value |= u64::from(byte & 0x7F) << shift; + if byte & 0x80 == 0 { + return value; + } + shift += 7; + } + } + + fn section(bytes: &[u8], id: u8) -> Vec { + sections(bytes) + .into_iter() + .find(|(s, _)| *s == id) + .map(|(_, payload)| payload) + .unwrap_or_else(|| panic!("no section {id}")) + } + + fn strings(bytes: &[u8]) -> Vec { + let payload = section(bytes, 1); + let mut pos = 0; + let count = read_varint(&payload, &mut pos) as usize; + while pos % 4 != 0 { + pos += 1; + } + let offsets: Vec = (0..count) + .map(|i| { + u32::from_le_bytes(payload[pos + 4 * i..pos + 4 * i + 4].try_into().unwrap()) + as usize + }) + .collect(); + let data = &payload[pos + 4 * count..]; + (0..count) + .map(|i| { + let end = offsets.get(i + 1).copied().unwrap_or(data.len()); + String::from_utf8(data[offsets[i]..end].to_vec()).unwrap() + }) + .collect() + } + + fn index(table: &[String], text: &str) -> u8 { + u8::try_from(table.iter().position(|t| t == text).expect(text)).unwrap() + } + + fn tile() -> TileType { + TileType::new(vec![128], ScalarType::F32) + } + + fn scale_library() -> Library { + let decl = Declaration::new( + "tilelib_scale", + vec![TileArg::new("arg0", tile(), Access::InOut)], + ); + let fragment = FragmentType::new( + vec![1], + ScalarType::F32, + MemorySpace::Local, + Layout::contiguous_mem(1), + Layout::elementwise(128), + ); + let imp = Implementation::new( + "tilelib_scale_impl", + "tilelib_scale", + vec![FragmentArg::new("arg0", fragment, Access::InOut)], + ); + Library::new("tilelib", vec![decl], vec![imp]) + } + + #[test] + fn header_carries_the_version_and_the_preview_tag() { + let lib = scale_library(); + let bytes = lib.interface_bytecode(BytecodeVersion::new(13, 6)).unwrap(); + assert_eq!(&bytes[8..12], &[13, 6, 1, 0]); + assert_eq!( + lib.interface_bytecode(BytecodeVersion::new(13, 4)), + Err(Error::Version(BytecodeVersion::new(13, 4))) + ); + let ids: Vec = sections(&bytes).into_iter().map(|(id, _)| id).collect(); + assert_eq!(ids, [2, 3, 5, 1], "function, debug, type, string"); + } + + /// Extern declaration: normal form, private, body length 0, then the + /// empty constant parameters. The upstream fixture `tilelib_interface`. + #[test] + fn declaration_entry_layout() { + let bytes = scale_library() + .interface_bytecode(BytecodeVersion::PREVIEW_FIRST) + .unwrap(); + let table = strings(&bytes); + let name = index(&table, "tilelib_scale"); + let access = index(&table, "cuda_tile.preview$access"); + assert_eq!( + section(&bytes, 2), + vec![ + 0x01, name, 0x02, // one function, name, signature type index + 0x01, // flags: private, not a kernel, normal form + 0x01, // debug list index + 0x06, 0x01, 0x0A, 0x01, access, 0xDF, 0x01, + 0x02, // arg_attrs: [{access = inout}] + 0x00, // body length 0: a declaration + 0x06, 0x00, // const_params: empty array + ] + ); + // Types: f32, tile<128xf32>, then (tile) -> (tile). + let types = section(&bytes, 5); + let mut pos = 0; + assert_eq!(read_varint(&types, &mut pos), 3); + let entries = &types[4 + 4 * 3..]; + assert_eq!(entries[0], 0x07, "f32"); + assert_eq!( + &entries[1..12], + &[0x0D, 0x00, 0x01, 128, 0, 0, 0, 0, 0, 0, 0], + "tile<128xf32>" + ); + assert_eq!( + &entries[12..], + &[0x10, 0x01, 0x01, 0x01, 0x01], + "(tile) -> (tile)" + ); + } + + /// Implementation: form bits 01, private, the op payload in place of a + /// body, body length 0. The upstream fixture `tilelib_implementation`. + #[test] + fn implementation_entry_layout() { + let lib = scale_library(); + let bytes = lib + .implementation_bytecode(BytecodeVersion::PREVIEW_FIRST) + .unwrap(); + let table = strings(&bytes); + let symbol = index(&table, "tilelib_scale_impl"); + let implements = index(&table, "tilelib_scale"); + let access = index(&table, "cuda_tile.preview$access"); + let mut expected = vec![ + 0x01, symbol, 0x02, // one function, symbol, signature type index + 0x05, // flags: private, form extern_impl + 0x01, // debug list index + 0x04, // payload flags: arg_attrs only + symbol, implements, // sym_name, implements + 0x02, // function_type index + 0x01, 0x0A, 0x01, access, 0xDF, 0x01, + 0x02, // arg_attrs inline: [{access = inout}] + 0x01, 0x00, // one region, zero blocks + 0x00, // body length 0 + ]; + expected.resize(24, 0xCB); + assert_eq!(section(&bytes, 2), expected); + + // The fragment type entry: tagged empty symbolic shape, static shape + // [1], element f32 (index 0), local, (1):(1), (128, 1, 1):(1, 0, 0), + // alignment 1. + let types = section(&bytes, 5); + let entries = &types[4 + 4 * 3..]; + assert_eq!( + &entries[1..], + &[ + 0xD2, 0x01, 0xD8, 0x01, 0x00, 0x01, 1, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, // + 0xD9, 0x01, 0x01, 0xD1, 0x01, 0x02, 0x01, 0xD1, 0x01, 0x02, // + 0xD9, 0x01, 0x03, 0xD1, 0x01, 0x80, 0x02, 0xD1, 0x01, 0x02, 0xD1, 0x01, + 0x02, // + 0x03, 0xD1, 0x01, 0x02, 0xD1, 0x01, 0x00, 0xD1, 0x01, 0x00, // + 0xD1, 0x01, 0x02, // + 0x10, 0x01, 0x01, 0x00, // (fragment) -> () + ] + ); + } + + /// A warp-synchronous implementation sets bit 8 and writes the value + /// after the argument attributes; arch and frontendABI take bits 6 and 7. + #[test] + fn optional_clauses_set_their_flag_bits() { + let mut lib = scale_library(); + let imp = &mut lib.implementations[0]; + imp.args[0].fragment.fragmap = Layout::warp_lanes(128); + imp.synchronization = Some(Synchronization::Warp); + imp.arch = vec!["sm_120".into()]; + imp.frontend_abi = vec![("bf16".into(), "i16".into())]; + lib.verify().unwrap(); + let bytes = lib + .implementation_bytecode(BytecodeVersion::PREVIEW_FIRST) + .unwrap(); + let table = strings(&bytes); + let func = section(&bytes, 2); + // flags = bits 2, 6, 7, 8 = 0x1C4 -> varint C4 03 + assert_eq!(&func[5..7], &[0xC4, 0x03]); + let after_attrs = 7 + 3 + 7; + assert_eq!( + &func[after_attrs..after_attrs + 10], + &[ + 0x01, + 0x05, + index(&table, "sm_120"), // arch: one tagged string + 0x01, + index(&table, "bf16"), + 0x05, + index(&table, "i16"), // frontendABI + 0x01, // synchronization = warp + 0x01, + 0x00, // region + ] + ); + } + + #[test] + fn debug_section_holds_one_unknown_location_per_function() { + let bytes = scale_library() + .interface_bytecode(BytecodeVersion::PREVIEW_FIRST) + .unwrap(); + assert_eq!( + section(&bytes, 3), + vec![ + 0x01, 0xCB, 0xCB, 0xCB, // one function, aligned + 0, 0, 0, 0, // its id list starts at 0 + 0x01, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, // one id, aligned to 8 + 0, 0, 0, 0, 0, 0, 0, 0, // id 0: unknown location + 0x01, 0xCB, 0xCB, 0xCB, // one attribute entry + 0, 0, 0, 0, // at offset 0 + 0x00, // tag 0: unknown + ] + ); + } + + #[test] + fn text_matches_the_reference_form() { + let lib = scale_library(); + assert_eq!( + lib.interface_text(), + "cuda_tile.module @tilelib {\n cuda_tile.preview$func extern @tilelib_scale(%arg0: \ + !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}) \ + -> !cuda_tile.tile<128xf32>\n}\n" + ); + assert!(lib.implementation_text().contains( + "@tilelib_scale_impl implements @tilelib_scale(%arg0: !cuda_tile.preview$fragment<1xf32, \ + local, mem_layout = #cuda_tile.preview$layout<(1):(1)>, fragmap = \ + #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> {cuda_tile.preview$access = \ + #cuda_tile.preview$access})\n" + )); + } + + #[test] + fn versions_parse_from_the_assembler_listing() { + assert_eq!( + BytecodeVersion::parse("13.5"), + Some(BytecodeVersion::new(13, 5)) + ); + assert_eq!( + BytecodeVersion::parse(" 13.6.1 "), + Some(BytecodeVersion::new(13, 6)) + ); + assert_eq!(BytecodeVersion::parse("internal"), None); + assert_eq!(BytecodeVersion::parse("13"), None); + assert!(BytecodeVersion::new(13, 6) > BytecodeVersion::PREVIEW_FIRST); + assert_eq!(BytecodeVersion::new(13, 6).to_string(), "13.6"); + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/src/model.rs b/cuda-oxide/crates/oxide-tilebc/src/model.rs new file mode 100644 index 0000000000..d6ef3991fc --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/model.rs @@ -0,0 +1,465 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! The vocabulary of a tile library description: the tiles a declaration +//! takes, the fragments an implementation receives, and the clauses that +//! tell the Tile compiler how to call the native function. + +use std::fmt; + +/// A Tile IR bytecode version (`major.minor`). The header tag bits are not +/// part of a version. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct BytecodeVersion { + /// Major version, 13 for every Tile IR release so far. + pub major: u8, + /// Minor version. + pub minor: u8, +} + +impl BytecodeVersion { + /// The first version with public-preview content, and the version the + /// descriptions are written at when no assembler can be asked. + pub const PREVIEW_FIRST: Self = Self { + major: 13, + minor: 5, + }; + + /// A version from its two numbers. + pub const fn new(major: u8, minor: u8) -> Self { + Self { major, minor } + } + + /// Parse one line of `tileiras --list-versions`: `13.5` or `13.5.1` + /// (the header tag is ignored). Lines that are not versions, such as a + /// named build an assembler may list, give `None`. + pub fn parse(text: &str) -> Option { + let mut parts = text.trim().split('.'); + let major = parts.next()?.parse().ok()?; + let minor = parts.next()?.parse().ok()?; + if let Some(tag) = parts.next() { + tag.parse::().ok()?; + } + if parts.next().is_some() { + return None; + } + Some(Self { major, minor }) + } +} + +impl fmt::Display for BytecodeVersion { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}.{}", self.major, self.minor) + } +} + +/// Element types a description can name. Tile IR has no unsigned integers: +/// the unsigned Rust types are the signless `iN` of the same width. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum ScalarType { + /// `f16` + F16, + /// `bf16` + BF16, + /// `f32` + F32, + /// `f64` + F64, + /// `i8` + I8, + /// `i16` + I16, + /// `i32` + I32, + /// `i64` + I64, +} + +impl ScalarType { + /// The type-table tag. + pub(crate) fn tag(self) -> u8 { + match self { + Self::I8 => 1, + Self::I16 => 2, + Self::I32 => 3, + Self::I64 => 4, + Self::F16 => 5, + Self::BF16 => 6, + Self::F32 => 7, + Self::F64 => 9, + } + } + + /// The textual name. + pub fn name(self) -> &'static str { + match self { + Self::F16 => "f16", + Self::BF16 => "bf16", + Self::F32 => "f32", + Self::F64 => "f64", + Self::I8 => "i8", + Self::I16 => "i16", + Self::I32 => "i32", + Self::I64 => "i64", + } + } +} + +/// A concrete tile type, the value a declaration argument carries. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TileType { + /// Extents, one per dimension. + pub shape: Vec, + /// Element type. + pub element: ScalarType, +} + +impl TileType { + /// A tile of `shape` by `element`. + pub fn new(shape: Vec, element: ScalarType) -> Self { + Self { shape, element } + } + + /// Number of elements. + pub fn size(&self) -> i64 { + self.shape.iter().product() + } +} + +/// How a callee uses an argument. `out` and `inout` arguments are also the +/// declaration's results, in argument order. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum Access { + /// Read only. + In, + /// Written, not read. + Out, + /// Read and written. + InOut, +} + +impl Access { + /// The bytecode value. + pub(crate) fn value(self) -> u64 { + match self { + Self::In => 0, + Self::Out => 1, + Self::InOut => 2, + } + } + + /// The textual name. + pub fn name(self) -> &'static str { + match self { + Self::In => "in", + Self::Out => "out", + Self::InOut => "inout", + } + } + + /// Whether the callee writes the argument. + pub fn is_written(self) -> bool { + !matches!(self, Self::In) + } +} + +/// Where a fragment's buffer lives. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum MemorySpace { + /// Per-thread storage. + Local, + /// CTA shared memory. + Smem, +} + +impl MemorySpace { + pub(crate) fn value(self) -> u64 { + match self { + Self::Local => 0, + Self::Smem => 1, + } + } + + /// The textual name. + pub fn name(self) -> &'static str { + match self { + Self::Local => "local", + Self::Smem => "smem", + } + } +} + +/// The threads that call the native function together. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum Synchronization { + /// One thread per invocation. + None, + /// The 32 lanes of a warp. + Warp, + /// Four warps. + Warpgroup, + /// The whole CTA. + Cta, +} + +impl Synchronization { + pub(crate) fn value(self) -> u64 { + match self { + Self::None => 0, + Self::Warp => 1, + Self::Warpgroup => 2, + Self::Cta => 3, + } + } + + /// The textual name. + pub fn name(self) -> &'static str { + match self { + Self::None => "none", + Self::Warp => "warp", + Self::Warpgroup => "warpgroup", + Self::Cta => "cta", + } + } + + /// How many threads one invocation spans. + pub fn participants(self) -> i64 { + match self { + Self::None => 1, + Self::Warp => 32, + Self::Warpgroup => 128, + Self::Cta => 0, + } + } +} + +/// A concrete layout: `(shapes):(strides)`, integers only. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Layout { + /// Mode extents. + pub shapes: Vec, + /// Mode strides. + pub strides: Vec, +} + +impl Layout { + /// A layout from its shapes and strides. + pub fn flat(shapes: &[i64], strides: &[i64]) -> Self { + Self { + shapes: shapes.to_vec(), + strides: strides.to_vec(), + } + } + + /// The rank-0 buffer layout `():()` of a scalar passed by value. + pub fn scalar_mem() -> Self { + Self::flat(&[], &[]) + } + + /// The buffer layout `(F):(1)` of `footprint` contiguous elements. + pub fn contiguous_mem(footprint: i64) -> Self { + Self::flat(&[footprint], &[1]) + } + + /// One invocation per element, no participants: `(N, 1, 1):(1, 0, 0)`. + pub fn elementwise(tile_size: i64) -> Self { + Self::flat(&[tile_size, 1, 1], &[1, 0, 0]) + } + + /// Warp-synchronous, one element per lane: `(N/32, 32, 1):(32, 1, 0)`. + pub fn warp_lanes(tile_size: i64) -> Self { + Self::flat(&[tile_size / 32, 32, 1], &[32, 1, 0]) + } + + /// One invocation per block of `footprint` contiguous elements: + /// `(N/F, 1, F):(F, 0, 1)`. + pub fn footprint_blocks(tile_size: i64, footprint: i64) -> Self { + Self::flat(&[tile_size / footprint, 1, footprint], &[footprint, 0, 1]) + } + + /// Number of dimensions. + pub fn rank(&self) -> usize { + self.shapes.len() + } + + /// Product of the shapes. + pub fn size(&self) -> i64 { + self.shapes.iter().product() + } +} + +/// The fragment the native function receives for one declaration argument. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FragmentType { + /// Elements one invocation owns (its footprint), one extent per dimension. + pub shape: Vec, + /// Element type. + pub element: ScalarType, + /// Where the buffer lives. + pub memory_space: MemorySpace, + /// How the footprint sits in the buffer; rank 0 means passed by value. + pub mem_layout: Layout, + /// `(invocations, participants, footprint):(strides)` onto the tile. + pub fragmap: Layout, +} + +impl FragmentType { + /// A fragment from its parts. The alignment the bytecode carries is + /// always the default of one. + pub fn new( + shape: Vec, + element: ScalarType, + memory_space: MemorySpace, + mem_layout: Layout, + fragmap: Layout, + ) -> Self { + Self { + shape, + element, + memory_space, + mem_layout, + fragmap, + } + } + + /// Elements per invocation. + pub fn footprint(&self) -> i64 { + self.shape.iter().product() + } +} + +/// One argument of a declaration. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TileArg { + /// Argument name, printed as `%name`. + pub name: String, + /// The tile at the call boundary. + pub ty: TileType, + /// How the callee uses it. + pub access: Access, +} + +impl TileArg { + /// An argument from its parts. + pub fn new(name: impl Into, ty: TileType, access: Access) -> Self { + Self { + name: name.into(), + ty, + access, + } + } +} + +/// One argument of an implementation. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FragmentArg { + /// Argument name, printed as `%name`. + pub name: String, + /// The fragment the native function receives. + pub fragment: FragmentType, + /// Must equal the access of the matching declaration argument. + pub access: Access, +} + +impl FragmentArg { + /// An argument from its parts. + pub fn new(name: impl Into, fragment: FragmentType, access: Access) -> Self { + Self { + name: name.into(), + fragment, + access, + } + } +} + +/// An extern declaration: what a Tile kernel can call. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Declaration { + /// The symbol a `preview$call` names. + pub name: String, + /// Arguments in order; at least one. + pub args: Vec, +} + +impl Declaration { + /// A declaration from its name and arguments. + pub fn new(name: impl Into, args: Vec) -> Self { + Self { + name: name.into(), + args, + } + } + + /// The tiles the declaration returns: its written arguments, in order. + pub fn results(&self) -> impl Iterator { + self.args + .iter() + .filter(|arg| arg.access.is_written()) + .map(|arg| &arg.ty) + } +} + +/// An implementation: the native symbol the code payload defines and how +/// its parameters map onto a declaration's tiles. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Implementation { + /// The linked symbol. + pub symbol: String, + /// The declaration this implements. + pub implements: String, + /// One fragment per declaration argument, in order. + pub args: Vec, + /// The `synchronization` clause; `None` leaves the clause out, which + /// means one thread per invocation. + pub synchronization: Option, + /// Target names such as `sm_120`; empty matches every target. + pub arch: Vec, + /// `frontendABI` entries: printed type to native type. + pub frontend_abi: Vec<(String, String)>, +} + +impl Implementation { + /// An implementation with no optional clauses. + pub fn new( + symbol: impl Into, + implements: impl Into, + args: Vec, + ) -> Self { + Self { + symbol: symbol.into(), + implements: implements.into(), + args, + synchronization: None, + arch: Vec::new(), + frontend_abi: Vec::new(), + } + } +} + +/// A tile library's two halves, under one module name. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Library { + /// The `cuda_tile.module` name of both halves. + pub name: String, + /// The interface: what can be called. + pub declarations: Vec, + /// The catalog: how each declaration is implemented. + pub implementations: Vec, +} + +impl Library { + /// A library from its parts. + pub fn new( + name: impl Into, + declarations: Vec, + implementations: Vec, + ) -> Self { + Self { + name: name.into(), + declarations, + implementations, + } + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/src/text.rs b/cuda-oxide/crates/oxide-tilebc/src/text.rs new file mode 100644 index 0000000000..32073f2b6e --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/text.rs @@ -0,0 +1,134 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! The readable form of a library: the Tile IR textual syntax of both +//! modules, as the reference tools print it. It is written next to the +//! bytecode so a reader can see what the assembler will read. + +use std::fmt::Write as _; + +use crate::model::{Declaration, FragmentType, Implementation, Layout, Library, TileType}; + +fn layout(layout: &Layout) -> String { + let list = |values: &[i64]| { + values + .iter() + .map(|v| v.to_string()) + .collect::>() + .join(", ") + }; + format!( + "#cuda_tile.preview$layout<({}):({})>", + list(&layout.shapes), + list(&layout.strides) + ) +} + +fn tile(ty: &TileType) -> String { + let dims: Vec = ty.shape.iter().map(|d| d.to_string()).collect(); + format!("!cuda_tile.tile<{}x{}>", dims.join("x"), ty.element.name()) +} + +fn fragment(ty: &FragmentType) -> String { + let dims: Vec = ty.shape.iter().map(|d| d.to_string()).collect(); + format!( + "!cuda_tile.preview$fragment<{}x{}, {}, mem_layout = {}, fragmap = {}>", + dims.join("x"), + ty.element.name(), + ty.memory_space.name(), + layout(&ty.mem_layout), + layout(&ty.fragmap) + ) +} + +fn access(access: crate::model::Access) -> String { + format!( + "{{cuda_tile.preview$access = #cuda_tile.preview$access<{}>}}", + access.name() + ) +} + +fn declaration(decl: &Declaration) -> String { + let args: Vec = decl + .args + .iter() + .map(|arg| format!("%{}: {} {}", arg.name, tile(&arg.ty), access(arg.access))) + .collect(); + let results: Vec = decl.results().map(tile).collect(); + let results = match results.len() { + 1 => results[0].clone(), + _ => format!("({})", results.join(", ")), + }; + format!( + " cuda_tile.preview$func extern @{}({}) -> {}\n", + decl.name, + args.join(", "), + results + ) +} + +fn implementation(imp: &Implementation) -> String { + let args: Vec = imp + .args + .iter() + .map(|arg| { + format!( + "%{}: {} {}", + arg.name, + fragment(&arg.fragment), + access(arg.access) + ) + }) + .collect(); + let mut text = format!( + " cuda_tile.preview$extern_impl @{} implements @{}({})", + imp.symbol, + imp.implements, + args.join(", ") + ); + if let Some(sync) = imp.synchronization { + let _ = write!( + text, + "\n synchronization = #cuda_tile.preview$synchronization<{}>", + sync.name() + ); + } + if !imp.arch.is_empty() { + let names: Vec = imp.arch.iter().map(|name| format!("\"{name}\"")).collect(); + let _ = write!(text, "\n arch = [{}]", names.join(", ")); + } + if !imp.frontend_abi.is_empty() { + let entries: Vec = imp + .frontend_abi + .iter() + .map(|(key, value)| format!("{key} = \"{value}\"")) + .collect(); + let _ = write!(text, "\n {{frontendABI = {{{}}}}}", entries.join(", ")); + } + text.push('\n'); + text +} + +impl Library { + /// The interface module in textual Tile IR. + pub fn interface_text(&self) -> String { + let mut text = format!("cuda_tile.module @{} {{\n", self.name); + for decl in &self.declarations { + text.push_str(&declaration(decl)); + } + text.push_str("}\n"); + text + } + + /// The implementation module in textual Tile IR. + pub fn implementation_text(&self) -> String { + let mut text = format!("cuda_tile.module @{} {{\n", self.name); + for imp in &self.implementations { + text.push_str(&implementation(imp)); + } + text.push_str("}\n"); + text + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/src/verify.rs b/cuda-oxide/crates/oxide-tilebc/src/verify.rs new file mode 100644 index 0000000000..3cc124448b --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/verify.rs @@ -0,0 +1,360 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! The structural rules the Tile compiler's verifier applies when a library's +//! two halves meet, checked here before any bytecode is written so a mistake +//! is reported in terms of the description rather than of a deserialized +//! module. + +use std::collections::HashSet; + +use crate::Error; +use crate::model::{Access, Declaration, FragmentArg, Implementation, Library, MemorySpace}; + +fn is_identifier(text: &str) -> bool { + let mut chars = text.chars(); + matches!(chars.next(), Some(c) if c == '_' || c.is_ascii_alphabetic()) + && chars.all(|c| c == '_' || c.is_ascii_alphanumeric()) +} + +impl Library { + /// Check the library against the rules below; the first violation is + /// the error. + /// + /// - names are identifiers, unique among declarations and among symbols; + /// - a declaration has at least one argument, one dimension per tile, + /// and its written arguments form one contiguous run (the native + /// implementation path needs destination-passing results in order); + /// - every implementation names a declaration, with one fragment per + /// argument, the same access and element type; + /// - a fragment covers the tile: invocations times participants times + /// footprint equals the tile size, the footprint equals the fragment's + /// shape, a rank-0 buffer layout only for a read-only local fragment; + /// - the participants of every fragmap equal what the synchronization + /// clause promises (1 without a clause, 32 for a warp). + pub fn verify(&self) -> Result<(), Error> { + if !is_identifier(&self.name) { + return Err(Error::Verify(format!( + "module name `{}` is not an identifier", + self.name + ))); + } + let mut names = HashSet::new(); + for decl in &self.declarations { + verify_declaration(decl)?; + if !names.insert(decl.name.as_str()) { + return Err(Error::Verify(format!( + "declaration @{} appears twice", + decl.name + ))); + } + } + let mut symbols = HashSet::new(); + for imp in &self.implementations { + if !symbols.insert(imp.symbol.as_str()) { + return Err(Error::Verify(format!( + "implementation @{} appears twice", + imp.symbol + ))); + } + let decl = self + .declarations + .iter() + .find(|decl| decl.name == imp.implements) + .ok_or_else(|| { + Error::Verify(format!( + "implementation @{} implements @{}, which the interface does not declare", + imp.symbol, imp.implements + )) + })?; + verify_implementation(imp, decl)?; + } + Ok(()) + } +} + +fn verify_declaration(decl: &Declaration) -> Result<(), Error> { + let at = |message: String| Error::Verify(format!("declaration @{}: {message}", decl.name)); + if !is_identifier(&decl.name) { + return Err(Error::Verify(format!( + "declaration name `{}` is not an identifier", + decl.name + ))); + } + if decl.args.is_empty() { + return Err(at("a declaration needs at least one argument".into())); + } + let mut seen = HashSet::new(); + for arg in &decl.args { + if !is_identifier(&arg.name) { + return Err(at(format!( + "argument name `{}` is not an identifier", + arg.name + ))); + } + if !seen.insert(arg.name.as_str()) { + return Err(at(format!("argument `{}` appears twice", arg.name))); + } + if arg.ty.shape.len() != 1 { + return Err(at(format!( + "argument `{}` has {} dimensions; this writer emits one-dimensional tiles", + arg.name, + arg.ty.shape.len() + ))); + } + if arg.ty.shape[0] <= 0 { + return Err(at(format!( + "argument `{}` has a non-positive extent", + arg.name + ))); + } + } + let written: Vec = decl + .args + .iter() + .enumerate() + .filter(|(_, arg)| arg.access.is_written()) + .map(|(i, _)| i) + .collect(); + if written.is_empty() { + return Err(at( + "no argument is written; a declaration's results are its out and inout arguments" + .into(), + )); + } + if written.last().unwrap() - written[0] + 1 != written.len() { + return Err(at(format!( + "written arguments must form one contiguous run; `{}` sits between them", + decl.args[written[0] + 1..*written.last().unwrap()] + .iter() + .find(|arg| !arg.access.is_written()) + .map(|arg| arg.name.as_str()) + .unwrap_or("?") + ))); + } + Ok(()) +} + +fn verify_implementation(imp: &Implementation, decl: &Declaration) -> Result<(), Error> { + let at = |message: String| Error::Verify(format!("implementation @{}: {message}", imp.symbol)); + if !is_identifier(&imp.symbol) { + return Err(Error::Verify(format!( + "implementation symbol `{}` is not an identifier", + imp.symbol + ))); + } + if imp.args.len() != decl.args.len() { + return Err(at(format!( + "{} fragment arguments for the {} arguments of @{}", + imp.args.len(), + decl.args.len(), + decl.name + ))); + } + let participants = imp.synchronization.map_or(1, |sync| sync.participants()); + for (arg, decl_arg) in imp.args.iter().zip(&decl.args) { + verify_fragment(arg, decl_arg.ty.size(), decl_arg.ty.element, participants) + .map_err(|message| at(format!("argument `{}`: {message}", arg.name)))?; + if arg.access != decl_arg.access { + return Err(at(format!( + "argument `{}` is `{}` but the declaration says `{}`", + arg.name, + arg.access.name(), + decl_arg.access.name() + ))); + } + } + for name in &imp.arch { + if name.is_empty() { + return Err(at("an empty arch name".into())); + } + } + Ok(()) +} + +fn verify_fragment( + arg: &FragmentArg, + tile_size: i64, + element: crate::model::ScalarType, + participants: i64, +) -> Result<(), String> { + let fragment = &arg.fragment; + if fragment.element != element { + return Err(format!( + "fragment element type {} differs from the tile element type {}", + fragment.element.name(), + element.name() + )); + } + if fragment.shape.is_empty() || fragment.shape.iter().any(|d| *d <= 0) { + return Err("fragment shape must have positive extents".into()); + } + let footprint = fragment.footprint(); + let fragmap = &fragment.fragmap; + if fragmap.rank() != 3 || fragmap.strides.len() != 3 { + return Err(format!( + "fragmap must have three modes (invocations, participants, footprint), found {}", + fragmap.rank() + )); + } + if fragmap.shapes[2] != footprint { + return Err(format!( + "fragmap footprint {} differs from the fragment's {} elements", + fragmap.shapes[2], footprint + )); + } + if fragmap.size() != tile_size { + return Err(format!( + "fragmap covers {} elements of a {tile_size}-element tile", + fragmap.size() + )); + } + if participants != 0 && fragmap.shapes[1] != participants { + return Err(format!( + "fragmap has {} participants but the synchronization clause promises {participants}", + fragmap.shapes[1] + )); + } + let mem = &fragment.mem_layout; + if mem.shapes.len() != mem.strides.len() { + return Err("mem_layout shapes and strides differ in length".into()); + } + if mem.rank() == 0 { + if footprint != 1 { + return Err("a rank-0 mem_layout needs a one-element footprint".into()); + } + if arg.access != Access::In || fragment.memory_space != MemorySpace::Local { + return Err( + "a rank-0 mem_layout (passed by value) is only valid for a read-only local fragment" + .into(), + ); + } + } else if mem.size() != footprint { + return Err(format!( + "mem_layout spans {} elements but the footprint is {footprint}", + mem.size() + )); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use crate::model::*; + + fn tile() -> TileType { + TileType::new(vec![128], ScalarType::F32) + } + + fn scalar_fragment() -> FragmentType { + FragmentType::new( + vec![1], + ScalarType::F32, + MemorySpace::Local, + Layout::scalar_mem(), + Layout::elementwise(128), + ) + } + + fn pointer_fragment() -> FragmentType { + FragmentType::new( + vec![1], + ScalarType::F32, + MemorySpace::Local, + Layout::contiguous_mem(1), + Layout::elementwise(128), + ) + } + + fn relu() -> Library { + Library::new( + "lib", + vec![Declaration::new( + "relu", + vec![ + TileArg::new("x", tile(), Access::In), + TileArg::new("relu_out", tile(), Access::Out), + ], + )], + vec![Implementation::new( + "relu_impl", + "relu", + vec![ + FragmentArg::new("x", scalar_fragment(), Access::In), + FragmentArg::new("relu_out", pointer_fragment(), Access::Out), + ], + )], + ) + } + + #[test] + fn the_relu_library_verifies() { + relu().verify().unwrap(); + } + + #[test] + fn written_arguments_must_be_contiguous() { + let mut lib = relu(); + lib.declarations[0] + .args + .push(TileArg::new("y", tile(), Access::In)); + lib.declarations[0] + .args + .push(TileArg::new("z", tile(), Access::Out)); + let error = lib.verify().unwrap_err().to_string(); + assert!( + error.contains("contiguous run") && error.contains("`y`"), + "{error}" + ); + } + + #[test] + fn an_implementation_needs_its_declaration() { + let mut lib = relu(); + lib.implementations[0].implements = "gelu".into(); + let error = lib.verify().unwrap_err().to_string(); + assert!(error.contains("does not declare"), "{error}"); + } + + #[test] + fn access_and_coverage_are_checked() { + let mut lib = relu(); + lib.implementations[0].args[1].access = Access::InOut; + assert!( + lib.verify() + .unwrap_err() + .to_string() + .contains("`relu_out` is `inout`") + ); + + let mut lib = relu(); + lib.implementations[0].args[1].fragment.fragmap = Layout::elementwise(64); + assert!( + lib.verify() + .unwrap_err() + .to_string() + .contains("covers 64 elements") + ); + + let mut lib = relu(); + lib.implementations[0].synchronization = Some(Synchronization::Warp); + let error = lib.verify().unwrap_err().to_string(); + assert!( + error.contains("1 participants") && error.contains("promises 32"), + "{error}" + ); + lib.implementations[0].args[0].fragment.fragmap = Layout::warp_lanes(128); + lib.implementations[0].args[1].fragment.fragmap = Layout::warp_lanes(128); + lib.verify().unwrap(); + } + + #[test] + fn by_value_is_only_for_read_only_local_scalars() { + let mut lib = relu(); + lib.implementations[0].args[1].fragment.mem_layout = Layout::scalar_mem(); + let error = lib.verify().unwrap_err().to_string(); + assert!(error.contains("rank-0 mem_layout"), "{error}"); + } +} diff --git a/cuda-oxide/crates/oxide-tilebc/src/writer.rs b/cuda-oxide/crates/oxide-tilebc/src/writer.rs new file mode 100644 index 0000000000..1b787bf141 --- /dev/null +++ b/cuda-oxide/crates/oxide-tilebc/src/writer.rs @@ -0,0 +1,379 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! Serialize a library's two halves as Tile IR bytecode. +//! +//! The two modules only ever contain bodiless functions, so the file has +//! four sections: the function table (one entry per declaration or +//! implementation), the debug table (one unknown location per function), the +//! type table and the string table. Every encoding below was checked against +//! the reference reader's sources and against an assembler that reads 13.5 +//! content, which packs the output into a `.tilelib` with +//! `--preview-create-tile-lib`. +//! +//! ```text +//! header: 7F 'T' 'i' 'l' 'e' 'I' 'R' 00 | major | minor | tag u16 (bit 0: preview) +//! section Func (aligned 8): varint(n) then entries, padded to 8 +//! section Debug (aligned 8): per-function id lists, one unknown entry +//! section Type (aligned 4): varint(n), offsets, entries +//! section String(aligned 4): varint(n), offsets, bytes +//! end byte 00 +//! ``` + +use std::collections::HashMap; + +use crate::Error; +use crate::encoding::{ + CONTAINS_PREVIEW, MAGIC, Section, Writer, begin_offset_table, write_section, +}; +use crate::model::{ + Access, BytecodeVersion, Declaration, FragmentType, Implementation, Layout, Library, + ScalarType, TileType, +}; + +// Type-table tags. +const TAG_TILE: u64 = 13; +const TAG_FUNC: u64 = 16; +const TAG_FRAGMENT: u64 = 0xD2; + +// Attribute tags. +const ATTR_STRING: u64 = 5; +const ATTR_ARRAY: u64 = 6; +const ATTR_DICTIONARY: u64 = 10; +const ATTR_SYMBOLIC_INT: u64 = 0xD1; +const ATTR_SYMBOLIC_TUPLE: u64 = 0xD8; +const ATTR_LAYOUT: u64 = 0xD9; +const ATTR_ACCESS: u64 = 0xDF; + +/// The argument attribute that carries an access. +const ACCESS_ATTR: &str = "cuda_tile.preview$access"; + +// Function-table entry flags: bit 0 private, bit 1 kernel, bits 3:2 form. +const FLAG_PRIVATE: u8 = 0x01; +const FORM_EXTERN_IMPL: u8 = 0x04; + +// `preview$extern_impl` payload flag bits, in the op's declaration order. +const IMPL_ARG_ATTRS: u64 = 1 << 2; +const IMPL_ARCH: u64 = 1 << 6; +const IMPL_FRONTEND_ABI: u64 = 1 << 7; +const IMPL_SYNCHRONIZATION: u64 = 1 << 8; + +/// A type the type table can hold. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +enum Type { + Scalar(ScalarType), + Tile(TileType), + Fragment(FragmentType), + Func(Vec, Vec), +} + +/// Interning tables, filled in first-use order. +#[derive(Default)] +struct Tables { + strings: Vec, + string_index: HashMap, + types: Vec, + type_index: HashMap, +} + +impl Tables { + fn string(&mut self, text: &str) -> u64 { + if let Some(&index) = self.string_index.get(text) { + return index; + } + let index = self.strings.len() as u64; + self.strings.push(text.to_owned()); + self.string_index.insert(text.to_owned(), index); + index + } + + /// Register `ty`, its dependencies first, and return its index. + fn ty(&mut self, ty: &Type) -> u64 { + if let Some(&index) = self.type_index.get(ty) { + return index; + } + match ty { + Type::Scalar(_) => {} + Type::Tile(tile) => { + self.ty(&Type::Scalar(tile.element)); + } + Type::Fragment(fragment) => { + self.ty(&Type::Scalar(fragment.element)); + } + Type::Func(inputs, results) => { + for input in inputs { + self.ty(input); + } + for result in results { + self.ty(result); + } + } + } + let index = self.types.len() as u64; + self.types.push(ty.clone()); + self.type_index.insert(ty.clone(), index); + index + } +} + +/// `varint(count)` then each value as a tagged symbolic integer: the +/// payload of a `SymbolicTuple` and the inline form of a layout's modes. +fn write_int_tuple(w: &mut Writer, values: &[i64]) { + w.varint(values.len() as u64); + for &value in values { + w.varint(ATTR_SYMBOLIC_INT); + w.signed_varint(value); + } +} + +/// A layout attribute: tag, then the shapes and strides tuples inline. +fn write_layout(w: &mut Writer, layout: &Layout) { + w.varint(ATTR_LAYOUT); + write_int_tuple(w, &layout.shapes); + write_int_tuple(w, &layout.strides); +} + +/// The dictionary `{cuda_tile.preview$access = #access<..>}`, tagged. +fn write_access_dictionary(w: &mut Writer, tables: &mut Tables, access: Access) { + w.varint(ATTR_DICTIONARY); + w.varint(1); + w.varint(tables.string(ACCESS_ATTR)); + w.varint(ATTR_ACCESS); + w.varint(access.value()); +} + +/// `arg_attrs`: one access dictionary per argument. Tagged as an array for +/// a declaration (a positional field of the function table), inline (count +/// first, no array tag) inside an implementation's payload. +fn write_arg_attrs(w: &mut Writer, tables: &mut Tables, accesses: &[Access], tagged: bool) { + if tagged { + w.varint(ATTR_ARRAY); + } + w.varint(accesses.len() as u64); + for &access in accesses { + write_access_dictionary(w, tables, access); + } +} + +/// One type-table entry. +fn write_type(w: &mut Writer, tables: &mut Tables, ty: &Type) { + match ty { + Type::Scalar(scalar) => w.varint(u64::from(scalar.tag())), + Type::Tile(tile) => { + w.varint(TAG_TILE); + w.varint(tables.ty(&Type::Scalar(tile.element))); + w.le_var_size_i64(&tile.shape); + } + Type::Func(inputs, results) => { + w.varint(TAG_FUNC); + w.varint(inputs.len() as u64); + for input in inputs { + w.varint(tables.ty(input)); + } + w.varint(results.len() as u64); + for result in results { + w.varint(tables.ty(result)); + } + } + // Tagged empty symbolic shape (the shape is static), the static + // shape, element type, memory space, both layouts tagged, then the + // alignment as a tagged symbolic integer, always 1. + Type::Fragment(fragment) => { + w.varint(TAG_FRAGMENT); + w.varint(ATTR_SYMBOLIC_TUPLE); + w.varint(0); + w.le_var_size_i64(&fragment.shape); + w.varint(tables.ty(&Type::Scalar(fragment.element))); + w.varint(fragment.memory_space.value()); + write_layout(w, &fragment.mem_layout); + write_layout(w, &fragment.fragmap); + w.varint(ATTR_SYMBOLIC_INT); + w.signed_varint(1); + } + } +} + +fn declaration_signature(decl: &Declaration) -> Type { + Type::Func( + decl.args + .iter() + .map(|arg| Type::Tile(arg.ty.clone())) + .collect(), + decl.results().map(|ty| Type::Tile(ty.clone())).collect(), + ) +} + +fn implementation_signature(imp: &Implementation) -> Type { + Type::Func( + imp.args + .iter() + .map(|arg| Type::Fragment(arg.fragment.clone())) + .collect(), + Vec::new(), + ) +} + +/// A `preview$func extern` entry: normal form, private, body length zero, +/// then its (empty) constant parameters. +fn write_declaration(w: &mut Writer, tables: &mut Tables, decl: &Declaration, debug: u64) { + w.varint(tables.string(&decl.name)); + w.varint(tables.ty(&declaration_signature(decl))); + w.byte(FLAG_PRIVATE); + w.varint(debug); + let accesses: Vec = decl.args.iter().map(|arg| arg.access).collect(); + write_arg_attrs(w, tables, &accesses, true); + w.varint(0); + w.varint(ATTR_ARRAY); + w.varint(0); +} + +/// A `preview$extern_impl` entry: form bits 01, private, then the op +/// payload in place of a body (flags, symbols, type, the present optional +/// clauses, one empty region) and a body length of zero. +fn write_implementation(w: &mut Writer, tables: &mut Tables, imp: &Implementation, debug: u64) { + w.varint(tables.string(&imp.symbol)); + w.varint(tables.ty(&implementation_signature(imp))); + w.byte(FLAG_PRIVATE | FORM_EXTERN_IMPL); + w.varint(debug); + + let mut flags = IMPL_ARG_ATTRS; + if !imp.arch.is_empty() { + flags |= IMPL_ARCH; + } + if !imp.frontend_abi.is_empty() { + flags |= IMPL_FRONTEND_ABI; + } + if imp.synchronization.is_some() { + flags |= IMPL_SYNCHRONIZATION; + } + w.varint(flags); + w.varint(tables.string(&imp.symbol)); + w.varint(tables.string(&imp.implements)); + w.varint(tables.ty(&implementation_signature(imp))); + let accesses: Vec = imp.args.iter().map(|arg| arg.access).collect(); + write_arg_attrs(w, tables, &accesses, false); + if !imp.arch.is_empty() { + w.varint(imp.arch.len() as u64); + for name in &imp.arch { + w.varint(ATTR_STRING); + w.varint(tables.string(name)); + } + } + if !imp.frontend_abi.is_empty() { + w.varint(imp.frontend_abi.len() as u64); + for (key, value) in &imp.frontend_abi { + w.varint(tables.string(key)); + w.varint(ATTR_STRING); + w.varint(tables.string(value)); + } + } + if let Some(sync) = imp.synchronization { + w.varint(sync.value()); + } + // One region with zero blocks, then the zero body length. + w.varint(1); + w.varint(0); + w.varint(0); +} + +/// Per-function id lists (each holds one id 0, an unknown location) and the +/// single unknown attribute the reader expects a non-empty table to hold. +fn debug_section(functions: usize) -> Vec { + let mut w = Writer::new(); + w.varint(functions as u64); + w.align_to(4); + for index in 0..functions { + w.le_u32(index as u32); + } + w.varint(functions as u64); + w.align_to(8); + for _ in 0..functions { + w.le_u64(0); + } + w.varint(1); + w.align_to(4); + w.le_u32(0); + w.byte(0); + w.into_bytes() +} + +fn type_section(tables: &mut Tables) -> Vec { + let mut w = Writer::new(); + let count = tables.types.len(); + let offsets = begin_offset_table(&mut w, count); + let start = w.len(); + // Writing an entry can only reference types registered before it, so + // the table does not grow while it is serialized. + let types = tables.types.clone(); + for (index, ty) in types.iter().enumerate() { + w.patch_u32(offsets + 4 * index, (w.len() - start) as u32); + write_type(&mut w, tables, ty); + } + debug_assert_eq!(tables.types.len(), count); + w.into_bytes() +} + +fn string_section(tables: &Tables) -> Vec { + let mut w = Writer::new(); + let offsets = begin_offset_table(&mut w, tables.strings.len()); + let mut running = 0u32; + for (index, text) in tables.strings.iter().enumerate() { + w.patch_u32(offsets + 4 * index, running); + w.bytes(text.as_bytes()); + running += text.len() as u32; + } + w.into_bytes() +} + +fn write_module( + version: BytecodeVersion, + entries: usize, + mut write_entries: impl FnMut(&mut Writer, &mut Tables), +) -> Result, Error> { + if version < BytecodeVersion::PREVIEW_FIRST { + return Err(Error::Version(version)); + } + let mut tables = Tables::default(); + let mut functions = Writer::new(); + functions.varint(entries as u64); + write_entries(&mut functions, &mut tables); + functions.align_to(8); + + let mut out = MAGIC.to_vec(); + out.push(version.major); + out.push(version.minor); + out.extend_from_slice(&CONTAINS_PREVIEW.to_le_bytes()); + write_section(&mut out, Section::Func, &functions.into_bytes(), 8); + write_section(&mut out, Section::Debug, &debug_section(entries), 8); + write_section(&mut out, Section::Type, &type_section(&mut tables), 4); + write_section(&mut out, Section::String, &string_section(&tables), 4); + out.push(Section::EndOfBytecode as u8); + Ok(out) +} + +impl Library { + /// The interface half: every declaration as a `preview$func extern`. + /// + /// `version` must be the one the consuming assembler calls current; + /// preview content is readable at no other version. Anything below + /// 13.5 is an error. + pub fn interface_bytecode(&self, version: BytecodeVersion) -> Result, Error> { + write_module(version, self.declarations.len(), |w, tables| { + for (index, decl) in self.declarations.iter().enumerate() { + write_declaration(w, tables, decl, index as u64 + 1); + } + }) + } + + /// The implementation half: every implementation as a + /// `preview$extern_impl`. + pub fn implementation_bytecode(&self, version: BytecodeVersion) -> Result, Error> { + write_module(version, self.implementations.len(), |w, tables| { + for (index, imp) in self.implementations.iter().enumerate() { + write_implementation(w, tables, imp, index as u64 + 1); + } + }) + } +} diff --git a/cuda-oxide/crates/reserved-oxide-symbols/README.md b/cuda-oxide/crates/reserved-oxide-symbols/README.md index cc8e0ad98d..0acc711a93 100644 --- a/cuda-oxide/crates/reserved-oxide-symbols/README.md +++ b/cuda-oxide/crates/reserved-oxide-symbols/README.md @@ -17,7 +17,7 @@ Every symbol prefix here contains the magic component `246e25db_`, which is exists purely to make accidental collisions impossible — a user is never going to write `fn cuda_oxide_codegen_v1_cuda_oxide_kernel_246e25db_foo()` by accident. -The crate owns these ten symbol constants. The `naming-guard` CI job keeps +The crate owns these eleven symbol constants. The `naming-guard` CI job keeps reserved-prefix literals out of their consumers: | Constant | Value | What it names | @@ -27,6 +27,7 @@ reserved-prefix literals out of their consumers: | `DEVICE_EXTERN_PREFIX` | `cuda_oxide_device_extern_246e25db_` | `extern` device declarations | | `INSTANTIATE_PREFIX` | `cuda_oxide_instantiate_246e25db_` | forced generic instantiations | | `CONSTANT_PREFIX` | `cuda_oxide_const_246e25db_` | `#[constant]` statics, for `cuModuleGetGlobal` lookup | +| `TILE_EXPORT_META_PREFIX` | `cuda_oxide_tile_export_246e25db_` | host-only `#[tile_export]` metadata functions whose body returns the export's JSON description | | `KERNEL_SCOPE_LOCAL` | `cuda_oxide_kernel_scope_246e25db` | the hidden thread-index scope token injected by `#[kernel]` / `#[device]` | | `ARTIFACT_ANCHOR_PREFIX` | `cuda_oxide_artifact_anchor_246e25db_` | the link anchor pinning a crate's `.oxart` section into the binary | | `PTX_MERGE_REQUIRED_PREFIX` | `cuda_oxide_ptx_merge_required_246e25db_` | statics marking modules whose generic kernels need PTX-bundle merging | diff --git a/cuda-oxide/crates/reserved-oxide-symbols/src/lib.rs b/cuda-oxide/crates/reserved-oxide-symbols/src/lib.rs index f21877ee87..010bc715d2 100644 --- a/cuda-oxide/crates/reserved-oxide-symbols/src/lib.rs +++ b/cuda-oxide/crates/reserved-oxide-symbols/src/lib.rs @@ -161,6 +161,22 @@ pub const INSTANTIATE_PREFIX: &str = "cuda_oxide_instantiate_246e25db_"; /// `set_coeffs` methods generated by `#[cuda_module]` resolve that exact name. pub const CONSTANT_PREFIX: &str = "cuda_oxide_const_246e25db_"; +/// Prefix of the host-only metadata function emitted by `#[tile_export]`. +/// +/// `tile_export_meta_symbol("relu_impl")` produces +/// `cuda_oxide_tile_export_246e25db_relu_impl`. The macro emits one such +/// `#[no_mangle] fn` per exported function; its body returns the JSON +/// description of the export as a `&'static str`. The codegen backend reads +/// that constant out of the function's MIR, writes the collected descriptions +/// to `.tileexports.json` next to the device artifact, and never +/// compiles the function itself for the device. +/// +/// The prefix contains neither [`LEGACY_KERNEL_PREFIX`] nor +/// [`LEGACY_DEVICE_PREFIX`] as a substring, so [`is_kernel_symbol`] and +/// [`is_device_symbol`] can never classify a metadata function as device +/// code. A unit test below pins that property. +pub const TILE_EXPORT_META_PREFIX: &str = "cuda_oxide_tile_export_246e25db_"; + /// Local binding name injected by `#[kernel]` and `#[device]` for the /// hidden thread-index scope token. pub const KERNEL_SCOPE_LOCAL: &str = "cuda_oxide_kernel_scope_246e25db"; @@ -266,6 +282,20 @@ pub fn constant_symbol(base: &str) -> String { format!("{CONSTANT_PREFIX}{base}") } +/// Build the `#[tile_export]` metadata-function symbol for an implementation +/// symbol. +/// +/// ``` +/// use reserved_oxide_symbols::tile_export_meta_symbol; +/// assert_eq!( +/// tile_export_meta_symbol("relu_impl"), +/// "cuda_oxide_tile_export_246e25db_relu_impl", +/// ); +/// ``` +pub fn tile_export_meta_symbol(base: &str) -> String { + format!("{TILE_EXPORT_META_PREFIX}{base}") +} + /// Build the compiler marker associated with one generic kernel. pub fn ptx_merge_required_marker(base: &str) -> String { let mut symbol = String::from(PTX_MERGE_REQUIRED_PREFIX); @@ -459,6 +489,26 @@ pub fn is_constant_symbol(name: &str) -> bool { name.contains(CONSTANT_PREFIX) } +/// Returns `true` if the last path component of `name` is a `#[tile_export]` +/// metadata function. +/// +/// Matches the final `::` component only, like +/// [`is_ptx_merge_required_marker`]: the backend looks these functions up by +/// definition path, and an enclosing module named after the prefix must not +/// turn its contents into metadata functions. +/// +/// ``` +/// use reserved_oxide_symbols::{is_tile_export_meta_symbol, tile_export_meta_symbol}; +/// assert!(is_tile_export_meta_symbol(&tile_export_meta_symbol("relu_impl"))); +/// assert!(is_tile_export_meta_symbol( +/// "tilelib::cuda_oxide_tile_export_246e25db_relu_impl" +/// )); +/// assert!(!is_tile_export_meta_symbol("relu_impl")); +/// ``` +pub fn is_tile_export_meta_symbol(name: &str) -> bool { + tile_export_meta_base_name(name).is_some() +} + /// Strip the kernel prefix from a possibly-FQDN symbol name. /// /// Returns the part of `name` after [`KERNEL_PREFIX`], or `None` if `name` @@ -551,6 +601,8 @@ pub fn display_name(name: &str) -> Option { Some(format!("{base} (device)")) } else if let Some(base) = constant_base_name(name) { Some(format!("{base} (constant)")) + } else if let Some(base) = tile_export_meta_base_name(name) { + Some(format!("{base} (tile export metadata)")) } else { instantiate_base_name(name).map(|base| format!("{base} (instantiate helper)")) } @@ -589,6 +641,29 @@ pub fn constant_base_name(name: &str) -> Option<&str> { .map(|pos| &name[pos + CONSTANT_PREFIX.len()..]) } +/// Strip the `#[tile_export]` metadata prefix from the last path component +/// of `name`, returning the implementation symbol it describes. +/// +/// ``` +/// use reserved_oxide_symbols::tile_export_meta_base_name; +/// assert_eq!( +/// tile_export_meta_base_name("cuda_oxide_tile_export_246e25db_relu_impl"), +/// Some("relu_impl"), +/// ); +/// assert_eq!( +/// tile_export_meta_base_name("tilelib::kernels::cuda_oxide_tile_export_246e25db_scale_impl"), +/// Some("scale_impl"), +/// ); +/// assert_eq!(tile_export_meta_base_name("relu_impl"), None); +/// assert_eq!(tile_export_meta_base_name("cuda_oxide_tile_export_246e25db_"), None); +/// ``` +pub fn tile_export_meta_base_name(name: &str) -> Option<&str> { + name.rsplit("::") + .next() + .and_then(|component| component.strip_prefix(TILE_EXPORT_META_PREFIX)) + .filter(|base| !base.is_empty()) +} + // ============================================================================ // Tests — pin the constant values, verify mutual-exclusion, round-trip // ============================================================================ @@ -617,6 +692,7 @@ mod tests { assert_eq!(DEVICE_EXTERN_PREFIX, "cuda_oxide_device_extern_246e25db_"); assert_eq!(INSTANTIATE_PREFIX, "cuda_oxide_instantiate_246e25db_"); assert_eq!(CONSTANT_PREFIX, "cuda_oxide_const_246e25db_"); + assert_eq!(TILE_EXPORT_META_PREFIX, "cuda_oxide_tile_export_246e25db_"); assert_eq!( PTX_MERGE_REQUIRED_PREFIX, "cuda_oxide_ptx_merge_required_246e25db_" @@ -660,6 +736,7 @@ mod tests { DEVICE_EXTERN_PREFIX, INSTANTIATE_PREFIX, CONSTANT_PREFIX, + TILE_EXPORT_META_PREFIX, PTX_MERGE_REQUIRED_PREFIX, ARTIFACT_ANCHOR_PREFIX, KERNEL_SCOPE_LOCAL, @@ -683,6 +760,45 @@ mod tests { assert!(!DEVICE_PREFIX.contains(DEVICE_EXTERN_PREFIX)); } + /// The backend finds `#[tile_export]` metadata functions by definition + /// path and must never hand one to device codegen. That holds because + /// the prefix contains no kernel or device prefix, current or legacy, + /// so the device predicates cannot match a metadata symbol, and because + /// the metadata predicate only looks at the final path component. + #[test] + fn tile_export_meta_symbols_are_neither_kernels_nor_device_functions() { + for device_like in [ + KERNEL_PREFIX, + LEGACY_KERNEL_PREFIX, + DEVICE_PREFIX, + LEGACY_DEVICE_PREFIX, + DEVICE_EXTERN_PREFIX, + ] { + assert!(!TILE_EXPORT_META_PREFIX.contains(device_like)); + assert!(!device_like.contains(TILE_EXPORT_META_PREFIX)); + } + + let meta = tile_export_meta_symbol("relu_impl"); + assert!(is_tile_export_meta_symbol(&meta)); + assert!(!is_kernel_symbol(&meta)); + assert!(!is_device_symbol(&meta)); + assert!(!is_device_extern_symbol(&meta)); + assert!(!is_constant_symbol(&meta)); + assert_eq!(tile_export_meta_base_name(&meta), Some("relu_impl")); + + // A device function and a kernel are not metadata functions. + assert!(!is_tile_export_meta_symbol(&device_symbol("relu_impl"))); + assert!(!is_tile_export_meta_symbol(&kernel_symbol("relu"))); + + // Only the final path component counts. + assert!(is_tile_export_meta_symbol(&format!( + "tilelib::kernels::{meta}" + ))); + assert!(!is_tile_export_meta_symbol(&format!("{meta}::child"))); + assert!(!is_tile_export_meta_symbol(&format!("prefix_{meta}"))); + assert!(!is_tile_export_meta_symbol(TILE_EXPORT_META_PREFIX)); + } + #[test] fn ptx_merge_markers_are_per_kernel_and_sanitized() { let marker = ptx_merge_required_marker("nested::map-value"); @@ -738,6 +854,10 @@ mod tests { ); assert_eq!(instantiate_base_name(&instantiate_symbol(base)), Some(base),); assert_eq!(constant_base_name(&constant_symbol(base)), Some(base)); + assert_eq!( + tile_export_meta_base_name(&tile_export_meta_symbol(base)), + Some(base) + ); } } @@ -851,6 +971,10 @@ mod tests { display_name(&constant_symbol("COEFFS")).as_deref(), Some("COEFFS (constant)"), ); + assert_eq!( + display_name(&tile_export_meta_symbol("relu_impl")).as_deref(), + Some("relu_impl (tile export metadata)"), + ); assert_eq!(display_name("std::vec::Vec::new"), None); } @@ -865,12 +989,17 @@ mod tests { "cuda_oxide_device_extern_evil", "cuda_oxide_instantiate_evil", "cuda_oxide_const_evil", + "cuda_oxide_tile_export_evil", ] { assert!(!is_kernel_symbol(evil), "unexpected match: {evil}"); assert!(!is_device_symbol(evil), "unexpected match: {evil}"); assert!(!is_device_extern_symbol(evil), "unexpected match: {evil}"); assert!(!is_instantiate_symbol(evil), "unexpected match: {evil}"); assert!(!is_constant_symbol(evil), "unexpected match: {evil}"); + assert!( + !is_tile_export_meta_symbol(evil), + "unexpected match: {evil}" + ); assert_eq!(display_name(evil), None); } } diff --git a/cuda-oxide/crates/rustc-codegen-cuda/.gitignore b/cuda-oxide/crates/rustc-codegen-cuda/.gitignore index f528657c89..e80f489098 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/.gitignore +++ b/cuda-oxide/crates/rustc-codegen-cuda/.gitignore @@ -7,6 +7,14 @@ rustc-ice-*.txt # Generated PTX/LLVM files *.ptx *.ll +# Tile export descriptions written next to them +*.tileexports.json +# Tile library descriptions and the library itself (cargo oxide tilelib) +*.tilebc +*.tilelib +*.tilelib.mlir +# Mock Tile-compiler callers that tile library examples generate when they run +examples/*/mock/ # Implementation log (internal notes) IMPLEMENTATION.md diff --git a/cuda-oxide/crates/rustc-codegen-cuda/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/Cargo.lock index 67a4e596a7..30afd8262e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/Cargo.lock @@ -588,6 +588,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "pliron" version = "0.20.0" @@ -746,6 +755,7 @@ dependencies = [ "mir-lower", "once_cell", "oxide-artifacts", + "oxide-tile-export", "pliron", "pliron-derive", "reserved-oxide-symbols", diff --git a/cuda-oxide/crates/rustc-codegen-cuda/Cargo.toml b/cuda-oxide/crates/rustc-codegen-cuda/Cargo.toml index 2d724fb74c..c20211c939 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/Cargo.toml +++ b/cuda-oxide/crates/rustc-codegen-cuda/Cargo.toml @@ -24,6 +24,8 @@ llvm-export = { path = "../llvm-export" } dialect-mir = { path = "../dialect-mir" } dialect-nvvm = { path = "../dialect-nvvm" } reserved-oxide-symbols = { path = "../reserved-oxide-symbols" } +# `#[tile_export]` descriptions, read back out of the metadata functions' MIR. +oxide-tile-export = { path = "../oxide-tile-export" } oxide-artifacts = { version = "0.2.1", features = ["object-write"] } # Shared driver-independent libNVVM + nvJitLink finalization policy. This # crate loads CUDA compiler libraries at run time and never links libcuda. diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/abi_hmm/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/abi_hmm/Cargo.lock index 1d51a50e54..ce0fdb7a46 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/abi_hmm/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/abi_hmm/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/addressof_sharedarray/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/addressof_sharedarray/Cargo.lock index b8e441c59e..298682ebe7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/addressof_sharedarray/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/addressof_sharedarray/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_loads/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_loads/Cargo.lock index 0b75539022..f5335376d4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_loads/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_loads/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_stores/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_stores/Cargo.lock index 502e06c899..4c5f7cb96a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_stores/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/aligned_field_stores/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_constants/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_constants/Cargo.lock index 708068528d..ef1ecaa2a8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_constants/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_constants/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_for_loop/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_for_loop/Cargo.lock index 0c024bb8a5..3d737175ef 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_for_loop/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_for_loop/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_index/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_index/Cargo.lock index e83e8a8704..d3a3501bfa 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_index/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_index/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_init/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_init/Cargo.lock index b93c70c05f..86fba05561 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/array_init/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/array_init/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/asin_acos_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/asin_acos_smoke/Cargo.lock index 0401eff7d5..802b3b906e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/asin_acos_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/asin_acos_smoke/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/assume_init_uninhabited_trap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/assume_init_uninhabited_trap/Cargo.lock index 248ff82b0f..3adf8ffba8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/assume_init_uninhabited_trap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/assume_init_uninhabited_trap/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/async_mlp/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/async_mlp/Cargo.lock index 22a8b4bc2c..7028e34dbe 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/async_mlp/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/async_mlp/Cargo.lock @@ -217,6 +217,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -443,6 +444,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -558,6 +565,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.18", +] + [[package]] name = "parking_lot_core" version = "0.9.12" @@ -712,6 +728,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -950,3 +979,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/async_vecadd/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/async_vecadd/Cargo.lock index 902af286c7..2174866807 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/async_vecadd/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/async_vecadd/Cargo.lock @@ -217,6 +217,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -443,6 +444,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -558,6 +565,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.18", +] + [[package]] name = "parking_lot_core" version = "0.9.12" @@ -712,6 +728,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -950,3 +979,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/atomic_f16/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/atomic_f16/Cargo.lock index 25e548ea3b..b9a5b8237d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/atomic_f16/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/atomic_f16/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/atomics/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/atomics/Cargo.lock index 011e726425..88b7fea84b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/atomics/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/atomics/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/barrier/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/barrier/Cargo.lock index f17829532f..8b838a20e4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/barrier/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/barrier/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_arith/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_arith/Cargo.lock index 31c36820b6..de59e51102 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_arith/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_arith/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_fma/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_fma/Cargo.lock index 4edfd7f252..251e9a2a67 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_fma/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/bf16x2_fma/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/bool_phi_cmp/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/bool_phi_cmp/Cargo.lock index 876fb8c273..670e54de0c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/bool_phi_cmp/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/bool_phi_cmp/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/carrying_mul_add/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/carrying_mul_add/Cargo.lock index c41a3f5c30..c07608a163 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/carrying_mul_add/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/carrying_mul_add/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_chunks/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_chunks/Cargo.lock index 0476d620a1..7354ec93d3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_chunks/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_chunks/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_tests/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_tests/Cargo.lock index a885f34945..5a0f4f1248 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_tests/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cast_tests/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cbrt_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cbrt_smoke/Cargo.lock index 6250c3b0b7..3dac7b1997 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cbrt_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cbrt_smoke/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/checked_arith/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/checked_arith/Cargo.lock index 22a605d5c9..aef438f58d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/checked_arith/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/checked_arith/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/clc/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/clc/Cargo.lock index 6409d9f788..b2358c8f96 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/clc/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/clc/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cluster/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cluster/Cargo.lock index 53a895695a..428561d84b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cluster/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cluster/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/compiler_features/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/compiler_features/Cargo.lock index 70deb8c7c7..33acd7147e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/compiler_features/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/compiler_features/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/complex_mul/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/complex_mul/Cargo.lock index 60eb1baa31..c4fa3cf464 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/complex_mul/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/complex_mul/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_aggregate/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_aggregate/Cargo.lock index 3ef71976cc..6ea623f850 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_aggregate/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_aggregate/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_bool_dead_branch/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_bool_dead_branch/Cargo.lock index 41fabb1728..91b2876e08 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_bool_dead_branch/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_bool_dead_branch/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_generic/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_generic/Cargo.lock index ccc08f96f2..b15a635b4c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_generic/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_generic/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_table_lookup/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_table_lookup/Cargo.lock index 26fb53caca..8ae82696df 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_table_lookup/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_table_lookup/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_tuple_table_lookup/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_tuple_table_lookup/Cargo.lock index 12a18ab687..53037c381d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/const_tuple_table_lookup/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/const_tuple_table_lookup/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_index_from_end/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_index_from_end/Cargo.lock index 4470121240..ab06a74fe1 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_index_from_end/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_index_from_end/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory/Cargo.lock index 6e8890fbf5..441dc70016 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_coeffs/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_coeffs/Cargo.lock index ac248d8bb3..cbd2c4a773 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_coeffs/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_coeffs/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_simple/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_simple/Cargo.lock index 98e2a8c034..8656b34c60 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_simple/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_simple/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_table/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_table/Cargo.lock index 7c62ceae52..e1b980e909 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_table/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/constant_memory_table/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/coop_groups_demo/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/coop_groups_demo/Cargo.lock index dcca83bb32..cd1195cbd1 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/coop_groups_demo/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/coop_groups_demo/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_aggregate_borrow/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_aggregate_borrow/Cargo.lock index fdaba39cbd..0ef4472db0 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_aggregate_borrow/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_aggregate_borrow/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_nonoverlapping/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_nonoverlapping/Cargo.lock index e583f5fddb..03fc3fb565 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_nonoverlapping/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/copy_nonoverlapping/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/counted_barrier/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/counted_barrier/Cargo.lock index d6e529758d..ee38589b3f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/counted_barrier/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/counted_barrier/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_small/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_small/Cargo.lock index 0641ecb7ab..8884ed45e2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_small/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_small/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_zfill/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_zfill/Cargo.lock index 19b846ea77..4c768d4fe9 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_zfill/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cp_async_zfill/Cargo.lock @@ -193,6 +193,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cpp_consumes_rust_device/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cpp_consumes_rust_device/Cargo.lock index 059f389beb..51381eb264 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cpp_consumes_rust_device/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cpp_consumes_rust_device/Cargo.lock @@ -192,6 +192,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -310,6 +311,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -416,6 +423,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -530,6 +546,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -715,3 +744,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_embedded/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_embedded/Cargo.lock index 5d37f456da..58f9f47452 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_embedded/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_embedded/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -321,6 +322,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -427,6 +434,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -541,6 +557,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -726,3 +755,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_kernel/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_kernel/Cargo.lock index 8aa5c60c45..4142ea1aa4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_kernel/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_kernel/Cargo.lock @@ -195,6 +195,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -313,6 +314,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "kernel-lib" version = "0.1.0" @@ -428,6 +435,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -542,6 +558,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -727,3 +756,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_merged_symbols/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_merged_symbols/Cargo.lock index 7d6afea4d1..12297db68c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_merged_symbols/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_merged_symbols/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -427,6 +434,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -541,6 +557,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -726,3 +755,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_recursion/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_recursion/Cargo.lock index 304d4f8738..8f2b797d96 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_recursion/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cross_crate_recursion/Cargo.lock @@ -194,6 +194,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_contract/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_contract/Cargo.lock index b7ccbf3cd6..08be6237f6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_contract/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_contract/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_in_lib/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_in_lib/Cargo.lock index aedf8ee1f5..ed02b84ccf 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_in_lib/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_in_lib/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -427,6 +434,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -541,6 +557,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -726,3 +755,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_nested/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_nested/Cargo.lock index 15fa7deaa9..971388c6c3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_nested/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cuda_module_nested/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/Cargo.lock index 79a4f6425a..fe8a69f59d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/Cargo.lock @@ -905,9 +905,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.150" +version = "1.0.154" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" dependencies = [ "itoa", "memchr", @@ -1403,6 +1403,6 @@ dependencies = [ [[package]] name = "zmij" -version = "1.0.21" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/simt/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/simt/Cargo.lock index b6bb84c873..35aaf4c667 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/simt/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cutile_inter_kernel/simt/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_f16x2/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_f16x2/Cargo.lock index 41761b8893..818576913e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_f16x2/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_f16x2/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_packed/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_packed/Cargo.lock index be34c2de32..94d0618251 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_packed/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/cvt_packed/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug-tests/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug-tests/Cargo.lock index f66d568a2c..f5df8eec21 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug-tests/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug-tests/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug/Cargo.lock index c45afc11ea..06c9f62bfd 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug_pointer_locals/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug_pointer_locals/Cargo.lock index ff0ba980c8..a163c07916 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/debug_pointer_locals/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/debug_pointer_locals/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_closures/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_closures/Cargo.lock index fbfc3fe9d0..a71448a33a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_closures/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_closures/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_ffi_test/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_ffi_test/Cargo.lock index f9a370b1fd..a158e03b8d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_ffi_test/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_ffi_test/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_global/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_global/Cargo.lock index d9f51af73f..35ee0cd474 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_global/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_global/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_panic_trap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_panic_trap/Cargo.lock index abbccc4d8d..6407c721d4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/device_panic_trap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/device_panic_trap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_from_raw_parts/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_from_raw_parts/Cargo.lock index 99e58cf0fa..16f5eeea64 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_from_raw_parts/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_from_raw_parts/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_slice_len/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_slice_len/Cargo.lock index b57449f344..dd634310c2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_slice_len/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/disjoint_slice_len/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/dotprod/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/dotprod/Cargo.lock index 927e35e5b9..6eae6d938e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/dotprod/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/dotprod/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/dpx_minmax_chains/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/dpx_minmax_chains/Cargo.lock index 3986154648..e089b4e94a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/dpx_minmax_chains/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/dpx_minmax_chains/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/drop_glue/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/drop_glue/Cargo.lock index 092d9bad63..266b7f6694 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/drop_glue/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/drop_glue/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/dst_metadata/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/dst_metadata/Cargo.lock index 663fe0e1e4..9c6fb2bc3e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/dst_metadata/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/dst_metadata/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/dynamic_smem/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/dynamic_smem/Cargo.lock index f1f4b2c026..d00f6456ab 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/dynamic_smem/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/dynamic_smem/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/elect_leader/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/elect_leader/Cargo.lock index f5ce40a552..24b95937f2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/elect_leader/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/elect_leader/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_abi_multi_payload/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_abi_multi_payload/Cargo.lock index 55fa067ced..6139e1050f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_abi_multi_payload/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_abi_multi_payload/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_array_match/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_array_match/Cargo.lock index 34e21c7c8e..4985ca6d9f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_array_match/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_array_match/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_constant_provenance/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_constant_provenance/Cargo.lock index 24abb1e836..8af4e5d135 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_constant_provenance/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_constant_provenance/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_payload_addr/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_payload_addr/Cargo.lock index 1966983afe..c952ef0989 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_payload_addr/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_payload_addr/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_state_transitions/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_state_transitions/Cargo.lock index 4d1eb8f254..3a6c6a60cc 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_state_transitions/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_state_transitions/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_table_lookup/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_table_lookup/Cargo.lock index 795acb9cd4..984dd1bb34 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_table_lookup/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/enum_table_lookup/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error/Cargo.lock index ae7af048ac..aaa54e5982 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_bool_payload_addr/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_bool_payload_addr/Cargo.lock index c7bd9ac758..ce15431ac5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_bool_payload_addr/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_bool_payload_addr/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_pointer_overlap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_pointer_overlap/Cargo.lock index 5e1649b078..0fa3b0a4ee 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_pointer_overlap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_pointer_overlap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_shared_pointer_layout/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_shared_pointer_layout/Cargo.lock index a8d8bd3db7..f06797a06b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_shared_pointer_layout/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_enum_shared_pointer_layout/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_abi/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_abi/Cargo.lock index 4d24441cc8..4c5a1cecc5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_abi/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_abi/Cargo.lock @@ -188,6 +188,7 @@ version = "99.0.2" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -315,6 +316,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -421,6 +428,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -535,6 +551,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -720,3 +749,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_callable/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_callable/Cargo.lock index ac775b6804..edd815e111 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_callable/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_callable/Cargo.lock @@ -188,6 +188,7 @@ version = "0.1.0" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -315,6 +316,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -421,6 +428,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -535,6 +551,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -720,3 +749,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_fn_pointer/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_fn_pointer/Cargo.lock index a471e93a9f..d5446db5d0 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_fn_pointer/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_fn_pointer/Cargo.lock @@ -188,6 +188,7 @@ version = "0.1.0" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -315,6 +316,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -421,6 +428,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -535,6 +551,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -720,3 +749,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_unknown_id/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_unknown_id/Cargo.lock index 25462fd135..9b25129d83 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_unknown_id/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_generated_intrinsic_unknown_id/Cargo.lock @@ -188,6 +188,7 @@ version = "99.0.1" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -315,6 +316,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -421,6 +428,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -535,6 +551,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -720,3 +749,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_heap_alloc/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_heap_alloc/Cargo.lock index 25827662ff..1a466544e6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_heap_alloc/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_heap_alloc/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_arch_intrinsic/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_arch_intrinsic/Cargo.lock index 5319a897c1..7191053847 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_arch_intrinsic/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_arch_intrinsic/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_target_feature/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_target_feature/Cargo.lock index 360a02431e..3219ee0d34 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_target_feature/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_host_target_feature/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_kernel_shared_param/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_kernel_shared_param/Cargo.lock index c04672d297..44916f1a99 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_kernel_shared_param/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_kernel_shared_param/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_missing_device_attr/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_missing_device_attr/Cargo.lock index 91997eec33..649e784194 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_missing_device_attr/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_missing_device_attr/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_set_discriminant_uninhabited/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_set_discriminant_uninhabited/Cargo.lock index 2a2d387203..5c81d90910 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_set_discriminant_uninhabited/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_set_discriminant_uninhabited/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_addr/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_addr/Cargo.lock index afe82ce12d..746e3e1063 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_addr/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_addr/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_layout/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_layout/Cargo.lock index 5710aaf5ca..ac804086d6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_layout/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/error_union_shared_pointer_layout/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ex2_approx_f16/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ex2_approx_f16/Cargo.lock index 2b169c6980..33cd0aa21e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ex2_approx_f16/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ex2_approx_f16/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/exact_div_chunks/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/exact_div_chunks/Cargo.lock index 87a392571e..93a2a2860b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/exact_div_chunks/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/exact_div_chunks/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/export_name_policy/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/export_name_policy/Cargo.lock index a5cf5dbb4b..ad50057c7b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/export_name_policy/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/export_name_policy/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_crate_closure/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_crate_closure/Cargo.lock index e45f61411e..a3de61cf65 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_crate_closure/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_crate_closure/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -316,6 +317,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -422,6 +429,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_libdevice/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_libdevice/Cargo.lock index e35322740d..676af798d0 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_libdevice/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/extern_libdevice/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/f16_stress/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/f16_stress/Cargo.lock index ba6233de9b..1981d414f2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/f16_stress/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/f16_stress/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/f16x2_arith/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/f16x2_arith/Cargo.lock index d3dc0ec184..31579841ea 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/f16x2_arith/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/f16x2_arith/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/f32x2_arith/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/f32x2_arith/Cargo.lock index 9df6fbcb48..9bc296863f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/f32x2_arith/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/f32x2_arith/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/fcmp_ne_nan_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/fcmp_ne_nan_smoke/Cargo.lock index 472983a662..71b0d21466 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/fcmp_ne_nan_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/fcmp_ne_nan_smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/field_array_assign/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/field_array_assign/Cargo.lock index de8cbf89e1..b198305b8e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/field_array_assign/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/field_array_assign/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/float_rounding/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/float_rounding/Cargo.lock index 82a53311d6..80dfa026eb 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/float_rounding/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/float_rounding/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/fmaxmin_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/fmaxmin_smoke/Cargo.lock index d9f5a36d7b..a3233b3c21 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/fmaxmin_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/fmaxmin_smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/fn_ptr_naming/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/fn_ptr_naming/Cargo.lock index 81d4b2aeb3..2a909c83ac 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/fn_ptr_naming/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/fn_ptr_naming/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/fp_special_literal_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/fp_special_literal_smoke/Cargo.lock index cc7a0b49d8..86eb3f25e8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/fp_special_literal_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/fp_special_literal_smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/function_item_call/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/function_item_call/Cargo.lock index 0aecde78e5..fc1c163579 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/function_item_call/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/function_item_call/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/future_apis/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/future_apis/Cargo.lock index 6acb192412..cbfd3853ea 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/future_apis/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/future_apis/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm/Cargo.lock index 056047ee7d..d83a865a01 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol/Cargo.lock index 0aa6bf7395..4ce39a1971 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol_final/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol_final/Cargo.lock index 99a1c1c813..ad956f3af4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol_final/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_sol_final/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -313,6 +314,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -419,6 +426,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -533,6 +549,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -718,3 +747,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_views/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_views/Cargo.lock index 6b48d2b29b..9a3324ea0b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_views/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/gemm_views/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -312,6 +313,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -418,6 +425,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics/Cargo.lock index e965b3570e..cd9f2ba0b2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics/Cargo.lock @@ -188,6 +188,7 @@ version = "0.1.0" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -316,6 +317,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -422,6 +429,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics_blackwell/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics_blackwell/Cargo.lock index 65176bc3a3..04de2c5f8b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics_blackwell/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_intrinsics_blackwell/Cargo.lock @@ -188,6 +188,7 @@ version = "0.1.0" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -316,6 +317,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -422,6 +429,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_ldmatrix/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_ldmatrix/Cargo.lock index 0e5a302952..bb356b611b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_ldmatrix/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/generated_ldmatrix/Cargo.lock @@ -188,6 +188,7 @@ version = "0.1.0" name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -316,6 +317,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -422,6 +429,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/generic/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/generic/Cargo.lock index cf06cdd05d..6a78ca4f12 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/generic/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/generic/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap/Cargo.lock index e44dd77b0c..86b24f7d2a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v2/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v2/Cargo.lock index 6a872c48e4..0fb7f0e99e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v2/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v2/Cargo.lock @@ -215,6 +215,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -346,6 +347,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -452,6 +459,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -586,6 +602,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -771,3 +800,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v3/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v3/Cargo.lock index f5ae4facdd..b781c994c5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v3/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/hashmap_v3/Cargo.lock @@ -215,6 +215,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -346,6 +347,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -452,6 +459,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -586,6 +602,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -771,3 +800,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/hello_constant/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/hello_constant/Cargo.lock index 5279c6e7ef..f3fe99746f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/hello_constant/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/hello_constant/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/helper_fn/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/helper_fn/Cargo.lock index f6d933ccbc..7de74fdb2b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/helper_fn/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/helper_fn/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure/Cargo.lock index 2add398677..05cdf65074 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure/Cargo.lock @@ -206,6 +206,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -442,6 +443,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -557,6 +564,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.18", +] + [[package]] name = "parking_lot_core" version = "0.9.12" @@ -711,6 +727,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -928,3 +957,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure_target_feature/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure_target_feature/Cargo.lock index df77869652..6c77a5ff67 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure_target_feature/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/host_closure_target_feature/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/iket_trace/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/iket_trace/Cargo.lock index 781249726e..86c75b8ff3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/iket_trace/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/iket_trace/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/image_convolution/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/image_convolution/Cargo.lock index 6cb6944b5c..d5aa2ae65e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/image_convolution/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/image_convolution/Cargo.lock @@ -196,6 +196,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -344,6 +345,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -470,6 +477,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "png" version = "0.17.16" @@ -597,6 +613,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -794,3 +823,9 @@ name = "zlib-rs" version = "0.6.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/index2d_const/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/index2d_const/Cargo.lock index 0686ce42dd..3836acca0b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/index2d_const/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/index2d_const/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/index_field_assign/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/index_field_assign/Cargo.lock index 34f5c2907d..1a1e93d7b5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/index_field_assign/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/index_field_assign/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/inline_ptx/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/inline_ptx/Cargo.lock index ebaeb8b7e0..53bc623360 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/inline_ptx/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/inline_ptx/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/integer_minmax/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/integer_minmax/Cargo.lock index ea07c279ad..fe88f463bb 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/integer_minmax/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/integer_minmax/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/interior_mutability/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/interior_mutability/Cargo.lock index b9c688b9c5..a6f716be40 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/interior_mutability/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/interior_mutability/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/interop_cubin_identity/device/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/interop_cubin_identity/device/Cargo.lock index 5b1e7cd88d..f22694c1a4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/interop_cubin_identity/device/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/interop_cubin_identity/device/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -311,6 +312,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/kernel_reference_validity/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/kernel_reference_validity/Cargo.lock index 421a8e618e..6100df50d1 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/kernel_reference_validity/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/kernel_reference_validity/Cargo.lock @@ -206,6 +206,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -432,6 +433,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "kernel_reference_validity" version = "0.1.0" @@ -556,6 +563,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror 2.0.18", +] + [[package]] name = "parking_lot_core" version = "0.9.12" @@ -710,6 +726,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -927,3 +956,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/lanemask_scan/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/lanemask_scan/Cargo.lock index e0a335f508..394622c351 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/lanemask_scan/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/lanemask_scan/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lanemask_scan" version = "0.1.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_fadd/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_fadd/Cargo.lock index acedcabc8b..1e2ee59815 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_fadd/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_fadd/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_rmw_cas/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_rmw_cas/Cargo.lock index 904c9c5d51..ecfb175d50 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_rmw_cas/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_atomic_rmw_cas/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_nvvm_pointer_shapes/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_nvvm_pointer_shapes/Cargo.lock index 41da688d10..1aa0595d80 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_nvvm_pointer_shapes/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/legacy_nvvm_pointer_shapes/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/libdevice_math/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/libdevice_math/Cargo.lock index 285c0c6c88..d285772669 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/libdevice_math/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/libdevice_math/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/libm_math/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/libm_math/Cargo.lock index fe87b406fb..460643529b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/libm_math/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/libm_math/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -424,6 +431,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -538,6 +554,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -723,3 +752,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_generic/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_generic/Cargo.lock index 175db3a78e..3f172b6f05 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_generic/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_generic/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_libdevice/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_libdevice/Cargo.lock index f402402704..4118e90b10 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_libdevice/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/manual_launch_libdevice/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/map_sum/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/map_sum/Cargo.lock index 8c33481722..9924014ffa 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/map_sum/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/map_sum/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_atan/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_atan/Cargo.lock index b60d260cf3..8ce1894329 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_atan/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_atan/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_hyperbolic/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_hyperbolic/Cargo.lock index bf4fc4cda4..f7f1e6c274 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_hyperbolic/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_hyperbolic/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_no_mir_inline/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_no_mir_inline/Cargo.lock index 9cbbb86a02..b7718a33a7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_no_mir_inline/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_no_mir_inline/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_tan/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_tan/Cargo.lock index d32db3b7d9..552212e5e4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/math_tan/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/math_tan/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/mathdx_ffi_test/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/mathdx_ffi_test/Cargo.lock index 8d14b54b1c..76fc9daba6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/mathdx_ffi_test/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/mathdx_ffi_test/Cargo.lock @@ -204,6 +204,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -331,6 +332,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -454,6 +461,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -574,6 +590,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -759,3 +788,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/mcast_barrier_test/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/mcast_barrier_test/Cargo.lock index f8bd26cdd5..47eec7302e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/mcast_barrier_test/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/mcast_barrier_test/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/mem_swap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/mem_swap/Cargo.lock index 9f0b7f6203..611d7a182b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/mem_swap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/mem_swap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/mir_projected_call_destination/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/mir_projected_call_destination/Cargo.lock index 3fd8bac65e..8791af0505 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/mir_projected_call_destination/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/mir_projected_call_destination/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -424,6 +431,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -538,6 +554,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -723,3 +752,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/mma_mxf8f6f4/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/mma_mxf8f6f4/Cargo.lock index 1e680c9900..da7974c0f7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/mma_mxf8f6f4/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/mma_mxf8f6f4/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ne_bytes_transmute/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ne_bytes_transmute/Cargo.lock index 978743e322..4bd0371e5b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ne_bytes_transmute/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ne_bytes_transmute/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/nested_index_assignment/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/nested_index_assignment/Cargo.lock index 2be4cddb5c..c52786e005 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/nested_index_assignment/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/nested_index_assignment/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/numeric_stress/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/numeric_stress/Cargo.lock index 3de95b53ce..bfd2fa4115 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/numeric_stress/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/numeric_stress/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/nvls_all_reduce/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/nvls_all_reduce/Cargo.lock index 816249364b..781a8d3f06 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/nvls_all_reduce/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/nvls_all_reduce/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_transmute/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_transmute/Cargo.lock index 74b48892c7..b5af8f30b4 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_transmute/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_transmute/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_unwrap_or/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_unwrap_or/Cargo.lock index 8f05005c91..f5893ba8a7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_unwrap_or/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_ref_unwrap_or/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_unwrap_trap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_unwrap_trap/Cargo.lock index 5dce21dac4..85a0cbe346 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/option_unwrap_trap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/option_unwrap_trap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ord_cmp/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ord_cmp/Cargo.lock index 31ced58282..b80b1f9dcb 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ord_cmp/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ord_cmp/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -417,6 +424,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_aggregate_abi/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_aggregate_abi/Cargo.lock index 09dddb0199..f4c8348b24 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_aggregate_abi/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_aggregate_abi/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "packed_aggregate_abi" version = "0.1.0" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_atomic_add/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_atomic_add/Cargo.lock index b3709e011e..5c9aae69d3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_atomic_add/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/packed_atomic_add/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "packed_atomic_add" version = "0.1.0" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/padded_constants/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/padded_constants/Cargo.lock index 393991e170..7621003859 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/padded_constants/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/padded_constants/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "padded_constants" version = "0.1.0" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/partial_warp_reduce/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/partial_warp_reduce/Cargo.lock index ba0ebf3c83..1dd0ec55a8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/partial_warp_reduce/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/partial_warp_reduce/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "partial_warp_reduce" version = "0.1.0" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/pinned_overlap/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/pinned_overlap/Cargo.lock index f819cd7b3b..f00ea7f41c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/pinned_overlap/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/pinned_overlap/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "pinned_overlap" version = "0.1.0" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/place_read_fallbacks/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/place_read_fallbacks/Cargo.lock index 78b2f77a2a..63206cdbab 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/place_read_fallbacks/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/place_read_fallbacks/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "place_read_fallbacks" version = "0.1.0" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/policy_config/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/policy_config/Cargo.lock index 713f0777ab..ac860e426a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/policy_config/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/policy_config/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "policy_config" version = "0.1.0" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/primitive_stress/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/primitive_stress/Cargo.lock index c84a6e15e3..f07ca73faa 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/primitive_stress/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/primitive_stress/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/printf/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/printf/Cargo.lock index a06ac1675b..cfaa742b4f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/printf/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/printf/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/projected_place_read/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/projected_place_read/Cargo.lock index 88cde29662..30bc83e4e5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/projected_place_read/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/projected_place_read/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/proof_carrying_views/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/proof_carrying_views/Cargo.lock index 3ec04b9e64..42b08210f7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/proof_carrying_views/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/proof_carrying_views/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_copy/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_copy/Cargo.lock index 5b4640b69b..de5ac4ae48 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_copy/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_copy/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_offset_from/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_offset_from/Cargo.lock index c17c3d7a1c..0ec7cfb44f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_offset_from/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_offset_from/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_without_provenance/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_without_provenance/Cargo.lock index b9d72525d5..fa5df66742 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_without_provenance/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ptr_without_provenance/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/reborrow/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/reborrow/Cargo.lock index c6112cebe8..8d7de86367 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/reborrow/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/reborrow/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_f32/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_f32/Cargo.lock index fbe1e8cb36..a74777042e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_f32/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_f32/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_minmax/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_minmax/Cargo.lock index ecbeeb54f8..bbb321da29 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_minmax/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_minmax/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_sum/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_sum/Cargo.lock index 45927fe620..3495a7289a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_sum/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/redux_sum/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_index_projections/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_index_projections/Cargo.lock index 74c888841a..58a388e07a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_index_projections/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_index_projections/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_operand_mul/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_operand_mul/Cargo.lock index 94d0fa2102..ec2404f932 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_operand_mul/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/ref_operand_mul/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_align_block_args/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_align_block_args/Cargo.lock index 159dcc98f3..cc0078e643 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_align_block_args/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_align_block_args/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_transparent_abi/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_transparent_abi/Cargo.lock index 10231a6158..fa4c02c424 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_transparent_abi/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_transparent_abi/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -532,6 +548,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_u32_enum_stride/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_u32_enum_stride/Cargo.lock index c2f3be4056..6af97378f8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_u32_enum_stride/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/repr_u32_enum_stride/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/row_width_slice/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/row_width_slice/Cargo.lock index 9cf1089479..85b2f5f477 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/row_width_slice/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/row_width_slice/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/rustlantis-smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/rustlantis-smoke/Cargo.lock index 9d24a6b8d4..67e55271c0 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/rustlantis-smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/rustlantis-smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -306,6 +307,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -412,6 +419,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -536,6 +552,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -721,3 +750,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/scoped_atomic_load_store/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/scoped_atomic_load_store/Cargo.lock index 26d379b8e3..013a3379fb 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/scoped_atomic_load_store/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/scoped_atomic_load_store/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/select_unpredictable/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/select_unpredictable/Cargo.lock index b1cb5d2039..86eafa2b6e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/select_unpredictable/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/select_unpredictable/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -531,6 +547,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant/Cargo.lock index a623091819..bbd354e38b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "set_discriminant" version = "0.1.0" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant_niche/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant_niche/Cargo.lock index 158ecda0ac..e157fea2ac 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant_niche/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/set_discriminant_niche/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "set_discriminant_niche" version = "0.1.0" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_debug/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_debug/Cargo.lock index b790ed2ca1..3195c5052d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_debug/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_debug/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_memory_helper/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_memory_helper/Cargo.lock index 881232eacb..e72dcc60f5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_memory_helper/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_memory_helper/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -724,3 +753,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_ptr_transmute/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_ptr_transmute/Cargo.lock index 6b72183413..42647acf94 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_ptr_transmute/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_ptr_transmute/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_slice_unsize/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_slice_unsize/Cargo.lock index 0a11acde77..7517a55603 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_slice_unsize/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_slice_unsize/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_stage_select/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_stage_select/Cargo.lock index b3f2de5290..98f07a9a47 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_stage_select/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shared_stage_select/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/sharedmem/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/sharedmem/Cargo.lock index e9f87595fa..e60e6cf190 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/sharedmem/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/sharedmem/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/shuffle_64/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/shuffle_64/Cargo.lock index 7e138e6546..46b3b08f05 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/shuffle_64/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/shuffle_64/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_from_raw_parts_cast/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_from_raw_parts_cast/Cargo.lock index 205c918587..52b8d52887 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_from_raw_parts_cast/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_from_raw_parts_cast/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_get_mut/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_get_mut/Cargo.lock index 9edf3c367b..20152e80f8 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_get_mut/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_get_mut/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_index_bounds_check/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_index_bounds_check/Cargo.lock index 5f89a85bdc..e28e9d5ddf 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_index_bounds_check/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_index_bounds_check/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_iterators/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_iterators/Cargo.lock index a0b6344167..0ac8bde6f2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_iterators/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_iterators/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_reslice/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_reslice/Cargo.lock index 1a2c8f2fad..fe2e92d2b2 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_reslice/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/slice_reslice/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/small_type_ffi_test/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/small_type_ffi_test/Cargo.lock index 4f6f48790e..d446e6625f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/small_type_ffi_test/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/small_type_ffi_test/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_fp8/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_fp8/Cargo.lock index 9b2a168a17..c781eb7524 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_fp8/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_fp8/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_ordered_float/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_ordered_float/Cargo.lock index 337858588b..03d67c5e3a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_ordered_float/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/sparse_mma_ordered_float/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/split_at_mut/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/split_at_mut/Cargo.lock index 60eb51980e..4324edf483 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/split_at_mut/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/split_at_mut/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/standalone_device_fn/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/standalone_device_fn/Cargo.lock index bd369b09ad..bbf2681720 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/standalone_device_fn/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/standalone_device_fn/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -715,3 +744,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_addend/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_addend/Cargo.lock index 651695d697..15f0537070 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_addend/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_addend/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_unsize/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_unsize/Cargo.lock index 3b9c78d986..c074858de1 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_unsize/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/static_slice_unsize/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/step_by/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/step_by/Cargo.lock index 8433420962..84cba98cab 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/step_by/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/step_by/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_constant_provenance/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_constant_provenance/Cargo.lock index 00a570174e..690c24a327 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_constant_provenance/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_constant_provenance/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_field_layout/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_field_layout/Cargo.lock index 3fdd686f8a..fe53acdb76 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_field_layout/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/struct_field_layout/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/subslice_projection/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/subslice_projection/Cargo.lock index b4cc31859f..7ef72e0da5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/subslice_projection/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/subslice_projection/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/switchint_128bit/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/switchint_128bit/Cargo.lock index 2ce3306137..03811356e6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/switchint_128bit/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/switchint_128bit/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/swizzle_smem/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/swizzle_smem/Cargo.lock index 3b56442154..f152cecc4c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/swizzle_smem/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/swizzle_smem/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05/Cargo.lock index 1f5d931f29..8c6054ce23 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05_matmul/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05_matmul/Cargo.lock index 8c2269f5d1..651ffe661e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05_matmul/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tcgen05_matmul/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/thread_runs/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/thread_runs/Cargo.lock index 34faff57b2..75c208fc87 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/thread_runs/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/thread_runs/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tiled_gemm/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tiled_gemm/Cargo.lock index 4ba660c11e..cf9576c158 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tiled_gemm/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tiled_gemm/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.lock new file mode 100644 index 0000000000..c86e4ed6e2 --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.lock @@ -0,0 +1,735 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "bindgen" +version = "0.69.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088" +dependencies = [ + "bitflags", + "cexpr", + "clang-sys", + "itertools", + "lazy_static", + "lazycell", + "log", + "prettyplease", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex", + "syn", + "which", +] + +[[package]] +name = "bitflags" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "clang-sys" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "cuda-artifact-finalizer" +version = "0.2.1" +dependencies = [ + "libnvvm-sys", + "nvjitlink-sys", + "serde", + "sha2", + "thiserror", +] + +[[package]] +name = "cuda-bindings" +version = "0.4.0" +dependencies = [ + "bindgen", + "libloading", + "prettyplease", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "cuda-core" +version = "0.4.0" +dependencies = [ + "anyhow", + "cuda-bindings", + "cuda-core-derive", + "half", + "oxide-artifacts", +] + +[[package]] +name = "cuda-core-derive" +version = "0.4.0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "cuda-device" +version = "0.2.1" +dependencies = [ + "cuda-macros", +] + +[[package]] +name = "cuda-macros" +version = "0.2.1" +dependencies = [ + "oxide-tile-export", + "proc-macro2", + "quote", + "reserved-oxide-symbols", + "syn", +] + +[[package]] +name = "cuda-target-spec" +version = "0.1.0" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "home" +version = "0.5.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", +] + +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "lazycell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libnvvm-sys" +version = "0.2.1" +dependencies = [ + "cuda-target-spec", + "libloading", + "thiserror", +] + +[[package]] +name = "linux-raw-sys" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "nvjitlink-sys" +version = "0.2.1" +dependencies = [ + "libloading", + "thiserror", +] + +[[package]] +name = "object" +version = "0.36.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87" +dependencies = [ + "crc32fast", + "hashbrown 0.15.5", + "indexmap", + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "oxide-artifacts" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d9a941c0c43d2dceaf25f5c9ca4c9f9cceb28dfa5e4e3cfd14e476f003e7c9" +dependencies = [ + "object", +] + +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "reserved-oxide-symbols" +version = "0.2.1" + +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + +[[package]] +name = "rustix" +version = "0.38.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.59.0", +] + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tilelib_relu" +version = "0.1.0" +dependencies = [ + "cuda-artifact-finalizer", + "cuda-core", + "cuda-device", + "oxide-tile-export", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "which" +version = "4.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" +dependencies = [ + "either", + "home", + "once_cell", + "rustix", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "zerocopy" +version = "0.8.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce1022995ff5ff5d841ad7d994facc23098cd40152f2c1d11cd607c6f530653f" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.52" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ae7f38b72ec2a254e2b87ef277cf2cd4fb97cbebf944faa6f33354da0867930" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.toml b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.toml new file mode 100644 index 0000000000..4ca1afc7b9 --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "tilelib_relu" +version = "0.1.0" +edition = "2024" +authors = ["Nihal Pasham "] +license = "Apache-2.0" + +# Mark as standalone crate (not part of parent workspace) +[workspace] + +# A tile library written in Rust: #[tile_export] functions a cuTile program +# calls through `foreign_call`. The host program proves the native SIMT ABI on +# this machine's GPU through a generated CUDA C++ caller: +# cargo oxide run tilelib_relu --emit-nvvm-ir --arch sm_120 + +[dependencies] +# Device-side intrinsics (#[tile_export], warp shuffles, etc.). +cuda-device = { path = "../../../cuda-device" } + +# The descriptions the backend writes next to the device artifact. The host +# derives the C++ prototypes from them instead of restating the ABI by hand. +oxide-tile-export = { path = "../../../oxide-tile-export" } + +# libNVVM and nvJitLink without the CUDA driver: NVVM IR to LTOIR, then the +# two-input LTOIR link into a cubin, the same calls cuda-host makes. +cuda-artifact-finalizer = { path = "../../../cuda-artifact-finalizer" } + +# Host-side CUDA runtime: context, device buffers, raw kernel launches. +cuda-core = { path = "../../../../../cuda-core" } diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/README.md b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/README.md new file mode 100644 index 0000000000..95bff63d19 --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/README.md @@ -0,0 +1,136 @@ +# tilelib_relu + +A tile library written in Rust. Three `#[tile_export]` functions compile to +one LTOIR module on the native SIMT ABI, and `tilelib_relu.tileexports.json` +describes them. A Tile kernel reaches them once the two are packaged as +`tilelib_relu.tilelib`, which needs a CUDA 13.5 or newer tileiras: from Tile +C++ through a foreign declaration (`cpp/tile_caller.cu`), or from cuTile +Python through `foreign_call` (`python/call_from_cutile.py`). The host +program here proves the ABI on any CUDA 13.4 machine, through a generated +CUDA C++ caller that declares the implementations the way the Tile compiler +would. + +```text +src/main.rs: #[tile_export] relu, scale_in_place, warp_sum + | + | cargo oxide run tilelib_relu --emit-nvvm-ir --arch sm_120 + v +tilelib_relu.ll ---libNVVM---> tilelib_relu.ltoir tilelib_relu.tileexports.json + (NVVM IR, SIMT ABI) (device code) (one description per export) + | | + +---------------------------+------------------------------+ + | | + v v +consumer 1: this host program (CUDA 13.4 is enough) consumer 2: cuTile (CUDA 13.5+) + descriptions -> mock/caller.cu cargo oxide tilelib tilelib_relu + nvcc -dc --keep -gencode arch=compute_120,code=lto_120 -> tilelib_relu.tilelib + nvJitLink(tilelib_relu.ltoir + caller.ltoir) -> cubin python/call_from_cutile.py + launch call_, compare, PASS x3 tp.foreign_call(symbol_name="relu") +``` + +## The exports + +| cuTile name | Rust | implementation the call resolves to | +|------------------|-----------------------------------------|----------------------------------------------------| +| `relu` | `fn relu(x: f32) -> f32` | `void relu_impl(float x, float *relu_out)` | +| `scale_in_place` | `fn scale(x: &mut f32, factor: f32)` | `void scale_in_place_impl(float *x, float factor)` | +| `warp_sum` | `fn warp_sum(x: f32) -> f32`, warp sync | `void warp_sum_impl(float x, float *warp_sum_out)` | + +`in` scalars travel by value, `&mut` parameters as pointers, and a return +value becomes a trailing `out` pointer. The host program does not restate +that table: it derives every prototype in `mock/caller.cu` from the +descriptions through `oxide_tile_export::TileExportDesc::abi_params`, so the +generated file is the ABI as the tooling understands it. It is written when +the program runs and is not tracked, like the other generated artifacts. + +The generated kernels launch one thread per invocation, tile size divided by +the export's footprint, and pass each thread the first of its footprint +elements; the three exports here have footprint 1. An export with `f16` +elements is skipped with a `SKIP` line and counted in the `SUCCESS` line +rather than failed, because nvcc has no scalar type that lowers to LLVM +`half`. + +## Run + +```bash +# 1. Build the library and prove the ABI on the GPU (needs nvcc, libNVVM, +# nvJitLink and a GPU matching --arch; CUDA 13.4 is enough). +cargo oxide run tilelib_relu --emit-nvvm-ir --arch sm_120 + +# 2. Package it as a tile library (needs a tileiras that lists 13.5 or newer). +cargo oxide tilelib tilelib_relu --arch sm_120 + +# 3. Call it from a Tile C++ kernel (needs the same toolkit's nvcc, which +# knows --enable-tile; the kernel runs on the GPU and checks all three exports). +nvcc --enable-tile --tile-preview simt -Xtileiras=-l=tilelib_relu.tilelib \ + -std=c++20 -arch=sm_120 -o tile_caller cpp/tile_caller.cu && ./tile_caller + +# 4. Or call it from cuTile Python (checked against cuTile Python 1.7). +python python/call_from_cutile.py --dry-run # bytecode only, no tileiras +python python/call_from_cutile.py # full run, needs step 2 +``` + +Step 1 is not a Tile kernel. The host program stands in for the Tile +compiler: it writes a CUDA C++ caller from the descriptions and links it +against the LTOIR, which proves the ABI on CUDA 13.4. The end-to-end test, a +Tile kernel calling the Rust functions, is step 2 followed by step 3 or 4. +Run step 2 after step 1: `cargo oxide run` and `cargo oxide build` clear the +example's generated artifacts, the `.tilelib` among them. When the toolkit +that brings the 13.5 assembler is not the one on `PATH`, point +`CUTILE_TILEIRAS_PATH` at its `tileiras` for step 2 and run its `nvcc` for +step 3. + +Step 3 prints one `PASS` line per export and then +`SUCCESS: 3/3 tile exports called from a Tile C++ kernel`. Each foreign +declaration in `cpp/tile_caller.cu` mirrors a declaration of the library: +parameters the library reads carry no attribute, parameters it writes carry +`[[cutile::experimental_inout]]` and come back as the result, the way the +MathDx tile libraries declare theirs. + +Step 1 prints one line per export and then the marker: + +```text +PASS relu: 128 elements through `relu_impl`, relu of a ramp from -4 to 4 +PASS scale_in_place: 128 elements through `scale_in_place_impl`, the ramp scaled in place by 0.5 +PASS warp_sum: 128 elements through `warp_sum_impl`, 32-lane sums over 0..128, every lane holding its warp's total +SUCCESS: 3/3 tile exports verified through the native ABI +``` + +Without nvcc it prints `skipping: nvcc not found` and exits 0. + +## What PASS proves + +- The wrapper `#[tile_export]` generates has the calling convention the Tile + compiler derives from the same description: a C++ caller written from the + description alone links against it and gets the right numbers. +- The link works the way a tile library is consumed: two LTOIR inputs, + symbols resolved by nvJitLink, no PTX in between. +- `sync = warp` behaves when every lane of a warp calls together: all 32 + lanes receive the warp total. + +All three checks compare bit for bit; the inputs are chosen so f32 cannot +round (relu copies or zeroes, 0.5 halves, the warp sums are small integers). + +## What still needs CUDA 13.5 or newer + +- `tilelib_relu.tilelib` itself: `tileiras --preview-create-tile-lib` exists + from 13.5 on, and an assembler reads preview content only at the version + it calls current, so the descriptions are written at the resolved + assembler's newest listed version. When the installed tileiras lists only + 13.4, + `cargo oxide tilelib` stops after writing the descriptions, says so, and + exits 2; with `--library-optional` the descriptions alone count as + success and it exits 0, which is how the smoketest runs it. +- The Tile C++ caller: nvcc gains `--enable-tile` and `--tile-preview simt` + with the same toolkit that brings the assembler, and the program and the + library then agree on the bytecode version by construction. +- The cuTile side: `foreign_call` is a 13.5 bytecode feature. The dry run + compiles it on 13.4 because it never calls tileiras. It was checked + against cuTile Python 1.7 (checkout 770b493) with the `cuda-tile-preview` + package built from that checkout's `experimental/tile_preview` folder: + `cuda.tile_preview` is not on PyPI, and `call_from_cutile.py` imports + private `cuda.tile._*` modules (`_bytecode`, `_cext`, `_compile`) that can + move between releases. The full run also needs a cuTile Python that lists + the assembler's current bytecode version: the script lists every version + its encoder knows, and the probe against tileiras picks the newest one it + accepts. diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/cpp/tile_caller.cu b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/cpp/tile_caller.cu new file mode 100644 index 0000000000..31e4942713 --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/cpp/tile_caller.cu @@ -0,0 +1,123 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +// A Tile C++ kernel that calls the three Rust exports of tilelib_relu.tilelib. +// +// nvcc --enable-tile --tile-preview simt -Xtileiras=-l=tilelib_relu.tilelib \ +// -std=c++20 -arch=sm_120 -o tile_caller cpp/tile_caller.cu +// +// Needs a toolkit whose nvcc knows `--enable-tile` and whose tileiras built +// the library (CUDA 13.5 or newer). Each foreign declaration mirrors one +// declaration in the library's interface: parameters the library reads carry +// no attribute, parameters it writes carry `[[cutile::experimental_inout]]` +// and come back as the result. The kernel runs one 128-element tile through +// each export; the host checks every element bit for bit. + +#include +#include + +#include +#include +#include + +namespace ct = cuda::tiles; + +inline constexpr int tile_size = 128; +using tile_f32 = ct::tile>; + +// @relu(%x: tile<128xf32> in, %relu_out: tile<128xf32> out) -> tile<128xf32> +__experimental_foreign_decl__ __experimental_foreign_name__("relu") + tile_f32 relu(tile_f32 x, [[cutile::experimental_inout]] tile_f32 relu_out); + +// @scale_in_place(%x: tile<128xf32> inout, %factor: tile<128xf32> in) -> tile<128xf32> +__experimental_foreign_decl__ __experimental_foreign_name__("scale_in_place") + tile_f32 scale_in_place([[cutile::experimental_inout]] tile_f32 x, tile_f32 factor); + +// @warp_sum(%x: tile<128xf32> in, %warp_sum_out: tile<128xf32> out) -> tile<128xf32>, +// implemented with synchronization: 32 lanes call the Rust function together. +__experimental_foreign_decl__ __experimental_foreign_name__("warp_sum") + tile_f32 warp_sum(tile_f32 x, [[cutile::experimental_inout]] tile_f32 warp_sum_out); + +[[cutile::hint(0, num_worker_warps_per_cta = 4)]] __tile_global__ void call_exports( + float* ramp, float* factor, float* lanes, float* relu_out, float* scale_out, float* warp_out) { + auto view = [](float* data) { + return ct::partition_view { ct::tensor_span { data, ct::shape {} }, ct::shape {} }; + }; + auto relu_view = view(relu_out); + auto scale_view = view(scale_out); + auto warp_view = view(warp_out); + + relu_view.store(relu(view(ramp).load(0), relu_view.load(0)), 0); + scale_view.store(scale_in_place(view(ramp).load(0), view(factor).load(0)), 0); + warp_view.store(warp_sum(view(lanes).load(0), warp_view.load(0)), 0); +} + +#define CHECK_CUDA(expression) \ + do { \ + const cudaError_t cuda_status = (expression); \ + if (cuda_status != cudaSuccess) { \ + std::fprintf(stderr, "%s failed: %s\n", #expression, cudaGetErrorString(cuda_status)); \ + return EXIT_FAILURE; \ + } \ + } while (0) + +int main() { + std::array ramp {}; + std::array factor {}; + std::array lanes {}; + for (int i = 0; i < tile_size; ++i) { + ramp[i] = -4.0f + 8.0f * float(i) / float(tile_size - 1); + factor[i] = 0.5f; + lanes[i] = float(i); + } + + float* device[6] = {}; + for (float*& pointer : device) CHECK_CUDA(cudaMalloc(&pointer, sizeof(ramp))); + CHECK_CUDA(cudaMemcpy(device[0], ramp.data(), sizeof(ramp), cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(device[1], factor.data(), sizeof(factor), cudaMemcpyHostToDevice)); + CHECK_CUDA(cudaMemcpy(device[2], lanes.data(), sizeof(lanes), cudaMemcpyHostToDevice)); + for (int i = 3; i < 6; ++i) CHECK_CUDA(cudaMemset(device[i], 0, sizeof(ramp))); + + call_exports<<<1>>>(device[0], device[1], device[2], device[3], device[4], device[5]); + CHECK_CUDA(cudaGetLastError()); + CHECK_CUDA(cudaDeviceSynchronize()); + + std::array relu_out {}; + std::array scale_out {}; + std::array warp_out {}; + CHECK_CUDA(cudaMemcpy(relu_out.data(), device[3], sizeof(relu_out), cudaMemcpyDeviceToHost)); + CHECK_CUDA(cudaMemcpy(scale_out.data(), device[4], sizeof(scale_out), cudaMemcpyDeviceToHost)); + CHECK_CUDA(cudaMemcpy(warp_out.data(), device[5], sizeof(warp_out), cudaMemcpyDeviceToHost)); + + int failures = 0; + for (int i = 0; i < tile_size; ++i) { + const float expected_relu = ramp[i] > 0.0f ? ramp[i] : 0.0f; + const float expected_scale = ramp[i] * 0.5f; + // Lane values 32w .. 32w+31 sum to 32 * 32w + 496. + const float expected_warp = float(32 * 32 * (i / 32) + 496); + if (relu_out[i] != expected_relu) { + std::fprintf(stderr, "relu mismatch at %d: got %f expected %f\n", i, relu_out[i], expected_relu); + ++failures; + } + if (scale_out[i] != expected_scale) { + std::fprintf(stderr, "scale_in_place mismatch at %d: got %f expected %f\n", i, scale_out[i], expected_scale); + ++failures; + } + if (warp_out[i] != expected_warp) { + std::fprintf(stderr, "warp_sum mismatch at %d: got %f expected %f\n", i, warp_out[i], expected_warp); + ++failures; + } + } + for (float* pointer : device) CHECK_CUDA(cudaFree(pointer)); + if (failures != 0) { + std::fprintf(stderr, "FAIL: %d mismatches\n", failures); + return EXIT_FAILURE; + } + std::printf("PASS relu: 128 elements through the tile library\n"); + std::printf("PASS scale_in_place: 128 elements through the tile library\n"); + std::printf("PASS warp_sum: 128 elements through the tile library, every lane holding its warp's total\n"); + std::printf("SUCCESS: 3/3 tile exports called from a Tile C++ kernel\n"); + return EXIT_SUCCESS; +} diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/python/call_from_cutile.py b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/python/call_from_cutile.py new file mode 100644 index 0000000000..7a9b6e4beb --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/python/call_from_cutile.py @@ -0,0 +1,215 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +"""Call tilelib_relu's `relu` from a cuTile kernel through `foreign_call`. + + python call_from_cutile.py --dry-run # bytecode only; runs on CUDA 13.4 + python call_from_cutile.py [path/to.tilelib] # full run; needs the CUDA 13.5 tileiras + +The kernel loads one 128-float tile, hands it to the library's `relu` +declaration together with a zero tile for the result slot, and stores what +comes back. `--dry-run` compiles that kernel to Tile IR bytecode without +tileiras (`return_cubin=False`) and checks that the program really calls +`relu`: the caller half of the contract, produced on this machine. The full +run also needs the library half, `tilelib_relu.tilelib`, which only a CUDA +13.5 tileiras can build (`cargo oxide tilelib tilelib_relu --arch sm_120`), +and a cuTile Python whose supported bytecode versions include 13.5. + +Checked against cuTile Python 1.7 (checkout 770b493) with the +`cuda-tile-preview` package from that checkout's experimental/tile_preview +folder; `cuda.tile_preview` is not on PyPI. The dry run reaches into private +`cuda.tile._*` modules (`_bytecode`, `_cext`, `_compile`), which can move +between releases. +""" + +from __future__ import annotations + +import argparse +import os +import pathlib +import shutil +import subprocess +import sys +import tempfile + +import numpy as np + +import cuda.tile as ct +from cuda import tile_preview as tp + +TILE = 128 +LIBRARY_VERSION = "0.1.0" +HERE = pathlib.Path(__file__).resolve().parent +DEFAULT_TILELIB = HERE.parent / "tilelib_relu.tilelib" +# preview$call in the bytecode opcode table; upstream's test_foreign_call.py +# looks for the same varint-encoded value. +PREVIEW_CALL_OPCODE = 0x4002 + +# Set by main() before the kernel is traced. foreign_call reads the library +# as a compile-time constant, so it has to be a module global, not an argument. +PROVIDER: tp.Tilelib | None = None + + +def relu_tile(x, y): + """One block runs `relu` over one 128-float tile of `x` into `y`.""" + pid = ct.bid(0) + tile = ct.load(x, index=(pid,), shape=(TILE,)) + # Every declaration argument needs an input tile, the `out` slot included. + result_slot = ct.zeros((TILE,), dtype=ct.float32) + (out,) = tp.foreign_call( + tilelibs=(PROVIDER,), + symbol_name="relu", + constant_params=(), + inputs=(tile, result_slot), + output_types=((ct.float32, (TILE,)),), + ) + ct.store(y, index=(pid,), tile=out) + + +def dry_run() -> None: + """Compile the kernel to 13.5 bytecode and show the preview$call to `relu` is in it.""" + from cuda.tile._bytecode.basic import encode_varint + from cuda.tile._bytecode.version import BytecodeVersion + from cuda.tile._cext import CallingConvention + from cuda.tile._compile import compile_tile + from cuda.tile.compilation import ArrayConstraint, KernelSignature + + constraint = ArrayConstraint( + dtype=ct.float32, + ndim=1, + index_dtype=ct.int32, + stride_lower_bound_incl=0, + alias_groups=(), + may_alias_internally=False, + ) + signature = KernelSignature( + [constraint, constraint], CallingConvention.cutile_python_v2(), symbol="relu_tile" + ) + result = compile_tile( + relu_tile, + [signature], + bytecode_version=BytecodeVersion.V_13_5, + return_final_ir=True, + return_bytecode=True, + return_cubin=False, + ) + bytecode = bytes(result.bytecode) + major, minor = bytecode[8], bytecode[9] + preview = int.from_bytes(bytecode[10:12], "little") & 1 + opcode = bytearray() + encode_varint(PREVIEW_CALL_OPCODE, opcode) + has_call_op = bytes(opcode) in bytecode + # The callee's name is read from the final IR, not from the bytecode's + # string table: the kernel symbol `relu_tile` contains `relu`, so a bare + # search of the bytes would pass without any call. + ir_text = "\n".join(str(block) for block in result.final_ir) + calls_relu = "preview_foreign_call" in ir_text and 'symbol_name="relu"' in ir_text + print(f"bytecode: {len(bytecode)} bytes, header {bytecode[8:12].hex()} " + f"(version {major}.{minor}, preview flag {'set' if preview else 'clear'}), " + f"preview$call opcode {'present' if has_call_op else 'absent'}; " + f"final IR {'calls' if calls_relu else 'does not call'} `relu`") + if (major, minor) != (13, 5) or not preview or not has_call_op or not calls_relu: + print("FAIL: the program does not carry a 13.5 preview call to `relu`") + sys.exit(1) + print("PASS: the caller side compiles; the program calls `relu` through " + "preview$call (dry run, no cubin)") + + +def full_run() -> None: + """Link the library with tileiras, run on the GPU, compare with numpy.""" + import cupy as cp + from cuda.tile import _compile as compile_module + from cuda.tile._bytecode.version import BytecodeVersion + + # A launched kernel is compiled at the newest bytecode version this cuTile + # Python lists and the installed tileiras accepts. The 1.7 checkout lists + # versions above 13.4 only when its extension is built with development + # features, so every version its encoder knows is listed here; the probe + # against tileiras still decides which one is used. foreign_call needs + # 13.5, and an assembler reads preview content only at the version it + # calls current, so this cuTile Python must encode that version too. A + # release that lists these versions itself needs no such lines. + for version in BytecodeVersion: + if (version > BytecodeVersion.V_13_4 + and version not in compile_module._SUPPORTED_VERSIONS): + compile_module._SUPPORTED_VERSIONS.append(version) + + relu_kernel = ct.kernel(relu_tile) + n = 32 * TILE + x = cp.linspace(-4.0, 4.0, n, dtype=cp.float32) + y = cp.zeros_like(x) + try: + ct.launch(cp.cuda.get_current_stream(), (n // TILE, 1, 1), relu_kernel, (x, y)) + except Exception as error: # noqa: BLE001 (every failure here is reported, not hidden) + explain(error) + sys.exit(1) + expected = np.maximum(cp.asnumpy(x), 0.0) + got = cp.asnumpy(y) + np.testing.assert_array_equal(got, expected) + print(f"PASS: relu from the tile library matches numpy on {n} elements") + + +def explain(error: Exception) -> None: + """Report the failure and, when it is the toolkit, say so plainly.""" + print(f"FAIL: {type(error).__name__}: {error}") + versions = tileiras_versions() + if versions and "13.5" not in versions: + print(f"The installed tileiras lists bytecode versions {', '.join(versions)}. " + "foreign_call needs 13.5, which ships with CUDA 13.5 or newer; until then " + "only --dry-run can run on this machine.") + else: + print("A 13.5 tileiras is also only used when this cuTile Python lists 13.5 " + "among its supported bytecode versions.") + + +def tileiras_versions() -> list[str]: + """The bytecode versions the tileiras on this machine accepts, or [].""" + candidates = [shutil.which("tileiras")] + for root in (os.environ.get("CUDA_HOME"), os.environ.get("CUDA_PATH"), "/usr/local/cuda"): + if root: + candidates.append(os.path.join(root, "bin", "tileiras")) + for path in candidates: + if not path or not os.path.isfile(path): + continue + try: + output = subprocess.run([path, "--list-versions"], capture_output=True, + text=True, check=True, timeout=30).stdout + except (OSError, subprocess.SubprocessError): + continue + return [line.strip() for line in output.splitlines() if line.strip()] + return [] + + +def main() -> None: + global PROVIDER + parser = argparse.ArgumentParser(description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("tilelib", nargs="?", default=DEFAULT_TILELIB, type=pathlib.Path, + help="the tile library (default: ../tilelib_relu.tilelib)") + parser.add_argument("--dry-run", action="store_true", + help="compile to bytecode only; no tileiras, no GPU") + args = parser.parse_args() + + if args.dry_run and not args.tilelib.is_file(): + # Tilelib() insists that the file exists; the bytecode only records + # its path, so a placeholder stands in for the real library. + with tempfile.TemporaryDirectory() as scratch: + placeholder = pathlib.Path(scratch) / args.tilelib.name + placeholder.write_bytes(b"placeholder") + print(f"{args.tilelib} is not built yet; using a placeholder for the dry run") + PROVIDER = tp.Tilelib(path=placeholder, version=LIBRARY_VERSION) + dry_run() + return + + if not args.tilelib.is_file(): + print(f"FAIL: {args.tilelib} does not exist; build it with " + "`cargo oxide tilelib tilelib_relu --arch sm_120` (CUDA 13.5 tileiras)") + sys.exit(1) + PROVIDER = tp.Tilelib(path=args.tilelib, version=LIBRARY_VERSION) + if args.dry_run: + dry_run() + else: + full_run() + + +if __name__ == "__main__": + main() diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/src/main.rs b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/src/main.rs new file mode 100644 index 0000000000..c6168616d6 --- /dev/null +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/src/main.rs @@ -0,0 +1,593 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ + +//! tilelib_relu: a tile library written in Rust, checked on the GPU. +//! +//! The device half is the three `#[tile_export]` functions below. Each one +//! becomes an implementation a cuTile program calls through `foreign_call`, +//! on the native SIMT ABI: `in` scalars by value, everything else behind a +//! pointer, the return value as a trailing `out` pointer. +//! +//! The host half proves that ABI without a CUDA 13.5 or newer tileiras. It reads the +//! descriptions the backend wrote, generates `mock/caller.cu` with the +//! prototypes the Tile compiler derives, compiles it with nvcc, links it with +//! the Rust LTOIR through nvJitLink, and checks the numbers on the GPU: +//! +//! cargo oxide run tilelib_relu --emit-nvvm-ir --arch sm_120 + +use cuda_artifact_finalizer::{ + CudaArch, DebugPolicy, FinalizationOptions, FinalizerOutput, LtoLinker, NamedInput, + NvvmCompiler, +}; +use cuda_core::embedded::{ArtifactCompileOptions, ArtifactDebugPolicy}; +use cuda_core::{CudaContext, CudaModule, DeviceBuffer, launch_kernel_on_stream}; +use cuda_device::{tile_export, warp}; +use oxide_tile_export::{ + AbiParamKind, DESCRIPTIONS_SUFFIX, TileAccess, TileElem, TileExportDesc, descriptions_from_json, +}; +use std::error::Error; +use std::ffi::c_void; +use std::fmt::Write as _; +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::sync::Arc; + +// ============================================================================ +// Device half: the tile library +// ============================================================================ + +/// Elementwise `max(x, 0)`. +#[tile_export(tile_shape = 128)] +pub fn relu(x: f32) -> f32 { + if x > 0.0 { x } else { 0.0 } +} + +/// Scale a tile in place. The cuTile side knows it as `scale_in_place`. +#[tile_export( + tile_shape = 128, + name = "scale_in_place", + symbol = "scale_in_place_impl" +)] +pub fn scale(x: &mut f32, factor: f32) { + *x *= factor; +} + +/// Sum over the 32 lanes of each warp; every lane gets the warp total. +#[tile_export(tile_shape = 128, sync = "warp")] +pub fn warp_sum(x: f32) -> f32 { + let mut total = x; + let mut offset = 16; + while offset > 0 { + total += warp::shuffle_xor_f32_sync(u32::MAX, total, offset); + offset /= 2; + } + total +} + +// ============================================================================ +// Host half: prove the ABI through a generated CUDA C++ caller +// ============================================================================ + +const CRATE: &str = "tilelib_relu"; + +type Fallible = Result>; + +/// How the run ended when nothing went wrong. +enum Outcome { + /// The exports that were called through the native ABI and checked, plus + /// the ones the generated caller cannot declare, each with its reason. + Verified { + verified: usize, + skipped: Vec<(String, String)>, + }, + /// The check cannot run on this machine; the reason is printed. + Skipped(String), +} + +fn main() { + match run() { + Ok(Outcome::Verified { verified, skipped }) => { + let total = verified + skipped.len(); + let mut line = + format!("SUCCESS: {verified}/{total} tile exports verified through the native ABI"); + if !skipped.is_empty() { + let names: Vec<&str> = skipped.iter().map(|(decl, _)| decl.as_str()).collect(); + let _ = write!(line, ", {} skipped ({})", skipped.len(), names.join(", ")); + } + println!("{line}"); + } + Ok(Outcome::Skipped(reason)) => println!("skipping: {reason}"), + Err(error) => { + println!("FAIL: {error}"); + std::process::exit(1); + } + } +} + +fn run() -> Fallible { + let dir = Path::new(env!("CARGO_MANIFEST_DIR")); + let (exports, skipped) = partition_callable(read_descriptions(dir)?); + if exports.is_empty() { + return Ok(Outcome::Skipped( + "every export uses half precision, which the generated caller cannot declare" + .to_string(), + )); + } + let options = read_build_policy(dir)?; + let Some(nvcc) = find_nvcc() else { + return Ok(Outcome::Skipped("nvcc not found".to_string())); + }; + + let caller_cu = dir.join("mock").join("caller.cu"); + write_if_changed(&caller_cu, &caller_source(&exports)?)?; + + let rust_ltoir = rust_ltoir(dir, &options)?; + let caller_ltoir = compile_caller(&nvcc, &caller_cu, options.target())?; + // Both halves are LTOIR, so nvJitLink resolves the implementation symbols + // at link time, the same way a real tile library is consumed. + let cubin = LtoLinker::discover()?.link_ltoir( + &[ + NamedInput::new("tilelib_relu.ltoir", &rust_ltoir), + NamedInput::new("caller.ltoir", &caller_ltoir), + ], + &options, + FinalizerOutput::Cubin, + )?; + println!( + "nvJitLink: {} bytes of cubin for {}", + cubin.len(), + options.target().sm() + ); + + let ctx = match CudaContext::new(0) { + Ok(ctx) => ctx, + Err(error) => return Ok(Outcome::Skipped(format!("no CUDA device: {error}"))), + }; + let (major, minor) = ctx.compute_capability()?; + let gpu = u32::try_from(major * 10 + minor)?; + if gpu != options.target().capability() { + return Ok(Outcome::Skipped(format!( + "the device code targets {}, this GPU is sm_{gpu}", + options.target().sm() + ))); + } + let module = ctx.load_module_from_image(&cubin)?; + for desc in &exports { + check_export(&ctx, &module, desc)?; + } + Ok(Outcome::Verified { + verified: exports.len(), + skipped, + }) +} + +/// Split the exports into the ones the generated caller can declare and the +/// ones it cannot, printing one `SKIP` line per export left out. nvcc has no +/// scalar type that lowers to LLVM `half` or `bfloat` (its `__half` is a +/// struct), so a half-precision export is reported and counted rather than +/// failed: the ABI defect that would be is in the mock, not in the export. +fn partition_callable( + exports: Vec, +) -> (Vec, Vec<(String, String)>) { + let mut callable = Vec::with_capacity(exports.len()); + let mut skipped = Vec::new(); + for desc in exports { + match desc + .params + .iter() + .find_map(|param| c_type(param.elem).err()) + { + Some(reason) => { + println!("SKIP {}: {reason}", desc.decl); + skipped.push((desc.decl, reason)); + } + None => callable.push(desc), + } + } + (callable, skipped) +} + +/// The descriptions the backend wrote next to the device artifact, validated +/// so the generated C++ can rely on the ABI rules. +fn read_descriptions(dir: &Path) -> Fallible> { + let path = dir.join(format!("{CRATE}.{DESCRIPTIONS_SUFFIX}")); + let text = std::fs::read_to_string(&path).map_err(|error| { + format!( + "could not read {} (build with `cargo oxide run {CRATE} --emit-nvvm-ir --arch sm_120`): {error}", + path.display() + ) + })?; + let exports = descriptions_from_json(&text)?; + if exports.is_empty() { + return Err(format!("{} describes no tile exports", path.display()).into()); + } + for desc in &exports { + desc.validate() + .map_err(|error| format!("description of `{}`: {error}", desc.decl))?; + } + Ok(exports) +} + +/// The target and compile policy recorded with the NVVM IR. The link must use +/// the same architecture and FMA setting as the build, or nvJitLink rejects +/// the input or changes the arithmetic. +fn read_build_policy(dir: &Path) -> Fallible { + let target_path = dir.join(format!("{CRATE}.target")); + let text = std::fs::read_to_string(&target_path) + .map_err(|error| format!("could not read {}: {error}", target_path.display()))?; + let target: CudaArch = text.lines().next().unwrap_or_default().trim().parse()?; + + let options_path = dir.join(format!("{CRATE}.options")); + let compile = match std::fs::read_to_string(&options_path) { + Ok(text) => ArtifactCompileOptions::from_sidecar_text(&text) + .map_err(|error| format!("invalid {}: {error}", options_path.display()))?, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => ArtifactCompileOptions::new(), + Err(error) => { + return Err(format!("could not read {}: {error}", options_path.display()).into()); + } + }; + let debug = match compile.debug_policy() { + ArtifactDebugPolicy::None => DebugPolicy::None, + ArtifactDebugPolicy::LineTables => DebugPolicy::LineTables, + ArtifactDebugPolicy::Full => DebugPolicy::Full, + }; + Ok(FinalizationOptions::new(target) + .with_fma_contraction(compile.fma_contraction_enabled()) + .with_debug_policy(debug)) +} + +/// The Rust half as LTOIR. `cargo oxide tilelib` and `emit-ltoir` leave a +/// `.ltoir` next to the `.ll`; a plain `--emit-nvvm-ir` build leaves only the +/// `.ll`, so it is compiled here with libNVVM, the call cargo oxide makes. A +/// `.ltoir` older than the `.ll` is stale and gets recompiled too. +fn rust_ltoir(dir: &Path, options: &FinalizationOptions) -> Fallible> { + let ll = dir.join(format!("{CRATE}.ll")); + let ltoir = dir.join(format!("{CRATE}.ltoir")); + if ltoir.is_file() && !older_than(<oir, &ll) { + println!("libNVVM: using {}", ltoir.display()); + return Ok(std::fs::read(<oir)?); + } + let ir = std::fs::read(&ll).map_err(|error| { + format!( + "could not read {} (build with `cargo oxide run {CRATE} --emit-nvvm-ir --arch sm_120`): {error}", + ll.display() + ) + })?; + let ltoir = + NvvmCompiler::discover()?.compile_nvvm_ir_to_ltoir(&format!("{CRATE}.ll"), &ir, options)?; + println!( + "libNVVM: {} compiled to LTOIR ({} bytes)", + ll.display(), + ltoir.len() + ); + Ok(ltoir) +} + +fn older_than(file: &Path, other: &Path) -> bool { + let modified = |path: &Path| std::fs::metadata(path).and_then(|meta| meta.modified()); + match (modified(file), modified(other)) { + (Ok(file_time), Ok(other_time)) => file_time < other_time, + _ => false, + } +} + +/// nvcc from `PATH`, then from the toolkit roots libNVVM is also looked up in. +fn find_nvcc() -> Option { + let on_path = std::env::var_os("PATH") + .map(|path| std::env::split_paths(&path).collect::>()) + .unwrap_or_default() + .into_iter() + .map(|dir| dir.join("nvcc")); + let in_toolkit = ["CUDA_TOOLKIT_PATH", "CUDA_HOME", "CUDA_PATH"] + .into_iter() + .filter_map(std::env::var_os) + .map(PathBuf::from) + .chain([PathBuf::from("/usr/local/cuda"), PathBuf::from("/opt/cuda")]) + .map(|root| root.join("bin").join("nvcc")); + on_path + .chain(in_toolkit) + .find(|candidate| candidate.is_file()) +} + +/// Generate `mock/caller.cu`: the implementation prototypes the Tile compiler +/// derives from the descriptions, and one kernel per export that calls the +/// implementation the way the compiler does over one tile. +fn caller_source(exports: &[TileExportDesc]) -> Fallible { + let mut out = String::new(); + out.push_str( + "// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n\ + // SPDX-License-Identifier: Apache-2.0\n\ + //\n\ + // Generated by the tilelib_relu host program from tilelib_relu.tileexports.json.\n\ + // Do not edit: it is rewritten whenever the descriptions change.\n\ + //\n\ + // Each kernel stands in for the Tile compiler: one thread per invocation of\n\ + // the implementation, launched as one block of tile-size / footprint threads.\n\ + // Scalar `in` parameters arrive by value, every other parameter as a pointer\n\ + // to the first of the invocation's footprint elements. A `sync = warp` export\n\ + // is called by every lane of each warp, which the full block provides.\n\n", + ); + for desc in exports { + // `validate` holds every parameter of an export to one footprint, so + // the first parameter's is the export's. + let footprint = desc.params[0].footprint; + let abi = desc.abi_params(); + let mut prototype = Vec::new(); + let mut kernel_params = Vec::new(); + let mut call_args = Vec::new(); + for (param, info) in abi.iter().zip(&desc.params) { + let c_type = c_type(param.kind.elem()).map_err(|reason| { + format!("`{}`: parameter `{}`: {reason}", desc.decl, param.name) + })?; + let constness = if info.access == TileAccess::In { + "const " + } else { + "" + }; + // Every parameter is a tile-size buffer to the kernel; by-value + // parameters are loaded from it, pointer parameters point into it. + kernel_params.push(format!("{constness}{c_type} *{}", param.name)); + match param.kind { + AbiParamKind::Scalar(_) => { + prototype.push(format!("{c_type} {}", param.name)); + call_args.push(format!("{}[i]", param.name)); + } + AbiParamKind::Pointer(_) => { + prototype.push(format!("{constness}{c_type} *{}", param.name)); + call_args.push(format!("&{}[i]", param.name)); + } + } + } + writeln!( + out, + "// {}: {} elements, footprint {footprint}, sync {}", + desc.decl, + desc.shape[0], + desc.sync.tile_ir_name() + )?; + writeln!( + out, + "extern \"C\" __device__ void {}({});", + desc.symbol, + prototype.join(", ") + )?; + writeln!( + out, + "extern \"C\" __global__ void call_{}({}) {{", + desc.decl, + kernel_params.join(", ") + )?; + if footprint == 1 { + writeln!( + out, + " const int i = blockIdx.x * blockDim.x + threadIdx.x;" + )?; + } else { + // Thread t owns elements [t * F, (t + 1) * F). + writeln!( + out, + " const int i = (blockIdx.x * blockDim.x + threadIdx.x) * {footprint};" + )?; + } + writeln!(out, " {}({});", desc.symbol, call_args.join(", "))?; + writeln!(out, "}}\n")?; + } + Ok(out) +} + +/// The C type of a tile element, or why nvcc has none: it has no scalar type +/// that lowers to LLVM `half` or `bfloat` (its `__half` is a struct), so +/// those two cannot be declared in the generated caller. +fn c_type(elem: TileElem) -> Result<&'static str, String> { + Ok(match elem { + TileElem::F32 => "float", + TileElem::F64 => "double", + TileElem::I8 => "signed char", + TileElem::I16 => "short", + TileElem::I32 => "int", + TileElem::I64 => "long long", + TileElem::U8 => "unsigned char", + TileElem::U16 => "unsigned short", + TileElem::U32 => "unsigned int", + TileElem::U64 => "unsigned long long", + TileElem::F16 | TileElem::BF16 => { + return Err(format!( + "{} has no by-value C type in nvcc; the mock covers f32, f64 and the integers", + elem.rust_name() + )); + } + }) +} + +/// Write `text` to `path` only when it differs, so a run that changes nothing +/// leaves the generated file alone. +fn write_if_changed(path: &Path, text: &str) -> Fallible<()> { + if std::fs::read_to_string(path).is_ok_and(|current| current == text) { + println!("caller: {} is current", path.display()); + return Ok(()); + } + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + std::fs::write(path, text)?; + println!("caller: wrote {}", path.display()); + Ok(()) +} + +/// Compile the generated caller to LTOIR for `target` in a scratch directory, +/// removed on success and kept for inspection on failure. `-dc` leaves the +/// Rust symbols unresolved for the link; `--keep` makes nvcc leave the +/// `.ltoir` behind. +fn compile_caller(nvcc: &Path, caller_cu: &Path, target: &CudaArch) -> Fallible> { + let work = std::env::temp_dir().join(format!("{CRATE}-nvcc-{}", std::process::id())); + std::fs::create_dir_all(&work)?; + let sm = target.sm(); + let code = sm.trim_start_matches("sm_"); + + let mut command = Command::new(nvcc); + // The same host-compiler override the other LTOIR examples honor. + if let Some(ccbin) = std::env::var_os("NVCC_CCBIN").or_else(|| std::env::var_os("CUDAHOSTCXX")) + { + command.arg("-ccbin").arg(ccbin); + } + let output = command + .args(["-dc", "--keep", "--keep-dir"]) + .arg(&work) + .arg("-gencode") + .arg(format!("arch={},code=lto_{code}", target.compute())) + .arg(caller_cu) + .arg("-o") + .arg(work.join("caller.o")) + .current_dir(&work) + .output()?; + if !output.status.success() { + return Err(format!( + "nvcc failed ({}); intermediates kept in {}\n{}", + output.status, + work.display(), + String::from_utf8_lossy(&output.stderr) + ) + .into()); + } + let ltoir = std::fs::read(work.join("caller.ltoir"))?; + std::fs::remove_dir_all(&work)?; + println!("nvcc: caller.ltoir ({} bytes, lto_{code})", ltoir.len()); + Ok(ltoir) +} + +/// The data fed to one export and the result expected back. +struct HostCase { + /// One tile of values per ABI parameter, in description order; result + /// slots start zeroed. + buffers: Vec>, + /// Index of the parameter whose buffer is read back and checked. + checked: usize, + expected: Vec, + what: &'static str, +} + +/// What the host feeds each export and what it expects back. Every case is +/// exact in f32: relu copies or zeroes, 0.5 halves without rounding, and the +/// warp sums are small integers. +fn host_model(desc: &TileExportDesc, n: usize) -> Fallible { + // A ramp from -4 to 4 crosses zero without landing on it. + let last = (n.max(2) - 1) as f32; + let ramp: Vec = (0..n).map(|i| -4.0 + 8.0 * (i as f32) / last).collect(); + let case = match desc.decl.as_str() { + "relu" => HostCase { + buffers: vec![ramp.clone(), vec![0.0; n]], + checked: 1, + expected: ramp + .iter() + .map(|&x| if x > 0.0 { x } else { 0.0 }) + .collect(), + what: "relu of a ramp from -4 to 4", + }, + "scale_in_place" => HostCase { + buffers: vec![ramp.clone(), vec![0.5; n]], + checked: 0, + expected: ramp.iter().map(|x| x * 0.5).collect(), + what: "the ramp scaled in place by 0.5", + }, + "warp_sum" => { + let lanes: Vec = (0..n).map(|i| i as f32).collect(); + let expected = (0..n) + .map(|i| { + let first = i - i % 32; + lanes[first..(first + 32).min(n)].iter().sum() + }) + .collect(); + HostCase { + buffers: vec![lanes, vec![0.0; n]], + checked: 1, + expected, + what: "32-lane sums over 0..128, every lane holding its warp's total", + } + } + other => return Err(format!("no host model for export `{other}`").into()), + }; + if case.buffers.len() != desc.params.len() || !desc.params[case.checked].access.is_output() { + return Err(format!( + "`{}`: the host model does not match the described parameters", + desc.decl + ) + .into()); + } + Ok(case) +} + +/// Run `call_` over one tile, one thread per footprint, and compare +/// every element of the checked buffer with the host model. +fn check_export( + ctx: &Arc, + module: &Arc, + desc: &TileExportDesc, +) -> Fallible<()> { + let n = usize::try_from(desc.shape[0])?; + let footprint = usize::try_from(desc.params[0].footprint)?; + if n % footprint != 0 { + return Err(format!( + "`{}`: footprint {footprint} does not divide the tile size {n}", + desc.decl + ) + .into()); + } + let invocations = n / footprint; + let case = host_model(desc, n)?; + + let stream = ctx.default_stream(); + let buffers = case + .buffers + .iter() + .map(|data| DeviceBuffer::from_host(&stream, data)) + .collect::, _>>()?; + let mut pointers: Vec<_> = buffers.iter().map(DeviceBuffer::cu_deviceptr).collect(); + let mut args: Vec<*mut c_void> = pointers + .iter_mut() + .map(|pointer| std::ptr::from_mut(pointer).cast::()) + .collect(); + let function = module.load_function(&format!("call_{}", desc.decl))?; + // SAFETY: the generated kernel takes one device pointer per ABI parameter + // in description order, which is how `args` was built; every buffer holds + // `n` elements, one footprint for each of the `n / footprint` threads + // launched, and outlives the launch; the stream belongs to the module's + // context. + unsafe { + launch_kernel_on_stream( + &function, + (1, 1, 1), + (u32::try_from(invocations)?, 1, 1), + 0, + &stream, + &mut args, + )?; + } + + let got = buffers[case.checked].to_host_vec(&stream)?; + let mismatches: Vec<_> = got + .iter() + .zip(&case.expected) + .enumerate() + .filter(|(_, (got, expected))| got != expected) + .collect(); + if let Some((index, (got, expected))) = mismatches.first() { + return Err(format!( + "`{}`: {} of {n} elements differ, first at [{index}]: got {got}, expected {expected}", + desc.decl, + mismatches.len() + ) + .into()); + } + let footprints = if footprint == 1 { + String::new() + } else { + format!(" in {invocations} footprints of {footprint}") + }; + println!( + "PASS {}: {n} elements{footprints} through `{}`, {}", + desc.decl, desc.symbol, case.what + ); + Ok(()) +} diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/tile_caller b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/tile_caller new file mode 100755 index 0000000000..b17e0e6b9e Binary files /dev/null and b/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu/tile_caller differ diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_copy/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_copy/Cargo.lock index d4c75a0b72..5a9c81ad8f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_copy/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_copy/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_multicast/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_multicast/Cargo.lock index 7af886b9bc..3977ab9ddc 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_multicast/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tma_multicast/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/toolchain_pairing_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/toolchain_pairing_smoke/Cargo.lock index d07a8d2fa7..29f8b4dec6 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/toolchain_pairing_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/toolchain_pairing_smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/transmute_scalar_struct/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/transmute_scalar_struct/Cargo.lock index 3c965c977f..0e2998f8d5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/transmute_scalar_struct/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/transmute_scalar_struct/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_array_provenance/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_array_provenance/Cargo.lock index ba512ea61c..de10cae507 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_array_provenance/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_array_provenance/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_constant_provenance/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_constant_provenance/Cargo.lock index a32429c09f..48212e960c 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_constant_provenance/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_constant_provenance/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_field_lookup/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_field_lookup/Cargo.lock index 44984c38b3..47aad8a282 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_field_lookup/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_field_lookup/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_return/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_return/Cargo.lock index ec8eee26e6..2ac68321ee 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_return/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/tuple_return/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/unaligned_memory/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/unaligned_memory/Cargo.lock index f063fd2267..4affc8b321 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/unaligned_memory/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/unaligned_memory/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/unchecked_indexing/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/unchecked_indexing/Cargo.lock index b3ee031b9c..53f368594d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/unchecked_indexing/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/unchecked_indexing/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/uninit_const/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/uninit_const/Cargo.lock index 0dae26617c..1517384a3b 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/uninit_const/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/uninit_const/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/union_aggregate/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/union_aggregate/Cargo.lock index 0ff48d9e4c..c2a4fec2d7 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/union_aggregate/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/union_aggregate/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_bounds_check/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_bounds_check/Cargo.lock index 5262ec59b0..71e089c287 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_bounds_check/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_bounds_check/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_smoke/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_smoke/Cargo.lock index 8d0cce9016..780f6f3e9d 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_smoke/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/unroll_smoke/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/vecadd/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/vecadd/Cargo.lock index dead9d09ff..9d76a571bd 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/vecadd/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/vecadd/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/vectorization/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/vectorization/Cargo.lock index 07061c7cb4..6cb5e3d2a9 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/vectorization/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/vectorization/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -717,3 +746,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/volatile_memory/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/volatile_memory/Cargo.lock index 31a9923785..51689b847a 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/volatile_memory/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/volatile_memory/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_reduce/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_reduce/Cargo.lock index 6225903e18..49805d2fe3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_reduce/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_reduce/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_sums/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_sums/Cargo.lock index cfffc70730..1b446984c3 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_sums/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/warp_sums/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma/Cargo.lock index 288c97ac06..11fbfa1d79 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma_mma_bf16/Cargo.lock b/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma_mma_bf16/Cargo.lock index 2fe046b8aa..e5e504178f 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma_mma_bf16/Cargo.lock +++ b/cuda-oxide/crates/rustc-codegen-cuda/examples/wgmma_mma_bf16/Cargo.lock @@ -184,6 +184,7 @@ dependencies = [ name = "cuda-macros" version = "0.2.1" dependencies = [ + "oxide-tile-export", "proc-macro2", "quote", "reserved-oxide-symbols", @@ -302,6 +303,12 @@ dependencies = [ "either", ] +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + [[package]] name = "lazy_static" version = "1.5.0" @@ -408,6 +415,15 @@ dependencies = [ "object", ] +[[package]] +name = "oxide-tile-export" +version = "0.2.1" +dependencies = [ + "serde", + "serde_json", + "thiserror", +] + [[package]] name = "prettyplease" version = "0.2.37" @@ -522,6 +538,19 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + [[package]] name = "sha2" version = "0.10.9" @@ -716,3 +745,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/cuda-oxide/crates/rustc-codegen-cuda/src/collector.rs b/cuda-oxide/crates/rustc-codegen-cuda/src/collector.rs index 0b2bb713ab..4fcbf51b3e 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/src/collector.rs +++ b/cuda-oxide/crates/rustc-codegen-cuda/src/collector.rs @@ -246,10 +246,11 @@ enum CollectDecision { // match. The mutual-exclusion guarantee between `DEVICE_PREFIX` and // `DEVICE_EXTERN_PREFIX` means we no longer need the historical // "test extern first" ordering dance that lived here previously. +use oxide_tile_export::TileExportDesc; use reserved_oxide_symbols::{ - device_extern_base_name, is_current_device_symbol, is_current_kernel_symbol, + device_base_name, device_extern_base_name, is_current_device_symbol, is_current_kernel_symbol, is_device_extern_symbol, is_device_symbol, is_kernel_symbol, is_legacy_kernel_symbol, - is_ptx_merge_required_marker, kernel_base_name, + is_ptx_merge_required_marker, is_tile_export_meta_symbol, kernel_base_name, }; /// Sanitize a symbol name for use as a PTX identifier. @@ -396,6 +397,12 @@ pub struct CollectionResult<'tcx> { /// dependency. Cubin materialization must reject this case until it can /// reproduce the same cross-crate linking semantics. pub requires_ptx_bundle_merge: bool, + + /// `#[tile_export]` descriptions read from this crate's metadata + /// functions, sorted by implementation symbol. Each one's implementation + /// is a root in `functions`; the backend writes them to + /// `.tileexports.json` beside the device artifact. + pub tile_exports: Vec, } /// Counts kernel functions across all codegen units. @@ -916,6 +923,145 @@ impl DiscoveryCtx { } } +/// Read every `#[tile_export]` description embedded in this crate. +/// +/// The macro emits one host-only `#[no_mangle] fn +/// cuda_oxide_tile_export__() -> &'static str` per export whose +/// body returns the JSON description. That shape needs no file IO or side +/// channel: `#[no_mangle]` items are always codegened, so the function is in +/// the CGUs even though nothing calls it, and its description is a constant +/// in MIR. The function is never compiled for the device; see the explicit +/// skips in [`collect_device_functions`] and `process_call_operand`. +/// +/// Malformed metadata is fatal rather than skipped: a description that does +/// not parse or validate means the macro and this backend disagree, and a +/// silently missing export would surface much later as a tile library +/// without the symbol the caller asked for. +fn collect_tile_exports<'tcx>( + tcx: TyCtxt<'tcx>, + cgus: &[CodegenUnit<'tcx>], + verbose: bool, +) -> Vec { + let mut descs: Vec = Vec::new(); + let mut seen = HashSet::new(); + for cgu in cgus { + for (item, _data) in cgu.items() { + let MonoItem::Fn(instance) = item else { + continue; + }; + let def_id = instance.def_id(); + let def_path = tcx.def_path_str(def_id); + if !is_tile_export_meta_symbol(&def_path) { + continue; + } + // Partitioning can place one item in several CGUs. + if !seen.insert(def_id) { + continue; + } + let Some(text) = tile_export_meta_text(tcx, *instance) else { + tcx.dcx().span_fatal( + tcx.def_span(def_id), + format!( + "[rustc_codegen_cuda] `{def_path}` carries the reserved tile export \ + metadata prefix but does not return one constant string; only \ + `#[tile_export]` may define functions with this prefix" + ), + ); + }; + let desc = TileExportDesc::from_json(&text).unwrap_or_else(|error| { + tcx.dcx().span_fatal( + tcx.def_span(def_id), + format!( + "[rustc_codegen_cuda] tile export metadata in `{def_path}` is not a \ + description this backend understands ({error}); rebuild with \ + cuda-macros from the same cuda-oxide revision as the backend" + ), + ) + }); + if let Err(error) = desc.validate() { + tcx.dcx().span_fatal( + tcx.def_span(def_id), + format!( + "[rustc_codegen_cuda] tile export `{}` is invalid: {error}", + desc.decl + ), + ); + } + if let Some(previous) = descs.iter().find(|other| other.symbol == desc.symbol) { + tcx.dcx().span_fatal( + tcx.def_span(def_id), + format!( + "[rustc_codegen_cuda] tile exports `{}` and `{}` both use the \ + implementation symbol `{}`; give one of them a distinct `symbol`", + previous.decl, desc.decl, desc.symbol + ), + ); + } + // The declaration name is what a cuTile caller resolves, so two + // exports sharing one would collide in the tile library; catch it + // here rather than when `cargo oxide tilelib` builds the modules. + if let Some(previous) = descs.iter().find(|other| other.decl == desc.decl) { + tcx.dcx().span_fatal( + tcx.def_span(def_id), + format!( + "[rustc_codegen_cuda] tile exports `{}` and `{}` both declare the \ + name `{}` to cuTile; give one of them a distinct `name`", + previous.symbol, desc.symbol, desc.decl + ), + ); + } + if verbose { + eprintln!( + "[collector] Found tile export: {} -> {} (shape {:?}, {} params, sync {})", + desc.decl, + desc.symbol, + desc.shape, + desc.params.len(), + desc.sync.tile_ir_name() + ); + } + descs.push(desc); + } + } + // Stable output regardless of CGU partitioning. + descs.sort_by(|a, b| a.symbol.cmp(&b.symbol)); + descs +} + +/// The constant `&str` a tile export metadata function returns. +/// +/// The optimized body is `_0 = const ""; return`, so the description is +/// the constant operand assigned to `RETURN_PLACE`. The constant evaluates to +/// a `ConstValue::Slice` (or `Indirect`) of UTF-8 bytes; `const_str_text` +/// reads both representations. Anything else (no such assignment, a +/// non-constant, or more than one) returns `None` and the caller reports it. +fn tile_export_meta_text<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Option { + use rustc_middle::mir::{Operand, RETURN_PLACE, Rvalue, StatementKind}; + + let mir = tcx.instance_mir(instance.def); + let mut found = None; + for block in mir.basic_blocks.iter() { + for statement in &block.statements { + let StatementKind::Assign(assign) = &statement.kind else { + continue; + }; + let (place, rvalue) = &**assign; + if place.as_local() != Some(RETURN_PLACE) { + continue; + } + // The second field is the retag marker, irrelevant to a constant. + let Rvalue::Use(Operand::Constant(constant), _) = rvalue else { + return None; + }; + let text = const_str_text(tcx, constant)?; + if found.replace(text).is_some() { + return None; + } + } + } + found +} + /// Collects all device-reachable functions starting from kernel entry points. /// /// This is the main entry point for device function collection. It: @@ -941,6 +1087,7 @@ pub fn collect_device_functions<'tcx>( verbose: bool, ) -> CollectionResult<'tcx> { let mut collector = DeviceCollector::new(tcx, verbose); + let tile_exports = collect_tile_exports(tcx, cgus, verbose); let mut requires_ptx_bundle_merge = cgus.iter().any(|cgu| { cgu.items().iter().any(|(item, _data)| match item { MonoItem::Static(def_id) => is_ptx_merge_required_marker(&tcx.def_path_str(*def_id)), @@ -948,10 +1095,13 @@ pub fn collect_device_functions<'tcx>( }) }); - // Find all kernel entry points + // Find all kernel entry points. `#[tile_export]` metadata functions are + // host-only (their descriptions were read above) and never device code; + // the prefix cannot match a kernel, but say so here rather than rely on it. for cgu in cgus { for (item, _data) in cgu.items() { if let MonoItem::Fn(instance) = item + && !is_tile_export_meta_symbol(&tcx.def_path_str(instance.def_id())) && is_kernel_function(tcx, instance.def_id()) { // Skip generic (non-monomorphized) instances. @@ -1005,15 +1155,67 @@ pub fn collect_device_functions<'tcx>( } } + let has_kernels = !collector.worklist.is_empty(); + + // `#[tile_export]` implementations are roots whether or not the crate has + // kernels: no device code calls them, and the standalone scan below only + // runs for kernel-less crates. The description's `symbol` is the base + // name of the `#[device]` wrapper, which is also what the symbol becomes + // in the device artifact once llvm-export strips the device prefix. + for desc in &tile_exports { + let mut found = false; + for cgu in cgus { + for (item, _data) in cgu.items() { + let MonoItem::Fn(instance) = item else { + continue; + }; + let raw_name = tcx.def_path_str(instance.def_id()); + if device_base_name(&raw_name) != Some(desc.symbol.as_str()) + || !is_device_function(tcx, instance.def_id()) + || !is_fully_monomorphized(tcx, *instance) + // The macro rejects generics, so a generic device function + // sharing the base name is not the implementation. + || !instance.args.is_empty() + { + continue; + } + let name = collector.fqdn(*instance); + let export_name = collector.compute_export_name(&name, *instance); + if verbose { + eprintln!( + "[collector] Found tile export implementation: {} -> {}", + name, export_name + ); + } + collector.add_root(*instance, false, export_name); + found = true; + } + } + if !found { + tcx.dcx().fatal(format!( + "[rustc_codegen_cuda] tile export `{}` names the implementation symbol `{}`, \ + but this crate has no `#[device]` function with that name. `#[tile_export]` \ + generates the implementation next to the exported function; keep the two \ + together and do not rename the generated item", + desc.decl, desc.symbol + )); + } + } + // Find standalone device function roots (Phase 2: device functions without kernels). // Only scan when there are NO kernels — when kernels exist, device functions are - // already collected transitively via the call graph walk. - if collector.worklist.is_empty() { + // already collected transitively via the call graph walk. Tile export + // implementations were rooted above and are skipped here so their export + // names are not computed twice. + if !has_kernels { for cgu in cgus { for (item, _data) in cgu.items() { if let MonoItem::Fn(instance) = item + // Host-only metadata, never device code (see the kernel scan). + && !is_tile_export_meta_symbol(&tcx.def_path_str(instance.def_id())) && is_device_function(tcx, instance.def_id()) && is_fully_monomorphized(tcx, *instance) + && !collector.is_seen(*instance) { let raw_name = tcx.def_path_str(instance.def_id()); @@ -1045,6 +1247,7 @@ pub fn collect_device_functions<'tcx>( // Process the worklist to collect all reachable functions let mut result = collector.collect(); result.requires_ptx_bundle_merge = requires_ptx_bundle_merge; + result.tile_exports = tile_exports; result } @@ -1120,6 +1323,11 @@ impl<'tcx> DeviceCollector<'tcx> { ) } + /// True once `instance` has been rooted or discovered. + fn is_seen(&self, instance: Instance<'tcx>) -> bool { + self.seen.contains(self.tcx.symbol_name(instance).name) + } + /// Adds a root function (kernel) to start collection from. fn add_root(&mut self, instance: Instance<'tcx>, is_kernel: bool, export_name: String) { // Use mangled name as the unique key - this distinguishes different @@ -1254,6 +1462,7 @@ impl<'tcx> DeviceCollector<'tcx> { functions: self.result, device_externs: self.device_externs, requires_ptx_bundle_merge: false, + tile_exports: Vec::new(), } } @@ -1498,6 +1707,28 @@ impl<'tcx> DeviceCollector<'tcx> { return; }; let fn_path = self.tcx.def_path_str(*def_id); + + // `#[tile_export]` metadata functions are host-only: their body is + // the JSON description the collector already consumed. A device-side + // call means user code reached for the generated item. Refuse it + // here instead of skipping: a skipped call would leave a dangling + // symbol that fails later at module verification. + if is_tile_export_meta_symbol(&fn_path) { + self.tcx + .dcx() + .struct_span_fatal( + call_span, + format!( + "device code in `{}` calls `{fn_path}`, a `#[tile_export]` metadata \ + function; it is host-only and holds the export's JSON description, \ + not device code", + caller.export_name + ), + ) + .with_help("call the exported function itself, or its `` wrapper") + .emit() + } + if fn_path.contains("DynamicSharedArray") && (fn_path.contains("::get") || fn_path.contains("::get_raw") diff --git a/cuda-oxide/crates/rustc-codegen-cuda/src/lib.rs b/cuda-oxide/crates/rustc-codegen-cuda/src/lib.rs index fc5fc48e74..97d5e41dd5 100644 --- a/cuda-oxide/crates/rustc-codegen-cuda/src/lib.rs +++ b/cuda-oxide/crates/rustc-codegen-cuda/src/lib.rs @@ -772,6 +772,25 @@ impl CodegenBackend for CudaCodegenBackend { "[rustc_codegen_cuda] Device codegen did not produce an embeddable artifact", ); } + if !collection_result.tile_exports.is_empty() { + match write_tile_export_descriptions( + &device_config.output_dir, + &device_config.output_name, + &collection_result.tile_exports, + ) { + Ok(path) => { + if self.config.verbose { + eprintln!( + "[rustc_codegen_cuda] Tile export descriptions written: {}", + path.display() + ); + } + } + Err(e) => tcx.dcx().fatal(format!( + "[rustc_codegen_cuda] Failed to write tile export descriptions: {e}" + )), + } + } Some(result) } Ok(Err(e)) => { @@ -849,6 +868,25 @@ impl CodegenBackend for CudaCodegenBackend { } } +/// Write `.tileexports.json` next to the `.ll`/`.ptx`: the JSON +/// array of this crate's `#[tile_export]` descriptions. `cargo oxide tilelib` +/// reads it to build the Tile IR interface and implementation modules; the +/// device artifact itself carries nothing from it. +fn write_tile_export_descriptions( + output_dir: &Path, + output_name: &str, + tile_exports: &[oxide_tile_export::TileExportDesc], +) -> std::io::Result { + let path = output_dir.join(format!( + "{output_name}.{}", + oxide_tile_export::DESCRIPTIONS_SUFFIX + )); + let mut text = oxide_tile_export::descriptions_to_json_pretty(tile_exports); + text.push('\n'); + std::fs::write(&path, text)?; + Ok(path) +} + #[allow(clippy::too_many_arguments)] fn write_device_artifact_object( tcx: TyCtxt<'_>, diff --git a/cuda-oxide/cuda-oxide-book/advanced/images/tilelib-direct-linkage.svg b/cuda-oxide/cuda-oxide-book/advanced/images/tilelib-direct-linkage.svg new file mode 100644 index 0000000000..b6ee2b4305 --- /dev/null +++ b/cuda-oxide/cuda-oxide-book/advanced/images/tilelib-direct-linkage.svg @@ -0,0 +1,107 @@ + + + + +Direct linkage: a Tile kernel calls a Rust function through a .tilelib +cuda-oxide is the SIMT provider. It ships code plus a description; the Tile compiler matches, marshals and links. +RUST SIDE (cuda-oxide) +TILE COMPILER (tileiras, CUDA 13.5 or newer) +TILE SIDE (Tile C++, cuTile Python or cutile-rs) + +#[tile_export(tile_shape = 128)] +pub fn relu(x: f32) -> f32 { .. } + +cargo oxide tilelib relu --arch sm_120 + +relu.ltoir +code: LLVM bitcode for nvJitLink + +relu.iface.tilebc +declaration: what can be called + +relu.impl.tilebc +implementation: how to call it + +tileiras --preview-create-tile-lib + +relu.tilelib +one host object file + +.nvtlifc +declaration + +.nvtl.0 +implementation + +.nvtl.1 +LTOIR + +tileiras --preview=simt prog.tilebc + -l relu.tilelib -o kernel.cubin + + +1 +splice the declaration from .nvtlifc +into the program + +2 +pick an implementation whose fragment +layout fits the call site + +3 +lower the boundary: spill the tile to +per-thread buffers, call relu_impl per invocation + +4 +nvJitLink: tile code + relu.ltoir +cross-module LTO, then SASS + +-l + +program + + +one cubin +tile kernel and relu_impl linked together + +tp.foreign_call(tilelibs=(relu_lib,), + symbol_name="relu", inputs=(x, zeros), + output_types=((f32, (128,)),)) + +the frontend emits + +prog.tilebc +preview$call @relu(%x, %out) + +The Tile frontend's half. It only emits the call +and passes the library on. It never sees Rust. + +THREE FILES, TWO KINDS + +.tilebc +metadata the Tile compiler reads: names, tile types, fragment layouts, scope. +No code inside. Written by oxide-tilebc from the #[tile_export] description. + +.ltoir +the code: LLVM bitcode, finalized to SASS by nvJitLink at link time. +The Tile compiler never looks inside it. Our existing emit-ltoir pipeline. +THE ABI THE MACRO GENERATES +fn relu(x: f32) -> f32 +becomes +extern "C" fn relu_impl(x: f32, out: *mut f32) +scalar in: by value · out and inout: a pointer · results travel through pointers +no logical thread id: threadIdx.x is the real one · shared memory only through scratch +Later: a linkage provider .so answers the same two things on demand. + diff --git a/cuda-oxide/cuda-oxide-book/advanced/tile-libraries.md b/cuda-oxide/cuda-oxide-book/advanced/tile-libraries.md new file mode 100644 index 0000000000..80098f03d9 --- /dev/null +++ b/cuda-oxide/cuda-oxide-book/advanced/tile-libraries.md @@ -0,0 +1,434 @@ +# Tile Libraries + +A Tile kernel works on whole tiles and never names a thread. A SIMT function +works on one element from one thread. A **tile library** joins the two. It +packages Rust device functions so the Tile compiler can call them from inside +a cuTile kernel, once per element or once per warp, and link them into the +kernel's cubin. The Rust side is `#[tile_export]`, the packaging is +`cargo oxide tilelib`, and the caller is cuTile Python's `foreign_call` today, +with [cutile-rs](https://nvidia.github.io/cuda-rust/cutile/) to follow. + +```text +#[tile_export(tile_shape = 128)] +pub fn relu(x: f32) -> f32 { .. } your Rust function + | + | cargo oxide tilelib --arch sm_120 + v +.ltoir device code void relu_impl(float x, float *relu_out) +.iface.tilebc declaration @relu(tile<128xf32> in, tile<128xf32> out) -> tile<128xf32> +.impl.tilebc implementation @relu_impl implements @relu, one invocation per element + | + | tileiras --preview-create-tile-lib (CUDA 13.5 or newer) + v +.tilelib + | + | tp.foreign_call(symbol_name="relu", ...) inside a cuTile kernel + v +the Tile compiler links relu_impl into the kernel's cubin +``` + +:::{seealso} +[Kernels and Device Functions](../gpu-programming/kernels-and-device-functions.md) +covers `#[device]` and the LTOIR route to CUDA C++. A tile library is the same +route with the Tile compiler as the caller. +::: + +```{figure} images/tilelib-direct-linkage.svg +:align: center +:width: 100% + +The direct-linkage path. cuda-oxide ships the code (LTOIR) and two +descriptions (interface and implementation bytecode); tileiras packs them +into one `.tilelib`, and a Tile kernel calls the Rust function from inside +its body. +``` + +## Writing an export + +Put `#[tile_export(tile_shape = N)]` on an ordinary function. `N` is the tile size +the caller will pass. The function stays as written, so the rest of your +device code keeps calling it. The attribute adds two items next to it: an +`extern "C"` implementation on the native SIMT ABI, named `_impl` by +default, and a host-only description that the compiler writes out as JSON. + +The +[`tilelib_relu`](https://github.com/NVIDIA/cuda-rust/tree/main/cuda-oxide/crates/rustc-codegen-cuda/examples/tilelib_relu) +example exports three functions, and this chapter follows them: + +```rust +use cuda_device::{tile_export, warp}; + +/// Elementwise `max(x, 0)`. +#[tile_export(tile_shape = 128)] +pub fn relu(x: f32) -> f32 { + if x > 0.0 { x } else { 0.0 } +} + +/// Scale a tile in place. The cuTile side knows it as `scale_in_place`. +#[tile_export( + tile_shape = 128, + name = "scale_in_place", + symbol = "scale_in_place_impl" +)] +pub fn scale(x: &mut f32, factor: f32) { + *x *= factor; +} + +/// Sum over the 32 lanes of each warp; every lane gets the warp total. +#[tile_export(tile_shape = 128, sync = "warp")] +pub fn warp_sum(x: f32) -> f32 { + let mut total = x; + let mut offset = 16; + while offset > 0 { + total += warp::shuffle_xor_f32_sync(u32::MAX, total, offset); + offset /= 2; + } + total +} +``` + +What each one becomes in the device artifact: + +| cuTile name | Rust | Implementation the call resolves to | +|:-----------------|:----------------------------------------|:---------------------------------------------------| +| `relu` | `fn relu(x: f32) -> f32` | `void relu_impl(float x, float *relu_out)` | +| `scale_in_place` | `fn scale(x: &mut f32, factor: f32)` | `void scale_in_place_impl(float *x, float factor)` | +| `warp_sum` | `fn warp_sum(x: f32) -> f32`, warp sync | `void warp_sum_impl(float x, float *warp_sum_out)` | + +`warp_sum` uses warp shuffles, which are legal because `sync = "warp"` makes +all 32 lanes of a warp call it together. The +[Warp-Level Programming](warp-level-programming.md) chapter explains the +shuffle pattern. + +### Attribute arguments + +| Argument | Meaning | Default | +|:----------------------------|:-------------------------------------------------|:-------------------| +| `tile_shape = N` | 1-D tile size, an integer literal (required) | none | +| `name = "..."` | declaration name the cuTile caller uses | the function name | +| `symbol = "..."` | implementation symbol in the device artifact | `_impl` | +| `sync = "none"` or `"warp"` | threads that must call the function together | `"none"` | +| `arch = ["sm_120", ...]` | compute capabilities the implementation supports | every architecture | + +`arch` is normally omitted, which matches every target. When given, names are +compared after stripping `_` and lowercasing, so `"sm_120"` also matches the +`sm_120a` the Tile compiler builds for. + +### Parameters and the ABI + +Every parameter is a plain identifier with one of four types. `T` is one of +`f16`, `f32`, `f64`, `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`. +Tile IR has no unsigned integers, so a `u32` parameter is an `i32` tile on the +Tile side, same bits. + +| Rust parameter | Access | Footprint | ABI parameter | +|:----------------------|:--------|:----------|:--------------------------------------| +| `x: T` | `in` | 1 | `T` by value | +| `x: &T` | `in` | 1 | `*const T` | +| `x: &[T; F]` | `in` | F | `*const T` | +| `x: &mut T` | `inout` | 1 | `*mut T` | +| `x: &mut [T; F]` | `inout` | F | `*mut T` | +| `-> T` (return value) | `out` | 1 | `*mut T`, appended last as `_out` | + +The footprint is the number of contiguous tile elements one invocation owns. +Only an `in` scalar travels by value. Everything else is a pointer to the +invocation's own elements, and the implementation returns nothing: a return +value is stored through the trailing `out` pointer. On the Tile side every +parameter, the return slot included, is one argument of the declaration, typed +as a tile of the export's size. Slices, raw pointers, tuples, structs, `bool`, +generics, `self`, and patterns in parameter position are rejected. + +### Rules the tooling enforces + +The attribute reports these at compile time: + +- `tile_shape` is present, an integer literal, and positive. A constant or an + expression is not accepted: a static library ships one concrete symbol per + export. +- The export has an output: a return value, or at least one `&mut` parameter. + A declaration's results are its `out` and `inout` arguments. +- The `out` and `inout` parameters form one contiguous run. + `fn f(a: &mut f32, b: f32) -> f32` is `[inout, in, out]` and is rejected; + write `fn f(b: f32, a: &mut f32) -> f32`, with the `in` parameters first. +- Every parameter of one export has the same footprint, because the + fragments of one implementation share their invocation count. A + `&mut [i32; 4]` next to a `&i32` would need 32 invocations for one argument + and 128 for the other, so `fn window(acc: &mut [i32; 4], bias: &i32)` is + rejected and `bias: &[i32; 4]` is the accepted form. +- `sync = "warp"` needs a tile size that is a multiple of 32 times the + footprint, so every invocation fills whole warps. +- `name` and `symbol` are ASCII identifiers outside the reserved + `cuda_oxide_` prefix. + +`cargo oxide tilelib` repeats the same checks when it reads the descriptions +back, so a hand-edited description cannot slip past them. + +## Building the library + +```bash +cargo oxide tilelib tilelib_relu --arch sm_120 --print +``` + +`--arch` is required because the LTOIR inside a library is built for one +architecture. In a standalone project, such as one made with `cargo oxide new`, +the crate name can be omitted. The command runs `emit-ltoir`, then writes the +description modules next to the device artifact: + +```text +tilelib_relu.ltoir device code for sm_120 +tilelib_relu.tileexports.json one description per export, written by the compiler +tilelib_relu.iface.tilebc declarations, Tile IR bytecode at the assembler's version +tilelib_relu.impl.tilebc implementations, same version +tilelib_relu.tilelib.mlir readable form of both; --print shows it +tilelib_relu.tilelib the library, when tileiras can build it +``` + +Before writing the modules it checks the emitted NVVM IR: every implementation +symbol must be a `define void` with the parameter list the ABI table predicts, +for example `define void @relu_impl(float, ptr)`. The assembler never looks +inside the code payload, so a missing or misdeclared symbol would otherwise +surface only when a cuTile program is compiled against the library. The two +bytecode modules are built by the `oxide-tilebc` crate, cuda-oxide's own +writer for these two kinds of module; the Tile stack's crates are not +involved. +writes its own Tile IR with. + +### Reading the dump + +`--print` shows both modules in Tile IR syntax. The text is the same as +`tilelib_relu.tilelib.mlir`. For `tilelib_relu`: + +```text +// tilelib_relu.iface.tilebc: the interface a cuTile program calls +cuda_tile.module @tilelib_relu { + cuda_tile.preview$func extern @relu(%x: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}, %relu_out: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}) -> !cuda_tile.tile<128xf32> + cuda_tile.preview$func extern @scale_in_place(%x: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}, %factor: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}) -> !cuda_tile.tile<128xf32> + cuda_tile.preview$func extern @warp_sum(%x: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}, %warp_sum_out: !cuda_tile.tile<128xf32> {cuda_tile.preview$access = #cuda_tile.preview$access}) -> !cuda_tile.tile<128xf32> +} +// tilelib_relu.impl.tilebc: the implementations the LTOIR defines +cuda_tile.module @tilelib_relu { + cuda_tile.preview$extern_impl @relu_impl implements @relu(%x: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<():()>, fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}, %relu_out: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<(1):(1)>, fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}) + cuda_tile.preview$extern_impl @scale_in_place_impl implements @scale_in_place(%x: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<(1):(1)>, fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}, %factor: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<():()>, fragmap = #cuda_tile.preview$layout<(128, 1, 1):(1, 0, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}) + cuda_tile.preview$extern_impl @warp_sum_impl implements @warp_sum(%x: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<():()>, fragmap = #cuda_tile.preview$layout<(4, 32, 1):(32, 1, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}, %warp_sum_out: !cuda_tile.preview$fragment<1xf32, local, mem_layout = #cuda_tile.preview$layout<(1):(1)>, fragmap = #cuda_tile.preview$layout<(4, 32, 1):(32, 1, 0)>> {cuda_tile.preview$access = #cuda_tile.preview$access}) + synchronization = #cuda_tile.preview$synchronization +} +``` + +How to read it: + +- The interface has one `preview$func extern` per export. Every Rust parameter + is a `tile<128xf32>` argument with its access, and the results are the + `out` and `inout` arguments in order. `relu` returns one tile, its + `relu_out` slot. +- The implementation has one `preview$extern_impl` per export, naming the + symbol it `implements`. Every argument is a `fragment`: the piece of the tile + one invocation sees. `mem_layout` is the buffer's own layout: `():()` for a + by-value scalar, `(1):(1)` for one element behind a pointer. +- `fragmap` maps `(invocations, participants, footprint)` onto the tile. + `(128, 1, 1):(1, 0, 0)` is one invocation per element, 128 of them. + `(4, 32, 1):(32, 1, 0)` is 4 invocations of 32 lanes each, which is what + `synchronization = warp` requires. + +The summary line names the artifacts and their sizes: + +```text +✓ Tile library descriptions written: 3 export(s), Tile IR 13.5 with the preview tag +``` + +### The tileiras requirement + +The descriptions are Tile IR public-preview content, which exists from +bytecode 13.5 on. An assembler reads preview content only at the version it +calls current, the newest numbered version its `--list-versions` prints, so +the command asks the resolved `tileiras` first and writes the descriptions at +that version: 13.5 for the CUDA 13.5 assembler, the newer version a newer +assembler names, and 13.5 when no assembler can read them yet. +`tileiras --preview-create-tile-lib` arrives with CUDA 13.5, the first +assembler whose `--list-versions` names 13.5. When the resolved `tileiras` +lists 13.5 or newer, the command assembles the interface, the +implementations, and the LTOIR into `tilelib_relu.tilelib` (or the path given +with `-o`) and prints the `tileiras` invocation it used. + +On CUDA 13.4 the command stops after the descriptions and says why: + +```text +Tile library skipped: /usr/local/cuda/bin/tileiras lists bytecode versions 13.1, 13.2, 13.3, 13.4; the descriptions need 13.5 or newer +The installed tileiras cannot create tile libraries: the descriptions are Tile IR public-preview content, which exists from bytecode 13.5 on and needs the CUDA 13.5 or newer assembler. +``` + +It then prints the `tileiras --preview-create-tile-lib` command that turns the +written files into the library on a newer toolkit, and exits 2 so a script +notices the missing library. `--library-optional` makes that outcome exit 0 +when the LTOIR and the descriptions are all you need. Both outcomes print a +line a script can match: `Tile library written to` on success, +`Tile library skipped:` otherwise. The assembler is resolved from +`CUTILE_TILEIRAS_PATH` first, then from `PATH`, the configured CUDA toolkit +root, and the standard install locations. The +[installation guide](../getting-started/installation.md) covers toolkit +selection. + +## Calling it from cuTile Python + +A cuTile kernel reaches the export through `cuda.tile_preview.foreign_call`. +This is the kernel from the example's `python/call_from_cutile.py`: + +```python +import cuda.tile as ct +from cuda import tile_preview as tp + +TILE = 128 +PROVIDER = tp.Tilelib(path="tilelib_relu.tilelib", version="0.1.0") + + +def relu_tile(x, y): + """One block runs `relu` over one 128-float tile of `x` into `y`.""" + pid = ct.bid(0) + tile = ct.load(x, index=(pid,), shape=(TILE,)) + # Every declaration argument needs an input tile, the `out` slot included. + result_slot = ct.zeros((TILE,), dtype=ct.float32) + (out,) = tp.foreign_call( + tilelibs=(PROVIDER,), + symbol_name="relu", + constant_params=(), + inputs=(tile, result_slot), + output_types=((ct.float32, (TILE,)),), + ) + ct.store(y, index=(pid,), tile=out) +``` + +Three things to get right: + +- `symbol_name` is the declaration name, `relu`, not the implementation symbol + `relu_impl`. The Tile compiler resolves the call to the implementation when + it links the library. +- Every declaration argument takes a tile, the `out` ones included. `relu` has + two arguments, so `inputs` has two tiles; a zero tile stands in for the + result slot. A scalar needs a 0-d tile, and a Python literal is rejected. +- `output_types` lists the results, one `(dtype, shape)` per `out` or `inout` + argument in declaration order. `relu` has one. + +`foreign_call` reads the library as a compile-time constant, so the `Tilelib` +is a module global rather than a kernel argument, and its file has to exist +when the kernel is traced. The script's `--dry-run` compiles the kernel to +bytecode without `tileiras`, which works on CUDA 13.4 today: + +```text +bytecode: 844 bytes, header 0d050100 (version 13.5, preview flag set) +PASS: the caller side compiles; the program calls `relu` through preview$call (dry run, no cubin) +``` + +The full run needs the `.tilelib` from a CUDA 13.5 or newer `tileiras` and +a cuTile Python that lists that assembler's current bytecode version, because +preview content is read only at that version. + +## Calling it from Tile C++ + +The same toolkit that brings the assembler teaches nvcc `--enable-tile` and +`--tile-preview simt`, and a Tile C++ kernel calls the library through a +foreign declaration. The example's `cpp/tile_caller.cu` declares all three +exports; this is the `relu` one: + +```text +namespace ct = cuda::tiles; +using tile_f32 = ct::tile>; + +// @relu(%x: tile<128xf32> in, %relu_out: tile<128xf32> out) -> tile<128xf32> +__experimental_foreign_decl__ __experimental_foreign_name__("relu") + tile_f32 relu(tile_f32 x, [[cutile::experimental_inout]] tile_f32 relu_out); + +[[cutile::hint(0, num_worker_warps_per_cta = 4)]] __tile_global__ void kernel(float* x, float* y) { + auto xs = ct::partition_view { ct::tensor_span { x, ct::shape<128> {} }, ct::shape<128> {} }; + auto ys = ct::partition_view { ct::tensor_span { y, ct::shape<128> {} }, ct::shape<128> {} }; + ys.store(relu(xs.load(0), ys.load(0)), 0); +} +``` + +A parameter the library reads carries no attribute; one it writes carries +`[[cutile::experimental_inout]]` and comes back as the call's result, in +argument order. The declaration's name is the library's declaration name, +not the implementation symbol. Compile and run: + +```bash +nvcc --enable-tile --tile-preview simt -Xtileiras=-l=tilelib_relu.tilelib \ + -std=c++20 -arch=sm_120 -o tile_caller cpp/tile_caller.cu +./tile_caller +``` + +```text +PASS relu: 128 elements through the tile library +PASS scale_in_place: 128 elements through the tile library +PASS warp_sum: 128 elements through the tile library, every lane holding its warp's total +SUCCESS: 3/3 tile exports called from a Tile C++ kernel +``` + +Because nvcc, tileiras and the Tile C++ front end come from one toolkit, the +program and the library always agree on the bytecode version. That is the +shortest path to a running Tile kernel on top of a Rust library; the cuTile +Python path needs a cuTile Python that lists the same assembler's version. + +## What happens at the boundary + +The Tile compiler never hands your function a whole tile. It splits each tile +argument into fragments, one per invocation, and calls the implementation once +per fragment. With `sync = "none"` a fragment is one element, so a 128-element +tile means 128 calls, each from one thread. With `sync = "warp"` an invocation +is a whole warp: 32 lanes call together, each with its own element, and warp +intrinsics are legal inside. The calling thread is a real thread of the Tile +kernel, and `threadIdx.x` reads the hardware register, so lane and warp +identity work as in any SIMT kernel (see the +[Execution Model](../gpu-programming/execution-model.md)). + +The pointers you receive point at the invocation's own buffer and nothing +else. `&mut f32` is one element and `&mut [f32; 4]` is four contiguous +elements; the function may not reach past them, and nothing outside the +invocation aliases them during the call. The function cannot allocate shared +memory, so do not declare a `SharedArray` in an export: the shared memory of a +Tile kernel is the Tile compiler's to place, and this release has no way to +request a scratch buffer from it (see +[Shared Memory and Synchronization](shared-memory-and-synchronization.md) +for what shared memory means in a SIMT kernel). Keep exports to registers, +the parameters they receive, and warp traffic. + +## Not in this release + +- Parametric tile sizes. `tile_shape` is one integer literal, so a library ships one + export per tile size. +- Warpgroup and CTA scope. `sync` accepts `"none"` and `"warp"` only. +- Scratch memory. An export cannot ask for a shared-memory buffer. +- `bf16` parameters. The attribute accepts `f16` but not `bf16` yet. +- 2-D tiles. `tile_shape` has one extent. +- Linkage providers, the form of a library that compiles implementations on + demand while the Tile compiler runs. They are not a public CUDA 13.5 + surface. A static library ships one implementation per declaration. +- A cutile-rs caller. Only cuTile Python has `foreign_call` today. + +The [Supported Features](../appendix/supported-features.md) appendix tracks +the interop status alongside the rest of the compiler. + +### Verifying the ABI on CUDA 13.4 + +The `.tilelib` needs the CUDA 13.5 or newer assembler, but the ABI can be +proven today. The example's +host program stands in for the Tile compiler: + +```bash +cargo oxide run tilelib_relu --emit-nvvm-ir --arch sm_120 +``` + +It reads `tilelib_relu.tileexports.json`, generates `mock/caller.cu` with the +prototypes the ABI table predicts and one kernel per export, compiles that with +`nvcc` to LTOIR, links it with the Rust LTOIR through nvJitLink, the same +two-input link a consumed library gets, and runs one block of 128 threads per +export on the GPU. Every result is compared bit for bit: + +```text +PASS relu: 128 elements through `relu_impl`, relu of a ramp from -4 to 4 +PASS scale_in_place: 128 elements through `scale_in_place_impl`, the ramp scaled in place by 0.5 +PASS warp_sum: 128 elements through `warp_sum_impl`, 32-lane sums over 0..128, every lane holding its warp's total +SUCCESS: 3/3 tile exports verified through the native ABI +``` + +The prototypes in `mock/caller.cu` are derived from the descriptions, not +written by hand, so the generated file is the ABI as the tooling understands +it. Without `nvcc`, or on a GPU that does not match `--arch`, the program +prints `skipping:` with the reason and exits 0. diff --git a/cuda-oxide/cuda-oxide-book/appendix/supported-features.md b/cuda-oxide/cuda-oxide-book/appendix/supported-features.md index 5081ab5e30..c038225a85 100644 --- a/cuda-oxide/cuda-oxide-book/appendix/supported-features.md +++ b/cuda-oxide/cuda-oxide-book/appendix/supported-features.md @@ -160,7 +160,7 @@ Anonymous promoted allocations remain unsupported. | Bi-directional LTOIR Support | **Full** | Rust kernels call CUDA C++ device functions **and** C++ calls Rust device functions. Via NVVM IR → libNVVM → LTOIR → nvJitLink. | | Device FFI (`extern "C"`) | **Full** | `#[device] extern "C" { fn ... }` declarations for external LTOIR functions. CUB/CCCL integration demonstrated. | | MathDx FFI (cuFFTDx / cuBLASDx) | **Full** | cuFFTDx (8/16/32-point thread-level FFT), cuBLASDx (32x32x32 block-level GEMM) via LTOIR. | -| Tile interop | **Partial** | Inter-kernel interop works today: a [cutile-rs Tile kernel](https://github.com/NVIDIA/cuda-rust/tree/main/cutile-rs) and a cuda-oxide SIMT PTX kernel can run in one host process on the same CUDA stream over shared device tensors. Intra-kernel Tile interop is work in progress and tracked in [#96](https://github.com/NVlabs/cuda-oxide/issues/96). | +| Tile interop | **Partial** | Inter-kernel interop works today: a [cutile-rs Tile kernel](https://github.com/NVIDIA/cuda-rust/tree/main/cutile-rs) and a cuda-oxide SIMT PTX kernel can run in one host process on the same CUDA stream over shared device tensors. Intra-kernel interop is built as a [tile library](../advanced/tile-libraries.md): `#[tile_export]` and `cargo oxide tilelib` produce the LTOIR and the Tile IR descriptions today (at the installed assembler's current bytecode version, 13.5 or newer), packaging them into a `.tilelib` needs the CUDA 13.5 or newer `tileiras`, and the caller is cuTile Python's `foreign_call`. Tracked in [#96](https://github.com/NVlabs/cuda-oxide/issues/96). | | Cross-Crate Kernels | **Full** | Kernels and device functions defined in library crates with monomorphization at the binary crate use site. | ## Compiler: Functions diff --git a/cuda-oxide/cuda-oxide-book/compiler/architecture-overview.md b/cuda-oxide/cuda-oxide-book/compiler/architecture-overview.md index 60ca175d69..efe28cf34e 100644 --- a/cuda-oxide/cuda-oxide-book/compiler/architecture-overview.md +++ b/cuda-oxide/cuda-oxide-book/compiler/architecture-overview.md @@ -146,6 +146,8 @@ cuda-oxide is split into focused crates. Here is every one and its role: | `cuda-intrinsics-gen`| Extractor and deterministic source generator for the intrinsics | | `cuda-artifact-finalizer` | Driver-independent NVVM IR, LTOIR, and PTX finalization | | `oxide-artifacts` | Architecture-neutral embedded device artifact metadata | +| `oxide-tile-export` | `#[tile_export]` descriptions shared by the macro, the backend and `cargo oxide tilelib` | +| `oxide-tilebc` | Tile IR bytecode writer for the tile library descriptions `cargo oxide tilelib` emits | | `dialect-iket` | pliron dialect modelling in-kernel event tracing | | `iket-lower` | `dialect-iket` profiles + instrumentation lowering | | `dialect-ptx` | pliron dialect modelling structured PTX | diff --git a/cuda-oxide/cuda-oxide-book/getting-started/installation.md b/cuda-oxide/cuda-oxide-book/getting-started/installation.md index eb929a4eaf..5a6740b18d 100644 --- a/cuda-oxide/cuda-oxide-book/getting-started/installation.md +++ b/cuda-oxide/cuda-oxide-book/getting-started/installation.md @@ -327,6 +327,7 @@ The full set, as `cargo oxide --help` reports it: | `fuzz-schedule` | Find schedule-sensitive failures by perturbing an example's generated PTX | | `test` | Run Cargo tests through the cuda-oxide backend | | `emit-ltoir` | Compile a crate's device code to a binary LTOIR artifact in one step | +| `tilelib` | Package a crate's `#[tile_export]` functions as a cuTile tile library | | `pipeline` | Show the full compilation pipeline (MIR -> PTX/NVVM IR) with verbose output | | `debug` | Build with debug info and launch `cuda-gdb` | | `list` | List the examples bundled with the cuda-oxide workspace | diff --git a/cuda-oxide/cuda-oxide-book/index.md b/cuda-oxide/cuda-oxide-book/index.md index 5c15827081..1529d376cb 100644 --- a/cuda-oxide/cuda-oxide-book/index.md +++ b/cuda-oxide/cuda-oxide-book/index.md @@ -178,6 +178,7 @@ advanced/warp-level-programming advanced/tensor-memory-accelerator advanced/matrix-multiply-accelerators advanced/cluster-programming +advanced/tile-libraries ``` ```{toctree} diff --git a/cuda-oxide/dependency-licenses.csv b/cuda-oxide/dependency-licenses.csv index e6b8722489..57b9c14f47 100644 --- a/cuda-oxide/dependency-licenses.csv +++ b/cuda-oxide/dependency-licenses.csv @@ -82,6 +82,8 @@ nvvm-transforms,0.2.1,Apache-2.0,Yes,local (workspace),1st Party (workspace),htt object,0.36.7,Apache-2.0 OR MIT,Yes,registry+https://github.com/rust-lang/crates.io-index,3rd Party (crates.io),https://github.com/gimli-rs/object,A unified interface for reading and writing object file formats.,ELF reading and writing behind oxide-artifacts' object features. once_cell,1.21.3,MIT OR Apache-2.0,Yes,registry+https://github.com/rust-lang/crates.io-index,3rd Party (crates.io),https://github.com/matklad/once_cell,Single assignment cells and lazy values., oxide-artifacts,0.2.1,Apache-2.0,Yes,registry+https://github.com/rust-lang/crates.io-index,1st Party (crates.io),https://github.com/NVIDIA/cuda-rust,Architecture-neutral embedded device artifact metadata for cuda-oxide,"Consumed from crates.io by the backend (writer) and by the shared cuda-core (reader) so both see one crate; crates/oxide-artifacts in this workspace is the source it is published from." +oxide-tile-export,0.2.1,Apache-2.0,Yes,local (workspace),1st Party (workspace),https://github.com/NVIDIA/cuda-rust,Descriptions of Rust device functions exported to cuTile tile libraries,Shared by #[tile_export] (cuda-macros) and the rustc-codegen-cuda backend; cargo oxide tilelib reads the .tileexports.json it describes. +oxide-tilebc,0.2.1,Apache-2.0,Yes,local (workspace),1st Party (workspace),https://github.com/NVIDIA/cuda-rust,Tile IR bytecode writer for the tile library descriptions cuda-oxide ships,cargo oxide tilelib writes a library's interface and implementation bytecode with it; no CUDA dependency. pliron,0.20.0,Apache-2.0,Yes,registry+https://github.com/rust-lang/crates.io-index,3rd Party (crates.io),https://github.com/pliron-org/pliron,Programming Languages Intermediate RepresentatiON,"Primary dependency: MLIR-inspired IR framework. Custom MLIR dialects (MIR, LLVM, NVVM) built on this. Exact published release shared by the compiler workspaces." pliron-derive,0.20.0,Apache-2.0,Yes,registry+https://github.com/rust-lang/crates.io-index,3rd Party (crates.io),https://github.com/pliron-org/pliron,Derive macros for pliron,Proc-macro companion pinned to the same published release as pliron. pliron-llvm,0.20.0,Apache-2.0,Yes,registry+https://github.com/rust-lang/crates.io-index,3rd Party (crates.io),https://github.com/pliron-org/pliron,LLVM dialect for pliron,Upstream LLVM dialect modeling; re-exported by llvm-export with std enabled and the llvm-sys FFI bridge disabled. Same published release as pliron. diff --git a/cuda-oxide/scripts/check-example-smoketest-contract.sh b/cuda-oxide/scripts/check-example-smoketest-contract.sh index 6ec700e8f0..710032d4e8 100644 --- a/cuda-oxide/scripts/check-example-smoketest-contract.sh +++ b/cuda-oxide/scripts/check-example-smoketest-contract.sh @@ -309,6 +309,7 @@ CATEGORY_LISTS = ( "BLACKWELL_MMA_EXAMPLES", "LTOIR_EXAMPLES", "LTOIR_MODERN_EXAMPLES", + "TILELIB_EXAMPLES", "AUTO_NVVM_EXAMPLES", "IKET_EXAMPLES", "BLACKWELL_COMPILE_EXAMPLES", diff --git a/cuda-oxide/scripts/smoketest.sh b/cuda-oxide/scripts/smoketest.sh index 92823ad212..0d23fca93e 100755 --- a/cuda-oxide/scripts/smoketest.sh +++ b/cuda-oxide/scripts/smoketest.sh @@ -40,6 +40,20 @@ # Blackwell+ (CC >= 10.0) and requires full execution # there; elsewhere compiles for the sm_100 floor and # requires the NVVM IR (`.ll`) plus its `.target` sidecar. +# tilelib -- a tile library written in Rust (`#[tile_export]`). +# `cargo oxide tilelib --arch= --library-optional` +# must exit 0 and leave the LTOIR, the interface and the +# implementation bytecode (`.iface.tilebc`, `.impl.tilebc`) +# and the readable `.tilelib.mlir`. cargo-oxide decides +# itself whether the installed tileiras can build the +# `.tilelib` (it lists bytecode 13.5, CUDA 13.5+) and ends +# its summary with one of two lines: after "Tile library +# written to" the `.tilelib` must exist too, after "Tile +# library skipped" it is not required; neither line fails +# the lane. Then the example's host program runs through +# `cargo oxide run --emit-nvvm-ir --arch=` and must +# print the SUCCESS marker, or opt out with `skipping:`. +# --compile-only stops after the first step. # auto-nvvm -- runs without NVVM or architecture flags to check automatic # libdevice and target selection. Compile-only CI supplies a # target because no GPU is available. @@ -78,6 +92,7 @@ WGMMA_EXAMPLES=(wgmma) BLACKWELL_MMA_EXAMPLES=(mma_mxf8f6f4) LTOIR_EXAMPLES=(addressof_sharedarray cpp_consumes_rust_device device_ffi_test legacy_atomic_fadd legacy_atomic_rmw_cas legacy_nvvm_pointer_shapes manual_launch_libdevice mathdx_ffi_test primitive_stress) LTOIR_MODERN_EXAMPLES=(small_type_ffi_test) +TILELIB_EXAMPLES=(tilelib_relu) AUTO_NVVM_EXAMPLES=(libdevice_math) IKET_EXAMPLES=(iket_trace) BLACKWELL_COMPILE_EXAMPLES=(generated_intrinsics_blackwell) @@ -126,6 +141,7 @@ classify() { for cat in "${BLACKWELL_MMA_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo blackwell-mma; return; }; done for cat in "${LTOIR_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo ltoir; return; }; done for cat in "${LTOIR_MODERN_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo ltoir-modern; return; }; done + for cat in "${TILELIB_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo tilelib; return; }; done for cat in "${AUTO_NVVM_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo auto-nvvm; return; }; done for cat in "${IKET_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo iket; return; }; done for cat in "${BLACKWELL_COMPILE_EXAMPLES[@]}"; do [[ "$ex" == "$cat" ]] && { echo blackwell-compile; return; }; done @@ -150,6 +166,45 @@ example_never_launches() { return 1 } +example_is_tilelib() { + local ex="$1" candidate + for candidate in "${TILELIB_EXAMPLES[@]}"; do + [[ "${ex}" == "${candidate}" ]] && return 0 + done + return 1 +} + +# The two summary lines `cargo oxide tilelib` ends with, one of which every +# successful run prints: the library was written, or skipped because the +# resolved tileiras cannot build one. They are constants in +# crates/cargo-oxide/src/commands/tilelib.rs (LIBRARY_WRITTEN_MARKER, +# LIBRARY_SKIPPED_MARKER) and a unit test there pins the text grepped here. +# cargo-oxide resolves tileiras and reads its `--list-versions` itself, so the +# lane takes its verdict from the log instead of probing the assembler a +# second time with a search order of its own. +tilelib_library_written() { + grep -qF 'Tile library written to' "$1" +} + +tilelib_library_skipped() { + grep -qF 'Tile library skipped' "$1" +} + +# Names, space separated, of the tilelib artifacts `cargo oxide tilelib` must +# have left for ${1} given its log ${2}; empty when every one is present. The +# LTOIR, the two bytecode halves and the readable dump are always required; +# the `.tilelib` itself when the log says it was written. +tilelib_missing_artifacts() { + local ex_dir="crates/rustc-codegen-cuda/examples/$1" artifact="${1//-/_}" log="$2" missing="" file + for file in "${artifact}.ltoir" "${artifact}.iface.tilebc" "${artifact}.impl.tilebc" "${artifact}.tilelib.mlir"; do + [[ -s "${ex_dir}/${file}" ]] || missing="${missing} ${file}" + done + if tilelib_library_written "${log}" && [[ ! -s "${ex_dir}/${artifact}.tilelib" ]]; then + missing="${missing} ${artifact}.tilelib" + fi + printf '%s' "${missing# }" +} + full_debug_uses_configured_route() { local ex="$1" candidate for candidate in "${FULL_DEBUG_CONFIGURED_ROUTE_EXAMPLES[@]}"; do @@ -872,6 +927,40 @@ verdict_ltoir_modern() { return 1 } +verdict_tilelib() { + local ex="$1" log="$2" ec="$3" + if [[ ${ec} -gt 128 ]]; then echo "FAIL (crashed, signal $((ec - 128)))"; return 1; fi + # The descriptions come first. `cargo oxide tilelib` prints this line + # once both bytecode halves are on disk, and run_tilelib records a + # missing artifact in the log with a failing exit code, so the marker is + # the proof that the library half finished before the host program ran. + if ! grep -qF 'Tile library descriptions written' "${log}"; then + echo "FAIL (tilelib, descriptions not written)" + return 1 + fi + if [[ ${ec} -ne 0 ]]; then echo "FAIL (tilelib, exit=${ec})"; return 1; fi + # The host program opts out without nvcc or a matching GPU; the + # descriptions still had to be written. + if grep -qE '^[[:space:]]*skipping:' "${log}"; then + echo "PASS (tilelib, descriptions written, host check skipped)" + return 0 + fi + if grep_failure_markers "${log}"; then + echo "FAIL (tilelib, failure marker in output)" + return 1 + fi + if grep -qE 'SUCCESS|PASS|Complete' "${log}"; then + if tilelib_library_written "${log}"; then + echo "PASS (tilelib, .tilelib built, ABI verified on ${LTOIR_ARCH})" + else + echo "PASS (tilelib, descriptions written, ABI verified on ${LTOIR_ARCH})" + fi + return 0 + fi + echo "FAIL (tilelib, no success marker)" + return 1 +} + verdict_iket() { local ex="$1" log="$2" ec="$3" local ex_dir="crates/rustc-codegen-cuda/examples/${ex}" @@ -975,6 +1064,24 @@ verdict_compile() { echo "FAIL (libNVVM compile produced no fresh LTOIR)" return 1 fi + if [[ ${FULL_DEBUG} -eq 0 ]] && example_is_tilelib "${ex}"; then + # run_tilelib ran the library step only. It already failed the exit + # code on a missing artifact or a missing summary line; naming the + # artifacts here tells a built library apart from descriptions alone + # in the summary, with cargo-oxide's own reason for skipping it. + local missing + missing="$(tilelib_missing_artifacts "${ex}" "${log}")" + if [[ -n "${missing}" ]]; then + echo "FAIL (tilelib, missing ${missing})" + return 1 + fi + if tilelib_library_written "${log}"; then + echo "PASS (tilelib descriptions and .tilelib for ${LTOIR_ARCH})" + else + echo "PASS (tilelib descriptions for ${LTOIR_ARCH}; $(grep -F 'Tile library skipped' "${log}" | head -1))" + fi + return 0 + fi if [[ -s "${ex_dir}/${artifact}.ptx" ]]; then # Nothing executes in compile-only mode, so every emitted PTX must # at least assemble: driver-JIT-only errors (e.g. .shared symbols @@ -1228,6 +1335,7 @@ run_full_debug_build() { blackwell-mma) arch="sm_120a" ;; ltoir) arch="${LTOIR_ARCH}" ;; ltoir-modern) arch="${LTOIR_MODERN_ARCH}" ;; + tilelib) arch="${LTOIR_ARCH}" ;; auto-nvvm) arch="${LTOIR_ARCH}" ;; iket) arch="sm_90" ;; blackwell-compile) arch="sm_120a" ;; @@ -2035,6 +2143,12 @@ run_cargo() { return fi + # Tile libraries have their own two-step lane in every mode. + if [[ "${cat}" == "tilelib" ]]; then + run_tilelib "${ex}" "${log}" + return + fi + # Designated NVVM examples use `emit-ltoir` in compile-only mode so CI # checks both textual export and real libNVVM compilation. Other examples # use `build`. @@ -2223,6 +2337,59 @@ run_cargo() { fi } +# The tilelib lane: the library half first, then the example's own host +# program, both through `cargo oxide` the way the example's README runs +# them. `--library-optional` lets the first step exit 0 on a toolkit whose +# tileiras cannot build a `.tilelib`; whether that step had to leave one is +# read from its own summary line (tilelib_library_written). The second step +# rebuilds the device half, and a rebuild clears every generated artifact, +# so the artifacts are checked in between and a gap is recorded in the log +# with a failing CARGO_EC, as the other lanes do. +run_tilelib() { + local ex="$1" log="$2" note="" + local -a args=("tilelib" "${ex}" "--arch=${LTOIR_ARCH}" "--library-optional") + if [[ ${VERBOSE} -eq 1 ]]; then + cargo oxide "${args[@]}" 2>&1 | tee "${log}" + CARGO_EC=${PIPESTATUS[0]} + else + cargo oxide "${args[@]}" >"${log}" 2>&1 + CARGO_EC=$? + fi + if [[ ${CARGO_EC} -ne 0 ]]; then + return + fi + # Exit 0 without either summary line means the command's contract + # changed under this lane, not that a library is optional. + if ! tilelib_library_written "${log}" && ! tilelib_library_skipped "${log}"; then + note="${ex}: cargo oxide tilelib --library-optional exited 0 without reporting the tile library as written or skipped" + else + local missing + missing="$(tilelib_missing_artifacts "${ex}" "${log}")" + if [[ -n "${missing}" ]]; then + note="${ex}: cargo oxide tilelib --library-optional exited 0 but left no ${missing}" + fi + fi + if [[ -n "${note}" ]]; then + printf '%s\n' "${note}" >>"${log}" + if [[ ${VERBOSE} -eq 1 ]]; then + printf '%s\n' "${note}" + fi + CARGO_EC=1 + return + fi + if [[ ${COMPILE_ONLY} -eq 1 ]]; then + return + fi + local -a run_args=("run" "${ex}" "--emit-nvvm-ir" "--arch=${LTOIR_ARCH}") + if [[ ${VERBOSE} -eq 1 ]]; then + cargo oxide "${run_args[@]}" 2>&1 | tee -a "${log}" + CARGO_EC=${PIPESTATUS[0]} + else + cargo oxide "${run_args[@]}" >>"${log}" 2>&1 + CARGO_EC=$? + fi +} + # ---- Shared example target dir ------------------------------------------- # # Each example under crates/rustc-codegen-cuda/examples/ is its own standalone @@ -2332,6 +2499,7 @@ for ex in "${selected[@]}"; do blackwell-mma) verdict="$(verdict_blackwell_mma "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; ltoir) verdict="$(verdict_ltoir "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; ltoir-modern) verdict="$(verdict_ltoir_modern "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; + tilelib) verdict="$(verdict_tilelib "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; auto-nvvm) verdict="$(verdict_ltoir "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; iket) verdict="$(verdict_iket "${ex}" "${log}" "${ec}")" && status=0 || status=$? ;; standard) verdict="$(verdict_standard "${log}" "${ec}" "${ex}")" && status=0 || status=$? ;;