💻 computer science

Deductive Verification of Weak Memory Programs with View-based Protocols (extended version)

Dieser Beitrag schließt die Lücke für die automatisierte deduktive Verifikation schwacher Speichermodelle, indem er mit VerCors-relaxed einen Ansatz zur Kodierung von Protokollautomaten und der SLR-Logik in das VerCors-Tool entwickelt, um komplexe Nebenläufigkeitsprogramme automatisch zu verifizieren.

Ursprüngliche Autoren: Ömer Şakar, Soham Chakraborty, Marieke Huisman, Anton Wijs

Veröffentlicht 2026-04-24

📖 4 Min. Lesezeit☕ Kaffeepausen-Lektüre

CC BY 4.0

Ursprüngliche Autoren: Ömer Şakar, Soham Chakraborty, Marieke Huisman, Anton Wijs

Originalarbeit lizenziert unter CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dies ist eine KI-generierte Erklärung des untenstehenden Papers. Sie wurde nicht von den Autoren verfasst oder gebilligt. Für technische Genauigkeit konsultieren Sie das Originalpaper. Vollständigen Haftungsausschluss lesen

Das große Problem: Wenn Computer "faul" werden

Stell dir vor, du und ein Freund schreibt beide in ein gemeinsames Notizbuch. In einer perfekten Welt (was Informatiker "sequenzielle Konsistenz" nennen) würdet ihr genau in der Reihenfolge schreiben, in der ihr es tut. Wenn du Seite 1 schreibst und er Seite 2, sieht er deine Seite 1, bevor er seine Seite 2 schreibt.

Aber moderne Computer sind nicht perfekt. Um schneller zu sein, lassen sie Dinge aus, verschieben Befehle oder schreiben Dinge erst später auf, wenn es gerade passt. Das nennt man "Weak Memory" (schwacher Speicher).

Das Problem: Manchmal sieht es für den Computer so aus, als hätte er alles getan, aber für einen anderen Prozess (oder einen anderen Computerkern) sieht es so aus, als wäre etwas passiert, das eigentlich gar nicht passiert ist. Das führt zu verrückten Ergebnissen, die man mit dem normalen "Reihenfolge-Prinzip" nicht erklären kann.

Die alte Lösung: Manuelle Detektivarbeit

Bisher mussten Programmierer und Mathematiker diese Programme wie Detektive von Hand durchgehen. Sie mussten für jedes kleine Programm beweisen: "Okay, unter diesen speziellen Bedingungen ist das Ergebnis noch sicher." Das war extrem mühsam, fehleranfällig und dauerte ewig.

Die neue Lösung: Ein digitaler "Protokoll-Wächter"

Die Autoren dieses Papiers haben eine neue Methode entwickelt, um das mit einem Computerprogramm (einem "Verifizierer" namens VerCors) automatisch zu prüfen.

Stell dir das so vor:

Die Protokolle (Die Spielregeln):
Für jeden Thread (jeden "Arbeiter" im Programm) und jeden Speicherort (jedes "Notizbuch") erstellen sie eine Art Baumdiagramm. Das ist wie ein Fahrplan.
- Beispiel: "Thread A darf zuerst '1' schreiben, dann '2'. Aber er darf nicht plötzlich '5' schreiben, ohne vorher '1' und '2' gemacht zu haben."
- Das ist das Protokoll. Es sagt genau, welche Zustände erlaubt sind.
Die lokalen Ansichten (Die Brille jedes Arbeiters):
Jeder Thread hat seine eigene "Brille" (eine lokale Ansicht). Durch diese Brille sieht der Thread nicht nur, was er selbst tut, sondern er spekuliert auch, was die anderen tun könnten.
- Die Metapher: Stell dir vor, du bist in einem Raum mit drei Leuten. Du hast eine Brille auf, durch die du die anderen drei siehst. Du denkst: "Ich habe gerade 'Rot' geschrieben. Vielleicht hat Person B gerade 'Blau' geschrieben, vielleicht 'Grün'. Ich muss prüfen, ob das, was ich sehe, mit den Spielregeln (dem Protokoll) übereinstimmt."
Der Wächter (VerCors-relaxed):
Das Tool VerCors ist wie ein strenger Wächter, der diese Brille und die Spielregeln überwacht.
- Wenn ein Thread etwas schreibt, prüft der Wächter: "Ist das im Protokoll erlaubt?"
- Wenn ein Thread etwas liest, prüft der Wächter: "Kann dieser Thread das überhaupt sehen, basierend auf dem, was er von den anderen 'spekuliert' hat?"
- Am Ende prüft er: "Hat jeder Thread am Ende einen erlaubten Zustand erreicht? Oder hat jemand etwas gelesen, das niemand je geschrieben hat?" (Das wäre ein Fehler!).

Warum ist das genial?

Bisher mussten Menschen diese Logik selbst erfinden. Jetzt haben die Autoren das SLR (eine sehr fortschrittliche mathematische Logik) in dieses Tool eingebaut.

Der Trick: Sie nutzen die "Brillen" (Ansichten), um zu simulieren, wie Computer denken, wenn sie Dinge verschieben.
Das Ergebnis: Das Tool kann jetzt automatisch prüfen, ob ein Programm sicher ist, auch wenn der Computer Dinge durcheinanderwirft. Es hat das in vielen Beispielen aus der Fachliteratur getestet und funktioniert erstaunlich schnell (in etwa 1 bis 1,5 Minuten pro Beispiel).

Zusammenfassung in einem Satz

Die Autoren haben eine Art automatischen Sicherheitsprüfer gebaut, der für Computerprogramme mit "verwirrendem" Gedächtnis (Weak Memory) nicht nur die Spielregeln aufstellt, sondern auch automatisch kontrolliert, ob jeder Spieler sich an diese Regeln hält, ohne dass ein Mensch jedes Detail von Hand durchrechnen muss.

Das bedeutet: Sicherere Software für unsere Smartphones und Server, die schneller und trotzdem fehlerfrei läuft.

1. Problemstellung

Die korrekte Verifikation von parallelen Programmen unter schwachen Speichermodellen (Weak Memory Models) stellt eine erhebliche Herausforderung dar. Im Gegensatz zum sequentiellen Konsistenzmodell (SC), bei dem Thread-Ausführungen als einfache Verschachtelung (Interleaving) betrachtet werden können, erlauben schwache Modelle (wie sie in modernen Hardware-Architekturen und Compilern üblich sind) Ausführungen, die durch Reordering von Speicherzugriffen entstehen. Dies führt zu Ergebnissen, die unter SC unmöglich wären.

Bisherige Ansätze zur formalen Verifikation dieser Programme (z. B. mittels Logiken wie RSL, GPS oder FSL) erfordern in der Regel manuelle Beweise, die komplex und fehleranfällig sind. Das Verifikationswerkzeug VerCors bietet zwar eine starke Automatisierung für Programme unter sequentieller Konsistenz (SC) mittels einer permissionsbasierten Separation-Logik (PBSL), fehlte jedoch bisher eine Methode zur automatisierten deduktiven Verifikation von Programmen mit schwachen Speicherzugriffen.

2. Methodik: View-based Protocols

Die Autoren schlagen einen neuen Ansatz vor, der die Lücke zwischen der Automatisierung von VerCors und der Komplexität schwacher Speichermodelle schließt. Der Kern der Methode sind protokollbasierte Ansichten (View-based Protocols).

Protokolle pro Thread und Speicherort: Im Gegensatz zu früheren Ansätzen (wie GPS), die ein globales Protokoll pro Speicherort definieren, führt dieser Ansatz ein separates Protokoll $P^t_x$ für jede Kombination aus Thread $t$ und Speicherort $x$ ein, auf den der Thread schreibt. Diese Protokolle sind endliche Automaten (Bäume), die den möglichen Schreibverlauf eines Threads modellieren.
Thread-Lokale Ansichten (Thread-local Views): Jeder Thread $t$ unterhält für jeden Speicherort $x$ eine lokale Ansicht $L^t_x$ . Diese Ansicht speichert den aktuellen Zustand des eigenen Protokolls sowie die vermuteten (spekulativen) Zustände der Protokolle aller anderen Threads.
Spekulative Zugriffe: Ein Thread kann beim Lesen (Load) Werte aus Zuständen lesen, die in den Protokollen anderer Threads erreichbar sind, auch wenn diese noch nicht explizit ausgeführt wurden. Dies modelliert das Verhalten schwacher Speichermodelle, bei denen Schreiboperationen reordering unterliegen können.
Operative Semantik (SOS-Regeln): Die Evolution der Ansichten wird durch Transitionen definiert:
- Schreiben (Store): Der Thread bewegt sich in seinem eigenen Protokoll zu einem neuen Zustand. Die globale Ansicht ( $\pi$ ) und die Ordnungsrelation ( $\tau$ ) werden aktualisiert, um die Schreibreihenfolge zu protokollieren.
- Lesen (Read): Ein Thread kann einen Wert lesen, der einem Zustand in einem anderen Thread-Protokoll entspricht, sofern dieser Zustand gemäß den aktuellen Ansichten erreichbar ist und keine Verletzung der Kohärenz (z. B. das Lesen eines Werts vor einem späteren Schreibzugriff) stattfindet.
Konsistenzprüfung: Am Ende der Ausführung wird geprüft, ob alle Threads ihre Protokolle in einem akzeptierenden Zustand beendet haben und ob alle Spekulationen (was ein Thread über andere annahm) mit der tatsächlichen Ausführung übereinstimmen.

3. Schlüsselanwendungen und Kodierung

VerCors-relaxed: Die Autoren haben eine Erweiterung von VerCors namens VerCors-relaxed entwickelt. Diese nutzt die bestehenden Fähigkeiten von VerCors (Permissions, Separation Logic) und erweitert sie um die Kodierung der oben genannten Protokolle und Ansichten.
Kodierung von SLR: Um die Wirksamkeit zu demonstrieren, kodieren sie den relaxierten Fragment der SLR-Logik (Separation Logic for Relaxed memory) in VerCors-relaxed. SLR ist ein moderner, zustandsbasieter Ansatz für schwache Speicher.
- Die SLR-Aussagen $Wp(x, X)$ (Schreibrechte) und $O(x, v, ts)$ (Beobachtung von Werten mit Zeitstempel) werden durch die Protokollzustände und die Ordnungsrelationen $\tau$ (Modifikationsreihenfolge) und $\pi$ (letzte beobachtete Operation) abgebildet.
- Die Autoren beweisen die Korrektheit (Soundness) ihres Ansatzes: Wenn ein Programm mit view-based Protocols in VerCors verifiziert wird, gilt es auch als verifiziert unter der SLR-Logik.
Implementierung: Die Protokolle werden in VerCors als Axiomatische Datentypen (ADTs) modelliert. Zustände und Transitionen werden durch abstrakte Funktionen und Axiome definiert, was eine flexible und modulare Verifikation ermöglicht.

4. Ergebnisse und Evaluation

Die Autoren haben 13 Beispiele aus der Literatur (u. a. ARM-weak, COH, LB, SB, 2+2W) in VerCors-relaxed kodiert und verifiziert.

Automatisierung: Alle Beispiele wurden automatisch verifiziert, ohne manuelle Beweisschritte.
Performance: Die durchschnittliche Verifizierungszeit lag bei ca. 1 bis 1,5 Minuten pro Beispiel (durchschnittlich 50–90 Sekunden). Dies gilt als realistisch für deduktive Verifikation komplexer paralleler Programme.
Skalierbarkeit: Die Anzahl der Zeilen für die Protokollkodierung wächst exponentiell mit der Anzahl der Zustände (da alle Zustände als distinkt definiert werden müssen), aber die Verifizierungszeiten blieben für die getesteten Beispiele stabil.
Fehlererkennung: Das System konnte inkonsistente Protokolle (z. B. fehlende Übergänge oder falsche Werte in den Protokollen) korrekt identifizieren und die Verifikation scheitern lassen, was die Robustheit des Ansatzes unterstreicht.

5. Bedeutung und Fazit

Dieses Paper ist ein bedeutender Schritt in der automatisierten Verifikation von parallelen Programmen:

Brückenschlag: Es verbindet erstmals die mächtige Automatisierung von VerCors (basierend auf Permissions) mit der Komplexität schwacher Speichermodelle.
Neue Abstraktion: Die Einführung von View-based Protocols (Protokolle pro Thread/Ort) ermöglicht eine elegante Handhabung von Spekulationen und Reordering, die in früheren Ansätzen oft manuell oder nur schwer automatisierbar war.
Praktische Anwendbarkeit: Durch die erfolgreiche Verifikation bekannter Beispiele aus der Literatur mit akzeptabler Laufzeit zeigt das Tool, dass deduktive Verifikation für schwache Speichermodelle in der Praxis einsetzbar ist.
Zukunftsausblick: Die Arbeit legt den Grundstein für die Unterstützung weiterer Speichermodelle (Release/Acquire-Fences) und die Skalierung auf größere Codebasen.

Zusammenfassend bietet der vorgestellte Ansatz eine vollautomatische, modulare und sounde Methode, um die Korrektheit von Concurrent Programs unter schwachen Speichermodellen zu garantieren, was bisher ein dominantes Hindernis für die breite Anwendung formaler Verifikation in diesem Bereich war.