Obtenez le nombre de cœurs CPU en JavaScript?

Question

Y a-t-il un moyen de déterminer le nombre de cœurs de la CPU disponibles dans JavaScript afin de pouvoir ajuster le nombre de travailleurs Web en fonction de cela?

Answer 1

Oui. Pour citer MDN:

the GeneraCoDeTagCode La propriété en lecture seule renvoie le Nombre de processeurs logiques disponibles pour exécuter des threads sur l'ordinateur de l'utilisateur ...

Les ordinateurs modernes ont plusieurs cœurs de processeur physique dans leur CPU (deux ou quatre cœurs sont typiques), mais chaque noyau physique est également capable de fonctionner plus d'un fil à la fois en utilisant des techniques de planification avancées. Donc, une processeur de quatre nœuds peut offrir huit cœurs logiques logiques , par exemple. Le nombre de cœurs de processeur logiques peut être utilisé pour mesurer le nombre de filets pouvant être exécutés de manière factuelle à la fois sans qu'ils ont à un interrupteur de contexte.

Le navigateur peut toutefois choisir de signaler un nombre inférieur de cœurs logiques afin de représenter plus précisément le nombre de travailleurs pouvant courir à la fois, alors ne traitez pas cela comme une mesure absolue du nombre de noyaux dans le système de l'utilisateur.

Il est pris en charge par chaque navigateur sauf Internet Explorer. Pour cela, vous pouvez utiliser le polyfill navigator.hardwareConcurrency ( démo , Blog POST ).

Answer 2

Non, il n'y a pas, à moins que vous n'utilisiez certains ActiveX.

Answer 3

Vous pouvez essayer d'estimer le nombre de cœurs avec: https://github.com/oftn/core-estimator

Démo: http://eligrey.com/blog/post/cpu-core-estimation-with-javascript

Answer 4

Voici un estimateur de concurrence assez rapide que j'ai piraté ensemble ... il n'a pas encore subi beaucoup de tests:

http://jsfiddle.net/ma4yt/2/

Voici le code des travailleurs exécutés (puisque j'ai un lien Jsfiddle, un échantillon est nécessaire):

// create worker concurrency estimation code as blob
var blobUrl = URL.createObjectURL(new Blob(['(',
  function() {
    self.addEventListener('message', function(e) {
      // run worker for 4 ms
      var st = Date.now();
      var et = st + 4;
      while(Date.now() < et);
      self.postMessage({st: st, et: et});
    });
  }.toString(),
')()'], {type: 'application/javascript'}));

L'estimateur a un grand nombre de travailleurs couramment couru pendant une courte période de temps (4 ms) et rapportent les temps qu'ils ont couru (malheureusement, la performance.Now () n'est pas disponible dans les travailleurs Web pour un moment plus précis). Le fil principal vérifie alors le nombre maximum de travailleurs qui fonctionnaient pendant le même temps. Ce test est répété un certain nombre de fois pour obtenir un échantillon décent pour produire une estimation avec.

L'idée principale est donc que, étant donné une petite partie de travail suffisante, les travailleurs ne doivent être programmés que pour courir en même temps s'il y a suffisamment de noyaux pour soutenir ce comportement. C'est évidemment juste une estimation, mais jusqu'à présent, cela a été raisonnablement précis pour quelques machines que j'ai testées - ce qui est suffisamment bon pour mon étui d'utilisation. Le nombre d'échantillons peut être augmenté pour obtenir une approximation plus précise; Je viens d'utiliser 10 parce que c'est rapide et je ne veux pas perdre de temps à estimer le temps par rapport à la réussite du travail.

Answer 5

Si vous allez faire des données crunching sur vos travailleurs, navigator.hardwareConcurrency pourrait ne pas être suffisamment bonne car elle renvoie le nombre de noyaux logiques dans les navigateurs modernes, vous pouvez essayer d'estimer le nombre de noyaux physiques utilisant webcpu :

import {WebCPU} from 'webcpu';

WebCPU.detectCPU().then(result => {
    console.log(`Reported Cores: ${result.reportedCores}`);
    console.log(`Estimated Idle Cores: ${result.estimatedIdleCores}`);
    console.log(`Estimated Physical Cores: ${result.estimatedPhysicalCores}`);
});