Konvertieren Sie die Ausgabe von os.cpus() in Node.js die prozentuale

Gibt es eine Möglichkeit, konvertieren Sie die os.cpus() info prozentuale? Genau wie die Ausgabe von iostat (auf der CPU-Bereich).

Mein code:

var os = require('os');
console.log(os.cpus());

Die Ausgabe:

[ { model: 'MacBookAir4,2',
    speed: 1800,
    times: 
     { user: 5264280,
       nice: 0,
       sys: 4001110,
       idle: 58703910,
       irq: 0 } },
  { model: 'MacBookAir4,2',
    speed: 1800,
    times: 
     { user: 2215030,
       nice: 0,
       sys: 1072600,
       idle: 64657440,
       irq: 0 } },
  { model: 'MacBookAir4,2',
    speed: 1800,
    times: 
     { user: 5973360,
       nice: 0,
       sys: 3197990,
       idle: 58773760,
       irq: 0 } },
  { model: 'MacBookAir4,2',
    speed: 1800,
    times: 
     { user: 2187650,
       nice: 0,
       sys: 1042550,
       idle: 64714820,
       irq: 0 } } ]

Ich würde gerne die "times" Metrik umgewandelt Prozentsatz, genau wie show auf der iostat Befehl:

  cpu
us sy id
6  3 91

Ich verstehe, dass die Werte in der nodejs-Funktion in CPU-Zeiteinheiten, aber ich habe keine Ahnung welche Formel soll ich verwenden, um Sie zu konvertieren Prozentsatz 🙂

Dank.

InformationsquelleAutor rogeriopvl | 2012-03-05

30

Laut die docs, times ist

ein Objekt mit der Anzahl der CPU ticks ausgegeben: user -, nice -, sys -, idle-und irq -

So sollten Sie nur in der Lage sein, um die Summe der Zeiten, und berechnen Sie den Prozentsatz, wie unten:
```
var cpus = os.cpus();

for(var i = 0, len = cpus.length; i < len; i++) {
    console.log("CPU %s:", i);
    var cpu = cpus[i], total = 0;

    for(var type in cpu.times) {
        total += cpu.times[type];
    }

    for(type in cpu.times) {
        console.log("\t", type, Math.round(100 * cpu.times[type] / total));
    }
}
```
EDIT: Als Tom Frost, sagt in den Kommentaren, das ist die Durchschnittliche Auslastung seit dem Systemstart. Dies ist konsistent mit der Frage, da das gleiche gilt von iostat. Allerdings iostat hat die Möglichkeit, wenn Sie regelmäßig aktualisiert und zeigt den Durchschnittsverbrauch seit dem letzten update. Tom ' s Methode, die gut funktionieren würde für die Umsetzung.

Das ist es! Das war die Formel, die ich suchte. Vielen Dank 🙂
Kann nicht glauben ich verpasste das os.* API bei der Suche :-/ Es gehen Sie sollten alles, was Sie brauchen.
Es ist erwähnenswert, dass dies nur gibt Ihnen die Verwendung gemittelt über die Zeit, da die Maschine das Letzte mal gebootet wurde. Wenn Sie im Leerlauf für eine Woche und spike zu 100% CPU-Auslastung, kann dieses Skript noch zeigen die Maschine, wie fast im Leerlauf. Ein besserer Ansatz ist die Verwendung von setTimeout zum Messen der stats vor und nach einer oder zwei Sekunden warten, subtrahieren Sie die start Zecken aus dem Ende Zecken, und führen Sie die Berechnungen auf.

InformationsquelleAutor Linus Gustav Larsson Thiel
6

Diesem Modul, die installiert werden kann über NPM bietet, was Sie brauchen:

https://github.com/oscmejia/os-utils

calle die cpuUsage(callback) - Methode, und Sie bekommen, was Sie brauchen.

InformationsquelleAutor oscarm
4

Wenn Sie auf der Suche an der CPU-Auslastung pro Prozess versuchen Knoten-Nutzung

InformationsquelleAutor Arunoda Susiripala

Dies ist meine Lösung

Intervall wird in Sekunden angegeben.

10 berechnet Belastung über die letzten 10 Sekunden!

var _  = require("underscore");
var os = require("os"); 
var interval = 1;
var old = _.map(os.cpus(),function(cpu){ return cpu.times;})

setInterval(function() {
    var result = [];
    var current = _.map(os.cpus(),function(cpu){ return cpu.times; })
    _.each(current, function(item,cpuKey){
        result[cpuKey]={}

        var oldVal = old[cpuKey];
        _.each(_.keys(item),function(timeKey){
            var diff = (  parseFloat((item[timeKey]) - parseFloat(oldVal[timeKey])) / parseFloat((interval*100)));
            var name = timeKey;
            if(timeKey == "idle"){
                name = "CPU"        
                diff = 100 - diff;
            }
            //console.log(timeKey + ":\t" + oldVal[timeKey] + "\t\t" + item[timeKey] + "\t\t" + diff);  
            result[cpuKey][name]=diff.toFixed(0);
        });
    });
    console.log(result);
    old=current;
}, (interval * 1000));

Ausgänge so etwas wie dies auf meinem 8-Kern jedes n-Sekunden

[ { user: '82', nice: '0', sys: '18', CPU: '100', irq: '0' },
  { user: '1', nice: '0', sys: '1', CPU: '3', irq: '0' },
  { user: '1', nice: '0', sys: '1', CPU: '3', irq: '0' },
  { user: '9', nice: '0', sys: '2', CPU: '11', irq: '0' },
  { user: '1', nice: '0', sys: '0', CPU: '1', irq: '0' },
  { user: '1', nice: '0', sys: '1', CPU: '2', irq: '0' },
  { user: '1', nice: '0', sys: '2', CPU: '2', irq: '0' },
  { user: '1', nice: '0', sys: '2', CPU: '3', irq: '0' } ]

Schob diesen über die Buchse.io in mein Flow-Charts 😉

Hinweis: ich geändert "Leerlauf" , "CPU" und subtrahiert es von 100. So haben Sie 80% cpu-Auslastung. Das ich aber lieber 20% im Leerlauf

InformationsquelleAutor user3575777

einen einfachen hack:

var os = require('os')
var samples = []
var prevCpus = os.cpus()

setInterval(sample,100)
setInterval(print,1000)

function print() {
  var result = {last10:null, last50:null, last100:null}
  var percent = 0
  var i = samples.length
  var j = 0
  while (i--) {
    j++
    if (samples[i].total > 0)
      percent += (100 - Math.round(100 * samples[i].idle / samples[i].total))
    if (j == 10)       result.last10  = percent/j   
    else if (j == 50)  result.last50  = percent/j    
    else if (j == 100) result.last100 = percent/j
  }
  console.log(result)
}

function sample() {
  currCpus = os.cpus()
  for (var i=0,len=currCpus.length;i<len;i++) {
    var prevCpu = prevCpus[i]
    var currCpu = currCpus[i]
    var deltas = {total:0}
    for (var t in prevCpu.times) 
      deltas.total += currCpu.times[t] - prevCpu.times[t]
    for (var t in prevCpu.times) 
      deltas[t] = currCpu.times[t] - prevCpu.times[t]
  }
  prevCpus = currCpus
  samples.push(deltas)
  if (samples.length>100) samples.shift()
}

könnte man eine Metriken-lib wie https://github.com/felixge/node-measured lot etwas mehr fruchtbar

InformationsquelleAutor guybrush

ich bin mit diesem code:

var cpu_used = function(){
var cpu = os.cpus();

var counter = 0;
var total=0;

var free=0;
var sys=0;
var user=0;

for (var i = 0; i<cpu.length ; i++) {

    counter++;
    total=parseFloat(cpu[i].times.idle)+parseFloat(cpu[i].times.sys)+parseFloat(cpu[i].times.user)+parseFloat(cpu[i].times.irq)+parseFloat(cpu[i].times.nice);

    free+=100*(parseFloat(cpu[i].times.idle)/total);
    sys+=100*(parseFloat(cpu[i].times.sys)/total);
    user+=100*(parseFloat(cpu[i].times.user)/total);
};

console.log('CPU %s : %s + %s + %s',i,(free/counter),(user/counter),(sys/counter));

}

InformationsquelleAutor lancha90

Wenn Sie möchten, zu beobachten, Echtzeit CPU-und Speichernutzung, können Sie versuchen,os-Nutzung.

Die grundlegende Verwendung ist wie folgt:

var usage = require('os-usage');

//create an instance of CpuMonitor
var cpuMonitor = new usage.CpuMonitor();

//watch cpu usage overview
cpuMonitor.on('cpuUsage', function(data) {
    console.log(data);

    //{ user: '9.33', sys: '56.0', idle: '34.66' }
});

Können Sie auch Prozesse, die verwenden die meisten cpu-Ressourcen:

cpuMonitor.on('topCpuProcs', function(data) {
    console.log(data);

    //[ { pid: '21749', cpu: '0.0', command: 'top' },
    // { pid: '21748', cpu: '0.0', command: 'node' },
    // { pid: '21747', cpu: '0.0', command: 'node' },
    // { pid: '21710', cpu: '0.0', command: 'com.apple.iCloud' },
    // { pid: '21670', cpu: '0.0', command: 'LookupViewServic' } ]
});

InformationsquelleAutor tning

Hier wie ich es gemacht habe:

var OS = require('os');
var oldCPUTime = 0
var oldCPUIdle = 0
function getLoad(){
    var cpus = OS.cpus()
    var totalTime = -oldCPUTime
    var totalIdle = -oldCPUIdle
    for(var i = 0; i < cpus.length; i++) {
        var cpu = cpus[i]
        for(var type in cpu.times) {
            totalTime += cpu.times[type];
            if(type == "idle"){
                totalIdle += cpu.times[type];
            }
        }
    }

    var CPUload = 100 - Math.round(totalIdle/totalTime*100))
    oldCPUTime = totalTime
    oldCPUIdle = totalIdle

    return {
        CPU:CPUload,
        mem:100 - Math.round(OS.freemem()/OS.totalmem()*100)
    }       
}

InformationsquelleAutor math_lab3.ca

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.