Waarom de geheugenlimiet buiten het proces moet liggen
Een ontwerpnotitie uit mlx-guard: wat een geheugenbewaker binnen het proces niet kan beloven op
Apples unified memory, en de externe supervisor die voor de buitenste ring is gebouwd
Update van 2026-11-13: wat er veranderde in mlx-guard 0.2 tot en met 0.5
De conclusie blijft overeind bij mlx-guard v0.5.0 (gepubliceerd op 2026-11-12): de limiet moet
buiten het proces liggen. De hoofdtekst beschrijft v0.1.0; latere versies komen hier niet aan bod.
In 0.2.0 veranderden drie dingen (changelog). De timeout voor de bevestiging van het coöperatieve checkpoint ging van 100 ms naar 1 s. Exitcode 70 betekent nog steeds dat de supervisor faalde; een kindproces dat stopt vóór de eerste identiteitscontrole, behoudt nu zijn eigen status. Pid en starttoken worden nu opnieuw gecontroleerd vlak voordat het checkpoint-signaal wordt afgeleverd; TERM en KILL gaan nog steeds naar de numerieke procesgroep (procesbesturing).
Op dezelfde M1 Max was de fout in de zichtbare delta van een 64 MiB grote Metal-buffer 1.929% bij v0.1.0, 4.028% bij 0.3.1 en 3.272% bij 0.5.0 (bundel), tegenover een grens van 10%. De sampler met een interval van 50 ms gebruikte 2.58% tot 2.89% van één core in zes debugruns van 30 minuten op macOS 27.2. De vier vroegste runs haalden de toen geldende grens van 2% niet; één daarvan draaide op een build van 0.3.1, dus de stijging zit niet alleen in de code van 0.5.0. De oorzaak is niet gevonden, en voor dit cijfer geldt nu geen streefwaarde meer. Bij de andere rijen van de bundel zijn de verschillen klein ten opzichte van hun streefwaarden.
De README noemt één storing die de hoofdtekst niet noemt: de bug in de IOGPU-driver die macOS 26.4 en later onder Metal-workloads een kernel panic bezorgt (eind augustus 2026 nog niet opgelost, volgens de README). Hij kan toeslaan terwijl de footprint ruim binnen elke limiet blijft, en geen externe supervisor kan erbij (grenzen).
Een MLX-workload die met het geheugen op de loop gaat, faalt niet netjes. Unified memory (geheugen
dat CPU en GPU delen) betekent dat het proces, de window server en de GPU-driver van de kernel
allemaal uit dezelfde pool putten. Een run die de bodem van die pool bereikt, kan eindigen in een
paging-storm, een bevroren machine of een kernel panic, en niet in een allocatiefout die de workload
had kunnen opvangen. Vanuit dat vertrekpunt verdedigt deze notitie één ontwerpclaim: de laatste
verdedigingslinie tegen een ontspoorde workload kan niet in het eigen proces van die workload zitten.
Het moet een aparte supervisor zijn die het getal volgt dat het besturingssysteem in rekening
brengt, eigenaar is van de procesgroep en blijft bestaan om op te schrijven wat er gebeurde.
mlx-guard is de tool die rond die claim is gebouwd; deze
notitie is het ontwerpargument, inclusief de delen van het probleem die het ontwerp bewust niet
claimt op te lossen.
Deze notitie is documentair. Elke meting van mlx-guard in de hoofdtekst komt uit een gecommitte,
linkbare bewijsbundel in de repository op v0.1.0: een begrensde kalibratierun op een Apple M1 Max met
10 cores en 32 GB unified memory, macOS 26.6.1
(bundel van de referentiehost),
en een begrensde integratierun in een project dat de tool gebruikt, op dezelfde vastgelegde
configuratie met MLX 0.32.0 en mlx-lm 0.31.3
(integratiebundel).
Voor dit stuk is niets opnieuw gedraaid. De incidentcijfers in sectie 1 zijn die van de
upstream-melders zelf, geen metingen van ons. In de hoofdtekst zijn links naar broncode, contracten
en bewijs van mlx-guard vastgepind op de publieke tag v0.1.0. De uitzondering is de
SIGKILL-beperking van de supervisor in sectie 4: die linkt, net als de bronnen van de update, naar
v0.5.0. Figuur 1 en de PlantUML-bron ervan komen van main, en begeleidende notities en
upstream-issues zijn gelinkt op hun publieke vindplaats.
1. Twee openbare incidenten, één faalpatroon
Twee onafhankelijke meldingen over de MLX-stack bakenen het probleem beter af dan een synthetische demonstratie dat zou kunnen.
In MLX issue #3896 volgde een streaming
saliency-workload op een mixture-of-experts-model met 198 miljard parameters zijn geheugen met de
eigen teller van het framework. mx.get_peak_memory() meldde ongeveer 46 GB, terwijl de
macOS-tool footprint ongeveer 109 GB aan IOAccelerator-allocaties (GPU) liet zien en een
phys_footprint (de boekhouding van het besturingssysteem zelf van wat het proces vasthoudt) van
ongeveer 110 GB: een onderschatting van ongeveer 2.4×. Doordat die teller als signaal voor
geheugendruk werd vertrouwd, overschreed het proces twee keer de veilige working set van de machine.
De ene keer eindigde dat in een GPU-watchdog-timeout van een Metal-command-buffer, de andere keer in
een volledige harde reboot.
Dat issue is gesloten, en de verklaring is geen mysterie. get_peak_memory() telt alleen de actieve
bytes van de allocator, dus buffers die MLX in zijn cache-pool bewaart (nog steeds resident, nog steeds
GPU-dirty, dus door de GPU beschreven) komen nooit in dat getal terecht. Een MLX-maintainer sloot de
melding met de opmerking dat de teller bedoeld is om één model te meten, waarbij de cache-hitrate bijna
100% is, en dat langlopende of parallelle serving get_active_memory() + get_cache_memory() hoort te
lezen. Een churn-test van een bijdrager liet zien dat dat paar het OS-cijfer tot op 0.14 GB volgde, in
een run waarin het piekgeheugen 1.00 GB meldde tegenover een footprint van 60.19 GB. De fix is echt,
maar het is een fix van de aflezing: een gecorrigeerde teller beschrijft nog steeds de allocator van
één proces, en hij draait nog steeds binnen het proces dat hij moet bewaken. De operationele les blijft
overeind: elke beslissing die hing aan de teller die deze workload werkelijk las, zou zijn genomen
meer dan 60 GB onder het getal dat het besturingssysteem het proces in rekening bracht.
In mlx-lm issue #883 liet een
mlx_lm.server-instantie die een 30B-model serveerde haar KV-cache onbegrensd groeien tijdens een
lange agentische sessie. Op het moment van de crash was de footprint van het proces 83.23 GB op een
machine met 96 GB, en 80.14 GB van het geheugen was wired: vastgezet, zodat het OS het niet kan
wegswappen. De machine kreeg een kernel panic in IOGPUMemory.cpp:550
(completeMemory() prepare count underflow) en startte geforceerd opnieuw op.
Geen van beide incidenten is een gecontroleerd experiment voor welke bewakingstool dan ook, en deze notitie beweert niet dat een supervisor een van beide machines had gered. De incidenten zeggen iets over signalen en grenzen. Het eerste laat zien dat de teller van het framework en de boekhouding van het OS tientallen gigabytes uiteen kunnen lopen, juist bij de workloads die een limiet het hardst nodig hebben. Het tweede laat zien wat het gat vult als er buiten het falende proces geen grens bestaat.
2. Een limiet binnen het proces is al geprobeerd
Het voorgaande artikel, When an MLX Memory Cap Is Not a Safety Boundary, beschrijft een machine voor trainingsbenchmarks die een kernel panic kreeg terwijl de geheugenlimieten van MLX waren ingesteld. Het beschrijft ook de watchdog (een bewakingsthread) binnen het proces die het project daarna toevoegde, en noemt die best-effort. De conclusie: een limiet of een watchdog binnen het falende proces is geen veiligheidsgrens. Een afbreekpad dat betrouwbaarder moet zijn dan de falende workload, kan geen thread daarbinnen zijn; het moet een ander proces zijn.
3. De teller die je volgt is niet de rekening die je betaalt
Een bewaker binnen het proces volgt bijna altijd de tellers van het framework, omdat het proces die
getallen goedkoop kan zien. Welke teller hij volgt, maakt uit: #3896 is het waarschuwende voorbeeld,
en wie get_active_memory() + get_cache_memory() leest, dicht het grootste deel van dat specifieke
gat. Maar ook een correct gelezen allocatortotaal is de blik van de allocator op één proces. Het
besturingssysteem houdt per proces een eigen rekening bij, phys_footprint, en die beperkt zich
niet tot wat het framework alloceerde: de kalibratie hieronder ziet er zowel een gewone anonieme
allocatie als een Metal-buffer in terug. Die rekening is ook uit te lezen voor processen die het
framework helemaal niet beheert: een dataloader, een tokenizer-service, een gestarte conversiestap.
Het
integratiecontract voor mlx-train-perf
zegt hetzelfde over de eigen in-process fallback van dat project: die samplet alleen
mx.get_active_memory(), MLX-cachegeheugen is een aparte, bewaarde pool die buiten het zicht van het
plafond kan blijven, en de footprint volgens het OS, die de externe supervisor leest, dekt alles wat
het OS het proces verder toerekent.
mlx-guard leest geheugen daarom zoals het OS dat doet:
proc_pid_rusage(RUSAGE_INFO_V0)
phys_footprint, per proces, opgeteld over de procesgroep die de tool bezit. In v0.1 leest
de tool de tellers van het framework helemaal niet. Systeembrede signalen (druk, swap, compressor,
wired-totalen) legt hij vast als adviserende context, niet als invoer voor handhaving, omdat geen
ervan aan het commando onder supervisie toe te schrijven is. De drempel wordt vergeleken met de
opgetelde phys_footprint van alle leden van die groep. Die som kan pages die binnen de
boom worden gedeeld dubbel tellen; de contracten presenteren haar als herhaalbare invoer voor
interventie, niet als totaal van unieke pages.
De gecommitte kalibratie van v0.1.0 laat zien hoe groot de fout van die keuze kan zijn op de referentiehost onder macOS 26.6.1: de grootste waargenomen fout was 0.073% bij een anonieme allocatie van 64 MiB en, over tien runs, 1.929% bij de zichtbare footprint-delta van een Metal-buffer van 64 MiB. Dat zijn maxima uit een begrensde run op één machine, geen statistische grenzen en geen grenzen die over hosts heen gelden. Het signaal is niet perfect (sectie 8 gaat over de grenzen ervan), maar het is de juiste grootheid, getoetst aan bekende allocaties.
4. De bewaker deelt het lot van wat hij bewaakt
Zet de handhavingslus in het proces, en hij erft de slechtste momenten van dat proces. Hij draait op een thread in dezelfde adresruimte, wordt gescheduled door dezelfde uitgehongerde machine en gedood door dezelfde SIGKILL. Concreet geldt voor een bewaker binnen het proces:
- Hij kan het proces niet overleven om te vertellen wat er gebeurde. Na de OOM-kill, de crash of de panic is er geen thread meer over om het rapport te schrijven. Het forensische verslag (wat groeide, hoe snel, wat de bewaker besloot, of beëindiging is geprobeerd) sterft met het proces, precies op het moment dat het nodig was.
- Hij wordt gescheduled door de machine die hij moet beschermen. Tijdens een paging-storm is de watchdog gewoon nog een thread van het proces dat de page faults veroorzaakt, zonder voorrang op de workload die hij bewaakt. Geen gepubliceerde run laat een watchdog zien die door uithongering niet aan afbreken toekwam, maar niets in het ontwerp voorkomt dat.
- Hij bewaakt één proces. Een benchmark-runner, een dataloader-pool of een gestarte conversiestap is een procesboom; een limiet die in één lid is geïnstalleerd, ziet geen van de andere.
- Hij sterft voordat hij kan opruimen. Als het bewaakte proces de ouder van de boom is, laat zijn dood de kinderen die hij moest begrenzen als wezen achter.
De externe supervisor keert het eerste, derde en vierde punt om. Zijn eigen dood is de resterende uitzondering: wordt hij met SIGKILL gedood, dan blijft het commando draaien en wordt er geen eindrapport geschreven (README op v0.5.0). Het tweede punt verkleint hij alleen: een klein, apart proces deelt noch de adresruimte, noch de locks van de workload, al overleeft geen user-space-tool een stilstand van de hele machine. Sectie 8 komt op die grens terug.
Het contract voor procesbesturing start het commando als leider van een nieuwe procesgroep waarvan de supervisor eigenaar is; TERM en KILL richten zich op de gevalideerde groep, niet op één PID. Het rapportcontract laat de ouder een journal (een doorlopend logboek) met checksums schrijven en naar schijf synchroniseren terwijl de gebeurtenissen plaatsvinden. Een workload die sterft, laat zo een herstelbaar begin achter op opslag die overleeft en leesbaar blijft.
Een supervisor waarvan de eigen opslag faalt, is een ander geval, en daarvoor belooft het contract geen rapport. Het wegschrijven stopt, de claim van een volledig rapport vervalt en de run eindigt met de exitcode voor een gedeeltelijk artefact. Dat is wat het gecommitte scenario met verlies van opslag laat zien: helemaal geen rapportbestand. Waar de supervisor en zijn opslag wel overleven, komt het artefact snel. Op de referentiehost leverde een externe TERM aan de supervisor bij v0.1.0 nog steeds een eindrapport op, met een p95 van 60.8 ms. Het rapport wordt opgeschoond voordat het wordt weggeschreven: schema v1 heeft geen velden voor ruwe argv, waarden van omgevingsvariabelen, paden, prompts of modelidentifiers. De basename van het uitvoerbare bestand en het aantal argumenten zijn de enige identiteit van het commando die het bewaart, naast een optionele correlatie-hash. Dat haalt de categorieën weg met het grootste risico op een lek, maar het bestand is daarmee niet automatisch veilig om te publiceren. Lees het voordat je het deelt; de supportpagina vraagt om een opgeschoond rapport bij het melden van een issue.
De referentiebundel van v0.1.0 meet ook de claim "overleeft de worker" in zijn goedkoopste vorm. In de lifecycle-scenario's, waaronder workers die TERM weerstaan, een root die snel stopt, verlies van opslag halverwege de run en een checkpoint-timeout, rondde de supervisor een schema-geldig rapport af in elk scenario waarin hij en zijn opslag overleefden. Vier veilige workloads liepen tot het einde door met nul onterechte interventies.
5. macOS geeft je een procesgroep, geen cgroup
Op Linux zou deze tool klein zijn: plaats de boom in een cgroup, stel memory.max in, en de kernel
dwingt de grens af zodra geheugen wordt toegerekend, zonder sampling-lus. Dat geldt althans voor geheugen
aan de CPU-kant; allocaties van device drivers zijn daar ook een verhaal apart. macOS heeft geen
equivalent voor een boom. De kernel houdt wel geheugenlimieten per proces bij (memorystatus, het
mechanisme achter jetsam), en taskpolicy -m start één programma onder zo'n limiet, zoals de
begeleidende methodenotitie
Measuring a macOS process tree honestly
laat zien. Dat is een fataal plafond voor één proces, bij de start ingesteld via een private
interface, geen budget voor een hele boom.
Wat macOS een supervisor wel geeft, is de POSIX-gereedschapskist: procesgroepen, signalen, sampling via
libproc. Elk onderdeel lekt op zichzelf. Een PID wordt herbruikbaar zodra het beëindigde proces is
opgeruimd (reaped), en een supervisor heeft geen zeggenschap over dat opruimen bij processen die hij
niet zelf startte. Een afstammeling kan de groep verlaten met één setsid-aanroep en begint dan een
nieuwe sessie buiten de groep van de supervisor. Het opsommen van een procesboom is niet atomair: de boom kan
veranderen terwijl je hem doorloopt. macOS heeft ook geen stabiele process handle in de stijl van
pidfd; de begeleidende notitie behandelt wat dat kost.
De ontwerpconsequentie is niet "geef het op", maar "bewaak de grens die je kunt bewaken, en leg de
rest vast als bewijs".
Het identiteitscontract
koppelt elk waargenomen proces aan (pid, process_start_abstime). Een lid waarvan het starttoken is
veranderd, wordt daardoor als verouderd vastgelegd, en niet geteld of vertrouwd.
De signaalpaden verdienen een precieze formulering, omdat hun garanties verschillen. In de runtime van v0.1.0 gingen TERM en KILL naar de bewaarde numerieke procesgroep die bij de start was gevalideerd; bij een checkpoint-verzoek werd het lidmaatschap van de groep opnieuw gecontroleerd vlak voordat het verzoek werd afgeleverd (broncode op v0.1.0). Geen van beide toetste op het moment van de systeemaanroep opnieuw een starttoken. Een hergebruikte PID binnen een levende groep, of een hergebruikt groepsnummer nadat de groep van de supervisor leeg was geraakt, was daardoor een reëel, zij het klein, risicovenster op een platform zonder stabiele process handle.
Afstammelingen worden bij elke sample opgespoord. Een afstammeling die buiten de groep van de supervisor wordt waargenomen, wordt vastgelegd als ontsnapping, en die markering geldt voor de hele run. Een latere schone controle op een lege groep kan de run dus nooit stilletjes opwaarderen tot een containment-claim (de bewering dat de hele boom binnen de groep is gebleven). Reparenting (een proces krijgt een nieuwe ouder) en identiteitswijzigingen worden ook vastgelegd, als containment-gebeurtenissen en niet als ontsnappingen. Een afstammeling die zich losmaakt voordat hij ooit is waargenomen, kan volledig worden gemist.
Het totaal volgt dezelfde eerlijkheidsregel als de sampler: als ook maar één lid van de groep van de
supervisor niet gemeten kon worden, is het totaal incomplete. Het blijft bewaard voor diagnose en
wordt nooit met de drempel vergeleken alsof het volledig was.
Dit is het structurele verschil tussen een grens die wordt afgedwongen en een grens die wordt aangetoond. macOS laat de tweede toe. Een tool die op dit platform de eerste claimt voor een procesboom, beschrijft een mechanisme dat het platform niet heeft.
6. Het ontwerp dat daaruit volgt
Een native ouderproces, geen bibliotheek. De supervisor is een gecompileerd uitvoerbaar bestand dat niets van de workload importeert: geen Python, geen MLX, geen koppeling aan een frameworkversie. De handhavingslus draait nooit binnen het proces onder supervisie. Het Python-pakket is een getypeerde client die de binary start; zelf handhaaft het niets.
Een expliciete limiet, nooit een verzonnen limiet. Geen enkel getal is veilig voor alle machines en
workloads. Daarom meet de
observe-modus
een workload zonder ooit in te grijpen, en legt hij het hoogste volledige totaal en de groeisnelheid vast
in een kalibratie-artefact met het stempel safety_certified: false. De operator kiest de
handhavingslimiet op basis van de waargenomen pieken plus een bewuste marge. De tool weigert te gokken.
Een deterministische, inspecteerbare policy. Het policy-contract beschrijft de policy (de beslisregels van de supervisor) als een pure toestandsmachine: gesamplede gebeurtenissen erin, acties eruit. Elke overgang wordt vastgelegd met zijn tijdstempel, het paar toestanden en het totaal dat op dat moment werd waargenomen; de drempels waaraan de overgang werd getoetst, staan één keer per rapport. De banden van v0.1 zijn allemaal afgeleid van de ene limiet die de operator instelde: de waarschuwing ligt één bandstap eronder, de noodband één stap erboven, en er zijn twee opeenvolgende overschrijdingen nodig voordat er iets gebeurt. Daarna verloopt de escalatie als waarschuwing → optioneel coöperatief checkpoint (100 ms timeout voor de bevestiging bij v0.1.0) → TERM (1 s respijt) → KILL, en een sample in de noodband gaat direct naar KILL. Samples die de supervisor niet kan vertrouwen, tellen nooit als nul. Drie opeenvolgende onbruikbare samples, of ze nu ontbreken, verouderd zijn, een teruglopende klok tonen of een te breed venster hebben, zetten de handhaving op fail-closed (bij twijfel ingrijpen in plaats van afwachten): de supervisor stuurt TERM, legt een getypeerde supervisorfout vast en escaleert naar KILL als het proces nog leeft. De tijdlijnen zijn uitvoerbaar en gecommit als golden tests.
Werk bewaren voordat je het vernietigt. Een worker die meedoet aan het
checkpoint-protocol
krijgt het verzoek om op te slaan voordat TERM komt. De gecommitte integratierun toont de coöperatieve
treden van begin tot eind. Een MLX-benchmark van een loss-laag met 1,000 herhalingen draaide onder een
bewust minuscule wall-time-limiet van 500 ms (de footprint-limiet van 512 MiB kwam nooit in
zicht; het piektotaal was ongeveer 46 MiB). De benchmark kreeg bij 505 ms het verzoek om een
checkpoint te maken, rondde herhaling 336 af, schreef een gedeeltelijk resultaat weg en
synchroniseerde het; de bevestiging kwam bij 527 ms, en bij 553 ms werd de benchmark
beëindigd met een eindrapport, met 336 voltooide herhalingen in het artefact van het checkpoint. Er
is geen controlerun die vaststelt wat afbreken zonder supervisie had gered (de eigen watchdog van het
project dat de tool gebruikt, schrijft ook een afgebroken resultaat weg). De aangetoonde claim is
dus het bewaarde artefact, geen redding vanaf nul. De bewijstermen van het protocol blijven eerlijk: aflevering alleen legt
requested_unverified vast, en zelfs een passende bevestiging legt
acknowledged_unverified_durability vast. Dat is de claim van de worker, geen bewijs dat de bytes
duurzaam zijn weggeschreven.
Een rapport dat overleeft. Sectie 4 behandelde het journal. Aan de kant van de uitkomst staan getypeerde exitcodes (de eigen code van het kindproces als er niets gebeurde, 75 bij een interventie van de policy, aparte codes voor fouten van de supervisor en van artefacten), zodat scripts en CI kunnen vertakken op wat er werkelijk gebeurde. Bij v0.1.0 stond één bekende uitzondering open: een kindproces dat stopte vóór de eerste identiteitscontrole van de supervisor, kon de foutcode van de supervisor opleveren in plaats van zijn eigen status.
7. De supervisor moet minder kosten dan het probleem dat hij bewaakt
Een buitenste ring die met de workload concurreert om de hulpbron die hij bewaakt, is zelf deel van het
probleem. De referentiebundel van v0.1.0 bepaalt wat de supervisor kost op de M1 Max-host en toetst
elke meting aan een vermelde streefwaarde; elke meting haalde die: maximale RSS van de supervisor
2.98 MiB; CPU van de sampler bij een interval van 50 ms over een groep van 16 leden 1.69% van
één core; één aanroep van proc_pid_rusage 1.25 µs bij p95; een samplevenster over 16 leden
0.183 ms bij p95; groei van de footprint van de supervisor over 30 minuten 80 KiB; latentie van
beslissing tot eerste signaal 8.2 µs bij p95. In die release leverde het standaardinterval van
50 ms ongeveer twintig waarnemingen per seconde op, voor ongeveer een zestigste van één core en drie
megabyte geheugen op deze host. Dat is goedkoop genoeg om vóór een zware run te laten staan, en dat is
de enige plek waar een circuit breaker helpt. Andere generaties Apple Silicon zijn niet gekalibreerd,
en het supportcontract koppelt prestatieverwachtingen aan host en workload.
8. Wat ook een externe supervisor niet kan beloven
De externe positie neemt het gedeelde lot weg en corrigeert de boekhouding. Handhaving wordt er niet atomair door, en dezelfde bewijsbundels die de kosten van de supervisor bepalen, meten ook zijn gaten.
Sampling heeft een venster, en allocaties wachten daar niet op. Bij een gecontroleerde synthetische ramp (geheugengebruik dat gestaag oploopt) van 128 MiB/s was de p95-overshoot boven de drempel 12.77 MiB, met als slechtste waarneming 13.19 MiB over de twintig runs. Dat getal schaalt met de ramp: een MLX-workload kan in één stap van de lazy evaluation gigabytes materialiseren, en één allocatie kan de drempel volledig tussen twee samples overschrijden. De policy legt per run de maximale waargenomen overshoot vast.
Een signaal naar het proces geeft het geheugen niet snel terug, voor zover we konden waarnemen. In alle tien Metal-kalibratieruns stond de Metal-buffer van 64 MiB direct na het vrijgeven nog steeds op rekening van het proces, met een maximaal residu van 65.2 MiB (68,403,272 bytes). In geen van de twintig ramp-runs verscheen na het interventiesignaal een numeriek lagere footprint-sample. Deze waarnemingen zijn rechtsgecensureerd: de runs eindigden voordat er teruggave werd waargenomen. Dat bewijst niet dat teruggave nooit plaatsvindt, en de bundel zegt precies dat. De ontwerpconsequentie: de supervisor blijft na TERM en KILL samplen totdat hij het proces echt ziet stoppen, en geen enkel deel van het rapport stelt een afgeleverd signaal gelijk aan teruggave.
De groep is van de supervisor, maar niet verzegeld. Een afstammeling die setsid aanroept, kan
vertrekken; het opsporen kan een proces missen dat forkt, ontsnapt en stopt tussen twee snapshots. Het rapport bevat
bewijs van ontsnapping in plaats van een containment-garantie, en het
dreigingsmodel beperkt de hele
tool tot één vertrouwd commando dat per ongeluk faalt, niet tot een kwaadwillend commando.
Een systeembrede storing gaat boven alles. Een supervisor is een user-space-proces. Bij een kernel panic, een driverstoring of een stilstand van de hele machine krijgt hij misschien geen CPU-tijd meer, en is zijn laatste journal-record misschien het enige artefact. Dat is het eerlijke plafond van elk antwoord vanuit user space op dit platform, extern of niet.
Daarom spreekt het project zelf van "OS-accounted footprint", "sampled intervention threshold" en "reduces risk" (door het OS toegerekende footprint, gesamplede interventiedrempel, verkleint het risico), en nooit van "hard boundary". De waarde van de externe positie is niet dat ze de grens hard maakt. Die waarde is dat de gaten hierboven gemeten worden waar ze waarneembaar zijn, en opgeschreven door een proces dat de workload overleeft, in plaats van met de workload te verdwijnen.
9. Lagen, geen vervanging
Niets in dit betoog maakt de binnenste bewakers overbodig. De wired limit (de limiet op vastgezet geheugen) begrenst nog steeds de residency die niet kan worden weggeswapt, de geheugenklasse waarvan uitputting één gedocumenteerde route naar een panic is. De adviserende geheugenlimiet stuurt nog steeds het gedrag van de allocator. De watchdog binnen het proces breekt in het gewone geval nog steeds af met een eerlijk artefact en werkt nog steeds als er geen supervisor is geïnstalleerd. Binnen een worker onder supervisie blijft hij draaien: het integratiecontract houdt de watchdog van het project dat de tool gebruikt, actief als fallback, en de supervisor legt daar eigendom van de procesgroep en de door het OS toegerekende footprint omheen. Veiligheidslagen voor MLX binnen de applicatie, zoals MetalGuard, bezetten dezelfde binnenste ring met veel meer kennis van het framework. De externe supervisor is bewust applicatieneutraal en framework-blind, en juist daardoor kan hij een ongewijzigd commando omhullen. De ringen meten verschillende grootheden en falen onafhankelijk van elkaar, en daar draait het bij ringen nu juist om.
10. Lessen
Een limiet die binnen het proces woont dat hij begrenst, is een advies. Het voorgaande artikel liet zien dat de limieten van het framework de panic van die machine niet tegenhielden. Deze notitie voegt daaraan toe dat elk mechanisme binnen het proces, limiet of watchdog, de scheduler, de adresruimte en de levensduur van het proces deelt, en daarmee ook zijn lot.
Volg het getal dat het OS je in rekening brengt. Tellers van het framework beperken zich tot wat de allocator bijhoudt, en de teller waar een workload als eerste naar grijpt, kan nog beperkter zijn: de publieke afwijking van 2.4× kwam van een teller voor piekgeheugen die de bewaarde cache-pool weglaat. Het juiste paar lezen verkleint dat gat, maar phys_footprint is de rekening, en opgeteld over de groep van de supervisor dekt die elk lid van die groep, inclusief geheugen dat het framework nooit alloceerde.
Het afbreekpad moet overleven wat het afbreekt. Een apart native ouderproces kan handelen terwijl de worker vastzit, de hele groep opruimen en, wat een bewaker binnen het proces nooit kan, het rapport schrijven nadat de worker weg is.
Op macOS is containment bewijs, geen ingebouwde bouwsteen. Geen cgroup, geen pidfd: identiteit moet opnieuw worden gevalideerd, ontsnappingen moeten worden vastgelegd, en een onvolledige meting moet weigeren te doen alsof ze volledig is. Een tool die geen grens van de kernel kan erven, moet de grens die hij vasthoudt zelf aantonen.
Benoem de gaten, en meet ze dan. Overshoot heeft een p95. Uitblijvende teruggave heeft een residu en een kanttekening over censurering. Het aandeel onterechte interventies op veilige workloads heeft een getal (nul, op vier workloads).
Bronnen en verwijzingen
mlx-guardop de tag v0.1.0: sampling, identiteit en containment, procesbesturing, policy, interventie, observe-modus en kalibratie, checkpoint-protocol, rapporten en privacy, dreigingsmodel, support, integratiecontract voor mlx-train-perf, broncode voor procesbesturing, golden tests voor de policy-tijdlijnen.- Gecommit bewijs op v0.1.0: referentiebundel M1 Max 32 GB (nauwkeurigheid, latentie, overhead, overshoot, duurtest, lifecycle-scenario's, corpus van veilige workloads); integratiebundel mlx-train-perf (checkpoint-tijdlijn, faalpaden).
mlx-guardop de tag v0.5.0, voor de update en de SIGKILL-beperking in sectie 4: README, changelog, procesbesturing, referentiebundel M1 Max 32 GB (macOS 27.2, met de cijfers van 0.3.1 ernaast).- Openbare incidentmeldingen: MLX #3896 (afwijking tussen de teller voor piekgeheugen en phys_footprint; twee overschrijdingen, één GPU-watchdog-timeout en één harde reboot; gesloten op 2026-08-08 met het upstream-advies om actief plus cachegeheugen te lezen); mlx-lm #883 (onbegrensde KV-cache, footprint van 83.23 GB, kernel panic).
- Begeleidende notities: When an MLX Memory Cap Is Not a Safety Boundary (de voorganger, sectie 2); Measuring a macOS process tree honestly (de methodenotitie, sectie 5).
- Aanverwante tooling: MetalGuard (veiligheidslaag voor MLX binnen de applicatie; een aanvullende grens).
Opgesteld 2026-08-14. Laatst bijgewerkt 2026-11-13. Denis Ineshin.
