Atomics.pause()

Syntax

Atomics.pause()
Atomics.pause(durationHint)

Parameter

durationHint Optional

Ein Integer, den eine Implementierung verwenden kann, um zu bestimmen, wie lange gewartet wird. Bei einem Wert von n + 1 wartet eine Implementierung mindestens so lange wie bei einem gegebenen Wert n. Die genaue Zahl hat keine physikalische Bedeutung. Es kann eine interne obere Grenze für die maximale Pausenzeit im Bereich von Dutzenden bis Hunderten von Nanosekunden geben. Dies kann verwendet werden, um eine Backoff-Strategie zu implementieren, indem der durationHint erhöht wird. Es gibt keine Garantie, dass eine Implementierung diesen Hinweis verwenden wird.

Rückgabewert

Keiner (undefined).

Ausnahmen

TypeError

Wird ausgelöst, wenn durationHint weder ein Integer noch undefined ist.

Beispiele

Beachten Sie, dass diese Beispiele nicht direkt aus der Konsole oder von einer beliebigen Webseite ausgeführt werden können, da SharedArrayBuffer nicht definiert ist, es sei denn, seine Sicherheitsanforderungen sind erfüllt.

Verwendung von Atomics.pause()

Das Aufrufen von Atomics.wait() oder Atomics.waitAsync(), um auf den Zugriff auf gemeinsamen Speicher zu warten, führt dazu, dass der Thread aus dem Kern heraus- und nach der Wartezeit wieder eingeplant wird. Dies ist effizient bei hoher Konkurrenz, wenn der Zugriff auf den gemeinsamen Speicher länger dauern könnte. Bei niedriger Konkurrenz ist es oft effizienter, die Sperre abzufragen, ohne den Thread abzugeben: Dieser Ansatz ist bekannt als busy waiting oder spinlocking. Die pause()-Methode ermöglicht es Ihnen, effizienter auf eine Sperre zu warten, indem sie der CPU Hinweise gibt, was der Thread gerade tut, und daher einen geringen Ressourcenbedarf hat.

Um beiden Bedingungen gerecht zu werden, ist es ein häufiger Ansatz, zunächst zu warten in der Hoffnung, dass die Konkurrenz niedrig ist, und dann zu warten, wenn die Sperre nicht nach kurzer Zeit erlangt wird. Wenn wir die Sperre bereits durch Spinlocking erworben haben, wird der wait()-Aufruf ein No-Operation sein.

Das folgende Beispiel zeigt, wie dieser Ansatz mit Atomics.pause() und Atomics.wait() verwendet werden kann.

// Imagine another thread also has access to this shared memory
const sab = new SharedArrayBuffer(1024);
const i32 = new Int32Array(sab);

// Fast path: spin the CPU for a short while
let spin = 0;
do {
  if (Atomics.compareExchange(i32, 0, 0, 1) === 0) {
    break;
  }
  Atomics.pause();
  spin++;
} while (spin < 10);

// Slow path: wait for the lock
// This can only be called in a worker thread,
// because the main thread cannot be blocked
Atomics.wait(i32, 0, 1);

Backoff-Strategien

Der durationHint-Parameter kann verwendet werden, um Backoff-Strategien zu implementieren. Beispielsweise kann ein Thread mit einem kleinen Hinweis beginnen und ihn exponentiell bei jeder Iteration erhöhen. Dies ist vorteilhafter als pause() viele Male aufzurufen, da bei nicht-JITed Code Funktionsaufrufe selbst einen hohen Overhead haben.

// Exponential backoff
for (let hint = 1; hint < 1000; hint *= 2) {
  Atomics.pause(hint);
}

// Linear backoff
for (let hint = 1; hint < 100; hint++) {
  Atomics.pause(hint);
}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Atomics
• Atomics.wait()
• Atomics.waitAsync()