Skip to content
- Each release carries its docs for docs.pitomd.com: install, a guide for every task, the command line, the JSON formats and the changelog.
- pgpu is 1.0.0: the queue, its commands and its JSON stay as they were in 0.31.3.
- The README shows every feature in a short clip (lanes, turns, budgets and memory ceilings, the JSON for scripts) and the measured numbers: 2.1 ms to start a job, 5.7 ms to hand a lane on, one 2 MB binary.
- The brand reads PITO MD.
- Running alone: –alone and –exclusive are still accepted but only print that the job shares a lane, and no job waits for an empty queue or the night.
- The lanes are GPU_SLOTS, never more: no lane opens past them however idle the card, and a wrapper from an older pgpu can’t open one either.
- A waiting job that doesn’t take a free GPU lane within 3 s, such as one queued under an older pgpu, is passed over by the jobs behind it, so it no longer stalls the queue.
- pgpu reads its settings from ~/.config/pgpu/config: GPU_SLOTS, GPU_SLOTS_FROM (a file whose GPU_SLOTS line overrides it), LEND and PRIORITY.
- Any AMD GPU on amdgpu with a busy reading drives the lanes, the one with the most VRAM when there are several.
- A waiting job’s reason and a bench’s end line are shorter: “all 2 lanes busy, card 9%: waits its turn (a lane opens under 70%)”.
- Crash reports: pgpu sends nothing anywhere.
- No GPU lane opens past GPU_SLOTS while a job queued under an older pgpu still waits, since its wrapper counts only GPU_SLOTS and would wait behind the new lanes.
- The GPU lanes follow the card: GPU_SLOTS is the floor, and one more lane opens (one per 10 s, up to 4) while jobs wait, the card averages under 70% busy over 10 s and VRAM is under 80%; over 90% or with VRAM over 80% no new lane opens, and a held lane is never taken back. Ordinary jobs no longer lend their lane by default.
- Every finished bench, and every re-run alone, says how many other jobs held a lane beside it and how busy the GPU was on average, on stderr and in pgpu stats (stats –json’s benches).
- Running alone is only for re-running a number that looks skewed: –alone “” replaces –exclusive, which is refused bare. By day the re-run waits for an empty queue; at night nothing new starts behind it while running jobs finish, so it never jumps the line or makes a job yield. The 60 s backfill beside a waiting bench is gone.
- A bench takes a GPU lane like any other class and runs beside the rest: it no longer runs alone, drains the card or makes running jobs yield to it. Running alone stays the opt-in –exclusive.
- Jobs backfill free lanes beside a waiting bench (or –exclusive job) for 60 s after it arrives and keep them at their turns; then nothing new starts, holders hand over at their next turn, and the bench runs alone once the card clears. pgpu status says “backfilling beside a waiting bench: 42 s left” on the bench meanwhile.
- On the live queue pgpu reads its config and state from the user’s own home whatever XDG_CONFIG_HOME and XDG_STATE_HOME say, so a job run inside a prec tape’s home (HOME and both XDG folders pointed there) sees both GPU lanes and logs to the real log.tsv; 0.30.5 covered HOME alone. A queue of its own (its own XDG_RUNTIME_DIR) still uses the XDG folders.
- Two lanes run two jobs again when a job is started with HOME pointed elsewhere (a prec tape): pgpu reads its config and state from the user’s home in the password database, not $HOME, so such a job no longer sees one lane, waits while the other sits free, or logs its holds outside log.tsv.
- Every waiting job in pgpu status has a waits_for and a reason, and “all GPU lanes busy” is said only when they are.
- A bench job, or one run with –exclusive, lends its lanes once its own GPU use has stayed under 5% for 10 s while a job could start, and takes them back the moment it uses the GPU again by freezing the jobs it lent them to; it is never frozen itself. A borrower’s hold ends as reclaim in log.tsv.
- pgpu status notes a bench idling the card, lists a lent bench as lent, and status –json gives every job’s idle_ms.
- A job that runs alone prints at its end how long it held the GPU alone, how busy the GPU was in that time, and how often it lent its lanes.
- A job never outlives or leaves its cell: an interrupted pgpu run signals every process of the job and kills what is left after 2 s, a job’s leftovers are killed when its command ends, and a wrapper killed with SIGKILL has its job killed by the next pgpu call; before, they were moved out of the cell and ran on past the memory ceiling.
- A bench job, or one run with –exclusive, keeps every lane until it ends: it never lends the GPU during its CPU steps and never hands it over at a turn, so it is never frozen waiting for the card.
- The file GPU_QUEUE_FROZEN names counts the time a job waits in pgpu turn for the GPU, not only freezes, and holds the same number as the end-of-run line and status –json’s frozen_ms.
- The stall check counts the job’s whole process tree, also processes that left its cell (a systemd-run –scope inside the job), and a stop kills them too; such a job read as idle and was stopped after 5 minutes while it worked.
- A memory ceiling for every job: 24G for every class, –memory to set another; the kernel slows the job at 15/16 of it and kills the whole job past it, with no swap.
- A job killed at its ceiling prints why, exits 137, and is recorded as memory in log.tsv and stats –json’s killed, which gains memory_bytes.
- A job’s cgroup sits beside its wrapper’s, in the same slice, so it gets the memory controller.
- GPU lanes: as many jobs hold the GPU at once as there are GPU lanes (GPU_SLOTS).
- A bench job, or one run with –exclusive, runs alone and keeps the jobs behind it out of a free lane.
- Budgets: every run has one (–budget, else its class’s); past it a job shows red, and at twice it or after 5 minutes with no GPU work, turn or CPU it is stopped and exits 124.
- Frozen time is reported: a job frozen or waiting for the GPU a second or more says so on stderr when it ends, and status –json has frozen_ms.
- Classes test, render and bench; status –json’s why, alone, budget_ms, ran_ms, over_ms and frozen_ms; waits_for alone and turn; stats –json’s killed.
- An interactive job that has run 60 s, or never calls turn in its first 5 s, takes turns as a clip.
- A job waiting its turn says why in status instead of nothing.
- pgpu uses the GPU all the time: the desk share, the desk guard, presence and away detection, the play rule and game freeze, the video-memory guard, render-CPU confinement, pgpu play and stats –play are removed with their knobs; status –json keeps play, away, away_reason and desk as null.
