Chuyển đổi đầu ra của os.cpus() trong Node.js thành phần trăm

Question

Có cách nào để chuyển đổi thông tin os.cpus() thành phần trăm không? Cũng giống như đầu ra của iostat (trên phần CPU).

Mã của tôi:

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

Sản lượng:

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

Tôi muốn có "lần" số liệu chuyển đổi ra tỷ lệ phần trăm, giống như là hiển thị trên các iostat lệnh:

cpu 
us sy id 
6 3 91 

Tôi hiểu rằng các giá trị trong chức năng nodejs nằm trong các dấu CPU, nhưng tôi không có ide tôi nên sử dụng công thức nào để chuyển đổi chúng thành tỷ lệ phần trăm :)

Cảm ơn.

Answer 1

Theo the docs, times là

một đối tượng có chứa số lượng CPU ve chi tiêu trong: người sử dụng, đẹp, sys, nhàn rỗi, và irq

Vì vậy, bạn chỉ có thể tổng số lần và tính phần trăm, như sau:

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: Như Tom Frost nói trong các bình luận, đây là mức sử dụng trung bình kể từ khi khởi động hệ thống. Điều này phù hợp với câu hỏi, vì điều này cũng đúng với số iostat. Tuy nhiên, iostat có tùy chọn thực hiện cập nhật thường xuyên, hiển thị mức sử dụng trung bình kể từ lần cập nhật cuối cùng. Phương pháp của Tom sẽ hoạt động tốt để thực hiện điều đó.

Answer 2

Module này, có thể được cài đặt bằng NPM cung cấp những gì bạn cần:

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

Calle phương pháp cpuUsage (callback) và bạn sẽ có được những gì bạn cần.

Answer 3

Nếu bạn đang xem xét sử dụng CPU cho mỗi quá trình thử node-usage

Answer 4

một hack đơn giản:

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

bạn có thể sử dụng một số liệu-lib như https://github.com/felixge/node-measured plumb một cái gì đó nhiều hơn

Answer 5

i đang sử dụng mã này:

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

} 

Answer 6

Đây là Giải pháp của tôi

Khoảng thời gian bằng Giây.

10 sẽ tính tải trong 10 giây qua!

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

Đầu ra một cái gì đó như thế này trên 8-core của tôi mỗi n-giây

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

Đẩy này qua socket.io vào tôi Flow-Charts;)

Answer 7

Nếu bạn muốn xem thời gian thực CPU và sử dụng bộ nhớ, bạn có thể thử os-usage.

Việc sử dụng cơ bản là như sau:

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

Bạn cũng có thể nhận được các quá trình sử dụng hầu hết các nguồn tài nguyên cpu:

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

đây làm thế nào tôi đã làm nó:

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