opción
HogarHogar Skill Seguridad jetson-memory-audit

jetson-memory-audit

NVIDIA/skills NVIDIA/skills

Mide el uso de la memoria DRAM de Jetson y de NvMap, captura los valores de referencia previos y posteriores, y verifica la recuperación de memoria con datos de auditoría en tiempo real.

...Expandir todo
15
Tiempo actualizado 24 de septiembre de 2026

Auditoría de memoria de Jetson

Instantánea centrada en la memoria de solo lectura para un Jetson, además de la herramienta auxiliar «drop_caches» para el bucle de verificación, que confirma que la memoria liberada aparece realmente como libre en lugar de como almacenada en caché.

Objetivo

Medir los consumidores actuales de memoria de Jetson, capturar valores de referencia previos y posteriores, y verificar si los cambios aprobados por el usuario han liberado realmente DRAM. Utilizar datos en tiempo real del dispositivo en lugar de estimaciones basadas en el tamaño del contenedor, el tamaño del modelo o la memoria genérica del proceso.

CRÍTICO: La memoria parece atascada tras detener vLLM / sglang (JetPack inferior a 7.2 / L4T inferior a r39.0)

Este es el problema de memoria más habitual en las versiones de Jetson anteriores a JetPack 7.2 o a L4T r39.0.

Tras detener un servidor vLLM, sglang u Ollama (o cualquier carga de trabajo CUDA), es posible que la memoria que aparece como libre en free -h o tegrastats no se recupere, aunque el proceso ya haya finalizado. nvidia-smi también puede mostrar un nivel de memoria libre de la GPU engañosamente bajo.

Causa principal: el gestor de recursos (RM) de Thor retiene las páginas de memoria del sistema (sysmem) liberadas en su propio grupo tras la salida de un contexto CUDA. En dispositivos con arquitectura de memoria unificada (UMA), como Jetson, `cudaMemGetInfo` lee el estado del grupo del RM e indica una cantidad de memoria libre muy inferior a la que realmente está disponible para un nuevo proceso.

Solución provisional (para JetPack inferior a la versión 7.2 o L4T inferior a la r39.0):

sudo sync && sudo sysctl -w vm.drop_caches=3

Ejecuta esto en el host, no dentro de un contenedor. La operación importante es sudo sysctl -w vm.drop_caches=3; mantén sudo sync inmediatamente antes de ella para que los datos no validados se vacíen antes de que se eliminen las cachés recuperables de páginas, dentry e inodos. Tras ejecutarlo, los comandos ` free -h ` y ` tegrastats ` mostrarán la memoria disponible real.

Para las versiones afectadas, se recomienda este comando cuando un usuario indique:

  • «La memoria no se ha liberado después de detener vLLM/sglang»
  • «¿Por qué tegrastats sigue mostrando un uso elevado después de que mi contenedor se haya cerrado?»
  • «Aparece un error OOM aunque no haya nada en ejecución»
  • «Ayer la memoria funcionaba bien, pero ahora está llena».

En JetPack inferior a la versión 7.2 o L4T inferior a la r39.0, «drop_caches» es la solución alternativa fiable cuando la memoria parece atascada tras salir de una carga de trabajo de CUDA; en versiones más recientes, utilízala solo si se observa el mismo síntoma y el usuario da su consentimiento.

Cuándo utilizarlo

  • «¿Cuánta memoria está en uso en este Jetson? ¿Qué la está ocupando?»
  • «He desactivado la interfaz gráfica / he detenido vLLM / he cerrado mi contenedor: ¿se ha liberado realmente la memoria?»
  • «¿Por qué free -h sigue mostrando poca memoria libre después de haber detenido mi carga de trabajo?»
  • Como referencia antes de aplicar jetson-headless-mode u otros cambios relacionados con la memoria, y de nuevo después para calcular la diferencia real.

Requisitos previos

  • Ejecutar en el host del Jetson, o en un entorno aislado/contenedor con acceso del host a /proc, /etc/nv_tegra_release, tegrastats y datos de procesos.
  • Las lecturas de NvMap en debugfs pueden requerir privilegios de root. Si no están disponibles, informa de que la atribución de memoria de la GPU es limitada, en lugar de hacer conjeturas.
  • drop_caches.sh requiere privilegios de root o sudo -n sin contraseña; ejecútalo solo después de que el usuario autorice explícitamente la eliminación de la caché.

Scripts disponibles

Script Finalidad Argumentos
scripts/audit.sh Genera una instantánea JSON a partir de jetson-diagnostic/scripts/snapshot.sh para flujos de trabajo de auditoría de memoria. Sin argumentos.
scripts/drop_caches.sh Vacía las cachés de páginas, dentry e inodos recuperables e imprime las diferencias de memoria antes y después. --mode 1|2|3, --quiet.

Si el entorno de ejecución de tu agente es compatible con run_script, utilízalo para ejecutar scripts/audit.sh o scripts/drop_caches.sh y resume el resultado devuelto. De lo contrario, ejecuta los scripts con bash desde la raíz del repositorio.

Instrucciones

Para preguntas del tipo «¿cuánta memoria se está utilizando en este momento?», ejecuta scripts/audit.sh e informa únicamente de los valores de la instantánea JSON.

Orientación para la elaboración de informes

No te limites a mostrar o mencionar la ruta de acceso a una herramienta auxiliar. Ejecuta la herramienta y, a continuación, resume los datos devueltos.

  • Para las consultas del tipo «¿cuánta memoria se está utilizando?», ejecuta scripts/audit.sh e indica los valores de mem_total_gb, memory_kb.available y el proceso procrank_top principal o el consumidor nvmap.top_clients.
  • Para las consultas sobre la memoria de la interfaz gráfica de usuario (GUI) o del escritorio, ejecuta scripts/audit.sh e informa de default_systemd_target más cualquier gestor de pantalla de candidate_services (gdm3, gdm, lightdm, sddm o display-manager). No desactives nada; remítete a jetson-headless-mode para obtener un plan.
  • Para las solicitudes que autoricen explícitamente el vaciado de la caché tras detener una carga de trabajo, ejecuta scripts/drop_caches.sh (equivalente a sudo sync && sudo sysctl -w vm.drop_caches=3 por defecto) e informa de las variaciones en «free», «available» y «cached» antes y después. Si no se dispone de privilegios de root, explica que debe ejecutarse en el host con sudo.

Si el entorno de ejecución de tu agente no ejecuta scripts auxiliares relativos a este directorio de habilidades, resuelve las rutas de los scripts con el marcador de posición {baseDir} de AgentSkills:

{baseDir}/scripts/audit.sh
{baseDir}/scripts/drop_caches.sh

No utilices jetson-memory-audit como nombre de herramienta a menos que el entorno de ejecución registre explícitamente las habilidades como herramientas invocables; las habilidades de agente suelen consistir en instrucciones más archivos, no en funciones directas de herramientas.

Nota sobre el entorno de pruebas para agentes: el hecho de ver este archivo de habilidad no garantiza el acceso a los datos de la memoria del host Jetson. Si faltan /proc/device-tree/model, /etc/nv_tegra_release, tegrastats, /sys/kernel/debug/nvmap o los datos del proceso del host no están disponibles dentro de un entorno de pruebas de NemoClaw/OpenClaw, indica que el entorno carece de visibilidad del host de Jetson y pide al usuario que lo ejecute en el host de Jetson o que lo reinicie con un perfil de entorno de pruebas con visibilidad del host. No inventes valores de memoria total, memoria disponible, PSS, NvMap ni diferencias de recuperación de memoria.

Para preguntas del tipo «¿cuánta memoria ha liberado este cambio?», utiliza la diferencia entre el antes y el después. No calcules la memoria liberada a partir del tamaño del contenedor, el tamaño de la imagen, el RSS o una única instantánea posterior al cambio.

  1. Antes del cambio, ejecuta el script audit.sh y guarda la línea de base en formato JSON.
  2. Realice el cambio aprobado por el usuario (detenga el contenedor, cambie de modo, aplique una recomendación de ajuste, etc.).
  3. En JetPack inferior a la versión 7.2 o L4T inferior a la r39.0, o cuando se observe el mismo síntoma de memoria bloqueada en una versión más reciente, vacía la caché de páginas recuperables en el host (no dentro de un contenedor) para que las páginas liberadas aparezcan como libres en lugar de en caché:
    sudo sync && sudo sysctl -w vm.drop_caches=3
    
    
  4. Vuelve a ejecutar scripts/audit.sh y compara el valor de memory_kb.available antes y después: esa diferencia es la recuperación real.

Si el usuario ya ha realizado el cambio y no existe una línea de base, indica que la cantidad exacta liberada no se puede recuperar solo a partir de la instantánea actual. Captura ahora una nueva línea de base para que se pueda medir el próximo cambio.

Utiliza los datos de auditoría en tiempo real como fuente de referencia. Los totales de memoria, la memoria disponible, los totales de NvMap, los valores de PSS, el estado del gestor de pantalla y las diferencias de ahorro deben proceder de scripts/audit.sh, free -h o tegrastats en el dispositivo real. Si un valor no aparece en esas salidas, no lo estimis.

Formato de salida de audit.sh

{
  "sku": "orin-nano",
  "variant": "orin-nano-8gb",
  "mem_total_gb": 8,
  "l4t_version": "36.4.0",
  "product_model": "nvidia jetson orin nano developer kit",
  "memory_kb": { "total": 8123456, "available": 4123456, "free": 1023456, "cached": 1234567, "swap_total": 0, "swap_free": 0 },
  "default_systemd_target": "graphical.target",
  "candidate_services": { "gdm3": { "active": "active", "enabled": "enabled" } },
  "tegrastats_sample": "RAM 4011/8138 MB (lfb 8x4 MB) ...",
  "nvmap": { "readable": false, "total_kb": 0, "top_clients": [] },
  "procrank_top": [ { "pid": 4321, "pss_kb": 4000000, "cmd": "vllm" } ]
}

Limitaciones

  • Para obtener las diferencias exactas de memoria liberada se requiere una instantánea previa, el cambio aprobado por el usuario, el vaciado de la caché cuando sea necesario y una instantánea posterior.
  • La atribución de NvMap depende del acceso a debugfs visible desde el host; si no está disponible, se informará de una atribución limitada de la memoria de la GPU en lugar de realizar estimaciones.
  • Es posible que las ejecuciones en entornos aislados (sandbox) o contenedores no puedan ver los datos de /proc, tegrastats, systemd o NvMap del host, a menos que el entorno de ejecución los exponga.

Gestión de errores

  • Si el script scripts/audit.sh no puede acceder a los datos del host Jetson, se informará de la falta de visibilidad y se solicitará que se vuelva a ejecutar en el host Jetson o en un entorno de pruebas accesible desde el host.
  • Si scripts/drop_caches.sh carece de privilegios de root o de sudo -n sin contraseña, informa de que la eliminación de la caché debe ejecutarse en el host con autorización de sudo.
  • Si no existe ninguna instantánea previa, indica que la cantidad exacta recuperada no puede determinarse a partir del estado actual por sí solo y captura una nueva referencia para el próximo cambio.

Seguridad

Solo lectura. drop_caches no es destructivo (el kernel solo libera páginas que, de todos modos, podría recuperar bajo presión; primero se ejecuta sync para conservar los datos modificados).

Pasar el control a

  • jetson-headless-mode: la mayor mejora en el espacio de usuario en sistemas que aún arrancan con graphical.target.
  • jetson-inference-mem-tune: cuando un servidor de modelos es el principal consumidor de NvMap / PSS.
  • Si los cambios en tiempo de ejecución no pueden alcanzar el objetivo, informa de que una mayor recuperación queda fuera del alcance de esta función, en lugar de sugerir modificaciones inseguras durante el arranque.
Ver en GitHub
---
name: jetson-memory-audit
description: Measure Jetson DRAM and NvMap usage, capture before/after baselines, and verify memory reclamation with live audit data.
license: Apache-2.0
---

# Jetson Memory Audit

Read-only memory-focused snapshot for a Jetson, plus the `drop_caches` verify-loop helper that confirms freed memory actually shows up as free instead of cached.

## Purpose

Measure current Jetson memory consumers, capture before/after baselines, and verify whether user-approved changes actually reclaimed DRAM. Use live device data rather than estimates from container size, model size, or generic process memory.

## CRITICAL: Memory appears stuck after stopping vLLM / sglang (JetPack below 7.2 / L4T below r39.0)

**This is the most common memory confusion on Jetson releases before JetPack 7.2 or before L4T r39.0.**

After you stop a vLLM, sglang, or Ollama server (or any CUDA workload), the memory shown as free by `free -h` or `tegrastats` may not recover — even though the process is gone. `nvidia-smi` may also show misleadingly low free GPU memory.

**Root cause:** The Thor RM (resource manager) holds freed sysmem pages in its own pool after a CUDA context exits. On Unified Memory Architecture (UMA) devices like Jetson, `cudaMemGetInfo` reads RM pool state and reports far less free memory than is actually available to a new process.

**Workaround (for JetPack below 7.2 or L4T below r39.0):**
```bash
sudo sync && sudo sysctl -w vm.drop_caches=3
```
Run this on the **host**, not inside a container. The important operation is `sudo sysctl -w vm.drop_caches=3`; keep `sudo sync` immediately before it so dirty data is flushed before reclaimable page/dentry/inode caches are dropped. After running it, `free -h` and `tegrastats` will reflect the true available memory.

For affected releases, recommend this command when a user says:
- "Memory didn't free after I stopped vLLM/sglang"
- "Why does tegrastats still show high usage after my container exited?"
- "OOM even though nothing is running"
- "Memory was fine yesterday but now it's full"

On JetPack below 7.2 or L4T below r39.0, `drop_caches` is the reliable workaround when memory appears stuck after a CUDA workload exits; on newer releases, use it only if the same symptom is observed and the user approves.

## When to use

- "How much memory is in use on this Jetson? What's holding it?"
- "I disabled the GUI / stopped vLLM / quit my container — did memory actually free?"
- "Why does `free -h` still show low free memory after I stopped my workload?"
- As the **baseline** before applying `jetson-headless-mode` or other memory-related changes, and again **after** to compute the actual delta.

## Prerequisites

- Run on the Jetson host, or in a sandbox/container with host-visible `/proc`, `/etc/nv_tegra_release`, `tegrastats`, and process data.
- NvMap debugfs reads may require root. If unavailable, report that GPU memory attribution is limited rather than guessing.
- `drop_caches.sh` requires root or passwordless `sudo -n`; run it only after the user explicitly authorizes cache dropping.

## Available Scripts

| Script | Purpose | Arguments |
|--------|---------|-----------|
| `scripts/audit.sh` | Emits a JSON snapshot from `jetson-diagnostic/scripts/snapshot.sh` for memory audit workflows. | No arguments. |
| `scripts/drop_caches.sh` | Flushes reclaimable page/dentry/inode caches and prints before/after memory deltas. | `--mode 1\|2\|3`, `--quiet`. |

If your agent runtime supports `run_script`, use it to run `scripts/audit.sh` or `scripts/drop_caches.sh` and summarize the returned output. Otherwise run the scripts with `bash` from the repository root.

## Instructions

For "how much memory is in use right now?" questions, run `scripts/audit.sh` and report only values from the JSON snapshot.

## Reporting guidance

Do not only print or mention the path to a helper. Invoke the helper and then summarize the returned data.

- For "how much memory is in use" prompts, run `scripts/audit.sh` and quote `mem_total_gb`, `memory_kb.available`, and the leading `procrank_top` process or `nvmap.top_clients` consumer.
- For GUI/desktop memory prompts, run `scripts/audit.sh` and report `default_systemd_target` plus any display manager in `candidate_services` (`gdm3`, `gdm`, `lightdm`, `sddm`, or `display-manager`). Do not disable anything; hand off to `jetson-headless-mode` for a plan.
- For prompts that explicitly authorize cache dropping after a stopped workload, run `scripts/drop_caches.sh` (equivalent to `sudo sync && sudo sysctl -w vm.drop_caches=3` by default) and report its before/after free, available, and cached deltas. If root is unavailable, explain that it must be run on the host with sudo.

If your agent runtime does not execute helper scripts relative to this skill directory, resolve script paths with the AgentSkills `{baseDir}` placeholder:

```bash
{baseDir}/scripts/audit.sh
{baseDir}/scripts/drop_caches.sh
```

Do not call `jetson-memory-audit` as a tool name unless the runtime explicitly registers skills as callable tools; Agent Skills are normally instructions plus files, not direct tool functions.

Sandbox note for agents: seeing this skill file does not guarantee access to Jetson host memory data. If `/proc/device-tree/model`, `/etc/nv_tegra_release`, `tegrastats`, `/sys/kernel/debug/nvmap`, or host process data are missing inside a NemoClaw/OpenClaw sandbox, say the sandbox lacks Jetson host visibility and ask the user to run on the Jetson host or relaunch with a host-visible sandbox profile. Do not fabricate memory totals, available memory, PSS, NvMap, or reclamation deltas.

For "how much memory did this change free?" questions, use a before/after delta. Do not estimate freed memory from container size, image size, RSS, or a single post-change snapshot.

1. Before the change, run `scripts/audit.sh` and save the JSON baseline.
2. Make the user-approved change (stop the container, switch mode, apply a tuning recommendation, etc.).
3. On JetPack below 7.2 / L4T below r39.0, or when the same stuck-memory symptom is observed on a newer release, flush reclaimable page cache on the **host** (not inside a container) so freed pages show up as free instead of cached:
   ```bash
   sudo sync && sudo sysctl -w vm.drop_caches=3
   ```
4. Re-run `scripts/audit.sh` and compare `memory_kb.available` before vs after — that delta is the real reclamation.

If the user already made the change and no baseline exists, say that the exact freed amount cannot be recovered from the current snapshot alone. Capture a new baseline now so the next change can be measured.

Use live audit data as the source of truth. Memory totals, available memory, NvMap totals, PSS values, display-manager state, and savings deltas must come from `scripts/audit.sh`, `free -h`, or `tegrastats` on the actual device. If a number is not present in those outputs, do not guess it.

## Output contract for `audit.sh`

```json
{
  "sku": "orin-nano",
  "variant": "orin-nano-8gb",
  "mem_total_gb": 8,
  "l4t_version": "36.4.0",
  "product_model": "nvidia jetson orin nano developer kit",
  "memory_kb": { "total": 8123456, "available": 4123456, "free": 1023456, "cached": 1234567, "swap_total": 0, "swap_free": 0 },
  "default_systemd_target": "graphical.target",
  "candidate_services": { "gdm3": { "active": "active", "enabled": "enabled" } },
  "tegrastats_sample": "RAM 4011/8138MB (lfb 8x4MB) ...",
  "nvmap": { "readable": false, "total_kb": 0, "top_clients": [] },
  "procrank_top": [ { "pid": 4321, "pss_kb": 4000000, "cmd": "vllm" } ]
}
```

## Limitations

- Exact freed-memory deltas require a before snapshot, the user-approved change, cache flush when appropriate, and an after snapshot.
- NvMap attribution depends on host-visible debugfs access; if it is unavailable, report limited GPU memory attribution instead of guessing.
- Sandbox/container runs may not see host `/proc`, `tegrastats`, systemd, or NvMap data unless the runtime exposes them.

## Error handling

- If `scripts/audit.sh` cannot access host Jetson data, report the missing visibility and ask to rerun on the Jetson host or in a host-visible sandbox.
- If `scripts/drop_caches.sh` lacks root or passwordless `sudo -n`, report that cache dropping must be run on the host with sudo approval.
- If no before snapshot exists, say the exact reclaimed amount cannot be recovered from the current state alone and capture a new baseline for the next change.

## Safety

Read-only. `drop_caches` is non-destructive (kernel only releases pages it could reclaim under pressure anyway; `sync` runs first to preserve dirty data).

## Hand off to

- `jetson-headless-mode` — biggest single user-space win on systems still booting `graphical.target`.
- `jetson-inference-mem-tune` — when a model server is the top NvMap / PSS consumer.
- If runtime changes cannot hit the target, report that further reclamation is outside this skill's scope rather than suggesting unsafe boot-time edits.

Instalar jetson-memory-audit

Descarga y descomprime los archivos de habilidades en tu directorio .claude/skills/.

Descargar ZIP

Clona el repositorio y copia los archivos de la habilidad a tu proyecto.

git clone https://github.com/NVIDIA/skills/tree/main/skills/jetson-memory-audit # Copy SKILL.md to your .claude/skills/ directory

Copiar Copiar
Configuración rápida: Copia la carpeta de la habilidad en .claude/skills/ Claude detectará y utilizará automáticamente la habilidad
Repositorio NVIDIA/skills

Habilidades relacionadas

gmgn-portfolio
Tiempo actualizado 1 de julio de 2026
device-integrity
Tiempo actualizado 29 de junio de 2026
zeroize-audit
Tiempo actualizado 1 de julio de 2026
flutter-use-http-package
Tiempo actualizado 30 de junio de 2026
OR