feat(cuda+py): Phase 1.5++ — NVRTC spawn-path + compile/launch

atomr-accel-cuda: ContextActor now spawns NvrtcActor when feature
`nvrtc` is on AND EnabledLibraries::NVRTC is set. KernelChildren gains
a typed `nvrtc: Option<ActorRef<NvrtcMsg>>` field (mirrors the
cuSOLVER spawn-path from 3e40c03).

atomr-accel-py: Device.compile_kernel(name, src, ...) returns an
NvrtcKernel; NvrtcKernel.launch(grid, block, args, shared) dispatches
typed KernelArg payloads. KernelArg is a one-shot Python wrapper with
constructors for scalar f32/f64/i32/i64/u32/u64 and device-pointer
buffers across every supported GpuBuffer* dtype (f32/f64/i32/u32/u8).
The NVRTC message variants are NvrtcMsg::Compile { src, kernel_name,
opts, reply } and NvrtcMsg::Launch { kernel, args, cfg, reply } —
matched against the actor source. NvrtcOpts is left at default for
now; Phase-5 builder surface (LTO, --std=c++17, SmArch, name
expressions) is a follow-up.

Refs: #1

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cognect

crates/atomr-accel-cuda/src/device/context_actor.rs

@@ -215,6 +215,20 @@ impl ContextActor {
                     children.solver = Some(solver_stub);
                 }
             }
+            #[cfg(feature = "nvrtc")]
+            {
+                if self.config.enabled_libraries.contains(EnabledLibraries::NVRTC) {
+                    let nvrtc_stub = ctx
+                        .spawn::<crate::kernel::NvrtcActor>(
+                            crate::kernel::NvrtcActor::mock_props(),
+                            "nvrtc",
+                        )
+                        .unwrap_or_else(|e| {
+                            panic!("Unrecoverable: spawn mock NvrtcActor: {e}")
+                        });
+                    children.nvrtc = Some(nvrtc_stub);
+                }
+            }
             self.children = Some(children.clone());
             self.parent.tell(DeviceMsg::ContextReady { children });
             info!(device_id, "ContextActor (mock) ready");
@@ -350,6 +364,24 @@ impl ContextActor {
             None
         };
 
+        #[cfg(feature = "nvrtc")]
+        let nvrtc_ref = if libs.contains(EnabledLibraries::NVRTC) {
+            let s = allocator.acquire(Default::default());
+            let props = crate::kernel::NvrtcActor::props(
+                s,
+                allocator.clone(),
+                self.completion.clone(),
+                self.state.clone(),
+                cuda_ctx.clone(),
+            );
+            Some(
+                ctx.spawn::<crate::kernel::NvrtcActor>(props, "nvrtc")
+                    .unwrap_or_else(|e| panic!("Unrecoverable: spawn NvrtcActor: {e}")),
+            )
+        } else {
+            None
+        };
+
         #[allow(unused_mut)]
         let mut children = KernelChildren::new(blas_ref);
         #[cfg(feature = "cudnn")]
@@ -368,6 +400,10 @@ impl ContextActor {
         {
             children.solver = solver_ref;
         }
+        #[cfg(feature = "nvrtc")]
+        {
+            children.nvrtc = nvrtc_ref;
+        }
         self.children = Some(children.clone());
         self.parent.tell(DeviceMsg::ContextReady { children });
         info!(

crates/atomr-accel-cuda/src/device/device_actor.rs

@@ -337,6 +337,8 @@ pub struct KernelChildren {
     pub rng: Option<ActorRef<crate::kernel::RngMsg>>,
     #[cfg(feature = "cusolver")]
     pub solver: Option<ActorRef<crate::kernel::SolverMsg>>,
+    #[cfg(feature = "nvrtc")]
+    pub nvrtc: Option<ActorRef<crate::kernel::NvrtcMsg>>,
     /// TypeId-keyed registry for child actors not represented by a
     /// typed field above. The `Arc<RwLock<…>>` keeps `KernelChildren`
     /// `Clone` while letting later library crates register / look up
@@ -359,6 +361,8 @@ impl KernelChildren {
             rng: None,
             #[cfg(feature = "cusolver")]
             solver: None,
+            #[cfg(feature = "nvrtc")]
+            nvrtc: None,
             extras: Arc::new(RwLock::new(HashMap::new())),
         }
     }

crates/atomr-accel-py/python/atomr_accel/__init__.py

@@ -97,6 +97,7 @@ def _try_import(name):
 Solver = _try_import("Solver")
 Collective = _try_import("Collective")
 NvrtcKernel = _try_import("NvrtcKernel")
+KernelArg = _try_import("KernelArg")
 
 # Phase 1.5 — IPC handles (cfg cuda-ipc)
 IpcMemHandle = _try_import("IpcMemHandle")
@@ -150,6 +151,7 @@ def _try_import(name):
     "Solver",
     "Collective",
     "NvrtcKernel",
+    "KernelArg",
     # Phase 2 — patterns
     "DynamicBatchingServer",
     "InferenceCascade",

crates/atomr-accel-py/python/atomr_accel/nvrtc.py

@@ -1,16 +1,20 @@
-"""``atomr_accel.nvrtc`` — NvrtcKernel handle.
+"""``atomr_accel.nvrtc`` — NVRTC compile + launch surface.
 
-Phase 1 keeps the existing ``NvrtcKernel`` stub (``name``, ``generation``).
-The device-side ``compile_kernel`` and ``launch`` paths require
-``SnapshotChildren`` plumbing plus typed ``KernelArg`` marshalling; both
-follow in the Phase 1.5 NVRTC tracking issue.
+Phase 1.5++ wires the full path:
 
-On builds without NVRTC, ``NvrtcKernel`` is ``None``.
+  * ``Device.compile_kernel(name, src, ...)`` returns an
+    :class:`NvrtcKernel`.
+  * :class:`NvrtcKernel.launch(grid, block, args, ...)` dispatches
+    typed :class:`KernelArg` payloads (scalar f32/f64/i32/i64/u32/u64
+    plus device-pointer wrappers around every supported ``GpuBuffer*``).
+
+On builds without NVRTC, ``NvrtcKernel`` and ``KernelArg`` are ``None``.
 """
 
 try:
-    from ._native import NvrtcKernel
+    from ._native import NvrtcKernel, KernelArg
 except ImportError:
     NvrtcKernel = None  # type: ignore[assignment]
+    KernelArg = None  # type: ignore[assignment]
 
-__all__ = ["NvrtcKernel"]
+__all__ = ["NvrtcKernel", "KernelArg"]

crates/atomr-accel-py/src/device.rs

@@ -389,6 +389,14 @@ impl PyDevice {
                 {
                     dict.set_item("cusolver", false)?;
                 }
+                #[cfg(feature = "nvrtc")]
+                {
+                    dict.set_item("nvrtc", children.nvrtc.is_some())?;
+                }
+                #[cfg(not(feature = "nvrtc"))]
+                {
+                    dict.set_item("nvrtc", false)?;
+                }
                 dict.set_item("extras", children.extras_len())?;
             }
             None => {
@@ -397,6 +405,7 @@ impl PyDevice {
                 dict.set_item("cufft", false)?;
                 dict.set_item("curand", false)?;
                 dict.set_item("cusolver", false)?;
+                dict.set_item("nvrtc", false)?;
                 dict.set_item("extras", 0usize)?;
                 dict.set_item("ready", false)?;
             }
@@ -488,6 +497,31 @@ impl PyDevice {
         Py::new(py, crate::solver::PySolver::new(h))
     }
 
+    /// JIT-compile a CUDA C++ kernel via NVRTC. Returns an
+    /// [`crate::nvrtc::PyNvrtcKernel`] which can be launched via
+    /// `kernel.launch(grid, block, args, ...)`. Requires the `nvrtc`
+    /// cargo feature at build time *and* `EnabledLibraries::NVRTC` on
+    /// this device. In mock mode the actor is spawned but every
+    /// compile returns `Unrecoverable("NvrtcActor in mock mode")`.
+    #[cfg(feature = "nvrtc")]
+    #[pyo3(signature = (name, src, timeout_secs=60.0))]
+    fn compile_kernel(
+        &self,
+        py: Python<'_>,
+        name: String,
+        src: String,
+        timeout_secs: f64,
+    ) -> PyResult<Py<crate::nvrtc::PyNvrtcKernel>> {
+        let kc = self
+            .snapshot_children(py, timeout_secs)?
+            .ok_or_else(|| errors::map_str("device children not ready"))?;
+        let actor = kc
+            .nvrtc
+            .clone()
+            .ok_or_else(|| errors::map_str("NVRTC actor not enabled on this device"))?;
+        crate::nvrtc::compile_via_actor(py, actor, name, src, timeout_secs)
+    }
+
     fn __repr__(&self) -> String {
         format!("Device(id={})", self.device_id)
     }