[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-nvidia-doca-pcc":3,"mdc-lb3979-key":34,"related-org-nvidia-doca-pcc":1676,"related-repo-nvidia-doca-pcc":1837},{"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-pcc","configure BlueField congestion control algorithms","Use this skill when the user is doing hands-on host-side DOCA PCC work to load a CUSTOM Programmable Congestion Control algorithm onto a BlueField DPU — creating per-port `doca_pcc` contexts, loading a `dpacc`-compiled `doca_pcc_app` onto the `doca_dev` for the RoCE-bearing port, parameterizing it, walking triple-axis capability discovery (DOCA cap-query + DPA-capable BlueField + firmware custom-PCC slot enabled), or debugging `DOCA_ERROR_*` from `doca_pcc_*`. Trigger even without explicit \"DOCA PCC\" phrasing — implicit forms include \"loading my own congestion control onto a BF port\", \"DOCA_ERROR_NOT_PERMITTED on algorithm load\", \"DOCA_ERROR_DRIVER when I attach my custom algorithm\", \"my custom rate-update isn't affecting RoCE traffic\", or \"load succeeds but no on-wire change\". Refuse and route elsewhere for DPA-side algorithm-body design, the `pcc_counters` CLI, default factory PCC in ConnectX firmware, or setting up the RDMA \u002F RoCE traffic — those belong to other skills.\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},"Networking","networking",{"name":9,"slug":8,"type":15},{"name":21,"slug":22,"type":15},"Engineering","engineering",2473,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills","2026-07-20T06:23:57.574475","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-pcc","---\nlicense: Apache-2.0\nname: doca-pcc\ndescription: >\n  Use this skill when the user is doing hands-on host-side DOCA\n  PCC work to load a CUSTOM Programmable Congestion Control\n  algorithm onto a BlueField DPU — creating per-port `doca_pcc`\n  contexts, loading a `dpacc`-compiled `doca_pcc_app` onto the\n  `doca_dev` for the RoCE-bearing port, parameterizing it,\n  walking triple-axis capability discovery (DOCA cap-query +\n  DPA-capable BlueField + firmware custom-PCC slot enabled), or\n  debugging `DOCA_ERROR_*` from `doca_pcc_*`. Trigger even\n  without explicit \"DOCA PCC\" phrasing — implicit forms include\n  \"loading my own congestion control onto a BF port\",\n  \"DOCA_ERROR_NOT_PERMITTED on algorithm load\",\n  \"DOCA_ERROR_DRIVER when I attach my custom algorithm\", \"my\n  custom rate-update isn't affecting RoCE traffic\", or \"load\n  succeeds but no on-wire change\". Refuse and route elsewhere\n  for DPA-side algorithm-body design, the `pcc_counters`\n  CLI, default factory PCC in ConnectX firmware, or setting up\n  the RDMA \u002F RoCE traffic — those belong to other skills.\nmetadata:\n  kind: library\ncompatibility: >\n  Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux\n  (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with a BlueField DPU whose\n  DPA processor is exposed to the host AND whose firmware has\n  the custom-PCC slot enabled. Also requires the DPACC compiler\n  installed at a version matched to DOCA per the DOCA\n  Compatibility Policy. Reads the user's local install via\n  `pkg-config doca-pcc` and inspects\n  \u002Fopt\u002Fmellanox\u002Fdoca\u002F{lib,include,samples,applications}.\n---\n\n# DOCA PCC\n\n**Where to start:** This skill assumes DOCA is already installed,\nthe user's BlueField has a DPA processor that the host can see\nthrough DOCA, the BlueField firmware has the custom-PCC slot\nenabled, and the user is doing **hands-on custom PCC work from\nthe host side** — i.e. using `doca-pcc` to load a DPA-side\ncongestion control algorithm onto the BlueField, attach it to a\nport handling RDMA \u002F RoCE traffic, and parameterize it from the\nhost. Open [`TASKS.md`](TASKS.md) if the user wants to *do*\nsomething (configure \u002F build \u002F modify \u002F run \u002F test \u002F debug);\nopen [`CAPABILITIES.md`](CAPABILITIES.md) when the question is\n*what can the host-side PCC API express* on this version + this\nBlueField generation + this firmware. If the user has not\ninstalled DOCA yet, route to\n[`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) first; if the user is\nasking how to *write* the DPA-side congestion-control algorithm\nitself (the code that runs on the DPA processor, compiled by\n`dpacc`), that is a different scope — route via\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)\nto the public DOCA PCC programming guide and to\n[`doca-dpa`](..\u002Fdoca-dpa\u002FSKILL.md) for the host-side DPA\nlifecycle this skill builds on. If the user only wants to\n*inspect* PCC counters at runtime without writing a custom\nalgorithm, that is the `pcc_counters` CLI tool — route via\n[`doca-public-knowledge-map ## DOCA tools`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md#doca-tools);\nthis skill is for *custom* algorithms only.\n\n## Example questions this skill answers well\n\nThe CLASSES of PCC questions this skill is built to answer,\neach with one worked example. The agent should treat the *class*\nas the load-bearing piece — the worked example is a single\ninstance.\n\n- **\"How do I deploy my own custom congestion control algorithm\n  onto a BlueField port carrying RDMA \u002F RoCE traffic?\"** —\n  worked example: *\"load a small DPA-side PCC algorithm and\n  attach it to the BlueField port that handles my RoCE traffic\"*.\n  Answered by the two-side-program model + the host-side\n  load-and-attach workflow in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the bring-up steps in\n  [`TASKS.md ## configure`](TASKS.md#configure).\n- **\"Does this BlueField + firmware actually allow a custom PCC\n  algorithm, and which PCC features does my DOCA install\n  expose?\"** — worked example: *\"my host has a BlueField and the\n  default factory PCC works; can I drop in a custom algorithm\n  instead?\"*. Answered by the triple-axis precondition rule\n  (BlueField generation must carry a DPA, firmware must have the\n  custom-PCC slot enabled, `doca_pcc_cap_*` against the active\n  `doca_devinfo` must agree) in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the env-precondition checklist in\n  [`TASKS.md ## configure`](TASKS.md#configure) step 1.\n- **\"Why does my custom PCC fail with `DOCA_ERROR_NOT_PERMITTED`\n  even though I have `doca_dev` access?\"** — worked example:\n  *\"the BlueField firmware in this host has the custom-PCC slot\n  disabled\"*. Answered by the permission matrix in\n  [`CAPABILITIES.md ## Safety policy`](CAPABILITIES.md#safety-policy)\n  + the firmware-side env fix in\n  [`TASKS.md ## configure`](TASKS.md#configure) step 1.\n- **\"Is this `doca-pcc` library the right tool for what I want,\n  or do I want the default firmware PCC or the\n  `pcc_counters` CLI?\"** — worked example: *\"I just want to\n  read PCC counters without touching the algorithm\"*. Answered\n  by the path-selection rule in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the deferred-topic boundaries in\n  [`CAPABILITIES.md ## Deferred topic boundaries`](CAPABILITIES.md#deferred-topic-boundaries)\n  which route to\n  [`doca-public-knowledge-map ## DOCA tools`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md#doca-tools)\n  for the counter tool.\n- **\"Is the host-side PCC API I'm reading about on my installed\n  DOCA?\"** — worked example: *\"is the host-side load helper I\n  see in the docs available against the DOCA + DPACC versions on\n  this host?\"*. Answered by the version-compatibility overlay in\n  [`CAPABILITIES.md ## Version compatibility`](CAPABILITIES.md#version-compatibility)\n  which cross-links the canonical detection chain in\n  [`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) and adds the\n  PCC-specific *DOCA must match DPACC* overlay inherited from\n  [`doca-dpa`](..\u002Fdoca-dpa\u002FSKILL.md).\n- **\"What does this `DOCA_ERROR_*` from a `doca_pcc_*` call mean\n  and which layer caused it?\"** — worked example:\n  *\"`DOCA_ERROR_DRIVER` on the host-side algorithm-load call —\n  is it DOCA, the firmware-side custom-PCC slot, or the DPACC-\n  produced image?\"*. Answered by the PCC overlay on the\n  cross-library taxonomy in\n  [`CAPABILITIES.md ## Error taxonomy`](CAPABILITIES.md#error-taxonomy)\n  + the layered ladder in\n  [`TASKS.md ## debug`](TASKS.md#debug) that escalates to\n  [`doca-debug`](..\u002F..\u002Fdoca-debug\u002FSKILL.md).\n\n## Audience\n\nThis skill serves **external developers building applications\nthat consume the DOCA PCC library from the host side** — i.e.,\nusers whose code calls `doca_pcc_*` from host C \u002F C++ to stand\nup the per-PCC-instance context, load a DPA-side PCC algorithm\nimage that `dpacc` produced from their DPA-side source, attach\nit to the BlueField port that carries the RDMA \u002F RoCE traffic\nthe algorithm is meant to control, parameterize the algorithm,\nstart the context, and observe runtime reports back from the\nalgorithm. It is *not* for NVIDIA developers contributing to\nDOCA PCC itself, nor is it the place to learn how to *write*\nthe DPA-side congestion-control algorithm itself (that path\ngoes through the public DOCA PCC programming guide and the\ncompanion DOCA DPA \u002F DPACC guides via\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)).\n\n**Language scope.** DOCA PCC ships as a host-side C library\nwith `pkg-config` module name `doca-pcc`. The host-side API is\nC; the DPA-side congestion-control algorithm is a separate\ntranslation unit written in the language the DPACC compiler\naccepts and compiled by `dpacc` into a binary that the host\npackages into the executable as the PCC algorithm image. The\nshipped samples under `\u002Fopt\u002Fmellanox\u002Fdoca\u002Fsamples\u002Fdoca_pcc\u002F`\nare written in C plus DPA-side source (NVIDIA's choice).\nOther-language consumers are limited in practice — the\nDPA-side algorithm has no FFI escape hatch because it must be\na translation unit `dpacc` accepts — but a Rust \u002F Go \u002F Python\nhost-side wrapper that drives `doca_pcc_*` setup and loads a\nPCC algorithm image built separately is still useful, and the\nskill keeps the lifecycle, capability-discovery,\nenv-precondition, and error-taxonomy guidance language-neutral.\n\n## When to load this skill\n\nLoad this skill when the user is doing hands-on DOCA PCC work\n**from the host side** for a **custom** congestion control\nalgorithm, in any host language plus a DPA-side translation\nunit built by `dpacc`. Concretely:\n\n- Initializing a `doca_pcc` against a `doca_dev` that maps to\n  the BlueField port carrying the RDMA \u002F RoCE traffic to be\n  controlled.\n- Loading a PCC algorithm image (`doca_pcc_app`) that `dpacc`\n  produced from the user's DPA-side congestion-control algorithm\n  source, into the `doca_pcc` context.\n- Parameterizing the loaded algorithm with the host-side knobs\n  the algorithm exposes, and starting the `doca_pcc` Core\n  context so the algorithm begins affecting RDMA \u002F RoCE\n  traffic on the attached port.\n- Checking which PCC features are supported on the active\n  `doca_devinfo` via the `doca_pcc_cap_*` family — BlueField\n  generations and firmware revisions differ in whether they\n  permit a custom PCC algorithm.\n- Debugging a `DOCA_ERROR_*` returned from a `doca_pcc_*` call\n  — in particular disambiguating *firmware-level custom-PCC\n  slot disabled* from *device does not support custom PCC at\n  all* from *algorithm image incompatible with this device*\n  from *standard `doca_dev` access denied*.\n- Designing host-side bindings in a non-C language that drive\n  a custom PCC algorithm image they built separately with\n  `dpacc` — the env-precondition and capability-discovery rules\n  in this skill still apply.\n\nDo **not** load this skill for general DOCA orientation, install\nof DOCA or the DPACC compiler, the DPA-side programming model\nitself (how to write the congestion-control algorithm body that\nruns on the DPA), questions about the default factory PCC\nalgorithm shipped in ConnectX firmware (no host-side `doca-pcc`\ncode needed — that path is firmware-only configuration), or\nquestions about the `pcc_counters` diagnostic CLI (route via\n[`doca-public-knowledge-map ## DOCA tools`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md#doca-tools)).\nFor all of those, route through\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)\nto the matching upstream guide.\n\n## What this skill provides\n\nThis is a **thin loader**. The body keeps only the orientation\nneeded to pick the right next file. The substantive\nPCC-specific material lives in two companion files:\n\n- `CAPABILITIES.md` — what the host-side PCC API can express on\n  this version + this BlueField generation + this firmware: the\n  per-PCC-instance `doca_pcc` context, the loaded `doca_pcc_app`\n  algorithm image produced by `dpacc`, the attach-to-port\n  semantics that bind the algorithm to the RDMA \u002F RoCE traffic\n  it will control, the capability-query surface\n  (`doca_pcc_cap_*`), the PCC error taxonomy mapped onto the\n  cross-library `DOCA_ERROR_*` set, the observability surface\n  (host-side reports plus the public PCC counter tool reachable\n  via `doca-public-knowledge-map`), and the safety policy that\n  gates env preconditions (DPA-capable BlueField, firmware-level\n  custom-PCC slot enabled, matched DOCA + DPACC versions,\n  algorithm image and host-side expectations agree).\n- `TASKS.md` — step-by-step workflows for the six in-scope PCC\n  verbs: `configure`, `build`, `modify`, `run`, `test`,\n  `debug`. Plus a `Deferred task verbs` block that points\n  out-of-scope questions at the right next skill.\n\nThe skill assumes a host where DOCA is already installed at\nthe standard location, a BlueField with a DPA processor is\nphysically present and visible to the host, the BlueField\nfirmware has the custom-PCC slot enabled, the DPACC compiler\nis installed at a version matched to the DOCA install per the\nDOCA Compatibility Policy, and the user already knows how\n(at least at a sketch level) to write the DPA-side PCC\nalgorithm that `dpacc` will compile. It does not cover\ninstalling DOCA, installing the DPACC compiler, or flipping\nfirmware-level configuration — those paths go through\n[`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md).\n\n## What this skill deliberately does not ship\n\nThis skill is **agent guidance**, not a samples or templates\nbundle. To keep the boundary clean, it deliberately does not\ncontain — and pull requests should not add:\n\n- **Pre-written DOCA PCC application source code or DPA-side\n  algorithm source, in any language.** The verified PCC source\n  is the shipped C + DPA-side samples at\n  `\u002Fopt\u002Fmellanox\u002Fdoca\u002Fsamples\u002Fdoca_pcc\u002F`. The agent's job is to\n  route the user to those files and prescribe a minimum-diff\n  modification on them via the universal modify-a-sample\n  workflow in\n  [`doca-programming-guide`](..\u002F..\u002Fdoca-programming-guide\u002FSKILL.md),\n  layered with the PCC-specific overrides in\n  [`TASKS.md ## modify`](TASKS.md#modify).\n- **A specific congestion control algorithm.** This library\n  *loads* an algorithm the user supplies; it does *not* define\n  one. The agent must refuse to invent algorithm bodies and\n  must route any *\"what algorithm should I write\"* question to\n  the public DOCA PCC programming guide and the user's own\n  domain expertise — that is a research question, not an API\n  question.\n- **Standalone build manifests** (`meson.build`,\n  `CMakeLists.txt`, …) parked inside the skill. The agent\n  constructs the build manifest *in the user's project\n  directory* against the user's installed DOCA + DPACC\n  compiler, where `pkg-config --modversion doca-pcc` and the\n  installed `dpacc` are the two sources of truth.\n- **A `samples\u002F`, `bindings\u002F`, or `reference\u002F` subtree** of any\n  kind. A mock or incomplete artifact in this skill's tree,\n  even one labeled \"reference\", is misleading: users will read\n  it as buildable.\n- **`pcc_counters` tool surface.** That CLI is a *separate\n  artifact* (the real tool is the `pcc_counters.sh` script under\n  `tools\u002Fpcc_counters\u002F`) with its own public page; routing for it lives in\n  [`doca-public-knowledge-map ## DOCA tools`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md#doca-tools).\n  Conflating it with the `doca-pcc` library is the single most\n  common PCC first-app design error.\n\n## Loading order\n\n1. Read this `SKILL.md` first to confirm the user's question is\n   in scope (host-side custom PCC work, not DPA-side algorithm\n   design and not the counter tool).\n2. **For the PCC capability matrix, the two-side-program model,\n   the `doca_pcc` per-instance context, the loaded `doca_pcc_app`\n   algorithm image, the attach-to-port semantics, the\n   triple-axis precondition rule, the env-precondition policy,\n   the error taxonomy, the observability surface, and the\n   safety policy, see [CAPABILITIES.md](CAPABILITIES.md).**\n3. **For step-by-step workflows — configure, build, modify,\n   run, test, debug — see [TASKS.md](TASKS.md).**\n\nBoth companion files cross-link to each other,\n[`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) for the canonical\nDOCA version-handling rules (with the PCC overlay that DOCA\nmust match the DPACC compiler), and\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)\nwhenever the right answer is \"look it up in the public DOCA\nPCC programming guide, the public DPA \u002F DPACC guides, the\n`pcc_counters` tool guide, or in the on-disk install\nlayout\" rather than \"PCC host-side-specific guidance\".\n\n## Related skills\n\n- [`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md) —\n  the routing table for every public DOCA documentation\n  source and the on-disk layout of an installed DOCA package.\n  The PCC public guide is at\n  \u003Chttps:\u002F\u002Fdocs.nvidia.com\u002Fdoca\u002Fsdk\u002FDOCA-PCC\u002Findex.html>; the\n  `pcc_counters` diagnostic CLI lives under the DOCA Tools\n  umbrella as a *companion surface* rather than a redefined\n  artifact here.\n- [`doca-dpa`](..\u002Fdoca-dpa\u002FSKILL.md) — the host-side DPA\n  control library that PCC depends on conceptually: the\n  custom PCC algorithm *is* DPA-side code, compiled by the\n  DPACC compiler, and the host-side `doca-pcc` Core lifecycle\n  follows the same shape as the `doca-dpa` Core lifecycle. The\n  agent loads `doca-dpa` alongside this skill when the user\n  has DPA-level questions (kernel-launch model, DPA-side\n  libraries) that PCC is layered on top of.\n- [`doca-rdma`](..\u002Fdoca-rdma\u002FSKILL.md) — the library whose\n  traffic the custom PCC algorithm is controlling. The custom\n  PCC algorithm affects RDMA \u002F RoCE flows on the attached\n  BlueField port; if the user has not yet set up RDMA \u002F RoCE\n  traffic on that port, there is nothing for the algorithm to\n  act on, and `doca-rdma` is the skill that brings that\n  traffic up.\n- [`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) — env preparation,\n  install verification, DPACC compiler install \u002F verification,\n  BlueField firmware configuration (including the custom-PCC\n  slot enable), and the *I have no install yet* path with the\n  public NGC DOCA container. This skill assumes its\n  preconditions are satisfied AND that DPACC is installed at a\n  version that matches DOCA AND that the firmware-level\n  custom-PCC slot is enabled.\n- [`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) — canonical\n  DOCA version-handling rules. This skill's `## Version\n  compatibility` cross-links the four-way match rule and adds\n  the PCC-specific *DOCA-and-DPACC must match* overlay per the\n  DOCA Compatibility Policy (inherited from\n  [`doca-dpa`](..\u002Fdoca-dpa\u002FSKILL.md)).\n- [`doca-structured-tools-contract`](..\u002F..\u002Fdoca-structured-tools-contract\u002FSKILL.md) —\n  the bundle's structured-tools precedence rule (detect \u002F\n  prefer \u002F fall back \u002F report). The Command appendix in\n  [TASKS.md](TASKS.md) honors this contract.\n- [`doca-programming-guide`](..\u002F..\u002Fdoca-programming-guide\u002FSKILL.md) —\n  general DOCA programming patterns shared by every library:\n  the canonical `pkg-config` + meson build pattern, the\n  universal modify-a-shipped-sample first-app workflow, the\n  universal Core-context lifecycle, the cross-library\n  `DOCA_ERROR_*` taxonomy, and the program-side debug order.\n  This skill layers PCC specifics on top.\n- [`doca-debug`](..\u002F..\u002Fdoca-debug\u002FSKILL.md) — the cross-cutting\n  debug ladder (install \u002F version \u002F build \u002F link \u002F runtime \u002F\n  program \u002F driver). PCC-specific debug (custom-PCC slot not\n  enabled in firmware, DPACC + DOCA version skew, algorithm\n  image rejected as incompatible with the device, traffic on\n  the attached port not being affected because the algorithm\n  body has no effect path) overlays on top of that ladder.\n\nThe default factory PCC algorithms shipped inside ConnectX\nfirmware are **not in scope** for this skill — those work\nwithout `doca-pcc` and are configured through firmware-level\nknobs, not through any host-side library API. The\n`pcc_counters` diagnostic CLI is **also not in scope** —\nit is a separate artifact for *inspecting* runtime PCC\ncounters and lives under the public DOCA Tools umbrella.\nConflating either of those with the `doca-pcc` library is the\nsingle most common PCC first-app design error.\n\n",{"data":35,"body":39},{"license":26,"name":4,"description":6,"metadata":36,"compatibility":38},{"kind":37},"library","Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with a BlueField DPU whose DPA processor is exposed to the host AND whose firmware has the custom-PCC slot enabled. Also requires the DPACC compiler installed at a version matched to DOCA per the DOCA Compatibility Policy. Reads the user's local install via `pkg-config doca-pcc` and inspects \u002Fopt\u002Fmellanox\u002Fdoca\u002F{lib,include,samples,applications}.\n",{"type":40,"children":41},"root",[42,50,200,207,219,595,601,650,704,710,735,880,925,931,943,1061,1082,1088,1100,1308,1314,1371,1403,1409,1629],{"type":43,"tag":44,"props":45,"children":46},"element","h1",{"id":4},[47],{"type":48,"value":49},"text","DOCA PCC",{"type":43,"tag":51,"props":52,"children":53},"p",{},[54,60,62,67,69,75,77,87,89,95,97,106,108,113,115,125,127,132,134,140,142,152,154,164,166,171,173,179,181,191,193,198],{"type":43,"tag":55,"props":56,"children":57},"strong",{},[58],{"type":48,"value":59},"Where to start:",{"type":48,"value":61}," This skill assumes DOCA is already installed,\nthe user's BlueField has a DPA processor that the host can see\nthrough DOCA, the BlueField firmware has the custom-PCC slot\nenabled, and the user is doing ",{"type":43,"tag":55,"props":63,"children":64},{},[65],{"type":48,"value":66},"hands-on custom PCC work from\nthe host side",{"type":48,"value":68}," — i.e. using ",{"type":43,"tag":70,"props":71,"children":73},"code",{"className":72},[],[74],{"type":48,"value":4},{"type":48,"value":76}," to load a DPA-side\ncongestion control algorithm onto the BlueField, attach it to a\nport handling RDMA \u002F RoCE traffic, and parameterize it from the\nhost. Open ",{"type":43,"tag":78,"props":79,"children":81},"a",{"href":80},"TASKS.md",[82],{"type":43,"tag":70,"props":83,"children":85},{"className":84},[],[86],{"type":48,"value":80},{"type":48,"value":88}," if the user wants to ",{"type":43,"tag":90,"props":91,"children":92},"em",{},[93],{"type":48,"value":94},"do",{"type":48,"value":96},"\nsomething (configure \u002F build \u002F modify \u002F run \u002F test \u002F debug);\nopen ",{"type":43,"tag":78,"props":98,"children":100},{"href":99},"CAPABILITIES.md",[101],{"type":43,"tag":70,"props":102,"children":104},{"className":103},[],[105],{"type":48,"value":99},{"type":48,"value":107}," when the question is\n",{"type":43,"tag":90,"props":109,"children":110},{},[111],{"type":48,"value":112},"what can the host-side PCC API express",{"type":48,"value":114}," on this version + this\nBlueField generation + this firmware. If the user has not\ninstalled DOCA yet, route to\n",{"type":43,"tag":78,"props":116,"children":118},{"href":117},"..\u002F..\u002Fdoca-setup\u002FSKILL.md",[119],{"type":43,"tag":70,"props":120,"children":122},{"className":121},[],[123],{"type":48,"value":124},"doca-setup",{"type":48,"value":126}," first; if the user is\nasking how to ",{"type":43,"tag":90,"props":128,"children":129},{},[130],{"type":48,"value":131},"write",{"type":48,"value":133}," the DPA-side congestion-control algorithm\nitself (the code that runs on the DPA processor, compiled by\n",{"type":43,"tag":70,"props":135,"children":137},{"className":136},[],[138],{"type":48,"value":139},"dpacc",{"type":48,"value":141},"), that is a different scope — route via\n",{"type":43,"tag":78,"props":143,"children":145},{"href":144},"..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md",[146],{"type":43,"tag":70,"props":147,"children":149},{"className":148},[],[150],{"type":48,"value":151},"doca-public-knowledge-map",{"type":48,"value":153},"\nto the public DOCA PCC programming guide and to\n",{"type":43,"tag":78,"props":155,"children":157},{"href":156},"..\u002Fdoca-dpa\u002FSKILL.md",[158],{"type":43,"tag":70,"props":159,"children":161},{"className":160},[],[162],{"type":48,"value":163},"doca-dpa",{"type":48,"value":165}," for the host-side DPA\nlifecycle this skill builds on. If the user only wants to\n",{"type":43,"tag":90,"props":167,"children":168},{},[169],{"type":48,"value":170},"inspect",{"type":48,"value":172}," PCC counters at runtime without writing a custom\nalgorithm, that is the ",{"type":43,"tag":70,"props":174,"children":176},{"className":175},[],[177],{"type":48,"value":178},"pcc_counters",{"type":48,"value":180}," CLI tool — route via\n",{"type":43,"tag":78,"props":182,"children":184},{"href":183},"..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md#doca-tools",[185],{"type":43,"tag":70,"props":186,"children":188},{"className":187},[],[189],{"type":48,"value":190},"doca-public-knowledge-map ## DOCA tools",{"type":48,"value":192},";\nthis skill is for ",{"type":43,"tag":90,"props":194,"children":195},{},[196],{"type":48,"value":197},"custom",{"type":48,"value":199}," algorithms only.",{"type":43,"tag":201,"props":202,"children":204},"h2",{"id":203},"example-questions-this-skill-answers-well",[205],{"type":48,"value":206},"Example questions this skill answers well",{"type":43,"tag":51,"props":208,"children":209},{},[210,212,217],{"type":48,"value":211},"The CLASSES of PCC questions this skill is built to answer,\neach with one worked example. The agent should treat the ",{"type":43,"tag":90,"props":213,"children":214},{},[215],{"type":48,"value":216},"class",{"type":48,"value":218},"\nas the load-bearing piece — the worked example is a single\ninstance.",{"type":43,"tag":220,"props":221,"children":222},"ul",{},[223,271,330,390,458,514],{"type":43,"tag":224,"props":225,"children":226},"li",{},[227,232,234,239,241,251],{"type":43,"tag":55,"props":228,"children":229},{},[230],{"type":48,"value":231},"\"How do I deploy my own custom congestion control algorithm\nonto a BlueField port carrying RDMA \u002F RoCE traffic?\"",{"type":48,"value":233}," —\nworked example: ",{"type":43,"tag":90,"props":235,"children":236},{},[237],{"type":48,"value":238},"\"load a small DPA-side PCC algorithm and\nattach it to the BlueField port that handles my RoCE traffic\"",{"type":48,"value":240},".\nAnswered by the two-side-program model + the host-side\nload-and-attach workflow in\n",{"type":43,"tag":78,"props":242,"children":244},{"href":243},"CAPABILITIES.md#capabilities-and-modes",[245],{"type":43,"tag":70,"props":246,"children":248},{"className":247},[],[249],{"type":48,"value":250},"CAPABILITIES.md ## Capabilities and modes",{"type":43,"tag":220,"props":252,"children":253},{},[254],{"type":43,"tag":224,"props":255,"children":256},{},[257,259,269],{"type":48,"value":258},"the bring-up steps in\n",{"type":43,"tag":78,"props":260,"children":262},{"href":261},"TASKS.md#configure",[263],{"type":43,"tag":70,"props":264,"children":266},{"className":265},[],[267],{"type":48,"value":268},"TASKS.md ## configure",{"type":48,"value":270},".",{"type":43,"tag":224,"props":272,"children":273},{},[274,279,281,286,288,294,296,302,304,312],{"type":43,"tag":55,"props":275,"children":276},{},[277],{"type":48,"value":278},"\"Does this BlueField + firmware actually allow a custom PCC\nalgorithm, and which PCC features does my DOCA install\nexpose?\"",{"type":48,"value":280}," — worked example: ",{"type":43,"tag":90,"props":282,"children":283},{},[284],{"type":48,"value":285},"\"my host has a BlueField and the\ndefault factory PCC works; can I drop in a custom algorithm\ninstead?\"",{"type":48,"value":287},". Answered by the triple-axis precondition rule\n(BlueField generation must carry a DPA, firmware must have the\ncustom-PCC slot enabled, ",{"type":43,"tag":70,"props":289,"children":291},{"className":290},[],[292],{"type":48,"value":293},"doca_pcc_cap_*",{"type":48,"value":295}," against the active\n",{"type":43,"tag":70,"props":297,"children":299},{"className":298},[],[300],{"type":48,"value":301},"doca_devinfo",{"type":48,"value":303}," must agree) in\n",{"type":43,"tag":78,"props":305,"children":306},{"href":243},[307],{"type":43,"tag":70,"props":308,"children":310},{"className":309},[],[311],{"type":48,"value":250},{"type":43,"tag":220,"props":313,"children":314},{},[315],{"type":43,"tag":224,"props":316,"children":317},{},[318,320,328],{"type":48,"value":319},"the env-precondition checklist in\n",{"type":43,"tag":78,"props":321,"children":322},{"href":261},[323],{"type":43,"tag":70,"props":324,"children":326},{"className":325},[],[327],{"type":48,"value":268},{"type":48,"value":329}," step 1.",{"type":43,"tag":224,"props":331,"children":332},{},[333,354,356,361,363,373],{"type":43,"tag":55,"props":334,"children":335},{},[336,338,344,346,352],{"type":48,"value":337},"\"Why does my custom PCC fail with ",{"type":43,"tag":70,"props":339,"children":341},{"className":340},[],[342],{"type":48,"value":343},"DOCA_ERROR_NOT_PERMITTED",{"type":48,"value":345},"\neven though I have ",{"type":43,"tag":70,"props":347,"children":349},{"className":348},[],[350],{"type":48,"value":351},"doca_dev",{"type":48,"value":353}," access?\"",{"type":48,"value":355}," — worked example:\n",{"type":43,"tag":90,"props":357,"children":358},{},[359],{"type":48,"value":360},"\"the BlueField firmware in this host has the custom-PCC slot\ndisabled\"",{"type":48,"value":362},". Answered by the permission matrix in\n",{"type":43,"tag":78,"props":364,"children":366},{"href":365},"CAPABILITIES.md#safety-policy",[367],{"type":43,"tag":70,"props":368,"children":370},{"className":369},[],[371],{"type":48,"value":372},"CAPABILITIES.md ## Safety policy",{"type":43,"tag":220,"props":374,"children":375},{},[376],{"type":43,"tag":224,"props":377,"children":378},{},[379,381,389],{"type":48,"value":380},"the firmware-side env fix in\n",{"type":43,"tag":78,"props":382,"children":383},{"href":261},[384],{"type":43,"tag":70,"props":385,"children":387},{"className":386},[],[388],{"type":48,"value":268},{"type":48,"value":329},{"type":43,"tag":224,"props":391,"children":392},{},[393,412,413,418,420,428],{"type":43,"tag":55,"props":394,"children":395},{},[396,398,403,405,410],{"type":48,"value":397},"\"Is this ",{"type":43,"tag":70,"props":399,"children":401},{"className":400},[],[402],{"type":48,"value":4},{"type":48,"value":404}," library the right tool for what I want,\nor do I want the default firmware PCC or the\n",{"type":43,"tag":70,"props":406,"children":408},{"className":407},[],[409],{"type":48,"value":178},{"type":48,"value":411}," CLI?\"",{"type":48,"value":280},{"type":43,"tag":90,"props":414,"children":415},{},[416],{"type":48,"value":417},"\"I just want to\nread PCC counters without touching the algorithm\"",{"type":48,"value":419},". Answered\nby the path-selection rule in\n",{"type":43,"tag":78,"props":421,"children":422},{"href":243},[423],{"type":43,"tag":70,"props":424,"children":426},{"className":425},[],[427],{"type":48,"value":250},{"type":43,"tag":220,"props":429,"children":430},{},[431],{"type":43,"tag":224,"props":432,"children":433},{},[434,436,446,448,456],{"type":48,"value":435},"the deferred-topic boundaries in\n",{"type":43,"tag":78,"props":437,"children":439},{"href":438},"CAPABILITIES.md#deferred-topic-boundaries",[440],{"type":43,"tag":70,"props":441,"children":443},{"className":442},[],[444],{"type":48,"value":445},"CAPABILITIES.md ## Deferred topic boundaries",{"type":48,"value":447},"\nwhich route to\n",{"type":43,"tag":78,"props":449,"children":450},{"href":183},[451],{"type":43,"tag":70,"props":452,"children":454},{"className":453},[],[455],{"type":48,"value":190},{"type":48,"value":457},"\nfor the counter tool.",{"type":43,"tag":224,"props":459,"children":460},{},[461,466,467,472,474,484,486,496,498,503,505,513],{"type":43,"tag":55,"props":462,"children":463},{},[464],{"type":48,"value":465},"\"Is the host-side PCC API I'm reading about on my installed\nDOCA?\"",{"type":48,"value":280},{"type":43,"tag":90,"props":468,"children":469},{},[470],{"type":48,"value":471},"\"is the host-side load helper I\nsee in the docs available against the DOCA + DPACC versions on\nthis host?\"",{"type":48,"value":473},". Answered by the version-compatibility overlay in\n",{"type":43,"tag":78,"props":475,"children":477},{"href":476},"CAPABILITIES.md#version-compatibility",[478],{"type":43,"tag":70,"props":479,"children":481},{"className":480},[],[482],{"type":48,"value":483},"CAPABILITIES.md ## Version compatibility",{"type":48,"value":485},"\nwhich cross-links the canonical detection chain in\n",{"type":43,"tag":78,"props":487,"children":489},{"href":488},"..\u002F..\u002Fdoca-version\u002FSKILL.md",[490],{"type":43,"tag":70,"props":491,"children":493},{"className":492},[],[494],{"type":48,"value":495},"doca-version",{"type":48,"value":497}," and adds the\nPCC-specific ",{"type":43,"tag":90,"props":499,"children":500},{},[501],{"type":48,"value":502},"DOCA must match DPACC",{"type":48,"value":504}," overlay inherited from\n",{"type":43,"tag":78,"props":506,"children":507},{"href":156},[508],{"type":43,"tag":70,"props":509,"children":511},{"className":510},[],[512],{"type":48,"value":163},{"type":48,"value":270},{"type":43,"tag":224,"props":515,"children":516},{},[517,538,539,552,554,564],{"type":43,"tag":55,"props":518,"children":519},{},[520,522,528,530,536],{"type":48,"value":521},"\"What does this ",{"type":43,"tag":70,"props":523,"children":525},{"className":524},[],[526],{"type":48,"value":527},"DOCA_ERROR_*",{"type":48,"value":529}," from a ",{"type":43,"tag":70,"props":531,"children":533},{"className":532},[],[534],{"type":48,"value":535},"doca_pcc_*",{"type":48,"value":537}," call mean\nand which layer caused it?\"",{"type":48,"value":355},{"type":43,"tag":90,"props":540,"children":541},{},[542,544,550],{"type":48,"value":543},"\"",{"type":43,"tag":70,"props":545,"children":547},{"className":546},[],[548],{"type":48,"value":549},"DOCA_ERROR_DRIVER",{"type":48,"value":551}," on the host-side algorithm-load call —\nis it DOCA, the firmware-side custom-PCC slot, or the DPACC-\nproduced image?\"",{"type":48,"value":553},". Answered by the PCC overlay on the\ncross-library taxonomy in\n",{"type":43,"tag":78,"props":555,"children":557},{"href":556},"CAPABILITIES.md#error-taxonomy",[558],{"type":43,"tag":70,"props":559,"children":561},{"className":560},[],[562],{"type":48,"value":563},"CAPABILITIES.md ## Error taxonomy",{"type":43,"tag":220,"props":565,"children":566},{},[567],{"type":43,"tag":224,"props":568,"children":569},{},[570,572,582,584,594],{"type":48,"value":571},"the layered ladder in\n",{"type":43,"tag":78,"props":573,"children":575},{"href":574},"TASKS.md#debug",[576],{"type":43,"tag":70,"props":577,"children":579},{"className":578},[],[580],{"type":48,"value":581},"TASKS.md ## debug",{"type":48,"value":583}," that escalates to\n",{"type":43,"tag":78,"props":585,"children":587},{"href":586},"..\u002F..\u002Fdoca-debug\u002FSKILL.md",[588],{"type":43,"tag":70,"props":589,"children":591},{"className":590},[],[592],{"type":48,"value":593},"doca-debug",{"type":48,"value":270},{"type":43,"tag":201,"props":596,"children":598},{"id":597},"audience",[599],{"type":48,"value":600},"Audience",{"type":43,"tag":51,"props":602,"children":603},{},[604,606,611,613,618,620,625,627,632,634,638,640,648],{"type":48,"value":605},"This skill serves ",{"type":43,"tag":55,"props":607,"children":608},{},[609],{"type":48,"value":610},"external developers building applications\nthat consume the DOCA PCC library from the host side",{"type":48,"value":612}," — i.e.,\nusers whose code calls ",{"type":43,"tag":70,"props":614,"children":616},{"className":615},[],[617],{"type":48,"value":535},{"type":48,"value":619}," from host C \u002F C++ to stand\nup the per-PCC-instance context, load a DPA-side PCC algorithm\nimage that ",{"type":43,"tag":70,"props":621,"children":623},{"className":622},[],[624],{"type":48,"value":139},{"type":48,"value":626}," produced from their DPA-side source, attach\nit to the BlueField port that carries the RDMA \u002F RoCE traffic\nthe algorithm is meant to control, parameterize the algorithm,\nstart the context, and observe runtime reports back from the\nalgorithm. It is ",{"type":43,"tag":90,"props":628,"children":629},{},[630],{"type":48,"value":631},"not",{"type":48,"value":633}," for NVIDIA developers contributing to\nDOCA PCC itself, nor is it the place to learn how to ",{"type":43,"tag":90,"props":635,"children":636},{},[637],{"type":48,"value":131},{"type":48,"value":639},"\nthe DPA-side congestion-control algorithm itself (that path\ngoes through the public DOCA PCC programming guide and the\ncompanion DOCA DPA \u002F DPACC guides via\n",{"type":43,"tag":78,"props":641,"children":642},{"href":144},[643],{"type":43,"tag":70,"props":644,"children":646},{"className":645},[],[647],{"type":48,"value":151},{"type":48,"value":649},").",{"type":43,"tag":51,"props":651,"children":652},{},[653,658,660,666,668,673,675,680,682,688,690,695,697,702],{"type":43,"tag":55,"props":654,"children":655},{},[656],{"type":48,"value":657},"Language scope.",{"type":48,"value":659}," DOCA PCC ships as a host-side C library\nwith ",{"type":43,"tag":70,"props":661,"children":663},{"className":662},[],[664],{"type":48,"value":665},"pkg-config",{"type":48,"value":667}," module name ",{"type":43,"tag":70,"props":669,"children":671},{"className":670},[],[672],{"type":48,"value":4},{"type":48,"value":674},". The host-side API is\nC; the DPA-side congestion-control algorithm is a separate\ntranslation unit written in the language the DPACC compiler\naccepts and compiled by ",{"type":43,"tag":70,"props":676,"children":678},{"className":677},[],[679],{"type":48,"value":139},{"type":48,"value":681}," into a binary that the host\npackages into the executable as the PCC algorithm image. The\nshipped samples under ",{"type":43,"tag":70,"props":683,"children":685},{"className":684},[],[686],{"type":48,"value":687},"\u002Fopt\u002Fmellanox\u002Fdoca\u002Fsamples\u002Fdoca_pcc\u002F",{"type":48,"value":689},"\nare written in C plus DPA-side source (NVIDIA's choice).\nOther-language consumers are limited in practice — the\nDPA-side algorithm has no FFI escape hatch because it must be\na translation unit ",{"type":43,"tag":70,"props":691,"children":693},{"className":692},[],[694],{"type":48,"value":139},{"type":48,"value":696}," accepts — but a Rust \u002F Go \u002F Python\nhost-side wrapper that drives ",{"type":43,"tag":70,"props":698,"children":700},{"className":699},[],[701],{"type":48,"value":535},{"type":48,"value":703}," setup and loads a\nPCC algorithm image built separately is still useful, and the\nskill keeps the lifecycle, capability-discovery,\nenv-precondition, and error-taxonomy guidance language-neutral.",{"type":43,"tag":201,"props":705,"children":707},{"id":706},"when-to-load-this-skill",[708],{"type":48,"value":709},"When to load this skill",{"type":43,"tag":51,"props":711,"children":712},{},[713,715,720,722,726,728,733],{"type":48,"value":714},"Load this skill when the user is doing hands-on DOCA PCC work\n",{"type":43,"tag":55,"props":716,"children":717},{},[718],{"type":48,"value":719},"from the host side",{"type":48,"value":721}," for a ",{"type":43,"tag":55,"props":723,"children":724},{},[725],{"type":48,"value":197},{"type":48,"value":727}," congestion control\nalgorithm, in any host language plus a DPA-side translation\nunit built by ",{"type":43,"tag":70,"props":729,"children":731},{"className":730},[],[732],{"type":48,"value":139},{"type":48,"value":734},". Concretely:",{"type":43,"tag":220,"props":736,"children":737},{},[738,758,785,797,816,868],{"type":43,"tag":224,"props":739,"children":740},{},[741,743,749,751,756],{"type":48,"value":742},"Initializing a ",{"type":43,"tag":70,"props":744,"children":746},{"className":745},[],[747],{"type":48,"value":748},"doca_pcc",{"type":48,"value":750}," against a ",{"type":43,"tag":70,"props":752,"children":754},{"className":753},[],[755],{"type":48,"value":351},{"type":48,"value":757}," that maps to\nthe BlueField port carrying the RDMA \u002F RoCE traffic to be\ncontrolled.",{"type":43,"tag":224,"props":759,"children":760},{},[761,763,769,771,776,778,783],{"type":48,"value":762},"Loading a PCC algorithm image (",{"type":43,"tag":70,"props":764,"children":766},{"className":765},[],[767],{"type":48,"value":768},"doca_pcc_app",{"type":48,"value":770},") that ",{"type":43,"tag":70,"props":772,"children":774},{"className":773},[],[775],{"type":48,"value":139},{"type":48,"value":777},"\nproduced from the user's DPA-side congestion-control algorithm\nsource, into the ",{"type":43,"tag":70,"props":779,"children":781},{"className":780},[],[782],{"type":48,"value":748},{"type":48,"value":784}," context.",{"type":43,"tag":224,"props":786,"children":787},{},[788,790,795],{"type":48,"value":789},"Parameterizing the loaded algorithm with the host-side knobs\nthe algorithm exposes, and starting the ",{"type":43,"tag":70,"props":791,"children":793},{"className":792},[],[794],{"type":48,"value":748},{"type":48,"value":796}," Core\ncontext so the algorithm begins affecting RDMA \u002F RoCE\ntraffic on the attached port.",{"type":43,"tag":224,"props":798,"children":799},{},[800,802,807,809,814],{"type":48,"value":801},"Checking which PCC features are supported on the active\n",{"type":43,"tag":70,"props":803,"children":805},{"className":804},[],[806],{"type":48,"value":301},{"type":48,"value":808}," via the ",{"type":43,"tag":70,"props":810,"children":812},{"className":811},[],[813],{"type":48,"value":293},{"type":48,"value":815}," family — BlueField\ngenerations and firmware revisions differ in whether they\npermit a custom PCC algorithm.",{"type":43,"tag":224,"props":817,"children":818},{},[819,821,826,828,833,835,840,842,847,848,853,855,867],{"type":48,"value":820},"Debugging a ",{"type":43,"tag":70,"props":822,"children":824},{"className":823},[],[825],{"type":48,"value":527},{"type":48,"value":827}," returned from a ",{"type":43,"tag":70,"props":829,"children":831},{"className":830},[],[832],{"type":48,"value":535},{"type":48,"value":834}," call\n— in particular disambiguating ",{"type":43,"tag":90,"props":836,"children":837},{},[838],{"type":48,"value":839},"firmware-level custom-PCC\nslot disabled",{"type":48,"value":841}," from ",{"type":43,"tag":90,"props":843,"children":844},{},[845],{"type":48,"value":846},"device does not support custom PCC at\nall",{"type":48,"value":841},{"type":43,"tag":90,"props":849,"children":850},{},[851],{"type":48,"value":852},"algorithm image incompatible with this device",{"type":48,"value":854},"\nfrom ",{"type":43,"tag":90,"props":856,"children":857},{},[858,860,865],{"type":48,"value":859},"standard ",{"type":43,"tag":70,"props":861,"children":863},{"className":862},[],[864],{"type":48,"value":351},{"type":48,"value":866}," access denied",{"type":48,"value":270},{"type":43,"tag":224,"props":869,"children":870},{},[871,873,878],{"type":48,"value":872},"Designing host-side bindings in a non-C language that drive\na custom PCC algorithm image they built separately with\n",{"type":43,"tag":70,"props":874,"children":876},{"className":875},[],[877],{"type":48,"value":139},{"type":48,"value":879}," — the env-precondition and capability-discovery rules\nin this skill still apply.",{"type":43,"tag":51,"props":881,"children":882},{},[883,885,889,891,896,898,903,905,913,915,923],{"type":48,"value":884},"Do ",{"type":43,"tag":55,"props":886,"children":887},{},[888],{"type":48,"value":631},{"type":48,"value":890}," load this skill for general DOCA orientation, install\nof DOCA or the DPACC compiler, the DPA-side programming model\nitself (how to write the congestion-control algorithm body that\nruns on the DPA), questions about the default factory PCC\nalgorithm shipped in ConnectX firmware (no host-side ",{"type":43,"tag":70,"props":892,"children":894},{"className":893},[],[895],{"type":48,"value":4},{"type":48,"value":897},"\ncode needed — that path is firmware-only configuration), or\nquestions about the ",{"type":43,"tag":70,"props":899,"children":901},{"className":900},[],[902],{"type":48,"value":178},{"type":48,"value":904}," diagnostic CLI (route via\n",{"type":43,"tag":78,"props":906,"children":907},{"href":183},[908],{"type":43,"tag":70,"props":909,"children":911},{"className":910},[],[912],{"type":48,"value":190},{"type":48,"value":914},").\nFor all of those, route through\n",{"type":43,"tag":78,"props":916,"children":917},{"href":144},[918],{"type":43,"tag":70,"props":919,"children":921},{"className":920},[],[922],{"type":48,"value":151},{"type":48,"value":924},"\nto the matching upstream guide.",{"type":43,"tag":201,"props":926,"children":928},{"id":927},"what-this-skill-provides",[929],{"type":48,"value":930},"What this skill provides",{"type":43,"tag":51,"props":932,"children":933},{},[934,936,941],{"type":48,"value":935},"This is a ",{"type":43,"tag":55,"props":937,"children":938},{},[939],{"type":48,"value":940},"thin loader",{"type":48,"value":942},". The body keeps only the orientation\nneeded to pick the right next file. The substantive\nPCC-specific material lives in two companion files:",{"type":43,"tag":220,"props":944,"children":945},{},[946,998],{"type":43,"tag":224,"props":947,"children":948},{},[949,954,956,961,963,968,970,975,977,982,984,989,991,996],{"type":43,"tag":70,"props":950,"children":952},{"className":951},[],[953],{"type":48,"value":99},{"type":48,"value":955}," — what the host-side PCC API can express on\nthis version + this BlueField generation + this firmware: the\nper-PCC-instance ",{"type":43,"tag":70,"props":957,"children":959},{"className":958},[],[960],{"type":48,"value":748},{"type":48,"value":962}," context, the loaded ",{"type":43,"tag":70,"props":964,"children":966},{"className":965},[],[967],{"type":48,"value":768},{"type":48,"value":969},"\nalgorithm image produced by ",{"type":43,"tag":70,"props":971,"children":973},{"className":972},[],[974],{"type":48,"value":139},{"type":48,"value":976},", the attach-to-port\nsemantics that bind the algorithm to the RDMA \u002F RoCE traffic\nit will control, the capability-query surface\n(",{"type":43,"tag":70,"props":978,"children":980},{"className":979},[],[981],{"type":48,"value":293},{"type":48,"value":983},"), the PCC error taxonomy mapped onto the\ncross-library ",{"type":43,"tag":70,"props":985,"children":987},{"className":986},[],[988],{"type":48,"value":527},{"type":48,"value":990}," set, the observability surface\n(host-side reports plus the public PCC counter tool reachable\nvia ",{"type":43,"tag":70,"props":992,"children":994},{"className":993},[],[995],{"type":48,"value":151},{"type":48,"value":997},"), and the safety policy that\ngates env preconditions (DPA-capable BlueField, firmware-level\ncustom-PCC slot enabled, matched DOCA + DPACC versions,\nalgorithm image and host-side expectations agree).",{"type":43,"tag":224,"props":999,"children":1000},{},[1001,1006,1008,1014,1016,1022,1023,1029,1030,1036,1037,1043,1045,1051,1053,1059],{"type":43,"tag":70,"props":1002,"children":1004},{"className":1003},[],[1005],{"type":48,"value":80},{"type":48,"value":1007}," — step-by-step workflows for the six in-scope PCC\nverbs: ",{"type":43,"tag":70,"props":1009,"children":1011},{"className":1010},[],[1012],{"type":48,"value":1013},"configure",{"type":48,"value":1015},", ",{"type":43,"tag":70,"props":1017,"children":1019},{"className":1018},[],[1020],{"type":48,"value":1021},"build",{"type":48,"value":1015},{"type":43,"tag":70,"props":1024,"children":1026},{"className":1025},[],[1027],{"type":48,"value":1028},"modify",{"type":48,"value":1015},{"type":43,"tag":70,"props":1031,"children":1033},{"className":1032},[],[1034],{"type":48,"value":1035},"run",{"type":48,"value":1015},{"type":43,"tag":70,"props":1038,"children":1040},{"className":1039},[],[1041],{"type":48,"value":1042},"test",{"type":48,"value":1044},",\n",{"type":43,"tag":70,"props":1046,"children":1048},{"className":1047},[],[1049],{"type":48,"value":1050},"debug",{"type":48,"value":1052},". Plus a ",{"type":43,"tag":70,"props":1054,"children":1056},{"className":1055},[],[1057],{"type":48,"value":1058},"Deferred task verbs",{"type":48,"value":1060}," block that points\nout-of-scope questions at the right next skill.",{"type":43,"tag":51,"props":1062,"children":1063},{},[1064,1066,1071,1073,1081],{"type":48,"value":1065},"The skill assumes a host where DOCA is already installed at\nthe standard location, a BlueField with a DPA processor is\nphysically present and visible to the host, the BlueField\nfirmware has the custom-PCC slot enabled, the DPACC compiler\nis installed at a version matched to the DOCA install per the\nDOCA Compatibility Policy, and the user already knows how\n(at least at a sketch level) to write the DPA-side PCC\nalgorithm that ",{"type":43,"tag":70,"props":1067,"children":1069},{"className":1068},[],[1070],{"type":48,"value":139},{"type":48,"value":1072}," will compile. It does not cover\ninstalling DOCA, installing the DPACC compiler, or flipping\nfirmware-level configuration — those paths go through\n",{"type":43,"tag":78,"props":1074,"children":1075},{"href":117},[1076],{"type":43,"tag":70,"props":1077,"children":1079},{"className":1078},[],[1080],{"type":48,"value":124},{"type":48,"value":270},{"type":43,"tag":201,"props":1083,"children":1085},{"id":1084},"what-this-skill-deliberately-does-not-ship",[1086],{"type":48,"value":1087},"What this skill deliberately does not ship",{"type":43,"tag":51,"props":1089,"children":1090},{},[1091,1093,1098],{"type":48,"value":1092},"This skill is ",{"type":43,"tag":55,"props":1094,"children":1095},{},[1096],{"type":48,"value":1097},"agent guidance",{"type":48,"value":1099},", not a samples or templates\nbundle. To keep the boundary clean, it deliberately does not\ncontain — and pull requests should not add:",{"type":43,"tag":220,"props":1101,"children":1102},{},[1103,1143,1173,1220,1253],{"type":43,"tag":224,"props":1104,"children":1105},{},[1106,1111,1113,1118,1120,1130,1132,1142],{"type":43,"tag":55,"props":1107,"children":1108},{},[1109],{"type":48,"value":1110},"Pre-written DOCA PCC application source code or DPA-side\nalgorithm source, in any language.",{"type":48,"value":1112}," The verified PCC source\nis the shipped C + DPA-side samples at\n",{"type":43,"tag":70,"props":1114,"children":1116},{"className":1115},[],[1117],{"type":48,"value":687},{"type":48,"value":1119},". The agent's job is to\nroute the user to those files and prescribe a minimum-diff\nmodification on them via the universal modify-a-sample\nworkflow in\n",{"type":43,"tag":78,"props":1121,"children":1123},{"href":1122},"..\u002F..\u002Fdoca-programming-guide\u002FSKILL.md",[1124],{"type":43,"tag":70,"props":1125,"children":1127},{"className":1126},[],[1128],{"type":48,"value":1129},"doca-programming-guide",{"type":48,"value":1131},",\nlayered with the PCC-specific overrides in\n",{"type":43,"tag":78,"props":1133,"children":1135},{"href":1134},"TASKS.md#modify",[1136],{"type":43,"tag":70,"props":1137,"children":1139},{"className":1138},[],[1140],{"type":48,"value":1141},"TASKS.md ## modify",{"type":48,"value":270},{"type":43,"tag":224,"props":1144,"children":1145},{},[1146,1151,1153,1158,1160,1164,1166,1171],{"type":43,"tag":55,"props":1147,"children":1148},{},[1149],{"type":48,"value":1150},"A specific congestion control algorithm.",{"type":48,"value":1152}," This library\n",{"type":43,"tag":90,"props":1154,"children":1155},{},[1156],{"type":48,"value":1157},"loads",{"type":48,"value":1159}," an algorithm the user supplies; it does ",{"type":43,"tag":90,"props":1161,"children":1162},{},[1163],{"type":48,"value":631},{"type":48,"value":1165}," define\none. The agent must refuse to invent algorithm bodies and\nmust route any ",{"type":43,"tag":90,"props":1167,"children":1168},{},[1169],{"type":48,"value":1170},"\"what algorithm should I write\"",{"type":48,"value":1172}," question to\nthe public DOCA PCC programming guide and the user's own\ndomain expertise — that is a research question, not an API\nquestion.",{"type":43,"tag":224,"props":1174,"children":1175},{},[1176,1181,1183,1189,1190,1196,1198,1203,1205,1211,1213,1218],{"type":43,"tag":55,"props":1177,"children":1178},{},[1179],{"type":48,"value":1180},"Standalone build manifests",{"type":48,"value":1182}," (",{"type":43,"tag":70,"props":1184,"children":1186},{"className":1185},[],[1187],{"type":48,"value":1188},"meson.build",{"type":48,"value":1044},{"type":43,"tag":70,"props":1191,"children":1193},{"className":1192},[],[1194],{"type":48,"value":1195},"CMakeLists.txt",{"type":48,"value":1197},", …) parked inside the skill. The agent\nconstructs the build manifest ",{"type":43,"tag":90,"props":1199,"children":1200},{},[1201],{"type":48,"value":1202},"in the user's project\ndirectory",{"type":48,"value":1204}," against the user's installed DOCA + DPACC\ncompiler, where ",{"type":43,"tag":70,"props":1206,"children":1208},{"className":1207},[],[1209],{"type":48,"value":1210},"pkg-config --modversion doca-pcc",{"type":48,"value":1212}," and the\ninstalled ",{"type":43,"tag":70,"props":1214,"children":1216},{"className":1215},[],[1217],{"type":48,"value":139},{"type":48,"value":1219}," are the two sources of truth.",{"type":43,"tag":224,"props":1221,"children":1222},{},[1223,1251],{"type":43,"tag":55,"props":1224,"children":1225},{},[1226,1228,1234,1235,1241,1243,1249],{"type":48,"value":1227},"A ",{"type":43,"tag":70,"props":1229,"children":1231},{"className":1230},[],[1232],{"type":48,"value":1233},"samples\u002F",{"type":48,"value":1015},{"type":43,"tag":70,"props":1236,"children":1238},{"className":1237},[],[1239],{"type":48,"value":1240},"bindings\u002F",{"type":48,"value":1242},", or ",{"type":43,"tag":70,"props":1244,"children":1246},{"className":1245},[],[1247],{"type":48,"value":1248},"reference\u002F",{"type":48,"value":1250}," subtree",{"type":48,"value":1252}," of any\nkind. A mock or incomplete artifact in this skill's tree,\neven one labeled \"reference\", is misleading: users will read\nit as buildable.",{"type":43,"tag":224,"props":1254,"children":1255},{},[1256,1266,1268,1273,1275,1281,1283,1289,1291,1299,1301,1306],{"type":43,"tag":55,"props":1257,"children":1258},{},[1259,1264],{"type":43,"tag":70,"props":1260,"children":1262},{"className":1261},[],[1263],{"type":48,"value":178},{"type":48,"value":1265}," tool surface.",{"type":48,"value":1267}," That CLI is a ",{"type":43,"tag":90,"props":1269,"children":1270},{},[1271],{"type":48,"value":1272},"separate\nartifact",{"type":48,"value":1274}," (the real tool is the ",{"type":43,"tag":70,"props":1276,"children":1278},{"className":1277},[],[1279],{"type":48,"value":1280},"pcc_counters.sh",{"type":48,"value":1282}," script under\n",{"type":43,"tag":70,"props":1284,"children":1286},{"className":1285},[],[1287],{"type":48,"value":1288},"tools\u002Fpcc_counters\u002F",{"type":48,"value":1290},") with its own public page; routing for it lives in\n",{"type":43,"tag":78,"props":1292,"children":1293},{"href":183},[1294],{"type":43,"tag":70,"props":1295,"children":1297},{"className":1296},[],[1298],{"type":48,"value":190},{"type":48,"value":1300},".\nConflating it with the ",{"type":43,"tag":70,"props":1302,"children":1304},{"className":1303},[],[1305],{"type":48,"value":4},{"type":48,"value":1307}," library is the single most\ncommon PCC first-app design error.",{"type":43,"tag":201,"props":1309,"children":1311},{"id":1310},"loading-order",[1312],{"type":48,"value":1313},"Loading order",{"type":43,"tag":1315,"props":1316,"children":1317},"ol",{},[1318,1331,1358],{"type":43,"tag":224,"props":1319,"children":1320},{},[1321,1323,1329],{"type":48,"value":1322},"Read this ",{"type":43,"tag":70,"props":1324,"children":1326},{"className":1325},[],[1327],{"type":48,"value":1328},"SKILL.md",{"type":48,"value":1330}," first to confirm the user's question is\nin scope (host-side custom PCC work, not DPA-side algorithm\ndesign and not the counter tool).",{"type":43,"tag":224,"props":1332,"children":1333},{},[1334],{"type":43,"tag":55,"props":1335,"children":1336},{},[1337,1339,1344,1346,1351,1353,1357],{"type":48,"value":1338},"For the PCC capability matrix, the two-side-program model,\nthe ",{"type":43,"tag":70,"props":1340,"children":1342},{"className":1341},[],[1343],{"type":48,"value":748},{"type":48,"value":1345}," per-instance context, the loaded ",{"type":43,"tag":70,"props":1347,"children":1349},{"className":1348},[],[1350],{"type":48,"value":768},{"type":48,"value":1352},"\nalgorithm image, the attach-to-port semantics, the\ntriple-axis precondition rule, the env-precondition policy,\nthe error taxonomy, the observability surface, and the\nsafety policy, see ",{"type":43,"tag":78,"props":1354,"children":1355},{"href":99},[1356],{"type":48,"value":99},{"type":48,"value":270},{"type":43,"tag":224,"props":1359,"children":1360},{},[1361],{"type":43,"tag":55,"props":1362,"children":1363},{},[1364,1366,1370],{"type":48,"value":1365},"For step-by-step workflows — configure, build, modify,\nrun, test, debug — see ",{"type":43,"tag":78,"props":1367,"children":1368},{"href":80},[1369],{"type":48,"value":80},{"type":48,"value":270},{"type":43,"tag":51,"props":1372,"children":1373},{},[1374,1376,1384,1386,1394,1396,1401],{"type":48,"value":1375},"Both companion files cross-link to each other,\n",{"type":43,"tag":78,"props":1377,"children":1378},{"href":488},[1379],{"type":43,"tag":70,"props":1380,"children":1382},{"className":1381},[],[1383],{"type":48,"value":495},{"type":48,"value":1385}," for the canonical\nDOCA version-handling rules (with the PCC overlay that DOCA\nmust match the DPACC compiler), and\n",{"type":43,"tag":78,"props":1387,"children":1388},{"href":144},[1389],{"type":43,"tag":70,"props":1390,"children":1392},{"className":1391},[],[1393],{"type":48,"value":151},{"type":48,"value":1395},"\nwhenever the right answer is \"look it up in the public DOCA\nPCC programming guide, the public DPA \u002F DPACC guides, the\n",{"type":43,"tag":70,"props":1397,"children":1399},{"className":1398},[],[1400],{"type":48,"value":178},{"type":48,"value":1402}," tool guide, or in the on-disk install\nlayout\" rather than \"PCC host-side-specific guidance\".",{"type":43,"tag":201,"props":1404,"children":1406},{"id":1405},"related-skills",[1407],{"type":48,"value":1408},"Related skills",{"type":43,"tag":220,"props":1410,"children":1411},{},[1412,1448,1489,1511,1531,1568,1589,1616],{"type":43,"tag":224,"props":1413,"children":1414},{},[1415,1423,1425,1432,1434,1439,1441,1446],{"type":43,"tag":78,"props":1416,"children":1417},{"href":144},[1418],{"type":43,"tag":70,"props":1419,"children":1421},{"className":1420},[],[1422],{"type":48,"value":151},{"type":48,"value":1424}," —\nthe routing table for every public DOCA documentation\nsource and the on-disk layout of an installed DOCA package.\nThe PCC public guide is at\n",{"type":43,"tag":78,"props":1426,"children":1430},{"href":1427,"rel":1428},"https:\u002F\u002Fdocs.nvidia.com\u002Fdoca\u002Fsdk\u002FDOCA-PCC\u002Findex.html",[1429],"nofollow",[1431],{"type":48,"value":1427},{"type":48,"value":1433},"; the\n",{"type":43,"tag":70,"props":1435,"children":1437},{"className":1436},[],[1438],{"type":48,"value":178},{"type":48,"value":1440}," diagnostic CLI lives under the DOCA Tools\numbrella as a ",{"type":43,"tag":90,"props":1442,"children":1443},{},[1444],{"type":48,"value":1445},"companion surface",{"type":48,"value":1447}," rather than a redefined\nartifact here.",{"type":43,"tag":224,"props":1449,"children":1450},{},[1451,1459,1461,1466,1468,1473,1475,1480,1482,1487],{"type":43,"tag":78,"props":1452,"children":1453},{"href":156},[1454],{"type":43,"tag":70,"props":1455,"children":1457},{"className":1456},[],[1458],{"type":48,"value":163},{"type":48,"value":1460}," — the host-side DPA\ncontrol library that PCC depends on conceptually: the\ncustom PCC algorithm ",{"type":43,"tag":90,"props":1462,"children":1463},{},[1464],{"type":48,"value":1465},"is",{"type":48,"value":1467}," DPA-side code, compiled by the\nDPACC compiler, and the host-side ",{"type":43,"tag":70,"props":1469,"children":1471},{"className":1470},[],[1472],{"type":48,"value":4},{"type":48,"value":1474}," Core lifecycle\nfollows the same shape as the ",{"type":43,"tag":70,"props":1476,"children":1478},{"className":1477},[],[1479],{"type":48,"value":163},{"type":48,"value":1481}," Core lifecycle. The\nagent loads ",{"type":43,"tag":70,"props":1483,"children":1485},{"className":1484},[],[1486],{"type":48,"value":163},{"type":48,"value":1488}," alongside this skill when the user\nhas DPA-level questions (kernel-launch model, DPA-side\nlibraries) that PCC is layered on top of.",{"type":43,"tag":224,"props":1490,"children":1491},{},[1492,1502,1504,1509],{"type":43,"tag":78,"props":1493,"children":1495},{"href":1494},"..\u002Fdoca-rdma\u002FSKILL.md",[1496],{"type":43,"tag":70,"props":1497,"children":1499},{"className":1498},[],[1500],{"type":48,"value":1501},"doca-rdma",{"type":48,"value":1503}," — the library whose\ntraffic the custom PCC algorithm is controlling. The custom\nPCC algorithm affects RDMA \u002F RoCE flows on the attached\nBlueField port; if the user has not yet set up RDMA \u002F RoCE\ntraffic on that port, there is nothing for the algorithm to\nact on, and ",{"type":43,"tag":70,"props":1505,"children":1507},{"className":1506},[],[1508],{"type":48,"value":1501},{"type":48,"value":1510}," is the skill that brings that\ntraffic up.",{"type":43,"tag":224,"props":1512,"children":1513},{},[1514,1522,1524,1529],{"type":43,"tag":78,"props":1515,"children":1516},{"href":117},[1517],{"type":43,"tag":70,"props":1518,"children":1520},{"className":1519},[],[1521],{"type":48,"value":124},{"type":48,"value":1523}," — env preparation,\ninstall verification, DPACC compiler install \u002F verification,\nBlueField firmware configuration (including the custom-PCC\nslot enable), and the ",{"type":43,"tag":90,"props":1525,"children":1526},{},[1527],{"type":48,"value":1528},"I have no install yet",{"type":48,"value":1530}," path with the\npublic NGC DOCA container. This skill assumes its\npreconditions are satisfied AND that DPACC is installed at a\nversion that matches DOCA AND that the firmware-level\ncustom-PCC slot is enabled.",{"type":43,"tag":224,"props":1532,"children":1533},{},[1534,1542,1544,1550,1552,1557,1559,1567],{"type":43,"tag":78,"props":1535,"children":1536},{"href":488},[1537],{"type":43,"tag":70,"props":1538,"children":1540},{"className":1539},[],[1541],{"type":48,"value":495},{"type":48,"value":1543}," — canonical\nDOCA version-handling rules. This skill's ",{"type":43,"tag":70,"props":1545,"children":1547},{"className":1546},[],[1548],{"type":48,"value":1549},"## Version compatibility",{"type":48,"value":1551}," cross-links the four-way match rule and adds\nthe PCC-specific ",{"type":43,"tag":90,"props":1553,"children":1554},{},[1555],{"type":48,"value":1556},"DOCA-and-DPACC must match",{"type":48,"value":1558}," overlay per the\nDOCA Compatibility Policy (inherited from\n",{"type":43,"tag":78,"props":1560,"children":1561},{"href":156},[1562],{"type":43,"tag":70,"props":1563,"children":1565},{"className":1564},[],[1566],{"type":48,"value":163},{"type":48,"value":649},{"type":43,"tag":224,"props":1569,"children":1570},{},[1571,1581,1583,1587],{"type":43,"tag":78,"props":1572,"children":1574},{"href":1573},"..\u002F..\u002Fdoca-structured-tools-contract\u002FSKILL.md",[1575],{"type":43,"tag":70,"props":1576,"children":1578},{"className":1577},[],[1579],{"type":48,"value":1580},"doca-structured-tools-contract",{"type":48,"value":1582}," —\nthe bundle's structured-tools precedence rule (detect \u002F\nprefer \u002F fall back \u002F report). The Command appendix in\n",{"type":43,"tag":78,"props":1584,"children":1585},{"href":80},[1586],{"type":48,"value":80},{"type":48,"value":1588}," honors this contract.",{"type":43,"tag":224,"props":1590,"children":1591},{},[1592,1600,1602,1607,1609,1614],{"type":43,"tag":78,"props":1593,"children":1594},{"href":1122},[1595],{"type":43,"tag":70,"props":1596,"children":1598},{"className":1597},[],[1599],{"type":48,"value":1129},{"type":48,"value":1601}," —\ngeneral DOCA programming patterns shared by every library:\nthe canonical ",{"type":43,"tag":70,"props":1603,"children":1605},{"className":1604},[],[1606],{"type":48,"value":665},{"type":48,"value":1608}," + meson build pattern, the\nuniversal modify-a-shipped-sample first-app workflow, the\nuniversal Core-context lifecycle, the cross-library\n",{"type":43,"tag":70,"props":1610,"children":1612},{"className":1611},[],[1613],{"type":48,"value":527},{"type":48,"value":1615}," taxonomy, and the program-side debug order.\nThis skill layers PCC specifics on top.",{"type":43,"tag":224,"props":1617,"children":1618},{},[1619,1627],{"type":43,"tag":78,"props":1620,"children":1621},{"href":586},[1622],{"type":43,"tag":70,"props":1623,"children":1625},{"className":1624},[],[1626],{"type":48,"value":593},{"type":48,"value":1628}," — the cross-cutting\ndebug ladder (install \u002F version \u002F build \u002F link \u002F runtime \u002F\nprogram \u002F driver). PCC-specific debug (custom-PCC slot not\nenabled in firmware, DPACC + DOCA version skew, algorithm\nimage rejected as incompatible with the device, traffic on\nthe attached port not being affected because the algorithm\nbody has no effect path) overlays on top of that ladder.",{"type":43,"tag":51,"props":1630,"children":1631},{},[1632,1634,1639,1641,1646,1648,1653,1655,1660,1662,1667,1669,1674],{"type":48,"value":1633},"The default factory PCC algorithms shipped inside ConnectX\nfirmware are ",{"type":43,"tag":55,"props":1635,"children":1636},{},[1637],{"type":48,"value":1638},"not in scope",{"type":48,"value":1640}," for this skill — those work\nwithout ",{"type":43,"tag":70,"props":1642,"children":1644},{"className":1643},[],[1645],{"type":48,"value":4},{"type":48,"value":1647}," and are configured through firmware-level\nknobs, not through any host-side library API. The\n",{"type":43,"tag":70,"props":1649,"children":1651},{"className":1650},[],[1652],{"type":48,"value":178},{"type":48,"value":1654}," diagnostic CLI is ",{"type":43,"tag":55,"props":1656,"children":1657},{},[1658],{"type":48,"value":1659},"also not in scope",{"type":48,"value":1661}," —\nit is a separate artifact for ",{"type":43,"tag":90,"props":1663,"children":1664},{},[1665],{"type":48,"value":1666},"inspecting",{"type":48,"value":1668}," runtime PCC\ncounters and lives under the public DOCA Tools umbrella.\nConflating either of those with the ",{"type":43,"tag":70,"props":1670,"children":1672},{"className":1671},[],[1673],{"type":48,"value":4},{"type":48,"value":1675}," library is the\nsingle most common PCC first-app design error.",{"items":1677,"total":1836},[1678,1696,1714,1725,1737,1751,1764,1778,1791,1802,1816,1825],{"slug":1679,"name":1679,"fn":1680,"description":1681,"org":1682,"tags":1683,"stars":1693,"repoUrl":1694,"updatedAt":1695},"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},[1684,1687,1690],{"name":1685,"slug":1686,"type":15},"Documentation","documentation",{"name":1688,"slug":1689,"type":15},"MCP","mcp",{"name":1691,"slug":1692,"type":15},"Search","search",21777,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FNemoClaw","2026-07-20T06:00:01.461044",{"slug":1697,"name":1697,"fn":1698,"description":1699,"org":1700,"tags":1701,"stars":1711,"repoUrl":1712,"updatedAt":1713},"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},[1702,1705,1708],{"name":1703,"slug":1704,"type":15},"Containers","containers",{"name":1706,"slug":1707,"type":15},"Deployment","deployment",{"name":1709,"slug":1710,"type":15},"Python","python",17049,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FMegatron-LM","2026-07-27T06:06:11.249662",{"slug":1715,"name":1715,"fn":1716,"description":1717,"org":1718,"tags":1719,"stars":1711,"repoUrl":1712,"updatedAt":1724},"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},[1720,1723],{"name":1721,"slug":1722,"type":15},"CI\u002FCD","ci-cd",{"name":1706,"slug":1707,"type":15},"2026-07-14T05:25:59.97109",{"slug":1726,"name":1726,"fn":1727,"description":1728,"org":1729,"tags":1730,"stars":1711,"repoUrl":1712,"updatedAt":1736},"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},[1731,1732,1733],{"name":1721,"slug":1722,"type":15},{"name":1706,"slug":1707,"type":15},{"name":1734,"slug":1735,"type":15},"GitHub","github","2026-07-27T06:06:12.278222",{"slug":1738,"name":1738,"fn":1739,"description":1740,"org":1741,"tags":1742,"stars":1711,"repoUrl":1712,"updatedAt":1750},"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},[1743,1746,1747],{"name":1744,"slug":1745,"type":15},"Debugging","debugging",{"name":1734,"slug":1735,"type":15},{"name":1748,"slug":1749,"type":15},"Triage","triage","2026-07-14T05:25:57.442089",{"slug":1752,"name":1752,"fn":1753,"description":1754,"org":1755,"tags":1756,"stars":1711,"repoUrl":1712,"updatedAt":1763},"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},[1757,1760],{"name":1758,"slug":1759,"type":15},"Best Practices","best-practices",{"name":1761,"slug":1762,"type":15},"Code Analysis","code-analysis","2026-07-14T05:25:56.18433",{"slug":1765,"name":1765,"fn":1766,"description":1767,"org":1768,"tags":1769,"stars":1711,"repoUrl":1712,"updatedAt":1777},"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},[1770,1773,1776],{"name":1771,"slug":1772,"type":15},"Machine Learning","machine-learning",{"name":1774,"slug":1775,"type":15},"Migration","migration",{"name":9,"slug":8,"type":15},"2026-07-17T06:07:11.777011",{"slug":1779,"name":1779,"fn":1780,"description":1781,"org":1782,"tags":1783,"stars":1711,"repoUrl":1712,"updatedAt":1790},"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},[1784,1787],{"name":1785,"slug":1786,"type":15},"QA","qa",{"name":1788,"slug":1789,"type":15},"Testing","testing","2026-07-14T05:25:53.673039",{"slug":1792,"name":1792,"fn":1793,"description":1794,"org":1795,"tags":1796,"stars":1711,"repoUrl":1712,"updatedAt":1801},"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},[1797,1798],{"name":1706,"slug":1707,"type":15},{"name":1799,"slug":1800,"type":15},"Infrastructure","infrastructure","2026-07-14T05:25:49.362534",{"slug":1803,"name":1803,"fn":1804,"description":1805,"org":1806,"tags":1807,"stars":1711,"repoUrl":1712,"updatedAt":1815},"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},[1808,1811,1812],{"name":1809,"slug":1810,"type":15},"Code Review","code-review",{"name":1734,"slug":1735,"type":15},{"name":1813,"slug":1814,"type":15},"Pull Requests","pull-requests","2026-07-14T05:26:01.226578",{"slug":1817,"name":1817,"fn":1818,"description":1819,"org":1820,"tags":1821,"stars":1711,"repoUrl":1712,"updatedAt":1824},"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},[1822,1823],{"name":1785,"slug":1786,"type":15},{"name":1788,"slug":1789,"type":15},"2026-07-14T05:25:54.928983",{"slug":1826,"name":1826,"fn":1827,"description":1828,"org":1829,"tags":1830,"stars":1711,"repoUrl":1712,"updatedAt":1835},"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},[1831,1834],{"name":1832,"slug":1833,"type":15},"Automation","automation",{"name":1721,"slug":1722,"type":15},"2026-07-30T05:29:03.275638",496,{"items":1838,"total":1932},[1839,1854,1864,1878,1888,1903,1918],{"slug":1840,"name":1840,"fn":1841,"description":1842,"org":1843,"tags":1844,"stars":23,"repoUrl":24,"updatedAt":1853},"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},[1845,1848,1851,1852],{"name":1846,"slug":1847,"type":15},"Data Analysis","data-analysis",{"name":1849,"slug":1850,"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":1855,"name":1855,"fn":1856,"description":1857,"org":1858,"tags":1859,"stars":23,"repoUrl":24,"updatedAt":1863},"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},[1860,1861,1862],{"name":1706,"slug":1707,"type":15},{"name":1799,"slug":1800,"type":15},{"name":9,"slug":8,"type":15},"2026-07-14T05:29:06.667109",{"slug":1865,"name":1865,"fn":1866,"description":1867,"org":1868,"tags":1869,"stars":23,"repoUrl":24,"updatedAt":1877},"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},[1870,1873,1874],{"name":1871,"slug":1872,"type":15},"Agents","agents",{"name":9,"slug":8,"type":15},{"name":1875,"slug":1876,"type":15},"Research","research","2026-07-14T05:28:06.816956",{"slug":1879,"name":1879,"fn":1880,"description":1881,"org":1882,"tags":1883,"stars":23,"repoUrl":24,"updatedAt":1887},"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},[1884,1885,1886],{"name":1846,"slug":1847,"type":15},{"name":9,"slug":8,"type":15},{"name":1788,"slug":1789,"type":15},"2026-07-17T05:29:03.913266",{"slug":1889,"name":1889,"fn":1890,"description":1891,"org":1892,"tags":1893,"stars":23,"repoUrl":24,"updatedAt":1902},"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},[1894,1895,1898,1899],{"name":1832,"slug":1833,"type":15},{"name":1896,"slug":1897,"type":15},"Imaging","imaging",{"name":9,"slug":8,"type":15},{"name":1900,"slug":1901,"type":15},"Video","video","2026-07-17T05:28:53.905004",{"slug":1904,"name":1904,"fn":1905,"description":1906,"org":1907,"tags":1908,"stars":23,"repoUrl":24,"updatedAt":1917},"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},[1909,1910,1913,1914],{"name":1706,"slug":1707,"type":15},{"name":1911,"slug":1912,"type":15},"Docker","docker",{"name":9,"slug":8,"type":15},{"name":1915,"slug":1916,"type":15},"Operations","operations","2026-07-17T05:28:56.913999",{"slug":1919,"name":1919,"fn":1920,"description":1921,"org":1922,"tags":1923,"stars":23,"repoUrl":24,"updatedAt":1931},"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},[1924,1925,1928],{"name":9,"slug":8,"type":15},{"name":1926,"slug":1927,"type":15},"Quantum Computing","quantum-computing",{"name":1929,"slug":1930,"type":15},"Simulation","simulation","2026-07-14T05:26:58.898253",305]