Преобразовать вывод os.cpus () в Node.js в процент

Question

Есть ли способ преобразовать информацию os.cpus () в процент? Точно так же как вывод iostat (на секции CPU).

Мой код:

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

Выход:

[ { 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 } } ]

Я бы хотел, чтобы метрика "times" была преобразована в процент, как это показано в команде iostat:

  cpu
us sy id
6  3 91

Я понимаю, что значения в функции nodejs указаны в тиках процессора, но я понятия не имею, какую формулу я должен использовать, чтобы преобразовать их в проценты:)

Спасибо.

Answer 1

Согласно документам , times является

объект, содержащий количество тиков ЦП, потраченных на: user, nice, sys, idle и irq

Так что вы должны просто суммировать время и рассчитать процент, как показано ниже:

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));
    }
}

РЕДАКТИРОВАТЬ: Как говорит Том Фрост в комментариях, это среднее использование с момента загрузки системы. Это согласуется с вопросом, поскольку то же самое относится и к iostat. Однако iostat имеет возможность делать регулярные обновления, показывая среднее использование с момента последнего обновления. Метод Тома хорошо бы сработал.

Answer 2

Этот модуль, который может быть установлен с помощью NPM, обеспечивает то, что вам нужно:

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

вызовите метод cpuUsage (callback), и вы получите то, что вам нужно.

Answer 3

Если вы смотрите на использование ЦП на процесс, попробуйте использование узла

Answer 4

Это мое решение

Интервал в секундах.

10 рассчитает нагрузку за последние 10 секунд!

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));

Выводит что-то подобное на моем 8-ядерном устройстве каждые n-секунд

[ { 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' } ]

Вставка этого через socket.io в мои блок-схемы;)

Answer 5

простой взломать:

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()
}

вы можете использовать метрику-библиотеку, например https://github.com/felixge/node-measured, чтобы получить что-то более продуктивное

Answer 6

Вот как я это сделал:

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)
    }       
}

Answer 7

Если вы хотите наблюдать за использованием процессора и памяти в режиме реального времени, вы можете попробовать os-using .

Основное использование выглядит следующим образом:

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' }
});

Вы также можете получить процессы, которые используют большинство ресурсов процессора:

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' } ]
});

Answer 8

Я использую этот код:

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));

}