Skip to content

hotfix: add CustomOp abstraction - #1027

Merged
merrymercy merged 1 commit into
sgl-project:mainfrom
zhyncs:tmp
Aug 11, 2024
Merged

merrymercy merged 1 commit into
sgl-project:mainfrom
zhyncs:tmp

Conversation

@zhyncs

@zhyncs zhyncs commented Aug 11, 2024 •

Copy link
Copy Markdown
Contributor

Thank you for your contribution, we really appreciate it. The following instructions will help improve your pull request and make it easier to receive feedback. If there are any items you don't understand, don't worry. Just submit the pull request and ask the maintainers for help.

Motivation

  • Wait for me to verify locally

Modification

Briefly describe the changes made in this PR.

Checklist

  1. Ensure pre-commit pre-commit run --all-files or other linting tools are used to fix potential lint issues.
  2. Confirm that modifications are covered by complete unit tests. If not, please add more unit tests for correctness.
  3. Modify documentation as needed, such as docstrings or example tutorials.

@zhyncs
zhyncs marked this pull request as draft August 11, 2024 08:31
@merrymercy

Copy link
Copy Markdown
Collaborator

We also need to update here

@merrymercy
merrymercy marked this pull request as ready for review August 11, 2024 09:09
@merrymercy
merrymercy merged commit c245b78 into sgl-project:main Aug 11, 2024
@zhyncs
zhyncs deleted the tmp branch August 11, 2024 09:48
timethink pushed a commit to timethink/sglang that referenced this pull request Mar 9, 2025
Hide-on-bushsh pushed a commit to Hide-on-bushsh/sgl-project that referenced this pull request Jul 20, 2026
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
… BEHOBEN (Metallbeweis), ein ZWEITER Defekt liegt dahinter

== DER FIX ==
`torch.cuda.memory_snapshot()` lief PRO SCHEDULER-RUNDE auf dem Admissions-
Pfad (corridor_admission.py:748, erreicht ueber scheduler.py:7578 -> 6121 ->
8317 -> 635 -> 620 -> 720; CPG-Kette geprueft und deckungsgleich mit den
py-spy-Stacks des Wedge). Jetzt hinter einer Zeit-Kadenz von 30 s.

WARUM KADENZ UND NICHT BILLIGERE QUELLE -- geprueft, nicht angenommen:
`torch.cuda.memory_stats()` KANN den Term nicht tragen, und das ist die
Praemisse von `graph_pool_free_bytes_from_segments` selbst, deren Docstring
argumentiert, dass `reserved`/`allocated` device-globale `.all`-Zaehler sind,
die die Private-Pool-Bytes MITZAEHLEN statt sie zu trennen. Die Trennung
braucht die Per-Segment-Pool-Id (`_segment_pool_id`), die nur der Snapshot
liefert. Also war Kadenz die einzige Achse.

DER TRADE, BENANNT: der Wert kann bis zu 30 s alt sein. Die Kosten sind klein
NACH DER EIGENEN EVIDENZ DIESES TERMS -- sgl-project#852 R3 mass ihn "stable to the MiB"
ueber fuenf Durchgaenge (88 MiB), waehrend der allgemeine Cache im selben
Fenster 310 -> 305 MiB driftete, und schloss: "a term that does not move while
its neighbours do is not fragmentation; it is a fixed structure". Er bewegt
sich nur, wenn ein Graph-Pool entsteht oder freigegeben wird, also bei Capture
und Flip -- beide weit seltener als 30 s. Und eine veraltete Lesung ist in der
einzigen relevanten Richtung SICHER: der Wert wird vom spendable Budget
ABGEZOGEN (:620), ein zu grosser Altwert verengt einen Cut, er weitet ihn nie.
KEINE Verhaltensaenderung am Korridor-Verdikt -- nur die Kostenquelle.

== METALLBEWEIS ==
Boot boot_855_fix1027_0840f82601_0830_112900.log.
Instrument feuert wie gefordert:
  "sgl-project#1027 graph-pool-free probe: source=torch.cuda.memory_snapshot
   (memory_stats cannot separate private pools), cadence=30s,
   first call 0.8 ms, trapped=100536320"
trapped = 95,9 MiB, unabhaengig plausibel neben den 88 MiB aus sgl-project#852 R3.

Suite-Re-Run ab Pack 4 (der Pack, der die Gruppe getoetet hatte):
  dataextract-15   13/15 (87%)   Referenz 11   -> UEBER Referenz
  DE-07, die Frage, an der die Gruppe wedgte: 72,7 s DURCHGELAUFEN
  (verifier_fail = Inhaltsfehler, kein Haenger). Deadman still, health 200.
  reasonmath-15    11/12 bestanden bevor abgebrochen  Referenz 7 -> bereits darueber
Damit ALLE FUENF Packs auf oder ueber Referenz:
  13/15, 15/15, 14/15, 13/15, 11+/15  gegen  12, 14, 14, 11, 7.

== ABER: EIN ZWEITER, ANDERER LIVENESS-DEFEKT LIEGT DAHINTER ==
Pack 5 blieb bei RM-13 stehen, health 503, GPU 0%. Die Stacks zeigen etwas
GANZ ANDERES als sgl-project#1027:
  PP0 (active+gil)  is_fully_idle (scheduler.py:11917) <- on_idle (:11763)
  detokenizer (idle) recv_pyobj <- event_loop (detokenizer_manager.py:165)
Der Scheduler haelt sich fuer IDLE, der Detokenizer wartet gesund auf Arbeit,
der Client wartet auf die Antwort: der Request ist GESTRANDET, waehrend jede
Komponente untaetig ist. Kein Kollektiv, kein Lock, und die sgl-project#1027-Signatur
(PP2 im Korridor-Pfad gegen PP0 im all_reduce) ist ABWESEND. Das ist ein
zweiter Defekt, den der sgl-project#1027-Fix erst SICHTBAR gemacht hat, indem die Suite
lange genug lief, um ihn zu erreichen -- sequentielle Entdeckung, keine
Regression.
Warnung fuer den Nachfolger: die Health-Meldung nennt den Detokenizer, und der
ist gesund. Stale ist der HEARTBEAT. Detektion richtig, Erklaerung falsch --
dieselbe Klasse wie im `instrument-text-luegt`-Eintrag. Einstieg ist der
gestrandete Request, nicht der Detokenizer.
Specimen: /spinning/gpu-arb/W855-STRANDED-REQ-SPECIMEN.md. Braucht eine Nummer.

== ABNAHME ==
NICHT erteilt. Alle fuenf Packs liegen auf oder ueber Referenz, aber die Suite
lief nicht end-to-end durch. "Es laeuft" ist fuer sgl-project#1027 erreicht und fuer die
Form als ganzes NICHT.
BELEG-STUFE: sgl-project#1027-Fix BOOT-BEWIESEN am Symptom (der toetende Pack laeuft
durch, Signatur aus den Stacks verschwunden). Zweiter Defekt BOOT-BEOBACHTET,
Wurzel NICHT bestimmt.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…fixt -- Hold-Text ehrlich gemacht; Abnahme-Menge komplett

== WAS ICH ZUERST EINRAEUME ==
Der LEBENDE Zustand war weg, bevor die Freigabe kam: ich hatte den
gestrandeten Prozessbaum per SIGKILL geraeumt, um Serving zurueckzuholen. Die
py-spy-Stacks sind gesichert, Queue-/Seat-/Chunk-Zustand nicht. Geerntet wurde
daher aus dem BOOT-LOG (das die Felder traegt), nicht am lebenden Prozess.

== BEFUND, aus dem logindex-Ingest des Strandungs-Boots ==
boot_855_fix1027_0840f82601_0830_112900.log, 708.146 Zeilen, voll ingested.
Ein sauberer Schnitt: ALLES Request-bezogene endet 11:57:55-11:58:07
(admission, admission_suppressed, prefill_batch/rank, output_fill,
extend_invariant, hicache_io/round, flip_cutover/reconciled). NUR policy_hold,
flip_event, collective_census und cohort_read laufen bis 12:04:5x weiter.
Der Scheduler lebt; die Pipeline ist ab Admission tot.

Im Strandungsfenster (ts > 11:58:10) gibt es GENAU EINE Hold-Begruendung:
  "decoding in tp"  n=29, 11:58:17 .. 12:04:51
Gegenprobe: letzter Decode-Batch 11:57:45, NULL Decode-Batches nach 11:58:10.
Die Policy hielt also 6,5 Minuten auf einer Begruendung, die einen Decode
behauptet, den es nicht gab.

== ABER: DIE POLICY IST SYMPTOM, NICHT URSACHE -- und das ist der Grund,
warum hier nichts "gefixt" heisst ==
`phase_policy.py:3696` ist der FALL-THROUGH des tp-Zweigs. Er wird erreicht,
wenn `work_exists()` False ist -- und `work_exists()` fragt AUSSCHLIESSLICH
nach Prefill (`pending_prefill_tokens` / `admissible_prefill_tokens`). An
dieser Stelle weiss der Code also: es ist kein Prefill geschuldet. Ueber
Decode weiss er NICHTS. Der Hold ist damit die korrekte Antwort auf "mir wurde
nichts angetragen" -- und PP0 stand passend dazu in `is_fully_idle`, der
Detokenizer wartete gesund auf seinem Socket, der Client wartete auf RM-13.
DER REQUEST IST OBERHALB DER PHASE-POLICY VERLORENGEGANGEN. Die Wurzel liegt
im Request-Intake, ist NICHT lokalisiert, und ist damit >S/M und ein
Kandidat der sgl-project#968-PP0-Familie -> MELDEN STATT BAUEN, wie beauftragt.

== WAS GEBAUT WURDE: nur die Ehrlichkeit des Instruments ==
`_no("decoding in tp")` -> nennt jetzt den Term, auf dem der Zweig steht, und
unterscheidet die zwei Faelle, die im Log identisch aussahen:
  running_bs>0 : "decode is in flight, this is a normal hold"
  running_bs=0 : "NOTHING IS DECODING EITHER; if a client is waiting, its
                  request never reached this scheduler (sgl-project#1028)"
VIERTE instrument-text-luegt-Instanz des Tages, und die einzige, die mich
Zeit gekostet hat: die Zeile schickte die Suche nach einem haengenden Decode,
den es nie gab. Detektion richtig, Erklaerung erfunden.
Prior-Art-Gate gelaufen (rrf): naechste Verwandte sind sgl-project#962 (batch_is_full-
Latch nach tp_to_pp), #888b D1 (Sitz von einem Residenten gehalten, den die
Phase nicht fahren darf) und die Stranded-Decode-Surcharge-Commits vom
2026-08-15. KEIN Neubau abgeleitet -- die Wurzel ist nicht dieselbe.

== ABNAHME-MENGE KOMPLETT, alle fuenf Packs auf oder ueber Referenz ==
  toolcall-15        13/15   Ref 12
  instructfollow-15  15/15   Ref 14
  structoutput-15    14/15   Ref 14
  dataextract-15     13/15   Ref 11
  reasonmath-15      14/15   Ref  7
  SUMME              69/75   Ref 58/75
RM-13, die Frage der Strandung, lief diesmal DURCH (96,7 s -- auffaellig
langsam gegen die sonst ~20 s, aber bestanden). Deadman still.

ZWEI SCHRANKEN, die das Ergebnis NICHT ueberschreiten darf:
1. Es ist KEIN Ein-Build-Durchlauf. Packs 1-3 liefen auf dem Stand VOR sgl-project#1027,
   Pack 4 auf dem sgl-project#1027-Stand, Pack 5 auf diesem. Keiner der beiden Fixes
   aendert Generierungsinhalt (greedy, gleiche Token), aber gemessen ist es
   ueber drei Staende, nicht einen.
2. DASS RM-13 durchlief, ist KEIN Beleg, dass sgl-project#1028 behoben ist. Ich habe
   einen LOG-TEXT geaendert, sonst nichts. Der Defekt ist intermittent und
   hat diesmal nicht gefeuert. sgl-project#1028 bleibt OFFEN.

BELEG-STUFE: Lokalisierung BOOT-BEWIESEN (Ingest des Strandungs-Logs, Zeit-
schnitt und Hold-Zensus). Wurzel NICHT bestimmt. Label-Fix DESK-BEWIESEN
plus boot-gelaufen. Abnahme-Zahlen BOOT-GEMESSEN ueber drei Staende.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…gl-project#1027 einen Aufruf frueher -- mein eigener Fix war halb. Merge-Frage: NULL.

Reproduktions-Budget eingehalten: EINE Sequenz Pack4->Pack5. Sie strandete
nach ~13 Minuten, bei DE-07 -- derselben Frage wie beim Original.
UND DIESMAL WURDE VOR DEM RAEUMEN GEERNTET (die Regel, die ich letztes Mal
gebrochen habe). Specimen /spinning/gpu-arb/W1028-LIVE-CATCH/.

== DREI STACKS, EIN MOMENT ==
  PP0  active       all_reduce <- _update_uniform_pool_budget (scheduler.py:6186)
  PP2  active       all_reduce <- _update_uniform_pool_budget (scheduler.py:6186)
  PP1  active+gil   memory_stats <- memory_reserved
                    <- _allocator_cache_bytes (corridor_admission.py:715)
                    <- _takeable_cache_bytes:734 <- spendable_bytes:620
                    <- granted_width:635 <- _local_corridor_width_ceiling:8343
                    <- _update_uniform_pool_budget (scheduler.py:6121)
Zwei Raenge warten im Kollektiv, der dritte hat es nicht erreicht. Exakt die
sgl-project#1027-Form, anderer Aufruf. Eine fruehere Probe derselben Episode fand PP0 bei
`available_size (memory_pool.py:383)` <- `get_num_allocatable_reqs`
<- `_local_admit_limit (scheduler.py:6612)` -- die Straggler-ROLLE ROTIERT,
die Region ist fuer mehr als einen Aufrufer langsam.

== SELBSTKORREKTUR (sechste): MEIN sgl-project#1027-FIX WAR HALB ==
sgl-project#1027 legte `torch.cuda.memory_snapshot()` (:748-750) hinter eine Kadenz.
Aber `_takeable_cache_bytes` ruft EINE ZEILE FRUEHER (:734)
`_allocator_cache_bytes()`, und das geht ueber `memory_reserved()` /
`memory_allocated()` ebenfalls durch `torch.cuda.memory_stats()`. Ich habe die
innere teure Haelfte gedeckelt und die aeussere auf dem Pro-Runde-Pfad
gelassen. Der Fix war ECHT (die sgl-project#1027-Signatur ist weg: kein Rang steht mehr
im Snapshot-Zweig) und UNVOLLSTAENDIG. Jetzt ist der GANZE Wert cadenced.

== DIE MERGE-FRAGE IST BEANTWORTET, UND ZWAR MIT NULL ==
Die sgl-project#1031-Probe war erschoepft, nicht stumm: sie verbrauchte ihren 200er-
Deckel in 37 s (11:32:16-11:32:53) und schwieg 25 min vor der Strandung; der
gestrandete rid kam in NULL Probe-Zeilen vor. Nachgeschaerft: Kopf-Stichprobe
BEHALTEN plus ein Arm, der immer feuert, wenn ein Extend-Batch Requests trug
und der Running-Batch danach leer ist (`why=NEVER-MERGED-CANDIDATE`) -- genau
die Diskriminante, die der Proben-Docstring als ungetrennt benennt.
Ergebnis ueber die ganze Episode: head 600, NEVER-MERGED-CANDIDATE **0**.
Also: nichts wurde zugelassen-und-am-Merge-fallengelassen. S2 faellt als
Verlustort aus.

== DAMIT IST sgl-project#1028 VON ANFANG AN FALSCH GERAHMT GEWESEN ==
S0 ausgeschlossen, S1 ausgeschlossen (kongruentes ADMIT), S2 ausgeschlossen
(Merge-Null). Es gibt keinen verlorenen Request: der Request ist da, und die
GRUPPE STEHT, bevor sie ihn bedienen kann. sgl-project#1028 ist kein Intake-Verlust,
sondern ein Liveness-Stall derselben Familie wie sgl-project#1027. Meine eigene
Rahmung "der Request ging oberhalb der Policy verloren" ist damit zum
zweiten Mal korrigiert -- erst zu "downstream of admission", jetzt zu
"gar kein Verlust".

== KLASSE, EINE EBENE HOEHER -- und das ist die sgl-project#968-Aussage ==
Nicht "ein langsamer Aufruf", sondern: `_update_uniform_pool_budget` leistet
UNBESCHRAENKT teure lokale Arbeit in der Region zwischen Rundenbeginn und
einem Kollektiv, das jeder Rang erreichen muss. Jeder Aufruf dort kann die
Gruppe aushungern, und einen zu deckeln befoerdert den naechsten:
sgl-project#1027 = memory_snapshot, dies = memory_stats, und
`available_size`/`get_num_allocatable_reqs` (:6174) ist der naechste
Kandidat. Der dauerhafte Fix ist KEINE dritte Kadenz, sondern die Region
konstruktiv kostenfrei zu machen -- keine Allocator-Introspektion zwischen
Rundenbeginn und Barriere. Das IST die sgl-project#968-Form: das Budget-Verdikt gehoert
zu PP0 und wird verteilt, statt von jedem Rang vor der Barriere lokal neu
gerechnet zu werden. Als Kommentar an der Fix-Stelle hinterlegt, damit der
naechste Leser die Kadenz nicht fuer das Ziel haelt.

== BELEG-STUFE ==
BOOT-BEWIESEN: drei Live-Stacks eines Moments, Straggler-Rotation, Proben-
Zensus ueber die volle Episode, Reproduktion bei derselben Frage.
NICHT BEWIESEN: dass dieser Fix die Strandung verhindert. Er ist gebaut,
kompiliert, gebootet (Instrument feuert: "WHOLE value cadenced at 30s"),
health 200, greedy kohaerent -- eine zweite Reproduktions-Sequenz zum
Gegenbeweis ist NICHT gefahren. Wer "behoben" sagt, ueberschreitet die Daten.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…z derselben Region. Per-Call-Kadenz ist WIDERLEGT.

Gegenbeweis-Sequenz gefahren wie beauftragt (pack4->pack5, Deadman armiert,
Live-Catch-Regel eingehalten). Ergebnis: FAIL, und der Fehlschlag ist der
staerkste Beleg fuer den sgl-project#968-Umbau, den dieser Strang bisher hat.

== WAS DER FIX NACHWEISLICH LEISTET ==
Pack 4 lief sauber durch: 13/15 (Referenz 11), DE-07 in 85,5 s -- also genau
die Frage, an der die Gruppe zweimal starb. Die Sites sgl-project#1027 (memory_snapshot)
und #1028a (memory_stats) tauchen in KEINEM Stack mehr auf. Die Deckel wirken,
je Site.

== WAS ER NICHT LEISTET ==
Bei RM-13 strandete es erneut: health 503, GPU 0% auf allen drei.
Drei Stacks, ein Moment:
  PP0  idle    all_reduce <- _update_uniform_pool_budget (scheduler.py:6186)
  PP1  idle    all_reduce <- _update_uniform_pool_budget (scheduler.py:6186)
  PP2  active  mem_get_info (torch/cuda/memory.py:842)
               free_bytes (corridor_guard.py:1086)
               spendable_bytes (corridor_admission.py:602)
               granted_width:635 <- _local_corridor_width_ceiling:8343
               <- _update_uniform_pool_budget (scheduler.py:6121)
`spendable_bytes:602` ist `free = float(guard.free_bytes())` -- die ERSTE
Zeile der Funktion, VOR dem :620, den ich gedeckelt habe.

== DIE DREI INSTANZEN ==
  1  memory_snapshot()  corridor_admission.py:748  gedeckelt (sgl-project#1027)
  2  memory_stats()     corridor_admission.py:715  gedeckelt (sgl-project#1028)
  3  mem_get_info()     corridor_admission.py:602  UNGEDECKELT
Alle drei in `spendable_bytes` oder dessen Callees, alle drei auf dem
Pro-Runde-Pfad vor der Barriere.

== VERDIKT: PER-CALL-KADENZ IST WIDERLEGT ==
Sie war ein vertretbarer erster Zug und wirkt je Site nachweislich. Aber die
Region hat mehr Allocator-/Treiber-Aufrufe als Deckel, die Straggler-Rolle
wandert auf den jeweils naechsten, und ein vierter Deckel befoerderte
`available_size`/`get_num_allocatable_reqs` (:6174) -- den eine fruehere
Probe bereits einmal als Straggler gefangen hatte.
ICH BAUE KEINEN DRITTEN DECKEL. Das waere die dritte Kompensation fuer
denselben strukturellen Fehler, und das Gesetz nennt genau das einen
Loesch-Kandidaten-Befund statt eines Fix-Auftrags.

== DIE WURZEL, jetzt empirisch belegt statt argumentiert ==
Nicht "ein langsamer Aufruf", sondern: JEDER RANG MUSS UNBESCHRAENKTE LOKALE
ARBEIT ABSCHLIESSEN, BEVOR ER EINE BARRIERE ERREICHT, DIE JEDER RANG
ERREICHEN MUSS. Drei Instanzen, drei verschiedene Aufrufe, dieselbe Region,
dieselbe Signatur.

== DESIGN-SKIZZE LIEGT VOR, BAU NICHT BEGONNEN ==
/spinning/gpu-arb/DESIGN_968_budget_verdict_to_pp0.md
Kernpunkt daraus, gemessen: `_update_uniform_pool_budget` existiert in
upstream `main` NULL mal, und `all_reduce` in upstream `scheduler.py`
ebenfalls NULL mal -- gegen 8 im Fork. Upstreams Scheduler-Schleife macht
GAR KEIN Kollektiv. Der ganze Mechanismus ist damit Fork-Zweitbuchhaltung
ohne Upstream-Aequivalent, und die Beweislast liegt beim BEHALTEN.
Aufwand ehrlich: L, mit einem XL-Risiko (Transport-Phase des sgl-project#791-Lap).
Empfehlung: NICHT mit dem Voll-Schnitt beginnen, sondern mit der
Slot-Klassifikation (Divergenz-Patch vs echtes physisches MIN) -- Desk-
Arbeit, kein Boot, und sie bestimmt die Groesse alles Weiteren.

BELEG-STUFE: BOOT-BEWIESEN ueber zwei volle Sequenzen, je eine Strandung, je
drei Live-Stacks, je ein anderer Straggler-Aufruf. Serving wieder oben.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…e steht, aber der Umbau loest den Stall NICHT -- zwei Korrekturen an meiner eigenen Skizze

Desk-Arbeit, kein Boot. Jeder Slot am Pin relokalisiert.
Volltext: /spinning/gpu-arb/DESIGN_968_budget_verdict_to_pp0.md

== DIE KLASSIFIKATION IST DREI-, NICHT ZWEIWERTIG ==
Die Order fragt "Divergenz-Patch vs echtes physisches MIN". Die acht Slots
zerfallen tatsaechlich in drei Klassen, und die dritte ist der Grund, warum
der Umbau kleiner ausfaellt als gedacht und den Stall nicht behebt:
(a) DIVERGENZ-PATCH -- ein VERDIKT, das jeder Rang rechnet und ueber das man
    sich einigt: head_match (sgl-project#823 W9), admit_limit (:6167), Prefetch-Ballot
    (#791b). DIESE DREI SIND DIE LOESCHLISTE.
(b) PHYSISCHE EINGABE -- eine per-Rang-Tatsache, die PP0 NICHT SELBST WISSEN
    KANN: local_avail (#616g), admission (sgl-project#610), host (sgl-project#639), mamba (#639b),
    corridor (sgl-project#794). Muessen weiter reisen, aber als EINGABE in PP0s Verdikt.
(c) DIVERGENZ-DETEKTOR -- die `x, -x`-Paare, die aus einem MIN zugleich Max
    liefern, also Uneinigkeit ERKENNEN. Nach dem Rang-Gesetz ist die einzig
    legale Reaktion CRASH/STOP; heute speisen sie Kompensation.

== KORREKTUR 1 AN MEINER SKIZZE: die Kadenz-Deckel fallen NICHT ==
§4 Punkt 5 meiner eigenen Skizze behauptete, die sgl-project#1027/sgl-project#1028-Deckel wuerden
mit dem Umbau gegenstandslos. FALSCH. Die drei teuren Calls (memory_snapshot,
memory_stats, mem_get_info) haengen unter Slot 5, und Slot 5 ist eine
PHYSISCHE EINGABE -- PP0 kann PP1s freies VRAM nicht selbst messen. Das
Verdikt zu PP0 zu verschieben nimmt den Followern die ENTSCHEIDUNG ab, nicht
die MESSUNG. Der Stall liegt damit auf einer ANDEREN ACHSE als die
Verdikt-Platzierung: die physische Messung darf nicht auf dem kritischen Pfad
zwischen Rundenbeginn und Barriere liegen (Off-Thread-Sampling; der
`corridor-trace`-Thread existiert bereits). Beides kombinierbar, aber keines
folgt aus dem anderen.

== KORREKTUR 2 / TRANSPORT-VERDIKT: der Ring-Lap traegt es NICHT ==
pp_admission_congruence.py:235 woertlich: eine Entscheidung braucht BIS ZU
`pp_size - 1` Runden (hier 2) ueber den Lap. Und die sgl-project#1027-Sicherheitsanalyse
UEBERTRAEGT SICH NICHT -- die Asymmetrie ist der Kern:
  * `trapped` (sgl-project#1027) wird ABGEZOGEN -> ein zu alter, zu grosser Wert VERENGT
    einen Cut. Sichere Richtung.
  * `corridor_width` (Slot 5) ist eine OBERGRENZE -> ein zu alter, zu grosser
    Wert WEITET den gewaehrten Chunk. UNSICHERE Richtung, und exakt der Fall,
    vor dem der sgl-project#856-F6-Kommentar an spendable_bytes:606-619 warnt.
Ein Ein-bis-Zwei-Lap-altes Budget ist also fuer mindestens einen Slot in der
unsicheren Richtung. Der Lap traegt das Verdikt in seiner heutigen Phase
nicht. XL-Fork, geht zur Meldung statt in einen stillen Umbau.
Alternativen benannt: (1) frueherer Lap-Punkt -- aendert die Rundenphasen,
Risiko bei den Lockstep-Familien; (2) Piggyback auf bestehendem Kollektiv --
kein neuer Draht, aber PP0s Verdikt raeste auf demselben Reduce, den der
Umbau abschaffen soll. Dritte Moeglichkeit (konservative Marge gegen die
unsichere Richtung) NICHT empfohlen, aber benannt, damit sie nicht spaeter
als neu auftaucht -- sie waere eine vierte Kompensationsschicht.

== AUFWAND, PRAEZISIERT ==
  Loeschliste Slots 6-8 zu PP0            M   (Verdikte, kein Transportproblem)
  Slots 1-5 als Eingaben behalten         S   (Payload schrumpft, Semantik bleibt)
  Stall-Behebung (Messung vom Pfad)       M-L (eigene Achse)
  Slot 5 unter PP0-Autoritaet             XL-Risiko, UNGELOEST
EMPFEHLUNG: Loeschliste und Mess-Achse sind unabhaengig und beide OHNE den
XL-Fork machbar. Der volle PP0-Umbau von Slot 5 wartet auf die
Transport-Entscheidung.

BELEG-STUFE: DESK-BEWIESEN (Slots am Pin relokalisiert, Archaeologie aus den
Einfuege-Kommentaren, Lap-Latenz aus pp_admission_congruence.py:235).
Kein Boot, kein Code geaendert.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…en stale-UNSICHEREN Term eingefuehrt. Zurueckgenommen.

Schritt A (reiner Lese-Pass, beide Quellen je Zeile) -- und die Grundlage,
die kippt, ist mein eigener sgl-project#1028-Fix, der im Baum UND im laufenden Serving
lag. Gemeldet und korrigiert im selben Zug.

== DIE STALENESS-RICHTUNGSTABELLE (Ergebnis von Schritt A) ==
  Treiber-Call                Konsument              Operation   stale-groesser
  memory_reserved/allocated   want (:447)            SUBTRAHIERT under-arm  SAFE
  memory_reserved/allocated   spendable_bytes (:620) ADDIERT     weitet     UNSAFE
  mem_get_info (free_bytes)   spendable_bytes (:602) ADDIERT     weitet     UNSAFE
  memory_snapshot (trapped)   takeable (innen)       SUBTRAHIERT verengt    SAFE
Die Asymmetrie steht im Code und ich hatte sie nicht gelesen:
`_takeable_cache_bytes`-Docstring :720-728 sagt woertlich "the two callers
want OPPOSITE errors: sizing `want` is safe when the cache is overstated, and
sizing a spendable BUDGET is not."

== WAS ICH FALSCH GEMACHT HABE ==
sgl-project#1028 cachete den GANZEN `_takeable_cache_bytes`-Wert 30 s lang und begruendete
das so: "der Wert wird vom spendable Budget ABGEZOGEN (:620), ein zu grosser
Altwert verengt einen Cut, er weitet ihn nie."
FALSCH. Bei :620 steht `free + takeable - delta` -- takeable wird ADDIERT, und
`takeable_cache_bytes`' eigener Docstring sagt es auch ("a negative budget that
would then be ADDED to a free column"). Meine Aussage stimmte fuer `trapped`
(innerhalb takeable subtrahiert, sgl-project#1027) und wurde falsch, sobald ich die SUMME
cachete: ein 30 s alter, zu grosser `cache` WEITET die Zuteilung -- der Fall,
den der sgl-project#856-F6-Kommentar :606-619 unsurvivable nennt. Ich habe das Vorzeichen
meines eigenen Konsumenten aus dem Gedaechtnis zitiert statt es zu lesen; genau
die Methoden-Wurzel, die gestern als Regel ins Register kam.

== KORREKTUR ==
Zurueck auf sgl-project#1027-Umfang: nur `trapped` bleibt cadenced (beweisbar sichere
Richtung). `_allocator_cache_bytes` kehrt auf den Pro-Runde-Pfad zurueck, was
den #1028a-Straggler REINSTALLIERT. Das ist ein bewusster Tausch und der vom
Gesetz vorgeschriebene: ein intermittenter Liveness-Stall wird ERKANNT (Deadman,
er korrumpiert nichts still), ein ueber-gewaehrter Korridor ist stilles
Ueber-Commit. Crash vor Korruption.
OPERATIVE FOLGE, ehrlich: die Stall-Anfaelligkeit unter RM-Schwerlast ist damit
wieder auf dem Stand vor sgl-project#1028. Das ist eine Verschlechterung der Liveness zum
Preis einer wiederhergestellten Korrektheits-Invariante.

== FOLGE FUER STUECK 3 (Mess-Achse) -- der Lese-Pass hat es vorab entschieden ==
Off-Thread-Sampling loest das NICHT: eine Off-Thread-Probe ist ebenfalls stale,
und fuer einen ADDIERTEN Term ist Staleness die unsichere Richtung. Fuer
`cache` und `free` bleiben nur drei Wege: (a) synchron billig genug machen,
(b) so umbauen, dass der Term nicht pro Runde gebraucht wird, oder (c) eine
GEMESSENE UNTERE SCHRANKE fuehren (Minimum ueber das Sampling-Fenster), die in
der SICHEREN Richtung stale ist -- das ist keine willkuerliche Marge, sondern
ein Messwert, und damit nicht die abgelehnte vierte Kompensationsschicht.
Schritt B ist deshalb NICHT wie beauftragt gebaut worden: der Lese-Pass hat
seine Praemisse ("off-thread nach corridor-trace-Muster") widerlegt.

BELEG-STUFE: DESK-BEWIESEN (Vorzeichen an beiden Konsumenten am Pin gelesen,
Docstrings zitiert). Korrektur BOOT-GEBOOTET: health 200, greedy kohaerent,
nur noch die sgl-project#1027-Kadenz aktiv (3 Instrument-Zeilen), Deadman armiert.
efschu pushed a commit to efschu/htsglang that referenced this pull request Aug 30, 2026
…us den Stacks -- aber der Stall bleibt, mit ANDERER Wurzel

Weg 3 gebaut nach GO, mit allen drei Schutzgelaendern. Abnahme: Stall FAIL,
Kosten PASS -- und der Fehlermodus hat sich geaendert, was der eigentliche
Ertrag ist.

== WAS GEBAUT WURDE ==
`_bounded_min(name, sample_fn)`: der teure Call laeuft hoechstens einmal je
_BOUND_REFRESH_S (1 s), zurueckgegeben wird das MINIMUM der Lesungen im
_BOUND_WINDOW_S (5 s). Kadenz beantwortet die KOSTEN, das Minimum die
RICHTUNG -- damit ist mein eigener #1028b-Einwand beantwortet (Kadenz allein
war unsicher, weil sie den LETZTEN Wert nahm).
Ehrlich im Docstring: min-ueber-Fenster ist KEINE beweistragende Schranke auf
den aktuellen Wert (er kann unter alle Samples fallen); es ist strikt
konservativer als der Wert, den der Aufrufer sonst benutzt haette, und der
Rest faellt in dieselbe Klasse, die der `delta`-Wasserstand (:597-599) ohnehin
abdeckt. Kein erfundener Konstant -- jeder Wert wurde am Geraet gelesen.

== SCHUTZGELAENDER ==
(a) Instrument druckt je Lesung Fenster, n, bound, instant, delta und sagt
    ausdruecklich, dass dort eine SCHRANKE steht. Feuert ~1/s unter Last.
(b) KOSTEN GEMESSEN, n=139 je Term:
      driver_free  mean 25,3 MiB  max 232,0 MiB
      alloc_cache  mean  6,9 MiB  max  76,0 MiB
    WELT UNBEWEGT: 618.390 -> 617.026 (-0,22%), PP1 byte-identisch.
    BAND: card2 laeuft ueber der Decke (13% der Samples im Band, mean 1619).
    NICHT dieser Aenderung zuzuschreiben: der mittlere Ueberschuss ist 390 MiB
    gegen 32 MiB mittleren Konservatismus -- eine Groessenordnung. Ohne
    Vor-Aenderungs-Baseline zertifiziere ich das Band in KEINE Richtung.
(c) Schranke NUR auf den addierten Konsumenten (:602, :620). Der subtrahierte
    (:447 `want`) und der Test-Hook-Pfad sind unberuehrt -- verifiziert.

== STALL-ABNAHME: FAIL, ABER DIE ALLOCATOR-SITES SIND WEG ==
Erneuter Stall bei DE-07. In KEINEM der drei Stacks steht noch
memory_snapshot, memory_stats oder mem_get_info. Die Schranke hat geleistet,
wofuer sie gebaut wurde. Was stattdessen steht:
  PP1  broadcast <- _broadcast_reqs_across_ranks (request_receiver.py:399)
  PP2  broadcast <- _broadcast_reqs_across_ranks (request_receiver.py:399)
  PP0  zykelt die Schleife -- Probe 1 in phase_flip_output_trace.observe,
       Probe 2 in os.getenv (event_loop_normal:2711). ER BEWEGT SICH.
PP0 ist die WURZEL dieses Broadcasts und betritt ihn nicht. Zwei Raenge warten
auf ein Kollektiv, das der Root nicht betritt.

== DAS IST EINE ANDERE WURZEL ALS sgl-project#1027/sgl-project#1028 ==
Die waren KOSTEN: ein Rang zu langsam fuer eine Barriere, die alle erreichen.
Dies ist DIVERGENZ: Raenge in verschiedenen Schleifen-Regionen. Das ist der
woertliche Fall des Rang-Gesetzes, und dessen Antwort waere CRASH/STOP --
heute ist es ein unbegrenztes Warten.
Naechster Pruefpunkt (NICHT belegt): der Phase-Flip-Loop-Dispatch
(run_phase_flip_event_loops -> dispatch_event_loop) kann PP0 einen anderen
Schleifenkoerper geben als den Followern.

== ZWEI EIGENE LESUNGEN INNERHALB DIESES LAUFS KORRIGIERT ==
1. Ein einzelner py-spy-Treffer in `phase_flip_output_trace.observe` sah aus
   wie "das Instrument ist der Straggler". `observe` ist `pass_no += 1;
   ring.append(...)` -- trivial billig. Die zweite Probe zeigte PP0 bewegt.
   Ein Sample einer billigen Funktion ist kein Stall-Beleg.
2. Eine einzelne NVML-Lesung (card2 1535 MiB, 306 ueber der Decke) sah aus wie
   ein Band-Riss durch meinen Konservatismus. Die 100-Sample-Verteilung zeigte
   ~4 GB Schwankung ueber den Flip-Zyklus und die Groessenordnungs-Differenz
   oben. Beide Male haette ein Einzelsample einen falschen Befund erzeugt.

BELEG-STUFE: Bau DESK+BOOT (Instrument feuert, Guardrails verifiziert).
Kosten BOOT-GEMESSEN. Stall-Abnahme FAIL, neue Wurzel BOOT-BEOBACHTET
(PP1/PP2 je 1 Sample, PP0 2 Samples), Mechanismus NICHT bestimmt.
Serving wieder oben, health 200, kohaerent.
efschu pushed a commit to efschu/htsglang that referenced this pull request Sep 24, 2026
…vat_frei + Transiente); W130 verweigert SCRATCH_D 86 auf der 5090 vor dem Laden (fnFL2 H33)

Der Dry-Run war fuer D-TP0 (5090, Attention-Host der Form A) kein Gate:
er liess FR_D[0] 0.10/0.15 und SCRATCH_D[0] 86 durch (W122 PASST, DECKE
0.150), am Metall starb fnFL2x128 mit SCRATCH 86 an OOM im Extend
("74.81 MiB is free ... 4.75 GiB allocated in private pools (e.g., CUDA
Graphs)"). W122 prueft das BUDGET; mit --max-total-tokens 262144 nimmt der
KV-Pool nur 262144 x Zelle, der Rest des Budgets bleibt liegen. Was die
KARTE fuellt, stand in keinem Posten: die freien Bloecke privater Graph-/
Tag-Pools (fuer empty_cache unerreichbar; TP0 x141/x144 4993 MiB, x128
4861 MiB) und die Transiente des schwersten Forwards.

Gemessen je Rang (torch-Sicht): Kopfraum = cap - peak - privat_frei mit
cap = card free + reserved, peak = allocator peak since pools. TP0 decode:
x141 28.71 - 23.23 - 4.876 GiB = 618 MiB, x144 608 MiB (beide liefen),
x128 289 MiB (starb). Die Grenze ist corridor_guard.NEAR_OOM_MIB (400).
"card free" im Extend trennt NICHT (x144 TP0 102 MiB, TP2 41 MiB, beide
liefen: der allgemeine Cache ist Luft, der private nicht).

Neu:
- planner/graph_pool_ledger.py (rein): Messpunkt, WEG2-GRAPH-POOL-Zeile
  und Leser; Altlogs ueber [vram-peak] + sgl-project#1027 trapped=.
- vram_family_census: Instrument WEG2-GRAPH-POOL rank=N phase=...
  captured_mib private_free_mib reserved_after_mib allocator_cache_mib
  ... headroom_mib pools=, einmal nach den Captures und neben jeder
  [vram-peak]-Zeile (ein memory_snapshot je Zeile, nie im Capture).
- expert_residency 4b: KARTEN-Bilanz neben W122, Referenz
  D_CARD_REFERENCE_FNFL2 aus fnFL2x141 + fnFL2x144 (per Test an die
  Logzeilen gebunden), je Rang um die Pufferbytes verschoben, Draft-
  Vokabular als exakter Term; W130 Weg2DCardNearOom unter near-OOM,
  Decode unter dem Band-Floor als Befund. Launcher --d-card-reference-logs.

Dry-Run gegen den Klon: x141-Form rc=0 DRY-RUN complete (TP0 Kopfraum
608, Decode frei 1065 MiB, KARTEN-DECKE 0.067/0.634/0.519); SCRATCH 86
W130 (Kopfraum 144); FR_D[0] 0.10 W130 (-320).

Tests: test_weg2_d_card_graph_pool_h33.py (Metall-Bilanz x141 1,05 GiB,
SCRATCH 86 und H30-Sprossen verweigert, Mutant ohne privat_frei passt
faelschlich, Instrument-Rundlauf, Runtime-Spiegel); H8-Launcher-Test:
0.098 mit eigenem Draft-Vokabular jetzt W130 statt still durch.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants