DOCA SPCX Congestion-Control Tool
Examples
- "Should I use SPCX or
doca-pcc for a custom CC
algorithm?" — this is in scope. Walk the decision tree
before loading anything on a live fabric.
- "SPCX loaded but throughput did not change." — confirm
the algorithm is in charge before retuning parameters.
Instructions
Follow Loading order below. Open the tasks companion for
configure / run. Open the capabilities companion for the
SPCX-vs-PCC tradeoff and safety. Do not open every companion
file.
Where to start: This is a tool skill for invoking
doca_spcx_cc — the host-side CLI that exercises
an SPC-X congestion-control algorithm on a
live RDMA / RoCE fabric driven by a BlueField with a DPA
processor. Open the tasks companion and start at
## configure for the
SPCX-vs-PCC-vs-factory-firmware decision tree (load-bearing
gate before any code), the role decision (RP / NP), the
DPA-side algorithm authoring vs consumption split, and the
live-link / contention precondition. Open
the capabilities companion when the question is
what does SPCX let me express that doca-pcc does not,
what is the SPCX-vs-PCC tradeoff, what runtime metrics
does the tool surface, or what is the safety posture for
loading a custom CC algorithm on a production fabric. If
DOCA is not installed yet, route to
doca-setup/SKILL.md first.
This skill covers the SPC-X CC tool.
doca-pcc/SKILL.md is the established
PCC story; SPCX is the documented extension that authors
SPCX-class algorithms on the same DPA hardware substrate.
The zero-touch RTT-based CC algorithm (ZTR-RTT) is one
NVIDIA reference algorithm that can be loaded through either the PCC or SPCX path
depending on the install and the user's algorithm choice;
the agent surfaces this decision tree explicitly per
the capabilities companion.
Example questions this skill answers well
The CLASSES of doca_spcx_cc questions this skill is built
to answer, each with one worked example. The class is the
load-bearing piece; the worked example is one instance.
- "Should I use SPCX or
doca-pcc for my custom CC
algorithm?" — worked example: "I want to write a new
RTT-based congestion-control algorithm for my RoCE
fabric — which surface do I target?". Answered by the
SPCX-vs-PCC-vs-factory-firmware decision tree in
the capabilities companion
- the
"is SPCX the right surface on this install?" gate in
the tasks companion step 1.
- "How do I evaluate my authored SPCX algorithm on a
real RDMA link before letting it touch production?" —
worked example: "I have a DPACC-compiled SPCX algorithm
and a non-prod BlueField pair; how do I run a
contention-positive evaluation?". Answered by the
authoring vs consumption split + the live-link
precondition in
the capabilities companion
- the replica-first evaluation flow in
the tasks companion.
- "My SPCX algorithm appears to load cleanly but the
link's throughput / latency curve is unchanged — what's
going on?" — worked example: "the host-side
doca_pcc --status reports Active and a stable session, but my
RoCE flows look unchanged". Answered by the live-link /
contention rule in
the capabilities companion
- the
"algorithm has no signal under no contention"
guidance in
the tasks companion +
the tasks companion (route through
the layered error taxonomy before blaming the
algorithm).
No contention → no signal → no conclusion. Active plus an
unchanged traffic curve is not evidence that the algorithm failed
to take over from factory CC. A CC algorithm has no observable
behaviour without actual contention on the fabric, so an idle-link
or contention-absent run is uninformative by construction — it
supports no verdict in either direction. Establish that the run
actually generated contention before concluding anything, and never
declare an algorithm either broken or safe on such a run. Rule in
the capabilities companion.
- "My SPCX algorithm passed replica testing — what's
the gate before I roll it forward to production?" —
worked example: "my CC algorithm works on the two
BlueField pairs in the lab; can I push it to the
fleet?". Answered by the safety overlay in
the capabilities companion
(heavily cross-linked to
doca-hardware-safety/SKILL.md):
blast-radius bounded, observability gate proven, OOB
reachable, factory-PCC rollback rehearsed, escalation
path documented before any production cutover.
- "Is
doca_spcx_cc on my install, and is it paired
with the matching doca-pcc library and DPACC compiler
version?" — worked example: "is the SPCX surface
available on my DOCA install?". Answered by the
version-overlay in
the capabilities companion,
which redirects to the canonical
doca-version/SKILL.md chain
and adds the tool ↔ doca-pcc library ↔ DPACC
compiler ↔ firmware custom-PCC slot match rule.
- "My SPCX session errored — is it the tool, the
algorithm, the device, or the firmware?" — worked
example: "
doca_spcx_cc exits with
DOCA_PCC_PS_ERROR on start". Answered by the
layered error taxonomy in
the capabilities companion
- the layered walk in
the tasks companion.
Audience
This skill serves external developers, platform
operators, and AI agents authoring, loading, and
evaluating an SPC-X congestion-control
algorithm on a BlueField with a DPA processor, against a
live RDMA / RoCE fabric. Concretely:
- A CC researcher / developer who has authored an
SPCX-class DPA-side algorithm (or who is consuming a
documented shipped reference such as the zero-touch
RTT-based algorithm via
the ZTR-RTT CC documentation via
doca-public-knowledge-map
on the SPCX path when the install + algorithm support
it) and needs the operator-side harness to load,
parameterize, start, observe, and stop the algorithm.
- A platform operator running a programmable-CC pilot
on a non-prod RDMA fabric to characterise the
algorithm's behaviour under controlled contention.
- An AI agent producing a "is this SPCX algorithm safe
to roll forward" answer honestly — with evidence
from a contention-positive evaluation, a documented
rollback to the factory PCC, and an explicit blast-
radius bound — instead of a guess from datasheet
prose.
It is not for users debugging the doca_spcx_cc
binary itself, not a substitute for the live public
DOCA SPCX / DOCA PCC programming guides, not the
right place for the DPA-side algorithm authoring detail
(that path goes through the public DOCA PCC programming guide and the
doca-pcc/SKILL.md +
doca-dpa/SKILL.md skills), and
not the right place for default factory PCC
configuration (no host-side library or SPCX tool needed;
route via
doca-public-knowledge-map/SKILL.md).
The tool is shipped as a CLI binary under
/opt/mellanox/doca/tools/, not a library you link
against; it uses the same kind: tool three-file
shape as the rest of the bundle.
Language scope
doca_spcx_cc is a C host-side CLI that links the
host-side doca-pcc/SKILL.md
library and loads a DPA-side SPCX algorithm image built
by the DPACC compiler. The algorithm body is a separate
DPA-side translation unit written in the language DPACC
accepts. The skill keeps workflow guidance
language-neutral and routes per-language questions to
the public DOCA PCC / DPACC guides via
doca-public-knowledge-map/SKILL.md.
When to load this skill
Load this skill when the user is — or the agent needs to
— invoke doca_spcx_cc on a real host with DOCA
installed, paired with a BlueField that has its DPA
processor exposed AND the firmware custom-PCC slot
enabled, against a port carrying RDMA / RoCE traffic with
actual contention. Concretely:
- Loading an authored SPCX algorithm (or a documented
shipped reference) onto the BlueField via the SPCX
surface, parameterizing it, starting it, and observing
its effect on the live link.
- Evaluating an SPCX algorithm on a non-prod replica
before any production rollout — capturing the
contention-positive run as evidence.
- Comparing SPCX vs
doca-pcc paths for the same
algorithm class on the same install (where both paths
are available) and deciding which to commit to.
- Producing a "safe to roll forward" recommendation
with the documented evidence + rollback plan, or
refusing the recommendation when the evidence /
rollback is missing per
the capabilities companion.
- Diagnosing a
DOCA_PCC_PS_ERROR or a silent-no-effect
symptom against the layered error taxonomy.
Do not load this skill for general DOCA orientation,
DPA-side algorithm authoring detail, raw cycle profiling
of the DPA, the factory PCC algorithm shipped in the
firmware, or DOCA install. For those, route to
doca-public-knowledge-map/SKILL.md,
doca-pcc/SKILL.md,
doca-dpa/SKILL.md, or
doca-setup/SKILL.md.
What this skill provides
This is a thin loader. Substantive material lives
in two companion files:
- the capabilities companion — what SPCX expresses that PCC does
not (and where the surfaces overlap), the
SPCX-vs-PCC-vs-factory-firmware decision tree, the
authoring vs consumption split, the role decision
(RP / NP), the documented probe-packet format axis,
the live-link / contention precondition rule (the
load-bearing safety invariant — "a CC algorithm has
no signal under no contention"), the runtime
observability surface (per-port / per-flow trace
formats + the host-side status surface), the
triple-axis precondition rule
(
doca-pcc/SKILL.md: DPA-capable
BlueField + firmware custom-PCC slot enabled +
doca_pcc_cap_* agreement) extended with SPCX-specific
availability, the version overlay (tool ↔ library ↔
DPACC ↔ firmware), the layered error taxonomy
(install / device-binding / fw-slot / DPA-image /
algorithm-precondition / live-link-precondition /
runtime / version / cross-cutting), the observability
surface, and the heavily-overlaid safety posture (a
wrong CC algorithm on production can melt the
fabric).
- the tasks companion — step-by-step workflows for the in-scope
task verbs:
install (host-side DOCA install + DPA
prerequisites + firmware custom-PCC slot), configure
(SPCX-vs-PCC decision + role + algorithm + parameters
- probe-packet format),
build (route to install —
the host-side tool is shipped; the DPA-side algorithm
is user-built by DPACC), modify (refuse — do not
patch the binary; modify the invocation, algorithm,
and parameters), run (the
prepare → smoke → contention-positive evaluation
flow), test (iterative loop on the replica before
production), debug (walk the error taxonomy),
use (the "safe to roll forward" decision with
evidence + rollback + escalation), plus a Deferred task verbs block.
The skill assumes a host where DOCA is already
installed, a BlueField with a DPA processor and the
firmware-level custom-PCC slot enabled is present and
visible, the DPACC compiler is installed at a version
matched to the host-side DOCA, the user already knows
how (at sketch level) to write the DPA-side SPCX
algorithm (or has a shipped reference algorithm to
consume), and a non-prod RDMA / RoCE fabric with
controllable contention is available for evaluation.
What this skill deliberately does not ship
This skill is agent guidance, not a samples or
scripts bundle. To keep the boundary clean, it
deliberately does not contain — and pull requests
should not add:
- A specific congestion-control algorithm. SPCX
loads an algorithm the user supplies; the skill
refuses to invent algorithm bodies and routes any
"what algorithm should I write" question to the
public DOCA PCC programming guide and
to the user's own domain expertise.
- Pre-baked example output (throughput / latency
curves, per-flow counter snapshots). Output is
device-, firmware-, fabric-topology-, and
workload-specific; pinning one would mislead
operators elsewhere.
- Flag strings, subcommand names, probe-packet format tokens,
or metric names beyond the DOCA release notes and
--help.
This surface still evolves; the installed --help is the
authoritative inventory.
- Wrappers, parsers, or scripts consuming the tool's output.
The format is documented; script against your installed
version using the release notes.
- A tuning recommendation derived from a single observation.
CC tuning on a live fabric is high-stakes: the skill prescribes
how to capture evidence and compare against the factory PCC
baseline, and refuses to turn one observation into a
parameter change without the user's own domain analysis.
- A
samples/ or reference/ subtree. This is
a thin loader for a shipped CLI; substantive
material lives in the release notes, in --help,
and in
doca-pcc/SKILL.md +
doca-dpa/SKILL.md.
Loading order
- Read this skill first to confirm the user's
question is in scope (SPCX-side custom CC work,
not factory firmware PCC, not raw DPA cycle
profiling, and not algorithm authoring detail).
- For the SPCX-vs-PCC decision tree, the authoring
vs consumption split, the live-link precondition,
the version overlay, the error taxonomy, the
observability surface, and the safety posture,
see the capabilities companion.
- For the documented invocations and the
prepare → smoke → contention-positive evaluation
workflow —
install, configure, build,
modify, run, test, debug, use — see
the tasks companion.
Related skills
doca-pcc/SKILL.md — the host-side
Programmable Congestion Control library SPCX builds on and links.
The SPCX-vs-PCC decision tree in
the capabilities companion
is the load-bearing routing rule; conflating the two is the most
common programmable-CC first-touch error.
doca-dpa/SKILL.md — the DPA control
library the algorithm's DPA-side body builds on: kernel-launch
model, DPACC build flags, DPA-side comms / verbs.
doca-rdma/SKILL.md — the RDMA / RoCE
flows being controlled. Without traffic in flight and contention
on the fabric the algorithm has no signal; surface this
precondition before any evaluation.
doca-pcc-counters/SKILL.md — read-only
PCC counter inspection; the cheaper "is anything happening on
this port" step before or during an SPCX evaluation.
doca-hardware-safety/SKILL.md —
the bundle-wide hardware-safety meta-policy this skill's
## Safety policy layers on. Deploying a wrong CC algorithm on a
production fabric is a meta-policy STOP case.
doca-public-knowledge-map/SKILL.md
— routing to the public SPCX, PCC, and DPA / DPACC guides.
doca-version/SKILL.md — canonical DOCA
version handling. ## Version compatibility in
the capabilities companion adds the tool ↔ doca-pcc
↔ DPACC ↔ firmware custom-PCC slot matching rule.
doca-setup/SKILL.md — env preparation,
install and DPACC compiler verification, BlueField firmware
configuration (the custom-PCC slot is a firmware-level setting),
and the no install yet path via the public NGC DOCA container.
doca-debug/SKILL.md — the cross-cutting
debug ladder. Cross-link runtime evidence and counter snapshots
into a doca-debug session when the cause sits below DOCA.
doca-structured-tools-contract/SKILL.md
— the detect → prefer → fall back → report contract the command
appendix in the tasks companion honors.
doca-programming-guide/SKILL.md
— shared DOCA programming patterns, including the cross-library
DOCA_ERROR_* taxonomy this tool's error layer overlays.
The factory PCC algorithms inside ConnectX firmware are not in
scope: they work without doca_spcx_cc and are configured through
firmware knobs, not a host-side API. Route via
doca-public-knowledge-map/SKILL.md.
1---2license: Apache-2.03name: doca-spcx-cc4description: >5 Use this skill when the user is invoking `doca_spcx_cc` (the host-side6 CLI under /opt/mellanox/doca/tools/) to load, parameterize, start,7 observe, or stop an SPC-X congestion-control algorithm on8 a BlueField with a DPA processor against a live RDMA / RoCE fabric, or9 picking SPCX vs the established `doca-pcc` surface. Trigger even when10 the user does not say "DOCA SPCX" or "doca_spcx_cc" — typical implicit11 phrasings include "I want to write a custom RTT-based CC algorithm for12 my RoCE fabric", "my SPCX session loaded but throughput / latency13 didn't change", "doca_pcc status shows Active but factory CC seems to14 still be in charge", "DOCA_PCC_PS_ERROR on start", "is the15 programmable-CC surface available on my install", or "DPA-side16 algorithm image won't load". Refuse and route elsewhere for DPA-side17 algorithm authoring detail, factory PCC firmware configuration,18 read-only PCC counter inspection, raw DPA cycle profiling, RDMA19 library programming, or general DOCA install — those belong to other20 skills.21metadata:22 source: https://skillmd.com/skills/nvidia/doca-spcx-cc23 author: NVIDIA <doca-feedback@nvidia.com>24 kind: tool25 doca_version: "3.5"26 tags:27 - doca28 - pcc29 - spcx30compatibility: >31 Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu32 22.04/24.04 or RHEL/SLES) with the SPCX optional component, a33 BlueField exposing its DPA processor with the firmware custom-PCC slot34 enabled, the DPACC compiler installed and version-matched, and a35 non-prod RDMA / RoCE fabric with controllable contention reachable for36 evaluation. Probes via `pkg-config doca-pcc` and `doca_spcx_cc37 --help`. The validation steps require a live DOCA install.38---3940# DOCA SPCX Congestion-Control Tool4142## Examples4344- **"Should I use SPCX or `doca-pcc` for a custom CC45 algorithm?"** — this is in scope. Walk the decision tree46 before loading anything on a live fabric.47- **"SPCX loaded but throughput did not change."** — confirm48 the algorithm is in charge before retuning parameters.4950## Instructions5152Follow Loading order below. Open the tasks companion for53configure / run. Open the capabilities companion for the54SPCX-vs-PCC tradeoff and safety. Do not open every companion55file.5657**Where to start:** This is a tool skill for invoking58`doca_spcx_cc` — the host-side CLI that exercises59an SPC-X congestion-control algorithm on a60live RDMA / RoCE fabric driven by a BlueField with a DPA61processor. Open the tasks companion and start at62`## configure` for the63SPCX-vs-PCC-vs-factory-firmware decision tree (load-bearing64gate before any code), the role decision (RP / NP), the65DPA-side algorithm authoring vs consumption split, and the66live-link / contention precondition. Open67the capabilities companion when the question is68*what does SPCX let me express that `doca-pcc` does not*,69*what is the SPCX-vs-PCC tradeoff*, *what runtime metrics70does the tool surface*, or *what is the safety posture for71loading a custom CC algorithm on a production fabric*. If72DOCA is not installed yet, route to73`doca-setup/SKILL.md` first.7475This skill covers the **SPC-X CC tool**.76`doca-pcc/SKILL.md` is the established77PCC story; SPCX is the documented extension that authors78SPCX-class algorithms on the same DPA hardware substrate.79The zero-touch RTT-based CC algorithm (ZTR-RTT) is one80NVIDIA reference algorithm that can be loaded through either the PCC or SPCX path81depending on the install and the user's algorithm choice;82the agent surfaces this decision tree explicitly per83the capabilities companion.8485## Example questions this skill answers well8687The CLASSES of `doca_spcx_cc` questions this skill is built88to answer, each with one worked example. The class is the89load-bearing piece; the worked example is one instance.9091- **"Should I use SPCX or `doca-pcc` for my custom CC92 algorithm?"** — worked example: *"I want to write a new93 RTT-based congestion-control algorithm for my RoCE94 fabric — which surface do I target?"*. Answered by the95 SPCX-vs-PCC-vs-factory-firmware decision tree in96 the capabilities companion97 + the98 *"is SPCX the right surface on this install?"* gate in99 the tasks companion step 1.100- **"How do I evaluate my authored SPCX algorithm on a101 real RDMA link before letting it touch production?"** —102 worked example: *"I have a DPACC-compiled SPCX algorithm103 and a non-prod BlueField pair; how do I run a104 contention-positive evaluation?"*. Answered by the105 authoring vs consumption split + the live-link106 precondition in107 the capabilities companion108 + the replica-first evaluation flow in109 the tasks companion.110- **"My SPCX algorithm appears to load cleanly but the111 link's throughput / latency curve is unchanged — what's112 going on?"** — worked example: *"the host-side `doca_pcc113 --status` reports `Active` and a stable session, but my114 RoCE flows look unchanged"*. Answered by the live-link /115 contention rule in116 the capabilities companion117 + the118 *"algorithm has no signal under no contention"*119 guidance in120 the tasks companion +121 the tasks companion (route through122 the layered error taxonomy before blaming the123 algorithm).124125> **No contention → no signal → no conclusion.** `Active` plus an126> unchanged traffic curve is not evidence that the algorithm failed127> to take over from factory CC. A CC algorithm has no observable128> behaviour without actual contention on the fabric, so an idle-link129> or contention-absent run is uninformative by construction — it130> supports no verdict in either direction. Establish that the run131> actually generated contention before concluding anything, and never132> declare an algorithm either broken or safe on such a run. Rule in133> the capabilities companion.134- **"My SPCX algorithm passed replica testing — what's135 the gate before I roll it forward to production?"** —136 worked example: *"my CC algorithm works on the two137 BlueField pairs in the lab; can I push it to the138 fleet?"*. Answered by the safety overlay in139 the capabilities companion140 (heavily cross-linked to141 `doca-hardware-safety/SKILL.md`):142 blast-radius bounded, observability gate proven, OOB143 reachable, factory-PCC rollback rehearsed, escalation144 path documented before any production cutover.145- **"Is `doca_spcx_cc` on my install, and is it paired146 with the matching `doca-pcc` library and DPACC compiler147 version?"** — worked example: *"is the SPCX surface148 available on my DOCA install?"*. Answered by the149 version-overlay in150 the capabilities companion,151 which redirects to the canonical152 `doca-version/SKILL.md` chain153 and adds the *tool ↔ `doca-pcc` library ↔ DPACC154 compiler ↔ firmware custom-PCC slot* match rule.155- **"My SPCX session errored — is it the tool, the156 algorithm, the device, or the firmware?"** — worked157 example: *"`doca_spcx_cc` exits with158 `DOCA_PCC_PS_ERROR` on start"*. Answered by the159 layered error taxonomy in160 the capabilities companion161 + the layered walk in162 the tasks companion.163164## Audience165166This skill serves **external developers, platform167operators, and AI agents authoring, loading, and168evaluating an SPC-X congestion-control169algorithm on a BlueField with a DPA processor, against a170live RDMA / RoCE fabric**. Concretely:171172- A CC researcher / developer who has authored an173 SPCX-class DPA-side algorithm (or who is consuming a174 documented shipped reference such as the zero-touch175 RTT-based algorithm via176 the ZTR-RTT CC documentation via `doca-public-knowledge-map`177 on the SPCX path when the install + algorithm support178 it) and needs the operator-side harness to load,179 parameterize, start, observe, and stop the algorithm.180- A platform operator running a programmable-CC pilot181 on a non-prod RDMA fabric to characterise the182 algorithm's behaviour under controlled contention.183- An AI agent producing a *"is this SPCX algorithm safe184 to roll forward"* answer honestly — with evidence185 from a contention-positive evaluation, a documented186 rollback to the factory PCC, and an explicit blast-187 radius bound — instead of a guess from datasheet188 prose.189190It is **not** for users debugging the `doca_spcx_cc`191binary itself, **not** a substitute for the live public192DOCA SPCX / DOCA PCC programming guides, **not** the193right place for the DPA-side algorithm authoring detail194(that path goes through the public DOCA PCC programming guide and the195`doca-pcc/SKILL.md` +196`doca-dpa/SKILL.md` skills), and197**not** the right place for default factory PCC198configuration (no host-side library or SPCX tool needed;199route via200`doca-public-knowledge-map/SKILL.md`).201202The tool is shipped as a **CLI binary** under203`/opt/mellanox/doca/tools/`, not a library you link204against; it uses the same `kind: tool` three-file205shape as the rest of the bundle.206207## Language scope208209`doca_spcx_cc` is a C host-side CLI that links the210host-side `doca-pcc/SKILL.md`211library and loads a DPA-side SPCX algorithm image built212by the DPACC compiler. The algorithm body is a separate213DPA-side translation unit written in the language DPACC214accepts. The skill keeps workflow guidance215language-neutral and routes per-language questions to216the public DOCA PCC / DPACC guides via217`doca-public-knowledge-map/SKILL.md`.218219## When to load this skill220221Load this skill when the user is — or the agent needs to222— invoke `doca_spcx_cc` on a real host with DOCA223installed, paired with a BlueField that has its DPA224processor exposed AND the firmware custom-PCC slot225enabled, against a port carrying RDMA / RoCE traffic with226**actual contention**. Concretely:227228- Loading an authored SPCX algorithm (or a documented229 shipped reference) onto the BlueField via the SPCX230 surface, parameterizing it, starting it, and observing231 its effect on the live link.232- Evaluating an SPCX algorithm on a non-prod replica233 before any production rollout — capturing the234 contention-positive run as evidence.235- Comparing SPCX vs `doca-pcc` paths for the same236 algorithm class on the same install (where both paths237 are available) and deciding which to commit to.238- Producing a *"safe to roll forward"* recommendation239 with the documented evidence + rollback plan, or240 refusing the recommendation when the evidence /241 rollback is missing per242 the capabilities companion.243- Diagnosing a `DOCA_PCC_PS_ERROR` or a silent-no-effect244 symptom against the layered error taxonomy.245246Do **not** load this skill for general DOCA orientation,247DPA-side algorithm authoring detail, raw cycle profiling248of the DPA, the factory PCC algorithm shipped in the249firmware, or DOCA install. For those, route to250`doca-public-knowledge-map/SKILL.md`,251`doca-pcc/SKILL.md`,252`doca-dpa/SKILL.md`, or253`doca-setup/SKILL.md`.254255## What this skill provides256257This is a **thin loader**. Substantive material lives258in two companion files:259260- the capabilities companion — what SPCX expresses that PCC does261 not (and where the surfaces overlap), the262 SPCX-vs-PCC-vs-factory-firmware decision tree, the263 authoring vs consumption split, the role decision264 (RP / NP), the documented probe-packet format axis,265 the live-link / contention precondition rule (the266 load-bearing safety invariant — *"a CC algorithm has267 no signal under no contention"*), the runtime268 observability surface (per-port / per-flow trace269 formats + the host-side status surface), the270 triple-axis precondition rule271 (`doca-pcc/SKILL.md`: DPA-capable272 BlueField + firmware custom-PCC slot enabled +273 `doca_pcc_cap_*` agreement) extended with SPCX-specific274 availability, the version overlay (tool ↔ library ↔275 DPACC ↔ firmware), the layered error taxonomy276 (install / device-binding / fw-slot / DPA-image /277 algorithm-precondition / live-link-precondition /278 runtime / version / cross-cutting), the observability279 surface, and the heavily-overlaid safety posture (a280 wrong CC algorithm on production can melt the281 fabric).282- the tasks companion — step-by-step workflows for the in-scope283 task verbs: `install` (host-side DOCA install + DPA284 prerequisites + firmware custom-PCC slot), `configure`285 (SPCX-vs-PCC decision + role + algorithm + parameters286 + probe-packet format), `build` (route to install —287 the host-side tool is shipped; the DPA-side algorithm288 is user-built by DPACC), `modify` (refuse — do not289 patch the binary; modify the invocation, algorithm,290 and parameters), `run` (the291 prepare → smoke → contention-positive evaluation292 flow), `test` (iterative loop on the replica before293 production), `debug` (walk the error taxonomy),294 `use` (the *"safe to roll forward"* decision with295 evidence + rollback + escalation), plus a `Deferred296 task verbs` block.297298The skill assumes a host where DOCA is already299installed, a BlueField with a DPA processor and the300firmware-level custom-PCC slot enabled is present and301visible, the DPACC compiler is installed at a version302matched to the host-side DOCA, the user already knows303how (at sketch level) to write the DPA-side SPCX304algorithm (or has a shipped reference algorithm to305consume), and a non-prod RDMA / RoCE fabric with306controllable contention is available for evaluation.307308## What this skill deliberately does not ship309310This skill is **agent guidance**, not a samples or311scripts bundle. To keep the boundary clean, it312deliberately does not contain — and pull requests313should not add:314315- **A specific congestion-control algorithm.** SPCX316 *loads* an algorithm the user supplies; the skill317 refuses to invent algorithm bodies and routes any318 *"what algorithm should I write"* question to the319 public DOCA PCC programming guide and320 to the user's own domain expertise.321- **Pre-baked example output** (throughput / latency322 curves, per-flow counter snapshots). Output is323 device-, firmware-, fabric-topology-, and324 workload-specific; pinning one would mislead325 operators elsewhere.326- **Flag strings, subcommand names, probe-packet format tokens,327 or metric names beyond the DOCA release notes and `--help`.**328 This surface still evolves; the installed `--help` is the329 authoritative inventory.330- **Wrappers, parsers, or scripts** consuming the tool's output.331 The format is documented; script against your installed332 version using the release notes.333- **A tuning recommendation derived from a single observation.**334 CC tuning on a live fabric is high-stakes: the skill prescribes335 how to *capture evidence and compare against the factory PCC336 baseline*, and refuses to turn one observation into a337 parameter change without the user's own domain analysis.338- **A `samples/` or `reference/` subtree.** This is339 a thin loader for a shipped CLI; substantive340 material lives in the release notes, in `--help`,341 and in342 `doca-pcc/SKILL.md` +343 `doca-dpa/SKILL.md`.344345## Loading order3463471. Read this skill first to confirm the user's348 question is in scope (SPCX-side custom CC work,349 not factory firmware PCC, not raw DPA cycle350 profiling, and not algorithm authoring detail).3512. **For the SPCX-vs-PCC decision tree, the authoring352 vs consumption split, the live-link precondition,353 the version overlay, the error taxonomy, the354 observability surface, and the safety posture,355 see the capabilities companion.**3563. **For the documented invocations and the357 prepare → smoke → contention-positive evaluation358 workflow — `install`, `configure`, `build`,359 `modify`, `run`, `test`, `debug`, `use` — see360 the tasks companion.**361362## Related skills363364- `doca-pcc/SKILL.md` — the host-side365 Programmable Congestion Control library SPCX builds on and links.366 The SPCX-vs-PCC decision tree in367 the capabilities companion368 is the load-bearing routing rule; conflating the two is the most369 common programmable-CC first-touch error.370- `doca-dpa/SKILL.md` — the DPA control371 library the algorithm's DPA-side body builds on: kernel-launch372 model, DPACC build flags, DPA-side comms / verbs.373- `doca-rdma/SKILL.md` — the RDMA / RoCE374 flows being controlled. Without traffic in flight *and contention375 on the fabric* the algorithm has no signal; surface this376 precondition before any evaluation.377- `doca-pcc-counters/SKILL.md` — read-only378 PCC counter inspection; the cheaper *"is anything happening on379 this port"* step before or during an SPCX evaluation.380- `doca-hardware-safety/SKILL.md` —381 the bundle-wide hardware-safety meta-policy this skill's382 `## Safety policy` layers on. Deploying a wrong CC algorithm on a383 production fabric is a *meta-policy STOP* case.384- `doca-public-knowledge-map/SKILL.md`385 — routing to the public SPCX, PCC, and DPA / DPACC guides.386- `doca-version/SKILL.md` — canonical DOCA387 version handling. `## Version compatibility` in388 the capabilities companion adds the *tool ↔ `doca-pcc`389 ↔ DPACC ↔ firmware custom-PCC slot* matching rule.390- `doca-setup/SKILL.md` — env preparation,391 install and DPACC compiler verification, BlueField firmware392 configuration (the custom-PCC slot is a firmware-level setting),393 and the *no install yet* path via the public NGC DOCA container.394- `doca-debug/SKILL.md` — the cross-cutting395 debug ladder. Cross-link runtime evidence and counter snapshots396 into a `doca-debug` session when the cause sits below DOCA.397- `doca-structured-tools-contract/SKILL.md`398 — the detect → prefer → fall back → report contract the command399 appendix in the tasks companion honors.400- `doca-programming-guide/SKILL.md`401 — shared DOCA programming patterns, including the cross-library402 `DOCA_ERROR_*` taxonomy this tool's error layer overlays.403404The factory PCC algorithms inside ConnectX firmware are **not in405scope**: they work without `doca_spcx_cc` and are configured through406firmware knobs, not a host-side API. Route via407`doca-public-knowledge-map/SKILL.md`.