[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-nvidia-doca-gpunetio-ib-write-lat":3,"mdc-47oupi-key":34,"related-repo-nvidia-doca-gpunetio-ib-write-lat":1459,"related-org-nvidia-doca-gpunetio-ib-write-lat":1563},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":23,"repoUrl":24,"updatedAt":25,"license":26,"forks":27,"topics":28,"repo":29,"sourceUrl":32,"mdContent":33},"doca-gpunetio-ib-write-lat","measure GPUNetIO RDMA write latency","Use this skill when the user is measuring GPU-kernel-initiated RDMA WRITE latency through doca-gpunetio — building and running the `gpunetio_ib_write_lat` client + server pair under `doca\u002Ftools\u002Fgpunetio_ib_write_lat\u002F`, checking GPU-NIC pairing, reading the half-iter \u002F full-iter \u002F CUDA-side usec columns, characterizing median \u002F p99 \u002F jitter for a real-time control loop, picking GPUNetIO vs GPI vs CPU-initiated `perftest`, or weighing the latency-vs-batching trade-off. Trigger even without 'GPUNetIO' or 'ib_write_lat': 'GPU kernel RDMA latency benchmark', 'how fast can a CUDA kernel post a WRITE', 'p99 RDMA latency on H100 + ConnectX', 'kernel-launched WR tail latency', or 'compare GPU-init vs CPU-init perftest'. Route elsewhere for bandwidth runs (doca-gpunetio-ib-write-bw), the GPI surface (doca-gpi), library debugging (doca-gpunetio), or DOCA install.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},"nvidia","NVIDIA","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fnvidia.png",[12,16,19,20],{"name":13,"slug":14,"type":15},"Performance","performance","tag",{"name":17,"slug":18,"type":15},"Benchmarking","benchmarking",{"name":9,"slug":8,"type":15},{"name":21,"slug":22,"type":15},"Engineering","engineering",2473,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills","2026-07-30T05:28:19.397412","Apache-2.0",281,[],{"repoUrl":24,"stars":23,"forks":27,"topics":30,"description":31},[],"AI agent skills published by NVIDIA","https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills\u002Ftree\u002FHEAD\u002Fskills\u002Fdoca-gpunetio-ib-write-lat","---\nlicense: Apache-2.0\nname: doca-gpunetio-ib-write-lat\ndescription: >\n  Use this skill when the user is measuring GPU-kernel-initiated RDMA\n  WRITE latency through doca-gpunetio — building and running the\n  `gpunetio_ib_write_lat` client + server pair under\n  `doca\u002Ftools\u002Fgpunetio_ib_write_lat\u002F`, checking GPU-NIC pairing,\n  reading the half-iter \u002F full-iter \u002F CUDA-side usec columns,\n  characterizing median \u002F p99 \u002F jitter for a real-time control loop,\n  picking GPUNetIO vs GPI vs CPU-initiated `perftest`, or weighing the\n  latency-vs-batching trade-off. Trigger even without 'GPUNetIO' or\n  'ib_write_lat': 'GPU kernel RDMA latency benchmark', 'how fast can a\n  CUDA kernel post a WRITE', 'p99 RDMA latency on H100 + ConnectX',\n  'kernel-launched WR tail latency', or 'compare GPU-init vs CPU-init\n  perftest'. Route elsewhere for bandwidth runs\n  (doca-gpunetio-ib-write-bw), the GPI surface (doca-gpi), library\n  debugging (doca-gpunetio), or DOCA install.\nmetadata:\n  kind: tool\ncompatibility: >\n  Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux\n  (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with an InfiniBand-capable\n  ConnectX or BlueField RNIC. Requires NVIDIA GPU with CUDA\n  Toolkit and `nvidia_peermem` loaded; client and server hosts\n  each need a GPU-NIC pair on a common PCIe \u002F NVLink fabric.\n  Reads pkg-config doca-gpunetio \u002F doca-rdma \u002F doca-common and\n  builds from the source tree at\n  \u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002Fgpunetio_ib_write_lat against the installed DOCA.\n---\n\n# DOCA GPUNetIO ib_write_lat\n\n**Where to start:** This is a tool skill for the GPUNetIO-\nflavored `ib_write_lat` benchmark shipped under\n`doca\u002Ftools\u002Fgpunetio_ib_write_lat\u002F` (a client + server pair,\nbuilt from source against the installed DOCA via `meson`).\nIt measures the latency of an RDMA WRITE work request when\nthe WR is posted **from a CUDA kernel through the\ndoca-gpunetio device-side surface**, in a ping-pong cadence.\nOpen [`TASKS.md`](TASKS.md) and start at\n[`## configure`](TASKS.md#configure) for the GPU-NIC pairing\nprecondition and the build pattern; jump to\n[`## run`](TASKS.md#run) for the single-iteration smoke\nflow. Open [`CAPABILITIES.md`](CAPABILITIES.md) when the\nquestion is *what this tool actually measures*, *how it\ndiffers from the GPI sister tool on the same physical\noperation*, or *how to interpret the half-iter \u002F full-iter\n\u002F CUDA-side usec output and the median \u002F p99 \u002F jitter\ncharacterization*. If DOCA is not installed yet, route to\n[`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) first; if the\nuser is still deciding between GPUNetIO and GPI as a\nprogramming surface, the picture in\n[`..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FCAPABILITIES.md#capabilities-and-modes`](..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FCAPABILITIES.md#capabilities-and-modes)\nand\n[`..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md#capabilities-and-modes`](..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md#capabilities-and-modes)\nis the first stop.\n\n## Example questions this skill answers well\n\nThe CLASSES of `doca-gpunetio-ib-write-lat` questions this\nskill is built to answer, each with one worked example. The\nclass is the load-bearing piece; the worked example is one\ninstance.\n\n- **\"What GPU-init RDMA-WRITE latency \u002F jitter can the\n  GPUNetIO path deliver for a real-time \u002F control-loop\n  workload?\"** — worked example: *\"measure per-iteration\n  WRITE latency between two hosts with an H100 +\n  ConnectX-7 on each side, target the median and the p99\n  separately\"*. Answered by the GPU-NIC pairing\n  precondition in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the bring-up flow in\n  [`TASKS.md ## configure`](TASKS.md#configure) +\n  [`TASKS.md ## run`](TASKS.md#run).\n- **\"This is the GPUNetIO tool — how does the latency\n  number differ from the GPI programming surface?\"** —\n  worked example: *\"the team is using GPI; should I expect\n  GPUNetIO to beat \u002F tie \u002F lose vs GPI?\"*. Answered by the\n  *\"same physical operation, different runtime framework\"*\n  rule in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the cross-link to the GPI library skill\n  [`..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md`](..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md)\n  (note: `doca\u002Ftools\u002F` ships no GPI `ib_write_lat`\n  benchmark binary — GPI is a programming surface, not a\n  shipped benchmark tool).\n- **\"Median vs p99 vs jitter — which one is the actual\n  answer for a real-time control loop?\"** — worked\n  example: *\"my control loop has a deadline; the median\n  is well under the budget but p99 spikes; do I quote\n  the median or the p99?\"*. Answered by the\n  median-vs-p99-vs-jitter rule in\n  [`CAPABILITIES.md ## Observability`](CAPABILITIES.md#observability)\n  + the eval-loop overlay in\n  [`TASKS.md ## test`](TASKS.md#test).\n- **\"What is the latency-vs-batching trade-off specific\n  to GPU-init RDMA?\"** — worked example: *\"my CUDA kernel\n  could batch multiple WRs to amortize the GPU-side\n  overhead; what does that buy me on latency vs what does\n  it cost me?\"*. Answered by the\n  latency-vs-batching trade-off in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes).\n- **\"What version of DOCA + CUDA Toolkit do I need for\n  this binary to build and run?\"** — worked example: *\"my\n  install has DOCA at one semver and CUDA at another;\n  will the ToT-shipped `gpunetio_ib_write_lat` even\n  link?\"*. Answered by the version overlay in\n  [`CAPABILITIES.md ## Version compatibility`](CAPABILITIES.md#version-compatibility).\n- **\"How do I read the half-iter \u002F full-iter \u002F CUDA-side\n  usec columns?\"** — worked example: *\"the binary printed\n  half-iter, full-iter, and a CUDA-side number — what is\n  the right column to quote for one-way latency vs\n  round-trip vs cross-check?\"*. Answered by the column-\n  semantics rule in\n  [`CAPABILITIES.md ## Observability`](CAPABILITIES.md#observability).\n\n## Audience\n\nThis skill serves **external developers and performance\nengineers who need a reproducible measurement of the\nlatency of an RDMA WRITE WR when the WR is posted from a\nCUDA kernel through doca-gpunetio**, on the user's actual\ninstall and GPU-NIC pair. Concretely:\n\n- A developer designing a GPU-resident real-time control\n  loop and deciding whether the GPUNetIO path's tail\n  latency fits the deadline.\n- A platform operator validating a tuning change (NUMA\n  pinning, GPU PCIe placement, IB device choice, GID\n  index, NIC firmware burn) by re-running this benchmark\n  against the new state.\n- An SRE \u002F performance engineer producing a *\"this is the\n  GPUNetIO-driven WRITE latency on this GPU-NIC pair\n  today, with median + p99 + jitter\"* artifact downstream\n  consumers can cite.\n- An AI agent answering *\"is the doca-gpunetio latency\n  budget acceptable for this real-time workload class\"*\n  honestly — with measured numbers, the build +\n  invocation that produced them, and the GPU + NIC +\n  DOCA version that scopes them — rather than guessing.\n\nIt is **not** for users debugging the `doca-gpunetio`\nlibrary itself (route to\n[`..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md`](..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md)),\nand **not** a substitute for the `perftest` upstream\n`ib_write_lat` (which measures CPU-initiated WRITE\nlatency).\n\n## Language scope\n\nThe `doca-gpunetio-ib-write-lat` tool is shipped as **C\nplus CUDA `.cu` translation units** under\n`doca\u002Ftools\u002Fgpunetio_ib_write_lat\u002F`, split into a\n`client\u002F` subtree, a `server\u002F` subtree, and a `common\u002F`\nsubtree shared between them (per the verified file layout:\n`client\u002F{main.c,perftest.{c,h},meson.build}`,\n`server\u002F{main.c,perftest.{c,h},meson.build}`,\n`common\u002F{common.c,common.h,kernel.cu}`). The host-side\nbuild is `meson` against the installed DOCA `pkg-config`\nmodules (`doca-gpunetio`, `doca-rdma`, `doca-common`,\nplus the CUDA Toolkit dependency); the device-side build\nis `nvcc` against the DOCA GPU NetIO device-side header\nset. There is no Python \u002F Rust \u002F Go binding — the tool is\na pair of CLI binaries.\n\n## When to load this skill\n\nLoad this skill when the user is — or the agent needs to\n— build and run the `gpunetio_ib_write_lat` client +\nserver on real hosts with DOCA installed plus a CUDA\nToolkit matched to the DOCA install, and a GPU + IB device\npair on each host's PCIe topology. Concretely:\n\n- Measuring kernel-initiated RDMA WRITE latency between\n  two hosts (or a host and a BlueField DPU) with the\n  GPUNetIO surface.\n- Characterizing tail latency (p99 \u002F p99.9) and jitter\n  for a real-time \u002F control-loop workload class.\n- Deciding whether the GPUNetIO path is the right runtime\n  surface for a class of workload vs the GPI programming\n  surface (the [`doca-gpi`](..\u002F..\u002Flibs\u002Fdoca-gpi\u002FSKILL.md)\n  library — `doca\u002Ftools\u002F` ships no GPI benchmark binary)\n  or the classic CPU-initiated `perftest` path.\n- Capturing a documented baseline (build + invocation +\n  DOCA version + GPU + NIC + as-deployed environment +\n  numbers) for later regression hunts.\n- Diagnosing a build \u002F link \u002F run failure that surfaces\n  the GPUNetIO + RDMA bring-up sequence under this tool's\n  shipped scaffolding.\n\nDo **not** load this skill for general DOCA orientation,\nlibrary API work, or installation. For those, use\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md),\n[`..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md`](..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md),\nor [`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md). Do not load\nit for *application-level* real-time deadline analysis —\nthis benchmark measures the WR latency through GPUNetIO,\nnot the user's full pipeline.\n\n## What this skill provides\n\nThis is a **thin loader**. Substantive material lives in\ntwo companion files:\n\n- `CAPABILITIES.md` — what the tool measures (the\n  ping-pong WRITE latency primitive driven by both sides'\n  CUDA kernels through doca-gpunetio), the\n  runtime-surface selection rule (GPUNetIO vs GPI vs\n  CPU-initiated), the GPU-NIC pairing precondition, the\n  latency-vs-batching trade-off intrinsic to GPU-init\n  RDMA, the median \u002F p99 \u002F jitter reporting taxonomy,\n  the version overlay (DOCA `.pc` PLUS CUDA Toolkit),\n  the layered error taxonomy, the observability surface\n  (stdout report including the timeout knob the\n  `gpunetio_rdma_write_lat_*` kernel functions surface\n  per the verified `common.h`), and the safety overlay.\n- `TASKS.md` — step-by-step workflows for the in-scope\n  task verbs: `install`, `configure`, `build`, `modify`,\n  `run` (smoke-before-bulk; single-iteration verification;\n  reading the report columns), `test` (the eval loop —\n  median \u002F p99 \u002F jitter \u002F steady-state), `debug` (walk\n  the error taxonomy layer by layer), `use` (how a\n  latency result feeds a real-time class-of-workload\n  decision), plus a `Deferred task verbs` block.\n\nThe skill assumes a host where DOCA is already installed,\na CUDA Toolkit matched to the install is present, and the\noperator has whatever privileges the public install\nprofile expects for binding a `doca_dev`, a `doca_gpu`,\nand an OOB TCP socket.\n\n## What this skill deliberately does not ship\n\nThis skill is **agent guidance**, not a samples or\nscripts bundle. It deliberately does not contain — and\npull requests should not add:\n\n- **Specific flag strings or expected latency numbers**\n  beyond what the tool's shipped `--help` and `main.c`\n  ARGP registration establish. The flag surface is small\n  (device name, GPU PCIe address, GID index, server IP\n  on the client side); the agent re-reads the binary's\n  `--help` on the installed version.\n- **Pre-written DOCA GPUNetIO or CUDA kernel source\n  code** that would compete with the shipped tool tree.\n  The shipped `client\u002F`, `server\u002F`, and `common\u002F`\n  subtrees are the verified worked example.\n- **Wrappers, parsers, or scripts** in any language that\n  consume the tool's stdout. The output format is small\n  and documented in\n  [`CAPABILITIES.md ## Observability`](CAPABILITIES.md#observability).\n- **A `samples\u002F`, `bindings\u002F`, or `reference\u002F` subtree.**\n  This is a thin loader for a shipped tool tree.\n\n## Loading order\n\n1. Read this `SKILL.md` first to confirm the user's\n   question is in scope (the user actually wants to\n   measure kernel-initiated WRITE latency through\n   GPUNetIO, not the GPI variant, not the CPU-initiated\n   variant, and not a library API question).\n2. **For what the tool measures, the surface-selection\n   rule against the GPI sister tool and the CPU-initiated\n   `perftest`, the latency-vs-batching trade-off, the\n   median \u002F p99 \u002F jitter reporting taxonomy, the version\n   overlay, the error taxonomy, the observability\n   surface, and the safety overlay, see\n   [CAPABILITIES.md](CAPABILITIES.md).**\n3. **For step-by-step workflows — `install`,\n   `configure`, `build`, `modify`, `run`, `test`,\n   `debug`, `use` — see [TASKS.md](TASKS.md).**\n\n## Related skills\n\n- [`..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md`](..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md) —\n  the library this tool wraps. The per-GPU `doca_gpu`\n  context, the GPU-visible RDMA handles, the CUDA-side\n  persistent-kernel pattern, the dual capability-\n  discovery rule (DOCA cap-query AND\n  `cudaGetDeviceProperties`), and the env preconditions\n  (`nvidia_peermem` loaded, CUDA buffers registered\n  with DOCA) live there.\n- [`..\u002F..\u002Flibs\u002Fdoca-rdma\u002FSKILL.md`](..\u002F..\u002Flibs\u002Fdoca-rdma\u002FSKILL.md) —\n  the underlying RDMA library. The RDMA queue this tool\n  binds is created and connected via `doca-rdma`; the\n  queue lifecycle, the transport type (RC vs UC vs UD),\n  the permission matrix, and the connection method are\n  owned there.\n- [`..\u002F..\u002Flibs\u002Fdoca-verbs\u002FSKILL.md`](..\u002F..\u002Flibs\u002Fdoca-verbs\u002FSKILL.md) —\n  the raw-verbs escape hatch beneath `doca-rdma` \u002F\n  `doca-gpunetio`. This tool stays on the higher-level\n  surfaces.\n- [`..\u002Fdoca-gpunetio-ib-write-bw\u002FSKILL.md`](..\u002Fdoca-gpunetio-ib-write-bw\u002FSKILL.md) —\n  bandwidth analog of this tool on the same runtime\n  framework. Same physical operation; different metric\n  class (latency vs BW). The two together carry the full\n  GPUNetIO-side latency \u002F throughput picture.\n- [`doca-gpi`](..\u002F..\u002Flibs\u002Fdoca-gpi\u002FSKILL.md) — the GPI\n  programming surface (CUDA-kernel-initiated RDMA). The\n  alternative runtime framework for the same physical\n  operation; `doca\u002Ftools\u002F` ships no GPI `ib_write_lat`\n  benchmark binary, so the GPI comparison is against the\n  library surface, not a sibling tool. The selection rule\n  in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  is the decision aid; the agent's job is to teach when\n  to pick which.\n- [`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) — the\n  canonical version-detection chain, four-way match\n  rule. The `## Version compatibility` section here is a\n  thin overlay.\n- [`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) — env\n  preparation, install verification, GPU + CUDA Toolkit\n  pairing, `nvidia_peermem` load, hugepages, NUMA, and\n  the NGC DOCA container path.\n- [`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md) —\n  routing to the public DOCA documentation set and the\n  CUDA Toolkit pointer.\n- [`doca-debug`](..\u002F..\u002Fdoca-debug\u002FSKILL.md) — the\n  cross-cutting debug ladder.\n- [`doca-hardware-safety`](..\u002F..\u002Fdoca-hardware-safety\u002FSKILL.md) —\n  the bundle-wide hardware-safety meta-policy.\n",{"data":35,"body":39},{"license":26,"name":4,"description":6,"metadata":36,"compatibility":38},{"kind":37},"tool","Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with an InfiniBand-capable ConnectX or BlueField RNIC. Requires NVIDIA GPU with CUDA Toolkit and `nvidia_peermem` loaded; client and server hosts each need a GPU-NIC pair on a common PCIe \u002F NVLink fabric. Reads pkg-config doca-gpunetio \u002F doca-rdma \u002F doca-common and builds from the source tree at \u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002Fgpunetio_ib_write_lat against the installed DOCA.\n",{"type":40,"children":41},"root",[42,51,198,205,217,476,482,494,531,583,589,714,720,732,786,835,841,853,968,989,995,1007,1124,1130,1229,1235],{"type":43,"tag":44,"props":45,"children":47},"element","h1",{"id":46},"doca-gpunetio-ib_write_lat",[48],{"type":49,"value":50},"text","DOCA GPUNetIO ib_write_lat",{"type":43,"tag":52,"props":53,"children":54},"p",{},[55,61,63,70,72,78,80,86,88,93,95,105,107,117,119,129,131,140,142,148,150,155,157,162,164,174,176,185,187,196],{"type":43,"tag":56,"props":57,"children":58},"strong",{},[59],{"type":49,"value":60},"Where to start:",{"type":49,"value":62}," This is a tool skill for the GPUNetIO-\nflavored ",{"type":43,"tag":64,"props":65,"children":67},"code",{"className":66},[],[68],{"type":49,"value":69},"ib_write_lat",{"type":49,"value":71}," benchmark shipped under\n",{"type":43,"tag":64,"props":73,"children":75},{"className":74},[],[76],{"type":49,"value":77},"doca\u002Ftools\u002Fgpunetio_ib_write_lat\u002F",{"type":49,"value":79}," (a client + server pair,\nbuilt from source against the installed DOCA via ",{"type":43,"tag":64,"props":81,"children":83},{"className":82},[],[84],{"type":49,"value":85},"meson",{"type":49,"value":87},").\nIt measures the latency of an RDMA WRITE work request when\nthe WR is posted ",{"type":43,"tag":56,"props":89,"children":90},{},[91],{"type":49,"value":92},"from a CUDA kernel through the\ndoca-gpunetio device-side surface",{"type":49,"value":94},", in a ping-pong cadence.\nOpen ",{"type":43,"tag":96,"props":97,"children":99},"a",{"href":98},"TASKS.md",[100],{"type":43,"tag":64,"props":101,"children":103},{"className":102},[],[104],{"type":49,"value":98},{"type":49,"value":106}," and start at\n",{"type":43,"tag":96,"props":108,"children":110},{"href":109},"TASKS.md#configure",[111],{"type":43,"tag":64,"props":112,"children":114},{"className":113},[],[115],{"type":49,"value":116},"## configure",{"type":49,"value":118}," for the GPU-NIC pairing\nprecondition and the build pattern; jump to\n",{"type":43,"tag":96,"props":120,"children":122},{"href":121},"TASKS.md#run",[123],{"type":43,"tag":64,"props":124,"children":126},{"className":125},[],[127],{"type":49,"value":128},"## run",{"type":49,"value":130}," for the single-iteration smoke\nflow. Open ",{"type":43,"tag":96,"props":132,"children":134},{"href":133},"CAPABILITIES.md",[135],{"type":43,"tag":64,"props":136,"children":138},{"className":137},[],[139],{"type":49,"value":133},{"type":49,"value":141}," when the\nquestion is ",{"type":43,"tag":143,"props":144,"children":145},"em",{},[146],{"type":49,"value":147},"what this tool actually measures",{"type":49,"value":149},", ",{"type":43,"tag":143,"props":151,"children":152},{},[153],{"type":49,"value":154},"how it\ndiffers from the GPI sister tool on the same physical\noperation",{"type":49,"value":156},", or ",{"type":43,"tag":143,"props":158,"children":159},{},[160],{"type":49,"value":161},"how to interpret the half-iter \u002F full-iter\n\u002F CUDA-side usec output and the median \u002F p99 \u002F jitter\ncharacterization",{"type":49,"value":163},". If DOCA is not installed yet, route to\n",{"type":43,"tag":96,"props":165,"children":167},{"href":166},"..\u002F..\u002Fdoca-setup\u002FSKILL.md",[168],{"type":43,"tag":64,"props":169,"children":171},{"className":170},[],[172],{"type":49,"value":173},"doca-setup",{"type":49,"value":175}," first; if the\nuser is still deciding between GPUNetIO and GPI as a\nprogramming surface, the picture in\n",{"type":43,"tag":96,"props":177,"children":179},{"href":178},"..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FCAPABILITIES.md#capabilities-and-modes",[180],{"type":43,"tag":64,"props":181,"children":183},{"className":182},[],[184],{"type":49,"value":178},{"type":49,"value":186},"\nand\n",{"type":43,"tag":96,"props":188,"children":190},{"href":189},"..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md#capabilities-and-modes",[191],{"type":43,"tag":64,"props":192,"children":194},{"className":193},[],[195],{"type":49,"value":189},{"type":49,"value":197},"\nis the first stop.",{"type":43,"tag":199,"props":200,"children":202},"h2",{"id":201},"example-questions-this-skill-answers-well",[203],{"type":49,"value":204},"Example questions this skill answers well",{"type":43,"tag":52,"props":206,"children":207},{},[208,210,215],{"type":49,"value":209},"The CLASSES of ",{"type":43,"tag":64,"props":211,"children":213},{"className":212},[],[214],{"type":49,"value":4},{"type":49,"value":216}," questions this\nskill is built to answer, each with one worked example. The\nclass is the load-bearing piece; the worked example is one\ninstance.",{"type":43,"tag":218,"props":219,"children":220},"ul",{},[221,279,345,391,416,451],{"type":43,"tag":222,"props":223,"children":224},"li",{},[225,230,232,237,239,249],{"type":43,"tag":56,"props":226,"children":227},{},[228],{"type":49,"value":229},"\"What GPU-init RDMA-WRITE latency \u002F jitter can the\nGPUNetIO path deliver for a real-time \u002F control-loop\nworkload?\"",{"type":49,"value":231}," — worked example: ",{"type":43,"tag":143,"props":233,"children":234},{},[235],{"type":49,"value":236},"\"measure per-iteration\nWRITE latency between two hosts with an H100 +\nConnectX-7 on each side, target the median and the p99\nseparately\"",{"type":49,"value":238},". Answered by the GPU-NIC pairing\nprecondition in\n",{"type":43,"tag":96,"props":240,"children":242},{"href":241},"CAPABILITIES.md#capabilities-and-modes",[243],{"type":43,"tag":64,"props":244,"children":246},{"className":245},[],[247],{"type":49,"value":248},"CAPABILITIES.md ## Capabilities and modes",{"type":43,"tag":218,"props":250,"children":251},{},[252],{"type":43,"tag":222,"props":253,"children":254},{},[255,257,266,268,277],{"type":49,"value":256},"the bring-up flow in\n",{"type":43,"tag":96,"props":258,"children":259},{"href":109},[260],{"type":43,"tag":64,"props":261,"children":263},{"className":262},[],[264],{"type":49,"value":265},"TASKS.md ## configure",{"type":49,"value":267}," +\n",{"type":43,"tag":96,"props":269,"children":270},{"href":121},[271],{"type":43,"tag":64,"props":272,"children":274},{"className":273},[],[275],{"type":49,"value":276},"TASKS.md ## run",{"type":49,"value":278},".",{"type":43,"tag":222,"props":280,"children":281},{},[282,287,289,294,296,301,303,311],{"type":43,"tag":56,"props":283,"children":284},{},[285],{"type":49,"value":286},"\"This is the GPUNetIO tool — how does the latency\nnumber differ from the GPI programming surface?\"",{"type":49,"value":288}," —\nworked example: ",{"type":43,"tag":143,"props":290,"children":291},{},[292],{"type":49,"value":293},"\"the team is using GPI; should I expect\nGPUNetIO to beat \u002F tie \u002F lose vs GPI?\"",{"type":49,"value":295},". Answered by the\n",{"type":43,"tag":143,"props":297,"children":298},{},[299],{"type":49,"value":300},"\"same physical operation, different runtime framework\"",{"type":49,"value":302},"\nrule in\n",{"type":43,"tag":96,"props":304,"children":305},{"href":241},[306],{"type":43,"tag":64,"props":307,"children":309},{"className":308},[],[310],{"type":49,"value":248},{"type":43,"tag":218,"props":312,"children":313},{},[314],{"type":43,"tag":222,"props":315,"children":316},{},[317,319,328,330,336,338,343],{"type":49,"value":318},"the cross-link to the GPI library skill\n",{"type":43,"tag":96,"props":320,"children":322},{"href":321},"..\u002F..\u002Flibs\u002Fdoca-gpi\u002FCAPABILITIES.md",[323],{"type":43,"tag":64,"props":324,"children":326},{"className":325},[],[327],{"type":49,"value":321},{"type":49,"value":329},"\n(note: ",{"type":43,"tag":64,"props":331,"children":333},{"className":332},[],[334],{"type":49,"value":335},"doca\u002Ftools\u002F",{"type":49,"value":337}," ships no GPI ",{"type":43,"tag":64,"props":339,"children":341},{"className":340},[],[342],{"type":49,"value":69},{"type":49,"value":344},"\nbenchmark binary — GPI is a programming surface, not a\nshipped benchmark tool).",{"type":43,"tag":222,"props":346,"children":347},{},[348,353,355,360,362,372],{"type":43,"tag":56,"props":349,"children":350},{},[351],{"type":49,"value":352},"\"Median vs p99 vs jitter — which one is the actual\nanswer for a real-time control loop?\"",{"type":49,"value":354}," — worked\nexample: ",{"type":43,"tag":143,"props":356,"children":357},{},[358],{"type":49,"value":359},"\"my control loop has a deadline; the median\nis well under the budget but p99 spikes; do I quote\nthe median or the p99?\"",{"type":49,"value":361},". Answered by the\nmedian-vs-p99-vs-jitter rule in\n",{"type":43,"tag":96,"props":363,"children":365},{"href":364},"CAPABILITIES.md#observability",[366],{"type":43,"tag":64,"props":367,"children":369},{"className":368},[],[370],{"type":49,"value":371},"CAPABILITIES.md ## Observability",{"type":43,"tag":218,"props":373,"children":374},{},[375],{"type":43,"tag":222,"props":376,"children":377},{},[378,380,390],{"type":49,"value":379},"the eval-loop overlay in\n",{"type":43,"tag":96,"props":381,"children":383},{"href":382},"TASKS.md#test",[384],{"type":43,"tag":64,"props":385,"children":387},{"className":386},[],[388],{"type":49,"value":389},"TASKS.md ## test",{"type":49,"value":278},{"type":43,"tag":222,"props":392,"children":393},{},[394,399,400,405,407,415],{"type":43,"tag":56,"props":395,"children":396},{},[397],{"type":49,"value":398},"\"What is the latency-vs-batching trade-off specific\nto GPU-init RDMA?\"",{"type":49,"value":231},{"type":43,"tag":143,"props":401,"children":402},{},[403],{"type":49,"value":404},"\"my CUDA kernel\ncould batch multiple WRs to amortize the GPU-side\noverhead; what does that buy me on latency vs what does\nit cost me?\"",{"type":49,"value":406},". Answered by the\nlatency-vs-batching trade-off in\n",{"type":43,"tag":96,"props":408,"children":409},{"href":241},[410],{"type":43,"tag":64,"props":411,"children":413},{"className":412},[],[414],{"type":49,"value":248},{"type":49,"value":278},{"type":43,"tag":222,"props":417,"children":418},{},[419,424,425,438,440,450],{"type":43,"tag":56,"props":420,"children":421},{},[422],{"type":49,"value":423},"\"What version of DOCA + CUDA Toolkit do I need for\nthis binary to build and run?\"",{"type":49,"value":231},{"type":43,"tag":143,"props":426,"children":427},{},[428,430,436],{"type":49,"value":429},"\"my\ninstall has DOCA at one semver and CUDA at another;\nwill the ToT-shipped ",{"type":43,"tag":64,"props":431,"children":433},{"className":432},[],[434],{"type":49,"value":435},"gpunetio_ib_write_lat",{"type":49,"value":437}," even\nlink?\"",{"type":49,"value":439},". Answered by the version overlay in\n",{"type":43,"tag":96,"props":441,"children":443},{"href":442},"CAPABILITIES.md#version-compatibility",[444],{"type":43,"tag":64,"props":445,"children":447},{"className":446},[],[448],{"type":49,"value":449},"CAPABILITIES.md ## Version compatibility",{"type":49,"value":278},{"type":43,"tag":222,"props":452,"children":453},{},[454,459,460,465,467,475],{"type":43,"tag":56,"props":455,"children":456},{},[457],{"type":49,"value":458},"\"How do I read the half-iter \u002F full-iter \u002F CUDA-side\nusec columns?\"",{"type":49,"value":231},{"type":43,"tag":143,"props":461,"children":462},{},[463],{"type":49,"value":464},"\"the binary printed\nhalf-iter, full-iter, and a CUDA-side number — what is\nthe right column to quote for one-way latency vs\nround-trip vs cross-check?\"",{"type":49,"value":466},". Answered by the column-\nsemantics rule in\n",{"type":43,"tag":96,"props":468,"children":469},{"href":364},[470],{"type":43,"tag":64,"props":471,"children":473},{"className":472},[],[474],{"type":49,"value":371},{"type":49,"value":278},{"type":43,"tag":199,"props":477,"children":479},{"id":478},"audience",[480],{"type":49,"value":481},"Audience",{"type":43,"tag":52,"props":483,"children":484},{},[485,487,492],{"type":49,"value":486},"This skill serves ",{"type":43,"tag":56,"props":488,"children":489},{},[490],{"type":49,"value":491},"external developers and performance\nengineers who need a reproducible measurement of the\nlatency of an RDMA WRITE WR when the WR is posted from a\nCUDA kernel through doca-gpunetio",{"type":49,"value":493},", on the user's actual\ninstall and GPU-NIC pair. Concretely:",{"type":43,"tag":218,"props":495,"children":496},{},[497,502,507,519],{"type":43,"tag":222,"props":498,"children":499},{},[500],{"type":49,"value":501},"A developer designing a GPU-resident real-time control\nloop and deciding whether the GPUNetIO path's tail\nlatency fits the deadline.",{"type":43,"tag":222,"props":503,"children":504},{},[505],{"type":49,"value":506},"A platform operator validating a tuning change (NUMA\npinning, GPU PCIe placement, IB device choice, GID\nindex, NIC firmware burn) by re-running this benchmark\nagainst the new state.",{"type":43,"tag":222,"props":508,"children":509},{},[510,512,517],{"type":49,"value":511},"An SRE \u002F performance engineer producing a ",{"type":43,"tag":143,"props":513,"children":514},{},[515],{"type":49,"value":516},"\"this is the\nGPUNetIO-driven WRITE latency on this GPU-NIC pair\ntoday, with median + p99 + jitter\"",{"type":49,"value":518}," artifact downstream\nconsumers can cite.",{"type":43,"tag":222,"props":520,"children":521},{},[522,524,529],{"type":49,"value":523},"An AI agent answering ",{"type":43,"tag":143,"props":525,"children":526},{},[527],{"type":49,"value":528},"\"is the doca-gpunetio latency\nbudget acceptable for this real-time workload class\"",{"type":49,"value":530},"\nhonestly — with measured numbers, the build +\ninvocation that produced them, and the GPU + NIC +\nDOCA version that scopes them — rather than guessing.",{"type":43,"tag":52,"props":532,"children":533},{},[534,536,541,543,549,551,560,562,566,568,574,576,581],{"type":49,"value":535},"It is ",{"type":43,"tag":56,"props":537,"children":538},{},[539],{"type":49,"value":540},"not",{"type":49,"value":542}," for users debugging the ",{"type":43,"tag":64,"props":544,"children":546},{"className":545},[],[547],{"type":49,"value":548},"doca-gpunetio",{"type":49,"value":550},"\nlibrary itself (route to\n",{"type":43,"tag":96,"props":552,"children":554},{"href":553},"..\u002F..\u002Flibs\u002Fdoca-gpunetio\u002FSKILL.md",[555],{"type":43,"tag":64,"props":556,"children":558},{"className":557},[],[559],{"type":49,"value":553},{"type":49,"value":561},"),\nand ",{"type":43,"tag":56,"props":563,"children":564},{},[565],{"type":49,"value":540},{"type":49,"value":567}," a substitute for the ",{"type":43,"tag":64,"props":569,"children":571},{"className":570},[],[572],{"type":49,"value":573},"perftest",{"type":49,"value":575}," upstream\n",{"type":43,"tag":64,"props":577,"children":579},{"className":578},[],[580],{"type":49,"value":69},{"type":49,"value":582}," (which measures CPU-initiated WRITE\nlatency).",{"type":43,"tag":199,"props":584,"children":586},{"id":585},"language-scope",[587],{"type":49,"value":588},"Language scope",{"type":43,"tag":52,"props":590,"children":591},{},[592,594,599,601,614,616,621,623,629,631,637,639,645,647,653,655,661,662,668,670,675,677,683,685,690,691,697,698,704,706,712],{"type":49,"value":593},"The ",{"type":43,"tag":64,"props":595,"children":597},{"className":596},[],[598],{"type":49,"value":4},{"type":49,"value":600}," tool is shipped as ",{"type":43,"tag":56,"props":602,"children":603},{},[604,606,612],{"type":49,"value":605},"C\nplus CUDA ",{"type":43,"tag":64,"props":607,"children":609},{"className":608},[],[610],{"type":49,"value":611},".cu",{"type":49,"value":613}," translation units",{"type":49,"value":615}," under\n",{"type":43,"tag":64,"props":617,"children":619},{"className":618},[],[620],{"type":49,"value":77},{"type":49,"value":622},", split into a\n",{"type":43,"tag":64,"props":624,"children":626},{"className":625},[],[627],{"type":49,"value":628},"client\u002F",{"type":49,"value":630}," subtree, a ",{"type":43,"tag":64,"props":632,"children":634},{"className":633},[],[635],{"type":49,"value":636},"server\u002F",{"type":49,"value":638}," subtree, and a ",{"type":43,"tag":64,"props":640,"children":642},{"className":641},[],[643],{"type":49,"value":644},"common\u002F",{"type":49,"value":646},"\nsubtree shared between them (per the verified file layout:\n",{"type":43,"tag":64,"props":648,"children":650},{"className":649},[],[651],{"type":49,"value":652},"client\u002F{main.c,perftest.{c,h},meson.build}",{"type":49,"value":654},",\n",{"type":43,"tag":64,"props":656,"children":658},{"className":657},[],[659],{"type":49,"value":660},"server\u002F{main.c,perftest.{c,h},meson.build}",{"type":49,"value":654},{"type":43,"tag":64,"props":663,"children":665},{"className":664},[],[666],{"type":49,"value":667},"common\u002F{common.c,common.h,kernel.cu}",{"type":49,"value":669},"). The host-side\nbuild is ",{"type":43,"tag":64,"props":671,"children":673},{"className":672},[],[674],{"type":49,"value":85},{"type":49,"value":676}," against the installed DOCA ",{"type":43,"tag":64,"props":678,"children":680},{"className":679},[],[681],{"type":49,"value":682},"pkg-config",{"type":49,"value":684},"\nmodules (",{"type":43,"tag":64,"props":686,"children":688},{"className":687},[],[689],{"type":49,"value":548},{"type":49,"value":149},{"type":43,"tag":64,"props":692,"children":694},{"className":693},[],[695],{"type":49,"value":696},"doca-rdma",{"type":49,"value":149},{"type":43,"tag":64,"props":699,"children":701},{"className":700},[],[702],{"type":49,"value":703},"doca-common",{"type":49,"value":705},",\nplus the CUDA Toolkit dependency); the device-side build\nis ",{"type":43,"tag":64,"props":707,"children":709},{"className":708},[],[710],{"type":49,"value":711},"nvcc",{"type":49,"value":713}," against the DOCA GPU NetIO device-side header\nset. There is no Python \u002F Rust \u002F Go binding — the tool is\na pair of CLI binaries.",{"type":43,"tag":199,"props":715,"children":717},{"id":716},"when-to-load-this-skill",[718],{"type":49,"value":719},"When to load this skill",{"type":43,"tag":52,"props":721,"children":722},{},[723,725,730],{"type":49,"value":724},"Load this skill when the user is — or the agent needs to\n— build and run the ",{"type":43,"tag":64,"props":726,"children":728},{"className":727},[],[729],{"type":49,"value":435},{"type":49,"value":731}," client +\nserver on real hosts with DOCA installed plus a CUDA\nToolkit matched to the DOCA install, and a GPU + IB device\npair on each host's PCIe topology. Concretely:",{"type":43,"tag":218,"props":733,"children":734},{},[735,740,745,776,781],{"type":43,"tag":222,"props":736,"children":737},{},[738],{"type":49,"value":739},"Measuring kernel-initiated RDMA WRITE latency between\ntwo hosts (or a host and a BlueField DPU) with the\nGPUNetIO surface.",{"type":43,"tag":222,"props":741,"children":742},{},[743],{"type":49,"value":744},"Characterizing tail latency (p99 \u002F p99.9) and jitter\nfor a real-time \u002F control-loop workload class.",{"type":43,"tag":222,"props":746,"children":747},{},[748,750,760,762,767,769,774],{"type":49,"value":749},"Deciding whether the GPUNetIO path is the right runtime\nsurface for a class of workload vs the GPI programming\nsurface (the ",{"type":43,"tag":96,"props":751,"children":753},{"href":752},"..\u002F..\u002Flibs\u002Fdoca-gpi\u002FSKILL.md",[754],{"type":43,"tag":64,"props":755,"children":757},{"className":756},[],[758],{"type":49,"value":759},"doca-gpi",{"type":49,"value":761},"\nlibrary — ",{"type":43,"tag":64,"props":763,"children":765},{"className":764},[],[766],{"type":49,"value":335},{"type":49,"value":768}," ships no GPI benchmark binary)\nor the classic CPU-initiated ",{"type":43,"tag":64,"props":770,"children":772},{"className":771},[],[773],{"type":49,"value":573},{"type":49,"value":775}," path.",{"type":43,"tag":222,"props":777,"children":778},{},[779],{"type":49,"value":780},"Capturing a documented baseline (build + invocation +\nDOCA version + GPU + NIC + as-deployed environment +\nnumbers) for later regression hunts.",{"type":43,"tag":222,"props":782,"children":783},{},[784],{"type":49,"value":785},"Diagnosing a build \u002F link \u002F run failure that surfaces\nthe GPUNetIO + RDMA bring-up sequence under this tool's\nshipped scaffolding.",{"type":43,"tag":52,"props":787,"children":788},{},[789,791,795,797,807,808,816,818,826,828,833],{"type":49,"value":790},"Do ",{"type":43,"tag":56,"props":792,"children":793},{},[794],{"type":49,"value":540},{"type":49,"value":796}," load this skill for general DOCA orientation,\nlibrary API work, or installation. For those, use\n",{"type":43,"tag":96,"props":798,"children":800},{"href":799},"..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md",[801],{"type":43,"tag":64,"props":802,"children":804},{"className":803},[],[805],{"type":49,"value":806},"doca-public-knowledge-map",{"type":49,"value":654},{"type":43,"tag":96,"props":809,"children":810},{"href":553},[811],{"type":43,"tag":64,"props":812,"children":814},{"className":813},[],[815],{"type":49,"value":553},{"type":49,"value":817},",\nor ",{"type":43,"tag":96,"props":819,"children":820},{"href":166},[821],{"type":43,"tag":64,"props":822,"children":824},{"className":823},[],[825],{"type":49,"value":173},{"type":49,"value":827},". Do not load\nit for ",{"type":43,"tag":143,"props":829,"children":830},{},[831],{"type":49,"value":832},"application-level",{"type":49,"value":834}," real-time deadline analysis —\nthis benchmark measures the WR latency through GPUNetIO,\nnot the user's full pipeline.",{"type":43,"tag":199,"props":836,"children":838},{"id":837},"what-this-skill-provides",[839],{"type":49,"value":840},"What this skill provides",{"type":43,"tag":52,"props":842,"children":843},{},[844,846,851],{"type":49,"value":845},"This is a ",{"type":43,"tag":56,"props":847,"children":848},{},[849],{"type":49,"value":850},"thin loader",{"type":49,"value":852},". Substantive material lives in\ntwo companion files:",{"type":43,"tag":218,"props":854,"children":855},{},[856,890],{"type":43,"tag":222,"props":857,"children":858},{},[859,864,866,872,874,880,882,888],{"type":43,"tag":64,"props":860,"children":862},{"className":861},[],[863],{"type":49,"value":133},{"type":49,"value":865}," — what the tool measures (the\nping-pong WRITE latency primitive driven by both sides'\nCUDA kernels through doca-gpunetio), the\nruntime-surface selection rule (GPUNetIO vs GPI vs\nCPU-initiated), the GPU-NIC pairing precondition, the\nlatency-vs-batching trade-off intrinsic to GPU-init\nRDMA, the median \u002F p99 \u002F jitter reporting taxonomy,\nthe version overlay (DOCA ",{"type":43,"tag":64,"props":867,"children":869},{"className":868},[],[870],{"type":49,"value":871},".pc",{"type":49,"value":873}," PLUS CUDA Toolkit),\nthe layered error taxonomy, the observability surface\n(stdout report including the timeout knob the\n",{"type":43,"tag":64,"props":875,"children":877},{"className":876},[],[878],{"type":49,"value":879},"gpunetio_rdma_write_lat_*",{"type":49,"value":881}," kernel functions surface\nper the verified ",{"type":43,"tag":64,"props":883,"children":885},{"className":884},[],[886],{"type":49,"value":887},"common.h",{"type":49,"value":889},"), and the safety overlay.",{"type":43,"tag":222,"props":891,"children":892},{},[893,898,900,906,907,913,914,920,921,927,928,934,936,942,944,950,952,958,960,966],{"type":43,"tag":64,"props":894,"children":896},{"className":895},[],[897],{"type":49,"value":98},{"type":49,"value":899}," — step-by-step workflows for the in-scope\ntask verbs: ",{"type":43,"tag":64,"props":901,"children":903},{"className":902},[],[904],{"type":49,"value":905},"install",{"type":49,"value":149},{"type":43,"tag":64,"props":908,"children":910},{"className":909},[],[911],{"type":49,"value":912},"configure",{"type":49,"value":149},{"type":43,"tag":64,"props":915,"children":917},{"className":916},[],[918],{"type":49,"value":919},"build",{"type":49,"value":149},{"type":43,"tag":64,"props":922,"children":924},{"className":923},[],[925],{"type":49,"value":926},"modify",{"type":49,"value":654},{"type":43,"tag":64,"props":929,"children":931},{"className":930},[],[932],{"type":49,"value":933},"run",{"type":49,"value":935}," (smoke-before-bulk; single-iteration verification;\nreading the report columns), ",{"type":43,"tag":64,"props":937,"children":939},{"className":938},[],[940],{"type":49,"value":941},"test",{"type":49,"value":943}," (the eval loop —\nmedian \u002F p99 \u002F jitter \u002F steady-state), ",{"type":43,"tag":64,"props":945,"children":947},{"className":946},[],[948],{"type":49,"value":949},"debug",{"type":49,"value":951}," (walk\nthe error taxonomy layer by layer), ",{"type":43,"tag":64,"props":953,"children":955},{"className":954},[],[956],{"type":49,"value":957},"use",{"type":49,"value":959}," (how a\nlatency result feeds a real-time class-of-workload\ndecision), plus a ",{"type":43,"tag":64,"props":961,"children":963},{"className":962},[],[964],{"type":49,"value":965},"Deferred task verbs",{"type":49,"value":967}," block.",{"type":43,"tag":52,"props":969,"children":970},{},[971,973,979,981,987],{"type":49,"value":972},"The skill assumes a host where DOCA is already installed,\na CUDA Toolkit matched to the install is present, and the\noperator has whatever privileges the public install\nprofile expects for binding a ",{"type":43,"tag":64,"props":974,"children":976},{"className":975},[],[977],{"type":49,"value":978},"doca_dev",{"type":49,"value":980},", a ",{"type":43,"tag":64,"props":982,"children":984},{"className":983},[],[985],{"type":49,"value":986},"doca_gpu",{"type":49,"value":988},",\nand an OOB TCP socket.",{"type":43,"tag":199,"props":990,"children":992},{"id":991},"what-this-skill-deliberately-does-not-ship",[993],{"type":49,"value":994},"What this skill deliberately does not ship",{"type":43,"tag":52,"props":996,"children":997},{},[998,1000,1005],{"type":49,"value":999},"This skill is ",{"type":43,"tag":56,"props":1001,"children":1002},{},[1003],{"type":49,"value":1004},"agent guidance",{"type":49,"value":1006},", not a samples or\nscripts bundle. It deliberately does not contain — and\npull requests should not add:",{"type":43,"tag":218,"props":1008,"children":1009},{},[1010,1043,1073,1092],{"type":43,"tag":222,"props":1011,"children":1012},{},[1013,1018,1020,1026,1028,1034,1036,1041],{"type":43,"tag":56,"props":1014,"children":1015},{},[1016],{"type":49,"value":1017},"Specific flag strings or expected latency numbers",{"type":49,"value":1019},"\nbeyond what the tool's shipped ",{"type":43,"tag":64,"props":1021,"children":1023},{"className":1022},[],[1024],{"type":49,"value":1025},"--help",{"type":49,"value":1027}," and ",{"type":43,"tag":64,"props":1029,"children":1031},{"className":1030},[],[1032],{"type":49,"value":1033},"main.c",{"type":49,"value":1035},"\nARGP registration establish. The flag surface is small\n(device name, GPU PCIe address, GID index, server IP\non the client side); the agent re-reads the binary's\n",{"type":43,"tag":64,"props":1037,"children":1039},{"className":1038},[],[1040],{"type":49,"value":1025},{"type":49,"value":1042}," on the installed version.",{"type":43,"tag":222,"props":1044,"children":1045},{},[1046,1051,1053,1058,1059,1064,1066,1071],{"type":43,"tag":56,"props":1047,"children":1048},{},[1049],{"type":49,"value":1050},"Pre-written DOCA GPUNetIO or CUDA kernel source\ncode",{"type":49,"value":1052}," that would compete with the shipped tool tree.\nThe shipped ",{"type":43,"tag":64,"props":1054,"children":1056},{"className":1055},[],[1057],{"type":49,"value":628},{"type":49,"value":149},{"type":43,"tag":64,"props":1060,"children":1062},{"className":1061},[],[1063],{"type":49,"value":636},{"type":49,"value":1065},", and ",{"type":43,"tag":64,"props":1067,"children":1069},{"className":1068},[],[1070],{"type":49,"value":644},{"type":49,"value":1072},"\nsubtrees are the verified worked example.",{"type":43,"tag":222,"props":1074,"children":1075},{},[1076,1081,1083,1091],{"type":43,"tag":56,"props":1077,"children":1078},{},[1079],{"type":49,"value":1080},"Wrappers, parsers, or scripts",{"type":49,"value":1082}," in any language that\nconsume the tool's stdout. The output format is small\nand documented in\n",{"type":43,"tag":96,"props":1084,"children":1085},{"href":364},[1086],{"type":43,"tag":64,"props":1087,"children":1089},{"className":1088},[],[1090],{"type":49,"value":371},{"type":49,"value":278},{"type":43,"tag":222,"props":1093,"children":1094},{},[1095,1122],{"type":43,"tag":56,"props":1096,"children":1097},{},[1098,1100,1106,1107,1113,1114,1120],{"type":49,"value":1099},"A ",{"type":43,"tag":64,"props":1101,"children":1103},{"className":1102},[],[1104],{"type":49,"value":1105},"samples\u002F",{"type":49,"value":149},{"type":43,"tag":64,"props":1108,"children":1110},{"className":1109},[],[1111],{"type":49,"value":1112},"bindings\u002F",{"type":49,"value":156},{"type":43,"tag":64,"props":1115,"children":1117},{"className":1116},[],[1118],{"type":49,"value":1119},"reference\u002F",{"type":49,"value":1121}," subtree.",{"type":49,"value":1123},"\nThis is a thin loader for a shipped tool tree.",{"type":43,"tag":199,"props":1125,"children":1127},{"id":1126},"loading-order",[1128],{"type":49,"value":1129},"Loading order",{"type":43,"tag":1131,"props":1132,"children":1133},"ol",{},[1134,1147,1167],{"type":43,"tag":222,"props":1135,"children":1136},{},[1137,1139,1145],{"type":49,"value":1138},"Read this ",{"type":43,"tag":64,"props":1140,"children":1142},{"className":1141},[],[1143],{"type":49,"value":1144},"SKILL.md",{"type":49,"value":1146}," first to confirm the user's\nquestion is in scope (the user actually wants to\nmeasure kernel-initiated WRITE latency through\nGPUNetIO, not the GPI variant, not the CPU-initiated\nvariant, and not a library API question).",{"type":43,"tag":222,"props":1148,"children":1149},{},[1150],{"type":43,"tag":56,"props":1151,"children":1152},{},[1153,1155,1160,1162,1166],{"type":49,"value":1154},"For what the tool measures, the surface-selection\nrule against the GPI sister tool and the CPU-initiated\n",{"type":43,"tag":64,"props":1156,"children":1158},{"className":1157},[],[1159],{"type":49,"value":573},{"type":49,"value":1161},", the latency-vs-batching trade-off, the\nmedian \u002F p99 \u002F jitter reporting taxonomy, the version\noverlay, the error taxonomy, the observability\nsurface, and the safety overlay, see\n",{"type":43,"tag":96,"props":1163,"children":1164},{"href":133},[1165],{"type":49,"value":133},{"type":49,"value":278},{"type":43,"tag":222,"props":1168,"children":1169},{},[1170],{"type":43,"tag":56,"props":1171,"children":1172},{},[1173,1175,1180,1181,1186,1187,1192,1193,1198,1199,1204,1205,1210,1211,1216,1217,1222,1224,1228],{"type":49,"value":1174},"For step-by-step workflows — ",{"type":43,"tag":64,"props":1176,"children":1178},{"className":1177},[],[1179],{"type":49,"value":905},{"type":49,"value":654},{"type":43,"tag":64,"props":1182,"children":1184},{"className":1183},[],[1185],{"type":49,"value":912},{"type":49,"value":149},{"type":43,"tag":64,"props":1188,"children":1190},{"className":1189},[],[1191],{"type":49,"value":919},{"type":49,"value":149},{"type":43,"tag":64,"props":1194,"children":1196},{"className":1195},[],[1197],{"type":49,"value":926},{"type":49,"value":149},{"type":43,"tag":64,"props":1200,"children":1202},{"className":1201},[],[1203],{"type":49,"value":933},{"type":49,"value":149},{"type":43,"tag":64,"props":1206,"children":1208},{"className":1207},[],[1209],{"type":49,"value":941},{"type":49,"value":654},{"type":43,"tag":64,"props":1212,"children":1214},{"className":1213},[],[1215],{"type":49,"value":949},{"type":49,"value":149},{"type":43,"tag":64,"props":1218,"children":1220},{"className":1219},[],[1221],{"type":49,"value":957},{"type":49,"value":1223}," — see ",{"type":43,"tag":96,"props":1225,"children":1226},{"href":98},[1227],{"type":49,"value":98},{"type":49,"value":278},{"type":43,"tag":199,"props":1230,"children":1232},{"id":1231},"related-skills",[1233],{"type":49,"value":1234},"Related skills",{"type":43,"tag":218,"props":1236,"children":1237},{},[1238,1274,1295,1323,1337,1373,1396,1416,1429,1444],{"type":43,"tag":222,"props":1239,"children":1240},{},[1241,1249,1251,1256,1258,1264,1266,1272],{"type":43,"tag":96,"props":1242,"children":1243},{"href":553},[1244],{"type":43,"tag":64,"props":1245,"children":1247},{"className":1246},[],[1248],{"type":49,"value":553},{"type":49,"value":1250}," —\nthe library this tool wraps. The per-GPU ",{"type":43,"tag":64,"props":1252,"children":1254},{"className":1253},[],[1255],{"type":49,"value":986},{"type":49,"value":1257},"\ncontext, the GPU-visible RDMA handles, the CUDA-side\npersistent-kernel pattern, the dual capability-\ndiscovery rule (DOCA cap-query AND\n",{"type":43,"tag":64,"props":1259,"children":1261},{"className":1260},[],[1262],{"type":49,"value":1263},"cudaGetDeviceProperties",{"type":49,"value":1265},"), and the env preconditions\n(",{"type":43,"tag":64,"props":1267,"children":1269},{"className":1268},[],[1270],{"type":49,"value":1271},"nvidia_peermem",{"type":49,"value":1273}," loaded, CUDA buffers registered\nwith DOCA) live there.",{"type":43,"tag":222,"props":1275,"children":1276},{},[1277,1286,1288,1293],{"type":43,"tag":96,"props":1278,"children":1280},{"href":1279},"..\u002F..\u002Flibs\u002Fdoca-rdma\u002FSKILL.md",[1281],{"type":43,"tag":64,"props":1282,"children":1284},{"className":1283},[],[1285],{"type":49,"value":1279},{"type":49,"value":1287}," —\nthe underlying RDMA library. The RDMA queue this tool\nbinds is created and connected via ",{"type":43,"tag":64,"props":1289,"children":1291},{"className":1290},[],[1292],{"type":49,"value":696},{"type":49,"value":1294},"; the\nqueue lifecycle, the transport type (RC vs UC vs UD),\nthe permission matrix, and the connection method are\nowned there.",{"type":43,"tag":222,"props":1296,"children":1297},{},[1298,1307,1309,1314,1316,1321],{"type":43,"tag":96,"props":1299,"children":1301},{"href":1300},"..\u002F..\u002Flibs\u002Fdoca-verbs\u002FSKILL.md",[1302],{"type":43,"tag":64,"props":1303,"children":1305},{"className":1304},[],[1306],{"type":49,"value":1300},{"type":49,"value":1308}," —\nthe raw-verbs escape hatch beneath ",{"type":43,"tag":64,"props":1310,"children":1312},{"className":1311},[],[1313],{"type":49,"value":696},{"type":49,"value":1315}," \u002F\n",{"type":43,"tag":64,"props":1317,"children":1319},{"className":1318},[],[1320],{"type":49,"value":548},{"type":49,"value":1322},". This tool stays on the higher-level\nsurfaces.",{"type":43,"tag":222,"props":1324,"children":1325},{},[1326,1335],{"type":43,"tag":96,"props":1327,"children":1329},{"href":1328},"..\u002Fdoca-gpunetio-ib-write-bw\u002FSKILL.md",[1330],{"type":43,"tag":64,"props":1331,"children":1333},{"className":1332},[],[1334],{"type":49,"value":1328},{"type":49,"value":1336}," —\nbandwidth analog of this tool on the same runtime\nframework. Same physical operation; different metric\nclass (latency vs BW). The two together carry the full\nGPUNetIO-side latency \u002F throughput picture.",{"type":43,"tag":222,"props":1338,"children":1339},{},[1340,1348,1350,1355,1356,1361,1363,1371],{"type":43,"tag":96,"props":1341,"children":1342},{"href":752},[1343],{"type":43,"tag":64,"props":1344,"children":1346},{"className":1345},[],[1347],{"type":49,"value":759},{"type":49,"value":1349}," — the GPI\nprogramming surface (CUDA-kernel-initiated RDMA). The\nalternative runtime framework for the same physical\noperation; ",{"type":43,"tag":64,"props":1351,"children":1353},{"className":1352},[],[1354],{"type":49,"value":335},{"type":49,"value":337},{"type":43,"tag":64,"props":1357,"children":1359},{"className":1358},[],[1360],{"type":49,"value":69},{"type":49,"value":1362},"\nbenchmark binary, so the GPI comparison is against the\nlibrary surface, not a sibling tool. The selection rule\nin\n",{"type":43,"tag":96,"props":1364,"children":1365},{"href":241},[1366],{"type":43,"tag":64,"props":1367,"children":1369},{"className":1368},[],[1370],{"type":49,"value":248},{"type":49,"value":1372},"\nis the decision aid; the agent's job is to teach when\nto pick which.",{"type":43,"tag":222,"props":1374,"children":1375},{},[1376,1386,1388,1394],{"type":43,"tag":96,"props":1377,"children":1379},{"href":1378},"..\u002F..\u002Fdoca-version\u002FSKILL.md",[1380],{"type":43,"tag":64,"props":1381,"children":1383},{"className":1382},[],[1384],{"type":49,"value":1385},"doca-version",{"type":49,"value":1387}," — the\ncanonical version-detection chain, four-way match\nrule. The ",{"type":43,"tag":64,"props":1389,"children":1391},{"className":1390},[],[1392],{"type":49,"value":1393},"## Version compatibility",{"type":49,"value":1395}," section here is a\nthin overlay.",{"type":43,"tag":222,"props":1397,"children":1398},{},[1399,1407,1409,1414],{"type":43,"tag":96,"props":1400,"children":1401},{"href":166},[1402],{"type":43,"tag":64,"props":1403,"children":1405},{"className":1404},[],[1406],{"type":49,"value":173},{"type":49,"value":1408}," — env\npreparation, install verification, GPU + CUDA Toolkit\npairing, ",{"type":43,"tag":64,"props":1410,"children":1412},{"className":1411},[],[1413],{"type":49,"value":1271},{"type":49,"value":1415}," load, hugepages, NUMA, and\nthe NGC DOCA container path.",{"type":43,"tag":222,"props":1417,"children":1418},{},[1419,1427],{"type":43,"tag":96,"props":1420,"children":1421},{"href":799},[1422],{"type":43,"tag":64,"props":1423,"children":1425},{"className":1424},[],[1426],{"type":49,"value":806},{"type":49,"value":1428}," —\nrouting to the public DOCA documentation set and the\nCUDA Toolkit pointer.",{"type":43,"tag":222,"props":1430,"children":1431},{},[1432,1442],{"type":43,"tag":96,"props":1433,"children":1435},{"href":1434},"..\u002F..\u002Fdoca-debug\u002FSKILL.md",[1436],{"type":43,"tag":64,"props":1437,"children":1439},{"className":1438},[],[1440],{"type":49,"value":1441},"doca-debug",{"type":49,"value":1443}," — the\ncross-cutting debug ladder.",{"type":43,"tag":222,"props":1445,"children":1446},{},[1447,1457],{"type":43,"tag":96,"props":1448,"children":1450},{"href":1449},"..\u002F..\u002Fdoca-hardware-safety\u002FSKILL.md",[1451],{"type":43,"tag":64,"props":1452,"children":1454},{"className":1453},[],[1455],{"type":49,"value":1456},"doca-hardware-safety",{"type":49,"value":1458}," —\nthe bundle-wide hardware-safety meta-policy.",{"items":1460,"total":1562},[1461,1476,1490,1504,1516,1533,1548],{"slug":1462,"name":1462,"fn":1463,"description":1464,"org":1465,"tags":1466,"stars":23,"repoUrl":24,"updatedAt":1475},"accelerated-computing-cudf","accelerate data processing with cuDF","Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV\u002FParquet I\u002FO, nullable semantics, and multi-GPU DataFrame workloads.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1467,1470,1473,1474],{"name":1468,"slug":1469,"type":15},"Data Analysis","data-analysis",{"name":1471,"slug":1472,"type":15},"Data Engineering","data-engineering",{"name":9,"slug":8,"type":15},{"name":13,"slug":14,"type":15},"2026-07-14T05:28:43.176466",{"slug":1477,"name":1477,"fn":1478,"description":1479,"org":1480,"tags":1481,"stars":23,"repoUrl":24,"updatedAt":1489},"aiq-deploy","deploy and manage NVIDIA AI-Q infrastructure","Use when asked to install, deploy, run, validate, troubleshoot, or stop NVIDIA AI-Q Blueprint infrastructure.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1482,1485,1488],{"name":1483,"slug":1484,"type":15},"Deployment","deployment",{"name":1486,"slug":1487,"type":15},"Infrastructure","infrastructure",{"name":9,"slug":8,"type":15},"2026-07-14T05:29:06.667109",{"slug":1491,"name":1491,"fn":1492,"description":1493,"org":1494,"tags":1495,"stars":23,"repoUrl":24,"updatedAt":1503},"aiq-research","conduct deep research with AI-Q","Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1496,1499,1500],{"name":1497,"slug":1498,"type":15},"Agents","agents",{"name":9,"slug":8,"type":15},{"name":1501,"slug":1502,"type":15},"Research","research","2026-07-14T05:28:06.816956",{"slug":1505,"name":1505,"fn":1506,"description":1507,"org":1508,"tags":1509,"stars":23,"repoUrl":24,"updatedAt":1515},"amc-run-sample-calibration","run AMC sample dataset calibration","Run end-to-end calibration on the shipped sample dataset (sdg_08_2_sample_data_010926.zip) against a running AMC microservice. Use when user says 'test sample dataset', 'run sample calibration', 'verify AMC install', or 'launch and test'.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1510,1511,1512],{"name":1468,"slug":1469,"type":15},{"name":9,"slug":8,"type":15},{"name":1513,"slug":1514,"type":15},"Testing","testing","2026-07-17T05:29:03.913266",{"slug":1517,"name":1517,"fn":1518,"description":1519,"org":1520,"tags":1521,"stars":23,"repoUrl":24,"updatedAt":1532},"amc-run-video-calibration","calibrate video datasets with AutoMagicCalib","Calibrate a new dataset from pre-recorded video files via the AutoMagicCalib REST API. Use when user has local MP4s and says 'calibrate my videos', 'run AMC on these videos', or similar. For RTSP\u002Flive streams, use amc-run-rtsp-calibration instead.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1522,1525,1528,1529],{"name":1523,"slug":1524,"type":15},"Automation","automation",{"name":1526,"slug":1527,"type":15},"Imaging","imaging",{"name":9,"slug":8,"type":15},{"name":1530,"slug":1531,"type":15},"Video","video","2026-07-17T05:28:53.905004",{"slug":1534,"name":1534,"fn":1535,"description":1536,"org":1537,"tags":1538,"stars":23,"repoUrl":24,"updatedAt":1547},"amc-setup-calibration-stack","deploy AutoMagicCalib microservice with Docker","Launch AutoMagicCalib microservice and web UI from NGC release images via Docker Compose. Use when user says 'deploy auto calibration', 'launch auto calibration', 'launch AMC', 'start MS+UI', or 'set up auto-magic-calib'. Requires NGC API key.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1539,1540,1543,1544],{"name":1483,"slug":1484,"type":15},{"name":1541,"slug":1542,"type":15},"Docker","docker",{"name":9,"slug":8,"type":15},{"name":1545,"slug":1546,"type":15},"Operations","operations","2026-07-17T05:28:56.913999",{"slug":1549,"name":1549,"fn":1550,"description":1551,"org":1552,"tags":1553,"stars":23,"repoUrl":24,"updatedAt":1561},"cudaq-guide","develop quantum applications with CUDA-Q","CUDA-Q onboarding guide for installation, test programs, GPU simulation, QPU hardware, and quantum applications.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1554,1555,1558],{"name":9,"slug":8,"type":15},{"name":1556,"slug":1557,"type":15},"Quantum Computing","quantum-computing",{"name":1559,"slug":1560,"type":15},"Simulation","simulation","2026-07-14T05:26:58.898253",305,{"items":1564,"total":1715},[1565,1583,1599,1610,1622,1636,1649,1663,1674,1683,1697,1706],{"slug":1566,"name":1566,"fn":1567,"description":1568,"org":1569,"tags":1570,"stars":1580,"repoUrl":1581,"updatedAt":1582},"nemoclaw-user-guide","retrieve NemoClaw documentation and configuration","Guides human users' AI agents to the NemoClaw docs MCP server and canonical Fern documentation in Markdown form. Use when users ask how to install, configure, operate, troubleshoot, secure, or learn NemoClaw with an AI coding assistant. Trigger keywords - nemoclaw docs, use nemoclaw with ai agent, nemoclaw mcp docs, nemoclaw install help, nemoclaw quickstart, nemoclaw markdown docs, llms.txt, agent skills.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1571,1574,1577],{"name":1572,"slug":1573,"type":15},"Documentation","documentation",{"name":1575,"slug":1576,"type":15},"MCP","mcp",{"name":1578,"slug":1579,"type":15},"Search","search",21777,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FNemoClaw","2026-07-20T06:00:01.461044",{"slug":1584,"name":1584,"fn":1585,"description":1586,"org":1587,"tags":1588,"stars":1596,"repoUrl":1597,"updatedAt":1598},"mcore-build-and-dependency","manage Megatron-LM development environments","Container-based dev environment setup and dependency management for Megatron-LM. Covers acquiring and launching the CI container, uv package management, and updating uv.lock.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1589,1592,1593],{"name":1590,"slug":1591,"type":15},"Containers","containers",{"name":1483,"slug":1484,"type":15},{"name":1594,"slug":1595,"type":15},"Python","python",17049,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FMegatron-LM","2026-07-27T06:06:11.249662",{"slug":1600,"name":1600,"fn":1601,"description":1602,"org":1603,"tags":1604,"stars":1596,"repoUrl":1597,"updatedAt":1609},"mcore-bump-base-image","update NVIDIA PyTorch base images","Bump the NVIDIA PyTorch base image (`nvcr.io\u002Fnvidia\u002Fpytorch:YY.MM-py3`) used by Megatron-LM CI. Covers the two pin sites (GitHub CI in `docker\u002F.ngc_version.dev` and GitLab CI in `.gitlab\u002Fstages\u002F01.build.yml`), the post-bump CI loop (re-run functional tests, refresh golden values, mark broken tests), and the gotchas that bit PRs",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1605,1608],{"name":1606,"slug":1607,"type":15},"CI\u002FCD","ci-cd",{"name":1483,"slug":1484,"type":15},"2026-07-14T05:25:59.97109",{"slug":1611,"name":1611,"fn":1612,"description":1613,"org":1614,"tags":1615,"stars":1596,"repoUrl":1597,"updatedAt":1621},"mcore-cicd","manage CI\u002FCD pipelines for Megatron-LM","CI\u002FCD reference for Megatron-LM. Covers CI pipeline structure, PR scope labels, triggering internal GitLab CI (which force-pushes the current branch to a pull-request\u002FBRANCH ref — always dry-run and verify the destination first; never run against shared or protected branches), and CI failure investigation.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1616,1617,1618],{"name":1606,"slug":1607,"type":15},{"name":1483,"slug":1484,"type":15},{"name":1619,"slug":1620,"type":15},"GitHub","github","2026-07-27T06:06:12.278222",{"slug":1623,"name":1623,"fn":1624,"description":1625,"org":1626,"tags":1627,"stars":1596,"repoUrl":1597,"updatedAt":1635},"mcore-create-issue","investigate CI failures and create issues","Investigate a failing GitHub Actions run or job and create a GitHub issue for the failure.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1628,1631,1632],{"name":1629,"slug":1630,"type":15},"Debugging","debugging",{"name":1619,"slug":1620,"type":15},{"name":1633,"slug":1634,"type":15},"Triage","triage","2026-07-14T05:25:57.442089",{"slug":1637,"name":1637,"fn":1638,"description":1639,"org":1640,"tags":1641,"stars":1596,"repoUrl":1597,"updatedAt":1648},"mcore-linting-and-formatting","lint and format Megatron-LM code","Linting and formatting for Megatron-LM. Covers running autoformat.sh, tools (ruff, black, isort, pylint, mypy), and code style rules.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1642,1645],{"name":1643,"slug":1644,"type":15},"Best Practices","best-practices",{"name":1646,"slug":1647,"type":15},"Code Analysis","code-analysis","2026-07-14T05:25:56.18433",{"slug":1650,"name":1650,"fn":1651,"description":1652,"org":1653,"tags":1654,"stars":1596,"repoUrl":1597,"updatedAt":1662},"mcore-migrate-gpt-to-hybrid","migrate Megatron-LM models to HybridModel","Migration guide for moving Megatron Core GPTModel checkpoints, model providers, training commands, and layer mappings to HybridModel.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1655,1658,1661],{"name":1656,"slug":1657,"type":15},"Machine Learning","machine-learning",{"name":1659,"slug":1660,"type":15},"Migration","migration",{"name":9,"slug":8,"type":15},"2026-07-17T06:07:11.777011",{"slug":1664,"name":1664,"fn":1665,"description":1666,"org":1667,"tags":1668,"stars":1596,"repoUrl":1597,"updatedAt":1673},"mcore-onboard-gb200-1node-tests","onboard functional tests for GB200","Onboard 1-node GitHub MR functional tests for GB200 from existing mr-scoped 2-node tests.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1669,1672],{"name":1670,"slug":1671,"type":15},"QA","qa",{"name":1513,"slug":1514,"type":15},"2026-07-14T05:25:53.673039",{"slug":1675,"name":1675,"fn":1676,"description":1677,"org":1678,"tags":1679,"stars":1596,"repoUrl":1597,"updatedAt":1682},"mcore-run-on-slurm","launch distributed training jobs on SLURM","How to launch distributed Megatron-LM training jobs on a SLURM cluster. Covers a minimal sbatch skeleton, environment-variable setup for torch.distributed.run, CUDA_DEVICE_MAX_CONNECTIONS rules across hardware and parallelism modes, container conventions, monitoring, and per-rank failure diagnosis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1680,1681],{"name":1483,"slug":1484,"type":15},{"name":1486,"slug":1487,"type":15},"2026-07-14T05:25:49.362534",{"slug":1684,"name":1684,"fn":1685,"description":1686,"org":1687,"tags":1688,"stars":1596,"repoUrl":1597,"updatedAt":1696},"mcore-split-pr","split pull requests to reduce review load","Split a PR into multiple PRs to reduce the number of required CODEOWNERS reviewer groups.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1689,1692,1693],{"name":1690,"slug":1691,"type":15},"Code Review","code-review",{"name":1619,"slug":1620,"type":15},{"name":1694,"slug":1695,"type":15},"Pull Requests","pull-requests","2026-07-14T05:26:01.226578",{"slug":1698,"name":1698,"fn":1699,"description":1700,"org":1701,"tags":1702,"stars":1596,"repoUrl":1597,"updatedAt":1705},"mcore-testing","run and manage Megatron-LM tests","Test system for Megatron-LM. Covers test layout, recipe YAML structure, adding and running unit and functional tests, golden values, marker filters, and CI parity.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1703,1704],{"name":1670,"slug":1671,"type":15},{"name":1513,"slug":1514,"type":15},"2026-07-14T05:25:54.928983",{"slug":1707,"name":1707,"fn":1708,"description":1709,"org":1710,"tags":1711,"stars":1596,"repoUrl":1597,"updatedAt":1714},"nightly-sync","manage nightly main-to-dev sync workflows","Domain knowledge for the nightly main-to-dev sync workflow. Covers merge strategy, CI architecture, failure investigation, and known issues.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1712,1713],{"name":1523,"slug":1524,"type":15},{"name":1606,"slug":1607,"type":15},"2026-07-30T05:29:03.275638",496]