option
MaisonMaison Skill Sécurité jetson-memory-audit

jetson-memory-audit

NVIDIA/skills NVIDIA/skills

Mesurer l'utilisation de la DRAM Jetson et de NvMap, enregistrer les valeurs de référence avant et après, et vérifier la récupération de mémoire à l'aide de données d'audit en temps réel.

...Développer tout
15
Heure mise à jour 24 septembre 2026

Audit de la mémoire du Jetson

Instantané axé sur la mémoire morte (ROM) pour un Jetson, ainsi que l'utilitaire « drop_caches » de la boucle de vérification qui confirme que la mémoire libérée apparaît bien comme libre et non comme mise en cache.

Objectif

Mesurer les consommateurs actuels de mémoire sur le Jetson, capturer des valeurs de référence avant/après, et vérifier si les modifications approuvées par l’utilisateur ont effectivement libéré de la DRAM. Utiliser les données en temps réel de l’appareil plutôt que des estimations basées sur la taille des conteneurs, la taille des modèles ou la mémoire générique des processus.

CRITIQUE : la mémoire semble bloquée après l'arrêt de vLLM / sglang (JetPack inférieur à la version 7.2 / L4T inférieur à la version r39.0)

Il s’agit de la confusion la plus courante concernant la mémoire sur les versions de Jetson antérieures à JetPack 7.2 ou à L4T r39.0.

Après avoir arrêté un serveur vLLM, sglang ou Ollama (ou toute charge de travail CUDA), la mémoire affichée comme libre par la commande `free -h` ou par `tegrastats` peut ne pas être libérée — même si le processus a cessé d’exister. La commande `nvidia-smi` peut également afficher un niveau de mémoire GPU libre trompeusement bas.

Cause première : le gestionnaire de ressources (RM) Thor conserve les pages de mémoire système libérées dans son propre pool après la fermeture d’un contexte CUDA. Sur les appareils dotés d’une architecture à mémoire unifiée (UMA) comme le Jetson, la commande `cudaMemGetInfo` lit l’état du pool du RM et indique une quantité de mémoire libre bien inférieure à celle réellement disponible pour un nouveau processus.

Solution de contournement (pour JetPack antérieur à la version 7.2 ou L4T antérieur à la version r39.0) :

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

Exécutez cette commande sur l’hôte, et non à l’intérieur d’un conteneur. L’opération importante est sudo sysctl -w vm.drop_caches=3; veillez à exécuter sudo sync immédiatement avant celle-ci afin que les données non validées soient vidées avant que les caches de pages, de dentry et d’inode récupérables ne soient supprimés. Une fois cette commande exécutée, les commandes ` free -h ` et ` tegrastats ` afficheront la mémoire réellement disponible.

Pour les versions concernées, il est recommandé d’utiliser cette commande lorsqu’un utilisateur signale :

  • « La mémoire n’a pas été libérée après l’arrêt de vLLM/sglang »
  • « Pourquoi tegrastats affiche-t-il toujours une utilisation élevée après la fermeture de mon conteneur ? »
  • « Erreur OOM alors que rien ne s’exécute »
  • « La mémoire fonctionnait bien hier, mais elle est désormais pleine »

Sur JetPack antérieur à la version 7.2 ou L4T antérieur à la version r39.0, la commande `drop_caches` constitue une solution de contournement fiable lorsque la mémoire semble bloquée après la fin d’une charge de travail CUDA ; sur les versions plus récentes, n’utilisez-la que si le même symptôme est observé et que l’utilisateur donne son accord.

Quand l’utiliser

  • « Quelle quantité de mémoire est utilisée sur ce Jetson ? Qu'est-ce qui l'occupe ? »
  • « J’ai désactivé l’interface graphique / arrêté vLLM / quitté mon conteneur — la mémoire a-t-elle réellement été libérée ? »
  • « Pourquoi la commande free -h indique-t-elle toujours un faible niveau de mémoire libre après l’arrêt de ma charge de travail ? »
  • Comme référence avant d’appliquer jetson-headless-mode ou d’autres modifications liées à la mémoire, puis à nouveau après pour calculer le delta réel.

Prérequis

  • Exécutez cette commande sur l’hôte Jetson, ou dans un bac à sable/conteneur où l’hôte a accès aux répertoires /proc, /etc/nv_tegra_release, tegrastats et aux données des processus.
  • La lecture de NvMap debugfs peut nécessiter les droits root. Si cela n’est pas possible, signalez que l’attribution de mémoire GPU est limitée plutôt que de faire des suppositions.
  • Le script `drop_caches.sh` nécessite les droits root ou l’utilisation de `sudo -n` sans mot de passe ; ne l’exécutez qu’après que l’utilisateur a explicitement autorisé la suppression des caches.

Scripts disponibles

Script Objectif Arguments
scripts/audit.sh Génère un instantané JSON à partir de jetson-diagnostic/scripts/snapshot.sh pour les workflows d'audit de la mémoire. Aucun argument.
scripts/drop_caches.sh Vide les caches de pages, de dentry et d'inode récupérables et affiche les écarts de mémoire avant et après. --mode 1|2|3, --quiet.

Si votre environnement d'exécution d'agent prend en charge la commande run_script, utilisez-la pour exécuter scripts/audit.sh ou scripts/drop_caches.sh et résumez la sortie renvoyée. Sinon, exécutez les scripts avec bash depuis la racine du référentiel.

Instructions

Pour répondre à la question « Quelle quantité de mémoire est actuellement utilisée ? », exécutez scripts/audit.sh et ne rapportez que les valeurs issues de l’instantané JSON.

Consignes de rapport

Ne vous contentez pas d’afficher ou de mentionner le chemin d’accès à un utilitaire. Lancez l’utilitaire, puis résumez les données renvoyées.

  • Pour les demandes du type « Quelle quantité de mémoire est utilisée ? », exécutez scripts/audit.sh et indiquez les valeurs de mem_total_gb, memory_kb.available, ainsi que le processus procrank_top en tête ou le consommateur nvmap.top_clients.
  • Pour les demandes concernant la mémoire de l’interface graphique/du bureau, exécutez scripts/audit.sh et indiquez default_systemd_target ainsi que tout gestionnaire d’affichage présent dans candidate_services (gdm3, gdm, lightdm, sddm ou display-manager). Ne désactivez rien ; remettez la question à jetson-headless-mode pour qu’il propose une solution.
  • Pour les invites autorisant explicitement la suppression du cache après l’arrêt d’une charge de travail, exécutez scripts/drop_caches.sh (équivalent à sudo sync && sudo sysctl -w vm.drop_caches=3 par défaut) et signalez les écarts avant/après en termes de mémoire libre, de mémoire disponible et de mémoire mise en cache. Si l’utilisateur root n’est pas disponible, précisez que la commande doit être exécutée sur l’hôte à l’aide de sudo.

Si le runtime de votre agent n’exécute pas les scripts d’assistance relatifs à ce répertoire de compétences, résolvez les chemins d’accès aux scripts à l’aide de l’espace réservé AgentSkills {baseDir}:

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

N’utilisez pas jetson-memory-audit comme nom d’outil, sauf si le runtime enregistre explicitement les compétences en tant qu’outils appelables ; les compétences d’agent sont normalement des instructions associées à des fichiers, et non des fonctions d’outils directes.

Remarque concernant le bac à sable pour les agents : le fait de voir ce fichier de compétence ne garantit pas l’accès aux données de la mémoire de l’hôte Jetson. Si /proc/device-tree/model, /etc/nv_tegra_release, tegrastats, /sys/kernel/debug/nvmap ou les données des processus de l’hôte sont absentes au sein d’un bac à sable NemoClaw/OpenClaw, indiquez que le bac à sable ne dispose pas de visibilité sur l’hôte Jetson et demandez à l’utilisateur d’exécuter le script sur l’hôte Jetson ou de relancer l’opération avec un profil de bac à sable offrant une visibilité sur l’hôte. Ne fabriquez pas de chiffres concernant la mémoire totale, la mémoire disponible, le PSS, le NvMap ou les deltas de récupération de mémoire.

Pour répondre aux questions du type « Quelle quantité de mémoire cette modification a-t-elle libérée ? », utilisez un delta avant/après. N’estimez pas la mémoire libérée à partir de la taille du conteneur, de la taille de l’image, du RSS ou d’un simple instantané postérieur à la modification.

  1. Avant la modification, exécutez le script audit.sh et enregistrez la référence JSON.
  2. Effectuez la modification approuvée par l’utilisateur (arrêtez le conteneur, changez de mode, appliquez une recommandation d’optimisation, etc.).
  3. Sur JetPack antérieur à la version 7.2 / L4T antérieur à la version r39.0, ou lorsque le même symptôme de mémoire bloquée est observé sur une version plus récente, videz le cache de pages récupérables sur l’hôte (et non à l’intérieur d’un conteneur) afin que les pages libérées apparaissent comme libres plutôt que mises en cache :
    sudo sync && sudo sysctl -w vm.drop_caches=3
    
    
  4. Relancez le script scripts/audit.sh et comparez la valeur de memory_kb.available avant et après — cet écart correspond à la quantité de mémoire réellement récupérée.

Si l’utilisateur a déjà effectué la modification et qu’aucune référence n’existe, indiquez que la quantité exacte de mémoire libérée ne peut pas être déterminée à partir du seul instantané actuel. Enregistrez une nouvelle référence dès maintenant afin de pouvoir mesurer la prochaine modification.

Utilisez les données d’audit en temps réel comme source de référence. Les totaux de mémoire, la mémoire disponible, les totaux NvMap, les valeurs PSS, l'état du gestionnaire d'affichage et les écarts d'économies doivent provenir de scripts/audit.sh, de la commande free -h ou de tegrastats sur l'appareil concerné. Si une valeur n'apparaît pas dans ces résultats, ne la devinez pas.

Exemple de sortie pour 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 Mo (lfb 8x4 Mo) ...",
  "nvmap" : { "readable" : false, "total_kb" : 0, "top_clients" : [] },
  "procrank_top" : [ { "pid" : 4321, "pss_kb" : 4000000, "cmd" : "vllm" } ]
}

Limites

  • Pour obtenir des deltas précis de mémoire libérée, il faut disposer d’un instantané « avant », de la modification approuvée par l’utilisateur, d’un vidage du cache le cas échéant, et d’un instantané « après ».
  • L’attribution NvMap dépend de l’accès au debugfs visible par l’hôte ; s’il n’est pas disponible, signalez une attribution limitée de la mémoire GPU plutôt que de faire des estimations.
  • Les exécutions en sandbox ou en conteneur peuvent ne pas avoir accès aux données /proc, tegrastats, systemd ou NvMap de l’hôte, à moins que l’environnement d’exécution ne les expose.

Gestion des erreurs

  • Si le script `scripts/audit.sh` ne parvient pas à accéder aux données du Jetson hôte, signalez l’absence de visibilité et demandez de relancer le script sur le Jetson hôte ou dans un bac à sable accessible depuis l’hôte.
  • Si le script scripts/drop_caches.sh ne dispose pas des droits root ou d’un sudo -n sans mot de passe, signalez que la suppression du cache doit être effectuée sur l’hôte avec l’autorisation sudo.
  • S’il n’existe aucun instantané antérieur, indiquez que le volume exact récupéré ne peut être déterminé à partir de l’état actuel seul et enregistrez une nouvelle référence pour la prochaine modification.

Sécurité

En lecture seule. La commande `drop_caches` est non destructive (le noyau ne libère de toute façon que les pages qu’il pourrait récupérer en cas de pression ; la commande `sync` s’exécute en premier pour préserver les données modifiées).

Transfert vers

  • jetson-headless-mode — le plus grand gain en espace utilisateur sur les systèmes démarrant encore avec graphical.target.
  • jetson-inference-mem-tune — lorsqu’un serveur de modèles est le principal consommateur de NvMap / PSS.
  • Si les modifications en cours d’exécution ne permettent pas d’atteindre l’objectif, signalez qu’une récupération supplémentaire dépasse le champ d’application de cette compétence, plutôt que de suggérer des modifications non sécurisées au démarrage.
Voir sur 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.

Installer jetson-memory-audit

Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

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

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera automatiquement la compétence et l'utilisera
Dépôt NVIDIA/skills

Compétences similaires

gmgn-portfolio
Heure mise à jour 1 juillet 2026
device-integrity
Heure mise à jour 29 juin 2026
zeroize-audit
Heure mise à jour 1 juillet 2026
flutter-use-http-package
Heure mise à jour 30 juin 2026
OR