DOCA PCC
Examples
- "Loading my own congestion control onto a BF port." — this
is in scope. Stay on host-side
doca_pcc + a DPACC-built
doca_pcc_app; do not rewrite the algorithm body here.
- "DOCA_ERROR_NOT_PERMITTED on algorithm load." — check the
firmware custom-PCC slot and DPA exposure before changing the
load call.
Instructions
Follow Loading order below. Open the tasks companion for configure /
load / debug. Open the capabilities companion for the triple-axis
cap query. Do not open every companion file.
Where to start: This skill assumes DOCA is already installed,
the user's BlueField has a DPA processor that the host can see
through DOCA, the BlueField firmware has the custom-PCC slot
enabled, and the user is doing hands-on custom PCC work from
the host side — i.e. using doca-pcc to load a DPA-side
congestion control algorithm onto the BlueField, attach it to a
port handling RDMA / RoCE traffic, and parameterize it from the
host. 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 the host-side PCC API express on this version + this
BlueField generation + this firmware. If the user has not
installed DOCA yet, route to
doca-setup/SKILL.md first; if the user is
asking how to write the DPA-side congestion-control algorithm
itself (the code that runs on the DPA processor, compiled by
dpacc), that is a different scope — route via
doca-public-knowledge-map/SKILL.md
to the public DOCA PCC programming guide and to
doca-dpa/SKILL.md for the host-side DPA
lifecycle this skill builds on. If the user only wants to
inspect PCC counters at runtime without writing a custom
algorithm, that is the pcc_counters CLI tool — route via
doca-public-knowledge-map ## DOCA tools (doca-public-knowledge-map/SKILL.md#doca-tools);
this skill is for custom algorithms only.
Example questions this skill answers well
The CLASSES of PCC 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.
Audience
This skill serves external developers consuming the DOCA PCC
library from the host side — code that calls doca_pcc_* to
stand up the per-port context, load the dpacc-produced
doca_pcc_app image, attach it to the RoCE-bearing BlueField
port, parameterize it, start it, and observe runtime reports.
It is not for NVIDIA developers contributing to DOCA PCC, nor
the place to learn how to write the DPA-side algorithm body
(route via doca-public-knowledge-map/SKILL.md to the public
PCC / DPA / DPACC guides).
Language scope. DOCA PCC ships as a host-side C library
(pkg-config module doca-pcc). The DPA-side algorithm is a
separate translation unit dpacc compiles into the PCC
algorithm image — no FFI escape hatch. A Rust / Go / Python
host-side wrapper driving doca_pcc_* is still useful; the
skill keeps its guidance language-neutral.
When to load this skill
Load this skill when the user is doing hands-on DOCA PCC work
from the host side for a custom congestion control
algorithm. Concretely:
- Initializing a
doca_pcc against a doca_dev that maps to
the BlueField port carrying the RDMA / RoCE traffic to be
controlled.
- Loading the
dpacc-produced doca_pcc_app algorithm image
into the doca_pcc context.
- Parameterizing the algorithm and starting the
doca_pcc Core
context so it begins affecting RoCE traffic on the port.
- Checking which PCC features the active
doca_devinfo supports
via doca_pcc_cap_* — BlueField generations and firmware
revisions differ on permitting a custom PCC algorithm.
- Debugging a
DOCA_ERROR_* from doca_pcc_* — disambiguating
firmware custom-PCC slot disabled vs device cannot do
custom PCC vs image incompatible vs plain doca_dev
access denied.
- Designing non-C host-side bindings that drive a separately
dpacc-built algorithm image — the env-precondition and
capability rules still apply.
Do not load this skill for general DOCA orientation, DOCA /
DPACC install, the DPA-side programming model itself, the
factory PCC algorithm shipped in ConnectX firmware (firmware-
only, no host-side code), or the pcc_counters diagnostic CLI.
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
PCC-specific material lives in two companion files:
- the capabilities companion — what the host-side PCC API can express on
this version + this BlueField generation + this firmware: the
per-PCC-instance
doca_pcc context, the loaded doca_pcc_app
algorithm image produced by dpacc, the attach-to-port
semantics that bind the algorithm to the RDMA / RoCE traffic
it will control, the capability-query surface
(doca_pcc_cap_*), the PCC error taxonomy mapped onto the
cross-library DOCA_ERROR_* set, the observability surface
(host-side reports plus the public PCC counter tool reachable
via doca-public-knowledge-map), and the safety policy that
gates env preconditions (DPA-capable BlueField, firmware-level
custom-PCC slot enabled, matched DOCA + DPACC versions,
algorithm image and host-side expectations agree).
- the tasks companion — step-by-step workflows for the six in-scope PCC
verbs:
configure, build, modify, run, test,
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, a BlueField with a DPA processor is
physically present and visible to the host, the BlueField
firmware has the custom-PCC slot enabled, the DPACC compiler
is installed at a version matched to the DOCA install per the
DOCA Compatibility Policy, and the user already knows how
(at least at a sketch level) to write the DPA-side PCC
algorithm that dpacc will compile. It does not cover
installing DOCA, installing the DPACC compiler, or flipping
firmware-level configuration — those paths go 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 PCC application source code or DPA-side
algorithm source, in any language. The verified PCC source
is the shipped C + DPA-side samples at
/opt/mellanox/doca/samples/doca_pcc/. 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 PCC-specific overrides inmodify.
- A specific congestion control algorithm. This library
loads an algorithm the user supplies; it does not define
one. The agent must refuse to invent algorithm bodies and
must route any "what algorithm should I write" question to
the public DOCA PCC programming guide and the user's own
domain expertise — that is a research question, not an API
question.
- 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 + DPACC
compiler, where pkg-config --modversion doca-pcc and the
installed dpacc are the two sources of truth.
- 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.
pcc_counters tool surface. That CLI is a separate
artifact (the pcc_counters.sh script installed at
/opt/mellanox/doca/tools/pcc_counters.sh) with its own page; routing lives in
doca-public-knowledge-map ## DOCA tools (doca-public-knowledge-map/SKILL.md#doca-tools).
Conflating it with the library is the most common PCC
first-app design error.
Loading order
- Read this skill first to confirm the user's question is
in scope (host-side custom PCC work, not DPA-side algorithm
design and not the counter tool).
- For the PCC capability matrix, the two-side-program model,
the
doca_pcc per-instance context, the loaded doca_pcc_app
algorithm image, the attach-to-port semantics, the
triple-axis precondition rule, 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 PCC overlay that DOCA
must match the DPACC compiler), and
doca-public-knowledge-map/SKILL.md
whenever the right answer is "look it up in the public DOCA
PCC programming guide, the public DPA / DPACC guides, the
pcc_counters tool guide, or in the on-disk install
layout" rather than "PCC host-side-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 PCC public guide is at
https://docs.nvidia.com/doca/sdk/DOCA-PCC/index.html; the
pcc_counters diagnostic CLI lives under the DOCA Tools
umbrella as a companion surface rather than a redefined
artifact here.
doca-dpa/SKILL.md — the host-side DPA
control library that PCC depends on conceptually: the
custom PCC algorithm is DPA-side code, compiled by the
DPACC compiler, and the host-side doca-pcc Core lifecycle
follows the same shape as the doca-dpa Core lifecycle. The
agent loads doca-dpa alongside this skill when the user
has DPA-level questions (kernel-launch model, DPA-side
libraries) that PCC is layered on top of.
doca-rdma/SKILL.md — the library whose
traffic the custom PCC algorithm is controlling. The custom
PCC algorithm affects RDMA / RoCE flows on the attached
BlueField port; if the user has not yet set up RDMA / RoCE
traffic on that port, there is nothing for the algorithm to
act on, and doca-rdma is the skill that brings that
traffic up.
doca-setup/SKILL.md — env preparation,
install verification, DPACC compiler install / verification,
BlueField firmware configuration (including the custom-PCC
slot enable), and the I have no install yet path with the
public NGC DOCA container. This skill assumes its
preconditions are satisfied AND that DPACC is installed at a
version that matches DOCA AND that the firmware-level
custom-PCC slot is enabled.
doca-version/SKILL.md — canonical
DOCA version-handling rules. This skill's ## Version compatibility cross-links the four-way match rule and adds
the PCC-specific DOCA-and-DPACC must match overlay per the
DOCA Compatibility Policy (inherited from
doca-dpa/SKILL.md).
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 Core-context lifecycle, the cross-library
DOCA_ERROR_* taxonomy, and the program-side debug order.
This skill layers PCC specifics on top.
doca-debug/SKILL.md — the cross-cutting
debug ladder (install / version / build / link / runtime /
program / driver). PCC-specific debug (custom-PCC slot not
enabled in firmware, DPACC + DOCA version skew, algorithm
image rejected as incompatible with the device, a loaded
algorithm producing no on-wire change because
doca_pcc_start() was never called or the attached port
carries no RoCE traffic) overlays on top of that ladder.
"It loads but nothing changes on the wire" is a host-side
question. A successful load is not a live algorithm:
doca_pcc_start() is the moment it goes live on the port, and
PCC only modulates RoCE traffic that already exists on the
doca_dev the doca_pcc was created against. Settle both here
and do not audit the DPA-side algorithm body: that is
doca-dpa/SKILL.md's surface, and reports
firing already proves the body runs — what is unproven is that
it is bound and live. Ordered checks in
debug.
1---2license: Apache-2.03name: doca-pcc4description: >5 Use this skill when the user is doing hands-on host-side DOCA PCC work6 to load a CUSTOM Programmable Congestion Control algorithm onto a7 BlueField DPU — creating per-port `doca_pcc` contexts, loading a8 `dpacc`-compiled `doca_pcc_app` onto the `doca_dev` for the9 RoCE-bearing port, parameterizing it, walking triple-axis capability10 discovery (DOCA cap-query + DPA-capable BlueField + firmware11 custom-PCC slot enabled), or debugging `DOCA_ERROR_*` from12 `doca_pcc_*`. Trigger even without explicit "DOCA PCC" phrasing —13 implicit forms include "loading my own congestion control onto a BF14 port", "DOCA_ERROR_NOT_PERMITTED on algorithm load",15 "DOCA_ERROR_DRIVER when I attach my custom algorithm", "my custom16 rate-update isn't affecting RoCE traffic", or "load succeeds but no17 on-wire change". Refuse and route elsewhere for DPA-side18 algorithm-body design, the `pcc_counters` CLI, default factory PCC in19 ConnectX firmware, or setting up the RDMA / RoCE traffic — those20 belong to other skills.21metadata:22 source: https://skillmd.com/skills/nvidia/doca-pcc23 author: NVIDIA <doca-feedback@nvidia.com>24 kind: library25 doca_version: "3.5"26 tags:27 - doca28 - pcc29 - congestion30compatibility: >31 Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu32 22.04/24.04 or RHEL/SLES) with a BlueField DPU whose DPA processor is33 exposed to the host AND whose firmware has the custom-PCC slot34 enabled. Also requires the DPACC compiler installed at a version35 matched to DOCA per the DOCA Compatibility Policy. Reads the user's36 local install via `pkg-config doca-pcc` and inspects37 /opt/mellanox/doca/{lib,include,samples,applications}. The validation38 steps require a live DOCA install.39---4041# DOCA PCC4243## Examples4445- **"Loading my own congestion control onto a BF port."** — this46 is in scope. Stay on host-side `doca_pcc` + a DPACC-built47 `doca_pcc_app`; do not rewrite the algorithm body here.48- **"DOCA_ERROR_NOT_PERMITTED on algorithm load."** — check the49 firmware custom-PCC slot and DPA exposure before changing the50 load call.5152## Instructions5354Follow Loading order below. Open the tasks companion for configure /55load / debug. Open the capabilities companion for the triple-axis56cap query. Do not open every companion file.5758**Where to start:** This skill assumes DOCA is already installed,59the user's BlueField has a DPA processor that the host can see60through DOCA, the BlueField firmware has the custom-PCC slot61enabled, and the user is doing **hands-on custom PCC work from62the host side** — i.e. using `doca-pcc` to load a DPA-side63congestion control algorithm onto the BlueField, attach it to a64port handling RDMA / RoCE traffic, and parameterize it from the65host. Open the tasks companion if the user wants to *do*66something (configure / build / modify / run / test / debug);67open the capabilities companion when the question is68*what can the host-side PCC API express* on this version + this69BlueField generation + this firmware. If the user has not70installed DOCA yet, route to71`doca-setup/SKILL.md` first; if the user is72asking how to *write* the DPA-side congestion-control algorithm73itself (the code that runs on the DPA processor, compiled by74`dpacc`), that is a different scope — route via75`doca-public-knowledge-map/SKILL.md`76to the public DOCA PCC programming guide and to77`doca-dpa/SKILL.md` for the host-side DPA78lifecycle this skill builds on. If the user only wants to79*inspect* PCC counters at runtime without writing a custom80algorithm, that is the `pcc_counters` CLI tool — route via81`doca-public-knowledge-map ## DOCA tools` (`doca-public-knowledge-map/SKILL.md#doca-tools`);82this skill is for *custom* algorithms only.8384## Example questions this skill answers well8586The CLASSES of PCC questions this skill is built to answer,87each with one worked example. The agent should treat the *class*88as the load-bearing piece — the worked example is a single89instance.9091- **"How do I deploy my own custom congestion control algorithm92 onto a BlueField port carrying RDMA / RoCE traffic?"** —93 worked example: *"load a small DPA-side PCC algorithm and94 attach it to the BlueField port that handles my RoCE traffic"*.95 Answered by the two-side-program model + the host-side96 load-and-attach workflow in97 ## Capabilities and modes98 + the bring-up steps in99 ## configure.100- **"Does this BlueField + firmware actually allow a custom PCC101 algorithm, and which PCC features does my DOCA install102 expose?"** — worked example: *"my host has a BlueField and the103 default factory PCC works; can I drop in a custom algorithm104 instead?"*. Answered by the triple-axis precondition rule105 (BlueField generation must carry a DPA, firmware must have the106 custom-PCC slot enabled, `doca_pcc_cap_*` against the active107 `doca_devinfo` must agree) in108 ## Capabilities and modes109 + the env-precondition checklist in110 ## configure step 1.111- **"Why does my custom PCC fail with `DOCA_ERROR_NOT_PERMITTED`112 even though I have `doca_dev` access?"** — worked example:113 *"the BlueField firmware in this host has the custom-PCC slot114 disabled"*. Answered by the permission matrix in115 ## Safety policy116 + the firmware-side env fix in117 ## configure step 1.118- **"Is this `doca-pcc` library the right tool for what I want,119 or do I want the default firmware PCC or the120 `pcc_counters` CLI?"** — worked example: *"I just want to121 read PCC counters without touching the algorithm"*. Answered122 by the path-selection rule in123 ## Capabilities and modes124 + the deferred-topic boundaries in125 ## Deferred topic boundaries126 which route to127 `doca-public-knowledge-map ## DOCA tools` (`doca-public-knowledge-map/SKILL.md#doca-tools`)128 for the counter tool.129- **"Is the host-side PCC API I'm reading about on my installed130 DOCA?"** — worked example: *"is the host-side load helper I131 see in the docs available against the DOCA + DPACC versions on132 this host?"*. Answered by the version-compatibility overlay in133 ## Version compatibility134 which cross-links the canonical detection chain in135 `doca-version/SKILL.md` and adds the136 PCC-specific *DOCA must match DPACC* overlay inherited from137 `doca-dpa/SKILL.md`.138- **"What does this `DOCA_ERROR_*` from a `doca_pcc_*` call mean139 and which layer caused it?"** — worked example:140 *"`DOCA_ERROR_DRIVER` on the host-side algorithm-load call —141 is it DOCA, the firmware-side custom-PCC slot, or the DPACC-142 produced image?"*. Answered by the PCC overlay on the143 cross-library taxonomy in144 ## Error taxonomy145 + the layered ladder in146 ## debug that escalates to147 `doca-debug/SKILL.md`.148149## Audience150151This skill serves **external developers consuming the DOCA PCC152library from the host side** — code that calls `doca_pcc_*` to153stand up the per-port context, load the `dpacc`-produced154`doca_pcc_app` image, attach it to the RoCE-bearing BlueField155port, parameterize it, start it, and observe runtime reports.156It is *not* for NVIDIA developers contributing to DOCA PCC, nor157the place to learn how to *write* the DPA-side algorithm body158(route via `doca-public-knowledge-map/SKILL.md` to the public159PCC / DPA / DPACC guides).160161**Language scope.** DOCA PCC ships as a host-side C library162(`pkg-config` module `doca-pcc`). The DPA-side algorithm is a163separate translation unit `dpacc` compiles into the PCC164algorithm image — no FFI escape hatch. A Rust / Go / Python165host-side wrapper driving `doca_pcc_*` is still useful; the166skill keeps its guidance language-neutral.167168## When to load this skill169170Load this skill when the user is doing hands-on DOCA PCC work171**from the host side** for a **custom** congestion control172algorithm. Concretely:173174- Initializing a `doca_pcc` against a `doca_dev` that maps to175 the BlueField port carrying the RDMA / RoCE traffic to be176 controlled.177- Loading the `dpacc`-produced `doca_pcc_app` algorithm image178 into the `doca_pcc` context.179- Parameterizing the algorithm and starting the `doca_pcc` Core180 context so it begins affecting RoCE traffic on the port.181- Checking which PCC features the active `doca_devinfo` supports182 via `doca_pcc_cap_*` — BlueField generations and firmware183 revisions differ on permitting a custom PCC algorithm.184- Debugging a `DOCA_ERROR_*` from `doca_pcc_*` — disambiguating185 *firmware custom-PCC slot disabled* vs *device cannot do186 custom PCC* vs *image incompatible* vs *plain `doca_dev`187 access denied*.188- Designing non-C host-side bindings that drive a separately189 `dpacc`-built algorithm image — the env-precondition and190 capability rules still apply.191192Do **not** load this skill for general DOCA orientation, DOCA /193DPACC install, the DPA-side programming model itself, the194factory PCC algorithm shipped in ConnectX firmware (firmware-195only, no host-side code), or the `pcc_counters` diagnostic CLI.196For those, route through197`doca-public-knowledge-map/SKILL.md`198to the matching upstream guide.199200## What this skill provides201202This is a **thin loader**. The body keeps only the orientation203needed to pick the right next file. The substantive204PCC-specific material lives in two companion files:205206- the capabilities companion — what the host-side PCC API can express on207 this version + this BlueField generation + this firmware: the208 per-PCC-instance `doca_pcc` context, the loaded `doca_pcc_app`209 algorithm image produced by `dpacc`, the attach-to-port210 semantics that bind the algorithm to the RDMA / RoCE traffic211 it will control, the capability-query surface212 (`doca_pcc_cap_*`), the PCC error taxonomy mapped onto the213 cross-library `DOCA_ERROR_*` set, the observability surface214 (host-side reports plus the public PCC counter tool reachable215 via `doca-public-knowledge-map`), and the safety policy that216 gates env preconditions (DPA-capable BlueField, firmware-level217 custom-PCC slot enabled, matched DOCA + DPACC versions,218 algorithm image and host-side expectations agree).219- the tasks companion — step-by-step workflows for the six in-scope PCC220 verbs: `configure`, `build`, `modify`, `run`, `test`,221 `debug`. Plus a `Deferred task verbs` block that points222 out-of-scope questions at the right next skill.223224The skill assumes a host where DOCA is already installed at225the standard location, a BlueField with a DPA processor is226physically present and visible to the host, the BlueField227firmware has the custom-PCC slot enabled, the DPACC compiler228is installed at a version matched to the DOCA install per the229DOCA Compatibility Policy, and the user already knows how230(at least at a sketch level) to write the DPA-side PCC231algorithm that `dpacc` will compile. It does not cover232installing DOCA, installing the DPACC compiler, or flipping233firmware-level configuration — those paths go through234`doca-setup/SKILL.md`.235236## What this skill deliberately does not ship237238This skill is **agent guidance**, not a samples or templates239bundle. To keep the boundary clean, it deliberately does not240contain — and pull requests should not add:241242- **Pre-written DOCA PCC application source code or DPA-side243 algorithm source, in any language.** The verified PCC source244 is the shipped C + DPA-side samples at245 `/opt/mellanox/doca/samples/doca_pcc/`. The agent's job is to246 route the user to those files and prescribe a minimum-diff247 modification on them via the universal modify-a-sample248 workflow in249 `doca-programming-guide/SKILL.md`,250 layered with the PCC-specific overrides in251 ## modify.252- **A specific congestion control algorithm.** This library253 *loads* an algorithm the user supplies; it does *not* define254 one. The agent must refuse to invent algorithm bodies and255 must route any *"what algorithm should I write"* question to256 the public DOCA PCC programming guide and the user's own257 domain expertise — that is a research question, not an API258 question.259- **Standalone build manifests** (`meson.build`,260 `CMakeLists.txt`, …) parked inside the skill. The agent261 constructs the build manifest *in the user's project262 directory* against the user's installed DOCA + DPACC263 compiler, where `pkg-config --modversion doca-pcc` and the264 installed `dpacc` are the two sources of truth.265- **A `samples/`, `bindings/`, or `reference/` subtree** of any266 kind. A mock or incomplete artifact in this skill's tree,267 even one labeled "reference", is misleading: users will read268 it as buildable.269- **`pcc_counters` tool surface.** That CLI is a *separate270 artifact* (the `pcc_counters.sh` script installed at271 `/opt/mellanox/doca/tools/pcc_counters.sh`) with its own page; routing lives in272 `doca-public-knowledge-map ## DOCA tools` (`doca-public-knowledge-map/SKILL.md#doca-tools`).273 Conflating it with the library is the most common PCC274 first-app design error.275276## Loading order2772781. Read this skill first to confirm the user's question is279 in scope (host-side custom PCC work, not DPA-side algorithm280 design and not the counter tool).2812. **For the PCC capability matrix, the two-side-program model,282 the `doca_pcc` per-instance context, the loaded `doca_pcc_app`283 algorithm image, the attach-to-port semantics, the284 triple-axis precondition rule, the env-precondition policy,285 the error taxonomy, the observability surface, and the286 safety policy, see the capabilities companion.**2873. **For step-by-step workflows — configure, build, modify,288 run, test, debug — see the tasks companion.**289290Both companion files cross-link to each other,291`doca-version/SKILL.md` for the canonical292DOCA version-handling rules (with the PCC overlay that DOCA293must match the DPACC compiler), and294`doca-public-knowledge-map/SKILL.md`295whenever the right answer is "look it up in the public DOCA296PCC programming guide, the public DPA / DPACC guides, the297`pcc_counters` tool guide, or in the on-disk install298layout" rather than "PCC host-side-specific guidance".299300## Related skills301302- `doca-public-knowledge-map/SKILL.md` —303 the routing table for every public DOCA documentation304 source and the on-disk layout of an installed DOCA package.305 The PCC public guide is at306 <https://docs.nvidia.com/doca/sdk/DOCA-PCC/index.html>; the307 `pcc_counters` diagnostic CLI lives under the DOCA Tools308 umbrella as a *companion surface* rather than a redefined309 artifact here.310- `doca-dpa/SKILL.md` — the host-side DPA311 control library that PCC depends on conceptually: the312 custom PCC algorithm *is* DPA-side code, compiled by the313 DPACC compiler, and the host-side `doca-pcc` Core lifecycle314 follows the same shape as the `doca-dpa` Core lifecycle. The315 agent loads `doca-dpa` alongside this skill when the user316 has DPA-level questions (kernel-launch model, DPA-side317 libraries) that PCC is layered on top of.318- `doca-rdma/SKILL.md` — the library whose319 traffic the custom PCC algorithm is controlling. The custom320 PCC algorithm affects RDMA / RoCE flows on the attached321 BlueField port; if the user has not yet set up RDMA / RoCE322 traffic on that port, there is nothing for the algorithm to323 act on, and `doca-rdma` is the skill that brings that324 traffic up.325- `doca-setup/SKILL.md` — env preparation,326 install verification, DPACC compiler install / verification,327 BlueField firmware configuration (including the custom-PCC328 slot enable), and the *I have no install yet* path with the329 public NGC DOCA container. This skill assumes its330 preconditions are satisfied AND that DPACC is installed at a331 version that matches DOCA AND that the firmware-level332 custom-PCC slot is enabled.333- `doca-version/SKILL.md` — canonical334 DOCA version-handling rules. This skill's `## Version335 compatibility` cross-links the four-way match rule and adds336 the PCC-specific *DOCA-and-DPACC must match* overlay per the337 DOCA Compatibility Policy (inherited from338 `doca-dpa/SKILL.md`).339- `doca-structured-tools-contract/SKILL.md` —340 the bundle's structured-tools precedence rule (detect /341 prefer / fall back / report). The Command appendix in342 the tasks companion honors this contract.343- `doca-programming-guide/SKILL.md` —344 general DOCA programming patterns shared by every library:345 the canonical `pkg-config` + meson build pattern, the346 universal modify-a-shipped-sample first-app workflow, the347 universal Core-context lifecycle, the cross-library348 `DOCA_ERROR_*` taxonomy, and the program-side debug order.349 This skill layers PCC specifics on top.350- `doca-debug/SKILL.md` — the cross-cutting351 debug ladder (install / version / build / link / runtime /352 program / driver). PCC-specific debug (custom-PCC slot not353 enabled in firmware, DPACC + DOCA version skew, algorithm354 image rejected as incompatible with the device, a loaded355 algorithm producing no on-wire change because356 `doca_pcc_start()` was never called or the attached port357 carries no RoCE traffic) overlays on top of that ladder.358359> **"It loads but nothing changes on the wire" is a host-side360> question.** A successful load is not a live algorithm:361> `doca_pcc_start()` is the moment it goes live on the port, and362> PCC only modulates RoCE traffic that already exists on the363> `doca_dev` the `doca_pcc` was created against. Settle both here364> and do not audit the DPA-side algorithm body: that is365> `doca-dpa/SKILL.md`'s surface, and reports366> firing already proves the body runs — what is unproven is that367> it is bound and live. Ordered checks in368> ## debug.