API Compute Pressure

Obtenez des informations sur la pression de calcul de votre système.

Jeff Posnick
Kenneth Christiansen
Kenneth Christiansen
X GitHub
Arnaud (Arno) Mandy
GitHub

L'API Compute Pressure propose des états de haut niveau qui représentent la pression exercée sur le système. Il permet à l'implémentation d'utiliser les bonnes métriques matérielles sous-jacentes pour s'assurer que les utilisateurs peuvent exploiter toute la puissance de traitement à leur disposition tant que le système n'est pas soumis à un stress incontrôlable.

État actuel

Étape État
1. Créer un message d'explication Fin
2. Créer une première ébauche de la spécification Fin
3. Recueillir des commentaires et itérer sur la conception En cours
4. Essai Origin Terminé
5. Lancement Terminé (Chrome 125)

Essayer l'API Compute Pressure

Pour tester l'API Compute Pressure en local, consultez cette page.

S'inscrire à l'essai de l'origine

À partir de Chrome 115, l'API Compute Pressure est disponible en tant que évaluation de l'origine. Elle devrait prendre fin dans Chrome 123 (29 mai 2024). Inscrivez-vous à la phase d'évaluation de Topics.

Cas d'utilisation

Les principaux cas d'utilisation améliorés par l'API Compute Pressure actuelle sont la visioconférence et les jeux vidéo.

Ces applications populaires en temps réel sont classées comme soft. Autrement dit, la qualité de service se dégrade si le système est utilisé au-delà de certains états, mais ne conduit pas à une défaillance totale du système. Ces applications en temps réel souples bénéficient grandement de la possibilité d'adapter leurs charges de travail en fonction de la consommation ou de la pression du processeur.

Plus précisément, la première version de cette API vise à permettre les décisions d'adaptation suivantes.

Visioconférence

  • Ajustez le nombre de flux vidéo affichés simultanément lors des appels avec de nombreux participants.
  • Réduire la qualité du traitement vidéo (résolution vidéo, images par seconde)
  • Ignorez le traitement vidéo non essentiel, comme certains filtres de l'appareil photo.
  • Désactivez le traitement audio non essentiel, comme la suppression du bruit WebRTC.
  • Réglez les curseurs "Qualité par rapport à la vitesse" et "Taille par rapport à la vitesse" sur "Vitesse" dans l'encodage vidéo et audio (dans WebRTC, WebCodecs ou l'encodage logiciel).

Jeux vidéo

  • Utilisez des éléments de qualité inférieure pour composer la vidéo (modèles 3D, textures, nuanceurs) et l'audio (voix, effets sonores) du jeu.
  • Désactivez les effets qui génèrent des détails non essentiels moins réalistes (eau, tissu, animations de feu, luminance de la peau, effets de reflet ou simulations physiques qui n'ont pas d'impact sur le gameplay).
  • Ajustez les curseurs de qualité par rapport à la vitesse dans le moteur de rendu du jeu (qualité des ombres, filtrage des textures, distance de vue).

Techniquement, cela peut être réalisé en connaissant les états thermiques (par exemple, le système est-il refroidi passivement) et de pression du processeur pour le thread principal et les workers utilisés par le site. L'état thermique du système est un état global et peut être affecté par des applications et des sites autres que le site d'observation.

Interfaces

L'API Compute Pressure peut être exécutée dans les contextes suivants:

  • Fenêtre ou thread principal
  • Nœud de calcul dédié
  • Nœud de calcul partagé

L'API Compute Pressure définit deux nouvelles interfaces.

PressureObserver: objet permettant d'observer la pression de calcul d'un nombre quelconque de sources à un intervalle d'échantillonnage prédéfini. La première itération dans Chromium expose "cpu" en tant que source. Pour en savoir plus, consultez la section sur les paramètres. Chaque observateur peut observer de manière asynchrone les tendances de changement de pression dans un système.

PressureRecord: décrit la tendance de la pression à un moment spécifique de la transition. Les objets de ce type ne peuvent être obtenus que de deux manières: en tant qu'entrée de votre rappel PressureObserver ou en appelant la méthode takeRecords() dans l'instance PressureObserver.

PressureObserver

Lorsqu'un objet PressureObserver est créé, il est configuré pour surveiller la pression des sources compatibles, à un intervalle d'échantillonnage donné. Les sources compatibles peuvent être observées ou non individuellement à tout moment pendant la durée de vie de l'objet PressureObserver. L'intervalle d'échantillonnage ne peut pas être modifié une fois l'objet créé.

Constructeur

PressureObserver(callback): crée un objet PressureObserver qui appelle une fonction de rappel spécifiée lorsqu'il détecte une modification des valeurs de la source observée.

Le constructeur accepte une fonction de rappel obligatoire.

Rappel

callback(): le rappel est appelé avec un tableau d'objets PressureRecord non lus.

Méthodes

PressureObserver.observe(source, options): indique à "PressureObserver" la source à observer et options facultatif, en tant que paramètres.

Options

PressureObserverOptions: contient l'intervalle d'échantillonnage, sampleInterval en millisecondes, à partir duquel l'utilisateur demande des mises à jour.

PressureObserver.unobserve(source): indique à "PressureObserver" d'arrêter d'observer une source.

PressureObserver.disconnect(): indique à "PressureObserver" d'arrêter d'observer toutes les sources.

PressureObserver.takeRecords(): renvoie une séquence d'enregistrements depuis la dernière invocation du rappel.

static PressureObserver.knownSources() (lecture seule): renvoie les types de sources connus de l'agent utilisateur dans l'ordre alphabétique.

Paramètres

source: source à observer, par exemple "cpu". Il doit s'agir de l'un des types de sources compatibles.

Dans la version actuelle de la pression de calcul, seul "cpu" est compatible.

PressureRecord

L'interface PressureRecord de l'API Compute Pressure décrit la tendance de pression d'une source à un moment de transition spécifique.

Propriétés de l'instance

PressureRecord.source (lecture seule): renvoie une chaîne représentant la source d'origine de l'enregistrement.

PressureRecord.state (lecture seule): renvoie une chaîne représentant l'état de pression enregistré.

PressureRecord.time (en lecture seule): renvoie un nombre représentant un code temporel haute résolution.

Exemples

Les sections suivantes présentent des exemples d'utilisation.

Déterminer la prise en charge de l'API

if ('PressureObserver' in globalThis) {
  // The Compute Pressure API is supported.
}

Créer un observateur de pression

Créez l'observateur de pression en appelant son constructeur avec une fonction de rappel à exécuter chaque fois qu'une mise à jour de la pression est effectuée:

const observer = new PressureObserver((records) => {
  /* ... */
});

Utilisation de l'observateur de pression

Il n'existe qu'une seule façon de démarrer un observateur de pression. Pour chaque source, appelez observer.observe(source).

observer.observe("cpu" { sampleInterval: 2_000 });

Dans cet exemple, "cpu" est la source de pression qui nous intéresse. Pour le moment, il s'agit de la seule source disponible. À l'avenir, d'autres sources telles que "gpu", "power" ou "thermals" pourraient être ajoutées.

Un intervalle d'échantillonnage, sampleInterval, de 2 000 ms signifie qu'il y aura au maximum une mise à jour toutes les deux secondes.

Si le système ne peut pas diffuser l'intervalle d'échantillonnage demandé, il fournira des échantillons à l'intervalle le plus approprié. Par exemple, si un intervalle de 2 000 ms est demandé, mais que le système ne peut fournir que des échantillons de 1 000 ms maximum, 1 000 ms seront sélectionnés.

Pour arrêter l'observation d'une source, utilisez la méthode unobserve(), comme dans l'exemple suivant:

observer.unobserve('cpu');

Pour désobserver toutes les sources en même temps, utilisez la méthode disconnect(), comme dans l'exemple suivant:

observer.disconnect();

Récupérer les enregistrements de pression

Les enregistrements de pression peuvent être récupérés à l'aide d'une fonction de rappel, qui sera appelée chaque fois qu'un changement se produira dans l'état de pression.

function callback(records) {
  const lastRecord = records[records.length - 1];
  console.log(`Current pressure ${lastRecord.state}`);
  if (lastRecord.state === 'critical') {
    // Reduce workers load by 4.
  } else if (lastRecord.state === 'serious') {
    // Reduce workers load by 2.
  } else {
    // Do not reduce.
  }
}

const observer = new PressureObserver(callback);
await observer.observe('cpu', { sampleInterval: 1_000 });

L'utilisateur peut également forcer la lecture de PressureRecord en appelant la méthode takeRecords().

La méthode takeRecords() de l'interface PressureObserver renvoie un tableau d'objets PressureRecords stockés dans l'observateur de pression, le vidant.

Le cas d'utilisation le plus courant consiste à récupérer immédiatement tous les enregistrements de pression en attente, qui n'ont pas encore été traités par la fonction de rappel de l'observateur, avant de déconnecter l'observateur, afin que tous les enregistrements en attente puissent être traités lors de l'arrêt de l'observateur.

L'appel de cette méthode efface la liste des enregistrements en attente, de sorte que le rappel ne s'exécute pas.

const observer = new PressureObserver((records) => {
  /* Do something with records. */
});

await observer.observe('cpu', { sampleInterval: 1_000 });

setTimeout(() => {
  // Forced records reading.
  const records = observer.takeRecords();
  observer.disconnect();
  // Do something with last records if any.
}, 2000);

Envoyer des commentaires

L'API ne fonctionne-t-elle pas comme prévu ? Voyez-vous une méthode ou une propriété manquante pour votre utilisation de l'API ? Signalez un problème de spécification ou commentez-en un existant dans le dépôt GitHub correspondant.

Signaler un problème d'implémentation

Avez-vous trouvé un bug dans l'implémentation de Chromium ? Ou l'implémentation est-elle différente de la spécification ? Envoyez un bug sur new.crbug.com. Veillez à inclure autant de détails que possible, des instructions pour reproduire le problème et saisissez Blink>PerformanceAPIs>ComputePressure dans le champ Components (Composants).

Ressources