Generated banner for Doca Perftest
Generated logo for Doca Perftest

Doca Perftest

NVIDIAOfficialCreated by NVIDIA

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

From the author

Use this skill when the user is running DOCA Perftest (doca_perftest), the RDMA benchmark that measures bandwidth, message rate and latency for RDMA verbs, point-to-point or across a cluster, with an optional DOCA Verbs backend (-r dv) or GPUNetIO engine (--engine gpunetio). Trigger even when the user does not say "DOCA Perftest" — implicit phrasings include "how do I benchmark RDMA write bandwidth with DOCA", "run ib_write_bw but across 8 nodes", "perftest says the device is busy", "my latency numbers differ between client and server", "launch the server over SSH", or "run an all-to-all RDMA test from a JSON scenario". Refuse and route elsewhere for DOCA install (doca-setup), DOCA Bench (doca-bench), and application-level throughput.
— the description by NVIDIA

AutoGineer summary

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

The doca-perftest skill assists users in executing and interpreting results from the doca_perftest utility, a performance benchmarking tool for RDMA verbs. It covers point-to-point and multi-node testing scenarios, including the use of DOCA Verbs and GPUNetIO backends. The skill provides instructions for configuring benchmarks, managing multi-node orchestration, and troubleshooting common issues like device contention or inconsistent latency metrics.

What it does

  • Guides users through running RDMA bandwidth, message rate, and latency benchmarks.
  • Supports configuration for point-to-point and cluster-wide multi-node testing.
  • Facilitates comparison between IBV, DOCA Verbs, and GPUNetIO engine backends.
  • Assists in interpreting benchmark results and diagnosing performance discrepancies.
  • Provides troubleshooting steps for common runtime errors like device busy states.

When to use it

  • When you need to measure RDMA performance metrics on systems with DOCA installed.
  • When performing multi-node benchmarking using JSON scenarios or traffic patterns.
  • When comparing different RDMA drivers or backends within the DOCA environment.
  • When debugging inconsistent latency or bandwidth numbers between client and server nodes.

Advantages

  • Streamlines the execution of complex multi-node RDMA performance tests.
  • Provides clear guidance on backend selection for optimized testing.
  • Helps identify and resolve common configuration issues in RDMA benchmarking.
  • Standardizes the approach to performance measurement across DOCA-enabled clusters.

Usage examples

“Run a point-to-point RDMA write bandwidth test.”
The agent provides the command structure using -v write -m bw, explaining how to coordinate the server and client nodes.
“Benchmark 16 nodes at once and get one report.”
The agent explains how to use a JSON scenario or the --traffic_pattern flag to aggregate performance data across the cluster.
“My latency numbers differ between client and server.”
The agent guides the user to check NUMA placement, core affinity, and consistency in message sizes and verb types.
“perftest says the device is busy”
The agent provides troubleshooting steps to identify and clear processes holding the RDMA device.

Install

  1. Download the skill as a ZIP:

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

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

Documentation by NVIDIA

DOCA Perftest

When to load this skill

Load this skill when the user wants to — or the agent needs to — run doca_perftest on a host with DOCA installed. Concretely:

  • Measuring RDMA bandwidth, message rate, or latency between two hosts (point-to-point) with a verb such as write / read / send.

  • Running the same benchmark across many nodes — JSON scenario or --traffic_pattern (pair-wise, all-to-all), orchestrated over OpenMPI / passwordless SSH.

  • Comparing the IBV and DOCA Verbs backends (-r ibv vs -r dv) or driving the GPUNetIO engine (--engine gpunetio).

  • Interpreting a run: client-vs-server number drift, "device busy", inconsistent latency across runs.

Do not load this skill for DOCA install (doca-setup), the doca-bench harness, Flow pipeline tuning (doca-flow-tune), or application-level throughput.

Examples

  • "Measure RDMA write bandwidth between two ConnectX-7 hosts with 64 KB messages." Point-to-point: run the server, then the client with -n.

  • "I need latency across 16 nodes, all-to-all." Multi-node: JSON scenario or --traffic_pattern, with OpenMPI.

  • "Compare the IBV and DOCA Verbs drivers on the same device." Same command, -r ibv vs -r dv.

Instructions

Follow the loading order below. Open TASKS.md for the commands and CAPABILITIES.md for what the tool can measure and what it does not.

Where to start: DOCA Perftest is the DOCA 3.5 replacement for legacy ib_write_bw / ib_send_lat plus the orchestration scripts used to run them on many nodes. Start at TASKS.md ## point-to-point for a first run. Use ## multi-node for scenarios and ## debug when a run fails or the numbers look wrong.

If DOCA is not installed, route to doca-setup/SKILL.md. Client and server must run the same DOCA Perftest version; check with doca-version/SKILL.md before comparing numbers across hosts. If the question is about GPU-initiated RDMA in the user's own code, route to doca-gpunetio/SKILL.md.

Example questions this skill answers well

  • "Run a point-to-point RDMA write bandwidth test." Use -d <dev> -n <server> -v write -m bw -s <size> -D <sec>; the client coordinates the server side over SSH (requires SSH key exchange set up beforehand).

  • "Benchmark 16 nodes at once and get one report." Use a JSON scenario or --traffic_pattern; the report aggregates per device, node and test.

  • "Latency differs between runs." Check the latency mode, the core and NUMA placement, and whether both sides use the same message size and verb.

Loading order

  1. This file for scope and routing.

  2. TASKS.md for the exact command for the job you are doing.

  3. CAPABILITIES.md when you need to know whether a verb, driver, memory type or traffic pattern is supported.

Do not open every companion file.

Scope boundaries

  • Installs and driver packages: doca-setup/SKILL.md.

  • Version matching across client, server and DOCA release: doca-version/SKILL.md.

  • Any change to NIC or eswitch state, firmware, or host kernel settings (hugepages, IOMMU, PCIe rebind): follow doca-hardware-safety/SKILL.md first.

  • Failure diagnosis: doca-debug/SKILL.md for the layer ladder, then the TASKS.md ## debug anchor here.

  • Upstream CPU-initiated ib_write_bw: this tool replaces it on DOCA 3.5; do not mix the two in one comparison without saying so.

Files

TASKS.md

DOCA Perftest: tasks

Source for every flag and behavior: the DOCA 3.5 guide, DOCA Perftest. Run doca_perftest -h on the installed binary; the flag set can change between releases.

point-to-point

Preconditions: same DOCA Perftest version on both hosts, RDMA device visible (ibv_devinfo or ibstat), passwordless SSH from client to server for auto-launch.

Smoke (auto-launch):

# server host is the target
doca_perftest -d mlx5_0 -n <server-host-name>

Equivalent explicit run (use when SSH auto-launch is not configured):

# server
doca_perftest -d mlx5_0 -N 1 -c RC -v write -m bw -s 65536 -D 10
# client
doca_perftest -d mlx5_0 -N 1 -c RC -v write -m bw -s 65536 -D 10 -n <server-host-name>

Flags used above: -d device, -N process count (-C <core> to pin), -c RC transport, -v write verb, -m bw metric (lat for latency), -s message size in bytes, -D duration in seconds, -n remote host (client only).

To stop the server from auto-launch: add --launch_server disable on the client and start the server by hand.

Done when: both sides report the same parameters and the client prints a bandwidth result. Record the device, verb, size, duration and DOCA version with the number.

select-driver

  • Default: -r ibv (libibverbs, always available).

  • -r dv: DOCA Verbs backend. Needs the DOCA Verbs package; if it is missing the tool exits with an error instead of falling back.

Run the same command with both drivers and compare; state the driver in every reported number.

select-memory

  • -M host (default), -M nullmr, -M device.

  • GPU memory: -M cuda -G <gpu-id>. Use cuda_auto_detect (the recommended syntax in the guide) or cuda_peermem / cuda_dmabuf / cuda_data_direct for an explicit path. The deprecated cuda_auto_detect alias forms still work but do not copy them into new scripts.

Check that nvidia_peermem (or the DMA-BUF path) is loaded before running GPU memory; without it the run fails at memory registration.

multi-node

Prerequisites: OpenMPI bundled with DOCA on every node, the same binary path on every node, and passwordless SSH.

Use one of:

  • CLI traffic pattern: --traffic_pattern (one-to-one, one-to-many, many-to-one, all-to-all, bisection, ring).

  • JSON scenario: a file that defines several tests, devices, hosts and patterns; one run produces the aggregate report.

Launch from one host; results are collected to a single report (CLI: a results file; JSON: the scenario report). Use -h or the guide section "Common Arguments and Use-Cases" for the exact keys.

Done when: the aggregate report lists every node and every test with a non-zero result. A partial list usually means one node failed to launch; check its SSH and MPI reachability first.

latency

  • -m lat with -v write or -v send. Read the latency mode section of the guide before comparing: one-way uses local send-completion timing, which is not the same as round-trip.

  • Keep the message size and core placement identical across runs.

gpunetio

Only for GPU-initiated RDMA through DOCA GPUNetIO.

doca_perftest -d mlx5_0 -n <server-host-name> -M cuda -G 0 -r dv --engine gpunetio

Limits: Write verb only, unidirectional only, needs -r dv, CUDA memory, doca-gpunetio, and a Volta+ GPU.

debug

Work the layers in order. Stop at the first failure and fix it before going on.

  1. Device open fails. Check the device name (ibdev2netdev, ibv_devices); another process may hold it (fuser on the device node or a stale doca_perftest). Do not kill another team's process without asking.

  2. Client cannot launch server. Check passwordless SSH to the server, the same binary path and version on both sides, and that the server port is free. Run the server by hand with the same parameters to separate the two problems.

  3. DV backend error. Confirm the DOCA Verbs package is installed and that -r dv is supported on this device. The tool reports this explicitly; read the message rather than retrying.

  4. GPU memory registration fails. Check nvidia_peermem (or DMA-BUF support) and the CUDA device id.

  5. Numbers are far below line rate. Check the core and NUMA placement (-C), message size (small messages are message-rate bound, not bandwidth bound), queue-pair count (-q or the QP histogram option in the guide), and whether both ends run the same version.

  6. Latency numbers disagree between runs. Confirm the same latency mode, message size and CPU pinning; reboot-free noise sources are frequency scaling and IRQ affinity.

Exit gate for a debug session: one run with the parameters recorded and a result that matches the expected order of magnitude for the link. Name the layer that was wrong.

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.

Needs: Needs Node.js

The author says: Requires DOCA 3.5 or later on Linux with a ConnectX or BlueField RDMA device, libibverbs (DOCA-OFED or upstream rdma-core), and OpenMPI for multi-node modes. The DOCA Verbs backend needs the doca-verbs package; the GPUNetIO engine needs doca-gpunetio, CUDA and a Volta+ GPU. Run benchmarks only on a trusted, non-shared fabric.

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-perftest · 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-perftest.zip