DOCA PCC ZTR RTTCC Algorithm
Where to start: This skill assumes DOCA is already
installed, the user's BlueField has a DPA processor that
the host can see through DOCA (a BlueField-3-generation
device per the README), the BlueField firmware has the
custom-PCC slot enabled, the DPACC compiler is installed at
a matched version per the DOCA Compatibility Policy, and the
user is doing hands-on deployment of the DOCA-shipped ZTR
RTTCC reference algorithm on a BlueField port that
already carries RoCE-v2 traffic — i.e. either deploying it
as the no-config-required baseline, tuning its documented
parameters, or evaluating it against a custom algorithm the
user intends to write. Open TASKS.md if the
user wants to do something (install / configure / build /
modify / run / test / debug / use); open
CAPABILITIES.md when the question is
what does the algorithm express, what are its variants and
parameters, what does it ship vs not ship. If the user has
not installed DOCA yet, route to
doca-setup first; if the user
has not stood up the host-side doca-pcc framework yet,
route to doca-pcc first (this
algorithm is a library consumed by the PCC framework, not
a standalone program); if the user only wants to inspect
PCC counters at runtime without changing the running
algorithm, route to
doca-pcc-counters;
if the user wants to write their own algorithm from
scratch, that is the doca-pcc library plus the public
PCC programming guide — this skill is for the shipped
reference algorithm specifically.
Example questions this skill answers well
The CLASSES of ZTR RTTCC questions this skill is built to
answer, each with one worked example. The agent should
treat the class as the load-bearing piece — the worked
example is a single instance.
- "Is the ZTR RTTCC reference algorithm the right
baseline for my deployment, or should I write a custom
algorithm?" — worked example: "I have a BlueField-3
carrying production RoCE-v2 traffic from a GPU cluster;
is the shipped algorithm a fine default or do I need
custom logic?". Answered by the decision rule in
CAPABILITIES.md ## Capabilities and modes
("when to use the reference vs custom") + the env
preconditions in
TASKS.md ## install.
- "How do I wire the shipped algorithm into the DOCA
PCC application that's already running on my host?" —
worked example: "
/opt/mellanox/doca/applications/pcc
is already building from sample sources; what do I
change so the user algo callback dispatches to
doca_pcc_dev_ztr_rttcc_algo under a chosen algo
slot?". Answered by the integration sequence in
CAPABILITIES.md ## Capabilities and modes
- the in-place edits in
TASKS.md ## modify.
- "Which variant of the algorithm am I getting — vanilla
RTT-CC, path-migration mode, RX-rate mode, multipath,
multipath with credits, window-probeless?" — worked
example: "the shipped library exposes one public
symbol
doca_pcc_dev_ztr_rttcc_algo but the device-
side source ships several variants; how do I know
which one I get and how do I pick another?".
Answered by the variants table in
CAPABILITIES.md ## Capabilities and modes.
- "How do I confirm the algorithm is actually
modulating my RDMA / RoCE traffic, and not just
loading?" — worked example: "I followed the
integration steps; the application starts; how do I
know the algorithm is shaping flows under load?".
Answered by the observability surface in
CAPABILITIES.md ## Observability
- "Which tunables does the algorithm expose, and how
do I change them from the host without rebuilding the
DPA-side image?" — worked example: "my workload is
more latency-sensitive than the default profile assumes
— which parameter knob do I adjust?". Answered by
the parameter surface in
CAPABILITIES.md ## Capabilities and modes
- the
doca_pcc_dev_set_ztr_rttcc_params workflow in
TASKS.md ## use.
- "What does this
DOCA_PCC_DEV_STATUS_FAIL or
DOCA_ERROR_* from a doca_pcc_dev_ztr_rttcc_* call
mean and which layer caused it?" — worked example:
"my init callback returns DOCA_PCC_DEV_STATUS_FAIL
on first launch". Answered by the algorithm overlay
on the host-side PCC taxonomy in
CAPABILITIES.md ## Error taxonomy
Audience
This skill serves external developers operating a
BlueField-3-class DPU who want to deploy NVIDIA's shipped
reference PCC algorithm on RoCE-v2 traffic, OR who are
evaluating it against a custom algorithm they intend to
write. The reference algorithm is zero-touch by design
— the no-config-required baseline — and the canonical use
case is dropping it onto a port and confirming it shapes
flows correctly under congestion. It is not for NVIDIA
developers contributing to the algorithm itself, nor for
users who want general PCC programming theory (route via
the public DOCA PCC programming guide), nor for users who
only want to inspect PCC counters (route to
doca-pcc-counters).
Language scope. The algorithm ships as a DPA-side
library (pkg-config module doca-pcc-ztr-rttcc-algo)
plus a public header doca_pcc_dev_ztr_rttcc_algo.h that
DPA-side translation units include. The shipped algorithm
binary is the static library
libdoca_pcc_ztr_rttcc_algo_dev.a per the README; the
device-side translation unit that consumes it is C and is
compiled by DPACC. The host-side that drives the PCC
context comes from doca-pcc;
this library does NOT add a host-side surface beyond the
host-side helpers (also shipped as
libdoca_pcc_ztr_rttcc_algo.{a,so} per the README) that
the doca-pcc framework links. Other-language host-side
wrappers around doca-pcc can drive this algorithm through
the same lifecycle described in doca-pcc; the DPA-side
integration always stays C-via-DPACC.
When to load this skill
Load this skill when the user is doing hands-on deployment,
tuning, or evaluation of the DOCA-shipped ZTR RTTCC
reference algorithm on a BlueField port carrying RoCE-v2
traffic, in any host language plus the DPA-side translation
unit built by dpacc. Concretely:
- Deciding whether the shipped algorithm is the right
baseline for the user's RoCE-v2 workload, or whether the
user needs a custom algorithm.
- Wiring the algorithm into the DOCA PCC sample
application by patching the user-algo / user-init /
user-set-algo-params callbacks per the steps the
shipped README documents.
- Picking which of the algorithm's documented variants
(vanilla, path-migration, RX-rate, RX-rate + PM,
multipath, multipath + credits, window-probeless)
matches the user's intent — and surfacing that the
public surface only ships one symbol
(
doca_pcc_dev_ztr_rttcc_algo); the variants live in
the DPA-side source the user compiles against.
- Tuning the host-set parameters the algorithm exposes
(per the parameter list in
doca_pcc_dev_ztr_rttcc_algo.h and the shipped
doca_pcc_dev_set_ztr_rttcc_params).
- Observing whether the running algorithm is actually
modulating RoCE-v2 flows under load (route to
doca-pcc-counters
for the read-only inspection side).
- Deciding when to replace the shipped algorithm with a
custom one because latency target, fairness policy, or
convergence behavior requirements diverge from what the
reference provides.
Do not load this skill for general DOCA orientation;
for the host-side doca-pcc lifecycle (route to
doca-pcc); for writing a custom
algorithm from scratch (route to
doca-pcc and the public PCC
programming guide via
doca-public-knowledge-map);
for read-only PCC counter inspection (route to
doca-pcc-counters);
or for the default firmware-shipped PCC algorithms that
predate Programmable Congestion Control entirely (no
host-side code, no DPACC compile — that is a firmware-only
path routed via
doca-public-knowledge-map).
What this skill provides
This is a thin loader. The body keeps only the
orientation needed to pick the right next file. The
substantive algorithm-specific material lives in two
companion files:
CAPABILITIES.md — what the shipped ZTR RTTCC
algorithm expresses on this version + this BlueField
generation + this firmware: the public DPA-side API
surface (doca_pcc_dev_ztr_rttcc_init,
doca_pcc_dev_ztr_rttcc_algo,
doca_pcc_dev_set_ztr_rttcc_params,
doca_pcc_dev_ztr_rttcc_get_param_num,
doca_pcc_dev_ztr_rttcc_get_counter_num,
doca_pcc_dev_ztr_rttcc_get_num_of_histograms), the
documented variants (vanilla / path-migration / RX-rate
/ multipath / window-probeless — pick one at
DPA-side compile time), the relationship to the
host-side doca-pcc framework (this is an algorithm
body the framework loads), the relationship to the
doca-pcc-counters tool (which is the canonical
inspection surface), the algorithm's parameter and
counter surface (RTT-based congestion signal,
per-feature parameter blocks), the error taxonomy in
DOCA_PCC_DEV_STATUS_OK / _FAIL, and the safety
policy.
TASKS.md — step-by-step workflows for the in-scope
algorithm verbs: install, configure, build,
modify, run, test, debug, use. Plus a
Deferred task verbs block that points out-of-scope
questions at the right next skill.
The skill assumes DOCA + the DPACC compiler + the
doca-pcc host-side framework are
already installed; the BlueField is a generation that
exposes the DPA processor (the algorithm runs on the DPA);
the BlueField firmware has the custom-PCC slot enabled
(inherited from
doca-pcc CAPABILITIES.md ## Safety policy);
and the BlueField port the algorithm will modulate has
RoCE-v2 traffic actually flowing on it (the algorithm
modulates existing RDMA / RoCE traffic — without traffic,
there is nothing for it to do).
What this skill deliberately does not ship
This skill is agent guidance, not a samples or templates
bundle. To keep the boundary clean, it deliberately does not
contain — and pull requests should not add:
- The algorithm body itself, in any language. The
shipped algorithm is the static library
libdoca_pcc_ztr_rttcc_algo_dev.a (plus the host-side
helpers) installed by the matching DOCA host package
per the README. The agent's job is to route the user to
the installed library and header
(doca_pcc_dev_ztr_rttcc_algo.h) and to prescribe the
in-place edits documented in the README on the
shipped DOCA PCC application source, not to author the
algorithm.
- A standalone PCC application. The DOCA PCC
application that hosts this algorithm is the shipped
C sample under
/opt/mellanox/doca/applications/pcc/ (per the
README). The agent's job is to prescribe the
minimum-diff modifications the README documents and to
walk the user through the rebuild — not to author a
parallel application.
- A description of every internal variant's
behavior. The DPA-side source ships several
variants (vanilla, path-migration, RX-rate, multipath,
multipath + credits, window-probeless). The agent
names the variant set, says which one is reachable via
the public symbol on this install, and routes
algorithm-design questions to the public PCC
programming guide via
doca-public-knowledge-map.
It does not redefine each variant's mathematical
behavior.
- A specific congestion-control algorithm tutorial.
Congestion-control theory, RoCE-v2 fairness analysis,
workload-specific tuning — out of scope. Route to the
user's own domain expertise and to the public DOCA PCC
guide.
Loading order
- Read this
SKILL.md first to confirm the user's
question is in scope (deployment / tuning / evaluation
of the shipped reference algorithm, not algorithm
design from scratch and not read-only counter
inspection).
- For the algorithm capability matrix, the public
DPA-side API surface, the variant set, the parameter
and counter surface, the host-side
doca-pcc
framework relationship, the
doca-pcc-counters inspection-side relationship, the
error taxonomy, the observability surface, and the
safety policy, see CAPABILITIES.md.
- For step-by-step workflows — install, configure,
build, modify, run, test, debug, use — see
TASKS.md.
Both companion files cross-link to each other,
doca-pcc for the host-side PCC
lifecycle that loads this algorithm,
doca-pcc-counters
for the read-only counter-inspection side of validating that
the algorithm is modulating traffic,
doca-dpa for the DPA-side
two-side-program model and the DPACC compiler discipline,
doca-version for the
canonical DOCA version-handling rules (with the DPACC
overlay inherited from
doca-dpa and
doca-pcc), and
doca-public-knowledge-map
whenever the right answer is "look it up in the public DOCA
PCC programming guide or the on-disk install layout".
Related skills
doca-pcc — the host-side PCC
control library. This algorithm is loaded INTO a
doca_pcc context that doca-pcc stands up; the
host-side lifecycle (doca_pcc create / configure /
start / stop / destroy, the algorithm image
doca_pcc_app, the attach-to-port semantics) is owned
by doca-pcc. This skill prescribes only the DPA-side
algorithm integration on top.
doca-pcc-counters —
the read-only diagnostic CLI for PCC counters at the
port. The canonical "is the algorithm actually
modulating traffic" check goes through the counter
tool; this skill names what counters the algorithm
emits (CNP / NACK / AI / HAI / decrement / RTT-band
counters per the public header) and routes the
inspection workflow to the tool skill.
doca-dpa — the host-side
DPA control library. The algorithm runs on the DPA,
compiled by DPACC; the two-side-program rule and the
DOCA-and-DPACC version-match overlay inherited from
here apply.
doca-public-knowledge-map —
the routing table for every public DOCA documentation
source (the DOCA PCC programming guide at
https://docs.nvidia.com/doca/sdk/doca-pcc/index.html;
the DOCA PCC application guide; the DOCA Compatibility
Policy) and the on-disk layout of an installed DOCA
package.
doca-setup — env
preparation, install verification, DPACC compiler
install / verification, BlueField firmware
configuration (including the custom-PCC slot enable),
and the I have no install yet path with the public
NGC DOCA container. This skill assumes its
preconditions are satisfied AND that DPACC is installed
at a version that matches DOCA AND that the firmware-
level custom-PCC slot is enabled.
doca-version —
canonical DOCA version-handling rules. This skill's
## Version compatibility cross-links the four-way
match rule plus the DOCA-and-DPACC overlay inherited
from doca-pcc.
doca-structured-tools-contract —
the bundle's structured-tools precedence rule (detect /
prefer / fall back / report). The Command appendix in
TASKS.md honors this contract.
doca-programming-guide —
general DOCA programming patterns. This skill layers
algorithm-specific overlays on top of the universal
build, modify-a-shipped-sample, and Core lifecycle
patterns.
doca-debug — cross-cutting
debug ladder. Algorithm-specific debug (the algorithm
loaded but counters do not move; the algorithm fails to
initialize; the algorithm modulates traffic too
aggressively / too gently for the workload) overlays on
top of that ladder.
doca-hardware-safety —
cross-cutting hardware-safety meta-policy. Because the
algorithm modulates production RoCE-v2 flows on a
BlueField port, the meta-policy's pre-flight inventory,
replica-first, and rollback rules apply via this
skill's ## Safety policy overlay.
1---2license: Apache-2.03name: doca-pcc-ztr-rttcc-algo4description: >5 Use this skill when the user is doing hands-on deployment, tuning,6 or evaluation of the DOCA-shipped Zero-Touch RoCE RTT-based7 Congestion Control (ZTR RTTCC) reference algorithm on a BlueField-38 DPA — wiring `doca_pcc_dev_ztr_rttcc_algo` into the shipped DOCA9 PCC sample, picking a variant (vanilla / PM / RX-rate / multipath /10 window-probeless) at DPACC build time, tuning host-set parameters,11 or diagnosing `DOCA_PCC_DEV_STATUS_FAIL` from the algorithm.12 Trigger even when the user does not say 'DOCA PCC' or 'ZTR RTTCC' —13 typical implicit phrasings: 'my RoCE-v2 flows aren't being14 throttled', 'PCC sample isn't dispatching to my algo', 'how do I15 pick the multipath PCC variant', 'set-params returns fail',16 'algorithm loaded but counters are flat', or 'do I need a custom17 CC algorithm on BF3'. Refuse and route elsewhere for writing a18 custom PCC algorithm from scratch, read-only PCC counter19 inspection, the host-side `doca-pcc` lifecycle, or firmware-only20 pre-Programmable PCC — those belong to other skills.21metadata:22 source: https://skillmd.com/skills/nvidia/doca-pcc-ztr-rttcc-algo23 kind: library24compatibility: >25 Requires DOCA SDK installed at /opt/mellanox/doca on Linux (Ubuntu26 22.04/24.04 or RHEL/SLES) with a BlueField-3 DPU exposing the DPA27 processor, the firmware custom-PCC slot enabled, a matched-version28 DPACC compiler, and live RoCE-v2 traffic on the attached port.29 Reads `pkg-config doca-pcc-ztr-rttcc-algo` and inspects30 /opt/mellanox/doca/{lib,include,applications/pcc}.31---3233# DOCA PCC ZTR RTTCC Algorithm3435**Where to start:** This skill assumes DOCA is already36installed, the user's BlueField has a DPA processor that37the host can see through DOCA (a BlueField-3-generation38device per the README), the BlueField firmware has the39custom-PCC slot enabled, the DPACC compiler is installed at40a matched version per the DOCA Compatibility Policy, and the41user is doing **hands-on deployment of the DOCA-shipped ZTR42RTTCC reference algorithm** on a BlueField port that43already carries RoCE-v2 traffic — i.e. either deploying it44as the no-config-required baseline, tuning its documented45parameters, or evaluating it against a custom algorithm the46user intends to write. Open [`TASKS.md`](TASKS.md) if the47user wants to *do* something (install / configure / build /48modify / run / test / debug / use); open49[`CAPABILITIES.md`](CAPABILITIES.md) when the question is50*what does the algorithm express, what are its variants and51parameters, what does it ship vs not ship*. If the user has52not installed DOCA yet, route to53[`doca-setup`](../../doca-setup/SKILL.md) first; if the user54has not stood up the host-side `doca-pcc` framework yet,55route to [`doca-pcc`](../doca-pcc/SKILL.md) first (this56algorithm is a *library consumed by* the PCC framework, not57a standalone program); if the user only wants to *inspect*58PCC counters at runtime without changing the running59algorithm, route to60[`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md);61if the user wants to *write their own algorithm from62scratch*, that is the `doca-pcc` library plus the public63PCC programming guide — this skill is for the shipped64reference algorithm specifically.6566## Example questions this skill answers well6768The CLASSES of ZTR RTTCC questions this skill is built to69answer, each with one worked example. The agent should70treat the *class* as the load-bearing piece — the worked71example is a single instance.7273- **"Is the ZTR RTTCC reference algorithm the right74 baseline for my deployment, or should I write a custom75 algorithm?"** — worked example: *"I have a BlueField-376 carrying production RoCE-v2 traffic from a GPU cluster;77 is the shipped algorithm a fine default or do I need78 custom logic?"*. Answered by the decision rule in79 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)80 ("when to use the reference vs custom") + the env81 preconditions in82 [`TASKS.md ## install`](TASKS.md#install).83- **"How do I wire the shipped algorithm into the DOCA84 PCC application that's already running on my host?"** —85 worked example: *"`/opt/mellanox/doca/applications/pcc`86 is already building from sample sources; what do I87 change so the user algo callback dispatches to88 `doca_pcc_dev_ztr_rttcc_algo` under a chosen algo89 slot?"*. Answered by the integration sequence in90 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)91 + the in-place edits in92 [`TASKS.md ## modify`](TASKS.md#modify).93- **"Which variant of the algorithm am I getting — vanilla94 RTT-CC, path-migration mode, RX-rate mode, multipath,95 multipath with credits, window-probeless?"** — worked96 example: *"the shipped library exposes one public97 symbol `doca_pcc_dev_ztr_rttcc_algo` but the device-98 side source ships several variants; how do I know99 which one I get and how do I pick another?"*.100 Answered by the variants table in101 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes).102- **"How do I confirm the algorithm is actually103 modulating my RDMA / RoCE traffic, and not just104 loading?"** — worked example: *"I followed the105 integration steps; the application starts; how do I106 know the algorithm is shaping flows under load?"*.107 Answered by the observability surface in108 [`CAPABILITIES.md ## Observability`](CAPABILITIES.md#observability)109 + the counter-watch loop in110 [`TASKS.md ## test`](TASKS.md#test) which routes to111 [`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md).112- **"Which tunables does the algorithm expose, and how113 do I change them from the host without rebuilding the114 DPA-side image?"** — worked example: *"my workload is115 more latency-sensitive than the default profile assumes116 — which parameter knob do I adjust?"*. Answered by117 the parameter surface in118 [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)119 + the `doca_pcc_dev_set_ztr_rttcc_params` workflow in120 [`TASKS.md ## use`](TASKS.md#use).121- **"What does this `DOCA_PCC_DEV_STATUS_FAIL` or122 `DOCA_ERROR_*` from a `doca_pcc_dev_ztr_rttcc_*` call123 mean and which layer caused it?"** — worked example:124 *"my init callback returns `DOCA_PCC_DEV_STATUS_FAIL`125 on first launch"*. Answered by the algorithm overlay126 on the host-side PCC taxonomy in127 [`CAPABILITIES.md ## Error taxonomy`](CAPABILITIES.md#error-taxonomy)128 + the layered ladder in129 [`TASKS.md ## debug`](TASKS.md#debug) that escalates130 through131 [`doca-pcc`](../doca-pcc/SKILL.md) and132 [`doca-debug`](../../doca-debug/SKILL.md).133134## Audience135136This skill serves **external developers operating a137BlueField-3-class DPU who want to deploy NVIDIA's shipped138reference PCC algorithm on RoCE-v2 traffic, OR who are139evaluating it against a custom algorithm they intend to140write**. The reference algorithm is *zero-touch* by design141— the no-config-required baseline — and the canonical use142case is dropping it onto a port and confirming it shapes143flows correctly under congestion. It is *not* for NVIDIA144developers contributing to the algorithm itself, nor for145users who want general PCC programming theory (route via146the public DOCA PCC programming guide), nor for users who147only want to *inspect* PCC counters (route to148[`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md)).149150**Language scope.** The algorithm ships as a DPA-side151library (`pkg-config` module `doca-pcc-ztr-rttcc-algo`)152plus a public header `doca_pcc_dev_ztr_rttcc_algo.h` that153DPA-side translation units include. The shipped algorithm154binary is the static library155`libdoca_pcc_ztr_rttcc_algo_dev.a` per the README; the156device-side translation unit that consumes it is C and is157compiled by DPACC. The host-side that drives the PCC158context comes from [`doca-pcc`](../doca-pcc/SKILL.md);159this library does NOT add a host-side surface beyond the160host-side helpers (also shipped as161`libdoca_pcc_ztr_rttcc_algo.{a,so}` per the README) that162the `doca-pcc` framework links. Other-language host-side163wrappers around `doca-pcc` can drive this algorithm through164the same lifecycle described in `doca-pcc`; the DPA-side165integration always stays C-via-DPACC.166167## When to load this skill168169Load this skill when the user is doing hands-on deployment,170tuning, or evaluation of the DOCA-shipped ZTR RTTCC171reference algorithm on a BlueField port carrying RoCE-v2172traffic, in any host language plus the DPA-side translation173unit built by `dpacc`. Concretely:174175- Deciding whether the shipped algorithm is the right176 baseline for the user's RoCE-v2 workload, or whether the177 user needs a custom algorithm.178- Wiring the algorithm into the DOCA PCC sample179 application by patching the user-algo / user-init /180 user-set-algo-params callbacks per the steps the181 shipped README documents.182- Picking which of the algorithm's documented variants183 (vanilla, path-migration, RX-rate, RX-rate + PM,184 multipath, multipath + credits, window-probeless)185 matches the user's intent — and surfacing that the186 *public* surface only ships one symbol187 (`doca_pcc_dev_ztr_rttcc_algo`); the variants live in188 the DPA-side source the user compiles against.189- Tuning the host-set parameters the algorithm exposes190 (per the parameter list in191 `doca_pcc_dev_ztr_rttcc_algo.h` and the shipped192 `doca_pcc_dev_set_ztr_rttcc_params`).193- Observing whether the running algorithm is actually194 modulating RoCE-v2 flows under load (route to195 [`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md)196 for the read-only inspection side).197- Deciding when to *replace* the shipped algorithm with a198 custom one because latency target, fairness policy, or199 convergence behavior requirements diverge from what the200 reference provides.201202Do **not** load this skill for general DOCA orientation;203for the host-side `doca-pcc` lifecycle (route to204[`doca-pcc`](../doca-pcc/SKILL.md)); for writing a custom205algorithm from scratch (route to206[`doca-pcc`](../doca-pcc/SKILL.md) and the public PCC207programming guide via208[`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md));209for read-only PCC counter inspection (route to210[`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md));211or for the default firmware-shipped PCC algorithms that212predate Programmable Congestion Control entirely (no213host-side code, no DPACC compile — that is a firmware-only214path routed via215[`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md)).216217## What this skill provides218219This is a **thin loader**. The body keeps only the220orientation needed to pick the right next file. The221substantive algorithm-specific material lives in two222companion files:223224- `CAPABILITIES.md` — what the shipped ZTR RTTCC225 algorithm expresses on this version + this BlueField226 generation + this firmware: the public DPA-side API227 surface (`doca_pcc_dev_ztr_rttcc_init`,228 `doca_pcc_dev_ztr_rttcc_algo`,229 `doca_pcc_dev_set_ztr_rttcc_params`,230 `doca_pcc_dev_ztr_rttcc_get_param_num`,231 `doca_pcc_dev_ztr_rttcc_get_counter_num`,232 `doca_pcc_dev_ztr_rttcc_get_num_of_histograms`), the233 documented variants (vanilla / path-migration / RX-rate234 / multipath / window-probeless — pick one at235 DPA-side compile time), the relationship to the236 host-side `doca-pcc` framework (this is an algorithm237 body the framework loads), the relationship to the238 `doca-pcc-counters` tool (which is the canonical239 inspection surface), the algorithm's parameter and240 counter surface (RTT-based congestion signal,241 per-feature parameter blocks), the error taxonomy in242 `DOCA_PCC_DEV_STATUS_OK` / `_FAIL`, and the safety243 policy.244- `TASKS.md` — step-by-step workflows for the in-scope245 algorithm verbs: `install`, `configure`, `build`,246 `modify`, `run`, `test`, `debug`, `use`. Plus a247 `Deferred task verbs` block that points out-of-scope248 questions at the right next skill.249250The skill assumes DOCA + the DPACC compiler + the251[`doca-pcc`](../doca-pcc/SKILL.md) host-side framework are252already installed; the BlueField is a generation that253exposes the DPA processor (the algorithm runs on the DPA);254the BlueField firmware has the custom-PCC slot enabled255(inherited from256[`doca-pcc CAPABILITIES.md ## Safety policy`](../doca-pcc/CAPABILITIES.md#safety-policy));257and the BlueField port the algorithm will modulate has258RoCE-v2 traffic actually flowing on it (the algorithm259modulates *existing* RDMA / RoCE traffic — without traffic,260there is nothing for it to do).261262## What this skill deliberately does not ship263264This skill is **agent guidance**, not a samples or templates265bundle. To keep the boundary clean, it deliberately does not266contain — and pull requests should not add:267268- **The algorithm body itself, in any language.** The269 shipped algorithm is the static library270 `libdoca_pcc_ztr_rttcc_algo_dev.a` (plus the host-side271 helpers) installed by the matching DOCA host package272 per the README. The agent's job is to route the user to273 the installed library and header274 (`doca_pcc_dev_ztr_rttcc_algo.h`) and to prescribe the275 in-place edits documented in the README on the276 shipped DOCA PCC application source, not to author the277 algorithm.278- **A standalone PCC application.** The DOCA PCC279 application that hosts this algorithm is the shipped280 C sample under281 `/opt/mellanox/doca/applications/pcc/` (per the282 README). The agent's job is to prescribe the283 minimum-diff modifications the README documents and to284 walk the user through the rebuild — not to author a285 parallel application.286- **A description of every internal variant's287 behavior.** The DPA-side source ships several288 variants (vanilla, path-migration, RX-rate, multipath,289 multipath + credits, window-probeless). The agent290 names the variant set, says which one is reachable via291 the public symbol on this install, and routes292 algorithm-design questions to the public PCC293 programming guide via294 [`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md).295 It does not redefine each variant's mathematical296 behavior.297- **A specific congestion-control algorithm tutorial.**298 Congestion-control theory, RoCE-v2 fairness analysis,299 workload-specific tuning — out of scope. Route to the300 user's own domain expertise and to the public DOCA PCC301 guide.302303## Loading order3043051. Read this `SKILL.md` first to confirm the user's306 question is in scope (deployment / tuning / evaluation307 of the shipped reference algorithm, not algorithm308 design from scratch and not read-only counter309 inspection).3102. **For the algorithm capability matrix, the public311 DPA-side API surface, the variant set, the parameter312 and counter surface, the host-side `doca-pcc`313 framework relationship, the314 `doca-pcc-counters` inspection-side relationship, the315 error taxonomy, the observability surface, and the316 safety policy, see [CAPABILITIES.md](CAPABILITIES.md).**3173. **For step-by-step workflows — install, configure,318 build, modify, run, test, debug, use — see319 [TASKS.md](TASKS.md).**320321Both companion files cross-link to each other,322[`doca-pcc`](../doca-pcc/SKILL.md) for the host-side PCC323lifecycle that loads this algorithm,324[`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md)325for the read-only counter-inspection side of validating that326the algorithm is modulating traffic,327[`doca-dpa`](../doca-dpa/SKILL.md) for the DPA-side328two-side-program model and the DPACC compiler discipline,329[`doca-version`](../../doca-version/SKILL.md) for the330canonical DOCA version-handling rules (with the DPACC331overlay inherited from332[`doca-dpa`](../doca-dpa/SKILL.md) and333[`doca-pcc`](../doca-pcc/SKILL.md)), and334[`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md)335whenever the right answer is "look it up in the public DOCA336PCC programming guide or the on-disk install layout".337338## Related skills339340- [`doca-pcc`](../doca-pcc/SKILL.md) — the host-side PCC341 control library. This algorithm is loaded INTO a342 `doca_pcc` context that `doca-pcc` stands up; the343 host-side lifecycle (`doca_pcc` create / configure /344 start / stop / destroy, the algorithm image345 `doca_pcc_app`, the attach-to-port semantics) is owned346 by `doca-pcc`. This skill prescribes only the DPA-side347 algorithm integration on top.348- [`doca-pcc-counters`](../../tools/doca-pcc-counters/SKILL.md) —349 the read-only diagnostic CLI for PCC counters at the350 port. The canonical *"is the algorithm actually351 modulating traffic"* check goes through the counter352 tool; this skill names what counters the algorithm353 emits (CNP / NACK / AI / HAI / decrement / RTT-band354 counters per the public header) and routes the355 inspection workflow to the tool skill.356- [`doca-dpa`](../doca-dpa/SKILL.md) — the host-side357 DPA control library. The algorithm runs on the DPA,358 compiled by DPACC; the two-side-program rule and the359 DOCA-and-DPACC version-match overlay inherited from360 here apply.361- [`doca-public-knowledge-map`](../../doca-public-knowledge-map/SKILL.md) —362 the routing table for every public DOCA documentation363 source (the DOCA PCC programming guide at364 <https://docs.nvidia.com/doca/sdk/doca-pcc/index.html>;365 the DOCA PCC application guide; the DOCA Compatibility366 Policy) and the on-disk layout of an installed DOCA367 package.368- [`doca-setup`](../../doca-setup/SKILL.md) — env369 preparation, install verification, DPACC compiler370 install / verification, BlueField firmware371 configuration (including the custom-PCC slot enable),372 and the *I have no install yet* path with the public373 NGC DOCA container. This skill assumes its374 preconditions are satisfied AND that DPACC is installed375 at a version that matches DOCA AND that the firmware-376 level custom-PCC slot is enabled.377- [`doca-version`](../../doca-version/SKILL.md) —378 canonical DOCA version-handling rules. This skill's379 `## Version compatibility` cross-links the four-way380 match rule plus the DOCA-and-DPACC overlay inherited381 from [`doca-pcc`](../doca-pcc/SKILL.md).382- [`doca-structured-tools-contract`](../../doca-structured-tools-contract/SKILL.md) —383 the bundle's structured-tools precedence rule (detect /384 prefer / fall back / report). The Command appendix in385 [TASKS.md](TASKS.md) honors this contract.386- [`doca-programming-guide`](../../doca-programming-guide/SKILL.md) —387 general DOCA programming patterns. This skill layers388 algorithm-specific overlays on top of the universal389 build, modify-a-shipped-sample, and Core lifecycle390 patterns.391- [`doca-debug`](../../doca-debug/SKILL.md) — cross-cutting392 debug ladder. Algorithm-specific debug (the algorithm393 loaded but counters do not move; the algorithm fails to394 initialize; the algorithm modulates traffic too395 aggressively / too gently for the workload) overlays on396 top of that ladder.397- [`doca-hardware-safety`](../../doca-hardware-safety/SKILL.md) —398 cross-cutting hardware-safety meta-policy. Because the399 algorithm modulates production RoCE-v2 flows on a400 BlueField port, the meta-policy's pre-flight inventory,401 replica-first, and rollback rules apply via this402 skill's `## Safety policy` overlay.403