Een kleine waarnemer buiten een overvolle kamer met een workload meet steeds de footprint ervan en houdt een verslag bij; beide staan op één gedeeld fundament.

Waarom de geheugenlimiet buiten het proces moet liggen

Denis Ineshin · 2026-08-17 · updated 2026-11-13

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:

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.

Where the enforcement loop runs, and what it shares fate withWorkload failure domainstarved, killed, or panicking togetherOwned process groupIn-process guardreads framework counters from inside;ends when the process endsSupervised command (root)Python and MLXDescendantsdataloader, spawned stepsSupervisor process — native parent, outside the failure domainsamples OS-accounted phys_footprint per validated member,runs the policy state machine, writes the journal and final reportEscaped descendantsetsid, outside the owned group;recorded as evidence, not containedsample every member,TERM then KILLcheckpoint request(negotiated endpoint only)setsid✕
Figuur 1. Welke componenten een failure domain delen (een groep onderdelen die samen uitvalt), en welke niet. De labels in het diagram staan in het Engels. De figuur toont de besturingsstructuur van v0.1 en de signaaldoelen die elk pad gebruikt; ze rapporteert geen meting. Het ontsnappingspad staat erin omdat de supervisor het vastlegt, niet omdat de groep van de supervisor het binnenhoudt. De bewerkbare PlantUML-bron is samen met de SVG gepubliceerd.

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


Opgesteld 2026-08-14. Laatst bijgewerkt 2026-11-13. Denis Ineshin.

Buy me a coffee