Design: Vorschlag: Async/Await JS API

Dieser Vorschlag wurde in Zusammenarbeit mit @fmccabe , @thibaudmichaud , @lukewagner und @kripken entwickelt , zusammen mit Feedback von der Stacks-Untergruppe (mit einer informellen Abstimmung, die das Vorrücken in Phase 0 heute genehmigt). Beachten Sie, dass aus Zeitgründen geplant ist, eine sehr schnelle Präsentation (dh 5 Minuten) abzuhalten und abzustimmen, um diese am 3. August in Phase 1 vorzurücken. Um dies zu erleichtern, ermutigen wir die Leute dringend, Bedenken hier im Voraus zu äußern, damit wir feststellen können, ob es größere Bedenken gibt, die es verdienen würden, die Präsentation und Abstimmung auf einen späteren Zeitpunkt mit mehr Zeit zu verschieben.

Der Zweck dieses Vorschlags besteht darin, eine relativ effiziente und relativ ergonomische Interop zwischen JavaScript-Versprechen und WebAssembly bereitzustellen, jedoch unter der Einschränkung zu arbeiten, dass die einzigen Änderungen an der JS-API und nicht am Core-Wasm vorgenommen werden.
Es ist zu erwarten, dass der Stack-Switching-Vorschlag schließlich den Kern von WebAssembly um die Funktionalität erweitert, um die in diesem Vorschlag bereitgestellten Operationen zusammen mit vielen anderen wertvollen Stack-Switching-Vorgängen direkt in WebAssembly zu implementieren, aber dieser spezielle Anwendungsfall für Stack-Switching hatte ausreichende Dringlichkeit, um einen schnelleren Weg nur über die JS-API zu verdienen.
Weitere Informationen finden Sie in den Notizen und Folien zum Stack-Untergruppentreffen am 28. Juni 2021 , in denen die von uns berücksichtigten Nutzungsszenarien und Faktoren detailliert beschrieben und die Gründe für unsere Herleitung des folgenden Designs zusammengefasst werden.

UPDATE: Nach dem Feedback, das die Stacks-Untergruppe von TC39 erhalten hatte, erlaubt dieser Vorschlag nur das Aussetzen von WebAssembly-Stacks – er nimmt keine Änderungen an der JavaScript-Sprache vor und ermöglicht insbesondere nicht indirekt die Unterstützung für getrennte asycn / await in JavaScript.

Dies hängt (lose) vom js-types- Vorschlag ab, der WebAssembly.Function als Unterklasse von Function einführt.

Schnittstelle

Der Vorschlag besteht darin, die folgende Schnittstelle, den Konstruktor und die folgenden Methoden zur JS-API hinzuzufügen, mit weiteren Details zu ihrer Semantik weiter unten.

interface Suspender {
   constructor();
   Function suspendOnReturnedPromise(Function func); // import wrapper
   // overloaded: WebAssembly.Function suspendOnReturnedPromise(WebAssembly.Function func);
   WebAssembly.Function returnPromiseOnSuspend(WebAssembly.Function func); // export wrapper
}

Beispiel

Das Folgende ist ein Beispiel dafür, wie wir erwarten, dass jemand diese API verwendet.
In unseren Nutzungsszenarien fanden wir es sinnvoll, WebAssembly-Module so zu betrachten, dass sie konzeptionell "synchrone" und "asynchrone" Importe und Exporte haben.
Die aktuelle JS-API unterstützt nur "synchrone" Importe und Exporte.
Die Methoden der Suspender-Schnittstelle werden verwendet, um relevante Importe und Exporte zu umschließen, um sie "asynchron" zu machen, wobei das Suspender-Objekt selbst diese Importe und Exporte explizit miteinander verbindet, um sowohl die Implementierung als auch die Zusammensetzbarkeit zu erleichtern.

WebAssembly ( demo.wasm ):

(module
    (import "js" "init_state" (func $init_state (result f64)))
    (import "js" "compute_delta" (func $compute_delta (result f64)))
    (global $state f64)
    (func $init (global.set $state (call $init_state)))
    (start $init)
    (func $get_state (export "get_state") (result f64) (global.get $state))
    (func $update_state (export "update_state") (result f64)
      (global.set (f64.add (global.get $state) (call $compute_delta)))
      (global.get $state)
    )
)

Text ( data.txt ):

19827.987

JavaScript:

var suspender = new Suspender();
var init_state = () => 2.71;
var compute_delta = () => fetch('data.txt').then(res => res.text()).then(txt => parseFloat(txt));
var importObj = {js: {
    init_state: init_state,
    compute_delta: suspender.suspendOnReturnedPromise(compute_delta)
}};

fetch('demo.wasm').then(response =>
    response.arrayBuffer()
).then(buffer =>
    WebAssembly.instantiate(buffer, importObj)
).then(({module, instance}) => {
    var get_state = instance.exports.get_state;
    var update_state = suspender.returnPromiseOnSuspend(instance.exports.update_state);
    ...
});

In diesem Beispiel haben wir ein WebAssembly-Modul, das eine sehr vereinfachte Zustandsmaschine ist – jedes Mal, wenn Sie den Zustand aktualisieren, ruft es einfach einen Import auf, um ein Delta zu berechnen, das dem Zustand hinzugefügt wird.
Auf JavaScript-Seite stellt sich jedoch heraus, dass die Funktion, die wir zum Berechnen des Deltas verwenden möchten, asynchron ausgeführt werden muss; das heißt, es gibt eher ein Versprechen einer Zahl als eine Zahl selbst zurück.

Wir können diese Synchronisationslücke schließen, indem wir die neue JS-API verwenden.
Im Beispiel wird ein Import des WebAssembly-Moduls mit suspender.suspendOnReturnedPromise und ein Export mit suspender.returnPromiseOnSuspend , beide verwenden dasselbe suspender .
Das suspender verbindet die beiden miteinander.
Es macht es so, dass, wenn jemals der (unverpackte) Import ein Versprechen zurückgibt, der (verpackte) Export ein Versprechen zurückgibt, wobei die gesamte Berechnung dazwischen "ausgesetzt" wird, bis das Versprechen des Imports aufgelöst wird.
Das Umschließen des Exports fügt im Wesentlichen einen async Marker hinzu, und das Umschließen des Imports fügt im Wesentlichen einen await Marker hinzu, aber im Gegensatz zu JavaScript müssen wir async nicht explizit einfädeln. await durch alle zwischengeschalteten WebAssembly-Funktionen!

In der Zwischenzeit kehrt der Aufruf von init_state während der Initialisierung notwendigerweise ohne Unterbrechung zurück, und Aufrufe von Export get_state kehren ebenfalls immer ohne Unterbrechung zurück, sodass der Vorschlag weiterhin die bestehenden "synchronen" Importe und Exporte unterstützt das WebAssembly-Ökosystem heute verwendet.
Natürlich werden viele Details überflogen, wie zum Beispiel die Tatsache, dass, wenn ein synchroner Export einen asynchronen Import aufruft, das Programm abfängt, wenn der Import versucht, anzuhalten.
Im Folgenden finden Sie eine detailliertere Spezifikation sowie einige Implementierungsstrategien.

Spezifikation

Ein Suspender befindet sich in einem der folgenden Zustände:

• Inaktiv - wird derzeit nicht verwendet
• Aktiv [ caller ] - Steuerelement befindet sich innerhalb von Suspender , wobei caller die Funktion ist, die in Suspender aufgerufen hat und ein externref erwartet.
• Gesperrt - warte derzeit auf ein Versprechen zur Lösung

Die Methode suspender.returnPromiseOnSuspend(func) behauptet, dass func ein WebAssembly.Function mit einem Funktionstyp der Form [ti*] -> [to] und gibt dann ein WebAssembly.Function mit einem Funktionstyp zurück [ti*] -> [externref] das folgendes macht, wenn es mit den Argumenten args aufgerufen wird:

1. Traps, wenn der Status von suspender nicht inaktiv ist
2. Ändert den Status von suspender in Aktiv [ caller ] (wobei caller der aktuelle Anrufer ist)
3. Lassen Sie result das Ergebnis des Aufrufs von func(args) (oder einer beliebigen Trap oder ausgelösten Ausnahme) sein.
4. Behauptet, dass der Status von suspender Aktiv [ caller' ] für einige caller' (sollte garantiert sein, obwohl sich der Anrufer möglicherweise geändert hat)
5. Ändert den Status von suspender in Inaktiv
6. Gibt (oder wiederholt) result zu caller'

Die Methode suspender.suspendOnReturnedPromise(func)

• wenn func ein WebAssembly.Function , dann behauptet, dass sein Funktionstyp die Form [t*] -> [externref] und gibt ein WebAssembly.Function mit dem Funktionstyp [t*] -> [externref] ;
• behauptet andernfalls, dass func Function und gibt Function .

In beiden Fällen führt die von suspender.suspendOnReturnedPromise(func) Funktion Folgendes aus, wenn sie mit den Argumenten args aufgerufen wird:

1. Lassen Sie result das Ergebnis des Aufrufs von func(args) (oder einer beliebigen Trap oder ausgelösten Ausnahme) sein.
2. Wenn result kein zurückgegebenes Versprechen ist, dann gibt (oder wiederholt) result
3. Traps, wenn der Status von suspender nicht aktiv ist [ caller ] für einige caller
4. Lassen Sie frames die Stack-Frames seit caller
5. Traps, wenn es in frames Frames mit nicht anhängigen Funktionen gibt
6. Ändert den Status von suspender in Gesperrt
7. Gibt das Ergebnis von result.then(onFulfilled, onRejected) mit den Funktionen onFulfilled und onRejected , die Folgendes tun:
   
   
   
   1. Behauptet , dass suspender ‚s Zustand ist vorübergehend gesperrt (garantiert werden soll)
   
   
   2. Ändert den Status von suspender in Aktiv [ caller' ], wobei caller' der Anrufer von onFulfilled / onRejected
   
   
   3. 
      
      
      • Konvertiert im Fall von onFulfilled den angegebenen Wert in externref und gibt ihn in frames
      
      
      
      • Im Fall von onRejected wird der angegebene Wert bis zu frames als Ausnahme gemäß der JS-API des Exception Handling- Vorschlags
      
      
      
   
   

Eine Funktion ist suspendierbar, wenn sie es war

• durch ein WebAssembly-Modul definiert,
• zurückgegeben von suspendOnReturnedPromise ,
• zurückgegeben von returnPromiseOnSuspend ,
• oder generiert durch Erstellen einer Hostfunktion für eine aussetzbare Funktion

Wichtig ist, dass in JavaScript geschriebene Funktionen nicht aussetzbar sind, was dem Feedback von Mitgliedern von TC39 entspricht , und Host-Funktionen (mit Ausnahme der wenigen oben aufgeführten) sind nicht aussetzbar, entsprechend dem Feedback von Engine-Maintainern.

Implementierung

Das Folgende ist eine Umsetzungsstrategie für diesen Vorschlag.
Es übernimmt die Engine-Unterstützung für das Stack-Switching, wo natürlich die Hauptherausforderungen bei der Implementierung liegen.

Es gibt zwei Arten von Stacks: einen Host- (und JavaScript-)Stack und einen WebAssembly-Stack. Jeder WebAssembly-Stack hat ein Suspender-Feld namens suspender . Jeder Thread hat einen Host-Stack.

Jedes Suspender hat zwei Stack-Referenzfelder: eines namens caller und eines namens suspended .

• Im Zustand Inaktiv sind beide Felder null.
• Im Status Aktiv verweist das Feld caller auf den (gesperrten) Stack des Aufrufers, und das Feld suspended ist null
• Im Suspended- Zustand verweist das suspended Feld auf den (suspendierten) WebAssembly-Stack, der derzeit dem Suspendierer zugeordnet ist, und das caller Feld ist null.

suspender.returnPromiseOnSuspend(func)(args) wird implementiert von

1. Überprüfen, ob suspender.caller und suspended.suspended null sind (andernfalls einfangen)
2. Lassen Sie stack ein neu zugewiesener WebAssembly-Stack sein, der mit suspender verknüpft ist
3. Wechseln zu stack und Speichern des ehemaligen Stack in suspender.caller
4. Lassen Sie result das Ergebnis von func(args) (oder einer beliebigen Falle oder ausgelösten Ausnahme) sein.
5. Zu suspender.caller wechseln und auf null setzen
6. Befreiung von stack
7. Zurückgeben (oder erneut werfen) result

suspender.suspendOnReturnedPromise(func)(args) wird implementiert von

1. Aufrufen von func(args) , Abfangen einer Falle oder ausgelösten Ausnahme
2. Wenn result kein zurückgegebenes Versprechen ist, wird result returning zurückgegeben (oder erneut geworfen).
3. Überprüfen, ob suspender.caller nicht null ist (andernfalls einfangen)
4. Sei stack der aktuelle Stack
5. Während stack kein WebAssembly-Stack ist, der mit suspender verknüpft ist:
   
   
   
   • Überprüfen, ob stack ein WebAssembly-Stack ist (andernfalls einfangen)
   
   
   • Aktualisieren von stack auf stack.suspender.caller
   
   
6. Zu suspender.caller wechseln, auf null setzen und den früheren Stack in suspender.suspended storing speichern
7. Rückgabe des Ergebnisses von result.then(onFulfilled, onRejected) mit den Funktionen onFulfilled und onRejected , die implementiert werden durch
   
   
   
   1. Zu suspender.suspended wechseln, auf null setzen und den früheren Stack in suspender.caller storing speichern
   
   
   2. 
      
      
      • Im Fall von onFulfilled den angegebenen Wert in externref umwandeln und zurückgeben
      
      
      
      • Im Fall von onRejected wird der angegebene Wert erneut geworfen
      
      
      
   
   

Die Implementierung der Funktion, die durch das Erstellen einer Host-Funktion für eine suspendierbare Funktion generiert wird