File size: 4,593 Bytes
0f775e2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 | # Managing background processes — READ THIS before you `kill` anything
You may start and stop background processes while iterating — a **server**, a long **build** or
**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
*your own agent process* and end the whole run.** This has happened repeatedly, including via a
hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.
## The trap: matching task text against process command lines
You were launched as roughly:
```
claude --print -- '<the entire task instruction text>'
```
The full task instruction is on **your own** process's command line, and it contains the file names
and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
So **any** command that finds processes by matching those strings will match — and can kill — **the
agent itself**:
```
pkill -9 -f "train.py" # matches the claude agent -> kills YOU
pgrep -f "server.py" | xargs kill # same: the pid list includes claude
for p in $(pgrep -f build.sh); do kill -9 $p; done # same
for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done # same
```
It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
worse than what you were about to finish.
## The one safe rule: kill only the exact PID you recorded
**Start** a background job and record its PID in a file:
```bash
nohup <your command> > /tmp/job.log 2>&1 &
echo $! > /tmp/job.pid
```
**Stop / restart** by that exact PID — never by a name pattern:
```bash
kill "$(cat /tmp/job.pid)" 2>/dev/null # SIGTERM: lets it release the GPU / flush cleanly
sleep 3
kill -9 "$(cat /tmp/job.pid)" 2>/dev/null # force only if it did not exit
```
If the job spawns workers, run it in its own process group and signal the group by its (negative)
PGID — still an exact id, never a pattern:
```bash
setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
```
## If you ever enumerate processes, EXCLUDE the agent
Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
a unique name and match only that:
```bash
# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash' # LOOK FIRST
# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
```
Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
single addition re-introduces the self-kill. Match the unique token **only**.
## Freeing the GPU without going nuclear
If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
`/proc` sweep:
- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
the process fully exits.
- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
single `kill $PID` is enough.
- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
confirming its cmdline is **not** `claude` / `--print`.
## Rules of thumb
- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
agent (its argv holds the prompt).
- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
and your own shell**; `pgrep -af` and look before you kill.
- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.
|