Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

doca-eth

/doca-eth

Pomaga uruchomić kolejki pakietów DOCA Ethernet na BlueField lub NIC: wybór typu kolejki, rozmiary i wysyłanie zadań.

Repozytorium
skills ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
12.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
8
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 12.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Pomaga uruchomić kolejki pakietów DOCA Ethernet na BlueField lub NIC: wybór typu kolejki, rozmiary i wysyłanie zadań.

Oryginalny opis (EN)

Use this skill for hands-on DOCA Ethernet packet-queue work on a BlueField DPU or ConnectX NIC — bringing up a `doca_eth_rxq` or `doca_eth_txq` on a port / representor / SF, picking among the four `enum doca_eth_rxq_type` values (`_REGULAR` / `_CYCLIC` / `_MANAGED_MEMPOOL` / `_SHARED_MEMPOOL`), sizing burst or scatter-gather length against the `_cap_*` queries, submitting `doca_eth_txq_task_send` / `_lso_send` (carrying packet `doca_buf`s — no `doca_eth_frame` struct exists), or debugging DOCA_ERROR_* from an Ethernet call. `doca_eth_rxq` and `doca_eth_txq` are two Core contexts; one `doca_ctx

Jak działa

  1. Examples
  2. Instructions
  3. Example questions this skill answers well
  4. Audience
  5. When to load this skill
  6. What this skill provides
  7. What this skill deliberately does not ship
  8. Loading order
  9. Related skills
Sekcje z nagłówków SKILL.md, w oryginale · 276 linii, 1 783 słów
Podgląd SKILL.md
---
license: Apache-2.0
name: doca-eth
description: >
  Use this skill for hands-on DOCA Ethernet packet-queue work on a
  BlueField DPU or ConnectX NIC — bringing up a `doca_eth_rxq` or
  `doca_eth_txq` on a port / representor / SF, picking among the four
  `enum doca_eth_rxq_type` values (`_REGULAR` / `_CYCLIC` /
  `_MANAGED_MEMPOOL` / `_SHARED_MEMPOOL`), sizing burst or
  scatter-gather length against the `_cap_*` queries, submitting
  `doca_eth_txq_task_send` / `_lso_send` (carrying packet `doca_buf`s —
  no `doca_eth_frame` struct exists), or debugging DOCA_ERROR_* from an
  Ethernet call. `doca_eth_rxq` and `doca_eth_txq` are two Core
  contexts; one `doca_ctx_start()` does not cover both. Trigger on
  implicit phrasings: "my RX queue is up but no packets arrive",
  "send-task returns AGAIN at line rate", "which queue type for
  fixed-MTU ingress", "device open fails without sudo", or "is L3
  checksum offload available here". Refuse and route elsewhere for
  installing DOCA, flow-rule / steering programming, host↔DPU control
  messaging, or RDMA data movement.
metadata:
  author: NVIDIA <doca-feedback@nvidia.com>
  kind: library
  doca_version: "3.5"
  tags:
    - doca
    - ethernet
    - queues
compatibility: >
  Requires DOCA SDK installed at /opt/mellanox/doca on Linux
  (Ubuntu 22.04/24.04 or RHEL/SLES) with a BlueField DPU or
  ConnectX NIC attached. Reads the user's local install via
  `pkg-config doca-eth` and inspects
  /opt/mellanox/doca/{lib,include,samples,applications}.
  The validation steps require a live DOCA install.
---

# DOCA Ethernet

## Examples

- **"My RX queue is up but no packets arrive."** — RX and TX are two
  Core contexts; one `doca_ctx_start()` does not cover both.
- **"Send-task returns AGAIN at line rate."** — size burst against
  the `_cap_*` queries before changing queue type.

## Instructions

Follow Loading order below. Open the tasks companion for configure /
build / run. Open the capabilities companion for the RX-type taxonomy
and send surface. Do not open every companion file.

**Where to start:** This skill assumes DOCA is already installed and
the user is doing **hands-on packet-queue work** on a host or
BlueField with DOCA. Open the tasks companion if the user wants
to *do* something (configure / build / modify / run / test /
debug); open the capabilities companion when the question
is *what can a DOCA Ethernet queue express* on this version. If
the user has not installed DOCA yet, route to
`doca-setup/SKILL.md` first. **RX and TX are
independent Core contexts.** A `doca_eth_rxq` and a `doca_eth_txq`
each get their own `doca_ctx_create` / `_start` / `_stop` /
`_destroy`; one `doca_ctx_start()` does **not** start both sides.
Do not walk a single lifecycle for "the queue pair". If the user is
asking *"how do I get packets to land on my RX queue at all"*, the
answer lives in `doca-flow/SKILL.md` — DOCA
Ethernet is the *queue* surface; DOCA Flow is the *steering*
surface, and they are independent libraries.

## Example questions this skill answers well

The CLASSES of DOCA Ethernet 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.

- **"How do I bring up an RX and TX queue on a representor or
  physical port?"** — worked example: *"set up a `doca_eth_rxq`
  plus a `doca_eth_txq` on a single BlueField representor for
  first-run testing"*. Answered by two independent Core
  contexts (each with its own start) in
  ## configure +
  ## Capabilities and modes
  RX / TX object table.
- **"Which RX type fits my data shape — regular, cyclic, or
  managed-recv?"** — worked example: *"line-rate ingress with
  fixed-size frames into a pre-allocated buffer ring"*. Answered
  by the RX-type taxonomy in
  ## Capabilities and modes
  + the capability-query rule (`doca_eth_rxq_cap_is_type_supported`
  against a `doca_devinfo`) in
  ## configure.
- **"How do I send a packet from user code through `doca_eth_txq`?"**
  — worked example: *"allocate a packet `doca_buf`, attach the
  payload, submit one send-task, wait for the completion event"*.
  Answered by the TX submission shape in
  ## Capabilities and modes
  + the property-set workflow in
  ## modify.
- **"My queue is up but no packets arrive — why?"** — worked
  example: *"`doca_eth_rxq` started cleanly but the recv callback
  never fires"*. Answered by the steering-dependency rule in
  ## Safety policy
  + the env-prep checklist in
  ## configure step 1, which
  routes the steering side to
  `doca-flow/SKILL.md` and the
  promiscuous-mode side to
  `doca-setup/SKILL.md`.
- **"Is this Ethernet capability available on my device + my
  installed DOCA?"** — worked example: *"does this device
  advertise L3 checksum offload"*. Answered by the
  capability-query rule (`doca_eth_txq_cap_is_l3_chksum_offload_supported`
  against a `doca_devinfo`) in
  ## Capabilities and modes
  + the version-and-device overlay in
  ## Version compatibility.
- **"What does this `DOCA_ERROR_*` from an Ethernet call mean and
  which layer caused it?"** — worked example: *"`DOCA_ERROR_AGAIN`
  on `doca_task_submit` for an `eth_txq` send-task at high rate"*.
  Answered by the Ethernet overlay on the cross-library taxonomy
  in
  ## Error taxonomy
  + the layered ladder in
  ## debug that escalates to
  `doca-debug/SKILL.md`.

**Picking the root-cause layer when several could explain a symptom.**
Walk the layers bottom-up (install → version → build → link → runtime →
program → driver) with the read-only check each layer names in `TASKS.md`
`## debug`. The lowest layer whose check fails is the root cause: fix it,
change one variable at a time, and re-run the same check before moving up.
For a silent RX queue, rule out the three runtime preconditions (device
access, port up, traffic steered to the queue) before any program or driver
cause.

## Audience

This skill serves **external developers building applications that
consume the DOCA Ethernet library** — i.e., users whose code calls
`doca_eth_rxq_*` / `doca_eth_txq_*` (directly in C/C++, or through
FFI/bindings from another language) to do line-rate packet I/O on
physical ports, representors, or SFs of a BlueField or ConnectX
device. It is *not* for NVIDIA developers contributing to DOCA
Ethernet itself.

**Language scope.** DOCA Ethernet ships as a C library with
`pkg-config` module name `doca-eth`. The shipped samples are
written in C. C and C++ consumers are the canonical case; the
worked examples in the tasks companion assume that path. Other-language
consumers (Rust, Go, Python, …) consume the same `*.so` through
FFI or language-specific bindings; the skill's contribution in
that case is to keep the queue-object split, lifecycle,
capability-discovery, permission, RX-type taxonomy, and
error-taxonomy guidance language-neutral, and to route the agent
to the public C ABI as the authoritative surface that any wrapper
will eventually call.

## When to load this skill

Load this skill when the user is doing hands-on DOCA Ethernet
work, in any language. Concretely:

- Initializing a `doca_eth_rxq` on a `doca_dev` opened against a
  physical port, a representor, or an SF — choosing among the
  regular / cyclic / managed-recv RX types based on data shape
  before `doca_ctx_start()`.
- Initializing a `doca_eth_txq` on the same or a different
  `doca_dev` and posting send-tasks against packet `doca_buf`s
  payload buffers.
- Reading or setting Ethernet queue properties via
  `doca_eth_rxq_set_*` / `doca_eth_txq_set_*` and querying device
  capability via `doca_eth_rxq_cap_*` / `doca_eth_txq_cap_*`
  (max burst size, RX-type support, max scatter-gather length,
  checksum-offload presence).
- Confirming the port is up and that traffic is actually steered
  to the chosen RX queue — either via DOCA Flow rules (the
  canonical path) or via kernel-side promiscuous mode (the
  expedient first-run path).
- Wiring an Ethernet queue to a higher-level data plane: GPU
  packet processing via DOCA GPUNetIO, custom user-space
  forwarding agents, or telemetry mirrors that snap a copy of
  every packet.
- Debugging a `DOCA_ERROR_*` returned from an Ethernet call
  (lifecycle vs. permission vs. capability vs. send-queue-full
  vs. driver-below) and the per-queue progress engine events.
- Designing or extending non-C bindings (Rust, Go, Python, …)
  that wrap the DOCA Ethernet C ABI — for the lifecycle, queue
  split, RX-type, capability, and permission rules the wrapper
  must honor.

Do **not** load this skill for general DOCA orientation, install
of DOCA itself, flow-rule programming (use
`doca-flow/SKILL.md`), host ↔ DPU control
messaging (use `doca-comch/SKILL.md`), or
RDMA data movement (use `doca-rdma/SKILL.md`).
For DOCA documentation orientation, use
`doca-public-knowledge-map/SKILL.md`.

## What this skill provides

This is a **thin loader**. The body keeps only the orientation
needed to pick the right next file. The substantive Ethernet-
specific material lives in two companion files:

- the capabilities companion — what a DOCA Ethernet queue can express on
  this version: the RX / TX object split, the RX-type taxonomy
  (regular / cyclic / managed-recv), the send-task / frame
  submission surface, the capability-query surface
  (`doca_eth_rxq_cap_*` / `doca_eth_txq_cap_*`), the Ethernet
  error taxonomy (mapped onto the cross-library `DOCA_ERROR_*`
  set), the observability surface (per-queue progress engine
  events, capability snapshots), and the safety policy that
  gates the steering / permission / port-state preconditions.
- the tasks companion — step-by-step workflows for the six in-scope
  Ethernet verbs: `configure`, `build`, `modify`, `run`,
  `test`, `debug`. Plus a `Deferred task verbs` block that
  points out-of-scope questions at the right next skill, and a
  `Command appendix` of the recurring commands the agent
  reaches for.

The skill assumes a host or BlueField where DOCA is already
installed at the standard location and the user has the
privileges their public install profile expects (typically sudo
or `mlnx`-group membership to open a `doca_dev` against a port).
It does not cover installing DOCA — that path goes through
`doca-setup/SKILL.md`.

## 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:

- **Pre-written DOCA Ethernet application source code, in any
  language.** The verified Ethernet source code is the shipped C
  samples at `/opt/mellanox/doca/samples/doca_eth/<name>/`. The
  agent's job is to route the user to those files and prescribe
  a minimum-diff modification on them via the universal
  modify-a-sample workflow in
  `doca-programming-guide/SKILL.md`,
  layered with the Ethernet-specific overrides in
  ## modify.
- **Standalone build manifests** (`meson.build`,
  `CMakeLists.txt`, `Cargo.toml`, …) parked inside the skill.
  The agent constructs the build manifest *in the user's project
  directory* against the user's installed DOCA, where
  `pkg-config --modversion doca-eth` is the source of truth.
- **A `samples/`, `bindings/`, or `reference/` subtree** of any
  kind. A mock or incomplete artifact in this skill's tree, even
  one labeled "reference", is misleading: users will read it as
  buildable.

## Loading order

1. Read this skill first to confirm the user's question is
   in scope.
2. **For the Ethernet capability matrix, RX-type taxonomy, send
   surface, capability-query rules, error taxonomy,
   observability, and safety policy, see
   the capabilities companion.**
3. **For step-by-step workflows — configure, build, modify, run,
   test, debug — see the tasks companion.**

Both companion files cross-link to each other,
`doca-version/SKILL.md` for the canonical
version-handling rules,
`doca-flow/SKILL.md` for the steering side
that the RX queue depends on, and
`doca-public-knowledge-map/SKILL.md`
whenever the right answer is "look it up in the public docs or
the installed package layout" rather than "Ethernet-specific
guidance".

## Related skills

- `doca-public-knowledge-map/SKILL.md` —
  the routing table for every public DOCA documentation source
  and the on-disk layout of an installed DOCA package. The
  Ethernet URL slug is `DOCA-Ethernet`.
- `doca-setup/SKILL.md` — env preparation,
  install verification, port-state checks (`devlink dev show`,
  `ip link`), permission and group-membership requirements for
  opening a `doca_dev`. This skill assumes its preconditions
  are satisfied.
- `doca-version/SKILL.md` — canonical
  DOCA version-handling rules. This skill's `## Version
  compatibility` cross-links the four-way match rule and adds
  only the Ethernet-specific overlay (RX-type availability
  windows, checksum-offload device-conditional support).
- `doca-structured-tools-contract/SKILL.md` —
  the bundle's structured-tools precedence rule (detect / prefer
  / fall back / report). The Command appendix in
  the tasks companion honors this contract.
- `doca-programming-guide/SKILL.md` —
  general DOCA programming patterns shared by every library:
  the canonical `pkg-config` + meson build pattern, the
  universal modify-a-shipped-sample first-app workflow, the
  universal lifecycle, the cross-library `DOCA_ERROR_*`
  taxonomy, and the program-side debug order. This skill layers
  Ethernet specifics on top.
- `doca-flow/SKILL.md` — the steering surface
  that decides which packets land on which `doca_eth_rxq`. DOCA
  Ethernet does *not* program steering itself; an empty RX queue
  almost always means a missing or wrong Flow rule, not an
  Ethernet bug.
- `doca-debug/SKILL.md` — the cross-cutting
  debug ladder (install / version / build / link / runtime /
  program / driver). Ethernet-specific debug (RX-type
  mismatches, send-queue-full retries, steering-empty-queue
  symptoms) overlays on top of that ladder.
Pliki w paczce (8)
  • BENCHMARK.md 10 KB
  • CAPABILITIES.md 20 KB
  • SKILL.md 14 KB
  • SKILLCARD.yaml 3 KB
  • TASKS.md 24 KB
  • skill-card.md 5 KB
  • skill.oms.sig 5 KB
  • evals/evals.json 3 KB

Wersje

W bazie nie ma innych skilli o nazwie doca-eth.

Migawka bazy z 13.11.2026 · wersja paczki 7f72dbf2495a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100doca-common
    Pokazuje podstawy programowania DOCA na BlueField i ConnectX: cykl życia doca_ctx, wykrywanie urządzeń, bufory i logowanie.
  • 100doca-aes-gcm
    Pomaga w pracy z DOCA AES-GCM na BlueField lub ConnectX: szyfrowanie, deszyfrowanie, zdolności kluczy i rozmiary buforów.
  • 90esp32-w5500-ethernet
    Pomaga uruchomić Ethernet W5500 przez SPI z ESP32, gdy DHCP nie działa, gniazda zawodzą, łącze zrywa się albo współistnienie z Wi-Fi szwankuje.
  • 100esp32-ethernet-link-recovery
    Przywraca połączenie Ethernet na ESP32 po utracie łącza i przegląda logikę ponownego wykrywania sieci.
  • 100doca-pcc-ztr-rttcc-algo
    Wdraża, dostraja i ocenia referencyjny algorytm ZTR RTTCC dla RoCE na DPA BlueField-3 przez przykład DOCA PCC.
  • 100doca-bench-extension
    Pomaga pisać, budować i debugować wtyczkę do doca-bench, czyli bibliotekę współdzieloną mierzącą obciążenia spoza wbudowanych trybów.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.