Atomics

Description

Contrairement à la plupart des objets globaux, Atomics n'est pas un constructeur. Vous ne pouvez pas l'utiliser avec l'opérateur new ni invoquer l'objet Atomics comme une fonction. Toutes les propriétés et méthodes de Atomics sont statiques (tout comme l'objet Math).

Opérations atomiques

Lorsque la mémoire est partagée, plusieurs processus peuvent lire et écrire les mêmes données en mémoire. Les opérations atomiques garantissent que des valeurs prévisibles sont écrites et lues, que les opérations sont terminées avant que l'opération suivante ne commence et que les opérations ne sont pas interrompues.

Attente et notification

Les méthodes wait() et notify() sont modélisées sur les futex Linux « fast user-space mutex » et fournissent des moyens d'attendre jusqu'à ce qu'une certaine condition devienne vraie et sont généralement utilisées comme constructions bloquantes.

Propriétés statiques

Atomics[Symbol.toStringTag]

La valeur initiale de la propriété [Symbol.toStringTag] est la chaîne « Atomics ». Cette propriété est utilisée dans Object.prototype.toString().

Méthodes statiques

Atomics.add()

Ajoute la valeur fournie à la valeur existante à l'index défini du tableau. Retourne l'ancienne valeur à cet index.

Atomics.and()

Calcule un « ET » binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Atomics.compareExchange()

Stocke la valeur fournie à l'index défini du tableau si elle est égale à une valeur donnée. Retourne l'ancienne valeur.

Atomics.exchange()

Stocke la valeur fournie à l'index défini du tableau. Retourne l'ancienne valeur.

Atomics.isLockFree()

Primitive d'optimisation permettant de déterminer s'il faut utiliser des verrous ou des opérations atomiques. Retourne true si une opération atomique sur des tableaux de la taille d'élément donnée sera implémentée par une opération atomique matérielle (plutôt que par un verrou). Réservé aux expert·e·s.

Atomics.load()

Retourne la valeur à l'index défini du tableau.

Atomics.notify()

Notifie les agents qui attendent sur l'index défini du tableau. Retourne le nombre d'agents notifiés.

Atomics.or()

Calcule un « OU » binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Atomics.pause()

Fournit une primitive de micro-attente qui indique au processeur que l'appelant effectue une boucle d'attente en attendant l'accès à une ressource partagée. Cela permet au système de réduire les ressources allouées au cœur (par exemple la consommation) ou au processus, sans céder l'exécution du processus courant.

Atomics.store()

Stocke une valeur à l'index défini du tableau. Retourne la valeur.

Atomics.sub()

Soustrait une valeur à l'index défini du tableau. Retourne l'ancienne valeur à cet index.

Atomics.wait()

Vérifie que l'index défini du tableau contient toujours une valeur puis dort en attendant ou expire. Retourne soit "ok", "not-equal" ou "timed-out". Si l'attente n'est pas autorisée dans l'agent appelant, cela lève une exception. (La plupart des navigateurs n'autoriseront pas wait() sur le processus principal du navigateur.)

Atomics.waitAsync()

Attend de manière asynchrone (c'est‑à‑dire sans bloquer, contrairement à Atomics.wait) sur une zone de mémoire partagée et retourne un objet représentant le résultat de l'opération.

Atomics.xor()

Calcule un « OU » exclusif binaire entre la valeur à l'index défini du tableau et la valeur fournie. Retourne l'ancienne valeur à cet index.

Exemples

Utilisation de Atomics

const sab = new SharedArrayBuffer(1024);
const ta = new Uint8Array(sab);

ta[0]; // 0
ta[0] = 5; // 5

Atomics.add(ta, 0, 12); // 5
Atomics.load(ta, 0); // 17

Atomics.and(ta, 0, 1); // 17
Atomics.load(ta, 0); // 1

Atomics.compareExchange(ta, 0, 5, 12); // 1
Atomics.load(ta, 0); // 1

Atomics.exchange(ta, 0, 12); // 1
Atomics.load(ta, 0); // 12

Atomics.isLockFree(1); // true
Atomics.isLockFree(2); // true
Atomics.isLockFree(3); // false
Atomics.isLockFree(4); // true

Atomics.or(ta, 0, 1); // 12
Atomics.load(ta, 0); // 13

Atomics.store(ta, 0, 12); // 12

Atomics.sub(ta, 0, 2); // 12
Atomics.load(ta, 0); // 10

Atomics.xor(ta, 0, 1); // 10
Atomics.load(ta, 0); // 11

Attente et notification

Étant donné un Int32Array partagé :

const sab = new SharedArrayBuffer(1024);
const int32 = new Int32Array(sab);

Un processus de lecture est en sommeil et attend sur l'index 0 parce que la valeur fournie correspond à celle stockée à l'index fourni. Le processus de lecture ne poursuivra pas son exécution tant que le processus d'écriture n'aura pas appelé Atomics.notify() à la position 0 du tableau typé fourni. Notez que si, après avoir été réveillé, la valeur de l'index 0 n'a pas été modifiée par le processus d'écriture, le processus de lecture ne se remettra pas à dormir, mais continuera son exécution.

Atomics.wait(int32, 0, 0);
console.log(int32[0]); // 123

Un processus d'écriture stocke une nouvelle valeur et notifie le processus en attente une fois qu'il a écrit :

console.log(int32[0]); // 0;
Atomics.store(int32, 0, 123);
Atomics.notify(int32, 0, 1);

Spécifications

Compatibilité des navigateurs

Voir aussi

• L'objet ArrayBuffer
• Guide des tableaux typés en JavaScript
• Web Workers
• La mémoire partagée — un rapide tutoriel ^(angl.) dans la proposition TC39 ecmascript-sharedmem
• Aperçu des nouvelles primitives parallèles de JavaScript ^(angl.) sur hacks.mozilla.org (2016)