Generated banner for Doca Pcc Counters
Generated logo for Doca Pcc Counters

Doca Pcc Counters

NVIDIAOfficialCreated by NVIDIA

  • Skill
  • Tool integration
  • Software development
  • Apache-2.0
  • Medium risk

From the author

Use this skill when the user is invoking the DOCA PCC Counters tool — the `pcc_counters.sh` bash script under the DOCA tools directory — to arm and read the fixed firmware/hardware PCC (Programmable Congestion Control) diagnostic counters (CNP, RTT, WRED-drop, etc.) on a ConnectX / BlueField device via mst + the mlx5 debugfs `diag_cnt` interface. The script takes two positional args — `set | query` and an mst device path — with no `--help` or subcommands. Trigger even without "pcc_counters.sh" or "PCC counters": "how do I read the CNP / RTT / WRED-drop counters", "PCC counter stuck at zero", "the script says Bad Device", or "is congestion control dropping packets on this port?". Route elsewhere for writing a custom PCC algorithm (doca-pcc), factory firmware PCC config, DOCA install, or fleet-wide CC tuning.
— the description by NVIDIA

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides instructions for using the pcc_counters.sh bash script, a tool included in the DOCA suite for monitoring Programmable Congestion Control (PCC) diagnostic counters. It enables operators and developers to arm and query fixed firmware and hardware counters, such as CNP counts, RTT performance, and WRED drops, on ConnectX or BlueField devices. The skill covers the required set-then-query workflow, troubleshooting common errors like Bad Device, and understanding the interaction with the mlx5 debugfs interface.

What it does

  • Arms PCC diagnostic counters using the set operation.
  • Queries and displays current counter values using the query operation.
  • Resolves mst device paths for interaction with the mlx5 debugfs interface.
  • Provides diagnostic steps for common script errors like Bad Device or zeroed counters.
  • Identifies the fixed set of firmware and hardware counters available for monitoring.

When to use it

  • When you need to verify if congestion control events like CNPs or WRED drops are occurring on a port.
  • When you need to capture a snapshot of device-level PCC counters for performance investigation.
  • When the pcc_counters.sh script returns errors and requires troubleshooting.
  • When you need to confirm if the device is correctly armed for diagnostic data collection.

Advantages

  • Provides a standardized workflow for accessing low-level firmware diagnostic data.
  • Clearly separates diagnostic readout from custom congestion control algorithm development.
  • Offers a structured approach to troubleshooting device-level counter issues.
  • Ensures consistent usage of the two-positional-argument contract for the script.

Usage examples

“How do I read the CNP and RTT counters on my device?”
The agent will guide you to run the set command followed by the query command on your specific mst device path to output the current counter values.
“The script says ERROR: Bad Device when I try to run it.”
The agent will help you verify the correct mst device path and ensure the device is properly recognized by the system before re-running the command.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/nvidia/doca-pcc-counters/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip doca-pcc-counters.zip -d .agents/skills

Documentation by NVIDIA

DOCA PCC Counters (pcc_counters.sh)

Examples

  • "How do I read the PCC diagnostic counters on this device?" — this is in scope. Arm then query; do not treat this as PCC algorithm tuning.

  • "The script printed ERROR: Bad Device." — resolve the mst path before assuming firmware is broken.

Instructions

Follow Loading order below. Open the tasks companion for run / debug. Open the capabilities companion for the fixed counter set. Do not open every companion file.

Where to start: This is a tool skill for invoking pcc_counters.sh — a small bash script that arms and reads the device's fixed set of firmware / hardware PCC diagnostic counters (CNP count, RTT-perf, WRED-drop, RTT-gen, handled events) through the mlx5 debugfs diag_cnt interface. Open the tasks companion and start at ## run for the canonical set-then-query sequence, or ## debug when the user reports "ERROR: Bad Device", "counter stuck at zero", or "the dump is empty". Open the capabilities companion when the question is which counters the script reports and how it reaches them. If the user has not installed DOCA / MFT yet, route to doca-setup/SKILL.md first.

This skill is the firmware / HW PCC counter readout surface. It is NOT the host-side control library that loads custom congestion-control kernels onto the DPA (that is doca-pcc/SKILL.md) and it is NOT the firmware PCC algorithm configuration (that path is firmware configuration, routed via doca-public-knowledge-map/SKILL.md). The counters this script reads are device / firmware diagnostic counters that exist regardless of whether a custom doca-pcc DPA kernel is running — do not condition them on a custom kernel being loaded.

Example questions this skill answers well

The CLASSES of pcc_counters.sh 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.

  • "How do I read the PCC diagnostic counters on this device?" — worked example: "arm and dump the CNP / RTT / WRED-drop counters for /dev/mst/mt41692_pciconf0". Answered by the fixed counter set in the capabilities companion

    • the set-then-query invocation in the tasks companion.

  • "What is the smallest legal invocation?" — worked example: "what exactly do I type?". Answered by the two-positional-argument contract (set | query + an mst device path) in the tasks companion.

  • "The script printed ERROR: Bad Device — what's wrong?" — worked example: "my device path is not matching". Answered by the device-resolution layer in the capabilities companion

    • the tasks companion.

  • "A counter is stuck at zero — is the device idle, the counters not armed, or genuinely no events?" — worked example: "PCC_CNP_COUNT reads 0 after query". Answered by the arm-before-read rule and the layered diagnosis in the tasks companion + the capabilities companion.

  • "Is this script on my install, and where?" — worked example: "is pcc_counters.sh present and where does the install put it". Answered by the install overlay in the capabilities companion, which redirects to the canonical doca-version/SKILL.md rules.

Audience

This skill serves operators, developers, and AI agents who need to read a ConnectX / BlueField device's firmware PCC diagnostic counters to reason about congestion-control behaviour (CNP generation, RTT requests/responses, WRED drops) on a port. Concretely:

  • A network operator confirming whether congestion-control events (CNPs, RTT, WRED drops) are occurring on a device.

  • A developer correlating a custom doca-pcc algorithm's effect with the device-level PCC diagnostic counters (the script reads the firmware counters; the custom algorithm itself is a separate surface owned by doca-pcc/SKILL.md).

  • An AI agent producing a PCC counter snapshot as evidence for a congestion-control investigation.

It is not for users debugging the script's bash itself, not the place to learn how to write a custom PCC algorithm — that audience belongs in doca-pcc/SKILL.md — and not the place for users who want to configure the factory firmware PCC algorithm (route via doca-public-knowledge-map/SKILL.md).

pcc_counters.sh is shipped as a plain bash script installed under the DOCA tools directory, not a compiled binary and not a library you link against. The skill uses the bundle's kind: tool three-file shape (this skill + the capabilities companion

  • the tasks companion) so the agent's task-verb contract (configure / build / modify / run / test / debug) is uniform across the bundle.

When to load this skill

Load this skill when the user is — or the agent needs to — arm and read the device PCC diagnostic counters on a host or BlueField Arm with the mst tools available and debugfs mounted. Concretely:

  • Arming the diagnostic counters with set on a target mst device.

  • Reading the armed counters with query and quoting the named counter lines verbatim.

  • Capturing a counter readout as evidence for a congestion-control investigation.

Do not load this skill for general DOCA orientation, custom-PCC algorithm design, the host-side doca-pcc library API, the factory firmware PCC algorithm, or DOCA / MFT install. For those, route to doca-public-knowledge-map/SKILL.md, doca-pcc/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 pcc_counters.sh does: the exact two-operation surface (set arms the device's diagnostic counters by writing counter IDs + params to debugfs; query reads the diag_cnt/dump and prints the named counters), the FIXED firmware / HW counter set it knows (PCC_CNP_COUNT, the MAD_RTT_PERF_CONT_*, the *_EVENT_WRED_DROP family, HANDLED_*_EVENTS, the DROP_RTT_PORT*/RTT_GEN_PORT* families), how it resolves an mst device to a PCI address (mst status -v + lspci) and reaches /sys/kernel/debug/mlx5/<pci>/diag_cnt/, the install-availability overlay that redirects to doca-version/SKILL.md, the layered error taxonomy (script-not-present / bad-device / not-armed-before-query / debugfs-or-permission / counter-stuck-at-zero / cross-cutting), and the safety policy that flags set as a privileged debugfs write and any CC tuning decision derived from a reading as high-stakes.

  • the tasks companion — step-by-step workflows for the in-scope task verbs: configure (route to install + confirm mst / debugfs / sudo), build (route to install; nothing to compile — it is a script), modify (refuse — do not patch the shipped script), run (the set-then-query sequence), test (confirm the dump contains the named counters with finite values), debug (the layered diagnosis ladder), plus a Deferred task verbs block and a Command appendix.

The skill assumes a host or BlueField where DOCA / MFT is already installed (mst tools present, debugfs mounted, sudo available) and the target device is visible to mst status -v.

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:

  • Invented flags or subcommands. pcc_counters.sh has exactly two operations (set, query), takes exactly two positional arguments, and has NO --help, --version, list, snapshot, watch, or diff. Do not invent any.

  • Pre-baked example counter values. Counter values are device-, firmware-, and traffic-state-specific; a captured value will mislead an operator on a different device.

  • Wrappers, parsers, or rewritten copies of the script. The script is the contract; modifying or re-implementing it is out of scope.

  • A specific congestion-control tuning recommendation derived from a counter reading. That is a high-stakes domain question — the skill prescribes how to capture the counters; it refuses to translate a delta into a CC parameter change without the user's own domain analysis.

  • A samples/ or reference/ subtree. This is a thin loader for a documented script; substantive material lives in the script and the public PCC documentation.

Loading order

  1. Read this skill first to confirm the user's question is in scope (reading the device's firmware PCC diagnostic counters; not designing or loading a custom algorithm).

  2. For what the script does, the fixed counter set, the debugfs mechanism, the install-availability overlay, the layered error surface, and the safety posture, see the capabilities companion.

  3. For the documented invocations — configure, build, modify, run, test, debug, plus the Command appendix — see the tasks companion.

  • doca-pcc/SKILL.md — the host-side library for writing and loading custom congestion-control kernels onto the DPA. It is a SEPARATE surface: the firmware PCC diagnostic counters pcc_counters.sh reads exist independently of any custom doca-pcc kernel, but an operator tuning a custom algorithm may read these counters to observe device-level CC behaviour. Conflating the script (firmware counter readout) with the library (custom algorithm load/control) is the most common PCC first-touch error.

  • doca-public-knowledge-map/SKILL.md — routing to the public DOCA / PCC documentation set, including the firmware PCC algorithm configuration.

  • doca-version/SKILL.md — canonical DOCA version-handling rules. The ## Version compatibility section in the capabilities companion is a concise overlay that redirects here.

  • doca-setup/SKILL.md — env preparation, install verification, mst tools, debugfs, and the I have no install yet path with the public NGC DOCA container. This skill assumes its preconditions are satisfied.

  • doca-debug/SKILL.md — the cross-cutting debug ladder. The PCC counter readout slots in as a read-only device-state evidence source before any congestion-control tuning recommendation is made.

  • doca-programming-guide/SKILL.md — general DOCA programming patterns shared across the bundle.

Files

TASKS.md

DOCA PCC Counters (pcc_counters.sh) — Tasks

Where to start: The verbs that carry real workflow content for this tool are ## configure, ## run, ## test, and ## debug. The other two (build, modify) are routing stubs because pcc_counters.sh is a shipped bash script — the user does not compile it and must not patch it. The canonical flow is dead simple: set <mst-device> to arm the counters, then query <mst-device> to read them.

This file is loaded by SKILL.md after CAPABILITIES.md. It walks the agent through the task verbs every artifact in this bundle exposes (configure / build / modify / run / test / debug), defers verbs that do not belong here, and ends with the Command appendix.

For the host-side custom-PCC control surface (a SEPARATE surface — the firmware counters this script reads are independent of any custom kernel), see doca-pcc/SKILL.md.

configure

Goal: confirm the environment preconditions pcc_counters.sh needs — DOCA / MFT installed, the mst tools available, debugfs mounted, root / sudo — and identify the target mst device path BEFORE running set / query.

Steps the agent should walk the user through, in order:

  1. Confirm DOCA / MFT is installed and the script is present. If the script is absent under the DOCA tools directory, locate it without guessing with find /opt/mellanox/doca -type f -name pcc_counters.sh -print. If that still returns no result, route to doca-setup TASKS.md ## configure (doca-setup/TASKS.md#configure) (or doca-setup TASKS.md ## no-install (doca-setup/TASKS.md#no-install) for the public NGC DOCA container path).

  2. Start mst and identify the device path. First check sudo mst status -v — if the mst service is not running, sudo mst start is a state change to a hardware-adjacent service and follows doca-hardware-safety ## configure (doca-hardware-safety/TASKS.md#configure) discipline: confirm the device is not mid-firmware-work, note the pre-existing mst status -v output, then apply. Read off the exact device path for the target NIC (e.g. /dev/mst/mt41692_pciconf0). The script's second positional argument MUST be a path that appears in mst status -v; otherwise it prints ERROR: Bad Device.

  3. Confirm debugfs and privileges. The script reads/writes /sys/kernel/debug/mlx5/<pci>/diag_cnt/, so debugfs must be mounted (mount | grep debugfs), the mlx5 driver loaded, and the user must have root / sudo.

  4. Confirm platform and exclusivity. The tool is not supported on ConnectX-8 and must not run alongside DOCA Ngauge or DOCA Telemetry. On BlueField-3, run it on the Arm side in DPU mode and on the host side in NIC mode.

pcc_counters.sh takes no configuration of its own — there is no config file, no environment knob. "Configure" here means confirming the preconditions above, not setting script options.

build

pcc_counters.sh is a shipped bash script, not a compiled artifact. It is installed with DOCA; there is nothing to compile, no meson / make step, no build flags. Do not recompile or re-implement it.

Routing for nearby "build" questions:

  • "The script isn't there — do I need to build it?" → no. Route to doca-setup TASKS.md ## configure (doca-setup/TASKS.md#configure).

  • "How do I build a custom PCC algorithm whose behaviour these counters reflect?" → that is the host-side + DPA-side compile path owned by doca-pcc/SKILL.md and the DPACC compiler — a separate surface from this firmware-counter readout script.

modify

Do not modify the shipped pcc_counters.sh. It is an NVIDIA-shipped diagnostic script with a fixed two-operation contract and a fixed counter set. There is no supported way to add a counter, a flag, or a subcommand by editing it, and none should be invented.

  • "I want a counter the script doesn't report" → the script reads a fixed firmware diagnostic counter set; it is not user-extensible here. If you need device counters outside that set, that is a firmware / driver question — route via doca-public-knowledge-map/SKILL.md.

  • "I want different output formatting / a parser" → out of scope; the script's printed Counter: ... Value: ... lines are the contract. Parse them on your side if needed, but the parser is not shipped by this skill per SKILL.md ## What this skill deliberately does not ship.

run

The canonical flow is set then query against the same mst device path. The script takes exactly two positional arguments and nothing else. Run the examples from the script directory found in ## configure, or replace ./pcc_counters.sh with that discovered absolute path; do not assume the current working directory.

  1. Confirm the configure baseline. Per ## configure: script present, mst device path known, debugfs mounted, sudo available.

  2. Arm the counters with set. Run:

sudo ./pcc_counters.sh set /dev/mst/mt41692_pciconf0

This resolves the device to a PCI address and writes the fixed counter-ID list + sampling params to /sys/kernel/debug/mlx5/<pci>/diag_cnt/, arming the device's diagnostic counter collection. Before executing it, show the resolved mst path and PCI BDF, explain this privileged debugfs write, and obtain the operator's explicit confirmation. 3. Read the counters with query. Run:

sudo ./pcc_counters.sh query /dev/mst/mt41692_pciconf0

This reads diag_cnt/dump and prints each known counter as Counter: <NAME> Value: <n> (e.g. PCC_CNP_COUNT, the *_EVENT_WRED_DROP family, RTT_GEN_PORT0_REQ, …). Quote the lines verbatim. 4. For a before / after comparison, leave the counters armed (one set), run query before the change, apply the controlled change, run query after, and diff the two captured outputs with standard text tooling — the script has no built-in diff / watch. The controlled change is operator-defined and outside this skill; this workflow must not invent or execute a traffic, congestion-control, firmware, or device-state mutation. Apply the owning skill's safety gate independently.

The query value of a counter is the device's firmware diagnostic value; it is independent of any custom doca-pcc DPA kernel. Do not attribute a value to a custom algorithm without independent evidence.

When recording the run for downstream consumers, write down: the device path used, whether set was run first, the full verbatim query output, and the host / BlueField side the script ran on.

test

"Test" for this script means confirm the readout is meaningful, not unit-testing the bash. The smoke:

  1. Arm-then-read smoke. Run set then query on the target device. The query output must contain the named counter lines (Counter: <NAME> Value: <n>) and the values must be finite integers. If query prints nothing or errors, walk ## debug.

  2. Sanity against traffic. On a device carrying RoCE traffic that should generate CNPs / RTT / WRED activity, re-run query once after a preselected controlled interval; the relevant counters should advance. A counter staying at 0 on a port with no such events is expected, not a bug — confirm there is relevant traffic before treating a zero as a finding. Do not poll indefinitely: at most one additional query may be taken for this smoke; then record the unchanged value and move to ## debug.

This skill does not ship pre-recorded expected counter values; they are device-, firmware-, and traffic-state-specific.

debug

When pcc_counters.sh errors or prints values that do not look defensible, walk the layers in CAPABILITIES.md ## Error taxonomy IN ORDER:

  1. Script-not-present. The script is not under the DOCA tools directory. Confirm DOCA / MFT is installed and route to doca-setup TASKS.md ## configure (doca-setup/TASKS.md#configure).

  2. Bad-device (ERROR: Bad Device). The mst device path does not match sudo mst status -v. If mst is not running, start it under the same hardware-safety confirmation as ## configure step 2, re-list with sudo mst status -v, and use the exact path.

  3. Bad-request (Bad Request: choose 'set' or 'query'). The first argument was not set or query (e.g. a guessed list / --help). Use exactly set or query.

  4. Not-armed-before-query. query returns stale / zero values because set was not run first. Run set then query once; if it recurs, stop and escalate per CAPABILITIES.md ## Error taxonomy layer 4 — do not repeat privileged arm/read cycles.

  5. Debugfs-or-permission. The script cannot access /sys/kernel/debug/mlx5/<pci>/diag_cnt/. Confirm sudo, mount | grep debugfs, and that the mlx5 driver is loaded; route env-side issues to doca-setup TASKS.md ## debug (doca-setup/TASKS.md#debug).

  6. Counter-stuck-at-zero. Values print but a counter reads 0 — usually correct (no such events). Confirm relevant traffic before treating it as a finding. If a malformed or non-integer value appears, stop parsing that capture, preserve the full stdout, and treat it as a script/firmware-interface error rather than silently coercing it to zero.

  7. Cross-cutting. The question is really about the custom doca-pcc algorithm, firmware PCC configuration, or driver / firmware behaviour. Route to doca-pcc TASKS.md ## debug (doca-pcc/TASKS.md#debug), doca-public-knowledge-map/SKILL.md, or doca-debug TASKS.md ## debug (doca-debug/TASKS.md#debug).

In every case: quote what the script printed. Do not paraphrase or reorder the counter lines.

Deferred task verbs

The verbs below are not pcc_counters.sh work and should be routed out before the agent does any of them under this skill's name.

  • install ⇒ doca-setup TASKS.md ## configure (doca-setup/TASKS.md#configure) (and doca-setup TASKS.md ## no-install (doca-setup/TASKS.md#no-install) for the NGC DOCA container path).

  • writing / loading a custom PCC algorithm ⇒ doca-pcc/SKILL.md. That is the host-side library + DPA-side compile surface; this script only reads the device's firmware diagnostic counters.

  • firmware PCC algorithm configuration / fleet-wide CC tuning ⇒ out of scope; route the documentation lookup via doca-public-knowledge-map/SKILL.md. Any CC decision derived from a counter reading must go back through the user's own domain analysis per CAPABILITIES.md ## Safety policy.

  • long-term retention / analytics on PCC counters ⇒ not a feature of this script. The DOCA Telemetry Service (DTS) is the documented telemetry surface; route via doca-public-knowledge-map ## DOCA services (doca-public-knowledge-map/SKILL.md#doca-services).

Command appendix

pcc_counters.sh-specific invocations the verbs above reach for. The script has exactly two operations and two positional arguments — the agent MUST NOT invent flags, subcommands, or counter names beyond the fixed set in CAPABILITIES.md ## Capabilities and modes.

PurposeInvocationOwning stepReads as healthy when …
Find the target device pathsudo mst start then sudo mst status -v## configure step 2The target NIC appears with a /dev/mst/... device path the script can take as its second argument
Arm the diagnostic counterssudo ./pcc_counters.sh set <mst-device>## run step 2Exit without ERROR: Bad Device; the device's diag_cnt is now configured
Read the counterssudo ./pcc_counters.sh query <mst-device>## run step 3; ## testPrints Counter: <NAME> Value: <n> lines for the fixed counter set with finite integer values
Confirm debugfs is reachablemount | grep debugfs and ls /sys/kernel/debug/mlx5/## debug layer 5debugfs is mounted and the mlx5 per-PCI directory exists with a diag_cnt/ subtree

Cross-cutting rules for this appendix:

  • Never invent a subcommand, flag, or counter name. The script accepts only set / query plus one device path and reports only the fixed counter set; the script source (/opt/mellanox/doca/tools/pcc_counters.sh) is the contract.

  • set before query. Every read presumes the counters were armed first.

  • Cross-link instead of duplicate. Cross-cutting commands (mst status, lspci, dmesg) and their interpretation live in doca-debug TASKS.md ## Command appendix (doca-debug/TASKS.md#command-appendix) and doca-setup TASKS.md ## Command appendix (doca-setup/TASKS.md#command-appendix); this appendix names only pcc_counters.sh-specific invocations on top.

Cross-cutting

A few rules that apply across every verb in this file:

  • The script source plus the device's actual query output are the joint source of truth. The script has no --help; its behaviour is fully determined by /opt/mellanox/doca/tools/pcc_counters.sh.

  • query is read-only; set is a privileged debugfs write. Neither changes dataplane forwarding, but any CC tuning decision derived from a reading is high-stakes per CAPABILITIES.md ## Safety policy.

  • Quote, do not paraphrase the counter lines.

  • This skill assumes a healthy DOCA / MFT install (mst tools, debugfs, sudo). If in doubt, route to doca-setup/SKILL.md first.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

The author says: Requires DOCA/MFT on Linux with a ConnectX-6 or newer (not ConnectX-8) or BlueField device, mst tools, mounted debugfs, and root access to the mlx5 diag_cnt interface. The script reads fixed firmware and hardware diagnostics independently of custom PCC code. Its set operation changes which counters are collected, not congestion-control or forwarding behavior; treat later fleet tuning as a separate high-stakes action. The validation steps require a live DOCA install.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
NVIDIA
Publisher
NVIDIA (Official)
Source
NVIDIA/skills · skills/doca-pcc-counters · commit fce3cca
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE-APACHE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download doca-pcc-counters.zip