DOCA GPUNetIO
Examples
- "CUDA kernel reading packets directly from the NIC." — this is
in scope. Stay on
doca_gpu_eth_rxq / _txq and the persistent
kernel; do not rewrite it as host-CPU Ethernet.
- "DOCA_ERROR_DRIVER on doca_gpu_create." — check CUDA device
match and dmabuf /
nvidia-peermem registration before changing queue type.
Instructions
Follow Loading order below. Open the tasks companion for configure /
build / run. Open the capabilities companion for GPU vs host path
selection. Do not open every companion file.
Where to start: This skill assumes DOCA is already installed,
the CUDA toolkit is installed and matched to the DOCA install, and
the user is doing hands-on GPUNetIO work — i.e. wiring a DOCA
network queue into a CUDA kernel on an NVIDIA GPU. Open
the tasks companion if the user wants to do something
(configure / build / modify / run / test / debug); open
the capabilities companion when the question is what
can GPUNetIO express on this version + this GPU. If the user has
not installed DOCA yet, route to
doca-setup/SKILL.md first; if the user has
not set up the underlying Ethernet RX/TX queues yet, that is a
DOCA Ethernet question — route to
doca-eth/SKILL.md.
Example questions this skill answers well
The CLASSES of GPUNetIO questions this skill is built to answer,
each with one worked example. The agent should treat the class
as the load-bearing piece — the worked example is a single
instance.
- "How do I get a CUDA kernel to receive packets directly from
the NIC?" — worked example: "persistent kernel on one GPU
reads packets from a
doca_gpu_eth_rxq built on top of a
representor doca_eth_rxq and counts them per-flow". Answered
by the persistent-kernel pattern inCapabilities and modes
- the GPU-side bring-up workflow in
configure.
- "Can I run GPUNetIO on this GPU?" — worked example: "my
host has one Ampere card and one Turing card; which one
supports GPU-initiated networking?". Answered by the dual
capability-discovery rule (DOCA cap-query AND
cudaGetDeviceProperties against the CUDA device ordinal) inCapabilities and modes
- the device-enumeration step in
configure.
- "Why does my GPUNetIO setup fail with
DOCA_ERROR_NOT_SUPPORTED even though doca-eth came up
fine?" — worked example: "nvidia_peermem is not loaded so
GPUDirect RDMA is unavailable". Answered by the env preconditions
in ## Safety policy
configure step 1.
- "How do I move data between CUDA-allocated buffers and a DOCA
queue?" — worked example: "use
cudaMalloc for the receive
buffer pool and register it with DOCA via doca_buf_arr_create_*
before starting the context". Answered by the CUDA-allocator
- DOCA-registration overlay in
Safety policy
configure step 4.
- "Is the GPUNetIO API I'm reading about on my installed DOCA +
CUDA combination?" — worked example: "is the persistent-kernel
helper available with the CUDA toolkit version I have?".
Answered by the version-compatibility overlay in
Version compatibility
which cross-links the canonical detection chain in
doca-version/SKILL.md and adds the
GPUNetIO-specific DOCA must match CUDA overlay.
- "What does this
DOCA_ERROR_* from a GPUNetIO call mean and
which layer caused it?" — worked example: "DOCA_ERROR_DRIVER
on doca_gpu_*_create — is it DOCA, CUDA, or the underlying
doca-eth queue?". Answered by the GPUNetIO overlay on the
cross-library taxonomy inError taxonomy
debug that escalates to
doca-debug/SKILL.md.
Audience
This skill serves external developers building applications
that consume the DOCA GPUNetIO library — i.e., users whose code
calls doca_gpu_* from host C/C++ to stand up the per-GPU
context and the GPU-visible queue handles, and whose CUDA kernel
(.cu translation unit) uses those handles from device code to
submit / receive packets. The canonical target shape is the GPU
Packet Processing reference application: a CUDA persistent
kernel on an NVIDIA GPU that polls a GPU-visible RX queue and
processes packets in-place on the GPU. It is not for NVIDIA
developers contributing to DOCA GPUNetIO itself.
Language scope. DOCA GPUNetIO ships as a C / CUDA library
with pkg-config module name doca-gpunetio. The host-side API
is C; the device-side API is CUDA C++ used inside a .cu
kernel. The shipped samples and the GPU Packet Processing
reference application are written in C + CUDA C++ (NVIDIA's
choice). Other-language consumers are limited in practice — the
device-side API has no FFI escape hatch because the kernel must
be a CUDA translation unit — but a Rust / Go / Python host-side
wrapper that drives the host-side doca_gpu_* setup and
launches a CUDA kernel built separately is still useful, and the
skill keeps the lifecycle, capability-discovery, env-precondition,
and error-taxonomy guidance language-neutral.
When to load this skill
Load this skill when the user is doing hands-on DOCA GPUNetIO
work, in any host language plus CUDA. Concretely:
- Initializing a
doca_gpu against a specific CUDA device
ordinal on a host with one or more NVIDIA GPUs.
- Creating a GPU-visible queue handle (
doca_gpu_eth_rxq,
doca_gpu_eth_txq) on top of an existing doca_eth_rxq /
doca_eth_txq from DOCA Ethernet, and passing the handle into
a CUDA kernel for device-side use.
- Writing or modifying the persistent CUDA kernel that drains
the GPU-visible RX queue in a long-running loop (the canonical
GPU Packet Processing shape).
- Allocating GPU buffers via
cudaMalloc and registering them
with DOCA via the doca_buf_arr_create_* family before
doca_ctx_start().
- Checking which GPUNetIO features are supported on the active
doca_devinfo (DOCA cap-query family) AND on the candidate
CUDA device (cudaGetDeviceProperties and CUDA-driver-version
checks).
- Debugging a
DOCA_ERROR_* returned from a GPUNetIO call — in
particular disambiguating DOCA capability missing from CUDA
device too old from nvidia_peermem not loaded from CUDA
driver + DOCA version skew.
- Designing host-side bindings for non-C languages that drive a
CUDA kernel they built separately — the env-precondition and
capability-discovery rules in this skill still apply.
Do not load this skill for general DOCA orientation, install
of DOCA or the CUDA toolkit, the underlying DOCA Ethernet queue
setup, or non-GPUNetIO library questions. For those, route
through doca-public-knowledge-map/SKILL.md
to the matching upstream guide.
What this skill provides
This is a thin loader. The body keeps only the orientation
needed to pick the right next file. The substantive
GPUNetIO-specific material lives in two companion files:
- the capabilities companion — what GPUNetIO can express on this version
- this GPU: the
doca_gpu per-device context, the GPU-visible
RX / TX queue handles layered on doca-eth, the persistent
CUDA-kernel pattern as the default usage shape, the
capability-query surface (the doca-eth
doca_eth_rxq_cap_is_type_supported / doca_eth_rxq_cap_get_*
family in doca_eth_rxq.h, plus the matching
doca_eth_txq_cap_* family, on the DOCA side, plus
cudaGetDeviceProperties on the CUDA side), the GPUNetIO error taxonomy mapped onto the cross-library
DOCA_ERROR_* set, the observability surface (CUDA-side
counters + DOCA-side per-task completion), and the safety
policy that gates env preconditions (CUDA + DOCA version
match, dmabuf or nvidia-peermem registration).
- the tasks companion — step-by-step workflows for the six in-scope
GPUNetIO verbs:
configure, build, modify, run, test,
debug. Plus a ## rollback overlay (GPUNetIO-specific
five-step teardown that signals the persistent kernel to
drain, unregisters GPU buffers in reverse-register order, and
leaves the parent doca-eth queue intact) and the 5-phase
universal debug-loop instantiation appended to ## debug.
Plus a Deferred task verbs block that points out-of-scope
questions at the right next skill.
The skill assumes a host where DOCA is already installed at the
standard location, an NVIDIA GPU is physically present, the CUDA
toolkit is installed and its version is matched to the DOCA
install per the DOCA Compatibility Policy, and the underlying
DOCA Ethernet RX/TX queues are already configured (this skill
sits on top of doca-eth, not below it). It does not cover
installing DOCA or the CUDA toolkit — that path goes through
doca-setup/SKILL.md.
What this skill deliberately does not ship
This skill is agent guidance, not a samples or templates
bundle. To keep the boundary clean, it deliberately does not
contain — and pull requests should not add:
- Pre-written DOCA GPUNetIO application source code or CUDA
kernel source, in any language. The verified GPUNetIO
source is the shipped C + CUDA samples at
/opt/mellanox/doca/samples/doca_gpunetio/ and the GPU Packet
Processing reference application. The agent's job is to route
the user to those files and prescribe a minimum-diff
modification on them via the universal modify-a-sample
workflow in
doca-programming-guide/SKILL.md,
layered with the GPUNetIO-specific overrides inmodify.
- Standalone build manifests (
meson.build,
CMakeLists.txt, …) parked inside the skill. The agent
constructs the build manifest in the user's project
directory against the user's installed DOCA + CUDA toolkit,
where pkg-config --modversion doca-gpunetio,
pkg-config --modversion doca-common, and nvcc --version
form the version gate.
- A
samples/, bindings/, or reference/ subtree of any
kind. A mock or incomplete artifact in this skill's tree, even
one labeled "reference", is misleading: users will read it as
buildable.
Loading order
- Read this skill first to confirm the user's question is
in scope.
- For the GPUNetIO capability matrix, the
doca_gpu per-device
context, the persistent-kernel pattern, the dual capability
query, the env-precondition policy, the error taxonomy, the
observability surface, and the safety policy, see
the capabilities companion.
- For step-by-step workflows — configure, build, modify, run,
test, debug — see the tasks companion.
Both companion files cross-link to each other,
doca-version/SKILL.md for the canonical
DOCA version-handling rules (with the GPUNetIO overlay that DOCA
must match CUDA), and
doca-public-knowledge-map/SKILL.md
whenever the right answer is "look it up in the public DOCA
GPUNetIO guide, the DOCA Compatibility Policy, the CUDA toolkit
docs, or the on-disk install layout" rather than
"GPUNetIO-specific guidance".
Related skills
doca-public-knowledge-map/SKILL.md —
the routing table for every public DOCA documentation source
and the on-disk layout of an installed DOCA package. The
GPUNetIO public guide is at
https://docs.nvidia.com/doca/sdk/DOCA-GPUNetIO/index.html;
the GPU Packet Processing reference application is reachable
from there. The CUDA toolkit and DOCA Compatibility Policy
links live in the same routing table.
doca-setup/SKILL.md — env preparation,
install verification, CUDA toolkit install / verification, and
the I have no install yet path with the public NGC DOCA
container. This skill assumes its preconditions are satisfied
AND that CUDA is installed at a version that matches DOCA.
doca-version/SKILL.md — canonical DOCA
version-handling rules. This skill's ## Version compatibility cross-links the four-way match rule and adds
the GPUNetIO-specific DOCA-and-CUDA must match overlay per
the DOCA Compatibility Policy.
doca-structured-tools-contract/SKILL.md —
the bundle's structured-tools precedence rule (detect / prefer
/ fall back / report). The Command appendix in
the tasks companion honors this contract.
doca-programming-guide/SKILL.md —
general DOCA programming patterns shared by every library:
the canonical pkg-config + meson build pattern, the
universal modify-a-shipped-sample first-app workflow, the
universal lifecycle, the cross-library DOCA_ERROR_*
taxonomy, and the program-side debug order. This skill
layers GPUNetIO specifics on top.
doca-debug/SKILL.md — the cross-cutting
debug ladder (install / version / build / link / runtime /
program / driver). GPUNetIO-specific debug (CUDA + DOCA
version skew, nvidia_peermem missing, persistent-kernel
silent hangs, CUDA-allocator + DOCA-registration mismatches)
overlays on top of that ladder.
DOCA Ethernet is GPUNetIO's mandatory companion library: GPU-visible
RX / TX queue handles are layered on top of doca_eth_rxq /
doca_eth_txq from DOCA Ethernet. For the underlying queue setup,
route to doca-eth/SKILL.md.
1---2license: Apache-2.03name: doca-gpunetio4description: >5 Use this skill when the user is doing hands-on DOCA GPUNetIO6 programming — wiring a CUDA kernel on an NVIDIA GPU to a doca-eth7 queue via doca_gpu_eth_rxq / doca_gpu_eth_txq, standing up the8 per-CUDA-device doca_gpu context, designing the persistent CUDA kernel9 that drains the GPU-visible queue, running the dual capability check10 (DOCA cap-query plus cudaGetDeviceProperties), registering cudaMalloc11 pools via doca_buf_arr_create_*, or debugging DOCA_ERROR_* returns12 from the GPUNetIO API. Trigger even when the user does not explicitly13 mention "DOCA GPUNetIO" or "persistent kernel" — typical implicit14 phrasings include "CUDA kernel reading packets directly from the NIC",15 "GPU-initiated networking on BlueField", "DOCA_ERROR_DRIVER on16 doca_gpu_create", "nvidia_peermem not loaded", "kernel-per-packet is17 too slow", or "which GPU supports GPU-side packet I/O". Refuse and18 route elsewhere for general CUDA programming, DOCA Ethernet queue19 bring-up, DOCA DPA, or DOCA install — those belong to other skills.20metadata:21 source: https://skillmd.com/skills/nvidia/doca-gpunetio22 author: NVIDIA <doca-feedback@nvidia.com>23 kind: library24 doca_version: "3.5"25 tags:26 - doca27 - gpunetio28 - cuda29compatibility: >30 Requires DOCA SDK at /opt/mellanox/doca on Linux (Ubuntu 22.04/24.0431 or RHEL/SLES) with a BlueField DPU or ConnectX NIC. Reads the local32 install via `pkg-config doca-gpunetio`. Requires an NVIDIA GPU with33 CUDA toolkit (matched to DOCA per the DOCA Compatibility Policy) and34 GPU memory registered via dmabuf (or the legacy nvidia-peermem fallback) for GPUDirect RDMA; some35 samples need an InfiniBand-capable RNIC. The validation steps require36 a live DOCA install.37---3839# DOCA GPUNetIO4041## Examples4243- **"CUDA kernel reading packets directly from the NIC."** — this is44 in scope. Stay on `doca_gpu_eth_rxq` / `_txq` and the persistent45 kernel; do not rewrite it as host-CPU Ethernet.46- **"DOCA_ERROR_DRIVER on doca_gpu_create."** — check CUDA device47 match and dmabuf / `nvidia-peermem` registration before changing queue type.4849## Instructions5051Follow Loading order below. Open the tasks companion for configure /52build / run. Open the capabilities companion for GPU vs host path53selection. Do not open every companion file.5455**Where to start:** This skill assumes DOCA is already installed,56the CUDA toolkit is installed and matched to the DOCA install, and57the user is doing **hands-on GPUNetIO work** — i.e. wiring a DOCA58network queue into a CUDA kernel on an NVIDIA GPU. Open59the tasks companion if the user wants to *do* something60(configure / build / modify / run / test / debug); open61the capabilities companion when the question is *what62can GPUNetIO express* on this version + this GPU. If the user has63not installed DOCA yet, route to64`doca-setup/SKILL.md` first; if the user has65not set up the underlying Ethernet RX/TX queues yet, that is a66DOCA Ethernet question — route to67`doca-eth/SKILL.md`.6869## Example questions this skill answers well7071The CLASSES of GPUNetIO questions this skill is built to answer,72each with one worked example. The agent should treat the *class*73as the load-bearing piece — the worked example is a single74instance.7576- **"How do I get a CUDA kernel to receive packets directly from77 the NIC?"** — worked example: *"persistent kernel on one GPU78 reads packets from a `doca_gpu_eth_rxq` built on top of a79 representor `doca_eth_rxq` and counts them per-flow"*. Answered80 by the persistent-kernel pattern in81 ## Capabilities and modes82 + the GPU-side bring-up workflow in83 ## configure.84- **"Can I run GPUNetIO on this GPU?"** — worked example: *"my85 host has one Ampere card and one Turing card; which one86 supports GPU-initiated networking?"*. Answered by the dual87 capability-discovery rule (DOCA cap-query AND88 `cudaGetDeviceProperties` against the CUDA device ordinal) in89 ## Capabilities and modes90 + the device-enumeration step in91 ## configure.92- **"Why does my GPUNetIO setup fail with93 `DOCA_ERROR_NOT_SUPPORTED` even though doca-eth came up94 fine?"** — worked example: *"`nvidia_peermem` is not loaded so95 GPUDirect RDMA is unavailable"*. Answered by the env preconditions96 in ## Safety policy97 + the env checklist in98 ## configure step 1.99- **"How do I move data between CUDA-allocated buffers and a DOCA100 queue?"** — worked example: *"use `cudaMalloc` for the receive101 buffer pool and register it with DOCA via `doca_buf_arr_create_*`102 before starting the context"*. Answered by the CUDA-allocator103 + DOCA-registration overlay in104 ## Safety policy105 + the buffer-prep step in106 ## configure step 4.107- **"Is the GPUNetIO API I'm reading about on my installed DOCA +108 CUDA combination?"** — worked example: *"is the persistent-kernel109 helper available with the CUDA toolkit version I have?"*.110 Answered by the version-compatibility overlay in111 ## Version compatibility112 which cross-links the canonical detection chain in113 `doca-version/SKILL.md` and adds the114 GPUNetIO-specific *DOCA must match CUDA* overlay.115- **"What does this `DOCA_ERROR_*` from a GPUNetIO call mean and116 which layer caused it?"** — worked example: *"`DOCA_ERROR_DRIVER`117 on `doca_gpu_*_create` — is it DOCA, CUDA, or the underlying118 doca-eth queue?"*. Answered by the GPUNetIO overlay on the119 cross-library taxonomy in120 ## Error taxonomy121 + the layered ladder in122 ## debug that escalates to123 `doca-debug/SKILL.md`.124125## Audience126127This skill serves **external developers building applications128that consume the DOCA GPUNetIO library** — i.e., users whose code129calls `doca_gpu_*` from host C/C++ to stand up the per-GPU130context and the GPU-visible queue handles, and whose CUDA kernel131(`.cu` translation unit) uses those handles from device code to132submit / receive packets. The canonical target shape is the GPU133Packet Processing reference application: a CUDA persistent134kernel on an NVIDIA GPU that polls a GPU-visible RX queue and135processes packets in-place on the GPU. It is *not* for NVIDIA136developers contributing to DOCA GPUNetIO itself.137138**Language scope.** DOCA GPUNetIO ships as a C / CUDA library139with `pkg-config` module name `doca-gpunetio`. The host-side API140is C; the device-side API is CUDA C++ used inside a `.cu`141kernel. The shipped samples and the GPU Packet Processing142reference application are written in C + CUDA C++ (NVIDIA's143choice). Other-language consumers are limited in practice — the144device-side API has no FFI escape hatch because the kernel must145be a CUDA translation unit — but a Rust / Go / Python host-side146wrapper that drives the host-side `doca_gpu_*` setup and147launches a CUDA kernel built separately is still useful, and the148skill keeps the lifecycle, capability-discovery, env-precondition,149and error-taxonomy guidance language-neutral.150151## When to load this skill152153Load this skill when the user is doing hands-on DOCA GPUNetIO154work, in any host language plus CUDA. Concretely:155156- Initializing a `doca_gpu` against a specific CUDA device157 ordinal on a host with one or more NVIDIA GPUs.158- Creating a GPU-visible queue handle (`doca_gpu_eth_rxq`,159 `doca_gpu_eth_txq`) on top of an existing `doca_eth_rxq` /160 `doca_eth_txq` from DOCA Ethernet, and passing the handle into161 a CUDA kernel for device-side use.162- Writing or modifying the persistent CUDA kernel that drains163 the GPU-visible RX queue in a long-running loop (the canonical164 GPU Packet Processing shape).165- Allocating GPU buffers via `cudaMalloc` and registering them166 with DOCA via the `doca_buf_arr_create_*` family before167 `doca_ctx_start()`.168- Checking which GPUNetIO features are supported on the active169 `doca_devinfo` (DOCA cap-query family) AND on the candidate170 CUDA device (`cudaGetDeviceProperties` and CUDA-driver-version171 checks).172- Debugging a `DOCA_ERROR_*` returned from a GPUNetIO call — in173 particular disambiguating *DOCA capability missing* from *CUDA174 device too old* from *`nvidia_peermem` not loaded* from *CUDA175 driver + DOCA version skew*.176- Designing host-side bindings for non-C languages that drive a177 CUDA kernel they built separately — the env-precondition and178 capability-discovery rules in this skill still apply.179180Do **not** load this skill for general DOCA orientation, install181of DOCA or the CUDA toolkit, the underlying DOCA Ethernet queue182setup, or non-GPUNetIO library questions. For those, route183through `doca-public-knowledge-map/SKILL.md`184to the matching upstream guide.185186## What this skill provides187188This is a **thin loader**. The body keeps only the orientation189needed to pick the right next file. The substantive190GPUNetIO-specific material lives in two companion files:191192- the capabilities companion — what GPUNetIO can express on this version193 + this GPU: the `doca_gpu` per-device context, the GPU-visible194 RX / TX queue handles layered on doca-eth, the persistent195 CUDA-kernel pattern as the default usage shape, the196 capability-query surface (the doca-eth197 `doca_eth_rxq_cap_is_type_supported` / `doca_eth_rxq_cap_get_*`198 family in `doca_eth_rxq.h`, plus the matching199 `doca_eth_txq_cap_*` family, on the DOCA side, plus200 `cudaGetDeviceProperties` on the CUDA side), the GPUNetIO error taxonomy mapped onto the cross-library201 `DOCA_ERROR_*` set, the observability surface (CUDA-side202 counters + DOCA-side per-task completion), and the safety203 policy that gates env preconditions (CUDA + DOCA version204 match, dmabuf or `nvidia-peermem` registration).205- the tasks companion — step-by-step workflows for the six in-scope206 GPUNetIO verbs: `configure`, `build`, `modify`, `run`, `test`,207 `debug`. Plus a `## rollback` overlay (GPUNetIO-specific208 five-step teardown that signals the persistent kernel to209 drain, unregisters GPU buffers in reverse-register order, and210 leaves the parent doca-eth queue intact) and the 5-phase211 universal debug-loop instantiation appended to `## debug`.212 Plus a `Deferred task verbs` block that points out-of-scope213 questions at the right next skill.214215The skill assumes a host where DOCA is already installed at the216standard location, an NVIDIA GPU is physically present, the CUDA217toolkit is installed and its version is matched to the DOCA218install per the DOCA Compatibility Policy, and the underlying219DOCA Ethernet RX/TX queues are *already* configured (this skill220sits on top of doca-eth, not below it). It does not cover221installing DOCA or the CUDA toolkit — that path goes through222`doca-setup/SKILL.md`.223224## What this skill deliberately does not ship225226This skill is **agent guidance**, not a samples or templates227bundle. To keep the boundary clean, it deliberately does not228contain — and pull requests should not add:229230- **Pre-written DOCA GPUNetIO application source code or CUDA231 kernel source, in any language.** The verified GPUNetIO232 source is the shipped C + CUDA samples at233 `/opt/mellanox/doca/samples/doca_gpunetio/` and the GPU Packet234 Processing reference application. The agent's job is to route235 the user to those files and prescribe a minimum-diff236 modification on them via the universal modify-a-sample237 workflow in238 `doca-programming-guide/SKILL.md`,239 layered with the GPUNetIO-specific overrides in240 ## modify.241- **Standalone build manifests** (`meson.build`,242 `CMakeLists.txt`, …) parked inside the skill. The agent243 constructs the build manifest *in the user's project244 directory* against the user's installed DOCA + CUDA toolkit,245 where `pkg-config --modversion doca-gpunetio`,246 `pkg-config --modversion doca-common`, and `nvcc --version`247 form the version gate.248- **A `samples/`, `bindings/`, or `reference/` subtree** of any249 kind. A mock or incomplete artifact in this skill's tree, even250 one labeled "reference", is misleading: users will read it as251 buildable.252253## Loading order2542551. Read this skill first to confirm the user's question is256 in scope.2572. **For the GPUNetIO capability matrix, the `doca_gpu` per-device258 context, the persistent-kernel pattern, the dual capability259 query, the env-precondition policy, the error taxonomy, the260 observability surface, and the safety policy, see261 the capabilities companion.**2623. **For step-by-step workflows — configure, build, modify, run,263 test, debug — see the tasks companion.**264265Both companion files cross-link to each other,266`doca-version/SKILL.md` for the canonical267DOCA version-handling rules (with the GPUNetIO overlay that DOCA268must match CUDA), and269`doca-public-knowledge-map/SKILL.md`270whenever the right answer is "look it up in the public DOCA271GPUNetIO guide, the DOCA Compatibility Policy, the CUDA toolkit272docs, or the on-disk install layout" rather than273"GPUNetIO-specific guidance".274275## Related skills276277- `doca-public-knowledge-map/SKILL.md` —278 the routing table for every public DOCA documentation source279 and the on-disk layout of an installed DOCA package. The280 GPUNetIO public guide is at281 <https://docs.nvidia.com/doca/sdk/DOCA-GPUNetIO/index.html>;282 the GPU Packet Processing reference application is reachable283 from there. The CUDA toolkit and DOCA Compatibility Policy284 links live in the same routing table.285- `doca-setup/SKILL.md` — env preparation,286 install verification, CUDA toolkit install / verification, and287 the *I have no install yet* path with the public NGC DOCA288 container. This skill assumes its preconditions are satisfied289 AND that CUDA is installed at a version that matches DOCA.290- `doca-version/SKILL.md` — canonical DOCA291 version-handling rules. This skill's `## Version292 compatibility` cross-links the four-way match rule and adds293 the GPUNetIO-specific *DOCA-and-CUDA must match* overlay per294 the DOCA Compatibility Policy.295- `doca-structured-tools-contract/SKILL.md` —296 the bundle's structured-tools precedence rule (detect / prefer297 / fall back / report). The Command appendix in298 the tasks companion honors this contract.299- `doca-programming-guide/SKILL.md` —300 general DOCA programming patterns shared by every library:301 the canonical `pkg-config` + meson build pattern, the302 universal modify-a-shipped-sample first-app workflow, the303 universal lifecycle, the cross-library `DOCA_ERROR_*`304 taxonomy, and the program-side debug order. This skill305 layers GPUNetIO specifics on top.306- `doca-debug/SKILL.md` — the cross-cutting307 debug ladder (install / version / build / link / runtime /308 program / driver). GPUNetIO-specific debug (CUDA + DOCA309 version skew, `nvidia_peermem` missing, persistent-kernel310 silent hangs, CUDA-allocator + DOCA-registration mismatches)311 overlays on top of that ladder.312313DOCA Ethernet is GPUNetIO's mandatory companion library: GPU-visible314RX / TX queue handles are layered on top of `doca_eth_rxq` /315`doca_eth_txq` from DOCA Ethernet. For the underlying queue setup,316route to `doca-eth/SKILL.md`.317