From 5027c9a88cf8c6249364d9fd3b2323653e217fe2 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Fri, 9 Jun 2023 14:09:33 +0200 Subject: [PATCH 01/37] chore: sort workspace members Sort the package names in the workspace member declaration. --- Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1c6a8e3c82..a92ccd2467 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,9 +29,9 @@ members = [ "influxdb_tsm", "influxdb2_client", "influxrpc_parser", + "ingester_query_grpc", "ingester_test_ctx", "ingester", - "ingester_query_grpc", "iox_catalog", "iox_data_generator", "iox_query_influxql", @@ -82,8 +82,8 @@ members = [ "trace", "tracker", "trogging", - "wal", "wal_inspect", + "wal", "workspace-hack", ] default-members = ["influxdb_iox"] From 69ab70ce9929e62d0520ef0f63b04bd08e3ec2fd Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Fri, 9 Jun 2023 14:10:47 +0200 Subject: [PATCH 02/37] feat: init gossip package Adds a new empty "gossip" package to the workspace. --- Cargo.lock | 4 ++++ Cargo.toml | 1 + gossip/Cargo.toml | 8 ++++++++ gossip/src/lib.rs | 1 + 4 files changed, 14 insertions(+) create mode 100644 gossip/Cargo.toml create mode 100644 gossip/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 8fa9abeece..b25f4c180b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2000,6 +2000,10 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" +[[package]] +name = "gossip" +version = "0.1.0" + [[package]] name = "grpc-binary-logger" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index a92ccd2467..f0788c9590 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,7 @@ members = [ "flightsql", "garbage_collector", "generated_types", + "gossip", "grpc-binary-logger-proto", "grpc-binary-logger-test-proto", "grpc-binary-logger", diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml new file mode 100644 index 0000000000..ce8e0c474b --- /dev/null +++ b/gossip/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "gossip" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/gossip/src/lib.rs @@ -0,0 +1 @@ + From 5c191ce6cfb75f500a4f6890901508ab1100119a Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Fri, 9 Jun 2023 14:42:46 +0200 Subject: [PATCH 03/37] ci: enable standard lint set Adds the somewhat "standard" lint set we use to the gossip lib. --- gossip/src/lib.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index 8b13789179..40b434d835 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -1 +1,16 @@ +//! A work-in-progress, simple gossip primitive for metadata distribution +//! between IOx nodes. +#![deny(rustdoc::broken_intra_doc_links, rust_2018_idioms)] +#![warn( + clippy::clone_on_ref_ptr, + clippy::dbg_macro, + clippy::explicit_iter_loop, + clippy::future_not_send, + clippy::todo, + clippy::use_self, + missing_copy_implementations, + missing_debug_implementations, + unused_crate_dependencies, + missing_docs +)] From 48aa4a5e33dbb08ac3d8bd33d04707cc1e7e1123 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Fri, 9 Jun 2023 14:44:48 +0200 Subject: [PATCH 04/37] feat(gossip): frame proto definitions Adds a proto definition and configures prost to build the rust types from it. The gossip framing is intended to be flexible and decoupled - the gossip library will batch together one or more opaque application messages and/or control frames, and uniquely identify each peer with a per-instance UUID to detect crashes/restarts and track peers. --- Cargo.lock | 4 ++++ gossip/Cargo.toml | 7 +++++-- gossip/build.rs | 13 +++++++++++++ gossip/proto/gossip.proto | 28 ++++++++++++++++++++++++++++ gossip/src/lib.rs | 2 ++ gossip/src/proto.rs | 3 +++ 6 files changed, 55 insertions(+), 2 deletions(-) create mode 100644 gossip/build.rs create mode 100644 gossip/proto/gossip.proto create mode 100644 gossip/src/proto.rs diff --git a/Cargo.lock b/Cargo.lock index b25f4c180b..918218a2f9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2003,6 +2003,10 @@ checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" [[package]] name = "gossip" version = "0.1.0" +dependencies = [ + "prost", + "prost-build", +] [[package]] name = "grpc-binary-logger" diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index ce8e0c474b..7bc69a875d 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -3,6 +3,9 @@ name = "gossip" version = "0.1.0" edition = "2021" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [dependencies] +prost = "0.11.9" + +[build-dependencies] +prost-build = "0.11.9" + diff --git a/gossip/build.rs b/gossip/build.rs new file mode 100644 index 0000000000..abbbe87cfb --- /dev/null +++ b/gossip/build.rs @@ -0,0 +1,13 @@ +use std::{error::Error, path::PathBuf}; + +use prost_build::Config; + +fn main() -> Result<(), Box> { + let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("proto"); + + Config::new() + .bytes(["."]) + .compile_protos(&[root.join("gossip.proto")], &[root])?; + + Ok(()) +} diff --git a/gossip/proto/gossip.proto b/gossip/proto/gossip.proto new file mode 100644 index 0000000000..fb259ff41a --- /dev/null +++ b/gossip/proto/gossip.proto @@ -0,0 +1,28 @@ +syntax = "proto3"; +package influxdata.iox.gossip.v1; +option go_package = "github.com/influxdata/iox/gossip/v1"; + +// The payload of a single gossip datagram. +message Frame { + // Per-instance UUID as raw BE bytes. + bytes identity = 1; + + // One or more user/control frames packed into a single message. + repeated FrameMessage messages = 2; +} + +// A single gossip message within a frame. +message FrameMessage { + // Various user/control message types. + oneof msg { + // User-provided data payload. + UserPayload user_data = 1; + } +} + +// An application payload from the caller of the gossip library. +message UserPayload { + // An opaque user payload - this is handed back to the gossip library user + // unmodified. + bytes payload = 1; +} diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index 40b434d835..24fe346224 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -14,3 +14,5 @@ unused_crate_dependencies, missing_docs )] + +mod proto; diff --git a/gossip/src/proto.rs b/gossip/src/proto.rs new file mode 100644 index 0000000000..cb888494fc --- /dev/null +++ b/gossip/src/proto.rs @@ -0,0 +1,3 @@ +//! Proto definitions of gossip message wire types. + +include!(concat!(env!("OUT_DIR"), "/influxdata.iox.gossip.v1.rs")); From bc9ebc9c668591e35602e36753cb19224472b9fb Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Fri, 9 Jun 2023 20:16:31 +0200 Subject: [PATCH 05/37] feat: gossip primitive Adds a simple "gossip" implementation (more accurately described as a pub/sub primitive currently) that supports broadcasting application-level messages to the set of active peers. This implementation uses UDP as a transport for best-effort delivery, and enables zero-copy use of the payload using the Bytes crate. Only peers explicitly provided as "seeds" when initialising will be known to a gossip node - there's currently no peer exchange mechanism. This implementation tolerates seeds changing their DNS entries when restarting to point at new socket addresses (such as within Kubernetes when pods move around). --- Cargo.lock | 7 + gossip/Cargo.toml | 8 + gossip/build.rs | 5 + gossip/proto/gossip.proto | 10 +- gossip/src/builder.rs | 60 +++++++ gossip/src/dispatcher.rs | 34 ++++ gossip/src/handle.rs | 61 +++++++ gossip/src/lib.rs | 43 +++++ gossip/src/peers.rs | 201 +++++++++++++++++++++++ gossip/src/reactor.rs | 328 ++++++++++++++++++++++++++++++++++++++ gossip/src/seed.rs | 91 +++++++++++ gossip/tests/smoke.rs | 70 ++++++++ 12 files changed, 916 insertions(+), 2 deletions(-) create mode 100644 gossip/src/builder.rs create mode 100644 gossip/src/dispatcher.rs create mode 100644 gossip/src/handle.rs create mode 100644 gossip/src/peers.rs create mode 100644 gossip/src/reactor.rs create mode 100644 gossip/src/seed.rs create mode 100644 gossip/tests/smoke.rs diff --git a/Cargo.lock b/Cargo.lock index 918218a2f9..7197270c6d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2004,8 +2004,15 @@ checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" name = "gossip" version = "0.1.0" dependencies = [ + "async-trait", + "futures", + "hashbrown 0.14.0", "prost", "prost-build", + "test_helpers", + "tokio", + "tracing", + "uuid", ] [[package]] diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index 7bc69a875d..14b70b9f5a 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -4,8 +4,16 @@ version = "0.1.0" edition = "2021" [dependencies] +async-trait = "0.1.68" +futures = "0.3.28" +hashbrown.workspace = true prost = "0.11.9" +tokio = { version = "1.28.2", features = ["net", "io-util", "time", "rt", "sync", "macros"] } +tracing = "0.1.37" +uuid = { version = "1.3.3", features = ["v4"] } [build-dependencies] prost-build = "0.11.9" +[dev-dependencies] +test_helpers = { path = "../test_helpers", features = ["future_timeout"] } diff --git a/gossip/build.rs b/gossip/build.rs index abbbe87cfb..8207b46030 100644 --- a/gossip/build.rs +++ b/gossip/build.rs @@ -5,6 +5,11 @@ use prost_build::Config; fn main() -> Result<(), Box> { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("proto"); + println!( + "cargo:rerun-if-changed={}", + root.join("gossip.proto").display() + ); + Config::new() .bytes(["."]) .compile_protos(&[root.join("gossip.proto")], &[root])?; diff --git a/gossip/proto/gossip.proto b/gossip/proto/gossip.proto index fb259ff41a..5af2c4814e 100644 --- a/gossip/proto/gossip.proto +++ b/gossip/proto/gossip.proto @@ -14,12 +14,18 @@ message Frame { // A single gossip message within a frame. message FrameMessage { // Various user/control message types. - oneof msg { + oneof payload { + Ping ping = 1; + Pong pong = 2; + // User-provided data payload. - UserPayload user_data = 1; + UserPayload user_data = 3; } } +message Ping {} +message Pong {} + // An application payload from the caller of the gossip library. message UserPayload { // An opaque user payload - this is handed back to the gossip library user diff --git a/gossip/src/builder.rs b/gossip/src/builder.rs new file mode 100644 index 0000000000..503c8e42ad --- /dev/null +++ b/gossip/src/builder.rs @@ -0,0 +1,60 @@ +use tokio::{ + net::{ToSocketAddrs, UdpSocket}, + sync::mpsc, +}; + +use crate::{handle::GossipHandle, reactor::Reactor, Dispatcher}; + +/// Gossip subsystem configuration and initialisation. +#[derive(Debug)] +pub struct Builder { + seed_addrs: Vec, + dispatcher: T, +} + +impl Builder { + /// Use `seed_addrs` as seed peer addresses, and dispatch any application + /// messages to `dispatcher`. + /// + /// Each address in `seed_addrs` is re-resolved periodically and the first + /// resolved IP address is used for peer communication. + pub fn new(seed_addrs: Vec, dispatcher: T) -> Self { + Self { + seed_addrs, + dispatcher, + } + } +} + +impl Builder +where + T: Dispatcher + 'static, +{ + /// Initialise the gossip subsystem using `socket` for communication. + /// + /// # Panics + /// + /// This call spawns a tokio task, and as such must be called from within a + /// tokio runtime. + pub fn build(self, socket: UdpSocket) -> GossipHandle { + // Obtain a channel to communicate between the actor, and all handles + let (tx, rx) = mpsc::channel(1000); + + // Initialise the reactor + let reactor = Reactor::new(self.seed_addrs, socket, self.dispatcher); + let identity = reactor.identity().clone(); + + // Start the message reactor. + tokio::spawn(reactor.run(rx)); + + GossipHandle::new(tx, identity) + } + + /// Bind to the provided socket address and initialise the gossip subsystem. + pub async fn bind(self, bind_addr: A) -> Result + where + A: ToSocketAddrs + Send, + { + Ok(self.build(UdpSocket::bind(bind_addr).await?)) + } +} diff --git a/gossip/src/dispatcher.rs b/gossip/src/dispatcher.rs new file mode 100644 index 0000000000..b6aa951679 --- /dev/null +++ b/gossip/src/dispatcher.rs @@ -0,0 +1,34 @@ +use async_trait::async_trait; +use tracing::warn; + +// Re-export the bytes type to ensure upstream users of this crate are +// interacting with the same type. +pub use prost::bytes::Bytes; + +/// A delegate abstraction through which the gossip subsystem propagates +/// application-level messages received from other peers. +#[async_trait] +pub trait Dispatcher: Send + Sync { + /// Invoked when an application-level payload is received from a peer. + /// + /// This call should not block / should complete quickly to avoid blocking + /// the gossip reactor loop - if a long-running job must be started within + /// this call, consider spawning a separate task. + async fn dispatch(&self, payload: Bytes); +} + +#[async_trait] +impl Dispatcher for tokio::sync::mpsc::Sender { + async fn dispatch(&self, payload: Bytes) { + if let Err(e) = self.send(payload).await { + warn!(error=%e, "error dispatching payload to application handler"); + } + } +} + +// A no-op dispatcher. +#[cfg(test)] +#[async_trait::async_trait] +impl Dispatcher for () { + async fn dispatch(&self, _payload: crate::Bytes) {} +} diff --git a/gossip/src/handle.rs b/gossip/src/handle.rs new file mode 100644 index 0000000000..075966a35c --- /dev/null +++ b/gossip/src/handle.rs @@ -0,0 +1,61 @@ +use crate::Bytes; +use tokio::sync::{mpsc, oneshot}; +use uuid::Uuid; + +use crate::peers::Identity; + +/// Requests sent to the [`Reactor`] actor task. +/// +/// [`Reactor`]: crate::reactor::Reactor +#[derive(Debug)] +pub(crate) enum Request { + /// Broadcast the given payload to all known peers. + Broadcast(Bytes), + + /// Get a snapshot of the peer identities. + GetPeers(oneshot::Sender>), +} + +/// A handle to the gossip subsystem. +/// +/// All resources used by the gossip system will be released once this +/// [`GossipHandle`] is dropped. To share the handle, wrap it in an [`Arc`]. +/// +/// [`Arc`]: std::sync::Arc +#[derive(Debug)] +pub struct GossipHandle { + tx: mpsc::Sender, + identity: Identity, +} + +impl GossipHandle { + pub(crate) fn new(tx: mpsc::Sender, identity: Identity) -> Self { + Self { tx, identity } + } + + /// Return the randomly generated identity of this gossip instance. + pub fn identity(&self) -> Uuid { + *self.identity + } + + /// Broadcast `payload` to all known peers. + /// + /// This is a best-effort operation - peers are not guaranteed to receive + /// this broadcast. + pub async fn broadcast(&self, payload: T) + where + T: Into + Send, + { + self.tx + .send(Request::Broadcast(payload.into())) + .await + .unwrap() + } + + /// Retrieve a snapshot of the connected peer list. + pub async fn get_peers(&self) -> Vec { + let (tx, rx) = oneshot::channel(); + self.tx.send(Request::GetPeers(tx)).await.unwrap(); + rx.await.unwrap() + } +} diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index 24fe346224..30a4994c22 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -1,5 +1,25 @@ //! A work-in-progress, simple gossip primitive for metadata distribution //! between IOx nodes. +//! +//! # Transport +//! +//! Prefer small payloads where possible, and expect loss of some messages - +//! this primitive provides *best effort* delivery. +//! +//! This implementation sends unicast UDP frames between peers, with support for +//! both control frames & user payloads. The maximum message size is 65,507 +//! bytes, but a packet this large is fragmented into smaller (at most +//! MTU-sized) packets and is at greater risk of being dropped due to a lost +//! fragment. +//! +//! # Security +//! +//! Messages exchanged between peers are unauthenticated and connectionless - +//! it's trivial to forge a message appearing to come from a different peer, or +//! include malicious payloads. +//! +//! The security model of this implementation expects the peers to be running in +//! a trusted environment, secure from malicious users. #![deny(rustdoc::broken_intra_doc_links, rust_2018_idioms)] #![warn( @@ -15,4 +35,27 @@ missing_docs )] +mod builder; +mod dispatcher; +mod handle; +mod peers; mod proto; +mod reactor; +pub(crate) mod seed; + +use std::time::Duration; + +/// Work around the unused_crate_dependencies false positives for test deps. +#[cfg(test)] +use test_helpers as _; + +pub use builder::*; +pub use dispatcher::*; +pub use handle::*; + +/// The maximum duration of time allotted to performing a DNS resolution against +/// a seed/peer address. +const RESOLVE_TIMEOUT: Duration = Duration::from_secs(5); + +/// Defines the interval between PING frames sent to all configured seed peers. +const SEED_PING_INTERVAL: std::time::Duration = Duration::from_secs(15); diff --git a/gossip/src/peers.rs b/gossip/src/peers.rs new file mode 100644 index 0000000000..a40d3bb3eb --- /dev/null +++ b/gossip/src/peers.rs @@ -0,0 +1,201 @@ +use std::net::SocketAddr; + +use futures::{stream::FuturesUnordered, StreamExt}; +use hashbrown::{hash_map::RawEntryMut, HashMap}; +use prost::bytes::Bytes; +use tokio::net::UdpSocket; +use tracing::{trace, warn}; +use uuid::Uuid; + +/// A unique generated identity containing 128 bits of randomness (V4 UUID). +#[derive(Debug, Eq, Clone)] +pub(crate) struct Identity(Bytes, Uuid); + +impl std::ops::Deref for Identity { + type Target = Uuid; + + fn deref(&self) -> &Self::Target { + &self.1 + } +} + +impl std::hash::Hash for Identity { + fn hash(&self, state: &mut H) { + self.0.hash(state); + } +} + +impl PartialEq for Identity { + fn eq(&self, other: &Self) -> bool { + debug_assert!((self.1 == other.1) == (self.0 == other.0)); + self.0 == other.0 + } +} + +impl std::fmt::Display for Identity { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.1.fmt(f) + } +} + +impl TryFrom for Identity { + type Error = uuid::Error; + + fn try_from(value: Bytes) -> Result { + let uuid = Uuid::from_slice(&value)?; + Ok(Self(value, uuid)) + } +} + +impl Identity { + /// Generate a new random identity. + pub(crate) fn new() -> Self { + let id = Uuid::new_v4(); + Self(Bytes::from(id.as_bytes().to_vec()), id) + } + + pub(crate) fn as_bytes(&self) -> &Bytes { + &self.0 + } +} + +/// A discovered peer within the gossip cluster. +#[derive(Debug, Clone)] +pub(crate) struct Peer { + identity: Identity, + addr: SocketAddr, +} + +impl Peer { + pub(crate) async fn send( + &self, + buf: &[u8], + socket: &UdpSocket, + ) -> Result { + let ret = socket.send_to(buf, self.addr).await; + match &ret { + Ok(n_bytes) => { + trace!(identity=%self.identity, n_bytes, peer_addr=%self.addr, "send frame") + } + Err(e) => { + warn!(error=%e, identity=%self.identity, peer_addr=%self.addr, "frame send error") + } + } + ret + } +} + +/// The set of currently active/known peers. +#[derive(Debug, Default)] +pub(crate) struct PeerList { + list: HashMap, +} + +impl PeerList { + /// Initialise the [`PeerList`] with capacity for `cap` number of [`Peer`] + /// instances. + pub(crate) fn with_capacity(cap: usize) -> Self { + Self { + list: HashMap::with_capacity(cap), + } + } + + /// Return the UUIDs of all known peers. + pub(crate) fn peer_uuids(&self) -> Vec { + self.list.keys().map(|v| **v).collect() + } + + /// Upsert a peer identified by `identity` to the peer list, associating it + /// with the provided `peer_addr`. + pub(crate) fn upsert(&mut self, identity: &Identity, peer_addr: SocketAddr) -> &mut Peer { + let p = match self.list.raw_entry_mut().from_key(identity) { + RawEntryMut::Vacant(v) => { + v.insert( + identity.to_owned(), + Peer { + addr: peer_addr, + identity: identity.to_owned(), + }, + ) + .1 + } + RawEntryMut::Occupied(v) => v.into_mut(), + }; + + p.addr = peer_addr; + p + } + + /// Broadcast `buf` to all known peers over `socket`, returning the number + /// of bytes sent in total. + pub(crate) async fn broadcast(&self, buf: &[u8], socket: &UdpSocket) -> usize { + self.list + .values() + .map(|v| v.send(buf, socket)) + .collect::>() + .fold(0, |acc, res| async move { + match res { + Ok(n) => acc + n, + Err(_) => acc, + } + }) + .await + } +} + +#[cfg(test)] +mod tests { + use std::{ + collections::hash_map::DefaultHasher, + hash::{Hash, Hasher}, + }; + + use super::*; + + #[test] + fn test_identity_round_trip() { + let a = Identity::new(); + + let encoded = a.as_bytes().to_owned(); + let decoded = Identity::try_from(encoded).unwrap(); + + assert_eq!(decoded, a); + } + + #[test] + fn test_identity_length_mismatch() { + let v = Bytes::from_static(&[42, 42, 42, 42]); + let _ = Identity::try_from(v).expect_err("short ID should fail"); + + let v = Bytes::from_static(&[ + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, + ]); + let _ = Identity::try_from(v).expect_err("short ID should fail"); + } + + #[test] + fn test_identity_eq() { + let v = Identity::new(); + assert_eq!(v.clone(), v); + assert_eq!(hash_identity(&v), hash_identity(&v)); + + let other = Identity::new(); + assert_ne!(v, other); + assert_ne!(hash_identity(&other), hash_identity(&v)); + } + + #[test] + fn test_identity_display() { + let v = Identity::new(); + let text = v.to_string(); + + let uuid = Uuid::try_parse(&text).expect("display impl should output valid uuids"); + assert_eq!(*v, uuid); + } + + fn hash_identity(v: &Identity) -> u64 { + let mut h = DefaultHasher::default(); + v.hash(&mut h); + h.finish() + } +} diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs new file mode 100644 index 0000000000..f70239745e --- /dev/null +++ b/gossip/src/reactor.rs @@ -0,0 +1,328 @@ +use std::{net::SocketAddr, sync::Arc}; + +use prost::{bytes::BytesMut, Message}; +use tokio::{ + net::UdpSocket, + sync::mpsc::{self}, +}; +use tracing::{debug, error, info, trace, warn}; + +use crate::{ + peers::{Identity, PeerList}, + proto::{self, frame_message::Payload, FrameMessage}, + seed::{seed_ping_task, Seed}, + Dispatcher, Request, +}; + +#[derive(Debug)] +enum Error { + NoPayload { + peer: Identity, + addr: SocketAddr, + }, + + Deserialise { + addr: SocketAddr, + source: prost::DecodeError, + }, + + Identity { + addr: SocketAddr, + }, + + Io(std::io::Error), +} + +impl From for Error { + fn from(value: std::io::Error) -> Self { + Self::Io(value) + } +} + +#[derive(Debug)] +struct AbortOnDrop(tokio::task::JoinHandle<()>); +impl Drop for AbortOnDrop { + fn drop(&mut self) { + self.0.abort() + } +} + +/// An event loop for gossip frames processing. +/// +/// This actor task is responsible for driving peer discovery, managing the set +/// of known peers and exchanging gossip frames between peers. +/// +/// A user interacts with a [`Reactor`] through a [`GossipHandle`]. +/// +/// [`GossipHandle`]: crate::GossipHandle +#[derive(Debug)] +pub(crate) struct Reactor { + dispatch: T, + + /// The random identity of this gossip instance. + identity: Identity, + + /// A cached wire frame, used to generate outgoing messages. + cached_frame: proto::Frame, + /// A re-used buffer for serialising outgoing messages into. + serialisation_buf: Vec, + + /// The immutable list of seed addresses provided by the user, periodically + /// pinged. + seed_list: Arc<[Seed]>, + /// A task that periodically sends PING frames to all seeds, executing in a + /// separate task so that DNS resolution does not block the reactor loop. + _seed_ping_task: AbortOnDrop, + + /// The set of active peers this node has communicated with and believes to + /// be (recently) healthy. + /// + /// Depending on the perceived availability of the seed nodes, this may + /// contain less peers than the number of initial seeds. + peer_list: PeerList, + + socket: Arc, +} + +impl Reactor +where + T: Dispatcher, +{ + pub(crate) fn new(seed_list: Vec, socket: UdpSocket, dispatch: T) -> Self { + // Generate a unique UUID for this Reactor instance, and cache the wire + // representation. + let identity = Identity::new(); + + let seed_list = seed_list.into_iter().map(Seed::new).collect(); + let socket = Arc::new(socket); + + // Generate a pre-populated frame header. + let mut cached_frame = proto::Frame { + identity: identity.as_bytes().clone(), + messages: Vec::with_capacity(1), + }; + + // A ping frame is static over the lifetime of a Reactor instance, so it + // can be pre-serialised, cached, and reused for every ping. + let cached_ping_frame = { + populate_frame( + &mut cached_frame, + vec![new_payload(Payload::Ping(proto::Ping {}))], + ); + cached_frame.encode_to_vec() + }; + + // Spawn a task that periodically pings all known seeds. + // + // Pinging all seeds announces this node as alive, propagating the + // instance UUID, and requesting PONG responses to drive population of + // the active peer list. + let seed_ping_task = AbortOnDrop(tokio::spawn(seed_ping_task( + Arc::clone(&seed_list), + Arc::clone(&socket), + cached_ping_frame, + ))); + + Self { + dispatch, + identity, + cached_frame, + serialisation_buf: Vec::with_capacity(1024), + peer_list: PeerList::with_capacity(seed_list.len()), + seed_list, + _seed_ping_task: seed_ping_task, + socket, + } + } + + pub(crate) async fn run(mut self, mut rx: mpsc::Receiver) { + info!( + identity = %self.identity, + seed_list = ?self.seed_list, + "gossip reactor started", + ); + + loop { + let (_bytes_read, _bytes_sent) = tokio::select! { + msg = self.read() => { + match msg { + Ok((bytes_read, bytes_sent)) => (bytes_read, bytes_sent), + Err(Error::NoPayload { peer, addr }) => { + warn!(%peer, %addr, "message contains no payload"); + continue; + } + Err(Error::Deserialise { addr, source }) => { + warn!(error=%source, %addr, "error deserialising frame"); + continue; + } + Err(Error::Identity { addr }) => { + warn!(%addr, "invalid identity value in frame"); + continue; + } + Err(Error::Io(error)) => { + error!(%error, "i/o error"); + continue; + } + } + } + op = rx.recv() => { + match op { + None => { + info!("stopping gossip reactor"); + return; + } + Some(Request::GetPeers(tx)) => { + let _ = tx.send(self.peer_list.peer_uuids()); + (0, 0) + }, + Some(Request::Broadcast(payload)) => { + populate_frame(&mut self.cached_frame, [ + new_payload(Payload::UserData(proto::UserPayload{payload})), + ]); + self.cached_frame + .encode(&mut self.serialisation_buf) + .expect("buffer should grow"); + let bytes_sent = self.peer_list.broadcast(&self.serialisation_buf, &self.socket).await; + (0, bytes_sent) + } + } + } + }; + } + } + + /// Read a gossip frame from the socket and potentially respond. + /// + /// This method waits for a frame to be made available by the OS, enumerates + /// the contents, batches any responses to those frames and if non-empty, + /// returns the result to the sender of the original frame. + /// + /// Returns the bytes read and bytes sent during execution of this method. + async fn read(&mut self) -> Result<(usize, usize), Error> { + // Read a frame into buf. + let (bytes_read, frame, peer_addr) = read_frame(&self.socket).await?; + + // Read the peer identity from the frame + let identity = + Identity::try_from(frame.identity).map_err(|_| Error::Identity { addr: peer_addr })?; + + // Don't process messages from this node. + // + // It's expected that all N servers will be included in a peer list, + // rather than the N-1 peers to this node. By dropping messages from + // this node, pings sent by this node will go unprocessed and therefore + // this node will not be added to the active peer list. + if identity == self.identity { + debug!(%identity, %peer_addr, bytes_read, "dropping frame from self"); + return Ok((bytes_read, 0)); + } + + // Find or create the peer in the peer list. + let peer = self.peer_list.upsert(&identity, peer_addr); + + let mut out_messages = Vec::with_capacity(1); + for msg in frame.messages { + // Extract the payload from the frame message + let payload = msg.payload.ok_or_else(|| Error::NoPayload { + peer: identity.clone(), + addr: peer_addr, + })?; + + // Handle the frame message from the peer, optionally returning a + // response frame. + let response = match payload { + Payload::Ping(_) => Some(Payload::Pong(proto::Pong {})), + Payload::Pong(_) => { + debug!(%identity, %peer_addr, "pong"); + None + } + Payload::UserData(data) => { + self.dispatch.dispatch(data.payload).await; + None + } + }; + + if let Some(payload) = response { + out_messages.push(new_payload(payload)); + } + } + + // Sometimes no message will be returned to the peer - there's no need + // to send an empty frame. + if out_messages.is_empty() { + return Ok((bytes_read, 0)); + } + + populate_frame(&mut self.cached_frame, out_messages); + + // Serialise the frame into the serialisation buffer. + self.cached_frame + .encode(&mut self.serialisation_buf) + .expect("buffer should grow"); + + let bytes_sent = peer.send(&self.serialisation_buf, &self.socket).await?; + + Ok((bytes_read, bytes_sent)) + } + + /// Return the randomised identity assigned to this instance. + pub(crate) fn identity(&self) -> &Identity { + &self.identity + } +} + +/// Wait for a UDP datagram to become ready, and read it entirely into `buf`. +async fn recv(socket: &UdpSocket, buf: &mut BytesMut) -> (usize, SocketAddr) { + let (n_bytes, addr) = socket.recv_buf_from(buf).await.expect("frame buffer maxed"); + trace!(%addr, n_bytes, "socket read"); + (n_bytes, addr) +} + +/// Wait for a UDP datagram to arrive, and decode it into a gossip Frame. +/// +/// Clears the contents of `buf` before reading the frame. +async fn read_frame(socket: &UdpSocket) -> Result<(usize, proto::Frame, SocketAddr), Error> { + // Allocate a buffer to hold a full-sized packet. + let mut buf = BytesMut::with_capacity(1024); + + let (n_bytes, addr) = recv(socket, &mut buf).await; + + // Decode the frame, re-using byte arrays from the underlying buffer. + match proto::Frame::decode(buf.freeze()) { + Ok(frame) => { + debug!(?frame, %addr, n_bytes, "read frame"); + Ok((n_bytes, frame, addr)) + } + Err(e) => Err(Error::Deserialise { addr, source: e }), + } +} + +/// Given a pre-allocated `frame`, clear and populate it with the provided +/// `payload` containing a set of [`FrameMessage`]. +fn populate_frame(frame: &mut proto::Frame, payload: impl IntoIterator) { + frame.messages.clear(); + frame.messages.extend(payload.into_iter()) +} + +/// Instantiate a new [`FrameMessage`] from the given [`Payload`]. +fn new_payload(p: Payload) -> proto::FrameMessage { + proto::FrameMessage { payload: Some(p) } +} + +/// Send a PING message to `socket`, using `peer_name` as logging context. +pub(crate) async fn ping(ping_frame: &[u8], socket: &UdpSocket, addr: SocketAddr) -> usize { + match socket.send_to(ping_frame, &addr).await { + Ok(n_bytes) => { + debug!(addr = %addr, "ping"); + n_bytes + } + Err(e) => { + warn!( + error=%e, + addr = %addr, + "ping failed" + ); + 0 + } + } +} diff --git a/gossip/src/seed.rs b/gossip/src/seed.rs new file mode 100644 index 0000000000..843a8960ba --- /dev/null +++ b/gossip/src/seed.rs @@ -0,0 +1,91 @@ +use std::{future, net::SocketAddr, sync::Arc}; + +use futures::{stream::FuturesUnordered, StreamExt}; +use tokio::{ + net::{self, UdpSocket}, + time::{timeout, MissedTickBehavior}, +}; +use tracing::{debug, warn}; + +use crate::{reactor::ping, RESOLVE_TIMEOUT, SEED_PING_INTERVAL}; + +/// The user-provided seed peer address. +/// +/// NOTE: the IP/socket address this resolves to may change over the +/// lifetime of the peer, so the raw address is retained instead of +/// the [`SocketAddr`] to ensure it is constantly re-resolved when the peer +/// is unreachable. +#[derive(Debug)] +pub(crate) struct Seed(String); + +impl Seed { + pub(crate) fn new(addr: String) -> Self { + Self(addr) + } + + /// Resolve this peer address, returning an error if resolution is not + /// complete within [`RESOLVE_TIMEOUT`]. + pub(crate) async fn resolve(&self) -> Option { + match timeout(RESOLVE_TIMEOUT, resolve(&self.0)).await { + Ok(v) => v, + Err(_) => { + warn!(addr = %self.0, "timeout resolving seed address"); + None + } + } + } +} + +/// Resolve `addr`, returning the first IP address, if any. +async fn resolve(addr: &str) -> Option { + match net::lookup_host(addr).await.map(|mut v| v.next()) { + Ok(Some(v)) => { + debug!(%addr, peer=%v, "resolved peer address"); + Some(v) + } + Ok(None) => { + warn!(%addr, "resolved peer address contains no IPs"); + None + } + Err(e) => { + warn!(%addr, error=%e, "failed to resolve peer address"); + None + } + } +} + +/// Block forever, sending `ping_frame` over `socket` to all the entries in +/// `seeds`. +/// +/// This method immediately pings all the seeds, and then pings periodically at +/// [`SEED_PING_INTERVAL`]. +pub(super) async fn seed_ping_task( + seeds: Arc<[Seed]>, + socket: Arc, + ping_frame: Vec, +) { + let mut interval = tokio::time::interval(SEED_PING_INTERVAL); + + // Do not burden seeds with faster PING frames to catch up this timer. + interval.set_missed_tick_behavior(MissedTickBehavior::Delay); + + // Start the ping loop, with the first iteration starting immediately. + loop { + interval.tick().await; + + let bytes_sent = seeds + .iter() + .map(|seed| async { + if let Some(addr) = seed.resolve().await { + ping(&ping_frame, &socket, addr).await + } else { + 0 + } + }) + .collect::>() + .fold(0, |acc, x| future::ready(acc + x)) + .await; + + debug!(bytes_sent, "seed ping sweep complete"); + } +} diff --git a/gossip/tests/smoke.rs b/gossip/tests/smoke.rs new file mode 100644 index 0000000000..554c282898 --- /dev/null +++ b/gossip/tests/smoke.rs @@ -0,0 +1,70 @@ +use std::time::Duration; + +use test_helpers::{maybe_start_logging, timeout::FutureTimeout}; +use tokio::{net::UdpSocket, sync::mpsc}; + +use gossip::*; + +/// Assert that starting up a reactor performs the initial peer discovery +/// from a set of seeds, resulting in both peers known of one another. +#[tokio::test] +async fn test_payload_exchange() { + maybe_start_logging(); + + // How long to wait for peer discovery to complete. + const TIMEOUT: Duration = Duration::from_secs(5); + + // Bind a UDP socket to a random port + let a_socket = UdpSocket::bind("127.0.0.1:0") + .await + .expect("failed to bind UDP socket"); + let a_addr = a_socket.local_addr().expect("failed to read local addr"); + + // And a socket for the second reactor + let b_socket = UdpSocket::bind("127.0.0.1:0") + .await + .expect("failed to bind UDP socket"); + let b_addr = b_socket.local_addr().expect("failed to read local addr"); + + // Initialise the dispatchers for the reactors + let (a_tx, mut a_rx) = mpsc::channel(5); + let (b_tx, mut b_rx) = mpsc::channel(5); + + // Initialise both reactors + let addrs = dbg!(vec![a_addr.to_string(), b_addr.to_string()]); + let a = Builder::new(addrs.clone(), a_tx).build(a_socket); + let b = Builder::new(addrs, b_tx).build(b_socket); + + // Wait for peer discovery to occur + async { + loop { + if a.get_peers().await.len() == 1 { + break; + } + } + } + .with_timeout_panic(TIMEOUT) + .await; + + // Send the payload through peer A + let a_payload = Bytes::from_static(b"bananas"); + a.broadcast(a_payload.clone()).await; + + // Assert it was received by peer B + let got = b_rx + .recv() + .with_timeout_panic(TIMEOUT) + .await + .expect("reactor stopped"); + assert_eq!(got, a_payload); + + // Do the reverse - send from B to A + let b_payload = Bytes::from_static(b"platanos"); + b.broadcast(b_payload.clone()).await; + let got = a_rx + .recv() + .with_timeout_panic(TIMEOUT) + .await + .expect("reactor stopped"); + assert_eq!(got, b_payload); +} From 93789d7abb3ac4cf568cd7e662ad7edc82ec21da Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Wed, 14 Jun 2023 01:13:31 +0200 Subject: [PATCH 06/37] feat: refuse oversized gossip payloads Calculate the available byte size for a user payload sent via gossip, and pro-actively check this limit earlier, when the caller is attempting to send the frame, rather than later in the reactor where there's no feedback to the caller. DRY frame serialisation to simplify enforcement, and validate/refuse oversized frames in the reactor so that frames are unlikely to be truncated by receivers. --- Cargo.lock | 1 + gossip/Cargo.toml | 1 + gossip/src/handle.rs | 24 ++++++--- gossip/src/lib.rs | 41 +++++++++++++-- gossip/src/peers.rs | 25 ++++++--- gossip/src/reactor.rs | 120 ++++++++++++++++++++++++++++++++++-------- gossip/tests/smoke.rs | 4 +- 7 files changed, 178 insertions(+), 38 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7197270c6d..6cc4a061ae 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2010,6 +2010,7 @@ dependencies = [ "prost", "prost-build", "test_helpers", + "thiserror", "tokio", "tracing", "uuid", diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index 14b70b9f5a..8000dd32f6 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -8,6 +8,7 @@ async-trait = "0.1.68" futures = "0.3.28" hashbrown.workspace = true prost = "0.11.9" +thiserror = "1.0.40" tokio = { version = "1.28.2", features = ["net", "io-util", "time", "rt", "sync", "macros"] } tracing = "0.1.37" uuid = { version = "1.3.3", features = ["v4"] } diff --git a/gossip/src/handle.rs b/gossip/src/handle.rs index 075966a35c..6a81acdea4 100644 --- a/gossip/src/handle.rs +++ b/gossip/src/handle.rs @@ -1,9 +1,17 @@ -use crate::Bytes; +use crate::{Bytes, MAX_USER_PAYLOAD_BYTES}; +use thiserror::Error; use tokio::sync::{mpsc, oneshot}; use uuid::Uuid; use crate::peers::Identity; +/// An error indicating a send was attempted with a payload that exceeds +/// [`MAX_USER_PAYLOAD_BYTES`]. +#[derive(Error, Debug)] +#[error("max allowed payload size exceeded")] +#[allow(missing_copy_implementations)] +pub struct PayloadSizeError {} + /// Requests sent to the [`Reactor`] actor task. /// /// [`Reactor`]: crate::reactor::Reactor @@ -42,14 +50,18 @@ impl GossipHandle { /// /// This is a best-effort operation - peers are not guaranteed to receive /// this broadcast. - pub async fn broadcast(&self, payload: T) + pub async fn broadcast(&self, payload: T) -> Result<(), PayloadSizeError> where T: Into + Send, { - self.tx - .send(Request::Broadcast(payload.into())) - .await - .unwrap() + let payload = payload.into(); + if payload.len() > MAX_USER_PAYLOAD_BYTES { + return Err(PayloadSizeError {}); + } + + self.tx.send(Request::Broadcast(payload)).await.unwrap(); + + Ok(()) } /// Retrieve a snapshot of the connected peer list. diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index 30a4994c22..c52e50e7e3 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -8,9 +8,9 @@ //! //! This implementation sends unicast UDP frames between peers, with support for //! both control frames & user payloads. The maximum message size is 65,507 -//! bytes, but a packet this large is fragmented into smaller (at most -//! MTU-sized) packets and is at greater risk of being dropped due to a lost -//! fragment. +//! bytes ([`MAX_USER_PAYLOAD_BYTES`] for application-level payloads), but a +//! packet this large is fragmented into smaller (at most MTU-sized) packets and +//! is at greater risk of being dropped due to a lost fragment. //! //! # Security //! @@ -59,3 +59,38 @@ const RESOLVE_TIMEOUT: Duration = Duration::from_secs(5); /// Defines the interval between PING frames sent to all configured seed peers. const SEED_PING_INTERVAL: std::time::Duration = Duration::from_secs(15); + +/// The maximum payload size allowed. +/// +/// Attempting to send a serialised packet (inclusive of control frames/fields) +/// in excess of this amount will result in an error. +const MAX_FRAME_BYTES: usize = 1024 * 10; + +/// The frame header overhead for user payloads. +const USER_PAYLOAD_OVERHEAD: usize = 22; + +/// The maximum allowed byte size of user payloads. +/// +/// Sending payloads of this size is discouraged as it leads to fragmentation of +/// the message and increases the chance of the message being undelivered / +/// dropped. Smaller is always better for UDP transports! +pub const MAX_USER_PAYLOAD_BYTES: usize = MAX_FRAME_BYTES - USER_PAYLOAD_OVERHEAD; + +#[cfg(test)] +#[allow(clippy::assertions_on_constants)] +mod tests { + use super::*; + + #[test] + fn test_max_msg_size() { + assert!(MAX_FRAME_BYTES < 65_536, "cannot exceed UDP maximum"); + } + + #[test] + fn test_max_user_payload_size() { + assert_eq!( + MAX_USER_PAYLOAD_BYTES, 10_218, + "applications may depend on this value not changing" + ); + } +} diff --git a/gossip/src/peers.rs b/gossip/src/peers.rs index a40d3bb3eb..6ab7f61607 100644 --- a/gossip/src/peers.rs +++ b/gossip/src/peers.rs @@ -1,4 +1,4 @@ -use std::net::SocketAddr; +use std::{io, net::SocketAddr}; use futures::{stream::FuturesUnordered, StreamExt}; use hashbrown::{hash_map::RawEntryMut, HashMap}; @@ -7,6 +7,8 @@ use tokio::net::UdpSocket; use tracing::{trace, warn}; use uuid::Uuid; +use crate::MAX_FRAME_BYTES; + /// A unique generated identity containing 128 bits of randomness (V4 UUID). #[derive(Debug, Eq, Clone)] pub(crate) struct Identity(Bytes, Uuid); @@ -67,11 +69,22 @@ pub(crate) struct Peer { } impl Peer { - pub(crate) async fn send( - &self, - buf: &[u8], - socket: &UdpSocket, - ) -> Result { + pub(crate) async fn send(&self, buf: &[u8], socket: &UdpSocket) -> Result { + // If the frame is larger than the allowed maximum, then the receiver + // will truncate the frame when reading the socket. + // + // Never send frames that will be unprocessable. + if buf.len() > MAX_FRAME_BYTES { + warn!( + n_bytes = buf.len(), + "not sending oversized packet - receiver would truncate" + ); + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "max frame size exceeded", + )); + } + let ret = socket.send_to(buf, self.addr).await; match &ret { Ok(n_bytes) => { diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs index f70239745e..9058398cfb 100644 --- a/gossip/src/reactor.rs +++ b/gossip/src/reactor.rs @@ -11,7 +11,7 @@ use crate::{ peers::{Identity, PeerList}, proto::{self, frame_message::Payload, FrameMessage}, seed::{seed_ping_task, Seed}, - Dispatcher, Request, + Dispatcher, Request, MAX_FRAME_BYTES, }; #[derive(Debug)] @@ -31,6 +31,8 @@ enum Error { }, Io(std::io::Error), + + MaxSize(usize), } impl From for Error { @@ -95,6 +97,7 @@ where let seed_list = seed_list.into_iter().map(Seed::new).collect(); let socket = Arc::new(socket); + let mut serialisation_buf = Vec::with_capacity(1024); // Generate a pre-populated frame header. let mut cached_frame = proto::Frame { @@ -108,8 +111,10 @@ where populate_frame( &mut cached_frame, vec![new_payload(Payload::Ping(proto::Ping {}))], - ); - cached_frame.encode_to_vec() + &mut serialisation_buf, + ) + .unwrap(); + serialisation_buf.clone() }; // Spawn a task that periodically pings all known seeds. @@ -127,7 +132,7 @@ where dispatch, identity, cached_frame, - serialisation_buf: Vec::with_capacity(1024), + serialisation_buf, peer_list: PeerList::with_capacity(seed_list.len()), seed_list, _seed_ping_task: seed_ping_task, @@ -163,6 +168,10 @@ where error!(%error, "i/o error"); continue; } + Err(Error::MaxSize(_)) => { + // Logged at source + continue; + } } } op = rx.recv() => { @@ -176,12 +185,17 @@ where (0, 0) }, Some(Request::Broadcast(payload)) => { - populate_frame(&mut self.cached_frame, [ - new_payload(Payload::UserData(proto::UserPayload{payload})), - ]); - self.cached_frame - .encode(&mut self.serialisation_buf) - .expect("buffer should grow"); + // The user is guaranteed MAX_USER_PAYLOAD_BYTES to + // be send-able, so send this frame without packing + // others with it for simplicity. + if populate_frame( + &mut self.cached_frame, + vec![new_payload(Payload::UserData(proto::UserPayload{payload}))], + &mut self.serialisation_buf + ).is_err() + { + continue + } let bytes_sent = self.peer_list.broadcast(&self.serialisation_buf, &self.socket).await; (0, bytes_sent) } @@ -253,12 +267,12 @@ where return Ok((bytes_read, 0)); } - populate_frame(&mut self.cached_frame, out_messages); - // Serialise the frame into the serialisation buffer. - self.cached_frame - .encode(&mut self.serialisation_buf) - .expect("buffer should grow"); + populate_frame( + &mut self.cached_frame, + out_messages, + &mut self.serialisation_buf, + )?; let bytes_sent = peer.send(&self.serialisation_buf, &self.socket).await?; @@ -282,8 +296,12 @@ async fn recv(socket: &UdpSocket, buf: &mut BytesMut) -> (usize, SocketAddr) { /// /// Clears the contents of `buf` before reading the frame. async fn read_frame(socket: &UdpSocket) -> Result<(usize, proto::Frame, SocketAddr), Error> { - // Allocate a buffer to hold a full-sized packet. - let mut buf = BytesMut::with_capacity(1024); + // Pre-allocate a buffer large enough to hold the maximum message size. + // + // Reading data from a UDP socket silently truncates if there's not enough + // buffer space to write the full packet payload (tokio doesn't support + // MSG_TRUNC-like flags on reads). + let mut buf = BytesMut::with_capacity(MAX_FRAME_BYTES); let (n_bytes, addr) = recv(socket, &mut buf).await; @@ -298,10 +316,33 @@ async fn read_frame(socket: &UdpSocket) -> Result<(usize, proto::Frame, SocketAd } /// Given a pre-allocated `frame`, clear and populate it with the provided -/// `payload` containing a set of [`FrameMessage`]. -fn populate_frame(frame: &mut proto::Frame, payload: impl IntoIterator) { - frame.messages.clear(); - frame.messages.extend(payload.into_iter()) +/// `payload` containing a set of [`FrameMessage`], serialising it to `buf`. +fn populate_frame( + frame: &mut proto::Frame, + payload: Vec, + buf: &mut Vec, +) -> Result<(), Error> { + frame.messages = payload; + + // Reading data from a UDP socket silently truncates if there's not enough + // buffer space to write the full packet payload. This library will + // pre-allocate a buffer of this size to read packets into, therefore all + // messages must be shorter than this value. + if frame.encoded_len() > MAX_FRAME_BYTES { + error!( + n_bytes=buf.len(), + n_max=%MAX_FRAME_BYTES, + "attempted to send frame larger than configured maximum" + ); + return Err(Error::MaxSize(buf.len())); + } + + buf.clear(); + frame.encode(buf).expect("buffer should grow"); + + debug_assert!(proto::Frame::decode(crate::Bytes::from(buf.clone())).is_ok()); + + Ok(()) } /// Instantiate a new [`FrameMessage`] from the given [`Payload`]. @@ -326,3 +367,40 @@ pub(crate) async fn ping(ping_frame: &[u8], socket: &UdpSocket, addr: SocketAddr } } } + +#[cfg(test)] +mod tests { + use crate::{MAX_USER_PAYLOAD_BYTES, USER_PAYLOAD_OVERHEAD}; + + use super::*; + + #[test] + fn test_user_frame_overhead() { + let identity = Identity::new(); + + // Generate a pre-populated frame header. + let mut frame = proto::Frame { + identity: identity.as_bytes().clone(), + messages: vec![], + }; + + let mut buf = Vec::new(); + populate_frame( + &mut frame, + vec![new_payload(Payload::UserData(proto::UserPayload { + payload: crate::Bytes::new(), // Empty/0-sized + }))], + &mut buf, + ) + .unwrap(); + + // The proto type should self-report the same size. + assert_eq!(buf.len(), frame.encoded_len()); + + // The overhead const should be accurate + assert_eq!(buf.len(), USER_PAYLOAD_OVERHEAD); + + // The max user payload size should be accurate. + assert_eq!(MAX_FRAME_BYTES - buf.len(), MAX_USER_PAYLOAD_BYTES); + } +} diff --git a/gossip/tests/smoke.rs b/gossip/tests/smoke.rs index 554c282898..c46be5f343 100644 --- a/gossip/tests/smoke.rs +++ b/gossip/tests/smoke.rs @@ -48,7 +48,7 @@ async fn test_payload_exchange() { // Send the payload through peer A let a_payload = Bytes::from_static(b"bananas"); - a.broadcast(a_payload.clone()).await; + a.broadcast(a_payload.clone()).await.unwrap(); // Assert it was received by peer B let got = b_rx @@ -60,7 +60,7 @@ async fn test_payload_exchange() { // Do the reverse - send from B to A let b_payload = Bytes::from_static(b"platanos"); - b.broadcast(b_payload.clone()).await; + b.broadcast(b_payload.clone()).await.unwrap(); let got = a_rx .recv() .with_timeout_panic(TIMEOUT) From 48466bfa89491969f6d0571c834e3317fb6286a1 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Wed, 14 Jun 2023 15:12:50 +0200 Subject: [PATCH 07/37] feat(metrics): bytes/frames sent/received & peers Emit metrics tracking the number of bytes sent / received, and number of frames sent / received by the local node. Track the number of discovered peers to record peer discovery rate and current number of known peers per node. --- Cargo.lock | 1 + gossip/Cargo.toml | 1 + gossip/src/builder.rs | 8 ++++-- gossip/src/lib.rs | 1 + gossip/src/metric.rs | 60 +++++++++++++++++++++++++++++++++++++++ gossip/src/peers.rs | 40 ++++++++++++++++++++++---- gossip/src/reactor.rs | 66 ++++++++++++++++++++++++++++++++++--------- gossip/src/seed.rs | 10 +++++-- gossip/tests/smoke.rs | 8 ++++-- 9 files changed, 170 insertions(+), 25 deletions(-) create mode 100644 gossip/src/metric.rs diff --git a/Cargo.lock b/Cargo.lock index 6cc4a061ae..7a2b7b364a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2007,6 +2007,7 @@ dependencies = [ "async-trait", "futures", "hashbrown 0.14.0", + "metric", "prost", "prost-build", "test_helpers", diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index 8000dd32f6..36110ca420 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -7,6 +7,7 @@ edition = "2021" async-trait = "0.1.68" futures = "0.3.28" hashbrown.workspace = true +metric = { version = "0.1.0", path = "../metric" } prost = "0.11.9" thiserror = "1.0.40" tokio = { version = "1.28.2", features = ["net", "io-util", "time", "rt", "sync", "macros"] } diff --git a/gossip/src/builder.rs b/gossip/src/builder.rs index 503c8e42ad..35d7ebab83 100644 --- a/gossip/src/builder.rs +++ b/gossip/src/builder.rs @@ -1,3 +1,5 @@ +use std::sync::Arc; + use tokio::{ net::{ToSocketAddrs, UdpSocket}, sync::mpsc, @@ -10,6 +12,7 @@ use crate::{handle::GossipHandle, reactor::Reactor, Dispatcher}; pub struct Builder { seed_addrs: Vec, dispatcher: T, + metric: Arc, } impl Builder { @@ -18,10 +21,11 @@ impl Builder { /// /// Each address in `seed_addrs` is re-resolved periodically and the first /// resolved IP address is used for peer communication. - pub fn new(seed_addrs: Vec, dispatcher: T) -> Self { + pub fn new(seed_addrs: Vec, dispatcher: T, metric: Arc) -> Self { Self { seed_addrs, dispatcher, + metric, } } } @@ -41,7 +45,7 @@ where let (tx, rx) = mpsc::channel(1000); // Initialise the reactor - let reactor = Reactor::new(self.seed_addrs, socket, self.dispatcher); + let reactor = Reactor::new(self.seed_addrs, socket, self.dispatcher, &self.metric); let identity = reactor.identity().clone(); // Start the message reactor. diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index c52e50e7e3..66ecad726f 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -38,6 +38,7 @@ mod builder; mod dispatcher; mod handle; +mod metric; mod peers; mod proto; mod reactor; diff --git a/gossip/src/metric.rs b/gossip/src/metric.rs new file mode 100644 index 0000000000..c7ae249458 --- /dev/null +++ b/gossip/src/metric.rs @@ -0,0 +1,60 @@ +//! Metric newtype wrappers for type safety. +//! +//! The metrics are easily confused (they're all counters) so have the compiler +//! check the right ones are being used in the right places. + +use metric::U64Counter; + +#[derive(Debug, Clone)] +pub(crate) struct SentFrames(metric::U64Counter); + +impl SentFrames { + pub(crate) fn inc(&self, v: usize) { + self.0.inc(v as u64) + } +} + +#[derive(Debug)] +pub(crate) struct ReceivedFrames(metric::U64Counter); + +impl ReceivedFrames { + pub(crate) fn inc(&self, v: usize) { + self.0.inc(v as u64) + } +} + +#[derive(Debug, Clone)] +pub(crate) struct SentBytes(metric::U64Counter); + +impl SentBytes { + pub(crate) fn inc(&self, v: usize) { + self.0.inc(v as u64) + } +} + +#[derive(Debug)] +pub(crate) struct ReceivedBytes(metric::U64Counter); + +impl ReceivedBytes { + pub(crate) fn inc(&self, v: usize) { + self.0.inc(v as u64) + } +} + +pub(crate) fn new_metrics( + metrics: &metric::Registry, +) -> (SentFrames, ReceivedFrames, SentBytes, ReceivedBytes) { + let metric_frames = metrics.register_metric::( + "gossip_frames", + "number of frames sent/received by this node", + ); + let metric_bytes = metrics + .register_metric::("gossip_bytes", "sum of bytes sent/received by this node"); + + ( + SentFrames(metric_frames.recorder(&[("direction", "sent")])), + ReceivedFrames(metric_frames.recorder(&[("direction", "received")])), + SentBytes(metric_bytes.recorder(&[("direction", "sent")])), + ReceivedBytes(metric_bytes.recorder(&[("direction", "received")])), + ) +} diff --git a/gossip/src/peers.rs b/gossip/src/peers.rs index 6ab7f61607..f4531af87b 100644 --- a/gossip/src/peers.rs +++ b/gossip/src/peers.rs @@ -2,12 +2,16 @@ use std::{io, net::SocketAddr}; use futures::{stream::FuturesUnordered, StreamExt}; use hashbrown::{hash_map::RawEntryMut, HashMap}; +use metric::U64Counter; use prost::bytes::Bytes; use tokio::net::UdpSocket; use tracing::{trace, warn}; use uuid::Uuid; -use crate::MAX_FRAME_BYTES; +use crate::{ + metric::{SentBytes, SentFrames}, + MAX_FRAME_BYTES, +}; /// A unique generated identity containing 128 bits of randomness (V4 UUID). #[derive(Debug, Eq, Clone)] @@ -69,7 +73,13 @@ pub(crate) struct Peer { } impl Peer { - pub(crate) async fn send(&self, buf: &[u8], socket: &UdpSocket) -> Result { + pub(crate) async fn send( + &self, + buf: &[u8], + socket: &UdpSocket, + frames_sent: &SentFrames, + bytes_sent: &SentBytes, + ) -> Result { // If the frame is larger than the allowed maximum, then the receiver // will truncate the frame when reading the socket. // @@ -88,6 +98,8 @@ impl Peer { let ret = socket.send_to(buf, self.addr).await; match &ret { Ok(n_bytes) => { + frames_sent.inc(1); + bytes_sent.inc(*n_bytes); trace!(identity=%self.identity, n_bytes, peer_addr=%self.addr, "send frame") } Err(e) => { @@ -102,14 +114,25 @@ impl Peer { #[derive(Debug, Default)] pub(crate) struct PeerList { list: HashMap, + + /// The number of known, believed-to-be-healthy peers. + metric_peer_count: metric::U64Counter, } impl PeerList { /// Initialise the [`PeerList`] with capacity for `cap` number of [`Peer`] /// instances. - pub(crate) fn with_capacity(cap: usize) -> Self { + pub(crate) fn with_capacity(cap: usize, metrics: &metric::Registry) -> Self { + let metric_peer_count = metrics + .register_metric::( + "gossip_known_peers", + "number of likely healthy peers known to this node", + ) + .recorder(&[]); + Self { list: HashMap::with_capacity(cap), + metric_peer_count, } } @@ -123,6 +146,7 @@ impl PeerList { pub(crate) fn upsert(&mut self, identity: &Identity, peer_addr: SocketAddr) -> &mut Peer { let p = match self.list.raw_entry_mut().from_key(identity) { RawEntryMut::Vacant(v) => { + self.metric_peer_count.inc(1); v.insert( identity.to_owned(), Peer { @@ -141,10 +165,16 @@ impl PeerList { /// Broadcast `buf` to all known peers over `socket`, returning the number /// of bytes sent in total. - pub(crate) async fn broadcast(&self, buf: &[u8], socket: &UdpSocket) -> usize { + pub(crate) async fn broadcast( + &self, + buf: &[u8], + socket: &UdpSocket, + frames_sent: &SentFrames, + bytes_sent: &SentBytes, + ) -> usize { self.list .values() - .map(|v| v.send(buf, socket)) + .map(|v| v.send(buf, socket, frames_sent, bytes_sent)) .collect::>() .fold(0, |acc, res| async move { match res { diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs index 9058398cfb..58c771b4ef 100644 --- a/gossip/src/reactor.rs +++ b/gossip/src/reactor.rs @@ -8,6 +8,7 @@ use tokio::{ use tracing::{debug, error, info, trace, warn}; use crate::{ + metric::*, peers::{Identity, PeerList}, proto::{self, frame_message::Payload, FrameMessage}, seed::{seed_ping_task, Seed}, @@ -83,14 +84,28 @@ pub(crate) struct Reactor { /// contain less peers than the number of initial seeds. peer_list: PeerList, + /// The UDP socket used for communication with peers. socket: Arc, + + /// The count of frames sent and received. + metric_frames_sent: SentFrames, + metric_frames_received: ReceivedFrames, + + /// The sum of bytes sent and received. + metric_bytes_sent: SentBytes, + metric_bytes_received: ReceivedBytes, } impl Reactor where T: Dispatcher, { - pub(crate) fn new(seed_list: Vec, socket: UdpSocket, dispatch: T) -> Self { + pub(crate) fn new( + seed_list: Vec, + socket: UdpSocket, + dispatch: T, + metrics: &metric::Registry, + ) -> Self { // Generate a unique UUID for this Reactor instance, and cache the wire // representation. let identity = Identity::new(); @@ -117,6 +132,11 @@ where serialisation_buf.clone() }; + // Initialise the various metrics with wrappers to help distinguish + // between the (very similar) counters. + let (metric_frames_sent, metric_frames_received, metric_bytes_sent, metric_bytes_received) = + new_metrics(metrics); + // Spawn a task that periodically pings all known seeds. // // Pinging all seeds announces this node as alive, propagating the @@ -126,6 +146,8 @@ where Arc::clone(&seed_list), Arc::clone(&socket), cached_ping_frame, + metric_frames_sent.clone(), + metric_bytes_sent.clone(), ))); Self { @@ -133,10 +155,14 @@ where identity, cached_frame, serialisation_buf, - peer_list: PeerList::with_capacity(seed_list.len()), + peer_list: PeerList::with_capacity(seed_list.len(), metrics), seed_list, _seed_ping_task: seed_ping_task, socket, + metric_frames_sent, + metric_frames_received, + metric_bytes_sent, + metric_bytes_received, } } @@ -148,10 +174,10 @@ where ); loop { - let (_bytes_read, _bytes_sent) = tokio::select! { + tokio::select! { msg = self.read() => { match msg { - Ok((bytes_read, bytes_sent)) => (bytes_read, bytes_sent), + Ok(()) => {}, Err(Error::NoPayload { peer, addr }) => { warn!(%peer, %addr, "message contains no payload"); continue; @@ -182,7 +208,6 @@ where } Some(Request::GetPeers(tx)) => { let _ = tx.send(self.peer_list.peer_uuids()); - (0, 0) }, Some(Request::Broadcast(payload)) => { // The user is guaranteed MAX_USER_PAYLOAD_BYTES to @@ -196,8 +221,7 @@ where { continue } - let bytes_sent = self.peer_list.broadcast(&self.serialisation_buf, &self.socket).await; - (0, bytes_sent) + self.peer_list.broadcast(&self.serialisation_buf, &self.socket, &self.metric_frames_sent, &self.metric_bytes_sent).await; } } } @@ -212,9 +236,11 @@ where /// returns the result to the sender of the original frame. /// /// Returns the bytes read and bytes sent during execution of this method. - async fn read(&mut self) -> Result<(usize, usize), Error> { + async fn read(&mut self) -> Result<(), Error> { // Read a frame into buf. let (bytes_read, frame, peer_addr) = read_frame(&self.socket).await?; + self.metric_frames_received.inc(1); + self.metric_bytes_received.inc(bytes_read as _); // Read the peer identity from the frame let identity = @@ -228,7 +254,7 @@ where // this node will not be added to the active peer list. if identity == self.identity { debug!(%identity, %peer_addr, bytes_read, "dropping frame from self"); - return Ok((bytes_read, 0)); + return Ok(()); } // Find or create the peer in the peer list. @@ -264,7 +290,7 @@ where // Sometimes no message will be returned to the peer - there's no need // to send an empty frame. if out_messages.is_empty() { - return Ok((bytes_read, 0)); + return Ok(()); } // Serialise the frame into the serialisation buffer. @@ -274,9 +300,15 @@ where &mut self.serialisation_buf, )?; - let bytes_sent = peer.send(&self.serialisation_buf, &self.socket).await?; + peer.send( + &self.serialisation_buf, + &self.socket, + &self.metric_frames_sent, + &self.metric_bytes_sent, + ) + .await?; - Ok((bytes_read, bytes_sent)) + Ok(()) } /// Return the randomised identity assigned to this instance. @@ -351,10 +383,18 @@ fn new_payload(p: Payload) -> proto::FrameMessage { } /// Send a PING message to `socket`, using `peer_name` as logging context. -pub(crate) async fn ping(ping_frame: &[u8], socket: &UdpSocket, addr: SocketAddr) -> usize { +pub(crate) async fn ping( + ping_frame: &[u8], + socket: &UdpSocket, + addr: SocketAddr, + sent_frames: &SentFrames, + sent_bytes: &SentBytes, +) -> usize { match socket.send_to(ping_frame, &addr).await { Ok(n_bytes) => { debug!(addr = %addr, "ping"); + sent_frames.inc(1); + sent_bytes.inc(n_bytes); n_bytes } Err(e) => { diff --git a/gossip/src/seed.rs b/gossip/src/seed.rs index 843a8960ba..97df4f245c 100644 --- a/gossip/src/seed.rs +++ b/gossip/src/seed.rs @@ -7,7 +7,11 @@ use tokio::{ }; use tracing::{debug, warn}; -use crate::{reactor::ping, RESOLVE_TIMEOUT, SEED_PING_INTERVAL}; +use crate::{ + metric::{SentBytes, SentFrames}, + reactor::ping, + RESOLVE_TIMEOUT, SEED_PING_INTERVAL, +}; /// The user-provided seed peer address. /// @@ -63,6 +67,8 @@ pub(super) async fn seed_ping_task( seeds: Arc<[Seed]>, socket: Arc, ping_frame: Vec, + sent_frames: SentFrames, + sent_bytes: SentBytes, ) { let mut interval = tokio::time::interval(SEED_PING_INTERVAL); @@ -77,7 +83,7 @@ pub(super) async fn seed_ping_task( .iter() .map(|seed| async { if let Some(addr) = seed.resolve().await { - ping(&ping_frame, &socket, addr).await + ping(&ping_frame, &socket, addr, &sent_frames, &sent_bytes).await } else { 0 } diff --git a/gossip/tests/smoke.rs b/gossip/tests/smoke.rs index c46be5f343..16ff06c469 100644 --- a/gossip/tests/smoke.rs +++ b/gossip/tests/smoke.rs @@ -1,4 +1,4 @@ -use std::time::Duration; +use std::{sync::Arc, time::Duration}; use test_helpers::{maybe_start_logging, timeout::FutureTimeout}; use tokio::{net::UdpSocket, sync::mpsc}; @@ -11,6 +11,8 @@ use gossip::*; async fn test_payload_exchange() { maybe_start_logging(); + let metrics = Arc::new(metric::Registry::default()); + // How long to wait for peer discovery to complete. const TIMEOUT: Duration = Duration::from_secs(5); @@ -32,8 +34,8 @@ async fn test_payload_exchange() { // Initialise both reactors let addrs = dbg!(vec![a_addr.to_string(), b_addr.to_string()]); - let a = Builder::new(addrs.clone(), a_tx).build(a_socket); - let b = Builder::new(addrs, b_tx).build(b_socket); + let a = Builder::new(addrs.clone(), a_tx, Arc::clone(&metrics)).build(a_socket); + let b = Builder::new(addrs, b_tx, Arc::clone(&metrics)).build(b_socket); // Wait for peer discovery to occur async { From 58c48748800c3bb86473279a41ba5f3447e93f41 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Thu, 22 Jun 2023 17:11:26 +0200 Subject: [PATCH 08/37] chore: workspace_hack support Add workspace_hack and whitelist the import. --- Cargo.lock | 1 + gossip/Cargo.toml | 1 + gossip/src/lib.rs | 1 + 3 files changed, 3 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index 7a2b7b364a..8483a15a65 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2015,6 +2015,7 @@ dependencies = [ "tokio", "tracing", "uuid", + "workspace-hack", ] [[package]] diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index 36110ca420..aa19f7a46c 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -13,6 +13,7 @@ thiserror = "1.0.40" tokio = { version = "1.28.2", features = ["net", "io-util", "time", "rt", "sync", "macros"] } tracing = "0.1.37" uuid = { version = "1.3.3", features = ["v4"] } +workspace-hack = { version = "0.1", path = "../workspace-hack" } [build-dependencies] prost-build = "0.11.9" diff --git a/gossip/src/lib.rs b/gossip/src/lib.rs index 66ecad726f..ab3aaf797a 100644 --- a/gossip/src/lib.rs +++ b/gossip/src/lib.rs @@ -49,6 +49,7 @@ use std::time::Duration; /// Work around the unused_crate_dependencies false positives for test deps. #[cfg(test)] use test_helpers as _; +use workspace_hack as _; pub use builder::*; pub use dispatcher::*; From 7880f9287f21104d454f59d1d247941ef4b786e6 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Thu, 22 Jun 2023 17:13:31 +0200 Subject: [PATCH 09/37] chore: add license --- gossip/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index aa19f7a46c..05c97e7d5f 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -2,6 +2,7 @@ name = "gossip" version = "0.1.0" edition = "2021" +license.workspace = true [dependencies] async-trait = "0.1.68" From 118aefe2d20bcd465ed4170bf0af6eec2e3ad0d4 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 13:39:52 +0200 Subject: [PATCH 10/37] chore: use workspace crate config Inherit version/authors/edition from the workspace. --- gossip/Cargo.toml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/gossip/Cargo.toml b/gossip/Cargo.toml index 05c97e7d5f..ed67bd9a7f 100644 --- a/gossip/Cargo.toml +++ b/gossip/Cargo.toml @@ -1,7 +1,8 @@ [package] name = "gossip" -version = "0.1.0" -edition = "2021" +version.workspace = true +authors.workspace = true +edition.workspace = true license.workspace = true [dependencies] From bee1b45c1391c1f71ffc1063dcff3d5778943ed1 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 13:48:01 +0200 Subject: [PATCH 11/37] build: reuse path var DRY the path var. --- gossip/build.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/gossip/build.rs b/gossip/build.rs index 8207b46030..313904759b 100644 --- a/gossip/build.rs +++ b/gossip/build.rs @@ -4,15 +4,13 @@ use prost_build::Config; fn main() -> Result<(), Box> { let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("proto"); + let proto = root.join("gossip.proto"); - println!( - "cargo:rerun-if-changed={}", - root.join("gossip.proto").display() - ); + println!("cargo:rerun-if-changed={}", proto.display()); Config::new() .bytes(["."]) - .compile_protos(&[root.join("gossip.proto")], &[root])?; + .compile_protos(&[proto], &[root])?; Ok(()) } From 991692d2fb0153c732d79dbdeb076f90571469d4 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 13:51:40 +0200 Subject: [PATCH 12/37] refactor: short/long panic message --- gossip/src/peers.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gossip/src/peers.rs b/gossip/src/peers.rs index f4531af87b..5e33f86620 100644 --- a/gossip/src/peers.rs +++ b/gossip/src/peers.rs @@ -213,7 +213,7 @@ mod tests { let v = Bytes::from_static(&[ 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, ]); - let _ = Identity::try_from(v).expect_err("short ID should fail"); + let _ = Identity::try_from(v).expect_err("long ID should fail"); } #[test] From 060f1b2ed6b83b985ebb423228c7cfe8d757e6a0 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 14:01:11 +0200 Subject: [PATCH 13/37] docs: unwrap correctness docs Describe the possible reasons a socket recvfrom() would cause a panic. --- gossip/src/reactor.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs index 58c771b4ef..d547df6d6e 100644 --- a/gossip/src/reactor.rs +++ b/gossip/src/reactor.rs @@ -319,7 +319,13 @@ where /// Wait for a UDP datagram to become ready, and read it entirely into `buf`. async fn recv(socket: &UdpSocket, buf: &mut BytesMut) -> (usize, SocketAddr) { - let (n_bytes, addr) = socket.recv_buf_from(buf).await.expect("frame buffer maxed"); + let (n_bytes, addr) = socket + .recv_buf_from(buf) + .await + // These errors are libc's recvfrom() or converting the kernel-provided + // socket structure to rust's SocketAddr - neither should ever happen. + .expect("invalid recvfrom"); + trace!(%addr, n_bytes, "socket read"); (n_bytes, addr) } From 71625043e2b393eecc803e7c30fb3554c7a7881c Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 14:02:57 +0200 Subject: [PATCH 14/37] test: remove dbg!() --- gossip/tests/smoke.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gossip/tests/smoke.rs b/gossip/tests/smoke.rs index 16ff06c469..d1a8136455 100644 --- a/gossip/tests/smoke.rs +++ b/gossip/tests/smoke.rs @@ -33,7 +33,7 @@ async fn test_payload_exchange() { let (b_tx, mut b_rx) = mpsc::channel(5); // Initialise both reactors - let addrs = dbg!(vec![a_addr.to_string(), b_addr.to_string()]); + let addrs = vec![a_addr.to_string(), b_addr.to_string()]; let a = Builder::new(addrs.clone(), a_tx, Arc::clone(&metrics)).build(a_socket); let b = Builder::new(addrs, b_tx, Arc::clone(&metrics)).build(b_socket); From a686580ffaa1cd3c861954058d06e14374d26edf Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 14:03:57 +0200 Subject: [PATCH 15/37] test: multiple messages in single test This ensures various reused scratch buffers are wiped between uses. --- gossip/tests/smoke.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/gossip/tests/smoke.rs b/gossip/tests/smoke.rs index d1a8136455..efe4a83798 100644 --- a/gossip/tests/smoke.rs +++ b/gossip/tests/smoke.rs @@ -69,4 +69,15 @@ async fn test_payload_exchange() { .await .expect("reactor stopped"); assert_eq!(got, b_payload); + + // Send another payload through peer A (ensuring scratch buffers are + // correctly wiped, etc) + let a_payload = Bytes::from_static(b"platanos"); + a.broadcast(a_payload.clone()).await.unwrap(); + let got = b_rx + .recv() + .with_timeout_panic(TIMEOUT) + .await + .expect("reactor stopped"); + assert_eq!(got, a_payload); } From 701da1363cb2ba4250a434b49a253fbec38347c8 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 14:10:03 +0200 Subject: [PATCH 16/37] refactor: remove panic on impossible error Remove the logical complexity of error handling for an error that cannot occur. This was an artifact of pre-PR refactoring - the error being returned SHOULD never be reached, as the only error returned is the "your message is too big" error, and that's not possible because the message size is validated in the GossipHandle::broadcast() method before it reaches the reactor. --- gossip/src/reactor.rs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs index d547df6d6e..990b8d3eda 100644 --- a/gossip/src/reactor.rs +++ b/gossip/src/reactor.rs @@ -213,15 +213,18 @@ where // The user is guaranteed MAX_USER_PAYLOAD_BYTES to // be send-able, so send this frame without packing // others with it for simplicity. - if populate_frame( + populate_frame( &mut self.cached_frame, vec![new_payload(Payload::UserData(proto::UserPayload{payload}))], &mut self.serialisation_buf - ).is_err() - { - continue - } - self.peer_list.broadcast(&self.serialisation_buf, &self.socket, &self.metric_frames_sent, &self.metric_bytes_sent).await; + ).expect("size validated in handle at enqueue time"); + + self.peer_list.broadcast( + &self.serialisation_buf, + &self.socket, + &self.metric_frames_sent, + &self.metric_bytes_sent + ).await; } } } From c2273e64880b3e1411c754fc64013bc21e8724b3 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Mon, 10 Jul 2023 14:27:08 +0200 Subject: [PATCH 17/37] docs: remove outdated comment --- gossip/src/reactor.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gossip/src/reactor.rs b/gossip/src/reactor.rs index 990b8d3eda..6173863afc 100644 --- a/gossip/src/reactor.rs +++ b/gossip/src/reactor.rs @@ -391,7 +391,7 @@ fn new_payload(p: Payload) -> proto::FrameMessage { proto::FrameMessage { payload: Some(p) } } -/// Send a PING message to `socket`, using `peer_name` as logging context. +/// Send a PING message to `socket`. pub(crate) async fn ping( ping_frame: &[u8], socket: &UdpSocket, From eec31b7f00385e9170148bc0b6e09723d392e30c Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Thu, 22 Jun 2023 14:50:43 -0400 Subject: [PATCH 18/37] feat: Abstract over which partition ID type we're using to get a partition from the catalog --- .../components/partition_source/catalog.rs | 13 ++++------- .../buffer_tree/partition/resolver/catalog.rs | 14 ++++++----- .../partition/resolver/sort_key.rs | 13 ++++------- iox_catalog/src/lib.rs | 23 ++++++++++++++++++- querier/src/cache/partition.rs | 13 ++++------- 5 files changed, 45 insertions(+), 31 deletions(-) diff --git a/compactor/src/components/partition_source/catalog.rs b/compactor/src/components/partition_source/catalog.rs index bde8351eef..b29ca839cd 100644 --- a/compactor/src/components/partition_source/catalog.rs +++ b/compactor/src/components/partition_source/catalog.rs @@ -2,8 +2,8 @@ use std::{fmt::Display, sync::Arc}; use async_trait::async_trait; use backoff::{Backoff, BackoffConfig}; -use data_types::{Partition, PartitionId}; -use iox_catalog::interface::Catalog; +use data_types::{Partition, PartitionId, TransitionPartitionId}; +use iox_catalog::{interface::Catalog, partition_lookup}; use super::PartitionSource; @@ -33,12 +33,9 @@ impl PartitionSource for CatalogPartitionSource { async fn fetch_by_id(&self, partition_id: PartitionId) -> Option { Backoff::new(&self.backoff_config) .retry_all_errors("partition_by_id", || async { - self.catalog - .repositories() - .await - .partitions() - .get_by_id(partition_id) - .await + let mut repos = self.catalog.repositories().await; + let id = TransitionPartitionId::Deprecated(partition_id); + partition_lookup(repos.as_mut(), &id).await }) .await .expect("retry forever") diff --git a/ingester/src/buffer_tree/partition/resolver/catalog.rs b/ingester/src/buffer_tree/partition/resolver/catalog.rs index 9b80f8dac8..770f3a052f 100644 --- a/ingester/src/buffer_tree/partition/resolver/catalog.rs +++ b/ingester/src/buffer_tree/partition/resolver/catalog.rs @@ -100,7 +100,11 @@ mod tests { use std::{sync::Arc, time::Duration}; use assert_matches::assert_matches; - use iox_catalog::test_helpers::{arbitrary_namespace, arbitrary_table}; + use data_types::TransitionPartitionId; + use iox_catalog::{ + partition_lookup, + test_helpers::{arbitrary_namespace, arbitrary_table}, + }; use super::*; use crate::buffer_tree::table::TableName; @@ -161,11 +165,9 @@ mod tests { assert_matches!(got.lock().sort_key(), SortKeyState::Provided(None)); assert!(got.lock().partition_key.ptr_eq(&callers_partition_key)); - let got = catalog - .repositories() - .await - .partitions() - .get_by_id(got.lock().partition_id) + let mut repos = catalog.repositories().await; + let id = TransitionPartitionId::Deprecated(got.lock().partition_id); + let got = partition_lookup(repos.as_mut(), &id) .await .unwrap() .expect("partition not created"); diff --git a/ingester/src/buffer_tree/partition/resolver/sort_key.rs b/ingester/src/buffer_tree/partition/resolver/sort_key.rs index 71e898f140..113b047b5d 100644 --- a/ingester/src/buffer_tree/partition/resolver/sort_key.rs +++ b/ingester/src/buffer_tree/partition/resolver/sort_key.rs @@ -3,8 +3,8 @@ use std::sync::Arc; use backoff::{Backoff, BackoffConfig}; -use data_types::PartitionId; -use iox_catalog::interface::Catalog; +use data_types::{PartitionId, TransitionPartitionId}; +use iox_catalog::{interface::Catalog, partition_lookup}; use schema::sort::SortKey; /// A resolver of [`SortKey`] from the catalog for a given [`PartitionId`]. @@ -33,12 +33,9 @@ impl SortKeyResolver { pub(crate) async fn fetch(self) -> Option { Backoff::new(&self.backoff_config) .retry_all_errors("fetch partition sort key", || async { - let s = self - .catalog - .repositories() - .await - .partitions() - .get_by_id(self.partition_id) + let mut repos = self.catalog.repositories().await; + let id = TransitionPartitionId::Deprecated(self.partition_id); + let s = partition_lookup(repos.as_mut(), &id) .await? .unwrap_or_else(|| { panic!( diff --git a/iox_catalog/src/lib.rs b/iox_catalog/src/lib.rs index 7d1cb04995..d7142a6268 100644 --- a/iox_catalog/src/lib.rs +++ b/iox_catalog/src/lib.rs @@ -22,7 +22,7 @@ use workspace_hack as _; use crate::interface::{ColumnTypeMismatchSnafu, Error, RepoCollection, Result}; use data_types::{ partition_template::{NamespacePartitionTemplateOverride, TablePartitionTemplateOverride}, - ColumnType, NamespaceId, NamespaceSchema, TableSchema, + ColumnType, NamespaceId, NamespaceSchema, Partition, TableSchema, TransitionPartitionId, }; use mutable_batch::MutableBatch; use std::{borrow::Cow, collections::HashMap}; @@ -67,6 +67,27 @@ impl TableScopedError { } } +/// Look up a partition in the catalog by either database-assigned ID or deterministic hash ID. +/// +/// The existence of this function should be temporary; it can be removed once all partition lookup +/// is happening with only the deterministic hash ID. +pub async fn partition_lookup( + repos: &mut R, + id: &TransitionPartitionId, +) -> Result, Error> +where + R: RepoCollection + ?Sized, +{ + match id { + TransitionPartitionId::Deprecated(partition_id) => { + repos.partitions().get_by_id(*partition_id).await + } + TransitionPartitionId::Deterministic(partition_hash_id) => { + repos.partitions().get_by_hash_id(partition_hash_id).await + } + } +} + /// Given an iterator of `(table_name, batch)` to validate, this function /// ensures all the columns within `batch` match the existing schema for /// `table_name` in `schema`. If the column does not already exist in `schema`, diff --git a/querier/src/cache/partition.rs b/querier/src/cache/partition.rs index fba27593e7..fd5fa52cd3 100644 --- a/querier/src/cache/partition.rs +++ b/querier/src/cache/partition.rs @@ -13,10 +13,10 @@ use cache_system::{ }; use data_types::{ partition_template::{build_column_values, ColumnValue}, - ColumnId, Partition, PartitionId, + ColumnId, Partition, PartitionId, TransitionPartitionId, }; use datafusion::scalar::ScalarValue; -use iox_catalog::interface::Catalog; +use iox_catalog::{interface::Catalog, partition_lookup}; use iox_query::chunk_statistics::{ColumnRange, ColumnRanges}; use iox_time::TimeProvider; use observability_deps::tracing::debug; @@ -66,12 +66,9 @@ impl PartitionCache { async move { let partition = Backoff::new(&backoff_config) .retry_all_errors("get partition_key", || async { - catalog - .repositories() - .await - .partitions() - .get_by_id(partition_id) - .await + let mut repos = catalog.repositories().await; + let id = TransitionPartitionId::Deprecated(partition_id); + partition_lookup(repos.as_mut(), &id).await }) .await .expect("retry forever")?; From c1e42651ec179be76d421513a114bf486a107dea Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Fri, 23 Jun 2023 15:56:54 -0400 Subject: [PATCH 19/37] feat: Abstract over which partition ID type we're using to compare and swap sort keys --- import_export/src/file/import.rs | 2 +- ingester/src/buffer_tree/partition.rs | 9 ++--- .../partition/resolver/sort_key.rs | 13 ++++--- ingester/src/persist/mod.rs | 2 +- ingester/src/persist/worker.rs | 6 ++- iox_catalog/src/interface.rs | 20 ++++++---- iox_catalog/src/mem.rs | 18 ++++++--- iox_catalog/src/metrics.rs | 4 +- iox_catalog/src/postgres.rs | 38 ++++++++++++------ iox_catalog/src/sqlite.rs | 39 +++++++++++++------ iox_tests/src/catalog.rs | 16 ++++++-- 11 files changed, 111 insertions(+), 56 deletions(-) diff --git a/import_export/src/file/import.rs b/import_export/src/file/import.rs index 4da41877a0..3056317498 100644 --- a/import_export/src/file/import.rs +++ b/import_export/src/file/import.rs @@ -526,7 +526,7 @@ impl RemoteImporter { let res = repos .partitions() .cas_sort_key( - partition.id, + &partition.transition_partition_id(), Some(partition.sort_key.clone()), &new_sort_key, ) diff --git a/ingester/src/buffer_tree/partition.rs b/ingester/src/buffer_tree/partition.rs index 28d571131e..f2359055a8 100644 --- a/ingester/src/buffer_tree/partition.rs +++ b/ingester/src/buffer_tree/partition.rs @@ -928,27 +928,26 @@ mod tests { // Populate the catalog with the namespace / table let (_ns_id, table_id) = populate_catalog(&*catalog, "bananas", "platanos").await; - let partition_id = catalog + let partition = catalog .repositories() .await .partitions() .create_or_get("test".into(), table_id) .await - .expect("should create") - .id; + .expect("should create"); catalog .repositories() .await .partitions() - .cas_sort_key(partition_id, None, &["terrific"]) + .cas_sort_key(&partition.transition_partition_id(), None, &["terrific"]) .await .unwrap(); // Read the just-created sort key (None) let fetcher = Arc::new(DeferredLoad::new( Duration::from_nanos(1), - SortKeyResolver::new(partition_id, Arc::clone(&catalog), backoff_config.clone()) + SortKeyResolver::new(partition.id, Arc::clone(&catalog), backoff_config.clone()) .fetch(), &metrics, )); diff --git a/ingester/src/buffer_tree/partition/resolver/sort_key.rs b/ingester/src/buffer_tree/partition/resolver/sort_key.rs index 113b047b5d..3bdae5e55d 100644 --- a/ingester/src/buffer_tree/partition/resolver/sort_key.rs +++ b/ingester/src/buffer_tree/partition/resolver/sort_key.rs @@ -73,24 +73,27 @@ mod tests { // Populate the catalog with the namespace / table let (_ns_id, table_id) = populate_catalog(&*catalog, NAMESPACE_NAME, TABLE_NAME).await; - let partition_id = catalog + let partition = catalog .repositories() .await .partitions() .create_or_get(PARTITION_KEY.into(), table_id) .await - .expect("should create") - .id; + .expect("should create"); let fetcher = - SortKeyResolver::new(partition_id, Arc::clone(&catalog), backoff_config.clone()); + SortKeyResolver::new(partition.id, Arc::clone(&catalog), backoff_config.clone()); // Set the sort key let catalog_state = catalog .repositories() .await .partitions() - .cas_sort_key(partition_id, None, &["uno", "dos", "bananas"]) + .cas_sort_key( + &partition.transition_partition_id(), + None, + &["uno", "dos", "bananas"], + ) .await .expect("should update existing partition key"); diff --git a/ingester/src/persist/mod.rs b/ingester/src/persist/mod.rs index 3dc23b8cd5..291ed0c60b 100644 --- a/ingester/src/persist/mod.rs +++ b/ingester/src/persist/mod.rs @@ -344,7 +344,7 @@ mod tests { .await .partitions() .cas_sort_key( - partition_id, + &transition_partition_id, None, &["bananas", "are", "good", "for", "you"], ) diff --git a/ingester/src/persist/worker.rs b/ingester/src/persist/worker.rs index 857265e92f..f640528a33 100644 --- a/ingester/src/persist/worker.rs +++ b/ingester/src/persist/worker.rs @@ -376,7 +376,11 @@ where let mut repos = catalog.repositories().await; match repos .partitions() - .cas_sort_key(ctx.partition_id(), old_sort_key.clone(), &new_sort_key_str) + .cas_sort_key( + &ctx.transition_partition_id(), + old_sort_key.clone(), + &new_sort_key_str, + ) .await { Ok(_) => ControlFlow::Break(Ok(())), diff --git a/iox_catalog/src/interface.rs b/iox_catalog/src/interface.rs index eeb41a7f21..0320c274a3 100644 --- a/iox_catalog/src/interface.rs +++ b/iox_catalog/src/interface.rs @@ -6,7 +6,7 @@ use data_types::{ Column, ColumnType, ColumnsByName, CompactionLevel, Namespace, NamespaceId, NamespaceName, NamespaceSchema, NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, - Table, TableId, TableSchema, Timestamp, + Table, TableId, TableSchema, Timestamp, TransitionPartitionId, }; use iox_time::TimeProvider; use snafu::{OptionExt, Snafu}; @@ -80,7 +80,7 @@ pub enum Error { TableNotFound { id: TableId }, #[snafu(display("partition {} not found", id))] - PartitionNotFound { id: PartitionId }, + PartitionNotFound { id: TransitionPartitionId }, #[snafu(display( "couldn't create column {} in table {}; limit reached on namespace", @@ -397,7 +397,7 @@ pub trait PartitionRepo: Send + Sync { /// concurrent writers. async fn cas_sort_key( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, old_sort_key: Option>, new_sort_key: &[&str], ) -> Result>>; @@ -1549,7 +1549,11 @@ pub(crate) mod test_helpers { // test update_sort_key from None to Some repos .partitions() - .cas_sort_key(other_partition.id, None, &["tag2", "tag1", "time"]) + .cas_sort_key( + &other_partition.transition_partition_id(), + None, + &["tag2", "tag1", "time"], + ) .await .unwrap(); @@ -1557,7 +1561,7 @@ pub(crate) mod test_helpers { let err = repos .partitions() .cas_sort_key( - other_partition.id, + &other_partition.transition_partition_id(), Some(["bananas".to_string()].to_vec()), &["tag2", "tag1", "tag3 , with comma", "time"], ) @@ -1593,7 +1597,7 @@ pub(crate) mod test_helpers { let err = repos .partitions() .cas_sort_key( - other_partition.id, + &other_partition.transition_partition_id(), None, &["tag2", "tag1", "tag3 , with comma", "time"], ) @@ -1607,7 +1611,7 @@ pub(crate) mod test_helpers { let err = repos .partitions() .cas_sort_key( - other_partition.id, + &other_partition.transition_partition_id(), Some(["bananas".to_string()].to_vec()), &["tag2", "tag1", "tag3 , with comma", "time"], ) @@ -1621,7 +1625,7 @@ pub(crate) mod test_helpers { repos .partitions() .cas_sort_key( - other_partition.id, + &other_partition.transition_partition_id(), Some( ["tag2", "tag1", "time"] .into_iter() diff --git a/iox_catalog/src/mem.rs b/iox_catalog/src/mem.rs index ebe8663a4d..35e9b242bc 100644 --- a/iox_catalog/src/mem.rs +++ b/iox_catalog/src/mem.rs @@ -19,7 +19,7 @@ use data_types::{ Column, ColumnId, ColumnType, CompactionLevel, Namespace, NamespaceId, NamespaceName, NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, Table, TableId, - Timestamp, + Timestamp, TransitionPartitionId, }; use iox_time::{SystemProvider, TimeProvider}; use snafu::ensure; @@ -625,20 +625,26 @@ impl PartitionRepo for MemTxn { async fn cas_sort_key( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, old_sort_key: Option>, new_sort_key: &[&str], ) -> Result>> { let stage = self.stage(); let old_sort_key = old_sort_key.unwrap_or_default(); - match stage.partitions.iter_mut().find(|p| p.id == partition_id) { + + match stage.partitions.iter_mut().find(|p| match partition_id { + TransitionPartitionId::Deterministic(hash_id) => { + p.hash_id().map_or(false, |h| h == hash_id) + } + TransitionPartitionId::Deprecated(id) => p.id == *id, + }) { Some(p) if p.sort_key == old_sort_key => { p.sort_key = new_sort_key.iter().map(|s| s.to_string()).collect(); Ok(p.clone()) } Some(p) => return Err(CasFailure::ValueMismatch(p.sort_key.clone())), None => Err(CasFailure::QueryError(Error::PartitionNotFound { - id: partition_id, + id: partition_id.clone(), })), } } @@ -962,7 +968,9 @@ async fn create_parquet_file( .partitions .iter_mut() .find(|p| p.id == partition_id) - .ok_or(Error::PartitionNotFound { id: partition_id })?; + .ok_or(Error::PartitionNotFound { + id: TransitionPartitionId::Deprecated(partition_id), + })?; partition.new_file_at = Some(created_at); } diff --git a/iox_catalog/src/metrics.rs b/iox_catalog/src/metrics.rs index b20357d144..bc8a3850ba 100644 --- a/iox_catalog/src/metrics.rs +++ b/iox_catalog/src/metrics.rs @@ -10,7 +10,7 @@ use data_types::{ Column, ColumnType, CompactionLevel, Namespace, NamespaceId, NamespaceName, NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, Table, TableId, - Timestamp, + Timestamp, TransitionPartitionId, }; use iox_time::{SystemProvider, TimeProvider}; use metric::{DurationHistogram, Metric}; @@ -174,7 +174,7 @@ decorate!( "partition_get_by_hash_id" = get_by_hash_id(&mut self, partition_hash_id: &PartitionHashId) -> Result>; "partition_list_by_table_id" = list_by_table_id(&mut self, table_id: TableId) -> Result>; "partition_list_ids" = list_ids(&mut self) -> Result>; - "partition_update_sort_key" = cas_sort_key(&mut self, partition_id: PartitionId, old_sort_key: Option>, new_sort_key: &[&str]) -> Result>>; + "partition_update_sort_key" = cas_sort_key(&mut self, partition_id: &TransitionPartitionId, old_sort_key: Option>, new_sort_key: &[&str]) -> Result>>; "partition_record_skipped_compaction" = record_skipped_compaction(&mut self, partition_id: PartitionId, reason: &str, num_files: usize, limit_num_files: usize, limit_num_files_first_in_partition: usize, estimated_bytes: u64, limit_bytes: u64) -> Result<()>; "partition_list_skipped_compactions" = list_skipped_compactions(&mut self) -> Result>; "partition_delete_skipped_compactions" = delete_skipped_compactions(&mut self, partition_id: PartitionId) -> Result>; diff --git a/iox_catalog/src/postgres.rs b/iox_catalog/src/postgres.rs index 46ab41bea2..3409963b10 100644 --- a/iox_catalog/src/postgres.rs +++ b/iox_catalog/src/postgres.rs @@ -23,7 +23,7 @@ use data_types::{ Column, ColumnType, CompactionLevel, Namespace, NamespaceId, NamespaceName, NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, Table, TableId, - Timestamp, + Timestamp, TransitionPartitionId, }; use iox_time::{SystemProvider, TimeProvider}; use observability_deps::tracing::{debug, info, warn}; @@ -1153,24 +1153,38 @@ WHERE table_id = $1; /// round trips to service a transaction in the happy path). async fn cas_sort_key( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, old_sort_key: Option>, new_sort_key: &[&str], ) -> Result>> { let old_sort_key = old_sort_key.unwrap_or_default(); - let res = sqlx::query_as::<_, Partition>( - r#" + // This `match` will go away when all partitions have hash IDs in the database. + let query = match partition_id { + TransitionPartitionId::Deterministic(hash_id) => sqlx::query_as::<_, Partition>( + r#" +UPDATE partition +SET sort_key = $1 +WHERE hash_id = $2 AND sort_key = $3 +RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; + "#, + ) + .bind(new_sort_key) // $1 + .bind(hash_id) // $2 + .bind(&old_sort_key), // $3 + TransitionPartitionId::Deprecated(id) => sqlx::query_as::<_, Partition>( + r#" UPDATE partition SET sort_key = $1 WHERE id = $2 AND sort_key = $3 RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; "#, - ) - .bind(new_sort_key) // $1 - .bind(partition_id) // $2 - .bind(&old_sort_key) // $3 - .fetch_one(&mut self.inner) - .await; + ) + .bind(new_sort_key) // $1 + .bind(id) // $2 + .bind(&old_sort_key), // $3 + }; + + let res = query.fetch_one(&mut self.inner).await; let partition = match res { Ok(v) => v, @@ -1187,11 +1201,11 @@ RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; // NOTE: this is racy, but documented - this might return "Sort // key differs! Old key: " return Err(CasFailure::ValueMismatch( - PartitionRepo::get_by_id(self, partition_id) + crate::partition_lookup(self, partition_id) .await .map_err(CasFailure::QueryError)? .ok_or(CasFailure::QueryError(Error::PartitionNotFound { - id: partition_id, + id: partition_id.clone(), }))? .sort_key, )); diff --git a/iox_catalog/src/sqlite.rs b/iox_catalog/src/sqlite.rs index e917a0bbe8..e83ad6bd6d 100644 --- a/iox_catalog/src/sqlite.rs +++ b/iox_catalog/src/sqlite.rs @@ -21,7 +21,7 @@ use data_types::{ Column, ColumnId, ColumnSet, ColumnType, CompactionLevel, Namespace, NamespaceId, NamespaceName, NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, - Table, TableId, Timestamp, + Table, TableId, Timestamp, TransitionPartitionId, }; use serde::{Deserialize, Serialize}; use std::collections::HashSet; @@ -952,24 +952,39 @@ WHERE table_id = $1; /// round trips to service a transaction in the happy path). async fn cas_sort_key( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, old_sort_key: Option>, new_sort_key: &[&str], ) -> Result>> { let old_sort_key = old_sort_key.unwrap_or_default(); - let res = sqlx::query_as::<_, PartitionPod>( - r#" + + // This `match` will go away when all partitions have hash IDs in the database. + let query = match partition_id { + TransitionPartitionId::Deterministic(hash_id) => sqlx::query_as::<_, PartitionPod>( + r#" +UPDATE partition +SET sort_key = $1 +WHERE hash_id = $2 AND sort_key = $3 +RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; + "#, + ) + .bind(Json(new_sort_key)) // $1 + .bind(hash_id) // $2 + .bind(Json(&old_sort_key)), // $3 + TransitionPartitionId::Deprecated(id) => sqlx::query_as::<_, PartitionPod>( + r#" UPDATE partition SET sort_key = $1 WHERE id = $2 AND sort_key = $3 RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; "#, - ) - .bind(Json(new_sort_key)) // $1 - .bind(partition_id) // $2 - .bind(Json(&old_sort_key)) // $3 - .fetch_one(self.inner.get_mut()) - .await; + ) + .bind(Json(new_sort_key)) // $1 + .bind(id) // $2 + .bind(Json(&old_sort_key)), // $3 + }; + + let res = query.fetch_one(self.inner.get_mut()).await; let partition = match res { Ok(v) => v, @@ -986,11 +1001,11 @@ RETURNING id, hash_id, table_id, partition_key, sort_key, new_file_at; // NOTE: this is racy, but documented - this might return "Sort // key differs! Old key: " return Err(CasFailure::ValueMismatch( - PartitionRepo::get_by_id(self, partition_id) + crate::partition_lookup(self, partition_id) .await .map_err(CasFailure::QueryError)? .ok_or(CasFailure::QueryError(Error::PartitionNotFound { - id: partition_id, + id: partition_id.clone(), }))? .sort_key, )); diff --git a/iox_tests/src/catalog.rs b/iox_tests/src/catalog.rs index 8cf760d77e..c24c1f6b3e 100644 --- a/iox_tests/src/catalog.rs +++ b/iox_tests/src/catalog.rs @@ -328,7 +328,11 @@ impl TestTable { let partition = repos .partitions() - .cas_sort_key(partition.id, None, sort_key) + .cas_sort_key( + &TransitionPartitionId::Deprecated(partition.id), + None, + sort_key, + ) .await .unwrap(); @@ -452,7 +456,7 @@ impl TestPartition { .await .partitions() .cas_sort_key( - self.partition.id, + &TransitionPartitionId::Deprecated(self.partition.id), Some(old_sort_key), &sort_key.to_columns().collect::>(), ) @@ -786,7 +790,7 @@ async fn update_catalog_sort_key_if_needed( ); partitions_catalog .cas_sort_key( - partition_id, + &TransitionPartitionId::Deprecated(partition_id), Some( catalog_sort_key .to_columns() @@ -803,7 +807,11 @@ async fn update_catalog_sort_key_if_needed( let new_columns = sort_key.to_columns().collect::>(); debug!("Updating sort key from None to {:?}", &new_columns); partitions_catalog - .cas_sort_key(partition_id, None, &new_columns) + .cas_sort_key( + &TransitionPartitionId::Deprecated(partition_id), + None, + &new_columns, + ) .await .unwrap(); } From 22c17fb9701eb15c052ad6d03ecc7072fb22ad40 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Mon, 26 Jun 2023 13:44:34 -0400 Subject: [PATCH 20/37] feat: Abstract over which partition ID type we're using to list Parquet files --- .../partition_files_source/catalog.rs | 4 +- garbage_collector/src/objectstore/checker.rs | 2 +- ingester/src/persist/mod.rs | 6 +-- iox_catalog/src/interface.rs | 15 +++++--- iox_catalog/src/mem.rs | 10 ++++- iox_catalog/src/metrics.rs | 2 +- iox_catalog/src/postgres.rs | 32 ++++++++++++---- iox_catalog/src/sqlite.rs | 38 +++++++++++++------ service_grpc_catalog/src/lib.rs | 6 +-- 9 files changed, 78 insertions(+), 37 deletions(-) diff --git a/compactor/src/components/partition_files_source/catalog.rs b/compactor/src/components/partition_files_source/catalog.rs index 4280643f0c..33918c1213 100644 --- a/compactor/src/components/partition_files_source/catalog.rs +++ b/compactor/src/components/partition_files_source/catalog.rs @@ -5,7 +5,7 @@ use std::{ use async_trait::async_trait; use backoff::{Backoff, BackoffConfig}; -use data_types::{ParquetFile, PartitionId}; +use data_types::{ParquetFile, PartitionId, TransitionPartitionId}; use iox_catalog::interface::Catalog; use observability_deps::tracing::warn; @@ -61,7 +61,7 @@ impl CatalogQuerier for Arc { self.repositories() .await .parquet_files() - .list_by_partition_not_to_delete(partition_id) + .list_by_partition_not_to_delete(&TransitionPartitionId::Deprecated(partition_id)) .await } } diff --git a/garbage_collector/src/objectstore/checker.rs b/garbage_collector/src/objectstore/checker.rs index 7d8fe1ceaf..a8e7a4bb24 100644 --- a/garbage_collector/src/objectstore/checker.rs +++ b/garbage_collector/src/objectstore/checker.rs @@ -542,7 +542,7 @@ mod tests { async fn list_by_partition_not_to_delete( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, ) -> iox_catalog::interface::Result> { self.inner .list_by_partition_not_to_delete(partition_id) diff --git a/ingester/src/persist/mod.rs b/ingester/src/persist/mod.rs index 291ed0c60b..ca0f829fc9 100644 --- a/ingester/src/persist/mod.rs +++ b/ingester/src/persist/mod.rs @@ -16,7 +16,7 @@ mod tests { use std::{sync::Arc, time::Duration}; use assert_matches::assert_matches; - use data_types::{CompactionLevel, ParquetFile}; + use data_types::{CompactionLevel, ParquetFile, TransitionPartitionId}; use futures::TryStreamExt; use iox_catalog::{ interface::{get_schema_by_id, Catalog, SoftDeletedRows}, @@ -243,7 +243,7 @@ mod tests { .repositories() .await .parquet_files() - .list_by_partition_not_to_delete(partition_id) + .list_by_partition_not_to_delete(&TransitionPartitionId::Deprecated(partition_id)) .await .expect("query for parquet files failed"); @@ -392,7 +392,7 @@ mod tests { .repositories() .await .parquet_files() - .list_by_partition_not_to_delete(partition_id) + .list_by_partition_not_to_delete(&TransitionPartitionId::Deprecated(partition_id)) .await .expect("query for parquet files failed"); diff --git a/iox_catalog/src/interface.rs b/iox_catalog/src/interface.rs index 0320c274a3..2d819f7f71 100644 --- a/iox_catalog/src/interface.rs +++ b/iox_catalog/src/interface.rs @@ -483,7 +483,7 @@ pub trait ParquetFileRepo: Send + Sync { /// [`to_delete`](ParquetFile::to_delete). async fn list_by_partition_not_to_delete( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, ) -> Result>; /// Return the parquet file with the given object store id @@ -2680,6 +2680,7 @@ pub(crate) mod test_helpers { let other_partition_params = ParquetFileParams { partition_id: partition2.id, + partition_hash_id: partition2.hash_id().cloned(), object_store_id: Uuid::new_v4(), ..parquet_file_params.clone() }; @@ -2691,14 +2692,16 @@ pub(crate) mod test_helpers { let files = repos .parquet_files() - .list_by_partition_not_to_delete(partition.id) + .list_by_partition_not_to_delete(&partition.transition_partition_id()) .await .unwrap(); - // not asserting against a vector literal to guard against flakiness due to uncertain - // ordering of SQL query in postgres impl assert_eq!(files.len(), 2); - assert_matches!(files.iter().find(|f| f.id == parquet_file.id), Some(_)); - assert_matches!(files.iter().find(|f| f.id == level1_file.id), Some(_)); + + let mut file_ids: Vec<_> = files.into_iter().map(|f| f.id).collect(); + file_ids.sort(); + let mut expected_ids = vec![parquet_file.id, level1_file.id]; + expected_ids.sort(); + assert_eq!(file_ids, expected_ids); // remove namespace to avoid it from affecting later tests repos diff --git a/iox_catalog/src/mem.rs b/iox_catalog/src/mem.rs index 35e9b242bc..ab5937f31a 100644 --- a/iox_catalog/src/mem.rs +++ b/iox_catalog/src/mem.rs @@ -850,14 +850,20 @@ impl ParquetFileRepo for MemTxn { async fn list_by_partition_not_to_delete( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, ) -> Result> { let stage = self.stage(); Ok(stage .parquet_files .iter() - .filter(|f| f.partition_id == partition_id && f.to_delete.is_none()) + .filter(|f| match partition_id { + TransitionPartitionId::Deterministic(hash_id) => { + f.partition_hash_id.as_ref().map_or(false, |h| h == hash_id) + } + TransitionPartitionId::Deprecated(id) => f.partition_id == *id, + }) + .filter(|f| f.to_delete.is_none()) .cloned() .collect()) } diff --git a/iox_catalog/src/metrics.rs b/iox_catalog/src/metrics.rs index bc8a3850ba..039db71e59 100644 --- a/iox_catalog/src/metrics.rs +++ b/iox_catalog/src/metrics.rs @@ -193,7 +193,7 @@ decorate!( "parquet_list_by_namespace_not_to_delete" = list_by_namespace_not_to_delete(&mut self, namespace_id: NamespaceId) -> Result>; "parquet_list_by_table_not_to_delete" = list_by_table_not_to_delete(&mut self, table_id: TableId) -> Result>; "parquet_delete_old_ids_only" = delete_old_ids_only(&mut self, older_than: Timestamp) -> Result>; - "parquet_list_by_partition_not_to_delete" = list_by_partition_not_to_delete(&mut self, partition_id: PartitionId) -> Result>; + "parquet_list_by_partition_not_to_delete" = list_by_partition_not_to_delete(&mut self, partition_id: &TransitionPartitionId) -> Result>; "parquet_get_by_object_store_id" = get_by_object_store_id(&mut self, object_store_id: Uuid) -> Result>; "parquet_exists_by_object_store_id_batch" = exists_by_object_store_id_batch(&mut self, object_store_ids: Vec) -> Result>; "parquet_create_upgrade_delete" = create_upgrade_delete(&mut self, delete: &[ParquetFileId], upgrade: &[ParquetFileId], create: &[ParquetFileParams], target_level: CompactionLevel) -> Result>; diff --git a/iox_catalog/src/postgres.rs b/iox_catalog/src/postgres.rs index 3409963b10..846aaf7975 100644 --- a/iox_catalog/src/postgres.rs +++ b/iox_catalog/src/postgres.rs @@ -1472,10 +1472,23 @@ RETURNING id; async fn list_by_partition_not_to_delete( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, ) -> Result> { - sqlx::query_as::<_, ParquetFile>( - r#" + // This `match` will go away when all partitions have hash IDs in the database. + let query = match partition_id { + TransitionPartitionId::Deterministic(hash_id) => sqlx::query_as::<_, ParquetFile>( + r#" +SELECT id, namespace_id, table_id, partition_id, partition_hash_id, object_store_id, min_time, + max_time, to_delete, file_size_bytes, row_count, compaction_level, created_at, column_set, + max_l0_created_at +FROM parquet_file +WHERE parquet_file.partition_hash_id = $1 + AND parquet_file.to_delete IS NULL; + "#, + ) + .bind(hash_id), // $1 + TransitionPartitionId::Deprecated(id) => sqlx::query_as::<_, ParquetFile>( + r#" SELECT id, namespace_id, table_id, partition_id, partition_hash_id, object_store_id, min_time, max_time, to_delete, file_size_bytes, row_count, compaction_level, created_at, column_set, max_l0_created_at @@ -1483,11 +1496,14 @@ FROM parquet_file WHERE parquet_file.partition_id = $1 AND parquet_file.to_delete IS NULL; "#, - ) - .bind(partition_id) // $1 - .fetch_all(&mut self.inner) - .await - .map_err(|e| Error::SqlxError { source: e }) + ) + .bind(id), // $1 + }; + + query + .fetch_all(&mut self.inner) + .await + .map_err(|e| Error::SqlxError { source: e }) } async fn get_by_object_store_id( diff --git a/iox_catalog/src/sqlite.rs b/iox_catalog/src/sqlite.rs index e83ad6bd6d..c35a9ef4b2 100644 --- a/iox_catalog/src/sqlite.rs +++ b/iox_catalog/src/sqlite.rs @@ -1338,10 +1338,23 @@ RETURNING id; async fn list_by_partition_not_to_delete( &mut self, - partition_id: PartitionId, + partition_id: &TransitionPartitionId, ) -> Result> { - Ok(sqlx::query_as::<_, ParquetFilePod>( - r#" + // This `match` will go away when all partitions have hash IDs in the database. + let query = match partition_id { + TransitionPartitionId::Deterministic(hash_id) => sqlx::query_as::<_, ParquetFilePod>( + r#" +SELECT id, namespace_id, table_id, partition_id, partition_hash_id, object_store_id, min_time, + max_time, to_delete, file_size_bytes, row_count, compaction_level, created_at, column_set, + max_l0_created_at +FROM parquet_file +WHERE parquet_file.partition_hash_id = $1 + AND parquet_file.to_delete IS NULL; + "#, + ) + .bind(hash_id), // $1 + TransitionPartitionId::Deprecated(id) => sqlx::query_as::<_, ParquetFilePod>( + r#" SELECT id, namespace_id, table_id, partition_id, partition_hash_id, object_store_id, min_time, max_time, to_delete, file_size_bytes, row_count, compaction_level, created_at, column_set, max_l0_created_at @@ -1349,14 +1362,17 @@ FROM parquet_file WHERE parquet_file.partition_id = $1 AND parquet_file.to_delete IS NULL; "#, - ) - .bind(partition_id) // $1 - .fetch_all(self.inner.get_mut()) - .await - .map_err(|e| Error::SqlxError { source: e })? - .into_iter() - .map(Into::into) - .collect()) + ) + .bind(id), // $1 + }; + + Ok(query + .fetch_all(self.inner.get_mut()) + .await + .map_err(|e| Error::SqlxError { source: e })? + .into_iter() + .map(Into::into) + .collect()) } async fn get_by_object_store_id( diff --git a/service_grpc_catalog/src/lib.rs b/service_grpc_catalog/src/lib.rs index 60c8cd9d06..356539060d 100644 --- a/service_grpc_catalog/src/lib.rs +++ b/service_grpc_catalog/src/lib.rs @@ -18,7 +18,7 @@ // Workaround for "unused crate" lint false positives. use workspace_hack as _; -use data_types::{PartitionId, TableId}; +use data_types::{PartitionId, TableId, TransitionPartitionId}; use generated_types::influxdata::iox::catalog::v1::*; use iox_catalog::interface::{Catalog, SoftDeletedRows}; use observability_deps::tracing::*; @@ -47,11 +47,11 @@ impl catalog_service_server::CatalogService for CatalogService { ) -> Result, Status> { let mut repos = self.catalog.repositories().await; let req = request.into_inner(); - let partition_id = PartitionId::new(req.partition_id); + let partition_id = TransitionPartitionId::Deprecated(PartitionId::new(req.partition_id)); let parquet_files = repos .parquet_files() - .list_by_partition_not_to_delete(partition_id) + .list_by_partition_not_to_delete(&partition_id) .await .map_err(|e| { warn!(error=%e, %req.partition_id, "failed to get parquet_files for partition"); From f20e9e63684a8b8266081146daa244d663870271 Mon Sep 17 00:00:00 2001 From: "Carol (Nichols || Goulding)" Date: Mon, 10 Jul 2023 10:32:18 -0400 Subject: [PATCH 21/37] fix: Add index on parquet_file.partition_hash_id for lookup perf --- .../20230710141740_partition_hash_id_index.sql | 11 +++++++++++ .../20230710141740_partition_hash_id_index.sql | 3 +++ 2 files changed, 14 insertions(+) create mode 100644 iox_catalog/migrations/20230710141740_partition_hash_id_index.sql create mode 100644 iox_catalog/sqlite/migrations/20230710141740_partition_hash_id_index.sql diff --git a/iox_catalog/migrations/20230710141740_partition_hash_id_index.sql b/iox_catalog/migrations/20230710141740_partition_hash_id_index.sql new file mode 100644 index 0000000000..197e7d664a --- /dev/null +++ b/iox_catalog/migrations/20230710141740_partition_hash_id_index.sql @@ -0,0 +1,11 @@ +-- By default, we often only have 5min to finish our statements. The `CREATE INDEX CONCURRENTLY`, +-- however, can take longer. +-- IOX_NO_TRANSACTION +SET statement_timeout TO '60min'; + +-- IOX_STEP_BOUNDARY + +-- IOX_NO_TRANSACTION +CREATE INDEX CONCURRENTLY IF NOT EXISTS parquet_file_partition_hash_id_idx +ON parquet_file (partition_hash_id) +WHERE partition_hash_id IS NOT NULL; diff --git a/iox_catalog/sqlite/migrations/20230710141740_partition_hash_id_index.sql b/iox_catalog/sqlite/migrations/20230710141740_partition_hash_id_index.sql new file mode 100644 index 0000000000..e1dda4e4c8 --- /dev/null +++ b/iox_catalog/sqlite/migrations/20230710141740_partition_hash_id_index.sql @@ -0,0 +1,3 @@ +CREATE INDEX IF NOT EXISTS parquet_file_partition_hash_id_idx +ON parquet_file (partition_hash_id) +WHERE partition_hash_id IS NOT NULL; From 9111cd517fc16e0c3e2a67177ff983c49c85d5ba Mon Sep 17 00:00:00 2001 From: Martin Hilton Date: Tue, 11 Jul 2023 06:33:16 +0100 Subject: [PATCH 22/37] feat(influxql): PERCENTILE function (#8187) * feat(influxql): support TOP and BOTTOM functions Add support for the TOP and BOTTOM functions which return the first n rows in some ordered data set. * fix: clippy * refactor(influxql): use window aggregates for selectors Change the implentation of ProjectionType::Selector to use a window aggregate, rather than an aggregate with a custom selector function. This is in preparation for implementing PERCENTILE. * feat(influxql): PERCENTILE selector Add a selector for the row containing the nth percentile of a partition. This is the behaviour used when a single selector function is used in an influxql query. * feat(influxql): PERCENTILE aggregator Add the PERCENTILE aggregation function for when the PERCENTILE function is used in an aggregating projection. This implementation buffers all non-null field values in memory in order to perform the operation and therefore could be an expensive operation. This is necessary for compatibility with earlier influxdb versions. * refactor(influxql): move PERCENTILE implementation out of plan The plan module is getting rather full of user-defined function implementations. This breaks the new functions used to implement percentile into some new top-level modules for aggregate and window UDFs. * fix: doc-lint * chore: refactor `find_enumerated` * chore: use `s` in format string * chore: include the unexpected selector function in the error * chore(influxql): review suggestions Added some addition comments to help understanding. Changed the handling os slector functions such that FIRST, LAST, MAX & MIN behave the same as they did before PERCENTILE was added. * chore(influxql): make percent_row_number a window UDF Now that user-defined window functions are available make the percent_row_number function be one of those. this allows the values to be calculated for the entire window partition in one go. For some reason the user-defined window function cannot return NULL values. This function uses 0 where it would otherwise use NULL, as row numbering starts at 1. --------- Co-authored-by: Stuart Carnie Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- influxdb_iox/tests/query_tests/cases.rs | 13 + .../query_tests/cases/in/percentile.influxql | 19 + .../cases/in/percentile.influxql.expected | 152 + .../tests/query_tests/data/percentile.lp | 10004 ++++++++++++++++ influxdb_iox/tests/query_tests/setups.rs | 14 + iox_query_influxql/src/aggregate.rs | 24 + .../src/aggregate/percentile.rs | 156 + iox_query_influxql/src/{plan => }/error.rs | 2 +- iox_query_influxql/src/lib.rs | 9 + .../src/plan/expr_type_evaluator.rs | 3 +- iox_query_influxql/src/plan/ir.rs | 3 +- iox_query_influxql/src/plan/mod.rs | 1 - iox_query_influxql/src/plan/planner.rs | 410 +- iox_query_influxql/src/plan/planner/select.rs | 239 +- iox_query_influxql/src/plan/rewriter.rs | 3 +- iox_query_influxql/src/plan/test_utils.rs | 3 +- iox_query_influxql/src/plan/udaf.rs | 6 +- iox_query_influxql/src/plan/udf.rs | 3 +- iox_query_influxql/src/plan/util.rs | 3 +- iox_query_influxql/src/window.rs | 23 + .../src/window/percent_row_number.rs | 96 + 21 files changed, 11051 insertions(+), 135 deletions(-) create mode 100644 influxdb_iox/tests/query_tests/cases/in/percentile.influxql create mode 100644 influxdb_iox/tests/query_tests/cases/in/percentile.influxql.expected create mode 100644 influxdb_iox/tests/query_tests/data/percentile.lp create mode 100644 iox_query_influxql/src/aggregate.rs create mode 100644 iox_query_influxql/src/aggregate/percentile.rs rename iox_query_influxql/src/{plan => }/error.rs (97%) create mode 100644 iox_query_influxql/src/window.rs create mode 100644 iox_query_influxql/src/window/percent_row_number.rs diff --git a/influxdb_iox/tests/query_tests/cases.rs b/influxdb_iox/tests/query_tests/cases.rs index b46b480f78..ed6f7610ae 100644 --- a/influxdb_iox/tests/query_tests/cases.rs +++ b/influxdb_iox/tests/query_tests/cases.rs @@ -440,6 +440,19 @@ mod influxql { .await; } + /// Test PERCENTILE functions. + #[tokio::test] + async fn percentile() { + test_helpers::maybe_start_logging(); + + TestCase { + input: "cases/in/percentile.influxql", + chunk_stage: ChunkStage::Ingester, + } + .run() + .await; + } + #[tokio::test] async fn influxql_metadata() { test_helpers::maybe_start_logging(); diff --git a/influxdb_iox/tests/query_tests/cases/in/percentile.influxql b/influxdb_iox/tests/query_tests/cases/in/percentile.influxql new file mode 100644 index 0000000000..4c55efd2f1 --- /dev/null +++ b/influxdb_iox/tests/query_tests/cases/in/percentile.influxql @@ -0,0 +1,19 @@ +-- Query tests for influxql percentile +-- IOX_SETUP: percentile + +-- +-- Selectors +-- +SELECT PERCENTILE(usage_idle,50) FROM cpu; +SELECT cpu,PERCENTILE(usage_idle,66.667),usage_system FROM cpu; +SELECT PERCENTILE(usage_idle,33.333) FROM cpu GROUP BY cpu; +SELECT PERCENTILE(usage_idle,90),usage_user FROM cpu WHERE cpu='3'; +-- 0th percentile doesn't return any rows. +SELECT PERCENTILE(usage_idle,0) FROM cpu; + +-- +-- Aggregators +-- +SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu; +SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu GROUP BY cpu; +SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu WHERE time >= '1970-01-01 00:00:00' AND time < '1970-01-01 03:00:00' GROUP BY time(1h),cpu; diff --git a/influxdb_iox/tests/query_tests/cases/in/percentile.influxql.expected b/influxdb_iox/tests/query_tests/cases/in/percentile.influxql.expected new file mode 100644 index 0000000000..f8a9fc0f07 --- /dev/null +++ b/influxdb_iox/tests/query_tests/cases/in/percentile.influxql.expected @@ -0,0 +1,152 @@ +-- Test Setup: percentile +-- InfluxQL: SELECT PERCENTILE(usage_idle,50) FROM cpu; +name: cpu ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T01:10:09 | 49.7047 | ++---------------------+------------+ +-- InfluxQL: SELECT cpu,PERCENTILE(usage_idle,66.667),usage_system FROM cpu; +name: cpu ++---------------------+-----+------------+--------------+ +| time | cpu | percentile | usage_system | ++---------------------+-----+------------+--------------+ +| 1970-01-01T01:39:15 | 0 | 66.1469 | 99.8854 | ++---------------------+-----+------------+--------------+ +-- InfluxQL: SELECT PERCENTILE(usage_idle,33.333) FROM cpu GROUP BY cpu; +name: cpu +tags: cpu=0 ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T01:15:15 | 32.9757 | ++---------------------+------------+ +name: cpu +tags: cpu=1 ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T02:13:36 | 32.3062 | ++---------------------+------------+ +name: cpu +tags: cpu=2 ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T01:24:22 | 35.0742 | ++---------------------+------------+ +name: cpu +tags: cpu=3 ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T01:16:58 | 32.0821 | ++---------------------+------------+ +name: cpu +tags: cpu=4 ++---------------------+------------+ +| time | percentile | ++---------------------+------------+ +| 1970-01-01T00:42:34 | 32.9685 | ++---------------------+------------+ +-- InfluxQL: SELECT PERCENTILE(usage_idle,90),usage_user FROM cpu WHERE cpu='3'; +name: cpu ++---------------------+------------+------------+ +| time | percentile | usage_user | ++---------------------+------------+------------+ +| 1970-01-01T00:19:23 | 89.7011 | 34.7815 | ++---------------------+------------+------------+ +-- InfluxQL: SELECT PERCENTILE(usage_idle,0) FROM cpu; ++------+------------+ +| time | percentile | ++------+------------+ ++------+------------+ +-- InfluxQL: SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu; +name: cpu ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 49.2732 | 89.754 | 99.0822 | ++---------------------+------------+--------------+--------------+ +-- InfluxQL: SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu GROUP BY cpu; +name: cpu +tags: cpu=0 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 49.7946 | 90.0001 | 98.8816 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=1 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 50.148 | 89.4109 | 98.8158 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=2 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 49.0258 | 89.7425 | 99.2486 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=3 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 49.2054 | 89.9907 | 99.244 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=4 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 48.1551 | 89.1691 | 98.9134 | ++---------------------+------------+--------------+--------------+ +-- InfluxQL: SELECT PERCENTILE(usage_system, 50), PERCENTILE(usage_system, 90), PERCENTILE(usage_system, 99) FROM cpu WHERE time >= '1970-01-01 00:00:00' AND time < '1970-01-01 03:00:00' GROUP BY time(1h),cpu; +name: cpu +tags: cpu=0 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 49.9884 | 89.7541 | 99.1413 | +| 1970-01-01T01:00:00 | 47.7725 | 90.8035 | 98.8471 | +| 1970-01-01T02:00:00 | 53.5363 | 90.0001 | 98.444 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=1 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 48.2785 | 88.3004 | 98.7959 | +| 1970-01-01T01:00:00 | 51.1512 | 92.2132 | 98.9797 | +| 1970-01-01T02:00:00 | 49.6265 | 87.8342 | 98.0481 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=2 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 50.0065 | 89.5125 | 99.109 | +| 1970-01-01T01:00:00 | 47.9867 | 89.5532 | 99.4226 | +| 1970-01-01T02:00:00 | 49.4459 | 90.439 | 99.2486 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=3 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 46.7256 | 90.7002 | 99.3269 | +| 1970-01-01T01:00:00 | 50.7717 | 89.2459 | 98.9579 | +| 1970-01-01T02:00:00 | 49.6766 | 89.555 | 98.9499 | ++---------------------+------------+--------------+--------------+ +name: cpu +tags: cpu=4 ++---------------------+------------+--------------+--------------+ +| time | percentile | percentile_1 | percentile_2 | ++---------------------+------------+--------------+--------------+ +| 1970-01-01T00:00:00 | 47.403 | 89.0086 | 98.9134 | +| 1970-01-01T01:00:00 | 50.6295 | 89.1826 | 98.9091 | +| 1970-01-01T02:00:00 | 46.1348 | 89.2463 | 98.7592 | ++---------------------+------------+--------------+--------------+ \ No newline at end of file diff --git a/influxdb_iox/tests/query_tests/data/percentile.lp b/influxdb_iox/tests/query_tests/data/percentile.lp new file mode 100644 index 0000000000..220dcf0a3f --- /dev/null +++ b/influxdb_iox/tests/query_tests/data/percentile.lp @@ -0,0 +1,10004 @@ +# Load into influxdb 1.8: +# +# curl localhost:8086/write\?db=percentile --data-binary "@influxdb_iox/tests/query_tests/data/percentile.lp" +# +cpu,cpu=0 usage_idle=84.0188,usage_system=39.4383,usage_user=78.3099 0000000000 +cpu,cpu=1 usage_idle=79.844,usage_system=91.1647,usage_user=19.7551 1000000000 +cpu,cpu=2 usage_idle=33.5223,usage_system=76.823,usage_user=27.7775 2000000000 +cpu,cpu=3 usage_idle=55.397,usage_system=47.7397,usage_user=62.8871 3000000000 +cpu,cpu=4 usage_idle=36.4784,usage_system=51.3401,usage_user=95.223 4000000000 +cpu,cpu=0 usage_idle=91.6195,usage_system=63.5712,usage_user=71.7297 5000000000 +cpu,cpu=1 usage_idle=14.1603,usage_system=60.6969,usage_user=1.63006 6000000000 +cpu,cpu=2 usage_idle=24.2887,usage_system=13.7232,usage_user=80.4177 7000000000 +cpu,cpu=3 usage_idle=15.6679,usage_system=40.0944,usage_user=12.979 8000000000 +cpu,cpu=4 usage_idle=10.8809,usage_system=99.8925,usage_user=21.8257 9000000000 +cpu,cpu=0 usage_idle=51.2932,usage_system=83.9112,usage_user=61.264 10000000000 +cpu,cpu=1 usage_idle=29.6032,usage_system=63.7552,usage_user=52.4287 11000000000 +cpu,cpu=2 usage_idle=49.3583,usage_system=97.2775,usage_user=29.2517 12000000000 +cpu,cpu=3 usage_idle=77.1358,usage_system=52.6745,usage_user=76.9914 13000000000 +cpu,cpu=4 usage_idle=40.0229,usage_system=89.1529,usage_user=28.3315 14000000000 +cpu,cpu=0 usage_idle=35.2458,usage_system=80.7725,usage_user=91.9026 15000000000 +cpu,cpu=1 usage_idle=6.97553,usage_system=94.9327,usage_user=52.5995 16000000000 +cpu,cpu=2 usage_idle=8.60558,usage_system=19.2214,usage_user=66.3227 17000000000 +cpu,cpu=3 usage_idle=89.0233,usage_system=34.8893,usage_user=6.41713 18000000000 +cpu,cpu=4 usage_idle=2.0023,usage_system=45.7702,usage_user=6.30958 19000000000 +cpu,cpu=0 usage_idle=23.828,usage_system=97.0634,usage_user=90.2208 20000000000 +cpu,cpu=1 usage_idle=85.092,usage_system=26.6666,usage_user=53.976 21000000000 +cpu,cpu=2 usage_idle=37.5207,usage_system=76.0249,usage_user=51.2535 22000000000 +cpu,cpu=3 usage_idle=66.7724,usage_system=53.1606,usage_user=3.92803 23000000000 +cpu,cpu=4 usage_idle=43.7638,usage_system=93.1835,usage_user=93.081 24000000000 +cpu,cpu=0 usage_idle=72.0952,usage_system=28.4293,usage_user=73.8534 25000000000 +cpu,cpu=1 usage_idle=63.9979,usage_system=35.4049,usage_user=68.7861 26000000000 +cpu,cpu=2 usage_idle=16.5974,usage_system=44.0105,usage_user=88.0075 27000000000 +cpu,cpu=3 usage_idle=82.9201,usage_system=33.0337,usage_user=22.8968 28000000000 +cpu,cpu=4 usage_idle=89.3372,usage_system=35.036,usage_user=68.667 29000000000 +cpu,cpu=0 usage_idle=95.6468,usage_system=58.864,usage_user=65.7304 30000000000 +cpu,cpu=1 usage_idle=85.8676,usage_system=43.956,usage_user=92.397 31000000000 +cpu,cpu=2 usage_idle=39.8437,usage_system=81.4767,usage_user=68.4219 32000000000 +cpu,cpu=3 usage_idle=91.0972,usage_system=48.2491,usage_user=21.5825 33000000000 +cpu,cpu=4 usage_idle=95.0252,usage_system=92.0128,usage_user=14.766 34000000000 +cpu,cpu=0 usage_idle=88.1062,usage_system=64.1081,usage_user=43.1953 35000000000 +cpu,cpu=1 usage_idle=61.9596,usage_system=28.1059,usage_user=78.6002 36000000000 +cpu,cpu=2 usage_idle=30.7458,usage_system=44.7034,usage_user=22.6107 37000000000 +cpu,cpu=3 usage_idle=18.7533,usage_system=27.6235,usage_user=55.6444 38000000000 +cpu,cpu=4 usage_idle=41.6501,usage_system=16.9607,usage_user=90.6804 39000000000 +cpu,cpu=0 usage_idle=10.3171,usage_system=12.6075,usage_user=49.5444 40000000000 +cpu,cpu=1 usage_idle=76.0475,usage_system=98.4752,usage_user=93.5004 41000000000 +cpu,cpu=2 usage_idle=68.4445,usage_system=38.3188,usage_user=74.9771 42000000000 +cpu,cpu=3 usage_idle=36.8664,usage_system=29.416,usage_user=23.2262 43000000000 +cpu,cpu=4 usage_idle=58.4489,usage_system=24.4413,usage_user=15.239 44000000000 +cpu,cpu=0 usage_idle=73.2149,usage_system=12.5475,usage_user=79.347 45000000000 +cpu,cpu=1 usage_idle=16.4102,usage_system=74.5071,usage_user=7.45298 46000000000 +cpu,cpu=2 usage_idle=95.0104,usage_system=5.25293,usage_user=52.1563 47000000000 +cpu,cpu=3 usage_idle=17.6211,usage_system=24.0062,usage_user=79.7798 48000000000 +cpu,cpu=4 usage_idle=73.2654,usage_system=65.6564,usage_user=96.7405 49000000000 +cpu,cpu=0 usage_idle=63.9458,usage_system=75.9735,usage_user=9.34805 50000000000 +cpu,cpu=1 usage_idle=13.4902,usage_system=52.021,usage_user=7.82321 51000000000 +cpu,cpu=2 usage_idle=6.99064,usage_system=20.4655,usage_user=46.142 52000000000 +cpu,cpu=3 usage_idle=81.9677,usage_system=57.3319,usage_user=75.5581 53000000000 +cpu,cpu=4 usage_idle=5.19388,usage_system=15.7807,usage_user=99.9994 54000000000 +cpu,cpu=0 usage_idle=20.4329,usage_system=88.9956,usage_user=12.5468 55000000000 +cpu,cpu=1 usage_idle=99.7799,usage_system=5.40576,usage_user=87.054 56000000000 +cpu,cpu=2 usage_idle=7.23288,usage_system=0.416161,usage_user=92.3069 57000000000 +cpu,cpu=3 usage_idle=59.3892,usage_system=18.0372,usage_user=16.3131 58000000000 +cpu,cpu=4 usage_idle=39.169,usage_system=91.3027,usage_user=81.9695 59000000000 +cpu,cpu=0 usage_idle=35.9095,usage_system=55.2485,usage_user=57.943 60000000000 +cpu,cpu=1 usage_idle=45.2576,usage_system=68.7387,usage_user=9.96401 61000000000 +cpu,cpu=2 usage_idle=53.0808,usage_system=75.7294,usage_user=30.4295 62000000000 +cpu,cpu=3 usage_idle=99.2228,usage_system=57.6971,usage_user=87.7614 63000000000 +cpu,cpu=4 usage_idle=74.7809,usage_system=62.891,usage_user=3.54209 64000000000 +cpu,cpu=0 usage_idle=74.7803,usage_system=83.3239,usage_user=92.5377 65000000000 +cpu,cpu=1 usage_idle=87.3271,usage_system=83.1038,usage_user=97.9434 66000000000 +cpu,cpu=2 usage_idle=74.3811,usage_system=90.3366,usage_user=98.3596 67000000000 +cpu,cpu=3 usage_idle=66.688,usage_system=49.7259,usage_user=16.3968 68000000000 +cpu,cpu=4 usage_idle=83.0012,usage_system=88.8949,usage_user=7.69947 69000000000 +cpu,cpu=0 usage_idle=64.9707,usage_system=24.8044,usage_user=62.948 70000000000 +cpu,cpu=1 usage_idle=22.9137,usage_system=70.062,usage_user=31.6867 71000000000 +cpu,cpu=2 usage_idle=32.8777,usage_system=23.1428,usage_user=7.4161 72000000000 +cpu,cpu=3 usage_idle=63.3072,usage_system=22.3656,usage_user=65.1132 73000000000 +cpu,cpu=4 usage_idle=51.0686,usage_system=97.1466,usage_user=28.0042 74000000000 +cpu,cpu=0 usage_idle=54.6107,usage_system=71.9269,usage_user=11.3281 75000000000 +cpu,cpu=1 usage_idle=47.1483,usage_system=59.254,usage_user=94.4318 76000000000 +cpu,cpu=2 usage_idle=45.0918,usage_system=33.6351,usage_user=84.7684 77000000000 +cpu,cpu=3 usage_idle=43.4513,usage_system=0.323146,usage_user=34.4943 78000000000 +cpu,cpu=4 usage_idle=59.8481,usage_system=83.3243,usage_user=23.3892 79000000000 +cpu,cpu=0 usage_idle=67.5476,usage_system=48.295,usage_user=48.1936 80000000000 +cpu,cpu=1 usage_idle=30.4956,usage_system=71.2087,usage_user=18.2556 81000000000 +cpu,cpu=2 usage_idle=62.1823,usage_system=4.08643,usage_user=41.3984 82000000000 +cpu,cpu=3 usage_idle=69.5984,usage_system=67.3936,usage_user=63.764 83000000000 +cpu,cpu=4 usage_idle=34.7116,usage_system=18.4622,usage_user=60.9106 84000000000 +cpu,cpu=0 usage_idle=62.7158,usage_system=73.0729,usage_user=32.8374 85000000000 +cpu,cpu=1 usage_idle=74.0438,usage_system=20.2213,usage_user=92.0914 86000000000 +cpu,cpu=2 usage_idle=68.4757,usage_system=65.313,usage_user=25.7265 87000000000 +cpu,cpu=3 usage_idle=53.2441,usage_system=8.76436,usage_user=26.0497 88000000000 +cpu,cpu=4 usage_idle=87.7384,usage_system=68.6125,usage_user=9.37402 89000000000 +cpu,cpu=0 usage_idle=11.1276,usage_system=36.1601,usage_user=57.6691 90000000000 +cpu,cpu=1 usage_idle=59.3211,usage_system=66.6557,usage_user=28.8778 91000000000 +cpu,cpu=2 usage_idle=77.5767,usage_system=28.8379,usage_user=32.9642 92000000000 +cpu,cpu=3 usage_idle=18.9751,usage_system=98.4363,usage_user=0.357857 93000000000 +cpu,cpu=4 usage_idle=82.7391,usage_system=33.1479,usage_user=18.8201 94000000000 +cpu,cpu=0 usage_idle=43.6497,usage_system=95.8637,usage_user=91.893 95000000000 +cpu,cpu=1 usage_idle=76.4871,usage_system=69.9075,usage_user=12.1143 96000000000 +cpu,cpu=2 usage_idle=68.5786,usage_system=38.3832,usage_user=77.4273 97000000000 +cpu,cpu=3 usage_idle=94.3051,usage_system=91.6273,usage_user=86.1917 98000000000 +cpu,cpu=4 usage_idle=20.3548,usage_system=79.3657,usage_user=54.8042 99000000000 +cpu,cpu=0 usage_idle=29.7288,usage_system=90.4932,usage_user=90.9643 100000000000 +cpu,cpu=1 usage_idle=87.3979,usage_system=49.8144,usage_user=57.62 101000000000 +cpu,cpu=2 usage_idle=16.2757,usage_system=27.3911,usage_user=86.4579 102000000000 +cpu,cpu=3 usage_idle=49.2399,usage_system=46.3662,usage_user=84.8942 103000000000 +cpu,cpu=4 usage_idle=49.5977,usage_system=29.1053,usage_user=18.0421 104000000000 +cpu,cpu=0 usage_idle=68.4178,usage_system=72.755,usage_user=13.9058 105000000000 +cpu,cpu=1 usage_idle=60.3109,usage_system=49.2422,usage_user=83.8134 106000000000 +cpu,cpu=2 usage_idle=72.4252,usage_system=17.8208,usage_user=22.1966 107000000000 +cpu,cpu=3 usage_idle=49.8525,usage_system=12.1259,usage_user=13.8238 108000000000 +cpu,cpu=4 usage_idle=36.0443,usage_system=32.4807,usage_user=93.1895 109000000000 +cpu,cpu=0 usage_idle=90.8485,usage_system=62.2095,usage_user=83.6828 110000000000 +cpu,cpu=1 usage_idle=81.8128,usage_system=49.6074,usage_user=33.4972 111000000000 +cpu,cpu=2 usage_idle=39.4327,usage_system=65.8831,usage_user=60.8883 112000000000 +cpu,cpu=3 usage_idle=25.8906,usage_system=15.123,usage_user=7.2545 113000000000 +cpu,cpu=4 usage_idle=10.7848,usage_system=64.7207,usage_user=36.3598 114000000000 +cpu,cpu=0 usage_idle=28.827,usage_system=33.1386,usage_user=9.11486 115000000000 +cpu,cpu=1 usage_idle=42.7328,usage_system=93.4495,usage_user=58.357 116000000000 +cpu,cpu=2 usage_idle=26.5461,usage_system=65.8747,usage_user=76.1778 117000000000 +cpu,cpu=3 usage_idle=48.7427,usage_system=15.7272,usage_user=88.3037 118000000000 +cpu,cpu=4 usage_idle=62.5665,usage_system=51.7715,usage_user=20.7844 119000000000 +cpu,cpu=0 usage_idle=55.7561,usage_system=42.6199,usage_user=82.9939 120000000000 +cpu,cpu=1 usage_idle=39.4388,usage_system=24.4327,usage_user=32.6013 121000000000 +cpu,cpu=2 usage_idle=72.936,usage_system=63.8654,usage_user=98.4845 122000000000 +cpu,cpu=3 usage_idle=33.8243,usage_system=89.756,usage_user=13.6075 123000000000 +cpu,cpu=4 usage_idle=41.0788,usage_system=0.540855,usage_user=78.3282 124000000000 +cpu,cpu=0 usage_idle=77.4386,usage_system=29.3678,usage_user=11.4668 125000000000 +cpu,cpu=1 usage_idle=86.5535,usage_system=72.1006,usage_user=4.91625 126000000000 +cpu,cpu=2 usage_idle=44.9105,usage_system=98.6467,usage_user=70.7909 127000000000 +cpu,cpu=3 usage_idle=21.0883,usage_system=47.3894,usage_user=86.5181 128000000000 +cpu,cpu=4 usage_idle=9.39195,usage_system=9.95593,usage_user=38.2896 129000000000 +cpu,cpu=0 usage_idle=30.1763,usage_system=65.712,usage_user=80.9095 130000000000 +cpu,cpu=1 usage_idle=13.1702,usage_system=5.15083,usage_user=5.34223 131000000000 +cpu,cpu=2 usage_idle=45.7716,usage_system=78.0868,usage_user=69.2076 132000000000 +cpu,cpu=3 usage_idle=44.256,usage_system=11.9111,usage_user=58.9637 133000000000 +cpu,cpu=4 usage_idle=57.8635,usage_system=52.9899,usage_user=59.5045 134000000000 +cpu,cpu=0 usage_idle=36.1917,usage_system=30.4285,usage_user=88.8723 135000000000 +cpu,cpu=1 usage_idle=47.6585,usage_system=16.982,usage_user=60.9729 136000000000 +cpu,cpu=2 usage_idle=52.5747,usage_system=61.8925,usage_user=59.6196 137000000000 +cpu,cpu=3 usage_idle=23.3656,usage_system=82.9808,usage_user=7.00902 138000000000 +cpu,cpu=4 usage_idle=9.88374,usage_system=92.3728,usage_user=16.965 139000000000 +cpu,cpu=0 usage_idle=48.1733,usage_system=22.5491,usage_user=82.6769 140000000000 +cpu,cpu=1 usage_idle=29.0829,usage_system=35.7193,usage_user=87.8278 141000000000 +cpu,cpu=2 usage_idle=34.4251,usage_system=81.4909,usage_user=65.9146 142000000000 +cpu,cpu=3 usage_idle=3.63274,usage_system=25.7469,usage_user=77.8257 143000000000 +cpu,cpu=4 usage_idle=62.5964,usage_system=83.6104,usage_user=30.8157 144000000000 +cpu,cpu=0 usage_idle=22.1009,usage_system=19.8021,usage_user=61.2442 145000000000 +cpu,cpu=1 usage_idle=10.9733,usage_system=67.4605,usage_user=78.2262 146000000000 +cpu,cpu=2 usage_idle=71.9462,usage_system=20.0352,usage_user=40.1188 147000000000 +cpu,cpu=3 usage_idle=31.5658,usage_system=43.4009,usage_user=23.0996 148000000000 +cpu,cpu=4 usage_idle=38.5748,usage_system=53.2846,usage_user=15.4724 149000000000 +cpu,cpu=0 usage_idle=55.5398,usage_system=1.45793,usage_user=38.0215 150000000000 +cpu,cpu=1 usage_idle=38.2167,usage_system=30.5408,usage_user=73.7408 151000000000 +cpu,cpu=2 usage_idle=26.0445,usage_system=64.9659,usage_user=55.2316 152000000000 +cpu,cpu=3 usage_idle=91.9591,usage_system=68.5986,usage_user=80.9785 153000000000 +cpu,cpu=4 usage_idle=69.7848,usage_system=31.195,usage_user=64.5889 154000000000 +cpu,cpu=0 usage_idle=0.600477,usage_system=53.296,usage_user=84.391 155000000000 +cpu,cpu=1 usage_idle=61.8447,usage_system=64.2693,usage_user=51.8515 156000000000 +cpu,cpu=2 usage_idle=40.0709,usage_system=36.2154,usage_user=71.8867 157000000000 +cpu,cpu=3 usage_idle=80.1897,usage_system=67.7812,usage_user=15.2876 158000000000 +cpu,cpu=4 usage_idle=3.28927,usage_system=6.35606,usage_user=68.5722 159000000000 +cpu,cpu=0 usage_idle=18.7616,usage_system=61.8958,usage_user=70.0301 160000000000 +cpu,cpu=1 usage_idle=56.7831,usage_system=0.112548,usage_user=0.570914 161000000000 +cpu,cpu=2 usage_idle=30.5239,usage_system=26.157,usage_user=65.5368 162000000000 +cpu,cpu=3 usage_idle=85.7555,usage_system=18.1161,usage_user=34.1354 163000000000 +cpu,cpu=4 usage_idle=66.7341,usage_system=87.9009,usage_user=65.3305 164000000000 +cpu,cpu=0 usage_idle=31.323,usage_system=88.5014,usage_user=18.6265 165000000000 +cpu,cpu=1 usage_idle=15.7139,usage_system=50.3461,usage_user=82.8957 166000000000 +cpu,cpu=2 usage_idle=67.5654,usage_system=90.417,usage_user=19.1112 167000000000 +cpu,cpu=3 usage_idle=39.4521,usage_system=70.6067,usage_user=86.8924 168000000000 +cpu,cpu=4 usage_idle=54.7397,usage_system=73.8959,usage_user=93.2485 169000000000 +cpu,cpu=0 usage_idle=23.3119,usage_system=92.6576,usage_user=55.1443 170000000000 +cpu,cpu=1 usage_idle=93.342,usage_system=49.4407,usage_user=55.2568 171000000000 +cpu,cpu=2 usage_idle=93.9129,usage_system=79.9646,usage_user=81.4139 172000000000 +cpu,cpu=3 usage_idle=59.4497,usage_system=65.7201,usage_user=99.53 173000000000 +cpu,cpu=4 usage_idle=93.5852,usage_system=32.4541,usage_user=87.4309 174000000000 +cpu,cpu=0 usage_idle=58.9157,usage_system=63.7771,usage_user=75.9324 175000000000 +cpu,cpu=1 usage_idle=77.5421,usage_system=79.491,usage_user=26.2785 176000000000 +cpu,cpu=2 usage_idle=60.4379,usage_system=47.0564,usage_user=16.6955 177000000000 +cpu,cpu=3 usage_idle=79.549,usage_system=86.5086,usage_user=87.3021 178000000000 +cpu,cpu=4 usage_idle=66.4414,usage_system=41.2483,usage_user=61.1981 179000000000 +cpu,cpu=0 usage_idle=59.6899,usage_system=64.5601,usage_user=53.8557 180000000000 +cpu,cpu=1 usage_idle=14.8342,usage_system=57.9022,usage_user=3.29634 181000000000 +cpu,cpu=2 usage_idle=70.091,usage_system=51.8151,usage_user=83.2609 182000000000 +cpu,cpu=3 usage_idle=51.5049,usage_system=11.2648,usage_user=48.981 183000000000 +cpu,cpu=4 usage_idle=51.0349,usage_system=4.84997,usage_user=81.4351 184000000000 +cpu,cpu=0 usage_idle=38.4658,usage_system=63.7656,usage_user=45.2122 185000000000 +cpu,cpu=1 usage_idle=14.3982,usage_system=41.3078,usage_user=24.7033 186000000000 +cpu,cpu=2 usage_idle=40.6767,usage_system=1.74566,usage_user=71.7597 187000000000 +cpu,cpu=3 usage_idle=57.3721,usage_system=81.2947,usage_user=58.2682 188000000000 +cpu,cpu=4 usage_idle=44.6743,usage_system=47.7361,usage_user=99.5165 189000000000 +cpu,cpu=0 usage_idle=5.87232,usage_system=7.42604,usage_user=64.0766 190000000000 +cpu,cpu=1 usage_idle=59.728,usage_system=22.2602,usage_user=21.9788 191000000000 +cpu,cpu=2 usage_idle=63.0243,usage_system=92.3513,usage_user=73.7939 192000000000 +cpu,cpu=3 usage_idle=46.2852,usage_system=43.8562,usage_user=85.0586 193000000000 +cpu,cpu=4 usage_idle=95.2662,usage_system=94.8911,usage_user=89.9086 194000000000 +cpu,cpu=0 usage_idle=76.7014,usage_system=33.3569,usage_user=53.6742 195000000000 +cpu,cpu=1 usage_idle=21.9136,usage_system=47.7551,usage_user=94.982 196000000000 +cpu,cpu=2 usage_idle=46.6169,usage_system=88.4318,usage_user=96.7277 197000000000 +cpu,cpu=3 usage_idle=18.3765,usage_system=45.8039,usage_user=78.0224 198000000000 +cpu,cpu=4 usage_idle=76.6448,usage_system=90.4782,usage_user=25.7585 199000000000 +cpu,cpu=0 usage_idle=76.1612,usage_system=96.3505,usage_user=33.1846 200000000000 +cpu,cpu=1 usage_idle=40.2379,usage_system=56.0785,usage_user=55.4448 201000000000 +cpu,cpu=2 usage_idle=62.2167,usage_system=19.1028,usage_user=47.7961 202000000000 +cpu,cpu=3 usage_idle=36.0105,usage_system=65.388,usage_user=91.6523 203000000000 +cpu,cpu=4 usage_idle=21.0692,usage_system=60.6542,usage_user=86.5434 204000000000 +cpu,cpu=0 usage_idle=10.9778,usage_system=37.3556,usage_user=19.9003 205000000000 +cpu,cpu=1 usage_idle=64.652,usage_system=59.2692,usage_user=67.6554 206000000000 +cpu,cpu=2 usage_idle=59.6341,usage_system=5.88605,usage_user=56.0872 207000000000 +cpu,cpu=3 usage_idle=56.3617,usage_system=24.2626,usage_user=1.89108 208000000000 +cpu,cpu=4 usage_idle=34.3841,usage_system=0.907344,usage_user=92.3692 209000000000 +cpu,cpu=0 usage_idle=60.1427,usage_system=77.0686,usage_user=88.7197 210000000000 +cpu,cpu=1 usage_idle=93.3273,usage_system=17.3065,usage_user=44.7982 211000000000 +cpu,cpu=2 usage_idle=48.7721,usage_system=79.5231,usage_user=63.9009 212000000000 +cpu,cpu=3 usage_idle=96.5682,usage_system=15.5336,usage_user=29.2889 213000000000 +cpu,cpu=4 usage_idle=88.2204,usage_system=36.6028,usage_user=89.9431 214000000000 +cpu,cpu=0 usage_idle=74.7638,usage_system=47.5806,usage_user=27.2987 215000000000 +cpu,cpu=1 usage_idle=94.664,usage_system=12.2326,usage_user=86.5679 216000000000 +cpu,cpu=2 usage_idle=62.3194,usage_system=71.8666,usage_user=92.454 217000000000 +cpu,cpu=3 usage_idle=18.4066,usage_system=28.2284,usage_user=16.7165 218000000000 +cpu,cpu=4 usage_idle=20.2977,usage_system=62.6125,usage_user=17.6239 219000000000 +cpu,cpu=0 usage_idle=12.6669,usage_system=22.7552,usage_user=94.6925 220000000000 +cpu,cpu=1 usage_idle=1.38663,usage_system=16.0824,usage_user=11.9989 221000000000 +cpu,cpu=2 usage_idle=46.1848,usage_system=64.8545,usage_user=91.5221 222000000000 +cpu,cpu=3 usage_idle=10.0857,usage_system=61.4227,usage_user=7.0557 223000000000 +cpu,cpu=4 usage_idle=39.3746,usage_system=49.6431,usage_user=43.6585 224000000000 +cpu,cpu=0 usage_idle=29.3177,usage_system=24.4069,usage_user=91.2391 225000000000 +cpu,cpu=1 usage_idle=56.6164,usage_system=19.0709,usage_user=3.47164 226000000000 +cpu,cpu=2 usage_idle=43.1844,usage_system=81.3904,usage_user=75.3383 227000000000 +cpu,cpu=3 usage_idle=35.6383,usage_system=99.797,usage_user=3.56664 228000000000 +cpu,cpu=4 usage_idle=52.3548,usage_system=20.0947,usage_user=66.1792 229000000000 +cpu,cpu=0 usage_idle=69.9787,usage_system=32.7616,usage_user=88.9343 230000000000 +cpu,cpu=1 usage_idle=64.6712,usage_system=34.1482,usage_user=5.01679 231000000000 +cpu,cpu=2 usage_idle=76.6701,usage_system=80.333,usage_user=69.8713 232000000000 +cpu,cpu=3 usage_idle=68.1922,usage_system=90.4187,usage_user=31.294 233000000000 +cpu,cpu=4 usage_idle=75.2479,usage_system=29.7933,usage_user=80.9371 234000000000 +cpu,cpu=0 usage_idle=18.9064,usage_system=59.1111,usage_user=5.34394 235000000000 +cpu,cpu=1 usage_idle=10.1454,usage_system=15.7275,usage_user=24.4149 236000000000 +cpu,cpu=2 usage_idle=13.6171,usage_system=58.9119,usage_user=5.80523 237000000000 +cpu,cpu=3 usage_idle=88.9553,usage_system=94.5502,usage_user=5.60222 238000000000 +cpu,cpu=4 usage_idle=92.522,usage_system=46.905,usage_user=25.6969 239000000000 +cpu,cpu=0 usage_idle=58.7011,usage_system=16.8837,usage_user=58.4585 240000000000 +cpu,cpu=1 usage_idle=47.6355,usage_system=81.5549,usage_user=92.6068 241000000000 +cpu,cpu=2 usage_idle=52.6523,usage_system=58.225,usage_user=72.9398 242000000000 +cpu,cpu=3 usage_idle=22.5236,usage_system=26.4172,usage_user=63.3585 243000000000 +cpu,cpu=4 usage_idle=53.8175,usage_system=1.66506,usage_user=93.1518 244000000000 +cpu,cpu=0 usage_idle=34.7546,usage_system=20.5714,usage_user=52.2629 245000000000 +cpu,cpu=1 usage_idle=40.0985,usage_system=30.7168,usage_user=67.9904 246000000000 +cpu,cpu=2 usage_idle=64.5134,usage_system=44.3339,usage_user=26.9022 247000000000 +cpu,cpu=3 usage_idle=70.3186,usage_system=33.2892,usage_user=21.4524 248000000000 +cpu,cpu=4 usage_idle=75.9208,usage_system=25.8112,usage_user=68.3574 249000000000 +cpu,cpu=0 usage_idle=1.61775,usage_system=84.5123,usage_user=85.2411 250000000000 +cpu,cpu=1 usage_idle=60.0763,usage_system=32.1478,usage_user=66.796 251000000000 +cpu,cpu=2 usage_idle=52.683,usage_system=84.8,usage_user=25.021 252000000000 +cpu,cpu=3 usage_idle=25.6228,usage_system=7.32357,usage_user=51.4382 253000000000 +cpu,cpu=4 usage_idle=88.9813,usage_system=61.1411,usage_user=53.1033 254000000000 +cpu,cpu=0 usage_idle=82.1331,usage_system=95.8957,usage_user=73.6747 255000000000 +cpu,cpu=1 usage_idle=34.3959,usage_system=35.9942,usage_user=4.39153 256000000000 +cpu,cpu=2 usage_idle=2.38632,usage_system=0.50762,usage_user=48.7254 257000000000 +cpu,cpu=3 usage_idle=29.2886,usage_system=70.8262,usage_user=82.0146 258000000000 +cpu,cpu=4 usage_idle=50.741,usage_system=46.7471,usage_user=7.82579 259000000000 +cpu,cpu=0 usage_idle=19.0984,usage_system=48.3648,usage_user=92.3381 260000000000 +cpu,cpu=1 usage_idle=4.33947,usage_system=8.4411,usage_user=24.4858 261000000000 +cpu,cpu=2 usage_idle=71.1355,usage_system=61.1241,usage_user=9.28584 262000000000 +cpu,cpu=3 usage_idle=96.1565,usage_system=86.7469,usage_user=16.6094 263000000000 +cpu,cpu=4 usage_idle=47.5947,usage_system=75.7282,usage_user=77.7505 264000000000 +cpu,cpu=0 usage_idle=0.698012,usage_system=57.8613,usage_user=73.6462 265000000000 +cpu,cpu=1 usage_idle=74.3727,usage_system=92.2572,usage_user=9.64041 266000000000 +cpu,cpu=2 usage_idle=78.7642,usage_system=94.6435,usage_user=10.148 267000000000 +cpu,cpu=3 usage_idle=27.4897,usage_system=23.9321,usage_user=80.9743 268000000000 +cpu,cpu=4 usage_idle=9.50427,usage_system=74.673,usage_user=27.7214 269000000000 +cpu,cpu=0 usage_idle=17.3301,usage_system=93.7714,usage_user=76.0862 270000000000 +cpu,cpu=1 usage_idle=9.66814,usage_system=98.1109,usage_user=84.5273 271000000000 +cpu,cpu=2 usage_idle=34.154,usage_system=69.2463,usage_user=45.6514 272000000000 +cpu,cpu=3 usage_idle=43.4398,usage_system=65.4029,usage_user=32.3983 273000000000 +cpu,cpu=4 usage_idle=60.0492,usage_system=12.9976,usage_user=8.1265 274000000000 +cpu,cpu=0 usage_idle=37.7997,usage_system=13.6956,usage_user=65.9878 275000000000 +cpu,cpu=1 usage_idle=11.4459,usage_system=88.0683,usage_user=58.245 276000000000 +cpu,cpu=2 usage_idle=21.0863,usage_system=66.8326,usage_user=52.8885 277000000000 +cpu,cpu=3 usage_idle=31.2343,usage_system=94.3222,usage_user=76.8206 278000000000 +cpu,cpu=4 usage_idle=12.2086,usage_system=3.82648,usage_user=51.4936 279000000000 +cpu,cpu=0 usage_idle=39.93,usage_system=21.1565,usage_user=45.265 280000000000 +cpu,cpu=1 usage_idle=16.0162,usage_system=30.8247,usage_user=43.3758 281000000000 +cpu,cpu=2 usage_idle=0.543489,usage_system=64.9787,usage_user=12.6222 282000000000 +cpu,cpu=3 usage_idle=46.1949,usage_system=8.41846,usage_user=78.0251 283000000000 +cpu,cpu=4 usage_idle=78.5932,usage_system=68.4677,usage_user=91.0227 284000000000 +cpu,cpu=0 usage_idle=86.7197,usage_system=6.26739,usage_user=4.71826 285000000000 +cpu,cpu=1 usage_idle=52.7075,usage_system=17.7133,usage_user=92.7866 286000000000 +cpu,cpu=2 usage_idle=10.9525,usage_system=38.7996,usage_user=59.6191 287000000000 +cpu,cpu=3 usage_idle=63.8409,usage_system=70.034,usage_user=53.9413 288000000000 +cpu,cpu=4 usage_idle=40.6615,usage_system=82.2426,usage_user=57.7678 289000000000 +cpu,cpu=0 usage_idle=92.1551,usage_system=22.1726,usage_user=78.9244 290000000000 +cpu,cpu=1 usage_idle=37.4201,usage_system=38.1888,usage_user=9.74906 291000000000 +cpu,cpu=2 usage_idle=80.7959,usage_system=38.7323,usage_user=74.7277 292000000000 +cpu,cpu=3 usage_idle=93.4181,usage_system=84.9272,usage_user=83.1462 293000000000 +cpu,cpu=4 usage_idle=71.4432,usage_system=63.5204,usage_user=51.6139 294000000000 +cpu,cpu=0 usage_idle=62.4658,usage_system=50.2401,usage_user=57.8813 295000000000 +cpu,cpu=1 usage_idle=67.1841,usage_system=2.94762,usage_user=75.5945 296000000000 +cpu,cpu=2 usage_idle=59.9707,usage_system=13.9001,usage_user=14.3942 297000000000 +cpu,cpu=3 usage_idle=19.5898,usage_system=77.741,usage_user=84.4281 298000000000 +cpu,cpu=4 usage_idle=73.5311,usage_system=18.4025,usage_user=66.6707 299000000000 +cpu,cpu=0 usage_idle=31.299,usage_system=10.5576,usage_user=88.8433 300000000000 +cpu,cpu=1 usage_idle=10.2233,usage_system=47.9777,usage_user=27.0321 301000000000 +cpu,cpu=2 usage_idle=19.9724,usage_system=28.7736,usage_user=65.7643 302000000000 +cpu,cpu=3 usage_idle=94.7001,usage_system=22.1918,usage_user=50.6915 303000000000 +cpu,cpu=4 usage_idle=77.8463,usage_system=93.6349,usage_user=14.2119 304000000000 +cpu,cpu=0 usage_idle=29.4601,usage_system=56.1007,usage_user=64.452 305000000000 +cpu,cpu=1 usage_idle=87.3414,usage_system=23.2848,usage_user=67.3996 306000000000 +cpu,cpu=2 usage_idle=62.9359,usage_system=83.2555,usage_user=81.2997 307000000000 +cpu,cpu=3 usage_idle=77.3301,usage_system=2.84525,usage_user=59.0407 308000000000 +cpu,cpu=4 usage_idle=61.7582,usage_system=76.3764,usage_user=77.4432 309000000000 +cpu,cpu=0 usage_idle=28.4289,usage_system=7.67534,usage_user=88.0009 310000000000 +cpu,cpu=1 usage_idle=17.2722,usage_system=17.8987,usage_user=35.9786 311000000000 +cpu,cpu=2 usage_idle=44.3043,usage_system=37.871,usage_user=64.7522 312000000000 +cpu,cpu=3 usage_idle=10.0686,usage_system=32.5711,usage_user=86.944 313000000000 +cpu,cpu=4 usage_idle=60.76,usage_system=10.4174,usage_user=80.5789 314000000000 +cpu,cpu=0 usage_idle=74.9719,usage_system=39.8775,usage_user=36.6796 315000000000 +cpu,cpu=1 usage_idle=39.4239,usage_system=27.2189,usage_user=59.9644 316000000000 +cpu,cpu=2 usage_idle=6.82348,usage_system=90.1549,usage_user=43.2199 317000000000 +cpu,cpu=3 usage_idle=88.1232,usage_system=67.485,usage_user=46.0652 318000000000 +cpu,cpu=4 usage_idle=47.1639,usage_system=29.2432,usage_user=22.4415 319000000000 +cpu,cpu=0 usage_idle=24.6071,usage_system=57.6721,usage_user=30.1169 320000000000 +cpu,cpu=1 usage_idle=12.608,usage_system=74.9443,usage_user=48.0156 321000000000 +cpu,cpu=2 usage_idle=48.5866,usage_system=19.2486,usage_user=85.8866 322000000000 +cpu,cpu=3 usage_idle=13.3388,usage_system=29.3171,usage_user=18.4577 323000000000 +cpu,cpu=4 usage_idle=0.282779,usage_system=90.0772,usage_user=28.8752 324000000000 +cpu,cpu=0 usage_idle=80.8617,usage_system=65.0491,usage_user=68.7527 325000000000 +cpu,cpu=1 usage_idle=17.5413,usage_system=4.47295,usage_user=95.9716 326000000000 +cpu,cpu=2 usage_idle=77.5058,usage_system=11.2964,usage_user=86.1265 327000000000 +cpu,cpu=3 usage_idle=20.7257,usage_system=99.4196,usage_user=53.6115 328000000000 +cpu,cpu=4 usage_idle=66.7908,usage_system=46.5835,usage_user=82.8546 329000000000 +cpu,cpu=0 usage_idle=89.2324,usage_system=71.1906,usage_user=40.5267 330000000000 +cpu,cpu=1 usage_idle=19.3493,usage_system=83.7986,usage_user=15.4711 331000000000 +cpu,cpu=2 usage_idle=67.3648,usage_system=32.3852,usage_user=34.7196 332000000000 +cpu,cpu=3 usage_idle=53.2514,usage_system=45.724,usage_user=64.0368 333000000000 +cpu,cpu=4 usage_idle=71.7092,usage_system=46.0067,usage_user=54.114 334000000000 +cpu,cpu=0 usage_idle=0.584319,usage_system=26.8684,usage_user=19.163 335000000000 +cpu,cpu=1 usage_idle=69.337,usage_system=44.4097,usage_user=23.636 336000000000 +cpu,cpu=2 usage_idle=65.3087,usage_system=21.9155,usage_user=34.9324 337000000000 +cpu,cpu=3 usage_idle=51.4352,usage_system=42.6412,usage_user=34.352 338000000000 +cpu,cpu=4 usage_idle=5.04663,usage_system=9.43199,usage_user=80.9355 339000000000 +cpu,cpu=0 usage_idle=87.9013,usage_system=98.6644,usage_user=52.1261 340000000000 +cpu,cpu=1 usage_idle=28.428,usage_system=18.0136,usage_user=35.9247 341000000000 +cpu,cpu=2 usage_idle=43.899,usage_system=85.3785,usage_user=68.3098 342000000000 +cpu,cpu=3 usage_idle=78.6187,usage_system=38.6299,usage_user=14.0338 343000000000 +cpu,cpu=4 usage_idle=42.6555,usage_system=10.339,usage_user=60.0405 344000000000 +cpu,cpu=0 usage_idle=96.7694,usage_system=10.9233,usage_user=86.909 345000000000 +cpu,cpu=1 usage_idle=15.9324,usage_system=80.2604,usage_user=31.3187 346000000000 +cpu,cpu=2 usage_idle=39.5684,usage_system=45.569,usage_user=53.2342 347000000000 +cpu,cpu=3 usage_idle=74.5008,usage_system=97.0042,usage_user=95.8753 348000000000 +cpu,cpu=4 usage_idle=8.85283,usage_system=2.05084,usage_user=5.30733 349000000000 +cpu,cpu=0 usage_idle=89.7883,usage_system=89.9521,usage_user=3.9717 350000000000 +cpu,cpu=1 usage_idle=41.9144,usage_system=18.3801,usage_user=21.9853 351000000000 +cpu,cpu=2 usage_idle=77.8391,usage_system=62.2791,usage_user=7.36379 352000000000 +cpu,cpu=3 usage_idle=46.1489,usage_system=40.8978,usage_user=45.9937 353000000000 +cpu,cpu=4 usage_idle=60.1827,usage_system=83.5533,usage_user=56.3327 354000000000 +cpu,cpu=0 usage_idle=20.2232,usage_system=80.3227,usage_user=67.256 355000000000 +cpu,cpu=1 usage_idle=7.1322,usage_system=96.2551,usage_user=47.5164 356000000000 +cpu,cpu=2 usage_idle=38.4509,usage_system=35.8235,usage_user=93.0854 357000000000 +cpu,cpu=3 usage_idle=91.6851,usage_system=10.3244,usage_user=90.0896 358000000000 +cpu,cpu=4 usage_idle=87.5604,usage_system=19.1772,usage_user=92.1405 359000000000 +cpu,cpu=0 usage_idle=92.8678,usage_system=8.9655,usage_user=82.0926 360000000000 +cpu,cpu=1 usage_idle=96.8395,usage_system=50.8799,usage_user=0.472651 361000000000 +cpu,cpu=2 usage_idle=18.8248,usage_system=28.7189,usage_user=62.7518 362000000000 +cpu,cpu=3 usage_idle=26.1886,usage_system=74.8678,usage_user=3.64959 363000000000 +cpu,cpu=4 usage_idle=72.1822,usage_system=35.0505,usage_user=87.2028 364000000000 +cpu,cpu=0 usage_idle=28.5149,usage_system=55.2738,usage_user=67.5255 365000000000 +cpu,cpu=1 usage_idle=95.7709,usage_system=62.406,usage_user=63.7806 366000000000 +cpu,cpu=2 usage_idle=43.2873,usage_system=0.856861,usage_user=99.6042 367000000000 +cpu,cpu=3 usage_idle=36.3727,usage_system=92.542,usage_user=9.92851 368000000000 +cpu,cpu=4 usage_idle=26.4624,usage_system=80.1024,usage_user=29.1057 369000000000 +cpu,cpu=0 usage_idle=18.6029,usage_system=72.9702,usage_user=38.0712 370000000000 +cpu,cpu=1 usage_idle=0.695418,usage_system=69.8096,usage_user=88.9511 371000000000 +cpu,cpu=2 usage_idle=1.16807,usage_system=88.6344,usage_user=17.67 372000000000 +cpu,cpu=3 usage_idle=63.9199,usage_system=14.823,usage_user=92.5379 373000000000 +cpu,cpu=4 usage_idle=67.5694,usage_system=87.0053,usage_user=27.5884 374000000000 +cpu,cpu=0 usage_idle=54.7723,usage_system=15.5202,usage_user=82.8622 375000000000 +cpu,cpu=1 usage_idle=22.2978,usage_system=11.2911,usage_user=45.2681 376000000000 +cpu,cpu=2 usage_idle=86.0784,usage_system=54.5784,usage_user=46.125 377000000000 +cpu,cpu=3 usage_idle=85.6826,usage_system=90.9512,usage_user=38.6669 378000000000 +cpu,cpu=4 usage_idle=95.6111,usage_system=17.4136,usage_user=18.7693 379000000000 +cpu,cpu=0 usage_idle=24.7168,usage_system=36.0164,usage_user=91.7395 380000000000 +cpu,cpu=1 usage_idle=62.788,usage_system=36.7118,usage_user=61.5491 381000000000 +cpu,cpu=2 usage_idle=51.7391,usage_system=37.8799,usage_user=50.1835 382000000000 +cpu,cpu=3 usage_idle=69.4091,usage_system=1.79977,usage_user=65.0066 383000000000 +cpu,cpu=4 usage_idle=61.947,usage_system=69.3692,usage_user=52.0118 384000000000 +cpu,cpu=0 usage_idle=89.5354,usage_system=24.1415,usage_user=67.532 385000000000 +cpu,cpu=1 usage_idle=72.3975,usage_system=46.4393,usage_user=78.8231 386000000000 +cpu,cpu=2 usage_idle=17.6656,usage_system=32.5177,usage_user=33.4016 387000000000 +cpu,cpu=3 usage_idle=63.7906,usage_system=18.2003,usage_user=24.3528 388000000000 +cpu,cpu=4 usage_idle=2.45755,usage_system=13.8114,usage_user=41.7663 389000000000 +cpu,cpu=0 usage_idle=21.2269,usage_system=38.5282,usage_user=77.7828 390000000000 +cpu,cpu=1 usage_idle=12.9663,usage_system=1.31615,usage_user=14.4946 391000000000 +cpu,cpu=2 usage_idle=74.5154,usage_system=53.0552,usage_user=52.3745 392000000000 +cpu,cpu=3 usage_idle=24.699,usage_system=22.4643,usage_user=54.1743 393000000000 +cpu,cpu=4 usage_idle=89.7055,usage_system=84.4113,usage_user=23.5435 394000000000 +cpu,cpu=0 usage_idle=41.7174,usage_system=73.9467,usage_user=47.685 395000000000 +cpu,cpu=1 usage_idle=9.24937,usage_system=46.3442,usage_user=94.1243 396000000000 +cpu,cpu=2 usage_idle=88.0725,usage_system=64.0098,usage_user=26.642 397000000000 +cpu,cpu=3 usage_idle=21.4741,usage_system=27.8005,usage_user=44.8423 398000000000 +cpu,cpu=4 usage_idle=45.8269,usage_system=30.258,usage_user=58.6537 399000000000 +cpu,cpu=0 usage_idle=87.5932,usage_system=51.4849,usage_user=97.1818 400000000000 +cpu,cpu=1 usage_idle=65.376,usage_system=64.4512,usage_user=98.498 401000000000 +cpu,cpu=2 usage_idle=79.8706,usage_system=38.9667,usage_user=51.5532 402000000000 +cpu,cpu=3 usage_idle=32.2451,usage_system=63.6656,usage_user=74.0175 403000000000 +cpu,cpu=4 usage_idle=86.4194,usage_system=53.3712,usage_user=58.4288 404000000000 +cpu,cpu=0 usage_idle=9.96293,usage_system=95.0885,usage_user=32.3755 405000000000 +cpu,cpu=1 usage_idle=57.6479,usage_system=4.3379,usage_user=78.7197 406000000000 +cpu,cpu=2 usage_idle=51.7722,usage_system=92.4104,usage_user=42.7295 407000000000 +cpu,cpu=3 usage_idle=78.4142,usage_system=13.8845,usage_user=70.53 408000000000 +cpu,cpu=4 usage_idle=23.2565,usage_system=59.7114,usage_user=0.788008 409000000000 +cpu,cpu=0 usage_idle=81.9102,usage_system=47.3045,usage_user=52.2729 410000000000 +cpu,cpu=1 usage_idle=79.092,usage_system=12.6805,usage_user=16.7241 411000000000 +cpu,cpu=2 usage_idle=77.5899,usage_system=92.5511,usage_user=55.6908 412000000000 +cpu,cpu=3 usage_idle=29.1431,usage_system=24.7962,usage_user=19.3564 413000000000 +cpu,cpu=4 usage_idle=3.16064,usage_system=11.2157,usage_user=72.7276 414000000000 +cpu,cpu=0 usage_idle=61.5894,usage_system=21.1786,usage_user=67.8161 415000000000 +cpu,cpu=1 usage_idle=93.9649,usage_system=78.8265,usage_user=72.154 416000000000 +cpu,cpu=2 usage_idle=72.6846,usage_system=30.5987,usage_user=64.5644 417000000000 +cpu,cpu=3 usage_idle=15.4141,usage_system=9.01297,usage_user=78.4489 418000000000 +cpu,cpu=4 usage_idle=85.9441,usage_system=32.2695,usage_user=38.1603 419000000000 +cpu,cpu=0 usage_idle=86.7321,usage_system=14.1796,usage_user=85.4648 420000000000 +cpu,cpu=1 usage_idle=39.005,usage_system=93.2716,usage_user=98.1453 421000000000 +cpu,cpu=2 usage_idle=55.7291,usage_system=70.8616,usage_user=90.6964 422000000000 +cpu,cpu=3 usage_idle=11.4199,usage_system=0.00468777,usage_user=15.4927 423000000000 +cpu,cpu=4 usage_idle=30.7763,usage_system=3.16532,usage_user=26.7083 424000000000 +cpu,cpu=0 usage_idle=3.50389,usage_system=64.7548,usage_user=47.8869 425000000000 +cpu,cpu=1 usage_idle=71.32,usage_system=58.7197,usage_user=26.7134 426000000000 +cpu,cpu=2 usage_idle=43.474,usage_system=31.4043,usage_user=57.3122 427000000000 +cpu,cpu=3 usage_idle=8.0384,usage_system=46.8185,usage_user=66.3252 428000000000 +cpu,cpu=4 usage_idle=86.4873,usage_system=32.7626,usage_user=98.5946 429000000000 +cpu,cpu=0 usage_idle=24.6476,usage_system=19.4948,usage_user=12.7743 430000000000 +cpu,cpu=1 usage_idle=10.1124,usage_system=58.4998,usage_user=6.04589 431000000000 +cpu,cpu=2 usage_idle=8.2577,usage_system=14.2289,usage_user=76.9074 432000000000 +cpu,cpu=3 usage_idle=98.9541,usage_system=25.6489,usage_user=76.9121 433000000000 +cpu,cpu=4 usage_idle=14.4468,usage_system=56.4252,usage_user=80.0775 434000000000 +cpu,cpu=0 usage_idle=41.1551,usage_system=59.9291,usage_user=44.8322 435000000000 +cpu,cpu=1 usage_idle=89.042,usage_system=31.2491,usage_user=3.55193 436000000000 +cpu,cpu=2 usage_idle=15.7555,usage_system=74.7231,usage_user=34.9562 437000000000 +cpu,cpu=3 usage_idle=73.0677,usage_system=82.7615,usage_user=81.7747 438000000000 +cpu,cpu=4 usage_idle=39.3928,usage_system=69.2488,usage_user=14.5373 439000000000 +cpu,cpu=0 usage_idle=37.9874,usage_system=93.8963,usage_user=34.0321 440000000000 +cpu,cpu=1 usage_idle=50.7617,usage_system=4.00871,usage_user=92.5318 441000000000 +cpu,cpu=2 usage_idle=56.8076,usage_system=12.2664,usage_user=6.76078 442000000000 +cpu,cpu=3 usage_idle=33.715,usage_system=11.2205,usage_user=32.4096 443000000000 +cpu,cpu=4 usage_idle=10.6272,usage_system=25.6673,usage_user=88.8348 444000000000 +cpu,cpu=0 usage_idle=90.7046,usage_system=66.8224,usage_user=48.7639 445000000000 +cpu,cpu=1 usage_idle=35.5369,usage_system=55.8645,usage_user=80.0129 446000000000 +cpu,cpu=2 usage_idle=39.0888,usage_system=71.6199,usage_user=54.736 447000000000 +cpu,cpu=3 usage_idle=74.045,usage_system=44.6876,usage_user=37.4975 448000000000 +cpu,cpu=4 usage_idle=55.8198,usage_system=84.0804,usage_user=6.74623 449000000000 +cpu,cpu=0 usage_idle=70.3571,usage_system=22.0679,usage_user=0.64256 450000000000 +cpu,cpu=1 usage_idle=4.38913,usage_system=72.8296,usage_user=4.65127 451000000000 +cpu,cpu=2 usage_idle=96.921,usage_system=29.6372,usage_user=16.9177 452000000000 +cpu,cpu=3 usage_idle=3.68176,usage_system=63.3522,usage_user=28.1382 453000000000 +cpu,cpu=4 usage_idle=36.0914,usage_system=73.9794,usage_user=53.8055 454000000000 +cpu,cpu=0 usage_idle=24.9262,usage_system=64.684,usage_user=20.628 455000000000 +cpu,cpu=1 usage_idle=73.6901,usage_system=0.220922,usage_user=76.4925 456000000000 +cpu,cpu=2 usage_idle=53.703,usage_system=39.3097,usage_user=48.1124 457000000000 +cpu,cpu=3 usage_idle=8.43902,usage_system=13.3548,usage_user=92.8 458000000000 +cpu,cpu=4 usage_idle=45.9365,usage_system=69.1745,usage_user=76.8804 459000000000 +cpu,cpu=0 usage_idle=52.6827,usage_system=39.5316,usage_user=98.9483 460000000000 +cpu,cpu=1 usage_idle=53.3253,usage_system=43.9207,usage_user=71.7778 461000000000 +cpu,cpu=2 usage_idle=57.9765,usage_system=40.8417,usage_user=1.41502 462000000000 +cpu,cpu=3 usage_idle=74.8942,usage_system=44.5235,usage_user=64.7672 463000000000 +cpu,cpu=4 usage_idle=3.0324,usage_system=80.6149,usage_user=38.7466 464000000000 +cpu,cpu=0 usage_idle=56.8379,usage_system=5.54106,usage_user=3.43068 465000000000 +cpu,cpu=1 usage_idle=77.4659,usage_system=79.2311,usage_user=3.6516 466000000000 +cpu,cpu=2 usage_idle=53.9584,usage_system=32.9342,usage_user=42.9613 467000000000 +cpu,cpu=3 usage_idle=2.07081,usage_system=41.3732,usage_user=56.3161 468000000000 +cpu,cpu=4 usage_idle=94.8708,usage_system=87.3097,usage_user=25.4906 469000000000 +cpu,cpu=0 usage_idle=71.7512,usage_system=39.9924,usage_user=65.0222 470000000000 +cpu,cpu=1 usage_idle=70.6995,usage_system=93.3176,usage_user=8.94297 471000000000 +cpu,cpu=2 usage_idle=42.4774,usage_system=51.2941,usage_user=49.7847 472000000000 +cpu,cpu=3 usage_idle=43.8924,usage_system=26.1883,usage_user=94.3081 473000000000 +cpu,cpu=4 usage_idle=8.65962,usage_system=29.2207,usage_user=74.923 474000000000 +cpu,cpu=0 usage_idle=47.4063,usage_system=86.0587,usage_user=80.4641 475000000000 +cpu,cpu=1 usage_idle=50.8369,usage_system=63.5246,usage_user=59.6952 476000000000 +cpu,cpu=2 usage_idle=54.4885,usage_system=17.483,usage_user=92.6294 477000000000 +cpu,cpu=3 usage_idle=97.4499,usage_system=19.5538,usage_user=34.0026 478000000000 +cpu,cpu=4 usage_idle=53.766,usage_system=14.4246,usage_user=21.3122 479000000000 +cpu,cpu=0 usage_idle=79.2566,usage_system=86.1759,usage_user=61.3046 480000000000 +cpu,cpu=1 usage_idle=44.2789,usage_system=56.8754,usage_user=54.6222 481000000000 +cpu,cpu=2 usage_idle=53.2218,usage_system=99.3528,usage_user=5.91633 482000000000 +cpu,cpu=3 usage_idle=3.00651,usage_system=43.2452,usage_user=32.1047 483000000000 +cpu,cpu=4 usage_idle=97.3147,usage_system=51.9048,usage_user=61.3254 484000000000 +cpu,cpu=0 usage_idle=72.2377,usage_system=99.311,usage_user=47.3841 485000000000 +cpu,cpu=1 usage_idle=52.7017,usage_system=50.148,usage_user=10.9087 486000000000 +cpu,cpu=2 usage_idle=12.3969,usage_system=4.63652,usage_user=28.3917 487000000000 +cpu,cpu=3 usage_idle=5.02633,usage_system=2.08639,usage_user=47.9455 488000000000 +cpu,cpu=4 usage_idle=39.0289,usage_system=55.8524,usage_user=62.3701 489000000000 +cpu,cpu=0 usage_idle=60.3411,usage_system=35.109,usage_user=48.546 490000000000 +cpu,cpu=1 usage_idle=21.6457,usage_system=79.3879,usage_user=5.4214 491000000000 +cpu,cpu=2 usage_idle=76.2679,usage_system=32.6097,usage_user=4.77418 492000000000 +cpu,cpu=3 usage_idle=82.1842,usage_system=35.6162,usage_user=48.0193 493000000000 +cpu,cpu=4 usage_idle=14.2889,usage_system=32.9309,usage_user=99.9241 494000000000 +cpu,cpu=0 usage_idle=75.6143,usage_system=5.16852,usage_user=99.2352 495000000000 +cpu,cpu=1 usage_idle=22.9984,usage_system=57.8702,usage_user=49.3831 496000000000 +cpu,cpu=2 usage_idle=33.9071,usage_system=70.2672,usage_user=54.0197 497000000000 +cpu,cpu=3 usage_idle=62.2988,usage_system=75.2935,usage_user=56.106 498000000000 +cpu,cpu=4 usage_idle=10.2443,usage_system=14.3224,usage_user=11.9584 499000000000 +cpu,cpu=0 usage_idle=72.6144,usage_system=74.6635,usage_user=47.0674 500000000000 +cpu,cpu=1 usage_idle=21.1604,usage_system=96.3092,usage_user=26.4553 501000000000 +cpu,cpu=2 usage_idle=26.5818,usage_system=72.5771,usage_user=59.0649 502000000000 +cpu,cpu=3 usage_idle=31.356,usage_system=54.7613,usage_user=94.6811 503000000000 +cpu,cpu=4 usage_idle=79.3753,usage_system=69.0502,usage_user=27.612 504000000000 +cpu,cpu=0 usage_idle=79.2995,usage_system=44.6645,usage_user=32.7805 505000000000 +cpu,cpu=1 usage_idle=78.5346,usage_system=67.6628,usage_user=90.6508 506000000000 +cpu,cpu=2 usage_idle=27.9178,usage_system=1.56992,usage_user=60.9179 507000000000 +cpu,cpu=3 usage_idle=81.9374,usage_system=63.8687,usage_user=36.2115 508000000000 +cpu,cpu=4 usage_idle=38.0434,usage_system=74.113,usage_user=50.5339 509000000000 +cpu,cpu=0 usage_idle=50.0019,usage_system=46.7274,usage_user=25.1974 510000000000 +cpu,cpu=1 usage_idle=97.0693,usage_system=67.8878,usage_user=21.5066 511000000000 +cpu,cpu=2 usage_idle=23.5245,usage_system=94.4697,usage_user=94.0837 512000000000 +cpu,cpu=3 usage_idle=82.5895,usage_system=25.8257,usage_user=48.845 513000000000 +cpu,cpu=4 usage_idle=77.2706,usage_system=5.20103,usage_user=17.8952 514000000000 +cpu,cpu=0 usage_idle=4.88258,usage_system=84.5005,usage_user=62.5596 515000000000 +cpu,cpu=1 usage_idle=37.6631,usage_system=63.0351,usage_user=30.2225 516000000000 +cpu,cpu=2 usage_idle=28.3138,usage_system=90.9529,usage_user=31.7924 517000000000 +cpu,cpu=3 usage_idle=89.2318,usage_system=72.8903,usage_user=95.6611 518000000000 +cpu,cpu=4 usage_idle=25.4432,usage_system=10.9337,usage_user=69.7741 519000000000 +cpu,cpu=0 usage_idle=75.9771,usage_system=60.9356,usage_user=16.5015 520000000000 +cpu,cpu=1 usage_idle=1.17453,usage_system=58.0048,usage_user=84.3894 521000000000 +cpu,cpu=2 usage_idle=22.6811,usage_system=81.5294,usage_user=78.859 522000000000 +cpu,cpu=3 usage_idle=16.7648,usage_system=64.1188,usage_user=4.68473 523000000000 +cpu,cpu=4 usage_idle=65.6098,usage_system=41.3894,usage_user=9.88576 524000000000 +cpu,cpu=0 usage_idle=83.505,usage_system=46.272,usage_user=94.3863 525000000000 +cpu,cpu=1 usage_idle=46.0646,usage_system=83.9351,usage_user=57.4214 526000000000 +cpu,cpu=2 usage_idle=76.2871,usage_system=12.2489,usage_user=48.3742 527000000000 +cpu,cpu=3 usage_idle=8.07953,usage_system=1.48069,usage_user=21.2645 528000000000 +cpu,cpu=4 usage_idle=3.74063,usage_system=26.9239,usage_user=32.1982 529000000000 +cpu,cpu=0 usage_idle=73.5147,usage_system=2.90106,usage_user=93.1338 530000000000 +cpu,cpu=1 usage_idle=90.0163,usage_system=4.07559,usage_user=51.1386 531000000000 +cpu,cpu=2 usage_idle=74.4056,usage_system=26.7567,usage_user=32.668 532000000000 +cpu,cpu=3 usage_idle=53.2647,usage_system=43.5216,usage_user=96.7868 533000000000 +cpu,cpu=4 usage_idle=57.9494,usage_system=9.13142,usage_user=38.1762 534000000000 +cpu,cpu=0 usage_idle=67.8351,usage_system=92.6364,usage_user=84.4482 535000000000 +cpu,cpu=1 usage_idle=62.2214,usage_system=38.7011,usage_user=68.3833 536000000000 +cpu,cpu=2 usage_idle=19.6428,usage_system=14.9882,usage_user=80.6322 537000000000 +cpu,cpu=3 usage_idle=68.017,usage_system=23.0677,usage_user=82.1129 538000000000 +cpu,cpu=4 usage_idle=89.2815,usage_system=26.8084,usage_user=9.03681 539000000000 +cpu,cpu=0 usage_idle=21.4797,usage_system=0.323105,usage_user=11.9379 540000000000 +cpu,cpu=1 usage_idle=14.6135,usage_system=90.3394,usage_user=16.0135 541000000000 +cpu,cpu=2 usage_idle=65.7522,usage_system=64.745,usage_user=42.7702 542000000000 +cpu,cpu=3 usage_idle=98.4202,usage_system=18.0096,usage_user=86.2918 543000000000 +cpu,cpu=4 usage_idle=95.207,usage_system=75.959,usage_user=95.4232 544000000000 +cpu,cpu=0 usage_idle=33.3832,usage_system=43.7942,usage_user=88.0596 545000000000 +cpu,cpu=1 usage_idle=17.8314,usage_system=6.01557,usage_user=26.7607 546000000000 +cpu,cpu=2 usage_idle=86.2147,usage_system=25.6583,usage_user=41.7489 547000000000 +cpu,cpu=3 usage_idle=66.8469,usage_system=93.6754,usage_user=64.8167 548000000000 +cpu,cpu=4 usage_idle=48.9597,usage_system=82.9569,usage_user=91.625 549000000000 +cpu,cpu=0 usage_idle=57.9965,usage_system=4.43661,usage_user=91.9481 550000000000 +cpu,cpu=1 usage_idle=69.9344,usage_system=19.0501,usage_user=82.2875 551000000000 +cpu,cpu=2 usage_idle=85.9479,usage_system=84.8023,usage_user=47.0325 552000000000 +cpu,cpu=3 usage_idle=28.7181,usage_system=83.2225,usage_user=65.0421 553000000000 +cpu,cpu=4 usage_idle=15.0099,usage_system=78.4295,usage_user=41.0011 554000000000 +cpu,cpu=0 usage_idle=10.4331,usage_system=11.8126,usage_user=84.7953 555000000000 +cpu,cpu=1 usage_idle=98.4927,usage_system=29.644,usage_user=90.8109 556000000000 +cpu,cpu=2 usage_idle=25.2535,usage_system=15.8587,usage_user=16.4692 557000000000 +cpu,cpu=3 usage_idle=67.0024,usage_system=82.7056,usage_user=10.1446 558000000000 +cpu,cpu=4 usage_idle=31.8191,usage_system=31.6653,usage_user=93.1014 559000000000 +cpu,cpu=0 usage_idle=23.4441,usage_system=89.6618,usage_user=97.538 560000000000 +cpu,cpu=1 usage_idle=15.3923,usage_system=59.5963,usage_user=16.5882 561000000000 +cpu,cpu=2 usage_idle=97.6798,usage_system=45.5442,usage_user=1.39049 562000000000 +cpu,cpu=3 usage_idle=44.7123,usage_system=74.2623,usage_user=84.613 563000000000 +cpu,cpu=4 usage_idle=9.75437,usage_system=89.2721,usage_user=63.0424 564000000000 +cpu,cpu=0 usage_idle=50.7555,usage_system=99.7052,usage_user=74.8551 565000000000 +cpu,cpu=1 usage_idle=35.5508,usage_system=98.198,usage_user=4.4991 566000000000 +cpu,cpu=2 usage_idle=26.3617,usage_system=23.4514,usage_user=20.3578 567000000000 +cpu,cpu=3 usage_idle=42.8309,usage_system=90.4539,usage_user=3.06337 568000000000 +cpu,cpu=4 usage_idle=52.9754,usage_system=22.2729,usage_user=34.7287 569000000000 +cpu,cpu=0 usage_idle=46.0768,usage_system=45.7171,usage_user=24.3905 570000000000 +cpu,cpu=1 usage_idle=43.6149,usage_system=61.1093,usage_user=83.9868 571000000000 +cpu,cpu=2 usage_idle=60.203,usage_system=58.7891,usage_user=29.5309 572000000000 +cpu,cpu=3 usage_idle=61.5935,usage_system=3.50138,usage_user=3.7932 573000000000 +cpu,cpu=4 usage_idle=46.2065,usage_system=13.2558,usage_user=93.0653 574000000000 +cpu,cpu=0 usage_idle=9.24893,usage_system=64.0113,usage_user=92.7706 575000000000 +cpu,cpu=1 usage_idle=84.104,usage_system=99.562,usage_user=90.9686 576000000000 +cpu,cpu=2 usage_idle=88.6031,usage_system=25.9237,usage_user=14.42 577000000000 +cpu,cpu=3 usage_idle=8.9609,usage_system=68.7546,usage_user=4.87385 578000000000 +cpu,cpu=4 usage_idle=12.0243,usage_system=21.73,usage_user=27.1468 579000000000 +cpu,cpu=0 usage_idle=46.7529,usage_system=67.8068,usage_user=72.8638 580000000000 +cpu,cpu=1 usage_idle=71.1434,usage_system=11.4216,usage_user=33.9732 581000000000 +cpu,cpu=2 usage_idle=55.1302,usage_system=71.6247,usage_user=92.7623 582000000000 +cpu,cpu=3 usage_idle=84.6611,usage_system=33.2182,usage_user=96.2637 583000000000 +cpu,cpu=4 usage_idle=88.4543,usage_system=79.4247,usage_user=9.51945 584000000000 +cpu,cpu=0 usage_idle=81.5197,usage_system=88.6736,usage_user=73.5307 585000000000 +cpu,cpu=1 usage_idle=74.2903,usage_system=72.7776,usage_user=73.0928 586000000000 +cpu,cpu=2 usage_idle=65.2588,usage_system=61.3807,usage_user=99.0165 587000000000 +cpu,cpu=3 usage_idle=79.6788,usage_system=70.3416,usage_user=67.771 588000000000 +cpu,cpu=4 usage_idle=84.5527,usage_system=82.3659,usage_user=89.501 589000000000 +cpu,cpu=0 usage_idle=11.6995,usage_system=29.1188,usage_user=57.3077 590000000000 +cpu,cpu=1 usage_idle=84.5633,usage_system=0.262258,usage_user=68.7294 591000000000 +cpu,cpu=2 usage_idle=18.5365,usage_system=55.3925,usage_user=40.3541 592000000000 +cpu,cpu=3 usage_idle=11.2988,usage_system=40.0536,usage_user=73.5723 593000000000 +cpu,cpu=4 usage_idle=7.56249,usage_system=28.508,usage_user=52.997 594000000000 +cpu,cpu=0 usage_idle=17.0819,usage_system=10.0276,usage_user=41.6706 595000000000 +cpu,cpu=1 usage_idle=90.6126,usage_system=84.3179,usage_user=14.4482 596000000000 +cpu,cpu=2 usage_idle=63.7054,usage_system=49.5767,usage_user=75.829 597000000000 +cpu,cpu=3 usage_idle=62.7219,usage_system=29.2555,usage_user=46.1706 598000000000 +cpu,cpu=4 usage_idle=30.4929,usage_system=13.8082,usage_user=28.5365 599000000000 +cpu,cpu=0 usage_idle=19.9938,usage_system=25.5076,usage_user=57.6553 600000000000 +cpu,cpu=1 usage_idle=77.3016,usage_system=10.0709,usage_user=57.9176 601000000000 +cpu,cpu=2 usage_idle=46.0309,usage_system=28.6074,usage_user=13.31 602000000000 +cpu,cpu=3 usage_idle=86.385,usage_system=39.9062,usage_user=53.3636 603000000000 +cpu,cpu=4 usage_idle=59.9573,usage_system=47.4687,usage_user=81.8716 604000000000 +cpu,cpu=0 usage_idle=12.9542,usage_system=64.5506,usage_user=91.8992 605000000000 +cpu,cpu=1 usage_idle=54.6248,usage_system=55.1633,usage_user=76.2171 606000000000 +cpu,cpu=2 usage_idle=69.0731,usage_system=18.8687,usage_user=25.7939 607000000000 +cpu,cpu=3 usage_idle=44.902,usage_system=81.5905,usage_user=55.0494 608000000000 +cpu,cpu=4 usage_idle=91.0726,usage_system=12.0834,usage_user=68.8576 609000000000 +cpu,cpu=0 usage_idle=19.6091,usage_system=32.0772,usage_user=94.3652 610000000000 +cpu,cpu=1 usage_idle=77.2644,usage_system=9.37877,usage_user=4.43619 611000000000 +cpu,cpu=2 usage_idle=35.1819,usage_system=55.4097,usage_user=33.0436 612000000000 +cpu,cpu=3 usage_idle=48.4919,usage_system=41.7947,usage_user=72.9499 613000000000 +cpu,cpu=4 usage_idle=1.85558,usage_system=1.75198,usage_user=20.4186 614000000000 +cpu,cpu=0 usage_idle=83.7272,usage_system=14.7062,usage_user=84.9692 615000000000 +cpu,cpu=1 usage_idle=75.6264,usage_system=69.3311,usage_user=40.1325 616000000000 +cpu,cpu=2 usage_idle=51.8436,usage_system=38.4041,usage_user=59.0012 617000000000 +cpu,cpu=3 usage_idle=77.6374,usage_system=83.3062,usage_user=40.5917 618000000000 +cpu,cpu=4 usage_idle=32.6868,usage_system=74.3788,usage_user=52.6751 619000000000 +cpu,cpu=0 usage_idle=1.54439,usage_system=93.9879,usage_user=84.7523 620000000000 +cpu,cpu=1 usage_idle=95.9096,usage_system=71.2522,usage_user=94.1311 621000000000 +cpu,cpu=2 usage_idle=0.345808,usage_system=6.43416,usage_user=49.5408 622000000000 +cpu,cpu=3 usage_idle=33.3894,usage_system=54.9261,usage_user=91.3355 623000000000 +cpu,cpu=4 usage_idle=6.33928,usage_system=56.7817,usage_user=93.0875 624000000000 +cpu,cpu=0 usage_idle=26.7578,usage_system=40.5089,usage_user=7.79371 625000000000 +cpu,cpu=1 usage_idle=11.7271,usage_system=16.1353,usage_user=77.1248 626000000000 +cpu,cpu=2 usage_idle=51.8596,usage_system=67.9788,usage_user=15.5289 627000000000 +cpu,cpu=3 usage_idle=10.8608,usage_system=45.6162,usage_user=98.8351 628000000000 +cpu,cpu=4 usage_idle=51.4525,usage_system=78.303,usage_user=73.2138 629000000000 +cpu,cpu=0 usage_idle=4.1276,usage_system=79.8474,usage_user=67.2017 630000000000 +cpu,cpu=1 usage_idle=88.8799,usage_system=75.7571,usage_user=38.4539 631000000000 +cpu,cpu=2 usage_idle=83.011,usage_system=76.1029,usage_user=44.8881 632000000000 +cpu,cpu=3 usage_idle=32.5518,usage_system=9.4923,usage_user=99.8142 633000000000 +cpu,cpu=4 usage_idle=23.8873,usage_system=15.8316,usage_user=56.5959 634000000000 +cpu,cpu=0 usage_idle=16.9748,usage_system=42.5894,usage_user=97.1047 635000000000 +cpu,cpu=1 usage_idle=24.7685,usage_system=54.3165,usage_user=13.24 636000000000 +cpu,cpu=2 usage_idle=1.89329,usage_system=6.17606,usage_user=81.2189 637000000000 +cpu,cpu=3 usage_idle=17.4222,usage_system=17.0368,usage_user=26.8351 638000000000 +cpu,cpu=4 usage_idle=16.2572,usage_system=68.4893,usage_user=5.13816 639000000000 +cpu,cpu=0 usage_idle=89.4711,usage_system=72.6169,usage_user=84.9856 640000000000 +cpu,cpu=1 usage_idle=56.6728,usage_system=61.4968,usage_user=60.7427 641000000000 +cpu,cpu=2 usage_idle=95.1267,usage_system=44.5079,usage_user=36.8455 642000000000 +cpu,cpu=3 usage_idle=40.0148,usage_system=77.0597,usage_user=46.3378 643000000000 +cpu,cpu=4 usage_idle=39.829,usage_system=0.947013,usage_user=62.1694 644000000000 +cpu,cpu=0 usage_idle=96.4248,usage_system=17.9218,usage_user=4.75882 645000000000 +cpu,cpu=1 usage_idle=93.5296,usage_system=42.6904,usage_user=59.0753 646000000000 +cpu,cpu=2 usage_idle=6.7696,usage_system=44.5836,usage_user=65.2514 647000000000 +cpu,cpu=3 usage_idle=87.9885,usage_system=62.0058,usage_user=82.2882 648000000000 +cpu,cpu=4 usage_idle=14.8236,usage_system=78.2631,usage_user=50.7775 649000000000 +cpu,cpu=0 usage_idle=19.9617,usage_system=67.7342,usage_user=23.3944 650000000000 +cpu,cpu=1 usage_idle=4.94732,usage_system=24.4069,usage_user=84.8912 651000000000 +cpu,cpu=2 usage_idle=65.69,usage_system=19.5336,usage_user=29.3991 652000000000 +cpu,cpu=3 usage_idle=2.53549,usage_system=59.5484,usage_user=6.45876 653000000000 +cpu,cpu=4 usage_idle=48.8733,usage_system=99.3774,usage_user=7.40577 654000000000 +cpu,cpu=0 usage_idle=11.0427,usage_system=95.8022,usage_user=25.3276 655000000000 +cpu,cpu=1 usage_idle=15.8015,usage_system=89.3318,usage_user=68.018 656000000000 +cpu,cpu=2 usage_idle=74.8768,usage_system=96.1014,usage_user=12.6016 657000000000 +cpu,cpu=3 usage_idle=40.1282,usage_system=84.0899,usage_user=74.6075 658000000000 +cpu,cpu=4 usage_idle=22.4164,usage_system=98.9134,usage_user=52.8705 659000000000 +cpu,cpu=0 usage_idle=73.1938,usage_system=18.8752,usage_user=20.6047 660000000000 +cpu,cpu=1 usage_idle=96.5882,usage_system=23.8225,usage_user=45.0117 661000000000 +cpu,cpu=2 usage_idle=81.4794,usage_system=89.5125,usage_user=64.5453 662000000000 +cpu,cpu=3 usage_idle=10.8785,usage_system=92.0479,usage_user=24.0937 663000000000 +cpu,cpu=4 usage_idle=17.3373,usage_system=40.9213,usage_user=23.4711 664000000000 +cpu,cpu=0 usage_idle=24.7431,usage_system=51.964,usage_user=19.2734 665000000000 +cpu,cpu=1 usage_idle=50.0707,usage_system=67.7655,usage_user=8.60517 666000000000 +cpu,cpu=2 usage_idle=18.0886,usage_system=42.6423,usage_user=4.70658 667000000000 +cpu,cpu=3 usage_idle=30.6902,usage_system=82.7705,usage_user=88.7965 668000000000 +cpu,cpu=4 usage_idle=5.29768,usage_system=5.18689,usage_user=87.7099 669000000000 +cpu,cpu=0 usage_idle=58.1682,usage_system=78.3807,usage_user=6.58506 670000000000 +cpu,cpu=1 usage_idle=78.7729,usage_system=74.969,usage_user=30.4075 671000000000 +cpu,cpu=2 usage_idle=23.7846,usage_system=56.4484,usage_user=19.92 672000000000 +cpu,cpu=3 usage_idle=88.3299,usage_system=67.3269,usage_user=11.9679 673000000000 +cpu,cpu=4 usage_idle=12.4236,usage_system=84.6642,usage_user=52.8892 674000000000 +cpu,cpu=0 usage_idle=35.8948,usage_system=9.40727,usage_user=4.85317 675000000000 +cpu,cpu=1 usage_idle=55.1681,usage_system=59.4779,usage_user=72.6187 676000000000 +cpu,cpu=2 usage_idle=63.7733,usage_system=77.5665,usage_user=15.261 677000000000 +cpu,cpu=3 usage_idle=68.4799,usage_system=8.25677,usage_user=98.0315 678000000000 +cpu,cpu=4 usage_idle=57.2763,usage_system=13.5545,usage_user=3.21839 679000000000 +cpu,cpu=0 usage_idle=44.9862,usage_system=71.7227,usage_user=81.5991 680000000000 +cpu,cpu=1 usage_idle=51.5713,usage_system=50.4956,usage_user=56.5681 681000000000 +cpu,cpu=2 usage_idle=81.9788,usage_system=74.2802,usage_user=13.0165 682000000000 +cpu,cpu=3 usage_idle=1.89879,usage_system=62.6101,usage_user=80.3434 683000000000 +cpu,cpu=4 usage_idle=13.8667,usage_system=75.0337,usage_user=65.0077 684000000000 +cpu,cpu=0 usage_idle=66.7559,usage_system=10.9285,usage_user=74.4149 685000000000 +cpu,cpu=1 usage_idle=71.6091,usage_system=66.0966,usage_user=33.8929 686000000000 +cpu,cpu=2 usage_idle=44.2278,usage_system=29.8698,usage_user=11.4594 687000000000 +cpu,cpu=3 usage_idle=59.4888,usage_system=98.3497,usage_user=19.7162 688000000000 +cpu,cpu=4 usage_idle=57.5203,usage_system=55.626,usage_user=33.2706 689000000000 +cpu,cpu=0 usage_idle=60.7387,usage_system=0.612195,usage_user=4.99329 690000000000 +cpu,cpu=1 usage_idle=42.3378,usage_system=52.1834,usage_user=55.4889 691000000000 +cpu,cpu=2 usage_idle=98.9059,usage_system=34.1622,usage_user=29.7691 692000000000 +cpu,cpu=3 usage_idle=11.9224,usage_system=36.061,usage_user=92.3792 693000000000 +cpu,cpu=4 usage_idle=92.2658,usage_system=49.9278,usage_user=67.4129 694000000000 +cpu,cpu=0 usage_idle=57.2735,usage_system=16.6837,usage_user=78.3413 695000000000 +cpu,cpu=1 usage_idle=31.6884,usage_system=88.2928,usage_user=44.4379 696000000000 +cpu,cpu=2 usage_idle=65.5813,usage_system=32.5206,usage_user=74.3078 697000000000 +cpu,cpu=3 usage_idle=77.0407,usage_system=92.0094,usage_user=72.6575 698000000000 +cpu,cpu=4 usage_idle=96.7568,usage_system=49.5297,usage_user=28.2835 699000000000 +cpu,cpu=0 usage_idle=30.0275,usage_system=10.2683,usage_user=28.8957 700000000000 +cpu,cpu=1 usage_idle=35.0207,usage_system=52.6061,usage_user=81.0791 701000000000 +cpu,cpu=2 usage_idle=90.5096,usage_system=51.512,usage_user=15.2413 702000000000 +cpu,cpu=3 usage_idle=20.2787,usage_system=63.4344,usage_user=51.3024 703000000000 +cpu,cpu=4 usage_idle=12.6579,usage_system=55.7002,usage_user=1.23013 704000000000 +cpu,cpu=0 usage_idle=80.0708,usage_system=12.9737,usage_user=17.9138 705000000000 +cpu,cpu=1 usage_idle=58.4121,usage_system=44.6622,usage_user=6.20666 706000000000 +cpu,cpu=2 usage_idle=2.85004,usage_system=10.2434,usage_user=38.7273 707000000000 +cpu,cpu=3 usage_idle=77.1578,usage_system=87.2841,usage_user=30.7366 708000000000 +cpu,cpu=4 usage_idle=49.8153,usage_system=84.0409,usage_user=80.2663 709000000000 +cpu,cpu=0 usage_idle=78.0987,usage_system=14.0684,usage_user=90.5346 710000000000 +cpu,cpu=1 usage_idle=6.99438,usage_system=49.0891,usage_user=43.1407 711000000000 +cpu,cpu=2 usage_idle=88.0735,usage_system=39.5988,usage_user=94.6527 712000000000 +cpu,cpu=3 usage_idle=3.31482,usage_system=59.8775,usage_user=58.0872 713000000000 +cpu,cpu=4 usage_idle=54.6172,usage_system=72.5354,usage_user=13.7874 714000000000 +cpu,cpu=0 usage_idle=55.8473,usage_system=52.6062,usage_user=26.7611 715000000000 +cpu,cpu=1 usage_idle=73.7611,usage_system=11.0183,usage_user=71.4233 716000000000 +cpu,cpu=2 usage_idle=79.9678,usage_system=13.8684,usage_user=81.6667 717000000000 +cpu,cpu=3 usage_idle=18.6951,usage_system=91.0262,usage_user=68.9509 718000000000 +cpu,cpu=4 usage_idle=49.4317,usage_system=40.8414,usage_user=52.9918 719000000000 +cpu,cpu=0 usage_idle=29.698,usage_system=18.9401,usage_user=67.0602 720000000000 +cpu,cpu=1 usage_idle=20.2326,usage_system=25.9345,usage_user=16.1494 721000000000 +cpu,cpu=2 usage_idle=63.3734,usage_system=14.008,usage_user=55.7481 722000000000 +cpu,cpu=3 usage_idle=58.0261,usage_system=17.3228,usage_user=15.6257 723000000000 +cpu,cpu=4 usage_idle=16.1133,usage_system=71.94,usage_user=88.1611 724000000000 +cpu,cpu=0 usage_idle=29.9007,usage_system=27.7873,usage_user=40.7673 725000000000 +cpu,cpu=1 usage_idle=56.6618,usage_system=1.54844,usage_user=51.7856 726000000000 +cpu,cpu=2 usage_idle=28.0851,usage_system=81.5162,usage_user=65.654 727000000000 +cpu,cpu=3 usage_idle=9.75185,usage_system=0.211305,usage_user=56.6801 728000000000 +cpu,cpu=4 usage_idle=78.7027,usage_system=49.643,usage_user=97.5215 729000000000 +cpu,cpu=0 usage_idle=31.6945,usage_system=79.341,usage_user=16.4617 730000000000 +cpu,cpu=1 usage_idle=98.7547,usage_system=99.5737,usage_user=42.3962 731000000000 +cpu,cpu=2 usage_idle=14.9041,usage_system=62.9471,usage_user=56.4042 732000000000 +cpu,cpu=3 usage_idle=70.6522,usage_system=20.9732,usage_user=73.727 733000000000 +cpu,cpu=4 usage_idle=86.2779,usage_system=37.0865,usage_user=45.667 734000000000 +cpu,cpu=0 usage_idle=74.439,usage_system=66.9871,usage_user=73.4543 735000000000 +cpu,cpu=1 usage_idle=15.2062,usage_system=23.649,usage_user=75.0027 736000000000 +cpu,cpu=2 usage_idle=66.9918,usage_system=51.7341,usage_user=56.5189 737000000000 +cpu,cpu=3 usage_idle=32.6458,usage_system=61.4859,usage_user=56.7302 738000000000 +cpu,cpu=4 usage_idle=89.3259,usage_system=40.1886,usage_user=6.37327 739000000000 +cpu,cpu=0 usage_idle=86.8474,usage_system=71.8831,usage_user=85.7143 740000000000 +cpu,cpu=1 usage_idle=3.30907,usage_system=70.6378,usage_user=85.288 741000000000 +cpu,cpu=2 usage_idle=45.7052,usage_system=85.5419,usage_user=48.235 742000000000 +cpu,cpu=3 usage_idle=2.1094,usage_system=56.1941,usage_user=69.2082 743000000000 +cpu,cpu=4 usage_idle=75.8364,usage_system=42.472,usage_user=6.29468 744000000000 +cpu,cpu=0 usage_idle=21.5033,usage_system=16.9109,usage_user=73.2818 745000000000 +cpu,cpu=1 usage_idle=94.9576,usage_system=32.1172,usage_user=96.9308 746000000000 +cpu,cpu=2 usage_idle=69.9603,usage_system=99.109,usage_user=48.6648 747000000000 +cpu,cpu=3 usage_idle=26.4793,usage_system=31.7548,usage_user=10.1507 748000000000 +cpu,cpu=4 usage_idle=83.2095,usage_system=21.0806,usage_user=50.3394 749000000000 +cpu,cpu=0 usage_idle=89.5828,usage_system=7.92805,usage_user=22.2225 750000000000 +cpu,cpu=1 usage_idle=75.2971,usage_system=11.2371,usage_user=92.8603 751000000000 +cpu,cpu=2 usage_idle=60.585,usage_system=56.9424,usage_user=78.4022 752000000000 +cpu,cpu=3 usage_idle=8.82007,usage_system=59.0518,usage_user=34.5963 753000000000 +cpu,cpu=4 usage_idle=78.0283,usage_system=34.8881,usage_user=77.0682 754000000000 +cpu,cpu=0 usage_idle=84.323,usage_system=56.3915,usage_user=93.9791 755000000000 +cpu,cpu=1 usage_idle=57.6048,usage_system=51.3491,usage_user=26.0963 756000000000 +cpu,cpu=2 usage_idle=54.5356,usage_system=21.3094,usage_user=25.2053 757000000000 +cpu,cpu=3 usage_idle=3.20041,usage_system=47.7887,usage_user=56.96 758000000000 +cpu,cpu=4 usage_idle=13.3512,usage_system=30.9982,usage_user=78.0407 759000000000 +cpu,cpu=0 usage_idle=63.6905,usage_system=20.5809,usage_user=85.9687 760000000000 +cpu,cpu=1 usage_idle=85.913,usage_system=95.878,usage_user=97.2059 761000000000 +cpu,cpu=2 usage_idle=78.7733,usage_system=56.463,usage_user=54.1482 762000000000 +cpu,cpu=3 usage_idle=57.1755,usage_system=65.2831,usage_user=13.2 763000000000 +cpu,cpu=4 usage_idle=91.7717,usage_system=43.3114,usage_user=48.0881 764000000000 +cpu,cpu=0 usage_idle=68.8399,usage_system=27.6344,usage_user=4.47959 765000000000 +cpu,cpu=1 usage_idle=62.8191,usage_system=85.2391,usage_user=55.8287 766000000000 +cpu,cpu=2 usage_idle=88.9154,usage_system=39.7747,usage_user=77.1381 767000000000 +cpu,cpu=3 usage_idle=14.1207,usage_system=42.9751,usage_user=24.9267 768000000000 +cpu,cpu=4 usage_idle=71.0807,usage_system=56.3263,usage_user=55.9249 769000000000 +cpu,cpu=0 usage_idle=49.1214,usage_system=20.0168,usage_user=76.5058 770000000000 +cpu,cpu=1 usage_idle=35.0901,usage_system=5.92977,usage_user=72.3838 771000000000 +cpu,cpu=2 usage_idle=32.296,usage_system=84.7031,usage_user=28.8468 772000000000 +cpu,cpu=3 usage_idle=86.4442,usage_system=41.8785,usage_user=94.1299 773000000000 +cpu,cpu=4 usage_idle=99.6442,usage_system=33.6502,usage_user=37.4413 774000000000 +cpu,cpu=0 usage_idle=47.7323,usage_system=2.49018,usage_user=65.0757 775000000000 +cpu,cpu=1 usage_idle=52.2119,usage_system=65.3093,usage_user=50.3148 776000000000 +cpu,cpu=2 usage_idle=8.04055,usage_system=54.2247,usage_user=90.0895 777000000000 +cpu,cpu=3 usage_idle=85.1786,usage_system=68.3453,usage_user=33.0647 778000000000 +cpu,cpu=4 usage_idle=10.1054,usage_system=39.426,usage_user=89.3909 779000000000 +cpu,cpu=0 usage_idle=66.0302,usage_system=88.5474,usage_user=9.40773 780000000000 +cpu,cpu=1 usage_idle=42.5361,usage_system=23.6375,usage_user=15.3375 781000000000 +cpu,cpu=2 usage_idle=14.9199,usage_system=55.9335,usage_user=0.0405591 782000000000 +cpu,cpu=3 usage_idle=43.7667,usage_system=42.3777,usage_user=41.9191 783000000000 +cpu,cpu=4 usage_idle=37.8966,usage_system=42.0218,usage_user=75.5693 784000000000 +cpu,cpu=0 usage_idle=75.3379,usage_system=89.7541,usage_user=78.0595 785000000000 +cpu,cpu=1 usage_idle=40.4136,usage_system=41.966,usage_user=43.3687 786000000000 +cpu,cpu=2 usage_idle=90.7284,usage_system=50.0065,usage_user=97.5934 787000000000 +cpu,cpu=3 usage_idle=80.8179,usage_system=35.1851,usage_user=65.9387 788000000000 +cpu,cpu=4 usage_idle=13.8826,usage_system=45.2905,usage_user=5.36473 789000000000 +cpu,cpu=0 usage_idle=3.27351,usage_system=11.3207,usage_user=93.9121 790000000000 +cpu,cpu=1 usage_idle=12.6812,usage_system=53.8568,usage_user=17.5496 791000000000 +cpu,cpu=2 usage_idle=28.0188,usage_system=68.7766,usage_user=73.4831 792000000000 +cpu,cpu=3 usage_idle=28.0593,usage_system=12.5433,usage_user=15.8607 793000000000 +cpu,cpu=4 usage_idle=69.9784,usage_system=50.4399,usage_user=57.8825 794000000000 +cpu,cpu=0 usage_idle=45.5477,usage_system=25.7778,usage_user=47.6366 795000000000 +cpu,cpu=1 usage_idle=23.6071,usage_system=66.1914,usage_user=89.6026 796000000000 +cpu,cpu=2 usage_idle=66.9759,usage_system=56.9198,usage_user=39.6091 797000000000 +cpu,cpu=3 usage_idle=64.5693,usage_system=37.7377,usage_user=74.7942 798000000000 +cpu,cpu=4 usage_idle=30.508,usage_system=51.6203,usage_user=20.0847 799000000000 +cpu,cpu=0 usage_idle=35.8727,usage_system=54.8938,usage_user=31.4054 800000000000 +cpu,cpu=1 usage_idle=29.7849,usage_system=67.575,usage_user=85.2622 801000000000 +cpu,cpu=2 usage_idle=47.3345,usage_system=95.5938,usage_user=54.0389 802000000000 +cpu,cpu=3 usage_idle=20.8175,usage_system=23.6531,usage_user=66.5822 803000000000 +cpu,cpu=4 usage_idle=36.6783,usage_system=93.6315,usage_user=17.0221 804000000000 +cpu,cpu=0 usage_idle=94.5608,usage_system=39.1792,usage_user=42.7999 805000000000 +cpu,cpu=1 usage_idle=42.1975,usage_system=62.7863,usage_user=8.99137 806000000000 +cpu,cpu=2 usage_idle=31.8,usage_system=29.7622,usage_user=65.9112 807000000000 +cpu,cpu=3 usage_idle=71.4091,usage_system=94.3315,usage_user=3.64889 808000000000 +cpu,cpu=4 usage_idle=46.2033,usage_system=24.8395,usage_user=55.2692 809000000000 +cpu,cpu=0 usage_idle=66.288,usage_system=60.7122,usage_user=10.163 810000000000 +cpu,cpu=1 usage_idle=97.6935,usage_system=90.4971,usage_user=77.738 811000000000 +cpu,cpu=2 usage_idle=82.9557,usage_system=37.8316,usage_user=73.3318 812000000000 +cpu,cpu=3 usage_idle=36.9946,usage_system=58.6491,usage_user=96.9849 813000000000 +cpu,cpu=4 usage_idle=3.57674,usage_system=95.3274,usage_user=90.6164 814000000000 +cpu,cpu=0 usage_idle=20.5989,usage_system=89.8882,usage_user=29.7956 815000000000 +cpu,cpu=1 usage_idle=63.3988,usage_system=32.0857,usage_user=92.5819 816000000000 +cpu,cpu=2 usage_idle=72.3902,usage_system=63.8857,usage_user=22.3441 817000000000 +cpu,cpu=3 usage_idle=38.3013,usage_system=35.2948,usage_user=16.6755 818000000000 +cpu,cpu=4 usage_idle=41.9502,usage_system=81.4982,usage_user=41.515 819000000000 +cpu,cpu=0 usage_idle=97.2194,usage_system=47.7862,usage_user=2.22729 820000000000 +cpu,cpu=1 usage_idle=7.38238,usage_system=45.4797,usage_user=92.7244 821000000000 +cpu,cpu=2 usage_idle=85.1204,usage_system=28.4354,usage_user=30.556 822000000000 +cpu,cpu=3 usage_idle=58.4522,usage_system=65.4299,usage_user=89.2051 823000000000 +cpu,cpu=4 usage_idle=55.4371,usage_system=69.0067,usage_user=84.5325 824000000000 +cpu,cpu=0 usage_idle=46.0535,usage_system=89.6055,usage_user=74.4207 825000000000 +cpu,cpu=1 usage_idle=75.8491,usage_system=53.0043,usage_user=6.50635 826000000000 +cpu,cpu=2 usage_idle=68.431,usage_system=25.3945,usage_user=70.3921 827000000000 +cpu,cpu=3 usage_idle=90.775,usage_system=63.6959,usage_user=5.6869 828000000000 +cpu,cpu=4 usage_idle=7.45054,usage_system=5.64608,usage_user=87.1851 829000000000 +cpu,cpu=0 usage_idle=48.9656,usage_system=2.86548,usage_user=34.9713 830000000000 +cpu,cpu=1 usage_idle=51.1929,usage_system=10.2479,usage_user=80.451 831000000000 +cpu,cpu=2 usage_idle=43.9173,usage_system=95.3683,usage_user=8.88636 832000000000 +cpu,cpu=3 usage_idle=74.4732,usage_system=53.8205,usage_user=74.3163 833000000000 +cpu,cpu=4 usage_idle=63.6783,usage_system=9.2576,usage_user=43.323 834000000000 +cpu,cpu=0 usage_idle=48.2107,usage_system=55.3111,usage_user=32.9285 835000000000 +cpu,cpu=1 usage_idle=22.6314,usage_system=31.1602,usage_user=85.9329 836000000000 +cpu,cpu=2 usage_idle=29.1378,usage_system=99.5912,usage_user=11.3274 837000000000 +cpu,cpu=3 usage_idle=99.5298,usage_system=90.3662,usage_user=75.0232 838000000000 +cpu,cpu=4 usage_idle=5.21674,usage_system=97.8167,usage_user=80.6693 839000000000 +cpu,cpu=0 usage_idle=92.4018,usage_system=46.7823,usage_user=83.5348 840000000000 +cpu,cpu=1 usage_idle=27.3731,usage_system=97.9752,usage_user=93.7826 841000000000 +cpu,cpu=2 usage_idle=7.82409,usage_system=41.8925,usage_user=89.1509 842000000000 +cpu,cpu=3 usage_idle=16.7104,usage_system=16.3657,usage_user=42.9714 843000000000 +cpu,cpu=4 usage_idle=91.0267,usage_system=80.044,usage_user=52.229 844000000000 +cpu,cpu=0 usage_idle=34.3497,usage_system=28.2547,usage_user=7.54011 845000000000 +cpu,cpu=1 usage_idle=67.2782,usage_system=50.8861,usage_user=38.7003 846000000000 +cpu,cpu=2 usage_idle=53.2111,usage_system=80.0239,usage_user=38.2915 847000000000 +cpu,cpu=3 usage_idle=64.5385,usage_system=79.5537,usage_user=28.6577 848000000000 +cpu,cpu=4 usage_idle=39.5617,usage_system=84.7705,usage_user=26.4745 849000000000 +cpu,cpu=0 usage_idle=20.231,usage_system=77.1723,usage_user=73.2568 850000000000 +cpu,cpu=1 usage_idle=3.76578,usage_system=4.54541,usage_user=71.232 851000000000 +cpu,cpu=2 usage_idle=97.5484,usage_system=12.3695,usage_user=13.1244 852000000000 +cpu,cpu=3 usage_idle=86.6993,usage_system=29.0799,usage_user=29.4901 853000000000 +cpu,cpu=4 usage_idle=29.6707,usage_system=20.1067,usage_user=9.53408 854000000000 +cpu,cpu=0 usage_idle=81.8996,usage_system=54.4564,usage_user=37.7888 855000000000 +cpu,cpu=1 usage_idle=89.4397,usage_system=21.7346,usage_user=88.6749 856000000000 +cpu,cpu=2 usage_idle=28.1401,usage_system=74.9457,usage_user=68.6988 857000000000 +cpu,cpu=3 usage_idle=66.4316,usage_system=39.4842,usage_user=48.2525 858000000000 +cpu,cpu=4 usage_idle=95.0893,usage_system=79.0458,usage_user=33.023 859000000000 +cpu,cpu=0 usage_idle=21.5638,usage_system=99.2768,usage_user=10.1953 860000000000 +cpu,cpu=1 usage_idle=94.8206,usage_system=3.04262,usage_user=14.7407 861000000000 +cpu,cpu=2 usage_idle=66.0526,usage_system=0.591033,usage_user=27.1102 862000000000 +cpu,cpu=3 usage_idle=79.177,usage_system=87.2903,usage_user=56.1902 863000000000 +cpu,cpu=4 usage_idle=8.66714,usage_system=16.961,usage_user=76.2968 864000000000 +cpu,cpu=0 usage_idle=18.2012,usage_system=98.8606,usage_user=30.7532 865000000000 +cpu,cpu=1 usage_idle=55.99,usage_system=88.3004,usage_user=52.4878 866000000000 +cpu,cpu=2 usage_idle=44.6649,usage_system=16.4405,usage_user=27.4335 867000000000 +cpu,cpu=3 usage_idle=13.3637,usage_system=82.8721,usage_user=66.9177 868000000000 +cpu,cpu=4 usage_idle=61.6163,usage_system=77.9615,usage_user=45.9635 869000000000 +cpu,cpu=0 usage_idle=94.6393,usage_system=99.5253,usage_user=45.2404 870000000000 +cpu,cpu=1 usage_idle=4.8346,usage_system=94.3459,usage_user=48.283 871000000000 +cpu,cpu=2 usage_idle=19.5753,usage_system=60.3984,usage_user=48.874 872000000000 +cpu,cpu=3 usage_idle=46.6855,usage_system=39.5754,usage_user=36.1644 873000000000 +cpu,cpu=4 usage_idle=2.8757,usage_system=48.2426,usage_user=53.1254 874000000000 +cpu,cpu=0 usage_idle=79.1725,usage_system=66.4438,usage_user=51.986 875000000000 +cpu,cpu=1 usage_idle=9.92575,usage_system=22.4338,usage_user=40.2864 876000000000 +cpu,cpu=2 usage_idle=62.4136,usage_system=67.0987,usage_user=56.7269 877000000000 +cpu,cpu=3 usage_idle=89.8471,usage_system=80.4625,usage_user=39.599 878000000000 +cpu,cpu=4 usage_idle=56.7648,usage_system=42.0787,usage_user=17.5605 879000000000 +cpu,cpu=0 usage_idle=2.72838,usage_system=36.718,usage_user=17.0857 880000000000 +cpu,cpu=1 usage_idle=47.9688,usage_system=41.5526,usage_user=11.4316 881000000000 +cpu,cpu=2 usage_idle=96.2518,usage_system=61.1279,usage_user=71.83 882000000000 +cpu,cpu=3 usage_idle=45.1258,usage_system=7.81347,usage_user=11.4054 883000000000 +cpu,cpu=4 usage_idle=81.2902,usage_system=10.6892,usage_user=59.648 884000000000 +cpu,cpu=0 usage_idle=34.4156,usage_system=89.8617,usage_user=26.0918 885000000000 +cpu,cpu=1 usage_idle=86.4016,usage_system=99.7875,usage_user=48.5257 886000000000 +cpu,cpu=2 usage_idle=26.688,usage_system=62.2011,usage_user=15.6244 887000000000 +cpu,cpu=3 usage_idle=83.4149,usage_system=52.0482,usage_user=96.0868 888000000000 +cpu,cpu=4 usage_idle=23.0139,usage_system=8.81301,usage_user=38.1656 889000000000 +cpu,cpu=0 usage_idle=40.5744,usage_system=11.5414,usage_user=74.8836 890000000000 +cpu,cpu=1 usage_idle=57.6601,usage_system=59.5102,usage_user=16.4362 891000000000 +cpu,cpu=2 usage_idle=69.0917,usage_system=55.7619,usage_user=77.5641 892000000000 +cpu,cpu=3 usage_idle=40.9217,usage_system=0.887705,usage_user=85.3776 893000000000 +cpu,cpu=4 usage_idle=52.3271,usage_system=82.1779,usage_user=96.0668 894000000000 +cpu,cpu=0 usage_idle=11.9752,usage_system=16.5934,usage_user=85.9285 895000000000 +cpu,cpu=1 usage_idle=38.067,usage_system=2.99502,usage_user=85.7159 896000000000 +cpu,cpu=2 usage_idle=86.5927,usage_system=29.683,usage_user=47.917 897000000000 +cpu,cpu=3 usage_idle=2.21705,usage_system=13.0979,usage_user=99.9652 898000000000 +cpu,cpu=4 usage_idle=98.3039,usage_system=36.1119,usage_user=8.77818 899000000000 +cpu,cpu=0 usage_idle=36.4695,usage_system=76.6862,usage_user=20.3196 900000000000 +cpu,cpu=1 usage_idle=11.353,usage_system=34.3464,usage_user=79.8297 901000000000 +cpu,cpu=2 usage_idle=27.7892,usage_system=3.43803,usage_user=35.5916 902000000000 +cpu,cpu=3 usage_idle=5.35336,usage_system=44.3597,usage_user=36.4793 903000000000 +cpu,cpu=4 usage_idle=90.731,usage_system=96.6868,usage_user=18.6572 904000000000 +cpu,cpu=0 usage_idle=86.7977,usage_system=8.662,usage_user=35.2506 905000000000 +cpu,cpu=1 usage_idle=72.7262,usage_system=46.729,usage_user=38.2457 906000000000 +cpu,cpu=2 usage_idle=58.4421,usage_system=33.3217,usage_user=67.9287 907000000000 +cpu,cpu=3 usage_idle=6.35912,usage_system=35.5387,usage_user=81.0266 908000000000 +cpu,cpu=4 usage_idle=6.32429,usage_system=33.8426,usage_user=17.1385 909000000000 +cpu,cpu=0 usage_idle=15.1025,usage_system=70.3121,usage_user=93.8247 910000000000 +cpu,cpu=1 usage_idle=35.4221,usage_system=81.6651,usage_user=28.1711 911000000000 +cpu,cpu=2 usage_idle=15.2518,usage_system=9.45434,usage_user=31.6091 912000000000 +cpu,cpu=3 usage_idle=50.8434,usage_system=14.8077,usage_user=75.9688 913000000000 +cpu,cpu=4 usage_idle=87.3228,usage_system=5.53866,usage_user=72.6557 914000000000 +cpu,cpu=0 usage_idle=5.97998,usage_system=92.3364,usage_user=81.3177 915000000000 +cpu,cpu=1 usage_idle=41.2306,usage_system=65.0626,usage_user=28.0467 916000000000 +cpu,cpu=2 usage_idle=79.4763,usage_system=23.5047,usage_user=61.3683 917000000000 +cpu,cpu=3 usage_idle=47.405,usage_system=29.8639,usage_user=96.907 918000000000 +cpu,cpu=4 usage_idle=28.4316,usage_system=36.1881,usage_user=30.7496 919000000000 +cpu,cpu=0 usage_idle=45.5701,usage_system=51.2906,usage_user=1.06171 920000000000 +cpu,cpu=1 usage_idle=39.3948,usage_system=86.7127,usage_user=82.7268 921000000000 +cpu,cpu=2 usage_idle=67.5659,usage_system=1.96445,usage_user=92.1812 922000000000 +cpu,cpu=3 usage_idle=99.1751,usage_system=52.8079,usage_user=6.98885 923000000000 +cpu,cpu=4 usage_idle=75.1439,usage_system=40.1306,usage_user=12.5275 924000000000 +cpu,cpu=0 usage_idle=47.7996,usage_system=46.1106,usage_user=4.8639 925000000000 +cpu,cpu=1 usage_idle=29.1173,usage_system=87.3412,usage_user=69.9265 926000000000 +cpu,cpu=2 usage_idle=57.1639,usage_system=66.8175,usage_user=93.4312 927000000000 +cpu,cpu=3 usage_idle=18.5323,usage_system=14.2225,usage_user=23.2951 928000000000 +cpu,cpu=4 usage_idle=15.4393,usage_system=42.6541,usage_user=59.4832 929000000000 +cpu,cpu=0 usage_idle=46.189,usage_system=88.2242,usage_user=10.7738 930000000000 +cpu,cpu=1 usage_idle=47.2507,usage_system=27.619,usage_user=97.4865 931000000000 +cpu,cpu=2 usage_idle=29.9775,usage_system=95.185,usage_user=99.451 932000000000 +cpu,cpu=3 usage_idle=22.1587,usage_system=94.3601,usage_user=52.2588 933000000000 +cpu,cpu=4 usage_idle=29.1475,usage_system=69.504,usage_user=92.3895 934000000000 +cpu,cpu=0 usage_idle=41.675,usage_system=17.3036,usage_user=38.5001 935000000000 +cpu,cpu=1 usage_idle=46.5389,usage_system=46.4208,usage_user=25.8413 936000000000 +cpu,cpu=2 usage_idle=16.4654,usage_system=3.58477,usage_user=92.6589 937000000000 +cpu,cpu=3 usage_idle=9.89663,usage_system=22.1171,usage_user=6.88135 938000000000 +cpu,cpu=4 usage_idle=33.1917,usage_system=37.5564,usage_user=49.5355 939000000000 +cpu,cpu=0 usage_idle=92.6749,usage_system=83.7454,usage_user=37.7597 940000000000 +cpu,cpu=1 usage_idle=3.44874,usage_system=30.9961,usage_user=65.3787 941000000000 +cpu,cpu=2 usage_idle=0.935241,usage_system=60.9736,usage_user=60.5637 942000000000 +cpu,cpu=3 usage_idle=0.386199,usage_system=83.1323,usage_user=54.9238 943000000000 +cpu,cpu=4 usage_idle=52.645,usage_system=12.2798,usage_user=24.4277 944000000000 +cpu,cpu=0 usage_idle=45.0345,usage_system=53.9549,usage_user=41.7313 945000000000 +cpu,cpu=1 usage_idle=83.5346,usage_system=0.493794,usage_user=88.1521 946000000000 +cpu,cpu=2 usage_idle=9.37589,usage_system=16.9592,usage_user=91.7369 947000000000 +cpu,cpu=3 usage_idle=2.03474,usage_system=26.8558,usage_user=13.8539 948000000000 +cpu,cpu=4 usage_idle=8.9161,usage_system=60.0475,usage_user=51.4103 949000000000 +cpu,cpu=0 usage_idle=58.4516,usage_system=52.7224,usage_user=35.1557 950000000000 +cpu,cpu=1 usage_idle=96.2112,usage_system=56.1712,usage_user=66.1518 951000000000 +cpu,cpu=2 usage_idle=61.5899,usage_system=57.1064,usage_user=27.1254 952000000000 +cpu,cpu=3 usage_idle=22.1536,usage_system=57.4926,usage_user=10.2577 953000000000 +cpu,cpu=4 usage_idle=77.0774,usage_system=10.1377,usage_user=22.5375 954000000000 +cpu,cpu=0 usage_idle=1.5051,usage_system=55.1721,usage_user=76.4924 955000000000 +cpu,cpu=1 usage_idle=43.2364,usage_system=38.7067,usage_user=76.9862 956000000000 +cpu,cpu=2 usage_idle=31.3885,usage_system=48.0826,usage_user=93.9454 957000000000 +cpu,cpu=3 usage_idle=23.1253,usage_system=50.1174,usage_user=20.8012 958000000000 +cpu,cpu=4 usage_idle=36.9793,usage_system=59.0334,usage_user=80.8488 959000000000 +cpu,cpu=0 usage_idle=88.3896,usage_system=17.485,usage_user=33.5712 960000000000 +cpu,cpu=1 usage_idle=23.5453,usage_system=13.6962,usage_user=89.7424 961000000000 +cpu,cpu=2 usage_idle=89.6971,usage_system=75.2861,usage_user=46.8488 962000000000 +cpu,cpu=3 usage_idle=16.8225,usage_system=97.4398,usage_user=4.34146 963000000000 +cpu,cpu=4 usage_idle=27.0803,usage_system=74.5172,usage_user=14.4791 964000000000 +cpu,cpu=0 usage_idle=49.6178,usage_system=76.0223,usage_user=69.6513 965000000000 +cpu,cpu=1 usage_idle=26.1102,usage_system=19.2586,usage_user=8.35797 966000000000 +cpu,cpu=2 usage_idle=3.09635,usage_system=50.6471,usage_user=56.4406 967000000000 +cpu,cpu=3 usage_idle=97.0417,usage_system=73.7725,usage_user=6.55793 968000000000 +cpu,cpu=4 usage_idle=17.843,usage_system=10.7517,usage_user=65.5914 969000000000 +cpu,cpu=0 usage_idle=98.6918,usage_system=99.1413,usage_user=83.0764 970000000000 +cpu,cpu=1 usage_idle=32.263,usage_system=22.6866,usage_user=96.7726 971000000000 +cpu,cpu=2 usage_idle=22.0054,usage_system=12.3838,usage_user=72.0587 972000000000 +cpu,cpu=3 usage_idle=68.8542,usage_system=29.2063,usage_user=69.4985 973000000000 +cpu,cpu=4 usage_idle=73.1957,usage_system=56.2866,usage_user=44.0157 974000000000 +cpu,cpu=0 usage_idle=87.6748,usage_system=5.90435,usage_user=20.0379 975000000000 +cpu,cpu=1 usage_idle=57.3261,usage_system=32.0145,usage_user=39.2965 976000000000 +cpu,cpu=2 usage_idle=65.684,usage_system=35.1109,usage_user=89.9437 977000000000 +cpu,cpu=3 usage_idle=22.1246,usage_system=32.1526,usage_user=63.7161 978000000000 +cpu,cpu=4 usage_idle=28.6825,usage_system=49.9956,usage_user=74.4678 979000000000 +cpu,cpu=0 usage_idle=94.2739,usage_system=48.6873,usage_user=73.6092 980000000000 +cpu,cpu=1 usage_idle=77.3503,usage_system=80.9503,usage_user=96.2958 981000000000 +cpu,cpu=2 usage_idle=74.1229,usage_system=2.95571,usage_user=8.67955 982000000000 +cpu,cpu=3 usage_idle=46.1816,usage_system=71.8099,usage_user=37.8859 983000000000 +cpu,cpu=4 usage_idle=15.6801,usage_system=45.0056,usage_user=94.1724 984000000000 +cpu,cpu=0 usage_idle=59.6958,usage_system=32.6804,usage_user=0.0767693 985000000000 +cpu,cpu=1 usage_idle=79.7337,usage_system=90.0065,usage_user=32.0913 986000000000 +cpu,cpu=2 usage_idle=19.0303,usage_system=55.6905,usage_user=67.2021 987000000000 +cpu,cpu=3 usage_idle=8.97392,usage_system=77.8152,usage_user=99.3547 988000000000 +cpu,cpu=4 usage_idle=72.69,usage_system=6.49769,usage_user=49.3503 989000000000 +cpu,cpu=0 usage_idle=47.1579,usage_system=0.771607,usage_user=98.0376 990000000000 +cpu,cpu=1 usage_idle=20.767,usage_system=78.1219,usage_user=78.9879 991000000000 +cpu,cpu=2 usage_idle=17.0628,usage_system=52.2448,usage_user=81.9437 992000000000 +cpu,cpu=3 usage_idle=25.7423,usage_system=98.4264,usage_user=53.7536 993000000000 +cpu,cpu=4 usage_idle=63.6282,usage_system=14.1065,usage_user=98.7592 994000000000 +cpu,cpu=0 usage_idle=57.8006,usage_system=73.8023,usage_user=31.4397 995000000000 +cpu,cpu=1 usage_idle=57.8774,usage_system=53.536,usage_user=21.4462 996000000000 +cpu,cpu=2 usage_idle=89.9687,usage_system=72.5663,usage_user=77.1367 997000000000 +cpu,cpu=3 usage_idle=57.1708,usage_system=81.5402,usage_user=54.9519 998000000000 +cpu,cpu=4 usage_idle=56.5256,usage_system=54.2303,usage_user=61.4496 999000000000 +cpu,cpu=0 usage_idle=5.87587,usage_system=1.38811,usage_user=62.2212 1000000000000 +cpu,cpu=1 usage_idle=3.91351,usage_system=22.1551,usage_user=40.3431 1001000000000 +cpu,cpu=2 usage_idle=82.9015,usage_system=39.2179,usage_user=92.5878 1002000000000 +cpu,cpu=3 usage_idle=64.8451,usage_system=64.9603,usage_user=91.0142 1003000000000 +cpu,cpu=4 usage_idle=18.5987,usage_system=28.5885,usage_user=5.12077 1004000000000 +cpu,cpu=0 usage_idle=17.3579,usage_system=86.3891,usage_user=78.9231 1005000000000 +cpu,cpu=1 usage_idle=48.7976,usage_system=44.2665,usage_user=32.4591 1006000000000 +cpu,cpu=2 usage_idle=70.2437,usage_system=34.2352,usage_user=5.02544 1007000000000 +cpu,cpu=3 usage_idle=47.3805,usage_system=91.406,usage_user=86.5657 1008000000000 +cpu,cpu=4 usage_idle=2.33231,usage_system=47.9315,usage_user=40.7959 1009000000000 +cpu,cpu=0 usage_idle=63.7819,usage_system=53.8074,usage_user=42.184 1010000000000 +cpu,cpu=1 usage_idle=26.003,usage_system=57.7209,usage_user=64.3391 1011000000000 +cpu,cpu=2 usage_idle=66.3461,usage_system=40.6224,usage_user=3.55706 1012000000000 +cpu,cpu=3 usage_idle=58.9339,usage_system=5.46747,usage_user=68.5173 1013000000000 +cpu,cpu=4 usage_idle=49.9481,usage_system=24.0662,usage_user=97.1058 1014000000000 +cpu,cpu=0 usage_idle=55.0689,usage_system=41.4241,usage_user=83.4949 1015000000000 +cpu,cpu=1 usage_idle=33.992,usage_system=90.2217,usage_user=27.7614 1016000000000 +cpu,cpu=2 usage_idle=66.4511,usage_system=60.4654,usage_user=61.9965 1017000000000 +cpu,cpu=3 usage_idle=71.4766,usage_system=7.84585,usage_user=53.4025 1018000000000 +cpu,cpu=4 usage_idle=58.0422,usage_system=10.1782,usage_user=1.33406 1019000000000 +cpu,cpu=0 usage_idle=98.8382,usage_system=73.96,usage_user=55.1415 1020000000000 +cpu,cpu=1 usage_idle=41.0222,usage_system=99.963,usage_user=12.8624 1021000000000 +cpu,cpu=2 usage_idle=5.36133,usage_system=66.3091,usage_user=53.4848 1022000000000 +cpu,cpu=3 usage_idle=8.91839,usage_system=25.243,usage_user=58.9522 1023000000000 +cpu,cpu=4 usage_idle=77.4357,usage_system=75.1912,usage_user=83.0184 1024000000000 +cpu,cpu=0 usage_idle=74.5415,usage_system=30.2601,usage_user=24.4425 1025000000000 +cpu,cpu=1 usage_idle=58.0364,usage_system=64.2521,usage_user=14.6641 1026000000000 +cpu,cpu=2 usage_idle=85.7978,usage_system=30.7032,usage_user=75.1295 1027000000000 +cpu,cpu=3 usage_idle=47.7943,usage_system=2.17983,usage_user=82.9754 1028000000000 +cpu,cpu=4 usage_idle=1.19682,usage_system=60.2221,usage_user=93.1535 1029000000000 +cpu,cpu=0 usage_idle=2.53088,usage_system=59.0602,usage_user=67.1135 1030000000000 +cpu,cpu=1 usage_idle=57.6724,usage_system=0.0824207,usage_user=67.0766 1031000000000 +cpu,cpu=2 usage_idle=70.5347,usage_system=5.44375,usage_user=33.3857 1032000000000 +cpu,cpu=3 usage_idle=24.0195,usage_system=14.3621,usage_user=58.6288 1033000000000 +cpu,cpu=4 usage_idle=82.9717,usage_system=91.7979,usage_user=33.8199 1034000000000 +cpu,cpu=0 usage_idle=65.9901,usage_system=66.3394,usage_user=64.08 1035000000000 +cpu,cpu=1 usage_idle=90.4326,usage_system=24.3758,usage_user=28.3321 1036000000000 +cpu,cpu=2 usage_idle=5.09667,usage_system=10.1735,usage_user=59.0354 1037000000000 +cpu,cpu=3 usage_idle=80.2262,usage_system=57.9678,usage_user=61.2152 1038000000000 +cpu,cpu=4 usage_idle=63.2015,usage_system=59.1647,usage_user=21.4373 1039000000000 +cpu,cpu=0 usage_idle=56.355,usage_system=61.6955,usage_user=80.4975 1040000000000 +cpu,cpu=1 usage_idle=23.4686,usage_system=19.3679,usage_user=80.5799 1041000000000 +cpu,cpu=2 usage_idle=90.5452,usage_system=89.9026,usage_user=86.0237 1042000000000 +cpu,cpu=3 usage_idle=23.9309,usage_system=13.9221,usage_user=0.385829 1043000000000 +cpu,cpu=4 usage_idle=82.5596,usage_system=96.8939,usage_user=92.1837 1044000000000 +cpu,cpu=0 usage_idle=16.3796,usage_system=62.884,usage_user=58.523 1045000000000 +cpu,cpu=1 usage_idle=80.4596,usage_system=53.3165,usage_user=82.8988 1046000000000 +cpu,cpu=2 usage_idle=8.79172,usage_system=58.4132,usage_user=93.0723 1047000000000 +cpu,cpu=3 usage_idle=67.8271,usage_system=38.6394,usage_user=51.0402 1048000000000 +cpu,cpu=4 usage_idle=29.0423,usage_system=1.84091,usage_user=10.2048 1049000000000 +cpu,cpu=0 usage_idle=50.4796,usage_system=58.196,usage_user=71.9004 1050000000000 +cpu,cpu=1 usage_idle=30.9771,usage_system=81.6645,usage_user=91.2683 1051000000000 +cpu,cpu=2 usage_idle=11.5571,usage_system=72.2097,usage_user=81.1709 1052000000000 +cpu,cpu=3 usage_idle=97.5807,usage_system=96.1406,usage_user=95.093 1053000000000 +cpu,cpu=4 usage_idle=97.9666,usage_system=78.7003,usage_user=91.9869 1054000000000 +cpu,cpu=0 usage_idle=90.1503,usage_system=95.0798,usage_user=54.8708 1055000000000 +cpu,cpu=1 usage_idle=48.6733,usage_system=75.5394,usage_user=8.18735 1056000000000 +cpu,cpu=2 usage_idle=31.5721,usage_system=84.3312,usage_user=66.6005 1057000000000 +cpu,cpu=3 usage_idle=24.6445,usage_system=52.1583,usage_user=5.23992 1058000000000 +cpu,cpu=4 usage_idle=75.6846,usage_system=81.2006,usage_user=7.08083 1059000000000 +cpu,cpu=0 usage_idle=85.8895,usage_system=31.6802,usage_user=65.2768 1060000000000 +cpu,cpu=1 usage_idle=57.7898,usage_system=62.6573,usage_user=46.9413 1061000000000 +cpu,cpu=2 usage_idle=49.0581,usage_system=74.2143,usage_user=19.1511 1062000000000 +cpu,cpu=3 usage_idle=30.229,usage_system=71.7951,usage_user=15.2917 1063000000000 +cpu,cpu=4 usage_idle=25.322,usage_system=69.7616,usage_user=93.992 1064000000000 +cpu,cpu=0 usage_idle=17.3089,usage_system=59.9119,usage_user=89.0718 1065000000000 +cpu,cpu=1 usage_idle=72.1797,usage_system=8.58521,usage_user=64.6113 1066000000000 +cpu,cpu=2 usage_idle=80.367,usage_system=40.1573,usage_user=48.9424 1067000000000 +cpu,cpu=3 usage_idle=46.9676,usage_system=64.8018,usage_user=1.10069 1068000000000 +cpu,cpu=4 usage_idle=52.2075,usage_system=40.4864,usage_user=82.3013 1069000000000 +cpu,cpu=0 usage_idle=59.2883,usage_system=26.3759,usage_user=13.9814 1070000000000 +cpu,cpu=1 usage_idle=24.5651,usage_system=84.1657,usage_user=76.6387 1071000000000 +cpu,cpu=2 usage_idle=71.5065,usage_system=33.2238,usage_user=50.853 1072000000000 +cpu,cpu=3 usage_idle=90.6575,usage_system=63.4528,usage_user=22.6481 1073000000000 +cpu,cpu=4 usage_idle=5.94924,usage_system=88.7748,usage_user=92.4097 1074000000000 +cpu,cpu=0 usage_idle=99.9412,usage_system=6.08362,usage_user=52.3216 1075000000000 +cpu,cpu=1 usage_idle=89.013,usage_system=78.2633,usage_user=60.9068 1076000000000 +cpu,cpu=2 usage_idle=53.6243,usage_system=58.6303,usage_user=1.06416 1077000000000 +cpu,cpu=3 usage_idle=2.56669,usage_system=5.59791,usage_user=65.8659 1078000000000 +cpu,cpu=4 usage_idle=3.66738,usage_system=57.8054,usage_user=6.35237 1079000000000 +cpu,cpu=0 usage_idle=85.9686,usage_system=17.0937,usage_user=32.7282 1080000000000 +cpu,cpu=1 usage_idle=99.95,usage_system=41.6589,usage_user=16.894 1081000000000 +cpu,cpu=2 usage_idle=76.5887,usage_system=13.1653,usage_user=50.1178 1082000000000 +cpu,cpu=3 usage_idle=27.4417,usage_system=3.82287,usage_user=13.5705 1083000000000 +cpu,cpu=4 usage_idle=50.0898,usage_system=9.77211,usage_user=2.34531 1084000000000 +cpu,cpu=0 usage_idle=42.4995,usage_system=9.71331,usage_user=8.42894 1085000000000 +cpu,cpu=1 usage_idle=94.8211,usage_system=98.7263,usage_user=86.6922 1086000000000 +cpu,cpu=2 usage_idle=55.7279,usage_system=52.3506,usage_user=45.3226 1087000000000 +cpu,cpu=3 usage_idle=56.7921,usage_system=54.9173,usage_user=50.9205 1088000000000 +cpu,cpu=4 usage_idle=22.658,usage_system=58.5846,usage_user=8.72588 1089000000000 +cpu,cpu=0 usage_idle=29.0104,usage_system=44.5533,usage_user=25.8196 1090000000000 +cpu,cpu=1 usage_idle=61.7387,usage_system=44.5033,usage_user=67.4785 1091000000000 +cpu,cpu=2 usage_idle=78.6326,usage_system=21.092,usage_user=80.6438 1092000000000 +cpu,cpu=3 usage_idle=28.7504,usage_system=48.5337,usage_user=84.4667 1093000000000 +cpu,cpu=4 usage_idle=42.3209,usage_system=98.6235,usage_user=94.2388 1094000000000 +cpu,cpu=0 usage_idle=44.6662,usage_system=41.123,usage_user=3.9521 1095000000000 +cpu,cpu=1 usage_idle=53.0952,usage_system=35.9441,usage_user=2.67842 1096000000000 +cpu,cpu=2 usage_idle=39.7874,usage_system=91.672,usage_user=55.029 1097000000000 +cpu,cpu=3 usage_idle=85.11,usage_system=48.4641,usage_user=9.94628 1098000000000 +cpu,cpu=4 usage_idle=36.0305,usage_system=71.1222,usage_user=68.5309 1099000000000 +cpu,cpu=0 usage_idle=44.7564,usage_system=0.132573,usage_user=13.0842 1100000000000 +cpu,cpu=1 usage_idle=70.576,usage_system=61.8712,usage_user=57.5875 1101000000000 +cpu,cpu=2 usage_idle=38.0544,usage_system=40.5038,usage_user=78.6796 1102000000000 +cpu,cpu=3 usage_idle=18.6983,usage_system=69.2542,usage_user=27.2133 1103000000000 +cpu,cpu=4 usage_idle=3.16495,usage_system=11.5752,usage_user=25.8368 1104000000000 +cpu,cpu=0 usage_idle=97.4037,usage_system=56.2414,usage_user=66.9598 1105000000000 +cpu,cpu=1 usage_idle=1.35584,usage_system=9.33659,usage_user=2.90395 1106000000000 +cpu,cpu=2 usage_idle=4.03427,usage_system=49.124,usage_user=94.576 1107000000000 +cpu,cpu=3 usage_idle=59.0633,usage_system=34.234,usage_user=43.0401 1108000000000 +cpu,cpu=4 usage_idle=69.0096,usage_system=70.2645,usage_user=14.1623 1109000000000 +cpu,cpu=0 usage_idle=37.5405,usage_system=15.0208,usage_user=14.2949 1110000000000 +cpu,cpu=1 usage_idle=50.6247,usage_system=85.5968,usage_user=76.1661 1111000000000 +cpu,cpu=2 usage_idle=8.21224,usage_system=23.6512,usage_user=16.6699 1112000000000 +cpu,cpu=3 usage_idle=86.8918,usage_system=42.3495,usage_user=85.9242 1113000000000 +cpu,cpu=4 usage_idle=14.1051,usage_system=45.5145,usage_user=97.4993 1114000000000 +cpu,cpu=0 usage_idle=39.942,usage_system=42.9182,usage_user=53.7407 1115000000000 +cpu,cpu=1 usage_idle=6.90179,usage_system=44.274,usage_user=63.0773 1116000000000 +cpu,cpu=2 usage_idle=9.80574,usage_system=48.3083,usage_user=12.2013 1117000000000 +cpu,cpu=3 usage_idle=4.38174,usage_system=7.37159,usage_user=46.4353 1118000000000 +cpu,cpu=4 usage_idle=47.4219,usage_system=76.3811,usage_user=16.6998 1119000000000 +cpu,cpu=0 usage_idle=61.5842,usage_system=13.9216,usage_user=31.7206 1120000000000 +cpu,cpu=1 usage_idle=75.879,usage_system=64.5464,usage_user=17.3174 1121000000000 +cpu,cpu=2 usage_idle=52.0451,usage_system=72.7586,usage_user=40.9687 1122000000000 +cpu,cpu=3 usage_idle=68.7151,usage_system=59.6504,usage_user=83.3182 1123000000000 +cpu,cpu=4 usage_idle=54.6393,usage_system=73.7555,usage_user=28.8326 1124000000000 +cpu,cpu=0 usage_idle=52.1386,usage_system=13.6975,usage_user=71.7508 1125000000000 +cpu,cpu=1 usage_idle=5.87931,usage_system=20.5993,usage_user=16.0248 1126000000000 +cpu,cpu=2 usage_idle=68.9566,usage_system=30.405,usage_user=64.3331 1127000000000 +cpu,cpu=3 usage_idle=81.1579,usage_system=34.7868,usage_user=71.7047 1128000000000 +cpu,cpu=4 usage_idle=27.5933,usage_system=82.2086,usage_user=48.0859 1129000000000 +cpu,cpu=0 usage_idle=44.2931,usage_system=43.7928,usage_user=62.0075 1130000000000 +cpu,cpu=1 usage_idle=76.0137,usage_system=19.6719,usage_user=26.5539 1131000000000 +cpu,cpu=2 usage_idle=93.3311,usage_system=71.717,usage_user=99.3125 1132000000000 +cpu,cpu=3 usage_idle=34.2998,usage_system=40.4321,usage_user=58.9629 1133000000000 +cpu,cpu=4 usage_idle=17.6179,usage_system=95.0714,usage_user=32.7184 1134000000000 +cpu,cpu=0 usage_idle=46.4505,usage_system=47.2099,usage_user=46.4159 1135000000000 +cpu,cpu=1 usage_idle=18.2014,usage_system=53.0892,usage_user=67.0152 1136000000000 +cpu,cpu=2 usage_idle=34.2262,usage_system=22.0459,usage_user=97.4202 1137000000000 +cpu,cpu=3 usage_idle=98.5593,usage_system=3.20382,usage_user=32.207 1138000000000 +cpu,cpu=4 usage_idle=70.2641,usage_system=30.7971,usage_user=14.4156 1139000000000 +cpu,cpu=0 usage_idle=18.35,usage_system=75.0902,usage_user=58.2084 1140000000000 +cpu,cpu=1 usage_idle=80.3575,usage_system=51.1039,usage_user=77.8803 1141000000000 +cpu,cpu=2 usage_idle=6.91138,usage_system=44.435,usage_user=49.5973 1142000000000 +cpu,cpu=3 usage_idle=6.22386,usage_system=78.7347,usage_user=90.0294 1143000000000 +cpu,cpu=4 usage_idle=65.1868,usage_system=96.3527,usage_user=85.1007 1144000000000 +cpu,cpu=0 usage_idle=97.9052,usage_system=42.8032,usage_user=32.3107 1145000000000 +cpu,cpu=1 usage_idle=44.3211,usage_system=61.0046,usage_user=85.3999 1146000000000 +cpu,cpu=2 usage_idle=11.3363,usage_system=95.2308,usage_user=7.44578 1147000000000 +cpu,cpu=3 usage_idle=8.75648,usage_system=93.7901,usage_user=10.6496 1148000000000 +cpu,cpu=4 usage_idle=40.9635,usage_system=64.0542,usage_user=41.4467 1149000000000 +cpu,cpu=0 usage_idle=55.3791,usage_system=82.4041,usage_user=16.5369 1150000000000 +cpu,cpu=1 usage_idle=13.5875,usage_system=62.7616,usage_user=67.6407 1151000000000 +cpu,cpu=2 usage_idle=91.4678,usage_system=69.673,usage_user=12.0757 1152000000000 +cpu,cpu=3 usage_idle=41.0651,usage_system=75.8969,usage_user=90.8104 1153000000000 +cpu,cpu=4 usage_idle=31.0944,usage_system=41.0836,usage_user=87.1631 1154000000000 +cpu,cpu=0 usage_idle=16.1952,usage_system=38.9888,usage_user=29.9663 1155000000000 +cpu,cpu=1 usage_idle=48.5059,usage_system=83.3099,usage_user=90.9708 1156000000000 +cpu,cpu=2 usage_idle=33.9058,usage_system=94.6461,usage_user=86.2016 1157000000000 +cpu,cpu=3 usage_idle=41.3516,usage_system=3.40263,usage_user=79.9917 1158000000000 +cpu,cpu=4 usage_idle=52.0012,usage_system=44.3661,usage_user=44.0458 1159000000000 +cpu,cpu=0 usage_idle=93.4478,usage_system=99.7451,usage_user=26.45 1160000000000 +cpu,cpu=1 usage_idle=9.98469,usage_system=13.3326,usage_user=89.2116 1161000000000 +cpu,cpu=2 usage_idle=77.6254,usage_system=4.8004,usage_user=58.8846 1162000000000 +cpu,cpu=3 usage_idle=89.7011,usage_system=45.8655,usage_user=34.7815 1163000000000 +cpu,cpu=4 usage_idle=80.5115,usage_system=76.9599,usage_user=75.8651 1164000000000 +cpu,cpu=0 usage_idle=67.6745,usage_system=93.1551,usage_user=14.8539 1165000000000 +cpu,cpu=1 usage_idle=97.6408,usage_system=41.6609,usage_user=98.1637 1166000000000 +cpu,cpu=2 usage_idle=88.6116,usage_system=75.5667,usage_user=92.8099 1167000000000 +cpu,cpu=3 usage_idle=74.8131,usage_system=16.9183,usage_user=96.2125 1168000000000 +cpu,cpu=4 usage_idle=54.8048,usage_system=68.9194,usage_user=40.5786 1169000000000 +cpu,cpu=0 usage_idle=98.8506,usage_system=62.3672,usage_user=40.3238 1170000000000 +cpu,cpu=1 usage_idle=25.3006,usage_system=72.3519,usage_user=53.6564 1171000000000 +cpu,cpu=2 usage_idle=14.5122,usage_system=49.9773,usage_user=58.4568 1172000000000 +cpu,cpu=3 usage_idle=73.3968,usage_system=39.6784,usage_user=4.32225 1173000000000 +cpu,cpu=4 usage_idle=8.17827,usage_system=20.1899,usage_user=81.2821 1174000000000 +cpu,cpu=0 usage_idle=84.0433,usage_system=87.8644,usage_user=74.4372 1175000000000 +cpu,cpu=1 usage_idle=98.8972,usage_system=85.5051,usage_user=16.0982 1176000000000 +cpu,cpu=2 usage_idle=97.061,usage_system=74.1167,usage_user=91.6649 1177000000000 +cpu,cpu=3 usage_idle=89.8709,usage_system=48.9298,usage_user=8.58311 1178000000000 +cpu,cpu=4 usage_idle=86.0834,usage_system=3.73466,usage_user=77.5025 1179000000000 +cpu,cpu=0 usage_idle=26.662,usage_system=2.58531,usage_user=39.8698 1180000000000 +cpu,cpu=1 usage_idle=66.9857,usage_system=27.8859,usage_user=12.2217 1181000000000 +cpu,cpu=2 usage_idle=20.6421,usage_system=42.3981,usage_user=62.199 1182000000000 +cpu,cpu=3 usage_idle=79.0989,usage_system=15.7949,usage_user=1.87743 1183000000000 +cpu,cpu=4 usage_idle=83.4212,usage_system=23.9732,usage_user=22.0673 1184000000000 +cpu,cpu=0 usage_idle=64.7033,usage_system=8.01656,usage_user=9.93164 1185000000000 +cpu,cpu=1 usage_idle=39.1405,usage_system=6.91378,usage_user=95.4368 1186000000000 +cpu,cpu=2 usage_idle=55.2387,usage_system=3.97475,usage_user=69.5535 1187000000000 +cpu,cpu=3 usage_idle=46.9035,usage_system=93.8456,usage_user=18.4833 1188000000000 +cpu,cpu=4 usage_idle=55.4866,usage_system=79.929,usage_user=22.218 1189000000000 +cpu,cpu=0 usage_idle=32.9892,usage_system=6.59098,usage_user=24.8033 1190000000000 +cpu,cpu=1 usage_idle=72.8589,usage_system=73.5767,usage_user=52.6892 1191000000000 +cpu,cpu=2 usage_idle=85.0806,usage_system=94.2188,usage_user=95.0873 1192000000000 +cpu,cpu=3 usage_idle=47.2796,usage_system=73.3178,usage_user=10.8823 1193000000000 +cpu,cpu=4 usage_idle=49.1571,usage_system=56.7389,usage_user=34.8555 1194000000000 +cpu,cpu=0 usage_idle=71.2244,usage_system=21.4422,usage_user=42.872 1195000000000 +cpu,cpu=1 usage_idle=81.156,usage_system=60.5827,usage_user=49.7858 1196000000000 +cpu,cpu=2 usage_idle=76.5928,usage_system=15.8214,usage_user=53.7606 1197000000000 +cpu,cpu=3 usage_idle=46.1462,usage_system=62.725,usage_user=47.6062 1198000000000 +cpu,cpu=4 usage_idle=64.6295,usage_system=18.2116,usage_user=27.5352 1199000000000 +cpu,cpu=0 usage_idle=86.8475,usage_system=51.2008,usage_user=34.1262 1200000000000 +cpu,cpu=1 usage_idle=11.6508,usage_system=24.0597,usage_user=7.70289 1201000000000 +cpu,cpu=2 usage_idle=64.34,usage_system=9.14027,usage_user=1.92173 1202000000000 +cpu,cpu=3 usage_idle=59.4273,usage_system=56.4199,usage_user=75.2395 1203000000000 +cpu,cpu=4 usage_idle=70.3096,usage_system=5.57698,usage_user=31.9784 1204000000000 +cpu,cpu=0 usage_idle=5.16508,usage_system=76.8013,usage_user=53.4206 1205000000000 +cpu,cpu=1 usage_idle=48.0371,usage_system=57.9573,usage_user=14.0033 1206000000000 +cpu,cpu=2 usage_idle=97.8229,usage_system=34.5501,usage_user=29.8248 1207000000000 +cpu,cpu=3 usage_idle=51.5835,usage_system=80.6963,usage_user=92.5497 1208000000000 +cpu,cpu=4 usage_idle=99.1897,usage_system=45.3259,usage_user=10.7613 1209000000000 +cpu,cpu=0 usage_idle=26.7249,usage_system=32.1734,usage_user=61.9621 1210000000000 +cpu,cpu=1 usage_idle=60.851,usage_system=43.8242,usage_user=86.0217 1211000000000 +cpu,cpu=2 usage_idle=68.5539,usage_system=8.16417,usage_user=95.162 1212000000000 +cpu,cpu=3 usage_idle=70.4757,usage_system=67.5915,usage_user=51.5819 1213000000000 +cpu,cpu=4 usage_idle=45.7151,usage_system=37.9011,usage_user=57.1589 1214000000000 +cpu,cpu=0 usage_idle=77.6935,usage_system=43.0662,usage_user=33.9602 1215000000000 +cpu,cpu=1 usage_idle=31.1141,usage_system=91.1033,usage_user=91.9176 1216000000000 +cpu,cpu=2 usage_idle=45.1175,usage_system=88.9262,usage_user=26.4676 1217000000000 +cpu,cpu=3 usage_idle=74.9422,usage_system=40.5098,usage_user=7.16397 1218000000000 +cpu,cpu=4 usage_idle=67.4919,usage_system=39.6995,usage_user=52.4898 1219000000000 +cpu,cpu=0 usage_idle=78.2533,usage_system=66.4243,usage_user=84.6632 1220000000000 +cpu,cpu=1 usage_idle=40.2153,usage_system=27.2754,usage_user=28.4874 1221000000000 +cpu,cpu=2 usage_idle=26.2371,usage_system=95.8293,usage_user=36.6516 1222000000000 +cpu,cpu=3 usage_idle=21.3991,usage_system=66.3049,usage_user=4.24307 1223000000000 +cpu,cpu=4 usage_idle=72.981,usage_system=12.0201,usage_user=42.1442 1224000000000 +cpu,cpu=0 usage_idle=30.1399,usage_system=89.7136,usage_user=85.2104 1225000000000 +cpu,cpu=1 usage_idle=64.1001,usage_system=20.8278,usage_user=76.3137 1226000000000 +cpu,cpu=2 usage_idle=56.0176,usage_system=65.9452,usage_user=65.2399 1227000000000 +cpu,cpu=3 usage_idle=82.4853,usage_system=40.8875,usage_user=5.74968 1228000000000 +cpu,cpu=4 usage_idle=89.6493,usage_system=8.3794,usage_user=45.4491 1229000000000 +cpu,cpu=0 usage_idle=42.1391,usage_system=86.6327,usage_user=11.8735 1230000000000 +cpu,cpu=1 usage_idle=26.8023,usage_system=26.848,usage_user=39.1488 1231000000000 +cpu,cpu=2 usage_idle=55.2897,usage_system=53.0851,usage_user=34.9781 1232000000000 +cpu,cpu=3 usage_idle=91.9413,usage_system=74.4841,usage_user=1.28304 1233000000000 +cpu,cpu=4 usage_idle=96.1843,usage_system=47.4651,usage_user=13.3031 1234000000000 +cpu,cpu=0 usage_idle=38.3285,usage_system=77.605,usage_user=3.01674 1235000000000 +cpu,cpu=1 usage_idle=23.5388,usage_system=41.7051,usage_user=23.8445 1236000000000 +cpu,cpu=2 usage_idle=99.8525,usage_system=97.7227,usage_user=89.7897 1237000000000 +cpu,cpu=3 usage_idle=65.0924,usage_system=80.208,usage_user=30.6772 1238000000000 +cpu,cpu=4 usage_idle=70.8421,usage_system=69.8573,usage_user=39.0566 1239000000000 +cpu,cpu=0 usage_idle=16.2912,usage_system=11.9964,usage_user=25.6892 1240000000000 +cpu,cpu=1 usage_idle=28.1647,usage_system=38.7987,usage_user=52.5373 1241000000000 +cpu,cpu=2 usage_idle=67.3135,usage_system=94.0884,usage_user=5.62232 1242000000000 +cpu,cpu=3 usage_idle=2.2916,usage_system=86.0296,usage_user=80.1065 1243000000000 +cpu,cpu=4 usage_idle=3.57464,usage_system=82.2139,usage_user=27.5716 1244000000000 +cpu,cpu=0 usage_idle=16.8778,usage_system=20.5424,usage_user=5.17661 1245000000000 +cpu,cpu=1 usage_idle=19.8945,usage_system=44.0813,usage_user=46.8817 1246000000000 +cpu,cpu=2 usage_idle=43.739,usage_system=43.9338,usage_user=44.6045 1247000000000 +cpu,cpu=3 usage_idle=33.5287,usage_system=9.02622,usage_user=24.8125 1248000000000 +cpu,cpu=4 usage_idle=64.2059,usage_system=79.8683,usage_user=94.6698 1249000000000 +cpu,cpu=0 usage_idle=3.2625,usage_system=96.1596,usage_user=6.66617 1250000000000 +cpu,cpu=1 usage_idle=28.9518,usage_system=24.3243,usage_user=45.4649 1251000000000 +cpu,cpu=2 usage_idle=81.489,usage_system=91.6378,usage_user=39.5532 1252000000000 +cpu,cpu=3 usage_idle=87.1113,usage_system=93.9294,usage_user=25.5829 1253000000000 +cpu,cpu=4 usage_idle=67.2178,usage_system=97.504,usage_user=7.79679 1254000000000 +cpu,cpu=0 usage_idle=94.7894,usage_system=14.3818,usage_user=28.3392 1255000000000 +cpu,cpu=1 usage_idle=99.966,usage_system=34.2763,usage_user=72.4205 1256000000000 +cpu,cpu=2 usage_idle=46.8477,usage_system=78.0153,usage_user=16.3543 1257000000000 +cpu,cpu=3 usage_idle=91.4522,usage_system=11.544,usage_user=25.3805 1258000000000 +cpu,cpu=4 usage_idle=16.2647,usage_system=75.7499,usage_user=5.24885 1259000000000 +cpu,cpu=0 usage_idle=10.9345,usage_system=79.0125,usage_user=1.40841 1260000000000 +cpu,cpu=1 usage_idle=17.6006,usage_system=7.9642,usage_user=25.7327 1261000000000 +cpu,cpu=2 usage_idle=63.0655,usage_system=89.4532,usage_user=17.3704 1262000000000 +cpu,cpu=3 usage_idle=2.61872,usage_system=76.5645,usage_user=11.2998 1263000000000 +cpu,cpu=4 usage_idle=28.2016,usage_system=43.7823,usage_user=8.80377 1264000000000 +cpu,cpu=0 usage_idle=35.9984,usage_system=38.5717,usage_user=23.1855 1265000000000 +cpu,cpu=1 usage_idle=64.3376,usage_system=38.5378,usage_user=57.4618 1266000000000 +cpu,cpu=2 usage_idle=36.7581,usage_system=85.3855,usage_user=35.4771 1267000000000 +cpu,cpu=3 usage_idle=53.1124,usage_system=76.8377,usage_user=47.0211 1268000000000 +cpu,cpu=4 usage_idle=78.4929,usage_system=93.1024,usage_user=22.7711 1269000000000 +cpu,cpu=0 usage_idle=83.7417,usage_system=4.03683,usage_user=1.78355 1270000000000 +cpu,cpu=1 usage_idle=85.1501,usage_system=21.6375,usage_user=9.74775 1271000000000 +cpu,cpu=2 usage_idle=10.8828,usage_system=84.703,usage_user=99.201 1272000000000 +cpu,cpu=3 usage_idle=28.2532,usage_system=87.3217,usage_user=75.7655 1273000000000 +cpu,cpu=4 usage_idle=39.553,usage_system=15.5233,usage_user=19.5478 1274000000000 +cpu,cpu=0 usage_idle=48.3568,usage_system=51.5216,usage_user=58.1196 1275000000000 +cpu,cpu=1 usage_idle=71.5423,usage_system=15.8592,usage_user=96.6573 1276000000000 +cpu,cpu=2 usage_idle=29.0041,usage_system=52.6173,usage_user=82.0428 1277000000000 +cpu,cpu=3 usage_idle=64.4812,usage_system=5.72967,usage_user=58.8805 1278000000000 +cpu,cpu=4 usage_idle=11.5024,usage_system=84.2226,usage_user=51.9828 1279000000000 +cpu,cpu=0 usage_idle=34.2735,usage_system=67.9643,usage_user=56.0197 1280000000000 +cpu,cpu=1 usage_idle=36.057,usage_system=53.1144,usage_user=77.6571 1281000000000 +cpu,cpu=2 usage_idle=45.8048,usage_system=63.9973,usage_user=62.3601 1282000000000 +cpu,cpu=3 usage_idle=45.0057,usage_system=92.2505,usage_user=49.6818 1283000000000 +cpu,cpu=4 usage_idle=20.7712,usage_system=31.8035,usage_user=65.2051 1284000000000 +cpu,cpu=0 usage_idle=40.3191,usage_system=80.1603,usage_user=16.7267 1285000000000 +cpu,cpu=1 usage_idle=98.4386,usage_system=51.7026,usage_user=32.5859 1286000000000 +cpu,cpu=2 usage_idle=95.0959,usage_system=80.7067,usage_user=85.2032 1287000000000 +cpu,cpu=3 usage_idle=77.1387,usage_system=45.1879,usage_user=90.9329 1288000000000 +cpu,cpu=4 usage_idle=36.0192,usage_system=56.6903,usage_user=75.1554 1289000000000 +cpu,cpu=0 usage_idle=88.002,usage_system=90.9638,usage_user=43.1197 1290000000000 +cpu,cpu=1 usage_idle=44.0217,usage_system=27.0209,usage_user=96.2342 1291000000000 +cpu,cpu=2 usage_idle=21.6789,usage_system=72.8256,usage_user=60.2314 1292000000000 +cpu,cpu=3 usage_idle=84.039,usage_system=17.8314,usage_user=52.4819 1293000000000 +cpu,cpu=4 usage_idle=33.7208,usage_system=38.6026,usage_user=84.2854 1294000000000 +cpu,cpu=0 usage_idle=98.9258,usage_system=78.9217,usage_user=64.4457 1295000000000 +cpu,cpu=1 usage_idle=15.6525,usage_system=77.3603,usage_user=16.1482 1296000000000 +cpu,cpu=2 usage_idle=48.2384,usage_system=72.4562,usage_user=96.8549 1297000000000 +cpu,cpu=3 usage_idle=33.4416,usage_system=49.5949,usage_user=42.0429 1298000000000 +cpu,cpu=4 usage_idle=24.3745,usage_system=85.6141,usage_user=98.7332 1299000000000 +cpu,cpu=0 usage_idle=99.5299,usage_system=73.6162,usage_user=89.697 1300000000000 +cpu,cpu=1 usage_idle=42.6496,usage_system=17.6379,usage_user=16.7179 1301000000000 +cpu,cpu=2 usage_idle=38.8838,usage_system=39.3168,usage_user=89.5435 1302000000000 +cpu,cpu=3 usage_idle=99.1152,usage_system=23.3557,usage_user=7.3749 1303000000000 +cpu,cpu=4 usage_idle=51.5971,usage_system=57.0765,usage_user=45.9775 1304000000000 +cpu,cpu=0 usage_idle=35.8825,usage_system=56.0023,usage_user=24.8992 1305000000000 +cpu,cpu=1 usage_idle=0.328197,usage_system=71.6548,usage_user=2.25948 1306000000000 +cpu,cpu=2 usage_idle=16.4764,usage_system=19.8933,usage_user=74.7157 1307000000000 +cpu,cpu=3 usage_idle=13.3314,usage_system=53.3348,usage_user=24.3106 1308000000000 +cpu,cpu=4 usage_idle=55.3743,usage_system=77.7093,usage_user=9.92475 1309000000000 +cpu,cpu=0 usage_idle=54.1075,usage_system=77.2392,usage_user=83.5409 1310000000000 +cpu,cpu=1 usage_idle=43.8045,usage_system=19.8887,usage_user=1.17881 1311000000000 +cpu,cpu=2 usage_idle=60.5223,usage_system=58.7725,usage_user=40.4956 1312000000000 +cpu,cpu=3 usage_idle=50.0659,usage_system=57.8877,usage_user=63.8513 1313000000000 +cpu,cpu=4 usage_idle=57.4408,usage_system=9.48478,usage_user=20.9278 1314000000000 +cpu,cpu=0 usage_idle=3.41828,usage_system=45.3673,usage_user=76.9301 1315000000000 +cpu,cpu=1 usage_idle=28.3175,usage_system=45.6955,usage_user=48.585 1316000000000 +cpu,cpu=2 usage_idle=30.577,usage_system=62.1719,usage_user=68.4782 1317000000000 +cpu,cpu=3 usage_idle=5.29265,usage_system=75.5033,usage_user=21.8131 1318000000000 +cpu,cpu=4 usage_idle=29.6033,usage_system=30.8776,usage_user=99.5223 1319000000000 +cpu,cpu=0 usage_idle=39.528,usage_system=84.985,usage_user=76.7615 1320000000000 +cpu,cpu=1 usage_idle=23.0689,usage_system=28.7895,usage_user=96.6503 1321000000000 +cpu,cpu=2 usage_idle=24.2477,usage_system=89.3119,usage_user=55.4228 1322000000000 +cpu,cpu=3 usage_idle=64.7433,usage_system=39.3777,usage_user=13.3104 1323000000000 +cpu,cpu=4 usage_idle=28.5946,usage_system=96.8185,usage_user=22.7952 1324000000000 +cpu,cpu=0 usage_idle=49.5224,usage_system=0.236773,usage_user=68.1625 1325000000000 +cpu,cpu=1 usage_idle=26.4525,usage_system=28.5543,usage_user=13.858 1326000000000 +cpu,cpu=2 usage_idle=75.0374,usage_system=59.1312,usage_user=76.03 1327000000000 +cpu,cpu=3 usage_idle=43.5157,usage_system=64.4239,usage_user=51.5333 1328000000000 +cpu,cpu=4 usage_idle=65.3287,usage_system=94.0271,usage_user=82.4109 1329000000000 +cpu,cpu=0 usage_idle=64.8511,usage_system=33.5551,usage_user=67.3959 1330000000000 +cpu,cpu=1 usage_idle=41.6126,usage_system=56.6241,usage_user=96.1854 1331000000000 +cpu,cpu=2 usage_idle=38.2628,usage_system=80.8718,usage_user=85.4973 1332000000000 +cpu,cpu=3 usage_idle=93.6856,usage_system=45.6151,usage_user=24.875 1333000000000 +cpu,cpu=4 usage_idle=6.99601,usage_system=74.2097,usage_user=21.6935 1334000000000 +cpu,cpu=0 usage_idle=29.7912,usage_system=23.7321,usage_user=21.9303 1335000000000 +cpu,cpu=1 usage_idle=97.9537,usage_system=50.1846,usage_user=50.4845 1336000000000 +cpu,cpu=2 usage_idle=11.8118,usage_system=25.2221,usage_user=9.61575 1337000000000 +cpu,cpu=3 usage_idle=87.8417,usage_system=68.7377,usage_user=74.0396 1338000000000 +cpu,cpu=4 usage_idle=39.375,usage_system=34.0664,usage_user=68.0667 1339000000000 +cpu,cpu=0 usage_idle=21.7858,usage_system=98.9175,usage_user=1.62189 1340000000000 +cpu,cpu=1 usage_idle=89.1817,usage_system=40.5301,usage_user=58.246 1341000000000 +cpu,cpu=2 usage_idle=85.3671,usage_system=78.7929,usage_user=39.1178 1342000000000 +cpu,cpu=3 usage_idle=70.8644,usage_system=72.4785,usage_user=84.733 1343000000000 +cpu,cpu=4 usage_idle=95.7394,usage_system=79.4745,usage_user=58.9427 1344000000000 +cpu,cpu=0 usage_idle=17.433,usage_system=9.26569,usage_user=82.6748 1345000000000 +cpu,cpu=1 usage_idle=39.3632,usage_system=7.21944,usage_user=32.8595 1346000000000 +cpu,cpu=2 usage_idle=89.8478,usage_system=19.0312,usage_user=58.0815 1347000000000 +cpu,cpu=3 usage_idle=99.4635,usage_system=6.87289,usage_user=26.8192 1348000000000 +cpu,cpu=4 usage_idle=73.5031,usage_system=46.2479,usage_user=60.8857 1349000000000 +cpu,cpu=0 usage_idle=41.5699,usage_system=68.0337,usage_user=59.8032 1350000000000 +cpu,cpu=1 usage_idle=43.1918,usage_system=57.2154,usage_user=0.333222 1351000000000 +cpu,cpu=2 usage_idle=1.43773,usage_system=42.5826,usage_user=79.1261 1352000000000 +cpu,cpu=3 usage_idle=40.5555,usage_system=13.447,usage_user=51.6045 1353000000000 +cpu,cpu=4 usage_idle=25.2885,usage_system=9.18645,usage_user=31.079 1354000000000 +cpu,cpu=0 usage_idle=84.2312,usage_system=26.6194,usage_user=40.3447 1355000000000 +cpu,cpu=1 usage_idle=66.906,usage_system=65.9826,usage_user=47.5641 1356000000000 +cpu,cpu=2 usage_idle=99.7655,usage_system=55.8304,usage_user=66.5953 1357000000000 +cpu,cpu=3 usage_idle=57.847,usage_system=55.2939,usage_user=73.4682 1358000000000 +cpu,cpu=4 usage_idle=84.6663,usage_system=28.797,usage_user=19.7161 1359000000000 +cpu,cpu=0 usage_idle=45.5519,usage_system=70.3669,usage_user=87.7498 1360000000000 +cpu,cpu=1 usage_idle=5.35511,usage_system=13.5586,usage_user=44.9652 1361000000000 +cpu,cpu=2 usage_idle=5.68833,usage_system=14.9964,usage_user=87.5478 1362000000000 +cpu,cpu=3 usage_idle=84.8144,usage_system=55.5519,usage_user=0.994797 1363000000000 +cpu,cpu=4 usage_idle=36.419,usage_system=80.8404,usage_user=10.1812 1364000000000 +cpu,cpu=0 usage_idle=67.498,usage_system=65.0716,usage_user=36.8006 1365000000000 +cpu,cpu=1 usage_idle=7.8427,usage_system=31.9776,usage_user=2.78327 1366000000000 +cpu,cpu=2 usage_idle=55.4068,usage_system=31.7431,usage_user=58.6137 1367000000000 +cpu,cpu=3 usage_idle=22.0022,usage_system=89.5901,usage_user=13.9076 1368000000000 +cpu,cpu=4 usage_idle=95.4704,usage_system=74.2564,usage_user=42.7046 1369000000000 +cpu,cpu=0 usage_idle=15.1865,usage_system=19.8083,usage_user=13.0715 1370000000000 +cpu,cpu=1 usage_idle=2.93628,usage_system=25.1634,usage_user=26.6301 1371000000000 +cpu,cpu=2 usage_idle=47.9015,usage_system=30.8517,usage_user=41.6264 1372000000000 +cpu,cpu=3 usage_idle=35.4493,usage_system=15.6662,usage_user=97.1783 1373000000000 +cpu,cpu=4 usage_idle=36.4441,usage_system=52.0852,usage_user=78.0187 1374000000000 +cpu,cpu=0 usage_idle=46.6253,usage_system=19.5831,usage_user=43.0903 1375000000000 +cpu,cpu=1 usage_idle=83.426,usage_system=27.4258,usage_user=75.0679 1376000000000 +cpu,cpu=2 usage_idle=86.2092,usage_system=82.8327,usage_user=6.81104 1377000000000 +cpu,cpu=3 usage_idle=44.8229,usage_system=4.83486,usage_user=96.4012 1378000000000 +cpu,cpu=4 usage_idle=58.7305,usage_system=0.305258,usage_user=70.6575 1379000000000 +cpu,cpu=0 usage_idle=1.43505,usage_system=15.4917,usage_user=90.4658 1380000000000 +cpu,cpu=1 usage_idle=14.5065,usage_system=18.428,usage_user=15.6293 1381000000000 +cpu,cpu=2 usage_idle=41.1366,usage_system=66.3295,usage_user=46.481 1382000000000 +cpu,cpu=3 usage_idle=82.763,usage_system=1.7788,usage_user=62.1472 1383000000000 +cpu,cpu=4 usage_idle=79.9414,usage_system=38.2229,usage_user=14.2323 1384000000000 +cpu,cpu=0 usage_idle=57.9601,usage_system=84.8482,usage_user=33.8155 1385000000000 +cpu,cpu=1 usage_idle=1.05039,usage_system=68.2742,usage_user=61.2413 1386000000000 +cpu,cpu=2 usage_idle=76.1183,usage_system=54.4834,usage_user=44.074 1387000000000 +cpu,cpu=3 usage_idle=82.9294,usage_system=99.3064,usage_user=48.9089 1388000000000 +cpu,cpu=4 usage_idle=79.3305,usage_system=58.0368,usage_user=49.2141 1389000000000 +cpu,cpu=0 usage_idle=49.9881,usage_system=59.4719,usage_user=64.7059 1390000000000 +cpu,cpu=1 usage_idle=40.4539,usage_system=73.9784,usage_user=83.1339 1391000000000 +cpu,cpu=2 usage_idle=56.0831,usage_system=15.1149,usage_user=49.4634 1392000000000 +cpu,cpu=3 usage_idle=2.56415,usage_system=97.878,usage_user=51.2422 1393000000000 +cpu,cpu=4 usage_idle=64.7113,usage_system=77.8193,usage_user=89.4651 1394000000000 +cpu,cpu=0 usage_idle=78.9437,usage_system=35.7794,usage_user=74.3133 1395000000000 +cpu,cpu=1 usage_idle=12.7591,usage_system=36.8298,usage_user=42.5875 1396000000000 +cpu,cpu=2 usage_idle=74.0005,usage_system=12.9481,usage_user=97.071 1397000000000 +cpu,cpu=3 usage_idle=18.0745,usage_system=95.8775,usage_user=96.3773 1398000000000 +cpu,cpu=4 usage_idle=66.9833,usage_system=75.208,usage_user=54.4142 1399000000000 +cpu,cpu=0 usage_idle=16.1975,usage_system=25.1961,usage_user=13.886 1400000000000 +cpu,cpu=1 usage_idle=80.9034,usage_system=65.65,usage_user=87.8644 1401000000000 +cpu,cpu=2 usage_idle=64.0373,usage_system=21.7331,usage_user=2.97934 1402000000000 +cpu,cpu=3 usage_idle=13.5007,usage_system=24.2973,usage_user=0.857304 1403000000000 +cpu,cpu=4 usage_idle=64.7429,usage_system=89.0086,usage_user=78.6766 1404000000000 +cpu,cpu=0 usage_idle=54.208,usage_system=67.9523,usage_user=14.456 1405000000000 +cpu,cpu=1 usage_idle=28.5213,usage_system=80.7114,usage_user=51.2858 1406000000000 +cpu,cpu=2 usage_idle=71.1088,usage_system=54.7119,usage_user=64.2339 1407000000000 +cpu,cpu=3 usage_idle=68.1798,usage_system=72.7863,usage_user=60.1114 1408000000000 +cpu,cpu=4 usage_idle=64.5571,usage_system=39.7697,usage_user=35.3195 1409000000000 +cpu,cpu=0 usage_idle=18.9713,usage_system=55.9672,usage_user=60.5156 1410000000000 +cpu,cpu=1 usage_idle=32.8573,usage_system=36.8705,usage_user=26.1656 1411000000000 +cpu,cpu=2 usage_idle=20.7217,usage_system=0.907761,usage_user=47.8987 1412000000000 +cpu,cpu=3 usage_idle=23.701,usage_system=14.4084,usage_user=72.196 1413000000000 +cpu,cpu=4 usage_idle=24.5583,usage_system=79.1513,usage_user=61.2046 1414000000000 +cpu,cpu=0 usage_idle=3.23497,usage_system=33.3593,usage_user=29.1569 1415000000000 +cpu,cpu=1 usage_idle=17.691,usage_system=61.8806,usage_user=9.86827 1416000000000 +cpu,cpu=2 usage_idle=68.9768,usage_system=32.9894,usage_user=64.5801 1417000000000 +cpu,cpu=3 usage_idle=33.2107,usage_system=1.16926,usage_user=37.3665 1418000000000 +cpu,cpu=4 usage_idle=93.3221,usage_system=65.7264,usage_user=77.1361 1419000000000 +cpu,cpu=0 usage_idle=28.6416,usage_system=84.6977,usage_user=33.1033 1420000000000 +cpu,cpu=1 usage_idle=89.1572,usage_system=17.555,usage_user=69.9738 1421000000000 +cpu,cpu=2 usage_idle=15.3227,usage_system=38.2767,usage_user=70.8816 1422000000000 +cpu,cpu=3 usage_idle=63.2214,usage_system=61.9777,usage_user=85.29 1423000000000 +cpu,cpu=4 usage_idle=35.4174,usage_system=86.5361,usage_user=64.4413 1424000000000 +cpu,cpu=0 usage_idle=96.622,usage_system=89.771,usage_user=97.8006 1425000000000 +cpu,cpu=1 usage_idle=25.7789,usage_system=7.46203,usage_user=59.6812 1426000000000 +cpu,cpu=2 usage_idle=35.6471,usage_system=76.4388,usage_user=92.6707 1427000000000 +cpu,cpu=3 usage_idle=0.227268,usage_system=9.64953,usage_user=93.8399 1428000000000 +cpu,cpu=4 usage_idle=37.5937,usage_system=2.97167,usage_user=59.5663 1429000000000 +cpu,cpu=0 usage_idle=14.7299,usage_system=31.6133,usage_user=44.264 1430000000000 +cpu,cpu=1 usage_idle=47.8332,usage_system=20.7704,usage_user=61.819 1431000000000 +cpu,cpu=2 usage_idle=17.807,usage_system=36.0932,usage_user=0.0956713 1432000000000 +cpu,cpu=3 usage_idle=88.6886,usage_system=99.3146,usage_user=62.0734 1433000000000 +cpu,cpu=4 usage_idle=73.9786,usage_system=34.732,usage_user=48.6095 1434000000000 +cpu,cpu=0 usage_idle=38.4199,usage_system=31.354,usage_user=38.3805 1435000000000 +cpu,cpu=1 usage_idle=36.2205,usage_system=57.1328,usage_user=45.8426 1436000000000 +cpu,cpu=2 usage_idle=95.9017,usage_system=92.78,usage_user=22.2814 1437000000000 +cpu,cpu=3 usage_idle=88.5723,usage_system=93.0072,usage_user=31.9309 1438000000000 +cpu,cpu=4 usage_idle=82.4122,usage_system=30.601,usage_user=34.9026 1439000000000 +cpu,cpu=0 usage_idle=41.9785,usage_system=45.3309,usage_user=66.5159 1440000000000 +cpu,cpu=1 usage_idle=86.2425,usage_system=93.164,usage_user=87.2863 1441000000000 +cpu,cpu=2 usage_idle=48.0615,usage_system=10.971,usage_user=23.3795 1442000000000 +cpu,cpu=3 usage_idle=48.1572,usage_system=99.6596,usage_user=22.6941 1443000000000 +cpu,cpu=4 usage_idle=10.2306,usage_system=73.6382,usage_user=57.426 1444000000000 +cpu,cpu=0 usage_idle=58.8401,usage_system=12.058,usage_user=88.78 1445000000000 +cpu,cpu=1 usage_idle=97.2206,usage_system=48.2785,usage_user=45.9128 1446000000000 +cpu,cpu=2 usage_idle=43.0632,usage_system=44.1802,usage_user=38.6928 1447000000000 +cpu,cpu=3 usage_idle=65.3445,usage_system=32.7525,usage_user=31.7 1448000000000 +cpu,cpu=4 usage_idle=97.2754,usage_system=15.1647,usage_user=62.301 1449000000000 +cpu,cpu=0 usage_idle=32.178,usage_system=57.1433,usage_user=7.63186 1450000000000 +cpu,cpu=1 usage_idle=98.6939,usage_system=43.3858,usage_user=0.795897 1451000000000 +cpu,cpu=2 usage_idle=85.9802,usage_system=91.4473,usage_user=11.7669 1452000000000 +cpu,cpu=3 usage_idle=9.35964,usage_system=39.6045,usage_user=11.4265 1453000000000 +cpu,cpu=4 usage_idle=32.0537,usage_system=49.8351,usage_user=85.0647 1454000000000 +cpu,cpu=0 usage_idle=89.4797,usage_system=8.67517,usage_user=97.1227 1455000000000 +cpu,cpu=1 usage_idle=78.2597,usage_system=5.89577,usage_user=45.4012 1456000000000 +cpu,cpu=2 usage_idle=24.1726,usage_system=48.9589,usage_user=89.5813 1457000000000 +cpu,cpu=3 usage_idle=62.8654,usage_system=14.3034,usage_user=22.3338 1458000000000 +cpu,cpu=4 usage_idle=94.5654,usage_system=11.5789,usage_user=37.4985 1459000000000 +cpu,cpu=0 usage_idle=56.8665,usage_system=43.7569,usage_user=94.6418 1460000000000 +cpu,cpu=1 usage_idle=64.4983,usage_system=42.4507,usage_user=38.0276 1461000000000 +cpu,cpu=2 usage_idle=65.2942,usage_system=28.4309,usage_user=29.4749 1462000000000 +cpu,cpu=3 usage_idle=77.0611,usage_system=37.7905,usage_user=69.0794 1463000000000 +cpu,cpu=4 usage_idle=88.4877,usage_system=69.8442,usage_user=18.9145 1464000000000 +cpu,cpu=0 usage_idle=73.5523,usage_system=59.324,usage_user=27.5897 1465000000000 +cpu,cpu=1 usage_idle=70.675,usage_system=37.5837,usage_user=33.4854 1466000000000 +cpu,cpu=2 usage_idle=16.0762,usage_system=61.7563,usage_user=82.4444 1467000000000 +cpu,cpu=3 usage_idle=5.65758,usage_system=24.6217,usage_user=96.7478 1468000000000 +cpu,cpu=4 usage_idle=27.9914,usage_system=19.1871,usage_user=8.32669 1469000000000 +cpu,cpu=0 usage_idle=65.4899,usage_system=76.0536,usage_user=52.0836 1470000000000 +cpu,cpu=1 usage_idle=60.1317,usage_system=40.5519,usage_user=94.5343 1471000000000 +cpu,cpu=2 usage_idle=98.1593,usage_system=5.84611,usage_user=22.9652 1472000000000 +cpu,cpu=3 usage_idle=27.6343,usage_system=82.9072,usage_user=60.7557 1473000000000 +cpu,cpu=4 usage_idle=96.7137,usage_system=71.3949,usage_user=30.6 1474000000000 +cpu,cpu=0 usage_idle=15.6282,usage_system=44.9472,usage_user=89.9239 1475000000000 +cpu,cpu=1 usage_idle=43.2179,usage_system=15.6223,usage_user=27.5076 1476000000000 +cpu,cpu=2 usage_idle=76.7033,usage_system=31.6985,usage_user=89.2639 1477000000000 +cpu,cpu=3 usage_idle=59.1477,usage_system=37.3561,usage_user=13.8856 1478000000000 +cpu,cpu=4 usage_idle=55.8955,usage_system=65.3475,usage_user=33.0728 1479000000000 +cpu,cpu=0 usage_idle=64.2222,usage_system=30.8374,usage_user=9.12634 1480000000000 +cpu,cpu=1 usage_idle=16.3057,usage_system=90.9692,usage_user=49.6782 1481000000000 +cpu,cpu=2 usage_idle=10.84,usage_system=89.1285,usage_user=55.5243 1482000000000 +cpu,cpu=3 usage_idle=33.8052,usage_system=16.7628,usage_user=38.4316 1483000000000 +cpu,cpu=4 usage_idle=94.561,usage_system=13.4765,usage_user=9.82649 1484000000000 +cpu,cpu=0 usage_idle=25.1609,usage_system=29.1046,usage_user=54.7737 1485000000000 +cpu,cpu=1 usage_idle=15.0848,usage_system=72.3225,usage_user=70.396 1486000000000 +cpu,cpu=2 usage_idle=42.5925,usage_system=49.0258,usage_user=2.09454 1487000000000 +cpu,cpu=3 usage_idle=31.8564,usage_system=8.17345,usage_user=39.4506 1488000000000 +cpu,cpu=4 usage_idle=45.742,usage_system=64.0689,usage_user=4.79816 1489000000000 +cpu,cpu=0 usage_idle=78.8148,usage_system=28.2911,usage_user=35.6356 1490000000000 +cpu,cpu=1 usage_idle=87.9411,usage_system=44.5968,usage_user=26.6048 1491000000000 +cpu,cpu=2 usage_idle=37.6193,usage_system=55.4369,usage_user=15.7333 1492000000000 +cpu,cpu=3 usage_idle=93.1437,usage_system=89.2421,usage_user=32.4961 1493000000000 +cpu,cpu=4 usage_idle=31.5753,usage_system=83.803,usage_user=45.9726 1494000000000 +cpu,cpu=0 usage_idle=41.4018,usage_system=8.96395,usage_user=75.0772 1495000000000 +cpu,cpu=1 usage_idle=96.1755,usage_system=24.0488,usage_user=47.3997 1496000000000 +cpu,cpu=2 usage_idle=66.5715,usage_system=66.6412,usage_user=96.4255 1497000000000 +cpu,cpu=3 usage_idle=68.6661,usage_system=98.4976,usage_user=4.59892 1498000000000 +cpu,cpu=4 usage_idle=8.11671,usage_system=44.2396,usage_user=68.6678 1499000000000 +cpu,cpu=0 usage_idle=12.9149,usage_system=23.0544,usage_user=96.9589 1500000000000 +cpu,cpu=1 usage_idle=48.5505,usage_system=10.9955,usage_user=41.5558 1501000000000 +cpu,cpu=2 usage_idle=75.1553,usage_system=48.6148,usage_user=96.9926 1502000000000 +cpu,cpu=3 usage_idle=90.8886,usage_system=41.7585,usage_user=86.2347 1503000000000 +cpu,cpu=4 usage_idle=23.3847,usage_system=73.3338,usage_user=70.0378 1504000000000 +cpu,cpu=0 usage_idle=69.3572,usage_system=14.7356,usage_user=79.0017 1505000000000 +cpu,cpu=1 usage_idle=44.4344,usage_system=10.9111,usage_user=3.05051 1506000000000 +cpu,cpu=2 usage_idle=91.8341,usage_system=77.4826,usage_user=69.6918 1507000000000 +cpu,cpu=3 usage_idle=88.2596,usage_system=46.1486,usage_user=68.1894 1508000000000 +cpu,cpu=4 usage_idle=92.8585,usage_system=54.2654,usage_user=12.429 1509000000000 +cpu,cpu=0 usage_idle=61.5263,usage_system=67.1802,usage_user=35.4834 1510000000000 +cpu,cpu=1 usage_idle=58.4853,usage_system=15.7307,usage_user=46.4789 1511000000000 +cpu,cpu=2 usage_idle=0.0410601,usage_system=90.886,usage_user=95.0937 1512000000000 +cpu,cpu=3 usage_idle=97.0337,usage_system=81.7745,usage_user=36.8523 1513000000000 +cpu,cpu=4 usage_idle=83.2684,usage_system=5.15924,usage_user=10.1861 1514000000000 +cpu,cpu=0 usage_idle=53.3062,usage_system=74.5165,usage_user=24.9216 1515000000000 +cpu,cpu=1 usage_idle=32.3079,usage_system=18.9509,usage_user=35.8327 1516000000000 +cpu,cpu=2 usage_idle=35.3584,usage_system=10.785,usage_user=13.3153 1517000000000 +cpu,cpu=3 usage_idle=5.05019,usage_system=99.0446,usage_user=59.4639 1518000000000 +cpu,cpu=4 usage_idle=73.2396,usage_system=91.9031,usage_user=13.7293 1519000000000 +cpu,cpu=0 usage_idle=85.6686,usage_system=53.4294,usage_user=80.9095 1520000000000 +cpu,cpu=1 usage_idle=21.152,usage_system=11.9147,usage_user=96.6402 1521000000000 +cpu,cpu=2 usage_idle=67.6309,usage_system=11.9558,usage_user=87.5261 1522000000000 +cpu,cpu=3 usage_idle=62.7247,usage_system=8.98948,usage_user=69.3007 1523000000000 +cpu,cpu=4 usage_idle=99.5769,usage_system=92.2579,usage_user=74.4599 1524000000000 +cpu,cpu=0 usage_idle=9.76298,usage_system=45.5641,usage_user=48.9764 1525000000000 +cpu,cpu=1 usage_idle=34.6846,usage_system=77.872,usage_user=67.9273 1526000000000 +cpu,cpu=2 usage_idle=70.5173,usage_system=13.2305,usage_user=78.7123 1527000000000 +cpu,cpu=3 usage_idle=83.8325,usage_system=18.2807,usage_user=77.757 1528000000000 +cpu,cpu=4 usage_idle=43.2964,usage_system=91.5202,usage_user=69.66 1529000000000 +cpu,cpu=0 usage_idle=57.0257,usage_system=77.1888,usage_user=23.0895 1530000000000 +cpu,cpu=1 usage_idle=37.9351,usage_system=98.3408,usage_user=35.0042 1531000000000 +cpu,cpu=2 usage_idle=34.5753,usage_system=65.9718,usage_user=46.96 1532000000000 +cpu,cpu=3 usage_idle=22.1014,usage_system=28.6964,usage_user=55.9494 1533000000000 +cpu,cpu=4 usage_idle=91.4021,usage_system=28.2733,usage_user=48.2073 1534000000000 +cpu,cpu=0 usage_idle=65.862,usage_system=38.0363,usage_user=93.7715 1535000000000 +cpu,cpu=1 usage_idle=14.8384,usage_system=72.7209,usage_user=71.6435 1536000000000 +cpu,cpu=2 usage_idle=82.7658,usage_system=43.2382,usage_user=84.8739 1537000000000 +cpu,cpu=3 usage_idle=61.4781,usage_system=27.0707,usage_user=3.1546 1538000000000 +cpu,cpu=4 usage_idle=39.2351,usage_system=70.3671,usage_user=94.6748 1539000000000 +cpu,cpu=0 usage_idle=8.89511,usage_system=27.3928,usage_user=71.8636 1540000000000 +cpu,cpu=1 usage_idle=31.9846,usage_system=65.328,usage_user=70.2045 1541000000000 +cpu,cpu=2 usage_idle=66.9888,usage_system=99.9033,usage_user=36.1762 1542000000000 +cpu,cpu=3 usage_idle=13.9488,usage_system=22.0047,usage_user=64.8727 1543000000000 +cpu,cpu=4 usage_idle=69.8982,usage_system=13.4069,usage_user=93.146 1544000000000 +cpu,cpu=0 usage_idle=18.1056,usage_system=79.2689,usage_user=31.1823 1545000000000 +cpu,cpu=1 usage_idle=11.877,usage_system=94.1074,usage_user=3.90324 1546000000000 +cpu,cpu=2 usage_idle=83.5205,usage_system=76.8731,usage_user=47.1414 1547000000000 +cpu,cpu=3 usage_idle=68.3944,usage_system=38.3512,usage_user=74.2122 1548000000000 +cpu,cpu=4 usage_idle=71.549,usage_system=77.5863,usage_user=44.5793 1549000000000 +cpu,cpu=0 usage_idle=66.2239,usage_system=86.4814,usage_user=71.9721 1550000000000 +cpu,cpu=1 usage_idle=38.0875,usage_system=18.466,usage_user=37.3001 1551000000000 +cpu,cpu=2 usage_idle=8.29198,usage_system=85.4548,usage_user=37.2034 1552000000000 +cpu,cpu=3 usage_idle=44.4682,usage_system=99.4035,usage_user=59.2081 1553000000000 +cpu,cpu=4 usage_idle=9.34087,usage_system=69.3017,usage_user=72.615 1554000000000 +cpu,cpu=0 usage_idle=2.48686,usage_system=87.4073,usage_user=51.8839 1555000000000 +cpu,cpu=1 usage_idle=33.6692,usage_system=99.2843,usage_user=45.9913 1556000000000 +cpu,cpu=2 usage_idle=37.5724,usage_system=82.8048,usage_user=22.8644 1557000000000 +cpu,cpu=3 usage_idle=84.7139,usage_system=51.1992,usage_user=61.2156 1558000000000 +cpu,cpu=4 usage_idle=58.926,usage_system=22.7483,usage_user=38.8019 1559000000000 +cpu,cpu=0 usage_idle=3.50534,usage_system=88.9721,usage_user=25.2833 1560000000000 +cpu,cpu=1 usage_idle=75.4775,usage_system=27.0596,usage_user=43.7493 1561000000000 +cpu,cpu=2 usage_idle=12.7776,usage_system=35.3516,usage_user=29.2041 1562000000000 +cpu,cpu=3 usage_idle=49.981,usage_system=79.8198,usage_user=28.6077 1563000000000 +cpu,cpu=4 usage_idle=9.18911,usage_system=89.1607,usage_user=97.9094 1564000000000 +cpu,cpu=0 usage_idle=81.8041,usage_system=91.6476,usage_user=85.3167 1565000000000 +cpu,cpu=1 usage_idle=33.688,usage_system=25.3167,usage_user=84.601 1566000000000 +cpu,cpu=2 usage_idle=79.6793,usage_system=62.8892,usage_user=67.4058 1567000000000 +cpu,cpu=3 usage_idle=2.54371,usage_system=47.603,usage_user=18.605 1568000000000 +cpu,cpu=4 usage_idle=63.7593,usage_system=6.52907,usage_user=41.3533 1569000000000 +cpu,cpu=0 usage_idle=2.56125,usage_system=10.0344,usage_user=30.3254 1570000000000 +cpu,cpu=1 usage_idle=27.8446,usage_system=85.5119,usage_user=57.3851 1571000000000 +cpu,cpu=2 usage_idle=71.5939,usage_system=98.2895,usage_user=92.7367 1572000000000 +cpu,cpu=3 usage_idle=0.798011,usage_system=48.2704,usage_user=72.5565 1573000000000 +cpu,cpu=4 usage_idle=29.4057,usage_system=57.4596,usage_user=61.7172 1574000000000 +cpu,cpu=0 usage_idle=27.3151,usage_system=39.2637,usage_user=53.3647 1575000000000 +cpu,cpu=1 usage_idle=12.6318,usage_system=72.9517,usage_user=78.6815 1576000000000 +cpu,cpu=2 usage_idle=97.2328,usage_system=52.631,usage_user=41.5707 1577000000000 +cpu,cpu=3 usage_idle=64.6386,usage_system=55.1747,usage_user=89.1737 1578000000000 +cpu,cpu=4 usage_idle=83.2436,usage_system=18.9341,usage_user=95.7028 1579000000000 +cpu,cpu=0 usage_idle=24.5969,usage_system=21.4953,usage_user=5.73717 1580000000000 +cpu,cpu=1 usage_idle=54.9224,usage_system=49.3399,usage_user=91.249 1581000000000 +cpu,cpu=2 usage_idle=12.3074,usage_system=20.9338,usage_user=89.5385 1582000000000 +cpu,cpu=3 usage_idle=5.04407,usage_system=21.7318,usage_user=37.8089 1583000000000 +cpu,cpu=4 usage_idle=77.6006,usage_system=51.1375,usage_user=95.2685 1584000000000 +cpu,cpu=0 usage_idle=39.3178,usage_system=78.4525,usage_user=34.5322 1585000000000 +cpu,cpu=1 usage_idle=92.6825,usage_system=91.0843,usage_user=7.48388 1586000000000 +cpu,cpu=2 usage_idle=71.364,usage_system=88.3171,usage_user=60.1149 1587000000000 +cpu,cpu=3 usage_idle=12.9347,usage_system=52.9557,usage_user=15.2896 1588000000000 +cpu,cpu=4 usage_idle=2.10835,usage_system=36.1993,usage_user=34.2237 1589000000000 +cpu,cpu=0 usage_idle=97.8111,usage_system=60.7963,usage_user=55.719 1590000000000 +cpu,cpu=1 usage_idle=3.54828,usage_system=15.7186,usage_user=5.05891 1591000000000 +cpu,cpu=2 usage_idle=94.7973,usage_system=28.026,usage_user=25.9927 1592000000000 +cpu,cpu=3 usage_idle=84.3358,usage_system=33.0701,usage_user=47.7245 1593000000000 +cpu,cpu=4 usage_idle=22.1448,usage_system=10.6706,usage_user=98.862 1594000000000 +cpu,cpu=0 usage_idle=17.4133,usage_system=49.9884,usage_user=77.3145 1595000000000 +cpu,cpu=1 usage_idle=51.9454,usage_system=42.6709,usage_user=68.3988 1596000000000 +cpu,cpu=2 usage_idle=59.4293,usage_system=14.0349,usage_user=56.716 1597000000000 +cpu,cpu=3 usage_idle=19.5442,usage_system=26.9696,usage_user=9.67167 1598000000000 +cpu,cpu=4 usage_idle=34.8338,usage_system=29.0779,usage_user=45.871 1599000000000 +cpu,cpu=0 usage_idle=69.0575,usage_system=26.889,usage_user=6.66728 1600000000000 +cpu,cpu=1 usage_idle=24.7766,usage_system=30.4373,usage_user=22.3859 1601000000000 +cpu,cpu=2 usage_idle=29.8355,usage_system=25.2346,usage_user=50.4119 1602000000000 +cpu,cpu=3 usage_idle=55.8282,usage_system=9.57045,usage_user=83.482 1603000000000 +cpu,cpu=4 usage_idle=3.55268,usage_system=31.7152,usage_user=94.1527 1604000000000 +cpu,cpu=0 usage_idle=2.41466,usage_system=49.1285,usage_user=44.1411 1605000000000 +cpu,cpu=1 usage_idle=79.7292,usage_system=1.07392,usage_user=86.812 1606000000000 +cpu,cpu=2 usage_idle=48.128,usage_system=60.5032,usage_user=0.846868 1607000000000 +cpu,cpu=3 usage_idle=4.84399,usage_system=80.0474,usage_user=27.8164 1608000000000 +cpu,cpu=4 usage_idle=14.5157,usage_system=14.8813,usage_user=56.8943 1609000000000 +cpu,cpu=0 usage_idle=60.3867,usage_system=83.9388,usage_user=83.7833 1610000000000 +cpu,cpu=1 usage_idle=67.054,usage_system=8.71539,usage_user=14.2206 1611000000000 +cpu,cpu=2 usage_idle=89.4398,usage_system=38.5509,usage_user=39.4553 1612000000000 +cpu,cpu=3 usage_idle=39.8518,usage_system=94.379,usage_user=49.0257 1613000000000 +cpu,cpu=4 usage_idle=23.3338,usage_system=97.9317,usage_user=80.7409 1614000000000 +cpu,cpu=0 usage_idle=17.4864,usage_system=0.346381,usage_user=29.8694 1615000000000 +cpu,cpu=1 usage_idle=61.6275,usage_system=80.0756,usage_user=30.9433 1616000000000 +cpu,cpu=2 usage_idle=48.4394,usage_system=28.2036,usage_user=91.4465 1617000000000 +cpu,cpu=3 usage_idle=49.2863,usage_system=33.0476,usage_user=71.494 1618000000000 +cpu,cpu=4 usage_idle=77.1027,usage_system=47.5632,usage_user=86.3753 1619000000000 +cpu,cpu=0 usage_idle=33.9971,usage_system=7.94991,usage_user=70.3141 1620000000000 +cpu,cpu=1 usage_idle=17.7804,usage_system=75.0039,usage_user=79.0295 1621000000000 +cpu,cpu=2 usage_idle=32.0011,usage_system=64.4437,usage_user=17.5803 1622000000000 +cpu,cpu=3 usage_idle=71.4563,usage_system=4.29547,usage_user=11.9594 1623000000000 +cpu,cpu=4 usage_idle=20.482,usage_system=27.6292,usage_user=9.8911 1624000000000 +cpu,cpu=0 usage_idle=1.22294,usage_system=45.1157,usage_user=10.2375 1625000000000 +cpu,cpu=1 usage_idle=31.0923,usage_system=6.74315,usage_user=90.313 1626000000000 +cpu,cpu=2 usage_idle=62.0357,usage_system=55.1826,usage_user=18.5166 1627000000000 +cpu,cpu=3 usage_idle=53.4822,usage_system=4.46891,usage_user=51.5642 1628000000000 +cpu,cpu=4 usage_idle=24.9762,usage_system=81.5716,usage_user=99.1274 1629000000000 +cpu,cpu=0 usage_idle=11.3514,usage_system=15.5687,usage_user=7.07733 1630000000000 +cpu,cpu=1 usage_idle=81.6655,usage_system=33.3491,usage_user=82.0812 1631000000000 +cpu,cpu=2 usage_idle=60.695,usage_system=65.3502,usage_user=46.5249 1632000000000 +cpu,cpu=3 usage_idle=78.2753,usage_system=36.8065,usage_user=50.8204 1633000000000 +cpu,cpu=4 usage_idle=90.2347,usage_system=57.2885,usage_user=78.4496 1634000000000 +cpu,cpu=0 usage_idle=0.125782,usage_system=58.5115,usage_user=23.5653 1635000000000 +cpu,cpu=1 usage_idle=10.3633,usage_system=89.6038,usage_user=30.3084 1636000000000 +cpu,cpu=2 usage_idle=0.676295,usage_system=51.6395,usage_user=85.491 1637000000000 +cpu,cpu=3 usage_idle=19.1929,usage_system=5.12168,usage_user=89.9599 1638000000000 +cpu,cpu=4 usage_idle=70.7571,usage_system=30.0979,usage_user=71.5316 1639000000000 +cpu,cpu=0 usage_idle=69.8845,usage_system=41.4493,usage_user=87.1003 1640000000000 +cpu,cpu=1 usage_idle=76.9619,usage_system=23.1148,usage_user=20.4495 1641000000000 +cpu,cpu=2 usage_idle=59.0431,usage_system=83.8098,usage_user=85.7997 1642000000000 +cpu,cpu=3 usage_idle=5.56795,usage_system=62.0851,usage_user=22.6062 1643000000000 +cpu,cpu=4 usage_idle=56.3883,usage_system=52.3198,usage_user=79.8947 1644000000000 +cpu,cpu=0 usage_idle=34.8379,usage_system=52.4456,usage_user=38.4062 1645000000000 +cpu,cpu=1 usage_idle=58.4032,usage_system=62.8089,usage_user=28.01 1646000000000 +cpu,cpu=2 usage_idle=88.7117,usage_system=63.4851,usage_user=79.6494 1647000000000 +cpu,cpu=3 usage_idle=74.2027,usage_system=82.6781,usage_user=84.7711 1648000000000 +cpu,cpu=4 usage_idle=64.1626,usage_system=53.4352,usage_user=14.869 1649000000000 +cpu,cpu=0 usage_idle=35.6942,usage_system=23.3197,usage_user=56.3183 1650000000000 +cpu,cpu=1 usage_idle=22.7945,usage_system=0.281557,usage_user=79.4331 1651000000000 +cpu,cpu=2 usage_idle=43.244,usage_system=59.3246,usage_user=63.2429 1652000000000 +cpu,cpu=3 usage_idle=29.0436,usage_system=64.8926,usage_user=25.328 1653000000000 +cpu,cpu=4 usage_idle=51.6498,usage_system=21.2809,usage_user=77.6479 1654000000000 +cpu,cpu=0 usage_idle=31.5445,usage_system=56.1188,usage_user=30.0935 1655000000000 +cpu,cpu=1 usage_idle=69.9507,usage_system=14.5221,usage_user=92.9023 1656000000000 +cpu,cpu=2 usage_idle=97.9606,usage_system=3.23375,usage_user=56.3875 1657000000000 +cpu,cpu=3 usage_idle=77.61,usage_system=77.4365,usage_user=39.0655 1658000000000 +cpu,cpu=4 usage_idle=62.3811,usage_system=41.5991,usage_user=92.5007 1659000000000 +cpu,cpu=0 usage_idle=77.2501,usage_system=77.2933,usage_user=15.8204 1660000000000 +cpu,cpu=1 usage_idle=33.5684,usage_system=0.0878856,usage_user=16.1019 1661000000000 +cpu,cpu=2 usage_idle=13.0015,usage_system=43.3319,usage_user=75.4266 1662000000000 +cpu,cpu=3 usage_idle=76.2444,usage_system=72.3755,usage_user=40.3191 1663000000000 +cpu,cpu=4 usage_idle=1.57245,usage_system=24.0253,usage_user=61.6 1664000000000 +cpu,cpu=0 usage_idle=79.2203,usage_system=55.5698,usage_user=17.7188 1665000000000 +cpu,cpu=1 usage_idle=9.31377,usage_system=25.5205,usage_user=32.2409 1666000000000 +cpu,cpu=2 usage_idle=2.21609,usage_system=23.4811,usage_user=35.4747 1667000000000 +cpu,cpu=3 usage_idle=58.6035,usage_system=1.09114,usage_user=12.9111 1668000000000 +cpu,cpu=4 usage_idle=97.6691,usage_system=63.4723,usage_user=54.5102 1669000000000 +cpu,cpu=0 usage_idle=90.1698,usage_system=40.7224,usage_user=31.8036 1670000000000 +cpu,cpu=1 usage_idle=5.99016,usage_system=74.2907,usage_user=31.8915 1671000000000 +cpu,cpu=2 usage_idle=22.0921,usage_system=87.2922,usage_user=75.2233 1672000000000 +cpu,cpu=3 usage_idle=97.5187,usage_system=63.5366,usage_user=47.5989 1673000000000 +cpu,cpu=4 usage_idle=37.8378,usage_system=65.1091,usage_user=71.6242 1674000000000 +cpu,cpu=0 usage_idle=99.4378,usage_system=44.3294,usage_user=27.1941 1675000000000 +cpu,cpu=1 usage_idle=17.1566,usage_system=53.6432,usage_user=52.7146 1676000000000 +cpu,cpu=2 usage_idle=49.3976,usage_system=55.8593,usage_user=76.1957 1677000000000 +cpu,cpu=3 usage_idle=84.8722,usage_system=14.4628,usage_user=77.2868 1678000000000 +cpu,cpu=4 usage_idle=97.7834,usage_system=12.1319,usage_user=40.7591 1679000000000 +cpu,cpu=0 usage_idle=52.2936,usage_system=2.30164,usage_user=81.4815 1680000000000 +cpu,cpu=1 usage_idle=84.0972,usage_system=8.2918,usage_user=55.7722 1681000000000 +cpu,cpu=2 usage_idle=15.9886,usage_system=30.3839,usage_user=43.0644 1682000000000 +cpu,cpu=3 usage_idle=91.2119,usage_system=27.9026,usage_user=6.60107 1683000000000 +cpu,cpu=4 usage_idle=38.8108,usage_system=65.7403,usage_user=71.7102 1684000000000 +cpu,cpu=0 usage_idle=10.435,usage_system=65.1781,usage_user=16.0395 1685000000000 +cpu,cpu=1 usage_idle=37.6291,usage_system=82.3348,usage_user=69.6827 1686000000000 +cpu,cpu=2 usage_idle=90.3437,usage_system=31.7323,usage_user=25.542 1687000000000 +cpu,cpu=3 usage_idle=66.5394,usage_system=16.6045,usage_user=40.0048 1688000000000 +cpu,cpu=4 usage_idle=43.8262,usage_system=14.3879,usage_user=52.1366 1689000000000 +cpu,cpu=0 usage_idle=84.5853,usage_system=66.6815,usage_user=54.4383 1690000000000 +cpu,cpu=1 usage_idle=66.0668,usage_system=50.7786,usage_user=62.7301 1691000000000 +cpu,cpu=2 usage_idle=21.839,usage_system=66.7672,usage_user=93.114 1692000000000 +cpu,cpu=3 usage_idle=64.9034,usage_system=57.9792,usage_user=21.0166 1693000000000 +cpu,cpu=4 usage_idle=71.5045,usage_system=96.79,usage_user=86.7569 1694000000000 +cpu,cpu=0 usage_idle=43.2147,usage_system=7.22504,usage_user=51.935 1695000000000 +cpu,cpu=1 usage_idle=59.2542,usage_system=44.8542,usage_user=34.2698 1696000000000 +cpu,cpu=2 usage_idle=28.9369,usage_system=35.1978,usage_user=66.0021 1697000000000 +cpu,cpu=3 usage_idle=54.4789,usage_system=1.73722,usage_user=82.6066 1698000000000 +cpu,cpu=4 usage_idle=94.4836,usage_system=45.5634,usage_user=96.9945 1699000000000 +cpu,cpu=0 usage_idle=46.6203,usage_system=30.1487,usage_user=63.676 1700000000000 +cpu,cpu=1 usage_idle=1.05854,usage_system=96.2155,usage_user=14.4546 1701000000000 +cpu,cpu=2 usage_idle=63.7886,usage_system=18.0545,usage_user=81.2218 1702000000000 +cpu,cpu=3 usage_idle=56.9026,usage_system=82.9579,usage_user=39.201 1703000000000 +cpu,cpu=4 usage_idle=77.9191,usage_system=54.4624,usage_user=35.991 1704000000000 +cpu,cpu=0 usage_idle=64.676,usage_system=97.6771,usage_user=43.216 1705000000000 +cpu,cpu=1 usage_idle=16.6111,usage_system=56.9313,usage_user=88.0702 1706000000000 +cpu,cpu=2 usage_idle=50.8808,usage_system=85.8682,usage_user=23.268 1707000000000 +cpu,cpu=3 usage_idle=16.8829,usage_system=40.3471,usage_user=25.0052 1708000000000 +cpu,cpu=4 usage_idle=99.4895,usage_system=34.8307,usage_user=70.5687 1709000000000 +cpu,cpu=0 usage_idle=96.484,usage_system=81.451,usage_user=0.717383 1710000000000 +cpu,cpu=1 usage_idle=60.1599,usage_system=82.5095,usage_user=96.9329 1711000000000 +cpu,cpu=2 usage_idle=74.6145,usage_system=46.2981,usage_user=14.9874 1712000000000 +cpu,cpu=3 usage_idle=55.8363,usage_system=3.20072,usage_user=97.9453 1713000000000 +cpu,cpu=4 usage_idle=95.0373,usage_system=81.1199,usage_user=52.4077 1714000000000 +cpu,cpu=0 usage_idle=31.0283,usage_system=45.7959,usage_user=50.0848 1715000000000 +cpu,cpu=1 usage_idle=74.2443,usage_system=62.407,usage_user=7.01613 1716000000000 +cpu,cpu=2 usage_idle=62.3144,usage_system=13.2878,usage_user=92.8843 1717000000000 +cpu,cpu=3 usage_idle=85.5825,usage_system=30.1707,usage_user=33.2314 1718000000000 +cpu,cpu=4 usage_idle=10.5877,usage_system=29.6602,usage_user=68.0621 1719000000000 +cpu,cpu=0 usage_idle=81.1564,usage_system=26.1442,usage_user=49.5131 1720000000000 +cpu,cpu=1 usage_idle=81.8737,usage_system=86.3042,usage_user=32.0226 1721000000000 +cpu,cpu=2 usage_idle=78.8066,usage_system=60.9187,usage_user=78.3207 1722000000000 +cpu,cpu=3 usage_idle=93.794,usage_system=16.755,usage_user=81.5214 1723000000000 +cpu,cpu=4 usage_idle=91.7393,usage_system=11.7923,usage_user=62.6413 1724000000000 +cpu,cpu=0 usage_idle=44.1471,usage_system=42.8205,usage_user=8.43719 1725000000000 +cpu,cpu=1 usage_idle=94.2319,usage_system=17.0648,usage_user=70.8442 1726000000000 +cpu,cpu=2 usage_idle=1.24802,usage_system=79.3793,usage_user=84.132 1727000000000 +cpu,cpu=3 usage_idle=94.1324,usage_system=64.9617,usage_user=14.3027 1728000000000 +cpu,cpu=4 usage_idle=27.3638,usage_system=75.5494,usage_user=43.9629 1729000000000 +cpu,cpu=0 usage_idle=95.4259,usage_system=56.7058,usage_user=70.1071 1730000000000 +cpu,cpu=1 usage_idle=44.939,usage_system=38.5795,usage_user=56.4112 1731000000000 +cpu,cpu=2 usage_idle=76.9615,usage_system=17.3862,usage_user=17.3299 1732000000000 +cpu,cpu=3 usage_idle=55.2822,usage_system=11.1802,usage_user=34.0849 1733000000000 +cpu,cpu=4 usage_idle=36.8037,usage_system=2.91947,usage_user=45.8772 1734000000000 +cpu,cpu=0 usage_idle=99.4449,usage_system=47.0665,usage_user=88.6977 1735000000000 +cpu,cpu=1 usage_idle=7.88214,usage_system=41.2984,usage_user=5.76252 1736000000000 +cpu,cpu=2 usage_idle=78.7263,usage_system=42.5464,usage_user=85.1418 1737000000000 +cpu,cpu=3 usage_idle=62.8583,usage_system=36.6788,usage_user=50.1035 1738000000000 +cpu,cpu=4 usage_idle=77.1609,usage_system=64.0426,usage_user=25.6529 1739000000000 +cpu,cpu=0 usage_idle=21.1238,usage_system=59.4684,usage_user=82.3587 1740000000000 +cpu,cpu=1 usage_idle=91.2309,usage_system=4.40741,usage_user=20.9382 1741000000000 +cpu,cpu=2 usage_idle=47.6422,usage_system=81.369,usage_user=38.3244 1742000000000 +cpu,cpu=3 usage_idle=64.9721,usage_system=36.6512,usage_user=49.5046 1743000000000 +cpu,cpu=4 usage_idle=99.057,usage_system=73.4549,usage_user=52.424 1744000000000 +cpu,cpu=0 usage_idle=44.9341,usage_system=72.8998,usage_user=99.4905 1745000000000 +cpu,cpu=1 usage_idle=33.6318,usage_system=80.782,usage_user=40.789 1746000000000 +cpu,cpu=2 usage_idle=39.3943,usage_system=59.5083,usage_user=83.3354 1747000000000 +cpu,cpu=3 usage_idle=24.5361,usage_system=22.3665,usage_user=20.0142 1748000000000 +cpu,cpu=4 usage_idle=74.6396,usage_system=99.5275,usage_user=84.0567 1749000000000 +cpu,cpu=0 usage_idle=0.292566,usage_system=20.6513,usage_user=43.5252 1750000000000 +cpu,cpu=1 usage_idle=82.6513,usage_system=11.8822,usage_user=47.9326 1751000000000 +cpu,cpu=2 usage_idle=3.58954,usage_system=59.5243,usage_user=29.3015 1752000000000 +cpu,cpu=3 usage_idle=41.9139,usage_system=24.4964,usage_user=65.9527 1753000000000 +cpu,cpu=4 usage_idle=91.4185,usage_system=23.5534,usage_user=39.4076 1754000000000 +cpu,cpu=0 usage_idle=43.8425,usage_system=68.4875,usage_user=12.3074 1755000000000 +cpu,cpu=1 usage_idle=43.3331,usage_system=2.11931,usage_user=93.0894 1756000000000 +cpu,cpu=2 usage_idle=84.122,usage_system=41.5137,usage_user=52.5976 1757000000000 +cpu,cpu=3 usage_idle=67.4574,usage_system=66.0498,usage_user=74.9642 1758000000000 +cpu,cpu=4 usage_idle=87.4716,usage_system=40.6894,usage_user=74.4916 1759000000000 +cpu,cpu=0 usage_idle=71.5283,usage_system=40.982,usage_user=95.1429 1760000000000 +cpu,cpu=1 usage_idle=15.0535,usage_system=23.6333,usage_user=7.02509 1761000000000 +cpu,cpu=2 usage_idle=62.9861,usage_system=27.2228,usage_user=66.5494 1762000000000 +cpu,cpu=3 usage_idle=92.2876,usage_system=69.1367,usage_user=91.0458 1763000000000 +cpu,cpu=4 usage_idle=58.2403,usage_system=60.5552,usage_user=14.5992 1764000000000 +cpu,cpu=0 usage_idle=97.6479,usage_system=4.39776,usage_user=83.0867 1765000000000 +cpu,cpu=1 usage_idle=9.95537,usage_system=47.7308,usage_user=85.206 1766000000000 +cpu,cpu=2 usage_idle=3.04474,usage_system=31.8528,usage_user=26.7197 1767000000000 +cpu,cpu=3 usage_idle=55.6424,usage_system=99.3102,usage_user=92.7695 1768000000000 +cpu,cpu=4 usage_idle=30.6065,usage_system=86.7818,usage_user=33.4589 1769000000000 +cpu,cpu=0 usage_idle=5.09814,usage_system=58.3101,usage_user=74.4408 1770000000000 +cpu,cpu=1 usage_idle=0.241037,usage_system=73.3636,usage_user=98.0741 1771000000000 +cpu,cpu=2 usage_idle=7.26613,usage_system=36.3496,usage_user=25.2969 1772000000000 +cpu,cpu=3 usage_idle=73.8156,usage_system=28.6372,usage_user=94.4336 1773000000000 +cpu,cpu=4 usage_idle=64.8614,usage_system=86.8776,usage_user=54.9889 1774000000000 +cpu,cpu=0 usage_idle=79.4606,usage_system=84.5255,usage_user=59.3867 1775000000000 +cpu,cpu=1 usage_idle=62.5473,usage_system=94.4809,usage_user=7.11748 1776000000000 +cpu,cpu=2 usage_idle=47.7534,usage_system=97.5256,usage_user=38.9703 1777000000000 +cpu,cpu=3 usage_idle=74.473,usage_system=53.168,usage_user=38.2806 1778000000000 +cpu,cpu=4 usage_idle=67.2425,usage_system=83.7745,usage_user=25.0624 1779000000000 +cpu,cpu=0 usage_idle=0.701368,usage_system=88.8727,usage_user=83.3725 1780000000000 +cpu,cpu=1 usage_idle=75.1422,usage_system=89.1137,usage_user=56.7361 1781000000000 +cpu,cpu=2 usage_idle=73.2163,usage_system=96.3799,usage_user=93.0858 1782000000000 +cpu,cpu=3 usage_idle=98.5132,usage_system=70.1954,usage_user=21.723 1783000000000 +cpu,cpu=4 usage_idle=92.9469,usage_system=35.0568,usage_user=8.60059 1784000000000 +cpu,cpu=0 usage_idle=47.9358,usage_system=14.5175,usage_user=93.1261 1785000000000 +cpu,cpu=1 usage_idle=7.3224,usage_system=77.0648,usage_user=87.607 1786000000000 +cpu,cpu=2 usage_idle=14.4399,usage_system=24.8182,usage_user=85.1327 1787000000000 +cpu,cpu=3 usage_idle=53.4102,usage_system=99.2912,usage_user=38.3007 1788000000000 +cpu,cpu=4 usage_idle=91.6908,usage_system=66.5337,usage_user=22.0752 1789000000000 +cpu,cpu=0 usage_idle=16.7532,usage_system=67.2351,usage_user=10.9479 1790000000000 +cpu,cpu=1 usage_idle=0.125721,usage_system=42.3773,usage_user=0.0616314 1791000000000 +cpu,cpu=2 usage_idle=56.8618,usage_system=15.5936,usage_user=96.4415 1792000000000 +cpu,cpu=3 usage_idle=49.9476,usage_system=14.1068,usage_user=66.6369 1793000000000 +cpu,cpu=4 usage_idle=71.6706,usage_system=7.05368,usage_user=1.69372 1794000000000 +cpu,cpu=0 usage_idle=80.2712,usage_system=54.9894,usage_user=16.2112 1795000000000 +cpu,cpu=1 usage_idle=73.3973,usage_system=62.3118,usage_user=93.276 1796000000000 +cpu,cpu=2 usage_idle=61.0043,usage_system=76.7517,usage_user=18.0941 1797000000000 +cpu,cpu=3 usage_idle=46.137,usage_system=30.1619,usage_user=17.3854 1798000000000 +cpu,cpu=4 usage_idle=84.4377,usage_system=21.8527,usage_user=83.9191 1799000000000 +cpu,cpu=0 usage_idle=6.51288,usage_system=38.6059,usage_user=51.1541 1800000000000 +cpu,cpu=1 usage_idle=17.4608,usage_system=38.7317,usage_user=93.5314 1801000000000 +cpu,cpu=2 usage_idle=17.5224,usage_system=95.5935,usage_user=9.12503 1802000000000 +cpu,cpu=3 usage_idle=13.9639,usage_system=45.5411,usage_user=23.2318 1803000000000 +cpu,cpu=4 usage_idle=80.6008,usage_system=17.2117,usage_user=30.2855 1804000000000 +cpu,cpu=0 usage_idle=82.2945,usage_system=97.4829,usage_user=85.275 1805000000000 +cpu,cpu=1 usage_idle=98.5057,usage_system=70.8802,usage_user=47.5868 1806000000000 +cpu,cpu=2 usage_idle=91.7817,usage_system=31.8845,usage_user=24.3385 1807000000000 +cpu,cpu=3 usage_idle=9.87583,usage_system=78.0215,usage_user=54.5005 1808000000000 +cpu,cpu=4 usage_idle=27.2612,usage_system=62.4592,usage_user=76.3532 1809000000000 +cpu,cpu=0 usage_idle=11.1803,usage_system=68.972,usage_user=14.9591 1810000000000 +cpu,cpu=1 usage_idle=62.3344,usage_system=86.4328,usage_user=53.6908 1811000000000 +cpu,cpu=2 usage_idle=55.8658,usage_system=3.95525,usage_user=49.2843 1812000000000 +cpu,cpu=3 usage_idle=64.9909,usage_system=17.9192,usage_user=94.8254 1813000000000 +cpu,cpu=4 usage_idle=88.2227,usage_system=98.52,usage_user=12.0371 1814000000000 +cpu,cpu=0 usage_idle=18.5082,usage_system=80.8145,usage_user=9.51994 1815000000000 +cpu,cpu=1 usage_idle=3.78321,usage_system=79.3202,usage_user=80.4001 1816000000000 +cpu,cpu=2 usage_idle=51.37,usage_system=71.1019,usage_user=12.2846 1817000000000 +cpu,cpu=3 usage_idle=75.7085,usage_system=80.9777,usage_user=90.3061 1818000000000 +cpu,cpu=4 usage_idle=30.209,usage_system=8.23889,usage_user=52.7653 1819000000000 +cpu,cpu=0 usage_idle=6.56218,usage_system=19.4191,usage_user=21.7373 1820000000000 +cpu,cpu=1 usage_idle=21.5213,usage_system=81.7535,usage_user=8.17017 1821000000000 +cpu,cpu=2 usage_idle=75.2121,usage_system=37.6194,usage_user=12.1254 1822000000000 +cpu,cpu=3 usage_idle=24.4964,usage_system=2.61023,usage_user=30.0446 1823000000000 +cpu,cpu=4 usage_idle=19.3217,usage_system=90.8329,usage_user=28.5645 1824000000000 +cpu,cpu=0 usage_idle=31.3588,usage_system=9.34119,usage_user=9.37902 1825000000000 +cpu,cpu=1 usage_idle=40.8787,usage_system=13.1244,usage_user=88.6992 1826000000000 +cpu,cpu=2 usage_idle=21.2788,usage_system=64.4944,usage_user=59.8011 1827000000000 +cpu,cpu=3 usage_idle=33.5635,usage_system=40.2029,usage_user=40.7788 1828000000000 +cpu,cpu=4 usage_idle=23.8696,usage_system=70.4119,usage_user=49.0177 1829000000000 +cpu,cpu=0 usage_idle=76.6349,usage_system=76.9741,usage_user=68.4368 1830000000000 +cpu,cpu=1 usage_idle=98.3723,usage_system=98.4954,usage_user=50.1904 1831000000000 +cpu,cpu=2 usage_idle=6.54244,usage_system=73.7075,usage_user=87.8097 1832000000000 +cpu,cpu=3 usage_idle=18.6679,usage_system=98.2038,usage_user=90.42 1833000000000 +cpu,cpu=4 usage_idle=48.7124,usage_system=17.5256,usage_user=81.2529 1834000000000 +cpu,cpu=0 usage_idle=77.277,usage_system=48.8844,usage_user=90.5941 1835000000000 +cpu,cpu=1 usage_idle=86.656,usage_system=89.7631,usage_user=3.7185 1836000000000 +cpu,cpu=2 usage_idle=75.3552,usage_system=11.0419,usage_user=68.2129 1837000000000 +cpu,cpu=3 usage_idle=35.1563,usage_system=44.6054,usage_user=8.41583 1838000000000 +cpu,cpu=4 usage_idle=75.9351,usage_system=68.475,usage_user=78.8277 1839000000000 +cpu,cpu=0 usage_idle=24.9527,usage_system=45.11,usage_user=55.8018 1840000000000 +cpu,cpu=1 usage_idle=93.3895,usage_system=43.4822,usage_user=54.2972 1841000000000 +cpu,cpu=2 usage_idle=43.5799,usage_system=50.0247,usage_user=28.0047 1842000000000 +cpu,cpu=3 usage_idle=31.3896,usage_system=68.6925,usage_user=26.2086 1843000000000 +cpu,cpu=4 usage_idle=21.8096,usage_system=17.405,usage_user=43.7341 1844000000000 +cpu,cpu=0 usage_idle=3.06254,usage_system=94.682,usage_user=92.6185 1845000000000 +cpu,cpu=1 usage_idle=93.6566,usage_system=81.338,usage_user=82.3816 1846000000000 +cpu,cpu=2 usage_idle=97.3751,usage_system=56.6932,usage_user=93.4235 1847000000000 +cpu,cpu=3 usage_idle=65.5881,usage_system=91.8494,usage_user=38.0289 1848000000000 +cpu,cpu=4 usage_idle=74.0039,usage_system=67.7845,usage_user=6.50395 1849000000000 +cpu,cpu=0 usage_idle=52.8316,usage_system=92.7372,usage_user=51.6139 1850000000000 +cpu,cpu=1 usage_idle=8.63347,usage_system=86.1267,usage_user=95.0961 1851000000000 +cpu,cpu=2 usage_idle=62.9307,usage_system=29.7067,usage_user=45.1208 1852000000000 +cpu,cpu=3 usage_idle=90.9354,usage_system=61.0963,usage_user=13.8133 1853000000000 +cpu,cpu=4 usage_idle=17.144,usage_system=82.9059,usage_user=31.2183 1854000000000 +cpu,cpu=0 usage_idle=60.8781,usage_system=85.9685,usage_user=25.9002 1855000000000 +cpu,cpu=1 usage_idle=53.4966,usage_system=79.6251,usage_user=7.23815 1856000000000 +cpu,cpu=2 usage_idle=35.8782,usage_system=77.0003,usage_user=63.9313 1857000000000 +cpu,cpu=3 usage_idle=29.3017,usage_system=42.5883,usage_user=55.7807 1858000000000 +cpu,cpu=4 usage_idle=67.3306,usage_system=16.5922,usage_user=23.5652 1859000000000 +cpu,cpu=0 usage_idle=73.8345,usage_system=69.4238,usage_user=16.3024 1860000000000 +cpu,cpu=1 usage_idle=25.4484,usage_system=78.0573,usage_user=2.42916 1861000000000 +cpu,cpu=2 usage_idle=20.5445,usage_system=40.988,usage_user=32.1358 1862000000000 +cpu,cpu=3 usage_idle=65.6653,usage_system=31.9234,usage_user=93.2321 1863000000000 +cpu,cpu=4 usage_idle=79.4786,usage_system=49.0673,usage_user=76.138 1864000000000 +cpu,cpu=0 usage_idle=10.6969,usage_system=9.94544,usage_user=62.1065 1865000000000 +cpu,cpu=1 usage_idle=36.5971,usage_system=63.442,usage_user=41.7316 1866000000000 +cpu,cpu=2 usage_idle=43.8352,usage_system=99.3202,usage_user=18.7319 1867000000000 +cpu,cpu=3 usage_idle=7.76651,usage_system=28.6219,usage_user=61.3202 1868000000000 +cpu,cpu=4 usage_idle=63.5472,usage_system=95.9525,usage_user=77.9124 1869000000000 +cpu,cpu=0 usage_idle=87.1125,usage_system=69.787,usage_user=47.3362 1870000000000 +cpu,cpu=1 usage_idle=3.41488,usage_system=95.2354,usage_user=25.3935 1871000000000 +cpu,cpu=2 usage_idle=5.84404,usage_system=15.78,usage_user=66.3814 1872000000000 +cpu,cpu=3 usage_idle=37.9799,usage_system=81.4453,usage_user=98.3048 1873000000000 +cpu,cpu=4 usage_idle=31.212,usage_system=60.9239,usage_user=47.3722 1874000000000 +cpu,cpu=0 usage_idle=7.35002,usage_system=71.6208,usage_user=57.3176 1875000000000 +cpu,cpu=1 usage_idle=69.4565,usage_system=8.21781,usage_user=20.7597 1876000000000 +cpu,cpu=2 usage_idle=11.1881,usage_system=52.053,usage_user=20.0799 1877000000000 +cpu,cpu=3 usage_idle=29.92,usage_system=59.8195,usage_user=48.7018 1878000000000 +cpu,cpu=4 usage_idle=91.2402,usage_system=23.3668,usage_user=44.6542 1879000000000 +cpu,cpu=0 usage_idle=69.1525,usage_system=10.4792,usage_user=14.4412 1880000000000 +cpu,cpu=1 usage_idle=16.4887,usage_system=13.8941,usage_user=9.67668 1881000000000 +cpu,cpu=2 usage_idle=41.8822,usage_system=19.7382,usage_user=25.4567 1882000000000 +cpu,cpu=3 usage_idle=8.26362,usage_system=57.718,usage_user=6.90197 1883000000000 +cpu,cpu=4 usage_idle=6.56846,usage_system=88.93,usage_user=67.8259 1884000000000 +cpu,cpu=0 usage_idle=53.9406,usage_system=96.28,usage_user=39.4466 1885000000000 +cpu,cpu=1 usage_idle=11.2583,usage_system=65.7366,usage_user=47.6645 1886000000000 +cpu,cpu=2 usage_idle=32.0179,usage_system=76.9247,usage_user=99.7175 1887000000000 +cpu,cpu=3 usage_idle=52.0978,usage_system=6.84469,usage_user=59.537 1888000000000 +cpu,cpu=4 usage_idle=0.799569,usage_system=98.0849,usage_user=82.9038 1889000000000 +cpu,cpu=0 usage_idle=45.4538,usage_system=67.2374,usage_user=93.383 1890000000000 +cpu,cpu=1 usage_idle=59.895,usage_system=83.7261,usage_user=7.27716 1891000000000 +cpu,cpu=2 usage_idle=69.5717,usage_system=25.6083,usage_user=27.0153 1892000000000 +cpu,cpu=3 usage_idle=95.0284,usage_system=33.8719,usage_user=84.7334 1893000000000 +cpu,cpu=4 usage_idle=1.93035,usage_system=40.4403,usage_user=73.6634 1894000000000 +cpu,cpu=0 usage_idle=69.7562,usage_system=94.381,usage_user=69.9434 1895000000000 +cpu,cpu=1 usage_idle=9.20286,usage_system=5.63925,usage_user=35.68 1896000000000 +cpu,cpu=2 usage_idle=56.8673,usage_system=37.6572,usage_user=12.6047 1897000000000 +cpu,cpu=3 usage_idle=56.5848,usage_system=89.755,usage_user=19.4494 1898000000000 +cpu,cpu=4 usage_idle=16.1218,usage_system=90.5546,usage_user=17.5342 1899000000000 +cpu,cpu=0 usage_idle=99.0256,usage_system=36.0084,usage_user=84.7716 1900000000000 +cpu,cpu=1 usage_idle=92.4086,usage_system=95.9034,usage_user=68.4977 1901000000000 +cpu,cpu=2 usage_idle=99.6858,usage_system=65.4751,usage_user=94.106 1902000000000 +cpu,cpu=3 usage_idle=26.7011,usage_system=60.5035,usage_user=27.9778 1903000000000 +cpu,cpu=4 usage_idle=11.4345,usage_system=62.4338,usage_user=68.4182 1904000000000 +cpu,cpu=0 usage_idle=85.0978,usage_system=32.1901,usage_user=62.7992 1905000000000 +cpu,cpu=1 usage_idle=55.0413,usage_system=41.3929,usage_user=68.4384 1906000000000 +cpu,cpu=2 usage_idle=90.7212,usage_system=98.2602,usage_user=6.09558 1907000000000 +cpu,cpu=3 usage_idle=3.32592,usage_system=54.845,usage_user=95.8506 1908000000000 +cpu,cpu=4 usage_idle=22.7753,usage_system=70.9668,usage_user=86.4051 1909000000000 +cpu,cpu=0 usage_idle=40.3095,usage_system=69.9924,usage_user=22.4135 1910000000000 +cpu,cpu=1 usage_idle=25.0811,usage_system=62.401,usage_user=18.3169 1911000000000 +cpu,cpu=2 usage_idle=93.5788,usage_system=62.0868,usage_user=83.792 1912000000000 +cpu,cpu=3 usage_idle=87.6848,usage_system=88.7879,usage_user=44.2955 1913000000000 +cpu,cpu=4 usage_idle=15.6626,usage_system=0.222359,usage_user=6.72935 1914000000000 +cpu,cpu=0 usage_idle=84.0808,usage_system=85.3202,usage_user=38.9194 1915000000000 +cpu,cpu=1 usage_idle=46.8799,usage_system=40.3615,usage_user=80.3123 1916000000000 +cpu,cpu=2 usage_idle=15.3183,usage_system=31.0827,usage_user=78.5726 1917000000000 +cpu,cpu=3 usage_idle=21.4139,usage_system=34.4086,usage_user=33.4176 1918000000000 +cpu,cpu=4 usage_idle=17.2645,usage_system=57.1839,usage_user=4.38439 1919000000000 +cpu,cpu=0 usage_idle=3.66962,usage_system=97.4934,usage_user=74.3768 1920000000000 +cpu,cpu=1 usage_idle=26.0831,usage_system=22.5746,usage_user=36.7778 1921000000000 +cpu,cpu=2 usage_idle=44.4,usage_system=16.1534,usage_user=98.8646 1922000000000 +cpu,cpu=3 usage_idle=28.192,usage_system=3.83814,usage_user=87.6525 1923000000000 +cpu,cpu=4 usage_idle=72.4876,usage_system=19.5007,usage_user=87.8748 1924000000000 +cpu,cpu=0 usage_idle=79.2169,usage_system=3.58152,usage_user=73.195 1925000000000 +cpu,cpu=1 usage_idle=18.1363,usage_system=50.4614,usage_user=13.5565 1926000000000 +cpu,cpu=2 usage_idle=98.4486,usage_system=65.7798,usage_user=44.6392 1927000000000 +cpu,cpu=3 usage_idle=77.0212,usage_system=87.1937,usage_user=79.0478 1928000000000 +cpu,cpu=4 usage_idle=10.4388,usage_system=4.45814,usage_user=36.2317 1929000000000 +cpu,cpu=0 usage_idle=14.8232,usage_system=8.12776,usage_user=33.7251 1930000000000 +cpu,cpu=1 usage_idle=89.1999,usage_system=34.2109,usage_user=56.2997 1931000000000 +cpu,cpu=2 usage_idle=25.9777,usage_system=78.6109,usage_user=72.4531 1932000000000 +cpu,cpu=3 usage_idle=24.8423,usage_system=6.80296,usage_user=76.2912 1933000000000 +cpu,cpu=4 usage_idle=12.4948,usage_system=79.2905,usage_user=95.792 1934000000000 +cpu,cpu=0 usage_idle=0.369629,usage_system=58.5074,usage_user=99.3735 1935000000000 +cpu,cpu=1 usage_idle=73.5647,usage_system=76.6437,usage_user=49.8349 1936000000000 +cpu,cpu=2 usage_idle=87.1212,usage_system=75.0923,usage_user=15.6147 1937000000000 +cpu,cpu=3 usage_idle=31.7604,usage_system=52.1135,usage_user=2.80833 1938000000000 +cpu,cpu=4 usage_idle=10.8082,usage_system=62.5523,usage_user=7.26647 1939000000000 +cpu,cpu=0 usage_idle=47.0399,usage_system=77.3755,usage_user=15.3942 1940000000000 +cpu,cpu=1 usage_idle=80.765,usage_system=66.5754,usage_user=49.6051 1941000000000 +cpu,cpu=2 usage_idle=37.0647,usage_system=92.5532,usage_user=28.216 1942000000000 +cpu,cpu=3 usage_idle=9.5178,usage_system=17.3955,usage_user=35.019 1943000000000 +cpu,cpu=4 usage_idle=85.809,usage_system=29.8903,usage_user=14.3095 1944000000000 +cpu,cpu=0 usage_idle=81.601,usage_system=30.2599,usage_user=72.8169 1945000000000 +cpu,cpu=1 usage_idle=80.9744,usage_system=3.82457,usage_user=49.4606 1946000000000 +cpu,cpu=2 usage_idle=30.8093,usage_system=90.9457,usage_user=24.553 1947000000000 +cpu,cpu=3 usage_idle=46.424,usage_system=22.7061,usage_user=76.6665 1948000000000 +cpu,cpu=4 usage_idle=49.2323,usage_system=33.5143,usage_user=39.2188 1949000000000 +cpu,cpu=0 usage_idle=56.4988,usage_system=80.5541,usage_user=16.5943 1950000000000 +cpu,cpu=1 usage_idle=71.893,usage_system=61.3192,usage_user=83.1697 1951000000000 +cpu,cpu=2 usage_idle=21.4982,usage_system=98.3839,usage_user=75.7229 1952000000000 +cpu,cpu=3 usage_idle=49.7142,usage_system=7.90171,usage_user=93.1183 1953000000000 +cpu,cpu=4 usage_idle=84.7332,usage_system=93.7107,usage_user=23.0086 1954000000000 +cpu,cpu=0 usage_idle=99.0427,usage_system=75.3117,usage_user=53.2685 1955000000000 +cpu,cpu=1 usage_idle=71.8596,usage_system=56.2861,usage_user=57.0931 1956000000000 +cpu,cpu=2 usage_idle=21.3202,usage_system=87.0954,usage_user=48.0388 1957000000000 +cpu,cpu=3 usage_idle=45.8732,usage_system=33.5194,usage_user=70.7449 1958000000000 +cpu,cpu=4 usage_idle=22.5397,usage_system=82.7517,usage_user=4.25917 1959000000000 +cpu,cpu=0 usage_idle=61.7585,usage_system=39.2505,usage_user=84.8133 1960000000000 +cpu,cpu=1 usage_idle=78.3528,usage_system=11.1436,usage_user=46.1325 1961000000000 +cpu,cpu=2 usage_idle=61.5225,usage_system=32.6417,usage_user=44.5164 1962000000000 +cpu,cpu=3 usage_idle=37.2454,usage_system=82.3559,usage_user=52.4181 1963000000000 +cpu,cpu=4 usage_idle=30.3637,usage_system=67.0891,usage_user=46.1288 1964000000000 +cpu,cpu=0 usage_idle=53.3723,usage_system=66.1318,usage_user=21.4405 1965000000000 +cpu,cpu=1 usage_idle=6.64086,usage_system=37.9914,usage_user=77.7266 1966000000000 +cpu,cpu=2 usage_idle=63.734,usage_system=59.3116,usage_user=64.822 1967000000000 +cpu,cpu=3 usage_idle=11.7728,usage_system=5.18483,usage_user=98.3414 1968000000000 +cpu,cpu=4 usage_idle=82.5177,usage_system=27.7245,usage_user=81.0932 1969000000000 +cpu,cpu=0 usage_idle=86.7769,usage_system=89.4831,usage_user=20.3437 1970000000000 +cpu,cpu=1 usage_idle=71.5902,usage_system=67.8359,usage_user=31.4873 1971000000000 +cpu,cpu=2 usage_idle=17.7227,usage_system=29.3584,usage_user=64.129 1972000000000 +cpu,cpu=3 usage_idle=62.2391,usage_system=66.6037,usage_user=46.485 1973000000000 +cpu,cpu=4 usage_idle=14.6572,usage_system=96.9675,usage_user=13.5741 1974000000000 +cpu,cpu=0 usage_idle=60.786,usage_system=50.3398,usage_user=79.7059 1975000000000 +cpu,cpu=1 usage_idle=82.2265,usage_system=56.9807,usage_user=17.6973 1976000000000 +cpu,cpu=2 usage_idle=59.9531,usage_system=20.7146,usage_user=77.0089 1977000000000 +cpu,cpu=3 usage_idle=24.7751,usage_system=32.4874,usage_user=82.1938 1978000000000 +cpu,cpu=4 usage_idle=23.1166,usage_system=15.0051,usage_user=9.9183 1979000000000 +cpu,cpu=0 usage_idle=4.20973,usage_system=1.78198,usage_user=99.4014 1980000000000 +cpu,cpu=1 usage_idle=24.5534,usage_system=73.3722,usage_user=67.2372 1981000000000 +cpu,cpu=2 usage_idle=56.0407,usage_system=91.0948,usage_user=96.5956 1982000000000 +cpu,cpu=3 usage_idle=20.1698,usage_system=53.3339,usage_user=63.1993 1983000000000 +cpu,cpu=4 usage_idle=66.6547,usage_system=67.9911,usage_user=60.1668 1984000000000 +cpu,cpu=0 usage_idle=80.2288,usage_system=28.7771,usage_user=10.5066 1985000000000 +cpu,cpu=1 usage_idle=59.9347,usage_system=11.0036,usage_user=67.4873 1986000000000 +cpu,cpu=2 usage_idle=77.632,usage_system=70.9567,usage_user=88.2019 1987000000000 +cpu,cpu=3 usage_idle=54.6409,usage_system=95.7318,usage_user=20.6893 1988000000000 +cpu,cpu=4 usage_idle=36.8347,usage_system=18.8484,usage_user=35.6944 1989000000000 +cpu,cpu=0 usage_idle=46.753,usage_system=23.0581,usage_user=37.4764 1990000000000 +cpu,cpu=1 usage_idle=46.1543,usage_system=47.6116,usage_user=10.8485 1991000000000 +cpu,cpu=2 usage_idle=13.3915,usage_system=3.65229,usage_user=1.94337 1992000000000 +cpu,cpu=3 usage_idle=9.98714,usage_system=23.8221,usage_user=55.2773 1993000000000 +cpu,cpu=4 usage_idle=73.1865,usage_system=90.4768,usage_user=23.2684 1994000000000 +cpu,cpu=0 usage_idle=33.3533,usage_system=70.7056,usage_user=52.0455 1995000000000 +cpu,cpu=1 usage_idle=43.8599,usage_system=30.6403,usage_user=63.0491 1996000000000 +cpu,cpu=2 usage_idle=11.3471,usage_system=8.27224,usage_user=34.0058 1997000000000 +cpu,cpu=3 usage_idle=99.549,usage_system=62.9132,usage_user=29.7376 1998000000000 +cpu,cpu=4 usage_idle=20.2383,usage_system=99.7478,usage_user=48.586 1999000000000 +cpu,cpu=0 usage_idle=55.9327,usage_system=46.5008,usage_user=71.6441 2000000000000 +cpu,cpu=1 usage_idle=93.4091,usage_system=92.6551,usage_user=19.2557 2001000000000 +cpu,cpu=2 usage_idle=4.2576,usage_system=6.04668,usage_user=22.9079 2002000000000 +cpu,cpu=3 usage_idle=6.20097,usage_system=16.0338,usage_user=46.73 2003000000000 +cpu,cpu=4 usage_idle=61.4782,usage_system=89.2203,usage_user=37.2068 2004000000000 +cpu,cpu=0 usage_idle=84.7466,usage_system=22.5736,usage_user=7.91234 2005000000000 +cpu,cpu=1 usage_idle=36.7921,usage_system=66.4335,usage_user=38.5526 2006000000000 +cpu,cpu=2 usage_idle=99.8412,usage_system=77.7806,usage_user=46.8248 2007000000000 +cpu,cpu=3 usage_idle=33.847,usage_system=77.3296,usage_user=9.738 2008000000000 +cpu,cpu=4 usage_idle=63.5846,usage_system=97.5679,usage_user=9.48584 2009000000000 +cpu,cpu=0 usage_idle=12.1706,usage_system=53.5006,usage_user=55.9866 2010000000000 +cpu,cpu=1 usage_idle=83.8147,usage_system=46.9097,usage_user=48.6418 2011000000000 +cpu,cpu=2 usage_idle=3.07031,usage_system=51.1673,usage_user=54.6885 2012000000000 +cpu,cpu=3 usage_idle=25.9782,usage_system=57.3683,usage_user=70.7223 2013000000000 +cpu,cpu=4 usage_idle=72.7082,usage_system=18.8465,usage_user=59.9426 2014000000000 +cpu,cpu=0 usage_idle=9.91501,usage_system=3.59314,usage_user=82.5162 2015000000000 +cpu,cpu=1 usage_idle=17.8274,usage_system=40.3852,usage_user=48.9496 2016000000000 +cpu,cpu=2 usage_idle=56.38,usage_system=40.2264,usage_user=26.7302 2017000000000 +cpu,cpu=3 usage_idle=3.2048,usage_system=74.0733,usage_user=4.05986 2018000000000 +cpu,cpu=4 usage_idle=12.9428,usage_system=37.6579,usage_user=1.6278 2019000000000 +cpu,cpu=0 usage_idle=22.4286,usage_system=49.8285,usage_user=55.1284 2020000000000 +cpu,cpu=1 usage_idle=78.4153,usage_system=33.6431,usage_user=2.03813 2021000000000 +cpu,cpu=2 usage_idle=27.0571,usage_system=36.7134,usage_user=53.2054 2022000000000 +cpu,cpu=3 usage_idle=81.7455,usage_system=62.6917,usage_user=10.5737 2023000000000 +cpu,cpu=4 usage_idle=52.4678,usage_system=35.3999,usage_user=29.4202 2024000000000 +cpu,cpu=0 usage_idle=12.4104,usage_system=45.3149,usage_user=33.0134 2025000000000 +cpu,cpu=1 usage_idle=94.9265,usage_system=63.1423,usage_user=73.3986 2026000000000 +cpu,cpu=2 usage_idle=43.8761,usage_system=19.5222,usage_user=13.625 2027000000000 +cpu,cpu=3 usage_idle=70.6064,usage_system=22.727,usage_user=87.6984 2028000000000 +cpu,cpu=4 usage_idle=74.6662,usage_system=35.6698,usage_user=25.3563 2029000000000 +cpu,cpu=0 usage_idle=76.294,usage_system=58.0985,usage_user=75.1847 2030000000000 +cpu,cpu=1 usage_idle=31.4225,usage_system=36.5138,usage_user=8.82787 2031000000000 +cpu,cpu=2 usage_idle=33.4606,usage_system=63.5708,usage_user=45.5413 2032000000000 +cpu,cpu=3 usage_idle=86.666,usage_system=45.3163,usage_user=8.233 2033000000000 +cpu,cpu=4 usage_idle=97.2397,usage_system=97.7841,usage_user=43.6329 2034000000000 +cpu,cpu=0 usage_idle=26.66,usage_system=10.1945,usage_user=88.9479 2035000000000 +cpu,cpu=1 usage_idle=59.6733,usage_system=5.12101,usage_user=52.0902 2036000000000 +cpu,cpu=2 usage_idle=33.0719,usage_system=48.9971,usage_user=71.6124 2037000000000 +cpu,cpu=3 usage_idle=46.6969,usage_system=19.6035,usage_user=94.3395 2038000000000 +cpu,cpu=4 usage_idle=34.3953,usage_system=94.2697,usage_user=30.0093 2039000000000 +cpu,cpu=0 usage_idle=59.7516,usage_system=70.5638,usage_user=88.1078 2040000000000 +cpu,cpu=1 usage_idle=34.9363,usage_system=1.9862,usage_user=24.6216 2041000000000 +cpu,cpu=2 usage_idle=43.7642,usage_system=35.4468,usage_user=88.1924 2042000000000 +cpu,cpu=3 usage_idle=89.3055,usage_system=22.1128,usage_user=33.5087 2043000000000 +cpu,cpu=4 usage_idle=97.5385,usage_system=19.3525,usage_user=31.2929 2044000000000 +cpu,cpu=0 usage_idle=41.1714,usage_system=46.0125,usage_user=41.4874 2045000000000 +cpu,cpu=1 usage_idle=30.1193,usage_system=5.68581,usage_user=46.6084 2046000000000 +cpu,cpu=2 usage_idle=82.2095,usage_system=38.7577,usage_user=95.6055 2047000000000 +cpu,cpu=3 usage_idle=53.8219,usage_system=85.4547,usage_user=15.209 2048000000000 +cpu,cpu=4 usage_idle=48.1613,usage_system=19.85,usage_user=9.47876 2049000000000 +cpu,cpu=0 usage_idle=78.1706,usage_system=79.6015,usage_user=80.0425 2050000000000 +cpu,cpu=1 usage_idle=66.2784,usage_system=14.5378,usage_user=82.0287 2051000000000 +cpu,cpu=2 usage_idle=90.9,usage_system=58.302,usage_user=17.4755 2052000000000 +cpu,cpu=3 usage_idle=79.0924,usage_system=47.6075,usage_user=39.5883 2053000000000 +cpu,cpu=4 usage_idle=12.6011,usage_system=45.1459,usage_user=58.9408 2054000000000 +cpu,cpu=0 usage_idle=43.894,usage_system=86.3174,usage_user=4.9533 2055000000000 +cpu,cpu=1 usage_idle=85.3813,usage_system=16.4367,usage_user=10.6391 2056000000000 +cpu,cpu=2 usage_idle=31.9897,usage_system=98.6461,usage_user=49.3969 2057000000000 +cpu,cpu=3 usage_idle=27.5952,usage_system=52.468,usage_user=34.8515 2058000000000 +cpu,cpu=4 usage_idle=42.8043,usage_system=0.629338,usage_user=54.7015 2059000000000 +cpu,cpu=0 usage_idle=52.283,usage_system=78.8,usage_user=34.303 2060000000000 +cpu,cpu=1 usage_idle=32.3255,usage_system=45.0784,usage_user=48.8408 2061000000000 +cpu,cpu=2 usage_idle=14.3543,usage_system=35.9784,usage_user=7.14281 2062000000000 +cpu,cpu=3 usage_idle=31.8298,usage_system=15.0708,usage_user=54.7503 2063000000000 +cpu,cpu=4 usage_idle=71.4181,usage_system=27.6719,usage_user=99.8962 2064000000000 +cpu,cpu=0 usage_idle=30.3589,usage_system=71.5658,usage_user=86.2136 2065000000000 +cpu,cpu=1 usage_idle=35.3122,usage_system=56.9472,usage_user=2.65022 2066000000000 +cpu,cpu=2 usage_idle=45.9513,usage_system=88.9369,usage_user=1.29633 2067000000000 +cpu,cpu=3 usage_idle=95.3481,usage_system=16.5321,usage_user=53.7643 2068000000000 +cpu,cpu=4 usage_idle=30.1997,usage_system=59.3364,usage_user=54.3937 2069000000000 +cpu,cpu=0 usage_idle=84.9012,usage_system=11.6194,usage_user=33.1937 2070000000000 +cpu,cpu=1 usage_idle=19.2042,usage_system=43.9449,usage_user=78.2721 2071000000000 +cpu,cpu=2 usage_idle=68.045,usage_system=58.2992,usage_user=14.2505 2072000000000 +cpu,cpu=3 usage_idle=75.1878,usage_system=90.1289,usage_user=29.3212 2073000000000 +cpu,cpu=4 usage_idle=29.9381,usage_system=61.547,usage_user=56.9931 2074000000000 +cpu,cpu=0 usage_idle=29.8343,usage_system=91.9059,usage_user=28.5589 2075000000000 +cpu,cpu=1 usage_idle=16.0479,usage_system=27.2181,usage_user=85.5061 2076000000000 +cpu,cpu=2 usage_idle=18.6981,usage_system=73.1694,usage_user=74.4429 2077000000000 +cpu,cpu=3 usage_idle=19.9944,usage_system=68.5175,usage_user=90.975 2078000000000 +cpu,cpu=4 usage_idle=73.7588,usage_system=98.7172,usage_user=50.3114 2079000000000 +cpu,cpu=0 usage_idle=28.1524,usage_system=83.6184,usage_user=61.9308 2080000000000 +cpu,cpu=1 usage_idle=61.3461,usage_system=2.82257,usage_user=5.87572 2081000000000 +cpu,cpu=2 usage_idle=39.6182,usage_system=70.8676,usage_user=64.1749 2082000000000 +cpu,cpu=3 usage_idle=53.8686,usage_system=46.0554,usage_user=54.3038 2083000000000 +cpu,cpu=4 usage_idle=83.1899,usage_system=75.9935,usage_user=15.8508 2084000000000 +cpu,cpu=0 usage_idle=40.183,usage_system=5.82786,usage_user=7.75673 2085000000000 +cpu,cpu=1 usage_idle=68.7419,usage_system=21.8758,usage_user=34.9748 2086000000000 +cpu,cpu=2 usage_idle=54.2479,usage_system=40.5739,usage_user=8.14416 2087000000000 +cpu,cpu=3 usage_idle=28.6909,usage_system=60.5683,usage_user=76.6617 2088000000000 +cpu,cpu=4 usage_idle=19.6659,usage_system=34.3271,usage_user=75.3789 2089000000000 +cpu,cpu=0 usage_idle=69.9773,usage_system=62.4795,usage_user=58.9973 2090000000000 +cpu,cpu=1 usage_idle=31.9081,usage_system=23.8256,usage_user=61.8198 2091000000000 +cpu,cpu=2 usage_idle=37.7838,usage_system=63.4438,usage_user=32.6874 2092000000000 +cpu,cpu=3 usage_idle=1.95871,usage_system=17.3124,usage_user=78.7428 2093000000000 +cpu,cpu=4 usage_idle=56.2626,usage_system=0.502245,usage_user=54.7364 2094000000000 +cpu,cpu=0 usage_idle=72.1134,usage_system=40.6852,usage_user=60.5642 2095000000000 +cpu,cpu=1 usage_idle=79.8701,usage_system=9.42707,usage_user=82.44 2096000000000 +cpu,cpu=2 usage_idle=14.8449,usage_system=63.675,usage_user=23.0139 2097000000000 +cpu,cpu=3 usage_idle=22.9891,usage_system=92.3659,usage_user=83.5822 2098000000000 +cpu,cpu=4 usage_idle=99.6508,usage_system=12.0318,usage_user=17.9092 2099000000000 +cpu,cpu=0 usage_idle=75.0297,usage_system=82.0091,usage_user=80.3887 2100000000000 +cpu,cpu=1 usage_idle=34.0269,usage_system=13.9171,usage_user=4.21432 2101000000000 +cpu,cpu=2 usage_idle=95.8467,usage_system=51.7009,usage_user=67.6581 2102000000000 +cpu,cpu=3 usage_idle=28.5341,usage_system=53.6597,usage_user=84.9705 2103000000000 +cpu,cpu=4 usage_idle=7.27699,usage_system=9.92222,usage_user=85.4727 2104000000000 +cpu,cpu=0 usage_idle=62.0134,usage_system=82.0356,usage_user=26.1579 2105000000000 +cpu,cpu=1 usage_idle=22.5776,usage_system=61.9058,usage_user=35.585 2106000000000 +cpu,cpu=2 usage_idle=5.01762,usage_system=76.7507,usage_user=99.26 2107000000000 +cpu,cpu=3 usage_idle=28.0315,usage_system=99.7398,usage_user=91.6258 2108000000000 +cpu,cpu=4 usage_idle=11.6136,usage_system=99.3906,usage_user=3.65761 2109000000000 +cpu,cpu=0 usage_idle=29.5228,usage_system=74.4202,usage_user=85.6667 2110000000000 +cpu,cpu=1 usage_idle=9.91157,usage_system=8.44715,usage_user=99.5838 2111000000000 +cpu,cpu=2 usage_idle=14.1259,usage_system=4.29388,usage_user=51.2847 2112000000000 +cpu,cpu=3 usage_idle=81.784,usage_system=32.828,usage_user=4.94439 2113000000000 +cpu,cpu=4 usage_idle=66.7544,usage_system=40.105,usage_user=14.8666 2114000000000 +cpu,cpu=0 usage_idle=52.2272,usage_system=2.11838,usage_user=96.9022 2115000000000 +cpu,cpu=1 usage_idle=78.3851,usage_system=24.696,usage_user=58.808 2116000000000 +cpu,cpu=2 usage_idle=13.97,usage_system=29.7136,usage_user=35.5587 2117000000000 +cpu,cpu=3 usage_idle=13.23,usage_system=57.7451,usage_user=35.2985 2118000000000 +cpu,cpu=4 usage_idle=4.85586,usage_system=69.3587,usage_user=34.6891 2119000000000 +cpu,cpu=0 usage_idle=8.51347,usage_system=98.8816,usage_user=9.10929 2120000000000 +cpu,cpu=1 usage_idle=94.1801,usage_system=8.79312,usage_user=17.5564 2121000000000 +cpu,cpu=2 usage_idle=93.7639,usage_system=22.919,usage_user=21.8503 2122000000000 +cpu,cpu=3 usage_idle=45.0487,usage_system=4.70298,usage_user=54.6783 2123000000000 +cpu,cpu=4 usage_idle=49.993,usage_system=71.4574,usage_user=94.7833 2124000000000 +cpu,cpu=0 usage_idle=64.8596,usage_system=23.6846,usage_user=96.9017 2125000000000 +cpu,cpu=1 usage_idle=61.7619,usage_system=2.06964,usage_user=21.5977 2126000000000 +cpu,cpu=2 usage_idle=20.5699,usage_system=16.0397,usage_user=51.3113 2127000000000 +cpu,cpu=3 usage_idle=56.1286,usage_system=29.2697,usage_user=9.05641 2128000000000 +cpu,cpu=4 usage_idle=91.427,usage_system=34.1256,usage_user=78.4151 2129000000000 +cpu,cpu=0 usage_idle=26.1161,usage_system=42.639,usage_user=77.2967 2130000000000 +cpu,cpu=1 usage_idle=35.2254,usage_system=36.8191,usage_user=86.0898 2131000000000 +cpu,cpu=2 usage_idle=52.7818,usage_system=30.5831,usage_user=9.00882 2132000000000 +cpu,cpu=3 usage_idle=74.6321,usage_system=75.6317,usage_user=13.7118 2133000000000 +cpu,cpu=4 usage_idle=29.3104,usage_system=25.6248,usage_user=85.1692 2134000000000 +cpu,cpu=0 usage_idle=24.0938,usage_system=90.4844,usage_user=8.8538 2135000000000 +cpu,cpu=1 usage_idle=20.9955,usage_system=52.2463,usage_user=10.9234 2136000000000 +cpu,cpu=2 usage_idle=42.5932,usage_system=72.8161,usage_user=26.9631 2137000000000 +cpu,cpu=3 usage_idle=93.9045,usage_system=28.9447,usage_user=56.2328 2138000000000 +cpu,cpu=4 usage_idle=2.96093,usage_system=20.3717,usage_user=90.3584 2139000000000 +cpu,cpu=0 usage_idle=81.3761,usage_system=46.4878,usage_user=32.9974 2140000000000 +cpu,cpu=1 usage_idle=58.6727,usage_system=81.7132,usage_user=69.8165 2141000000000 +cpu,cpu=2 usage_idle=44.7625,usage_system=34.495,usage_user=0.399594 2142000000000 +cpu,cpu=3 usage_idle=53.7714,usage_system=9.12713,usage_user=76.0313 2143000000000 +cpu,cpu=4 usage_idle=67.4832,usage_system=38.4376,usage_user=1.65607 2144000000000 +cpu,cpu=0 usage_idle=52.6524,usage_system=62.5314,usage_user=92.1405 2145000000000 +cpu,cpu=1 usage_idle=61.5062,usage_system=83.5268,usage_user=44.3867 2146000000000 +cpu,cpu=2 usage_idle=72.4296,usage_system=26.12,usage_user=17.2029 2147000000000 +cpu,cpu=3 usage_idle=99.3927,usage_system=20.0246,usage_user=46.1476 2148000000000 +cpu,cpu=4 usage_idle=55.6255,usage_system=22.9855,usage_user=66.5193 2149000000000 +cpu,cpu=0 usage_idle=45.9839,usage_system=4.36154,usage_user=13.0072 2150000000000 +cpu,cpu=1 usage_idle=78.9813,usage_system=63.0343,usage_user=94.7204 2151000000000 +cpu,cpu=2 usage_idle=48.7978,usage_system=7.79682,usage_user=29.2154 2152000000000 +cpu,cpu=3 usage_idle=49.1974,usage_system=61.5682,usage_user=38.3425 2153000000000 +cpu,cpu=4 usage_idle=25.2287,usage_system=29.0513,usage_user=76.7801 2154000000000 +cpu,cpu=0 usage_idle=26.8848,usage_system=81.7037,usage_user=39.3114 2155000000000 +cpu,cpu=1 usage_idle=19.0252,usage_system=43.2099,usage_user=22.8383 2156000000000 +cpu,cpu=2 usage_idle=63.412,usage_system=15.6395,usage_user=48.9583 2157000000000 +cpu,cpu=3 usage_idle=80.6149,usage_system=15.0322,usage_user=68.9829 2158000000000 +cpu,cpu=4 usage_idle=26.7625,usage_system=70.6577,usage_user=91.9683 2159000000000 +cpu,cpu=0 usage_idle=93.2818,usage_system=16.6416,usage_user=96.3299 2160000000000 +cpu,cpu=1 usage_idle=6.28894,usage_system=95.6229,usage_user=59.3642 2161000000000 +cpu,cpu=2 usage_idle=1.00931,usage_system=44.4206,usage_user=67.161 2162000000000 +cpu,cpu=3 usage_idle=30.2247,usage_system=93.618,usage_user=28.7292 2163000000000 +cpu,cpu=4 usage_idle=68.5672,usage_system=18.8467,usage_user=57.7805 2164000000000 +cpu,cpu=0 usage_idle=45.3473,usage_system=45.7315,usage_user=39.4842 2165000000000 +cpu,cpu=1 usage_idle=84.6587,usage_system=64.7567,usage_user=82.6941 2166000000000 +cpu,cpu=2 usage_idle=7.497,usage_system=28.1687,usage_user=98.3336 2167000000000 +cpu,cpu=3 usage_idle=56.4553,usage_system=8.78351,usage_user=13.3659 2168000000000 +cpu,cpu=4 usage_idle=25.4382,usage_system=35.546,usage_user=84.0236 2169000000000 +cpu,cpu=0 usage_idle=17.4065,usage_system=28.8277,usage_user=0.665221 2170000000000 +cpu,cpu=1 usage_idle=13.7364,usage_system=35.1167,usage_user=96.2881 2171000000000 +cpu,cpu=2 usage_idle=73.1006,usage_system=36.126,usage_user=40.7087 2172000000000 +cpu,cpu=3 usage_idle=40.2615,usage_system=66.3507,usage_user=34.3268 2173000000000 +cpu,cpu=4 usage_idle=68.9907,usage_system=34.9179,usage_user=53.1735 2174000000000 +cpu,cpu=0 usage_idle=26.7712,usage_system=80.2652,usage_user=98.9049 2175000000000 +cpu,cpu=1 usage_idle=66.2554,usage_system=64.9239,usage_user=63.6616 2176000000000 +cpu,cpu=2 usage_idle=48.9495,usage_system=72.4209,usage_user=91.8303 2177000000000 +cpu,cpu=3 usage_idle=47.2832,usage_system=28.8762,usage_user=0.613772 2178000000000 +cpu,cpu=4 usage_idle=60.649,usage_system=54.3144,usage_user=36.1597 2179000000000 +cpu,cpu=0 usage_idle=44.6726,usage_system=71.7209,usage_user=64.9875 2180000000000 +cpu,cpu=1 usage_idle=45.3378,usage_system=85.4573,usage_user=0.104169 2181000000000 +cpu,cpu=2 usage_idle=41.6259,usage_system=58.5579,usage_user=36.2302 2182000000000 +cpu,cpu=3 usage_idle=82.3347,usage_system=98.8194,usage_user=2.58086 2183000000000 +cpu,cpu=4 usage_idle=16.6614,usage_system=67.8101,usage_user=37.4988 2184000000000 +cpu,cpu=0 usage_idle=69.8349,usage_system=94.5813,usage_user=17.7639 2185000000000 +cpu,cpu=1 usage_idle=68.7398,usage_system=60.8368,usage_user=82.6878 2186000000000 +cpu,cpu=2 usage_idle=32.4014,usage_system=9.78629,usage_user=55.1088 2187000000000 +cpu,cpu=3 usage_idle=24.2317,usage_system=57.0695,usage_user=83.985 2188000000000 +cpu,cpu=4 usage_idle=24.8455,usage_system=17.7185,usage_user=38.2994 2189000000000 +cpu,cpu=0 usage_idle=61.0052,usage_system=62.3911,usage_user=10.0203 2190000000000 +cpu,cpu=1 usage_idle=25.9927,usage_system=7.72893,usage_user=95.4776 2191000000000 +cpu,cpu=2 usage_idle=26.0968,usage_system=49.3549,usage_user=54.0355 2192000000000 +cpu,cpu=3 usage_idle=62.327,usage_system=31.6895,usage_user=52.8549 2193000000000 +cpu,cpu=4 usage_idle=64.9079,usage_system=48.351,usage_user=20.665 2194000000000 +cpu,cpu=0 usage_idle=2.40662,usage_system=18.1859,usage_user=15.2464 2195000000000 +cpu,cpu=1 usage_idle=20.1706,usage_system=86.9257,usage_user=76.0831 2196000000000 +cpu,cpu=2 usage_idle=2.85841,usage_system=19.3271,usage_user=85.8694 2197000000000 +cpu,cpu=3 usage_idle=57.9672,usage_system=43.5588,usage_user=42.9389 2198000000000 +cpu,cpu=4 usage_idle=41.9521,usage_system=68.4042,usage_user=60.6573 2199000000000 +cpu,cpu=0 usage_idle=80.2515,usage_system=29.4094,usage_user=23.0484 2200000000000 +cpu,cpu=1 usage_idle=90.2718,usage_system=55.4021,usage_user=30.7774 2201000000000 +cpu,cpu=2 usage_idle=85.7493,usage_system=81.4989,usage_user=80.1322 2202000000000 +cpu,cpu=3 usage_idle=39.7848,usage_system=43.8259,usage_user=11.8217 2203000000000 +cpu,cpu=4 usage_idle=92.6397,usage_system=8.73379,usage_user=60.1727 2204000000000 +cpu,cpu=0 usage_idle=13.3047,usage_system=11.1404,usage_user=78.3586 2205000000000 +cpu,cpu=1 usage_idle=28.5511,usage_system=31.311,usage_user=65.2842 2206000000000 +cpu,cpu=2 usage_idle=4.63421,usage_system=34.1694,usage_user=84.6113 2207000000000 +cpu,cpu=3 usage_idle=90.5036,usage_system=92.1365,usage_user=28.1701 2208000000000 +cpu,cpu=4 usage_idle=33.4425,usage_system=34.0887,usage_user=96.5743 2209000000000 +cpu,cpu=0 usage_idle=94.0998,usage_system=14.3402,usage_user=25.9837 2210000000000 +cpu,cpu=1 usage_idle=17.1482,usage_system=4.61191,usage_user=81.3858 2211000000000 +cpu,cpu=2 usage_idle=47.9256,usage_system=90.3612,usage_user=62.8847 2212000000000 +cpu,cpu=3 usage_idle=28.0578,usage_system=30.146,usage_user=6.71061 2213000000000 +cpu,cpu=4 usage_idle=39.8795,usage_system=22.7857,usage_user=15.4444 2214000000000 +cpu,cpu=0 usage_idle=0.0522443,usage_system=36.0904,usage_user=26.5848 2215000000000 +cpu,cpu=1 usage_idle=78.4108,usage_system=64.6415,usage_user=57.8958 2216000000000 +cpu,cpu=2 usage_idle=43.695,usage_system=69.2757,usage_user=92.0652 2217000000000 +cpu,cpu=3 usage_idle=28.3063,usage_system=59.7793,usage_user=84.2017 2218000000000 +cpu,cpu=4 usage_idle=56.4764,usage_system=93.2218,usage_user=18.2904 2219000000000 +cpu,cpu=0 usage_idle=53.0507,usage_system=87.3216,usage_user=32.6305 2220000000000 +cpu,cpu=1 usage_idle=79.0344,usage_system=4.46988,usage_user=37.2424 2221000000000 +cpu,cpu=2 usage_idle=60.4202,usage_system=52.3955,usage_user=27.6037 2222000000000 +cpu,cpu=3 usage_idle=23.3048,usage_system=80.4533,usage_user=57.7497 2223000000000 +cpu,cpu=4 usage_idle=30.0155,usage_system=20.3328,usage_user=80.5354 2224000000000 +cpu,cpu=0 usage_idle=45.4599,usage_system=20.3851,usage_user=16.6258 2225000000000 +cpu,cpu=1 usage_idle=72.0447,usage_system=98.7959,usage_user=81.2673 2226000000000 +cpu,cpu=2 usage_idle=29.9405,usage_system=42.4909,usage_user=50.5431 2227000000000 +cpu,cpu=3 usage_idle=22.0056,usage_system=70.7972,usage_user=10.3224 2228000000000 +cpu,cpu=4 usage_idle=6.20732,usage_system=27.2736,usage_user=3.54423 2229000000000 +cpu,cpu=0 usage_idle=24.4977,usage_system=80.3242,usage_user=90.8659 2230000000000 +cpu,cpu=1 usage_idle=57.1282,usage_system=59.3586,usage_user=95.3358 2231000000000 +cpu,cpu=2 usage_idle=94.3706,usage_system=19.7788,usage_user=47.7312 2232000000000 +cpu,cpu=3 usage_idle=21.9743,usage_system=43.0836,usage_user=28.1845 2233000000000 +cpu,cpu=4 usage_idle=79.724,usage_system=73.0991,usage_user=48.5173 2234000000000 +cpu,cpu=0 usage_idle=60.2594,usage_system=18.5589,usage_user=68.9024 2235000000000 +cpu,cpu=1 usage_idle=76.8852,usage_system=90.6036,usage_user=67.6982 2236000000000 +cpu,cpu=2 usage_idle=58.1526,usage_system=20.5441,usage_user=10.1891 2237000000000 +cpu,cpu=3 usage_idle=8.69565,usage_system=42.5497,usage_user=80.9863 2238000000000 +cpu,cpu=4 usage_idle=19.0181,usage_system=48.757,usage_user=8.25982 2239000000000 +cpu,cpu=0 usage_idle=22.5623,usage_system=73.2547,usage_user=88.5841 2240000000000 +cpu,cpu=1 usage_idle=13.4282,usage_system=30.3829,usage_user=47.9427 2241000000000 +cpu,cpu=2 usage_idle=8.76391,usage_system=24.7535,usage_user=67.7214 2242000000000 +cpu,cpu=3 usage_idle=56.4951,usage_system=46.7278,usage_user=10.805 2243000000000 +cpu,cpu=4 usage_idle=84.6796,usage_system=26.4518,usage_user=83.9041 2244000000000 +cpu,cpu=0 usage_idle=33.1969,usage_system=86.7112,usage_user=2.46303 2245000000000 +cpu,cpu=1 usage_idle=2.09929,usage_system=63.5965,usage_user=93.0666 2246000000000 +cpu,cpu=2 usage_idle=69.7975,usage_system=21.749,usage_user=13.6107 2247000000000 +cpu,cpu=3 usage_idle=79.9866,usage_system=30.4447,usage_user=56.1603 2248000000000 +cpu,cpu=4 usage_idle=60.9728,usage_system=49.4627,usage_user=4.91733 2249000000000 +cpu,cpu=0 usage_idle=69.2326,usage_system=72.025,usage_user=78.172 2250000000000 +cpu,cpu=1 usage_idle=57.8167,usage_system=85.4532,usage_user=8.55488 2251000000000 +cpu,cpu=2 usage_idle=5.75937,usage_system=94.2171,usage_user=33.3084 2252000000000 +cpu,cpu=3 usage_idle=73.4808,usage_system=50.7122,usage_user=80.0362 2253000000000 +cpu,cpu=4 usage_idle=84.2858,usage_system=35.3919,usage_user=6.48805 2254000000000 +cpu,cpu=0 usage_idle=68.1899,usage_system=68.5888,usage_user=93.1993 2255000000000 +cpu,cpu=1 usage_idle=70.653,usage_system=70.6881,usage_user=56.7957 2256000000000 +cpu,cpu=2 usage_idle=63.7196,usage_system=40.4856,usage_user=78.5448 2257000000000 +cpu,cpu=3 usage_idle=77.3303,usage_system=20.4722,usage_user=8.98946 2258000000000 +cpu,cpu=4 usage_idle=33.4906,usage_system=81.445,usage_user=58.4522 2259000000000 +cpu,cpu=0 usage_idle=38.408,usage_system=50.6776,usage_user=30.4772 2260000000000 +cpu,cpu=1 usage_idle=16.58,usage_system=8.49434,usage_user=15.9304 2261000000000 +cpu,cpu=2 usage_idle=25.1348,usage_system=14.2537,usage_user=10.1475 2262000000000 +cpu,cpu=3 usage_idle=58.4432,usage_system=87.7345,usage_user=60.8598 2263000000000 +cpu,cpu=4 usage_idle=38.4795,usage_system=72.0204,usage_user=96.2517 2264000000000 +cpu,cpu=0 usage_idle=44.9675,usage_system=40.2103,usage_user=64.8405 2265000000000 +cpu,cpu=1 usage_idle=38.1668,usage_system=10.8633,usage_user=35.5285 2266000000000 +cpu,cpu=2 usage_idle=94.9625,usage_system=74.5829,usage_user=76.0141 2267000000000 +cpu,cpu=3 usage_idle=73.5073,usage_system=51.9132,usage_user=96.4863 2268000000000 +cpu,cpu=4 usage_idle=82.4967,usage_system=85.4038,usage_user=77.9313 2269000000000 +cpu,cpu=0 usage_idle=40.949,usage_system=23.8118,usage_user=28.6089 2270000000000 +cpu,cpu=1 usage_idle=71.4262,usage_system=40.3917,usage_user=37.1033 2271000000000 +cpu,cpu=2 usage_idle=87.3566,usage_system=65.5266,usage_user=51.357 2272000000000 +cpu,cpu=3 usage_idle=97.5042,usage_system=23.9698,usage_user=39.0915 2273000000000 +cpu,cpu=4 usage_idle=58.364,usage_system=62.4493,usage_user=11.1119 2274000000000 +cpu,cpu=0 usage_idle=54.6156,usage_system=7.41684,usage_user=51.3222 2275000000000 +cpu,cpu=1 usage_idle=19.4561,usage_system=45.5836,usage_user=62.1855 2276000000000 +cpu,cpu=2 usage_idle=54.9846,usage_system=40.5461,usage_user=36.7684 2277000000000 +cpu,cpu=3 usage_idle=30.9987,usage_system=14.0534,usage_user=88.6816 2278000000000 +cpu,cpu=4 usage_idle=27.485,usage_system=96.5502,usage_user=74.0854 2279000000000 +cpu,cpu=0 usage_idle=5.4163,usage_system=37.4991,usage_user=97.8972 2280000000000 +cpu,cpu=1 usage_idle=34.0252,usage_system=8.92532,usage_user=38.2889 2281000000000 +cpu,cpu=2 usage_idle=71.1285,usage_system=96.282,usage_user=3.81551 2282000000000 +cpu,cpu=3 usage_idle=22.4854,usage_system=93.7861,usage_user=27.7854 2283000000000 +cpu,cpu=4 usage_idle=61.5769,usage_system=52.1501,usage_user=90.2347 2284000000000 +cpu,cpu=0 usage_idle=72.6888,usage_system=6.76572,usage_user=97.6515 2285000000000 +cpu,cpu=1 usage_idle=24.011,usage_system=26.2218,usage_user=43.2352 2286000000000 +cpu,cpu=2 usage_idle=86.1965,usage_system=81.2064,usage_user=83.7813 2287000000000 +cpu,cpu=3 usage_idle=22.9649,usage_system=12.2052,usage_user=97.8347 2288000000000 +cpu,cpu=4 usage_idle=11.6464,usage_system=39.6902,usage_user=94.3849 2289000000000 +cpu,cpu=0 usage_idle=85.7318,usage_system=45.1065,usage_user=31.884 2290000000000 +cpu,cpu=1 usage_idle=83.629,usage_system=79.1317,usage_user=40.8093 2291000000000 +cpu,cpu=2 usage_idle=21.9179,usage_system=50.2602,usage_user=37.0913 2292000000000 +cpu,cpu=3 usage_idle=25.7334,usage_system=72.7456,usage_user=30.8774 2293000000000 +cpu,cpu=4 usage_idle=53.5188,usage_system=34.3226,usage_user=83.0275 2294000000000 +cpu,cpu=0 usage_idle=43.7534,usage_system=7.01137,usage_user=89.7932 2295000000000 +cpu,cpu=1 usage_idle=41.405,usage_system=31.0224,usage_user=16.015 2296000000000 +cpu,cpu=2 usage_idle=84.6401,usage_system=17.2189,usage_user=97.2215 2297000000000 +cpu,cpu=3 usage_idle=68.4214,usage_system=40.1837,usage_user=9.42665 2298000000000 +cpu,cpu=4 usage_idle=66.2561,usage_system=51.8301,usage_user=49.1168 2299000000000 +cpu,cpu=0 usage_idle=60.641,usage_system=37.562,usage_user=94.2233 2300000000000 +cpu,cpu=1 usage_idle=92.5251,usage_system=21.1909,usage_user=73.3551 2301000000000 +cpu,cpu=2 usage_idle=33.3344,usage_system=43.1088,usage_user=23.6152 2302000000000 +cpu,cpu=3 usage_idle=70.4257,usage_system=68.8422,usage_user=96.3609 2303000000000 +cpu,cpu=4 usage_idle=1.30312,usage_system=22.361,usage_user=30.6834 2304000000000 +cpu,cpu=0 usage_idle=84.3306,usage_system=66.1144,usage_user=37.6948 2305000000000 +cpu,cpu=1 usage_idle=74.1239,usage_system=7.51938,usage_user=68.7172 2306000000000 +cpu,cpu=2 usage_idle=90.1389,usage_system=92.1595,usage_user=85.936 2307000000000 +cpu,cpu=3 usage_idle=87.3604,usage_system=60.5809,usage_user=26.1198 2308000000000 +cpu,cpu=4 usage_idle=96.7871,usage_system=26.837,usage_user=77.9499 2309000000000 +cpu,cpu=0 usage_idle=45.9039,usage_system=87.4781,usage_user=15.5119 2310000000000 +cpu,cpu=1 usage_idle=40.1273,usage_system=80.0031,usage_user=36.7028 2311000000000 +cpu,cpu=2 usage_idle=13.4823,usage_system=13.3375,usage_user=79.8116 2312000000000 +cpu,cpu=3 usage_idle=37.0976,usage_system=83.7632,usage_user=48.6538 2313000000000 +cpu,cpu=4 usage_idle=33.4584,usage_system=85.0663,usage_user=71.0148 2314000000000 +cpu,cpu=0 usage_idle=64.1419,usage_system=69.397,usage_user=37.1292 2315000000000 +cpu,cpu=1 usage_idle=1.83669,usage_system=43.5209,usage_user=44.6486 2316000000000 +cpu,cpu=2 usage_idle=70.5539,usage_system=33.6598,usage_user=36.8081 2317000000000 +cpu,cpu=3 usage_idle=56.4899,usage_system=21.0202,usage_user=97.389 2318000000000 +cpu,cpu=4 usage_idle=82.6097,usage_system=17.8073,usage_user=24.2261 2319000000000 +cpu,cpu=0 usage_idle=60.5596,usage_system=63.7112,usage_user=11.7041 2320000000000 +cpu,cpu=1 usage_idle=76.0714,usage_system=3.83841,usage_user=91.7072 2321000000000 +cpu,cpu=2 usage_idle=12.7742,usage_system=17.3207,usage_user=5.04474 2322000000000 +cpu,cpu=3 usage_idle=92.5858,usage_system=54.4183,usage_user=88.808 2323000000000 +cpu,cpu=4 usage_idle=41.2397,usage_system=87.8767,usage_user=73.8743 2324000000000 +cpu,cpu=0 usage_idle=12.2545,usage_system=52.0186,usage_user=43.2712 2325000000000 +cpu,cpu=1 usage_idle=49.3837,usage_system=53.8553,usage_user=86.7921 2326000000000 +cpu,cpu=2 usage_idle=94.0324,usage_system=24.4092,usage_user=20.4519 2327000000000 +cpu,cpu=3 usage_idle=30.8405,usage_system=80.8991,usage_user=41.4721 2328000000000 +cpu,cpu=4 usage_idle=28.2295,usage_system=63.5088,usage_user=59.2793 2329000000000 +cpu,cpu=0 usage_idle=52.4556,usage_system=24.0683,usage_user=22.9905 2330000000000 +cpu,cpu=1 usage_idle=64.1597,usage_system=0.139733,usage_user=26.8289 2331000000000 +cpu,cpu=2 usage_idle=55.8669,usage_system=12.9139,usage_user=44.1496 2332000000000 +cpu,cpu=3 usage_idle=60.9117,usage_system=5.49977,usage_user=98.5679 2333000000000 +cpu,cpu=4 usage_idle=49.7196,usage_system=46.7394,usage_user=86.4447 2334000000000 +cpu,cpu=0 usage_idle=23.5939,usage_system=58.9939,usage_user=38.4633 2335000000000 +cpu,cpu=1 usage_idle=66.8651,usage_system=8.37769,usage_user=92.3186 2336000000000 +cpu,cpu=2 usage_idle=53.6572,usage_system=2.41007,usage_user=16.7278 2337000000000 +cpu,cpu=3 usage_idle=74.1091,usage_system=33.2506,usage_user=97.6269 2338000000000 +cpu,cpu=4 usage_idle=15.5812,usage_system=61.4801,usage_user=61.1356 2339000000000 +cpu,cpu=0 usage_idle=74.8606,usage_system=13.9357,usage_user=85.2039 2340000000000 +cpu,cpu=1 usage_idle=97.8511,usage_system=78.0954,usage_user=85.3437 2341000000000 +cpu,cpu=2 usage_idle=24.68,usage_system=33.9623,usage_user=98.2576 2342000000000 +cpu,cpu=3 usage_idle=68.8296,usage_system=94.874,usage_user=3.7574 2343000000000 +cpu,cpu=4 usage_idle=67.3976,usage_system=44.5936,usage_user=50.4968 2344000000000 +cpu,cpu=0 usage_idle=53.8422,usage_system=68.1875,usage_user=9.49078 2345000000000 +cpu,cpu=1 usage_idle=92.3055,usage_system=35.0527,usage_user=17.8685 2346000000000 +cpu,cpu=2 usage_idle=84.6241,usage_system=88.7099,usage_user=20.2785 2347000000000 +cpu,cpu=3 usage_idle=1.35191,usage_system=62.819,usage_user=53.5291 2348000000000 +cpu,cpu=4 usage_idle=98.9788,usage_system=78.4003,usage_user=15.0092 2349000000000 +cpu,cpu=0 usage_idle=60.1144,usage_system=53.2608,usage_user=28.9449 2350000000000 +cpu,cpu=1 usage_idle=45.3184,usage_system=51.1119,usage_user=7.04025 2351000000000 +cpu,cpu=2 usage_idle=30.6621,usage_system=75.7918,usage_user=41.0026 2352000000000 +cpu,cpu=3 usage_idle=28.9197,usage_system=44.6215,usage_user=35.8766 2353000000000 +cpu,cpu=4 usage_idle=32.6771,usage_system=12.019,usage_user=80.4702 2354000000000 +cpu,cpu=0 usage_idle=83.1739,usage_system=65.8612,usage_user=48.6577 2355000000000 +cpu,cpu=1 usage_idle=92.6647,usage_system=58.1668,usage_user=83.7104 2356000000000 +cpu,cpu=2 usage_idle=10.5332,usage_system=42.7909,usage_user=72.4203 2357000000000 +cpu,cpu=3 usage_idle=30.8117,usage_system=44.1428,usage_user=35.2394 2358000000000 +cpu,cpu=4 usage_idle=84.3408,usage_system=43.1216,usage_user=13.6396 2359000000000 +cpu,cpu=0 usage_idle=99.35,usage_system=3.23602,usage_user=66.9004 2360000000000 +cpu,cpu=1 usage_idle=28.2949,usage_system=48.5544,usage_user=18.0123 2361000000000 +cpu,cpu=2 usage_idle=35.3351,usage_system=79.2164,usage_user=93.8041 2362000000000 +cpu,cpu=3 usage_idle=76.3377,usage_system=8.13613,usage_user=38.4256 2363000000000 +cpu,cpu=4 usage_idle=12.2143,usage_system=40.8132,usage_user=50.4446 2364000000000 +cpu,cpu=0 usage_idle=92.6844,usage_system=23.9871,usage_user=16.3059 2365000000000 +cpu,cpu=1 usage_idle=41.3422,usage_system=16.6518,usage_user=74.4726 2366000000000 +cpu,cpu=2 usage_idle=25.0525,usage_system=27.185,usage_user=17.2635 2367000000000 +cpu,cpu=3 usage_idle=97.4728,usage_system=57.9967,usage_user=61.4064 2368000000000 +cpu,cpu=4 usage_idle=32.7122,usage_system=42.3375,usage_user=4.52796 2369000000000 +cpu,cpu=0 usage_idle=46.3518,usage_system=41.6875,usage_user=7.76398 2370000000000 +cpu,cpu=1 usage_idle=13.2522,usage_system=69.9824,usage_user=56.3184 2371000000000 +cpu,cpu=2 usage_idle=31.2645,usage_system=5.3175,usage_user=35.5348 2372000000000 +cpu,cpu=3 usage_idle=25.0687,usage_system=81.6552,usage_user=43.671 2373000000000 +cpu,cpu=4 usage_idle=63.4943,usage_system=93.8695,usage_user=84.4842 2374000000000 +cpu,cpu=0 usage_idle=13.9389,usage_system=86.5539,usage_user=8.47128 2375000000000 +cpu,cpu=1 usage_idle=30.2448,usage_system=27.8961,usage_user=25.1231 2376000000000 +cpu,cpu=2 usage_idle=4.71742,usage_system=52.9486,usage_user=52.3081 2377000000000 +cpu,cpu=3 usage_idle=21.981,usage_system=50.4214,usage_user=10.3048 2378000000000 +cpu,cpu=4 usage_idle=83.3873,usage_system=83.1336,usage_user=52.6423 2379000000000 +cpu,cpu=0 usage_idle=87.9153,usage_system=29.4854,usage_user=94.3298 2380000000000 +cpu,cpu=1 usage_idle=95.6793,usage_system=42.7377,usage_user=64.3121 2381000000000 +cpu,cpu=2 usage_idle=51.9976,usage_system=74.0022,usage_user=69.6296 2382000000000 +cpu,cpu=3 usage_idle=87.5325,usage_system=99.0709,usage_user=51.2848 2383000000000 +cpu,cpu=4 usage_idle=31.2034,usage_system=62.5652,usage_user=45.1543 2384000000000 +cpu,cpu=0 usage_idle=15.6876,usage_system=76.5041,usage_user=31.7082 2385000000000 +cpu,cpu=1 usage_idle=24.1589,usage_system=6.74892,usage_user=59.6042 2386000000000 +cpu,cpu=2 usage_idle=49.282,usage_system=11.4663,usage_user=12.5528 2387000000000 +cpu,cpu=3 usage_idle=1.59006,usage_system=33.4473,usage_user=62.9742 2388000000000 +cpu,cpu=4 usage_idle=11.8948,usage_system=16.8346,usage_user=46.1079 2389000000000 +cpu,cpu=0 usage_idle=64.5371,usage_system=4.74988,usage_user=75.5933 2390000000000 +cpu,cpu=1 usage_idle=58.8669,usage_system=0.429139,usage_user=18.331 2391000000000 +cpu,cpu=2 usage_idle=23.179,usage_system=52.4268,usage_user=92.3332 2392000000000 +cpu,cpu=3 usage_idle=92.8086,usage_system=39.9592,usage_user=91.4041 2393000000000 +cpu,cpu=4 usage_idle=44.0934,usage_system=71.1627,usage_user=53.9694 2394000000000 +cpu,cpu=0 usage_idle=89.2477,usage_system=86.8503,usage_user=30.4735 2395000000000 +cpu,cpu=1 usage_idle=20.9559,usage_system=11.0091,usage_user=37.2224 2396000000000 +cpu,cpu=2 usage_idle=80.5601,usage_system=60.2911,usage_user=48.6887 2397000000000 +cpu,cpu=3 usage_idle=93.113,usage_system=61.8812,usage_user=82.136 2398000000000 +cpu,cpu=4 usage_idle=56.0872,usage_system=73.776,usage_user=98.9706 2399000000000 +cpu,cpu=0 usage_idle=2.19507,usage_system=38.3131,usage_user=3.72052 2400000000000 +cpu,cpu=1 usage_idle=77.7884,usage_system=97.1799,usage_user=4.14966 2401000000000 +cpu,cpu=2 usage_idle=96.1194,usage_system=20.3589,usage_user=56.5764 2402000000000 +cpu,cpu=3 usage_idle=88.4526,usage_system=13.1675,usage_user=96.5357 2403000000000 +cpu,cpu=4 usage_idle=79.8567,usage_system=57.261,usage_user=67.6984 2404000000000 +cpu,cpu=0 usage_idle=33.8261,usage_system=46.5087,usage_user=54.5486 2405000000000 +cpu,cpu=1 usage_idle=64.2996,usage_system=67.4646,usage_user=65.5577 2406000000000 +cpu,cpu=2 usage_idle=1.52197,usage_system=48.0247,usage_user=25.8488 2407000000000 +cpu,cpu=3 usage_idle=50.2107,usage_system=41.1376,usage_user=87.73 2408000000000 +cpu,cpu=4 usage_idle=32.3467,usage_system=97.2249,usage_user=61.506 2409000000000 +cpu,cpu=0 usage_idle=31.3174,usage_system=99.4199,usage_user=99.8191 2410000000000 +cpu,cpu=1 usage_idle=35.0379,usage_system=77.2083,usage_user=96.999 2411000000000 +cpu,cpu=2 usage_idle=39.1876,usage_system=73.3277,usage_user=17.3579 2412000000000 +cpu,cpu=3 usage_idle=95.764,usage_system=61.7802,usage_user=30.5254 2413000000000 +cpu,cpu=4 usage_idle=92.2997,usage_system=41.6369,usage_user=87.7864 2414000000000 +cpu,cpu=0 usage_idle=59.9981,usage_system=75.463,usage_user=34.2951 2415000000000 +cpu,cpu=1 usage_idle=14.5467,usage_system=39.7625,usage_user=1.75963 2416000000000 +cpu,cpu=2 usage_idle=80.1044,usage_system=41.2845,usage_user=49.7843 2417000000000 +cpu,cpu=3 usage_idle=5.95323,usage_system=91.4952,usage_user=90.922 2418000000000 +cpu,cpu=4 usage_idle=93.6832,usage_system=23.842,usage_user=88.1468 2419000000000 +cpu,cpu=0 usage_idle=55.1892,usage_system=55.1594,usage_user=87.5668 2420000000000 +cpu,cpu=1 usage_idle=55.0082,usage_system=90.1973,usage_user=64.7751 2421000000000 +cpu,cpu=2 usage_idle=52.0072,usage_system=29.3849,usage_user=38.1027 2422000000000 +cpu,cpu=3 usage_idle=69.3651,usage_system=25.1489,usage_user=99.883 2423000000000 +cpu,cpu=4 usage_idle=99.8906,usage_system=17.4486,usage_user=41.5199 2424000000000 +cpu,cpu=0 usage_idle=87.677,usage_system=77.4466,usage_user=16.9829 2425000000000 +cpu,cpu=1 usage_idle=21.972,usage_system=91.9933,usage_user=56.7454 2426000000000 +cpu,cpu=2 usage_idle=23.7317,usage_system=72.0977,usage_user=98.03 2427000000000 +cpu,cpu=3 usage_idle=73.516,usage_system=78.0509,usage_user=89.5252 2428000000000 +cpu,cpu=4 usage_idle=64.438,usage_system=71.7341,usage_user=13.3672 2429000000000 +cpu,cpu=0 usage_idle=52.5848,usage_system=26.9233,usage_user=68.5265 2430000000000 +cpu,cpu=1 usage_idle=40.1516,usage_system=81.9316,usage_user=58.7238 2431000000000 +cpu,cpu=2 usage_idle=4.92661,usage_system=33.9388,usage_user=88.1087 2432000000000 +cpu,cpu=3 usage_idle=43.0293,usage_system=3.30394,usage_user=13.2576 2433000000000 +cpu,cpu=4 usage_idle=42.9123,usage_system=3.19453,usage_user=30.7061 2434000000000 +cpu,cpu=0 usage_idle=84.4322,usage_system=90.8715,usage_user=8.15278 2435000000000 +cpu,cpu=1 usage_idle=1.4151,usage_system=12.8435,usage_user=0.146079 2436000000000 +cpu,cpu=2 usage_idle=58.1605,usage_system=36.5752,usage_user=72.2438 2437000000000 +cpu,cpu=3 usage_idle=56.1905,usage_system=10.0912,usage_user=50.2947 2438000000000 +cpu,cpu=4 usage_idle=45.7157,usage_system=74.5292,usage_user=22.0288 2439000000000 +cpu,cpu=0 usage_idle=59.0828,usage_system=27.114,usage_user=48.9522 2440000000000 +cpu,cpu=1 usage_idle=27.6094,usage_system=67.2655,usage_user=30.8837 2441000000000 +cpu,cpu=2 usage_idle=86.3332,usage_system=72.1922,usage_user=64.8225 2442000000000 +cpu,cpu=3 usage_idle=74.4419,usage_system=15.2215,usage_user=68.1264 2443000000000 +cpu,cpu=4 usage_idle=87.6994,usage_system=58.1338,usage_user=71.321 2444000000000 +cpu,cpu=0 usage_idle=18.4055,usage_system=42.566,usage_user=62.1925 2445000000000 +cpu,cpu=1 usage_idle=26.5583,usage_system=43.9811,usage_user=75.036 2446000000000 +cpu,cpu=2 usage_idle=26.7044,usage_system=2.14164,usage_user=11.6112 2447000000000 +cpu,cpu=3 usage_idle=98.9482,usage_system=58.3321,usage_user=21.7025 2448000000000 +cpu,cpu=4 usage_idle=49.2429,usage_system=4.04783,usage_user=96.2317 2449000000000 +cpu,cpu=0 usage_idle=71.2717,usage_system=63.1307,usage_user=23.3456 2450000000000 +cpu,cpu=1 usage_idle=20.2239,usage_system=90.7401,usage_user=90.6112 2451000000000 +cpu,cpu=2 usage_idle=51.1076,usage_system=77.0732,usage_user=62.8034 2452000000000 +cpu,cpu=3 usage_idle=15.9301,usage_system=51.5151,usage_user=78.0249 2453000000000 +cpu,cpu=4 usage_idle=84.0565,usage_system=39.2145,usage_user=36.1586 2454000000000 +cpu,cpu=0 usage_idle=55.3775,usage_system=57.6201,usage_user=78.7246 2455000000000 +cpu,cpu=1 usage_idle=17.57,usage_system=84.1784,usage_user=22.7057 2456000000000 +cpu,cpu=2 usage_idle=92.606,usage_system=10.8828,usage_user=24.8474 2457000000000 +cpu,cpu=3 usage_idle=4.21726,usage_system=9.83097,usage_user=83.1795 2458000000000 +cpu,cpu=4 usage_idle=25.9197,usage_system=59.0739,usage_user=87.2274 2459000000000 +cpu,cpu=0 usage_idle=22.1514,usage_system=30.3456,usage_user=50.3581 2460000000000 +cpu,cpu=1 usage_idle=45.497,usage_system=50.5694,usage_user=41.0981 2461000000000 +cpu,cpu=2 usage_idle=36.1082,usage_system=1.67703,usage_user=18.1714 2462000000000 +cpu,cpu=3 usage_idle=98.9116,usage_system=17.6071,usage_user=69.6865 2463000000000 +cpu,cpu=4 usage_idle=76.9364,usage_system=1.66367,usage_user=8.90097 2464000000000 +cpu,cpu=0 usage_idle=13.0951,usage_system=57.0412,usage_user=66.521 2465000000000 +cpu,cpu=1 usage_idle=91.8197,usage_system=74.6112,usage_user=50.6994 2466000000000 +cpu,cpu=2 usage_idle=14.5255,usage_system=67.2172,usage_user=61.5822 2467000000000 +cpu,cpu=3 usage_idle=39.3728,usage_system=71.4344,usage_user=71.4132 2468000000000 +cpu,cpu=4 usage_idle=22.5524,usage_system=97.3542,usage_user=30.487 2469000000000 +cpu,cpu=0 usage_idle=9.77975,usage_system=19.5055,usage_user=60.8326 2470000000000 +cpu,cpu=1 usage_idle=60.1378,usage_system=65.0026,usage_user=11.402 2471000000000 +cpu,cpu=2 usage_idle=1.23591,usage_system=1.11076,usage_user=13.0791 2472000000000 +cpu,cpu=3 usage_idle=19.4073,usage_system=0.0223212,usage_user=30.6862 2473000000000 +cpu,cpu=4 usage_idle=89.0937,usage_system=76.9587,usage_user=32.3499 2474000000000 +cpu,cpu=0 usage_idle=97.9947,usage_system=90.0538,usage_user=89.3911 2475000000000 +cpu,cpu=1 usage_idle=64.5157,usage_system=81.8735,usage_user=64.0022 2476000000000 +cpu,cpu=2 usage_idle=15.2152,usage_system=96.399,usage_user=31.2194 2477000000000 +cpu,cpu=3 usage_idle=76.7974,usage_system=35.7718,usage_user=2.65387 2478000000000 +cpu,cpu=4 usage_idle=48.2106,usage_system=58.3242,usage_user=0.00803829 2479000000000 +cpu,cpu=0 usage_idle=78.6976,usage_system=68.1039,usage_user=19.5136 2480000000000 +cpu,cpu=1 usage_idle=39.5302,usage_system=28.2417,usage_user=84.5161 2481000000000 +cpu,cpu=2 usage_idle=50.9322,usage_system=29.4776,usage_user=85.6269 2482000000000 +cpu,cpu=3 usage_idle=64.0113,usage_system=48.8849,usage_user=85.6492 2483000000000 +cpu,cpu=4 usage_idle=94.6975,usage_system=37.9786,usage_user=62.6079 2484000000000 +cpu,cpu=0 usage_idle=27.0474,usage_system=35.9733,usage_user=52.6617 2485000000000 +cpu,cpu=1 usage_idle=16.4385,usage_system=0.48907,usage_user=34.5352 2486000000000 +cpu,cpu=2 usage_idle=80.4407,usage_system=15.7042,usage_user=30.9342 2487000000000 +cpu,cpu=3 usage_idle=11.6601,usage_system=92.5016,usage_user=66.706 2488000000000 +cpu,cpu=4 usage_idle=14.314,usage_system=40.7122,usage_user=25.0302 2489000000000 +cpu,cpu=0 usage_idle=14.3221,usage_system=19.4097,usage_user=93.1341 2490000000000 +cpu,cpu=1 usage_idle=33.8356,usage_system=58.9399,usage_user=21.3759 2491000000000 +cpu,cpu=2 usage_idle=18.3518,usage_system=9.87217,usage_user=50.8535 2492000000000 +cpu,cpu=3 usage_idle=3.97864,usage_system=73.8835,usage_user=99.7384 2493000000000 +cpu,cpu=4 usage_idle=89.6278,usage_system=68.581,usage_user=37.717 2494000000000 +cpu,cpu=0 usage_idle=52.2358,usage_system=95.6284,usage_user=73.6904 2495000000000 +cpu,cpu=1 usage_idle=4.89752,usage_system=12.0669,usage_user=74.1794 2496000000000 +cpu,cpu=2 usage_idle=39.4328,usage_system=92.5076,usage_user=89.8837 2497000000000 +cpu,cpu=3 usage_idle=70.367,usage_system=4.16778,usage_user=82.3853 2498000000000 +cpu,cpu=4 usage_idle=37.073,usage_system=18.4818,usage_user=23.0974 2499000000000 +cpu,cpu=0 usage_idle=62.1032,usage_system=32.8038,usage_user=42.5072 2500000000000 +cpu,cpu=1 usage_idle=55.2373,usage_system=66.6395,usage_user=1.44709 2501000000000 +cpu,cpu=2 usage_idle=76.6132,usage_system=84.9912,usage_user=11.3193 2502000000000 +cpu,cpu=3 usage_idle=27.4667,usage_system=88.9699,usage_user=85.2028 2503000000000 +cpu,cpu=4 usage_idle=27.2051,usage_system=78.5977,usage_user=53.7838 2504000000000 +cpu,cpu=0 usage_idle=64.9221,usage_system=30.8335,usage_user=49.4122 2505000000000 +cpu,cpu=1 usage_idle=38.6125,usage_system=35.731,usage_user=61.4792 2506000000000 +cpu,cpu=2 usage_idle=12.7919,usage_system=75.1638,usage_user=53.9868 2507000000000 +cpu,cpu=3 usage_idle=2.6756,usage_system=45.5307,usage_user=58.1546 2508000000000 +cpu,cpu=4 usage_idle=85.0609,usage_system=82.6037,usage_user=76.6364 2509000000000 +cpu,cpu=0 usage_idle=8.15829,usage_system=44.7069,usage_user=9.44023 2510000000000 +cpu,cpu=1 usage_idle=50.6655,usage_system=99.9442,usage_user=76.0797 2511000000000 +cpu,cpu=2 usage_idle=52.1125,usage_system=76.5574,usage_user=61.0709 2512000000000 +cpu,cpu=3 usage_idle=63.4318,usage_system=4.02403,usage_user=50.0408 2513000000000 +cpu,cpu=4 usage_idle=48.6346,usage_system=31.2291,usage_user=28.6385 2514000000000 +cpu,cpu=0 usage_idle=2.41837,usage_system=96.1512,usage_user=59.472 2515000000000 +cpu,cpu=1 usage_idle=51.8306,usage_system=34.7637,usage_user=95.203 2516000000000 +cpu,cpu=2 usage_idle=13.3098,usage_system=47.5556,usage_user=70.3667 2517000000000 +cpu,cpu=3 usage_idle=67.2966,usage_system=50.2312,usage_user=15.8975 2518000000000 +cpu,cpu=4 usage_idle=25.4512,usage_system=35.2921,usage_user=98.5012 2519000000000 +cpu,cpu=0 usage_idle=2.08756,usage_system=43.4504,usage_user=43.2081 2520000000000 +cpu,cpu=1 usage_idle=11.5278,usage_system=94.1158,usage_user=43.1523 2521000000000 +cpu,cpu=2 usage_idle=87.6075,usage_system=46.2284,usage_user=19.7096 2522000000000 +cpu,cpu=3 usage_idle=48.6784,usage_system=9.66018,usage_user=23.7336 2523000000000 +cpu,cpu=4 usage_idle=98.7192,usage_system=58.2948,usage_user=54.9627 2524000000000 +cpu,cpu=0 usage_idle=27.3577,usage_system=60.7131,usage_user=51.114 2525000000000 +cpu,cpu=1 usage_idle=86.8297,usage_system=12.5437,usage_user=85.8777 2526000000000 +cpu,cpu=2 usage_idle=82.0326,usage_system=25.8535,usage_user=33.4333 2527000000000 +cpu,cpu=3 usage_idle=52.3994,usage_system=93.1501,usage_user=83.6645 2528000000000 +cpu,cpu=4 usage_idle=68.2968,usage_system=18.6013,usage_user=18.9566 2529000000000 +cpu,cpu=0 usage_idle=66.798,usage_system=20.6888,usage_user=62.407 2530000000000 +cpu,cpu=1 usage_idle=10.0061,usage_system=32.2166,usage_user=56.5228 2531000000000 +cpu,cpu=2 usage_idle=53.1583,usage_system=19.8241,usage_user=2.75116 2532000000000 +cpu,cpu=3 usage_idle=72.8679,usage_system=68.5025,usage_user=12.4113 2533000000000 +cpu,cpu=4 usage_idle=96.6016,usage_system=67.2217,usage_user=70.7061 2534000000000 +cpu,cpu=0 usage_idle=51.5643,usage_system=94.5794,usage_user=31.4192 2535000000000 +cpu,cpu=1 usage_idle=2.67825,usage_system=81.409,usage_user=43.9629 2536000000000 +cpu,cpu=2 usage_idle=88.5559,usage_system=63.4416,usage_user=69.8164 2537000000000 +cpu,cpu=3 usage_idle=21.9892,usage_system=15.841,usage_user=62.9665 2538000000000 +cpu,cpu=4 usage_idle=5.65368,usage_system=84.1378,usage_user=81.5678 2539000000000 +cpu,cpu=0 usage_idle=24.6103,usage_system=50.9358,usage_user=2.25663 2540000000000 +cpu,cpu=1 usage_idle=87.0172,usage_system=60.9419,usage_user=34.4732 2541000000000 +cpu,cpu=2 usage_idle=43.54,usage_system=14.1002,usage_user=54.2973 2542000000000 +cpu,cpu=3 usage_idle=46.2912,usage_system=86.9681,usage_user=22.7998 2543000000000 +cpu,cpu=4 usage_idle=58.7025,usage_system=83.5697,usage_user=90.0215 2544000000000 +cpu,cpu=0 usage_idle=29.4086,usage_system=35.134,usage_user=84.6009 2545000000000 +cpu,cpu=1 usage_idle=60.8278,usage_system=37.8122,usage_user=66.0099 2546000000000 +cpu,cpu=2 usage_idle=4.79073,usage_system=26.3682,usage_user=29.4515 2547000000000 +cpu,cpu=3 usage_idle=74.6072,usage_system=48.3573,usage_user=45.2926 2548000000000 +cpu,cpu=4 usage_idle=37.5737,usage_system=54.011,usage_user=29.4304 2549000000000 +cpu,cpu=0 usage_idle=19.1415,usage_system=78.6213,usage_user=80.3662 2550000000000 +cpu,cpu=1 usage_idle=21.3982,usage_system=65.6385,usage_user=41.3081 2551000000000 +cpu,cpu=2 usage_idle=55.8714,usage_system=9.17848,usage_user=55.4083 2552000000000 +cpu,cpu=3 usage_idle=10.1687,usage_system=55.4696,usage_user=42.3765 2553000000000 +cpu,cpu=4 usage_idle=32.9685,usage_system=14.1721,usage_user=25.9462 2554000000000 +cpu,cpu=0 usage_idle=22.99,usage_system=43.5807,usage_user=61.0801 2555000000000 +cpu,cpu=1 usage_idle=7.59093,usage_system=4.40851,usage_user=98.8924 2556000000000 +cpu,cpu=2 usage_idle=73.6008,usage_system=9.19923,usage_user=25.2606 2557000000000 +cpu,cpu=3 usage_idle=3.05237,usage_system=83.8064,usage_user=73.6179 2558000000000 +cpu,cpu=4 usage_idle=48.3449,usage_system=21.3801,usage_user=27.6289 2559000000000 +cpu,cpu=0 usage_idle=77.7753,usage_system=40.5217,usage_user=6.25016 2560000000000 +cpu,cpu=1 usage_idle=58.1415,usage_system=61.9198,usage_user=71.8886 2561000000000 +cpu,cpu=2 usage_idle=99.4496,usage_system=17.7912,usage_user=81.0671 2562000000000 +cpu,cpu=3 usage_idle=54.858,usage_system=27.9599,usage_user=36.5368 2563000000000 +cpu,cpu=4 usage_idle=97.2344,usage_system=60.9284,usage_user=50.7089 2564000000000 +cpu,cpu=0 usage_idle=23.1806,usage_system=83.9185,usage_user=94.2896 2565000000000 +cpu,cpu=1 usage_idle=84.2607,usage_system=91.5094,usage_user=98.6981 2566000000000 +cpu,cpu=2 usage_idle=83.1531,usage_system=65.1102,usage_user=7.89736 2567000000000 +cpu,cpu=3 usage_idle=8.41368,usage_system=68.1626,usage_user=91.7038 2568000000000 +cpu,cpu=4 usage_idle=82.0316,usage_system=16.5075,usage_user=13.0839 2569000000000 +cpu,cpu=0 usage_idle=9.66047,usage_system=94.2828,usage_user=53.6055 2570000000000 +cpu,cpu=1 usage_idle=15.9106,usage_system=52.4244,usage_user=15.5253 2571000000000 +cpu,cpu=2 usage_idle=87.7993,usage_system=51.874,usage_user=33.3165 2572000000000 +cpu,cpu=3 usage_idle=68.8664,usage_system=6.732,usage_user=61.2764 2573000000000 +cpu,cpu=4 usage_idle=5.40318,usage_system=3.96644,usage_user=22.2049 2574000000000 +cpu,cpu=0 usage_idle=56.1121,usage_system=27.147,usage_user=6.12336 2575000000000 +cpu,cpu=1 usage_idle=50.4017,usage_system=11.4078,usage_user=97.6328 2576000000000 +cpu,cpu=2 usage_idle=49.0998,usage_system=94.5609,usage_user=62.743 2577000000000 +cpu,cpu=3 usage_idle=56.9972,usage_system=2.97458,usage_user=30.9056 2578000000000 +cpu,cpu=4 usage_idle=48.7009,usage_system=85.0061,usage_user=47.4132 2579000000000 +cpu,cpu=0 usage_idle=61.7848,usage_system=94.6666,usage_user=41.696 2580000000000 +cpu,cpu=1 usage_idle=15.3904,usage_system=10.5772,usage_user=94.1204 2581000000000 +cpu,cpu=2 usage_idle=30.9157,usage_system=98.3765,usage_user=45.9944 2582000000000 +cpu,cpu=3 usage_idle=64.2323,usage_system=67.2429,usage_user=52.7264 2583000000000 +cpu,cpu=4 usage_idle=25.5087,usage_system=72.6461,usage_user=56.6928 2584000000000 +cpu,cpu=0 usage_idle=47.7136,usage_system=28.7582,usage_user=83.8399 2585000000000 +cpu,cpu=1 usage_idle=53.837,usage_system=79.1599,usage_user=95.2476 2586000000000 +cpu,cpu=2 usage_idle=51.4697,usage_system=28.2597,usage_user=89.8085 2587000000000 +cpu,cpu=3 usage_idle=14.2127,usage_system=85.2569,usage_user=92.7831 2588000000000 +cpu,cpu=4 usage_idle=45.1184,usage_system=33.9578,usage_user=77.7892 2589000000000 +cpu,cpu=0 usage_idle=92.5315,usage_system=95.7426,usage_user=72.4559 2590000000000 +cpu,cpu=1 usage_idle=34.2275,usage_system=11.133,usage_user=83.0331 2591000000000 +cpu,cpu=2 usage_idle=28.3479,usage_system=42.0488,usage_user=81.4096 2592000000000 +cpu,cpu=3 usage_idle=74.3423,usage_system=6.28103,usage_user=48.6525 2593000000000 +cpu,cpu=4 usage_idle=27.0687,usage_system=31.7897,usage_user=21.2986 2594000000000 +cpu,cpu=0 usage_idle=83.7615,usage_system=79.5033,usage_user=50.0568 2595000000000 +cpu,cpu=1 usage_idle=67.6014,usage_system=33.3403,usage_user=29.2167 2596000000000 +cpu,cpu=2 usage_idle=62.849,usage_system=84.81,usage_user=57.4764 2597000000000 +cpu,cpu=3 usage_idle=52.6576,usage_system=99.0228,usage_user=42.7332 2598000000000 +cpu,cpu=4 usage_idle=45.4406,usage_system=44.1411,usage_user=76.691 2599000000000 +cpu,cpu=0 usage_idle=23.2299,usage_system=36.6727,usage_user=72.4337 2600000000000 +cpu,cpu=1 usage_idle=95.6857,usage_system=70.9002,usage_user=83.5667 2601000000000 +cpu,cpu=2 usage_idle=78.7188,usage_system=99.2481,usage_user=25.6155 2602000000000 +cpu,cpu=3 usage_idle=60.1284,usage_system=73.5904,usage_user=31.8965 2603000000000 +cpu,cpu=4 usage_idle=8.78097,usage_system=0.659137,usage_user=63.6862 2604000000000 +cpu,cpu=0 usage_idle=30.0796,usage_system=84.4207,usage_user=43.1896 2605000000000 +cpu,cpu=1 usage_idle=80.1364,usage_system=52.0221,usage_user=76.5298 2606000000000 +cpu,cpu=2 usage_idle=9.35307,usage_system=14.8711,usage_user=61.3399 2607000000000 +cpu,cpu=3 usage_idle=66.8294,usage_system=67.5287,usage_user=60.3627 2608000000000 +cpu,cpu=4 usage_idle=9.56266,usage_system=12.9693,usage_user=4.5038 2609000000000 +cpu,cpu=0 usage_idle=86.2537,usage_system=36.1992,usage_user=41.1765 2610000000000 +cpu,cpu=1 usage_idle=58.6874,usage_system=31.8849,usage_user=12.0767 2611000000000 +cpu,cpu=2 usage_idle=42.2541,usage_system=10.6038,usage_user=11.3248 2612000000000 +cpu,cpu=3 usage_idle=67.8695,usage_system=70.7322,usage_user=84.9153 2613000000000 +cpu,cpu=4 usage_idle=99.766,usage_system=79.5132,usage_user=85.5744 2614000000000 +cpu,cpu=0 usage_idle=63.4522,usage_system=9.59277,usage_user=69.9951 2615000000000 +cpu,cpu=1 usage_idle=6.64177,usage_system=89.7292,usage_user=22.0172 2616000000000 +cpu,cpu=2 usage_idle=83.1716,usage_system=99.0822,usage_user=36.8883 2617000000000 +cpu,cpu=3 usage_idle=44.5115,usage_system=65.9117,usage_user=4.41693 2618000000000 +cpu,cpu=4 usage_idle=4.87414,usage_system=75.4743,usage_user=17.3862 2619000000000 +cpu,cpu=0 usage_idle=9.37795,usage_system=61.728,usage_user=53.5854 2620000000000 +cpu,cpu=1 usage_idle=50.5544,usage_system=20.4154,usage_user=85.4704 2621000000000 +cpu,cpu=2 usage_idle=62.6311,usage_system=62.6694,usage_user=96.0741 2622000000000 +cpu,cpu=3 usage_idle=73.956,usage_system=30.539,usage_user=66.8063 2623000000000 +cpu,cpu=4 usage_idle=58.8712,usage_system=30.3049,usage_user=46.3195 2624000000000 +cpu,cpu=0 usage_idle=44.4456,usage_system=93.7572,usage_user=55.9123 2625000000000 +cpu,cpu=1 usage_idle=14.4407,usage_system=0.398931,usage_user=45.6414 2626000000000 +cpu,cpu=2 usage_idle=36.4578,usage_system=83.5705,usage_user=44.7237 2627000000000 +cpu,cpu=3 usage_idle=73.3461,usage_system=28.082,usage_user=10.6354 2628000000000 +cpu,cpu=4 usage_idle=77.763,usage_system=32.9562,usage_user=86.1097 2629000000000 +cpu,cpu=0 usage_idle=95.1493,usage_system=42.3341,usage_user=47.8377 2630000000000 +cpu,cpu=1 usage_idle=48.7347,usage_system=92.8886,usage_user=68.2531 2631000000000 +cpu,cpu=2 usage_idle=34.2051,usage_system=55.5197,usage_user=30.9226 2632000000000 +cpu,cpu=3 usage_idle=30.2792,usage_system=29.4756,usage_user=61.4615 2633000000000 +cpu,cpu=4 usage_idle=97.0855,usage_system=88.3469,usage_user=91.7665 2634000000000 +cpu,cpu=0 usage_idle=43.4051,usage_system=32.7925,usage_user=85.5236 2635000000000 +cpu,cpu=1 usage_idle=99.3173,usage_system=47.2332,usage_user=85.9225 2636000000000 +cpu,cpu=2 usage_idle=44.9588,usage_system=83.691,usage_user=69.4931 2637000000000 +cpu,cpu=3 usage_idle=89.6824,usage_system=57.0371,usage_user=97.5751 2638000000000 +cpu,cpu=4 usage_idle=0.317807,usage_system=34.8002,usage_user=30.5313 2639000000000 +cpu,cpu=0 usage_idle=86.4275,usage_system=29.9494,usage_user=72.8655 2640000000000 +cpu,cpu=1 usage_idle=34.2652,usage_system=78.6841,usage_user=65.754 2641000000000 +cpu,cpu=2 usage_idle=2.51834,usage_system=12.8892,usage_user=21.2737 2642000000000 +cpu,cpu=3 usage_idle=33.4409,usage_system=43.1684,usage_user=50.7493 2643000000000 +cpu,cpu=4 usage_idle=94.9024,usage_system=40.254,usage_user=39.0962 2644000000000 +cpu,cpu=0 usage_idle=86.6688,usage_system=83.659,usage_user=71.8887 2645000000000 +cpu,cpu=1 usage_idle=72.1925,usage_system=82.9763,usage_user=19.1218 2646000000000 +cpu,cpu=2 usage_idle=58.115,usage_system=27.9351,usage_user=2.81286 2647000000000 +cpu,cpu=3 usage_idle=27.6081,usage_system=17.6175,usage_user=59.85 2648000000000 +cpu,cpu=4 usage_idle=25.1832,usage_system=17.9354,usage_user=94.6501 2649000000000 +cpu,cpu=0 usage_idle=55.7146,usage_system=4.36286,usage_user=24.5996 2650000000000 +cpu,cpu=1 usage_idle=28.58,usage_system=38.6281,usage_user=3.2837 2651000000000 +cpu,cpu=2 usage_idle=94.334,usage_system=41.1464,usage_user=16.1729 2652000000000 +cpu,cpu=3 usage_idle=15.6077,usage_system=74.5873,usage_user=59.3413 2653000000000 +cpu,cpu=4 usage_idle=66.3571,usage_system=69.4897,usage_user=99.5953 2654000000000 +cpu,cpu=0 usage_idle=5.45327,usage_system=56.1585,usage_user=83.2543 2655000000000 +cpu,cpu=1 usage_idle=77.342,usage_system=28.351,usage_user=66.2306 2656000000000 +cpu,cpu=2 usage_idle=96.4638,usage_system=86.466,usage_user=94.1657 2657000000000 +cpu,cpu=3 usage_idle=99.2767,usage_system=14.0741,usage_user=11.7833 2658000000000 +cpu,cpu=4 usage_idle=59.1266,usage_system=39.2574,usage_user=29.7186 2659000000000 +cpu,cpu=0 usage_idle=53.7768,usage_system=94.9719,usage_user=34.0815 2660000000000 +cpu,cpu=1 usage_idle=78.3763,usage_system=23.552,usage_user=72.7095 2661000000000 +cpu,cpu=2 usage_idle=81.66,usage_system=17.886,usage_user=13.856 2662000000000 +cpu,cpu=3 usage_idle=97.833,usage_system=33.4937,usage_user=88.4433 2663000000000 +cpu,cpu=4 usage_idle=57.1743,usage_system=99.8508,usage_user=57.933 2664000000000 +cpu,cpu=0 usage_idle=56.7696,usage_system=5.30405,usage_user=14.0915 2665000000000 +cpu,cpu=1 usage_idle=40.0239,usage_system=82.646,usage_user=42.4425 2666000000000 +cpu,cpu=2 usage_idle=6.25448,usage_system=79.1098,usage_user=28.9086 2667000000000 +cpu,cpu=3 usage_idle=0.420194,usage_system=78.3865,usage_user=42.9827 2668000000000 +cpu,cpu=4 usage_idle=12.2035,usage_system=37.5131,usage_user=82.2401 2669000000000 +cpu,cpu=0 usage_idle=41.9221,usage_system=91.2899,usage_user=77.212 2670000000000 +cpu,cpu=1 usage_idle=76.0035,usage_system=69.6662,usage_user=0.764006 2671000000000 +cpu,cpu=2 usage_idle=48.7131,usage_system=51.3263,usage_user=18.65 2672000000000 +cpu,cpu=3 usage_idle=62.569,usage_system=49.1592,usage_user=52.1437 2673000000000 +cpu,cpu=4 usage_idle=51.0123,usage_system=6.33352,usage_user=51.9945 2674000000000 +cpu,cpu=0 usage_idle=8.94529,usage_system=63.1031,usage_user=57.2985 2675000000000 +cpu,cpu=1 usage_idle=23.0368,usage_system=3.12695,usage_user=39.9446 2676000000000 +cpu,cpu=2 usage_idle=65.4794,usage_system=9.38142,usage_user=19.0544 2677000000000 +cpu,cpu=3 usage_idle=94.3879,usage_system=9.80162,usage_user=97.4408 2678000000000 +cpu,cpu=4 usage_idle=37.3706,usage_system=22.0051,usage_user=34.9539 2679000000000 +cpu,cpu=0 usage_idle=19.6107,usage_system=63.9271,usage_user=26.2438 2680000000000 +cpu,cpu=1 usage_idle=96.8228,usage_system=39.9307,usage_user=95.9101 2681000000000 +cpu,cpu=2 usage_idle=97.5868,usage_system=88.6438,usage_user=47.2363 2682000000000 +cpu,cpu=3 usage_idle=16.2368,usage_system=51.2128,usage_user=96.3956 2683000000000 +cpu,cpu=4 usage_idle=68.3805,usage_system=2.22512,usage_user=2.7291 2684000000000 +cpu,cpu=0 usage_idle=20.375,usage_system=11.1704,usage_user=65.8322 2685000000000 +cpu,cpu=1 usage_idle=77.6735,usage_system=34.2072,usage_user=68.9591 2686000000000 +cpu,cpu=2 usage_idle=17.6181,usage_system=99.6866,usage_user=78.3406 2687000000000 +cpu,cpu=3 usage_idle=36.6724,usage_system=94.0745,usage_user=88.1422 2688000000000 +cpu,cpu=4 usage_idle=34.1133,usage_system=31.4451,usage_user=10.1472 2689000000000 +cpu,cpu=0 usage_idle=69.0672,usage_system=51.0559,usage_user=74.0744 2690000000000 +cpu,cpu=1 usage_idle=95.311,usage_system=47.8786,usage_user=14.0051 2691000000000 +cpu,cpu=2 usage_idle=91.2211,usage_system=45.4654,usage_user=2.64881 2692000000000 +cpu,cpu=3 usage_idle=38.4574,usage_system=61.7021,usage_user=53.8616 2693000000000 +cpu,cpu=4 usage_idle=34.853,usage_system=30.0826,usage_user=56.0867 2694000000000 +cpu,cpu=0 usage_idle=37.5821,usage_system=50.4576,usage_user=67.2571 2695000000000 +cpu,cpu=1 usage_idle=3.41431,usage_system=28.1311,usage_user=1.46438 2696000000000 +cpu,cpu=2 usage_idle=72.3734,usage_system=45.7491,usage_user=1.15097 2697000000000 +cpu,cpu=3 usage_idle=50.714,usage_system=82.4216,usage_user=95.2255 2698000000000 +cpu,cpu=4 usage_idle=38.8562,usage_system=16.5348,usage_user=26.6706 2699000000000 +cpu,cpu=0 usage_idle=49.0034,usage_system=85.602,usage_user=77.7265 2700000000000 +cpu,cpu=1 usage_idle=23.0778,usage_system=80.913,usage_user=25.6051 2701000000000 +cpu,cpu=2 usage_idle=37.0829,usage_system=72.1341,usage_user=71.0705 2702000000000 +cpu,cpu=3 usage_idle=39.7317,usage_system=10.5916,usage_user=32.7726 2703000000000 +cpu,cpu=4 usage_idle=93.5933,usage_system=45.4446,usage_user=62.8552 2704000000000 +cpu,cpu=0 usage_idle=49.68,usage_system=83.0267,usage_user=13.3128 2705000000000 +cpu,cpu=1 usage_idle=16.9372,usage_system=86.441,usage_user=41.4439 2706000000000 +cpu,cpu=2 usage_idle=18.4015,usage_system=58.8145,usage_user=87.1931 2707000000000 +cpu,cpu=3 usage_idle=19.5525,usage_system=9.52848,usage_user=69.6146 2708000000000 +cpu,cpu=4 usage_idle=14.778,usage_system=48.3847,usage_user=86.1494 2709000000000 +cpu,cpu=0 usage_idle=41.4486,usage_system=97.3881,usage_user=71.7514 2710000000000 +cpu,cpu=1 usage_idle=19.1751,usage_system=20.4659,usage_user=52.6645 2711000000000 +cpu,cpu=2 usage_idle=44.7802,usage_system=57.5488,usage_user=24.7986 2712000000000 +cpu,cpu=3 usage_idle=15.8507,usage_system=97.2805,usage_user=35.3902 2713000000000 +cpu,cpu=4 usage_idle=48.6233,usage_system=90.8738,usage_user=80.8348 2714000000000 +cpu,cpu=0 usage_idle=11.4786,usage_system=40.5538,usage_user=63.8615 2715000000000 +cpu,cpu=1 usage_idle=24.7914,usage_system=57.491,usage_user=50.3025 2716000000000 +cpu,cpu=2 usage_idle=66.2353,usage_system=75.8925,usage_user=9.11701 2717000000000 +cpu,cpu=3 usage_idle=53.4283,usage_system=95.445,usage_user=18.6455 2718000000000 +cpu,cpu=4 usage_idle=23.043,usage_system=10.223,usage_user=67.0302 2719000000000 +cpu,cpu=0 usage_idle=9.1924,usage_system=51.6717,usage_user=64.4183 2720000000000 +cpu,cpu=1 usage_idle=80.9439,usage_system=70.8468,usage_user=84.8842 2721000000000 +cpu,cpu=2 usage_idle=33.6083,usage_system=15.627,usage_user=42.433 2722000000000 +cpu,cpu=3 usage_idle=58.407,usage_system=31.4777,usage_user=39.7135 2723000000000 +cpu,cpu=4 usage_idle=93.7972,usage_system=80.101,usage_user=30.5873 2724000000000 +cpu,cpu=0 usage_idle=74.632,usage_system=91.5795,usage_user=71.1411 2725000000000 +cpu,cpu=1 usage_idle=38.4935,usage_system=16.3709,usage_user=28.632 2726000000000 +cpu,cpu=2 usage_idle=88.796,usage_system=82.6062,usage_user=4.52454 2727000000000 +cpu,cpu=3 usage_idle=97.913,usage_system=36.0346,usage_user=99.9696 2728000000000 +cpu,cpu=4 usage_idle=16.5585,usage_system=59.0775,usage_user=10.1926 2729000000000 +cpu,cpu=0 usage_idle=83.5887,usage_system=68.2699,usage_user=61.8643 2730000000000 +cpu,cpu=1 usage_idle=48.007,usage_system=49.2138,usage_user=32.711 2731000000000 +cpu,cpu=2 usage_idle=32.8912,usage_system=82.8221,usage_user=48.338 2732000000000 +cpu,cpu=3 usage_idle=75.3242,usage_system=41.2291,usage_user=79.8157 2733000000000 +cpu,cpu=4 usage_idle=15.0377,usage_system=35.0263,usage_user=59.9167 2734000000000 +cpu,cpu=0 usage_idle=45.625,usage_system=9.65826,usage_user=51.4962 2735000000000 +cpu,cpu=1 usage_idle=16.766,usage_system=48.1518,usage_user=67.8672 2736000000000 +cpu,cpu=2 usage_idle=45.3981,usage_system=36.9478,usage_user=50.4734 2737000000000 +cpu,cpu=3 usage_idle=49.9226,usage_system=34.8608,usage_user=86.508 2738000000000 +cpu,cpu=4 usage_idle=49.8922,usage_system=51.4194,usage_user=45.5855 2739000000000 +cpu,cpu=0 usage_idle=60.0848,usage_system=35.0081,usage_user=13.8554 2740000000000 +cpu,cpu=1 usage_idle=21.9491,usage_system=83.015,usage_user=63.0692 2741000000000 +cpu,cpu=2 usage_idle=54.6601,usage_system=15.9062,usage_user=45.8913 2742000000000 +cpu,cpu=3 usage_idle=2.99815,usage_system=91.2304,usage_user=87.1205 2743000000000 +cpu,cpu=4 usage_idle=82.8139,usage_system=6.26813,usage_user=22.1467 2744000000000 +cpu,cpu=0 usage_idle=42.7305,usage_system=51.8931,usage_user=31.805 2745000000000 +cpu,cpu=1 usage_idle=94.2268,usage_system=68.6591,usage_user=79.9568 2746000000000 +cpu,cpu=2 usage_idle=62.094,usage_system=14.0572,usage_user=16.9045 2747000000000 +cpu,cpu=3 usage_idle=12.5673,usage_system=63.9798,usage_user=51.7654 2748000000000 +cpu,cpu=4 usage_idle=99.0753,usage_system=13.872,usage_user=3.18471 2749000000000 +cpu,cpu=0 usage_idle=44.6608,usage_system=73.9568,usage_user=38.1928 2750000000000 +cpu,cpu=1 usage_idle=58.5162,usage_system=95.9058,usage_user=21.2078 2751000000000 +cpu,cpu=2 usage_idle=21.5854,usage_system=50.566,usage_user=37.114 2752000000000 +cpu,cpu=3 usage_idle=67.4768,usage_system=53.5641,usage_user=28.3445 2753000000000 +cpu,cpu=4 usage_idle=54.5972,usage_system=36.378,usage_user=34.6126 2754000000000 +cpu,cpu=0 usage_idle=76.744,usage_system=79.1085,usage_user=86.5057 2755000000000 +cpu,cpu=1 usage_idle=8.54896,usage_system=73.3353,usage_user=55.1648 2756000000000 +cpu,cpu=2 usage_idle=88.5057,usage_system=35.4292,usage_user=69.222 2757000000000 +cpu,cpu=3 usage_idle=5.41025,usage_system=47.9966,usage_user=33.2018 2758000000000 +cpu,cpu=4 usage_idle=57.1756,usage_system=47.0719,usage_user=47.0738 2759000000000 +cpu,cpu=0 usage_idle=60.3603,usage_system=91.7327,usage_user=21.0306 2760000000000 +cpu,cpu=1 usage_idle=98.5531,usage_system=50.2489,usage_user=16.9365 2761000000000 +cpu,cpu=2 usage_idle=19.7609,usage_system=71.8343,usage_user=67.5024 2762000000000 +cpu,cpu=3 usage_idle=56.8749,usage_system=39.3111,usage_user=21.0665 2763000000000 +cpu,cpu=4 usage_idle=85.2194,usage_system=93.9083,usage_user=57.4445 2764000000000 +cpu,cpu=0 usage_idle=19.832,usage_system=70.6523,usage_user=36.553 2765000000000 +cpu,cpu=1 usage_idle=6.33767,usage_system=79.2012,usage_user=9.88831 2766000000000 +cpu,cpu=2 usage_idle=61.5025,usage_system=67.7069,usage_user=45.3176 2767000000000 +cpu,cpu=3 usage_idle=30.7245,usage_system=73.1172,usage_user=93.3141 2768000000000 +cpu,cpu=4 usage_idle=63.9264,usage_system=30.2928,usage_user=40.386 2769000000000 +cpu,cpu=0 usage_idle=11.0002,usage_system=90.6531,usage_user=32.1187 2770000000000 +cpu,cpu=1 usage_idle=32.0308,usage_system=89.2062,usage_user=82.3676 2771000000000 +cpu,cpu=2 usage_idle=48.9673,usage_system=8.96708,usage_user=54.2019 2772000000000 +cpu,cpu=3 usage_idle=16.4697,usage_system=65.842,usage_user=93.513 2773000000000 +cpu,cpu=4 usage_idle=37.5362,usage_system=51.0614,usage_user=87.4213 2774000000000 +cpu,cpu=0 usage_idle=94.9807,usage_system=70.8934,usage_user=58.0735 2775000000000 +cpu,cpu=1 usage_idle=31.5337,usage_system=77.2311,usage_user=37.2748 2776000000000 +cpu,cpu=2 usage_idle=41.4221,usage_system=38.7336,usage_user=4.9817 2777000000000 +cpu,cpu=3 usage_idle=86.7396,usage_system=69.4581,usage_user=78.0989 2778000000000 +cpu,cpu=4 usage_idle=80.0538,usage_system=33.3844,usage_user=8.39169 2779000000000 +cpu,cpu=0 usage_idle=20.4398,usage_system=44.3846,usage_user=99.0448 2780000000000 +cpu,cpu=1 usage_idle=52.5585,usage_system=76.4155,usage_user=88.251 2781000000000 +cpu,cpu=2 usage_idle=34.9261,usage_system=25.3827,usage_user=97.2181 2782000000000 +cpu,cpu=3 usage_idle=89.128,usage_system=41.8524,usage_user=63.0601 2783000000000 +cpu,cpu=4 usage_idle=82.6409,usage_system=79.3887,usage_user=14.1215 2784000000000 +cpu,cpu=0 usage_idle=70.0622,usage_system=74.3694,usage_user=85.0149 2785000000000 +cpu,cpu=1 usage_idle=28.1357,usage_system=5.90315,usage_user=62.2459 2786000000000 +cpu,cpu=2 usage_idle=65.4105,usage_system=47.3252,usage_user=0.979468 2787000000000 +cpu,cpu=3 usage_idle=70.3922,usage_system=34.0648,usage_user=70.4375 2788000000000 +cpu,cpu=4 usage_idle=48.491,usage_system=14.1186,usage_user=3.822 2789000000000 +cpu,cpu=0 usage_idle=56.8827,usage_system=34.5583,usage_user=48.2066 2790000000000 +cpu,cpu=1 usage_idle=55.9275,usage_system=87.1168,usage_user=24.6221 2791000000000 +cpu,cpu=2 usage_idle=44.1785,usage_system=22.0429,usage_user=50.0048 2792000000000 +cpu,cpu=3 usage_idle=41.3966,usage_system=11.1709,usage_user=91.8573 2793000000000 +cpu,cpu=4 usage_idle=4.45671,usage_system=93.8118,usage_user=71.2459 2794000000000 +cpu,cpu=0 usage_idle=18.5782,usage_system=63.874,usage_user=45.6153 2795000000000 +cpu,cpu=1 usage_idle=3.59305,usage_system=92.0097,usage_user=51.5185 2796000000000 +cpu,cpu=2 usage_idle=65.839,usage_system=57.4201,usage_user=98.8437 2797000000000 +cpu,cpu=3 usage_idle=66.8184,usage_system=27.8123,usage_user=32.9085 2798000000000 +cpu,cpu=4 usage_idle=37.256,usage_system=76.3033,usage_user=47.027 2799000000000 +cpu,cpu=0 usage_idle=41.078,usage_system=33.1861,usage_user=81.5854 2800000000000 +cpu,cpu=1 usage_idle=89.2846,usage_system=89.1136,usage_user=68.7022 2801000000000 +cpu,cpu=2 usage_idle=13.9067,usage_system=33.2921,usage_user=90.7451 2802000000000 +cpu,cpu=3 usage_idle=63.9115,usage_system=74.6888,usage_user=1.91599 2803000000000 +cpu,cpu=4 usage_idle=55.7688,usage_system=79.1455,usage_user=95.7278 2804000000000 +cpu,cpu=0 usage_idle=27.0147,usage_system=97.7236,usage_user=59.6017 2805000000000 +cpu,cpu=1 usage_idle=72.6301,usage_system=1.3167,usage_user=51.6114 2806000000000 +cpu,cpu=2 usage_idle=24.1485,usage_system=67.1557,usage_user=9.03151 2807000000000 +cpu,cpu=3 usage_idle=22.9922,usage_system=33.9741,usage_user=36.8438 2808000000000 +cpu,cpu=4 usage_idle=55.9007,usage_system=71.2301,usage_user=13.1471 2809000000000 +cpu,cpu=0 usage_idle=2.92774,usage_system=12.308,usage_user=46.3332 2810000000000 +cpu,cpu=1 usage_idle=84.5131,usage_system=1.59267,usage_user=35.4467 2811000000000 +cpu,cpu=2 usage_idle=53.2154,usage_system=15.4994,usage_user=68.7389 2812000000000 +cpu,cpu=3 usage_idle=43.9605,usage_system=79.4109,usage_user=43.4276 2813000000000 +cpu,cpu=4 usage_idle=45.8765,usage_system=35.1797,usage_user=22.5731 2814000000000 +cpu,cpu=0 usage_idle=41.6042,usage_system=62.1945,usage_user=20.2968 2815000000000 +cpu,cpu=1 usage_idle=1.20595,usage_system=34.8245,usage_user=21.6134 2816000000000 +cpu,cpu=2 usage_idle=52.8173,usage_system=58.9731,usage_user=88.7691 2817000000000 +cpu,cpu=3 usage_idle=61.8489,usage_system=81.9653,usage_user=22.7432 2818000000000 +cpu,cpu=4 usage_idle=98.6926,usage_system=37.866,usage_user=93.9733 2819000000000 +cpu,cpu=0 usage_idle=11.8397,usage_system=40.7937,usage_user=6.28131 2820000000000 +cpu,cpu=1 usage_idle=58.1729,usage_system=25.3068,usage_user=7.87398 2821000000000 +cpu,cpu=2 usage_idle=93.6196,usage_system=78.5222,usage_user=23.3734 2822000000000 +cpu,cpu=3 usage_idle=62.3585,usage_system=22.4827,usage_user=2.7843 2823000000000 +cpu,cpu=4 usage_idle=5.78614,usage_system=68.3591,usage_user=37.964 2824000000000 +cpu,cpu=0 usage_idle=28.3592,usage_system=9.96335,usage_user=0.158508 2825000000000 +cpu,cpu=1 usage_idle=48.656,usage_system=11.1693,usage_user=34.983 2826000000000 +cpu,cpu=2 usage_idle=70.2694,usage_system=63.9866,usage_user=93.9561 2827000000000 +cpu,cpu=3 usage_idle=59.0385,usage_system=25.8355,usage_user=75.9214 2828000000000 +cpu,cpu=4 usage_idle=81.7817,usage_system=24.5281,usage_user=13.7873 2829000000000 +cpu,cpu=0 usage_idle=75.755,usage_system=36.3679,usage_user=54.581 2830000000000 +cpu,cpu=1 usage_idle=82.0363,usage_system=94.5407,usage_user=79.8878 2831000000000 +cpu,cpu=2 usage_idle=89.9103,usage_system=88.1604,usage_user=58.41 2832000000000 +cpu,cpu=3 usage_idle=13.2837,usage_system=50.5189,usage_user=80.8926 2833000000000 +cpu,cpu=4 usage_idle=16.068,usage_system=56.305,usage_user=49.2518 2834000000000 +cpu,cpu=0 usage_idle=54.032,usage_system=84.6643,usage_user=59.2151 2835000000000 +cpu,cpu=1 usage_idle=54.1905,usage_system=33.3202,usage_user=70.3844 2836000000000 +cpu,cpu=2 usage_idle=89.1735,usage_system=3.58969,usage_user=34.3711 2837000000000 +cpu,cpu=3 usage_idle=83.1296,usage_system=62.6282,usage_user=60.2065 2838000000000 +cpu,cpu=4 usage_idle=59.051,usage_system=44.41,usage_user=84.7347 2839000000000 +cpu,cpu=0 usage_idle=72.8383,usage_system=20.165,usage_user=21.1025 2840000000000 +cpu,cpu=1 usage_idle=27.4193,usage_system=2.20132,usage_user=15.6433 2841000000000 +cpu,cpu=2 usage_idle=7.30712,usage_system=92.1116,usage_user=3.80362 2842000000000 +cpu,cpu=3 usage_idle=65.7171,usage_system=5.39527,usage_user=54.3225 2843000000000 +cpu,cpu=4 usage_idle=46.6098,usage_system=21.4632,usage_user=10.6275 2844000000000 +cpu,cpu=0 usage_idle=95.8615,usage_system=75.4952,usage_user=95.2918 2845000000000 +cpu,cpu=1 usage_idle=55.0766,usage_system=29.6857,usage_user=28.612 2846000000000 +cpu,cpu=2 usage_idle=25.4611,usage_system=18.8593,usage_user=32.2017 2847000000000 +cpu,cpu=3 usage_idle=59.8321,usage_system=1.98888,usage_user=94.8299 2848000000000 +cpu,cpu=4 usage_idle=20.0387,usage_system=61.0399,usage_user=39.2399 2849000000000 +cpu,cpu=0 usage_idle=4.77334,usage_system=33.8782,usage_user=59.4049 2850000000000 +cpu,cpu=1 usage_idle=25.8759,usage_system=61.2974,usage_user=61.6062 2851000000000 +cpu,cpu=2 usage_idle=41.5191,usage_system=68.6046,usage_user=53.7178 2852000000000 +cpu,cpu=3 usage_idle=45.3228,usage_system=34.3217,usage_user=59.1131 2853000000000 +cpu,cpu=4 usage_idle=99.6452,usage_system=80.9315,usage_user=80.5763 2854000000000 +cpu,cpu=0 usage_idle=10.2727,usage_system=76.793,usage_user=56.0716 2855000000000 +cpu,cpu=1 usage_idle=5.5645,usage_system=31.8696,usage_user=85.7573 2856000000000 +cpu,cpu=2 usage_idle=34.1765,usage_system=57.3307,usage_user=4.61652 2857000000000 +cpu,cpu=3 usage_idle=66.3782,usage_system=17.1628,usage_user=6.6054 2858000000000 +cpu,cpu=4 usage_idle=61.2081,usage_system=37.2015,usage_user=67.6453 2859000000000 +cpu,cpu=0 usage_idle=0.44803,usage_system=41.9748,usage_user=1.52341 2860000000000 +cpu,cpu=1 usage_idle=59.8529,usage_system=67.8507,usage_user=62.8209 2861000000000 +cpu,cpu=2 usage_idle=21.4592,usage_system=9.36982,usage_user=31.4254 2862000000000 +cpu,cpu=3 usage_idle=75.177,usage_system=54.6926,usage_user=65.7471 2863000000000 +cpu,cpu=4 usage_idle=34.2901,usage_system=54.3378,usage_user=46.6786 2864000000000 +cpu,cpu=0 usage_idle=14.8664,usage_system=64.6106,usage_user=23.4716 2865000000000 +cpu,cpu=1 usage_idle=70.938,usage_system=70.1751,usage_user=55.3412 2866000000000 +cpu,cpu=2 usage_idle=56.6953,usage_system=4.35155,usage_user=12.6719 2867000000000 +cpu,cpu=3 usage_idle=61.3118,usage_system=70.7297,usage_user=29.8347 2868000000000 +cpu,cpu=4 usage_idle=67.9172,usage_system=31.9379,usage_user=67.0362 2869000000000 +cpu,cpu=0 usage_idle=35.5624,usage_system=32.3859,usage_user=9.01099 2870000000000 +cpu,cpu=1 usage_idle=37.0858,usage_system=92.2388,usage_user=76.8617 2871000000000 +cpu,cpu=2 usage_idle=99.9067,usage_system=13.698,usage_user=86.2315 2872000000000 +cpu,cpu=3 usage_idle=31.3321,usage_system=88.875,usage_user=40.9241 2873000000000 +cpu,cpu=4 usage_idle=97.0792,usage_system=23.1651,usage_user=95.2619 2874000000000 +cpu,cpu=0 usage_idle=43.7578,usage_system=38.0315,usage_user=59.8724 2875000000000 +cpu,cpu=1 usage_idle=67.2293,usage_system=8.96951,usage_user=30.0475 2876000000000 +cpu,cpu=2 usage_idle=22.5705,usage_system=65.6648,usage_user=34.399 2877000000000 +cpu,cpu=3 usage_idle=35.2424,usage_system=26.9765,usage_user=5.12878 2878000000000 +cpu,cpu=4 usage_idle=65.0771,usage_system=94.8937,usage_user=37.0666 2879000000000 +cpu,cpu=0 usage_idle=32.1133,usage_system=30.4561,usage_user=69.4525 2880000000000 +cpu,cpu=1 usage_idle=41.1243,usage_system=67.542,usage_user=61.6914 2881000000000 +cpu,cpu=2 usage_idle=17.986,usage_system=67.4486,usage_user=75.3893 2882000000000 +cpu,cpu=3 usage_idle=4.21745,usage_system=98.7808,usage_user=64.2643 2883000000000 +cpu,cpu=4 usage_idle=45.1415,usage_system=95.86,usage_user=87.4294 2884000000000 +cpu,cpu=0 usage_idle=40.4034,usage_system=39.6178,usage_user=25.4609 2885000000000 +cpu,cpu=1 usage_idle=0.275822,usage_system=6.84713,usage_user=34.4305 2886000000000 +cpu,cpu=2 usage_idle=30.3233,usage_system=29.4177,usage_user=0.0952164 2887000000000 +cpu,cpu=3 usage_idle=64.7224,usage_system=64.6601,usage_user=27.0718 2888000000000 +cpu,cpu=4 usage_idle=69.8511,usage_system=29.7372,usage_user=21.9655 2889000000000 +cpu,cpu=0 usage_idle=6.91778,usage_system=61.8505,usage_user=52.4216 2890000000000 +cpu,cpu=1 usage_idle=76.3703,usage_system=2.97474,usage_user=19.9635 2891000000000 +cpu,cpu=2 usage_idle=38.0617,usage_system=20.9607,usage_user=87.4122 2892000000000 +cpu,cpu=3 usage_idle=13.451,usage_system=25.1781,usage_user=86.193 2893000000000 +cpu,cpu=4 usage_idle=77.7153,usage_system=70.3197,usage_user=82.0529 2894000000000 +cpu,cpu=0 usage_idle=65.1448,usage_system=10.723,usage_user=21.6707 2895000000000 +cpu,cpu=1 usage_idle=90.6057,usage_system=10.9989,usage_user=28.5179 2896000000000 +cpu,cpu=2 usage_idle=25.0362,usage_system=41.3222,usage_user=57.9355 2897000000000 +cpu,cpu=3 usage_idle=25.1314,usage_system=6.04453,usage_user=22.5956 2898000000000 +cpu,cpu=4 usage_idle=52.2031,usage_system=75.8957,usage_user=52.3328 2899000000000 +cpu,cpu=0 usage_idle=74.1686,usage_system=82.8134,usage_user=14.1832 2900000000000 +cpu,cpu=1 usage_idle=26.5902,usage_system=59.1838,usage_user=17.158 2901000000000 +cpu,cpu=2 usage_idle=46.5537,usage_system=97.2454,usage_user=38.1187 2902000000000 +cpu,cpu=3 usage_idle=33.9659,usage_system=10.6964,usage_user=63.2968 2903000000000 +cpu,cpu=4 usage_idle=20.1589,usage_system=88.4118,usage_user=33.6165 2904000000000 +cpu,cpu=0 usage_idle=2.21182,usage_system=53.5565,usage_user=44.3395 2905000000000 +cpu,cpu=1 usage_idle=23.8825,usage_system=44.1622,usage_user=55.3384 2906000000000 +cpu,cpu=2 usage_idle=52.4004,usage_system=69.1984,usage_user=96.6605 2907000000000 +cpu,cpu=3 usage_idle=10.3359,usage_system=94.3298,usage_user=2.70507 2908000000000 +cpu,cpu=4 usage_idle=32.9315,usage_system=46.5329,usage_user=78.6007 2909000000000 +cpu,cpu=0 usage_idle=85.2643,usage_system=20.7015,usage_user=61.4142 2910000000000 +cpu,cpu=1 usage_idle=99.4475,usage_system=47.2916,usage_user=20.5979 2911000000000 +cpu,cpu=2 usage_idle=16.6055,usage_system=93.8453,usage_user=17.8434 2912000000000 +cpu,cpu=3 usage_idle=54.7242,usage_system=27.8112,usage_user=28.5398 2913000000000 +cpu,cpu=4 usage_idle=18.021,usage_system=47.9701,usage_user=16.9516 2914000000000 +cpu,cpu=0 usage_idle=51.6374,usage_system=50.1819,usage_user=70.5081 2915000000000 +cpu,cpu=1 usage_idle=95.9769,usage_system=74.0645,usage_user=14.6703 2916000000000 +cpu,cpu=2 usage_idle=51.3153,usage_system=26.4649,usage_user=83.8687 2917000000000 +cpu,cpu=3 usage_idle=47.9759,usage_system=36.8008,usage_user=78.1985 2918000000000 +cpu,cpu=4 usage_idle=50.6809,usage_system=69.7323,usage_user=24.7313 2919000000000 +cpu,cpu=0 usage_idle=29.2817,usage_system=54.9966,usage_user=45.4328 2920000000000 +cpu,cpu=1 usage_idle=90.6958,usage_system=54.4441,usage_user=92.7244 2921000000000 +cpu,cpu=2 usage_idle=11.2938,usage_system=71.0495,usage_user=86.5697 2922000000000 +cpu,cpu=3 usage_idle=29.1371,usage_system=25.7737,usage_user=14.381 2923000000000 +cpu,cpu=4 usage_idle=57.6769,usage_system=43.7947,usage_user=62.3511 2924000000000 +cpu,cpu=0 usage_idle=74.6285,usage_system=95.4321,usage_user=12.5331 2925000000000 +cpu,cpu=1 usage_idle=45.1366,usage_system=91.409,usage_user=86.5975 2926000000000 +cpu,cpu=2 usage_idle=59.8069,usage_system=42.7243,usage_user=13.0624 2927000000000 +cpu,cpu=3 usage_idle=43.6756,usage_system=90.7002,usage_user=49.8632 2928000000000 +cpu,cpu=4 usage_idle=21.8741,usage_system=41.3811,usage_user=19.5955 2929000000000 +cpu,cpu=0 usage_idle=46.6054,usage_system=70.6628,usage_user=74.5921 2930000000000 +cpu,cpu=1 usage_idle=92.0382,usage_system=61.3586,usage_user=29.0361 2931000000000 +cpu,cpu=2 usage_idle=84.7626,usage_system=72.6524,usage_user=0.0856793 2932000000000 +cpu,cpu=3 usage_idle=71.3324,usage_system=1.78958,usage_user=25.8594 2933000000000 +cpu,cpu=4 usage_idle=85.7133,usage_system=59.4665,usage_user=69.654 2934000000000 +cpu,cpu=0 usage_idle=48.0645,usage_system=34.095,usage_user=65.0861 2935000000000 +cpu,cpu=1 usage_idle=60.5975,usage_system=79.2316,usage_user=56.4952 2936000000000 +cpu,cpu=2 usage_idle=47.195,usage_system=39.0386,usage_user=99.2195 2937000000000 +cpu,cpu=3 usage_idle=60.2575,usage_system=82.7142,usage_user=89.9197 2938000000000 +cpu,cpu=4 usage_idle=10.1207,usage_system=4.5883,usage_user=31.3008 2939000000000 +cpu,cpu=0 usage_idle=29.7162,usage_system=51.1937,usage_user=1.96364 2940000000000 +cpu,cpu=1 usage_idle=4.30831,usage_system=43.2319,usage_user=63.3223 2941000000000 +cpu,cpu=2 usage_idle=33.3445,usage_system=27.9946,usage_user=35.9747 2942000000000 +cpu,cpu=3 usage_idle=33.4301,usage_system=99.3269,usage_user=37.7643 2943000000000 +cpu,cpu=4 usage_idle=59.2895,usage_system=85.0403,usage_user=97.2308 2944000000000 +cpu,cpu=0 usage_idle=28.9435,usage_system=33.1047,usage_user=31.3258 2945000000000 +cpu,cpu=1 usage_idle=94.0296,usage_system=93.7022,usage_user=10.5575 2946000000000 +cpu,cpu=2 usage_idle=50.5248,usage_system=40.8973,usage_user=49.596 2947000000000 +cpu,cpu=3 usage_idle=49.7443,usage_system=1.15476,usage_user=32.3102 2948000000000 +cpu,cpu=4 usage_idle=39.664,usage_system=11.2755,usage_user=36.8985 2949000000000 +cpu,cpu=0 usage_idle=70.9648,usage_system=40.9917,usage_user=88.0922 2950000000000 +cpu,cpu=1 usage_idle=72.9285,usage_system=45.3,usage_user=31.3242 2951000000000 +cpu,cpu=2 usage_idle=36.2508,usage_system=78.6445,usage_user=59.3188 2952000000000 +cpu,cpu=3 usage_idle=72.2255,usage_system=12.0746,usage_user=58.6457 2953000000000 +cpu,cpu=4 usage_idle=9.98976,usage_system=71.3641,usage_user=43.6859 2954000000000 +cpu,cpu=0 usage_idle=7.22057,usage_system=0.307608,usage_user=76.7907 2955000000000 +cpu,cpu=1 usage_idle=38.5464,usage_system=94.3372,usage_user=70.4929 2956000000000 +cpu,cpu=2 usage_idle=49.1039,usage_system=44.862,usage_user=11.3902 2957000000000 +cpu,cpu=3 usage_idle=98.6999,usage_system=94.6063,usage_user=12.5449 2958000000000 +cpu,cpu=4 usage_idle=31.0101,usage_system=34.2703,usage_user=23.8204 2959000000000 +cpu,cpu=0 usage_idle=67.9087,usage_system=5.23519,usage_user=64.8121 2960000000000 +cpu,cpu=1 usage_idle=56.0009,usage_system=78.1637,usage_user=10.1121 2961000000000 +cpu,cpu=2 usage_idle=87.3251,usage_system=14.4144,usage_user=88.7565 2962000000000 +cpu,cpu=3 usage_idle=46.6439,usage_system=86.6399,usage_user=0.831128 2963000000000 +cpu,cpu=4 usage_idle=5.28953,usage_system=96.6297,usage_user=72.1952 2964000000000 +cpu,cpu=0 usage_idle=48.9755,usage_system=3.85024,usage_user=72.5028 2965000000000 +cpu,cpu=1 usage_idle=25.7662,usage_system=42.3967,usage_user=66.8401 2966000000000 +cpu,cpu=2 usage_idle=96.2591,usage_system=91.5005,usage_user=11.7021 2967000000000 +cpu,cpu=3 usage_idle=7.64926,usage_system=90.2004,usage_user=6.30846 2968000000000 +cpu,cpu=4 usage_idle=20.1942,usage_system=21.2106,usage_user=40.5788 2969000000000 +cpu,cpu=0 usage_idle=44.0146,usage_system=89.1192,usage_user=45.814 2970000000000 +cpu,cpu=1 usage_idle=8.82672,usage_system=45.1202,usage_user=23.9777 2971000000000 +cpu,cpu=2 usage_idle=18.9388,usage_system=32.4453,usage_user=38.3921 2972000000000 +cpu,cpu=3 usage_idle=7.69535,usage_system=79.0891,usage_user=25.032 2973000000000 +cpu,cpu=4 usage_idle=8.52648,usage_system=84.3786,usage_user=21.6617 2974000000000 +cpu,cpu=0 usage_idle=80.7217,usage_system=33.3541,usage_user=25.5119 2975000000000 +cpu,cpu=1 usage_idle=53.2245,usage_system=59.1203,usage_user=67.9085 2976000000000 +cpu,cpu=2 usage_idle=20.0646,usage_system=55.3794,usage_user=59.4091 2977000000000 +cpu,cpu=3 usage_idle=31.7667,usage_system=63.0286,usage_user=49.6095 2978000000000 +cpu,cpu=4 usage_idle=38.0752,usage_system=83.2228,usage_user=70.8201 2979000000000 +cpu,cpu=0 usage_idle=78.654,usage_system=27.2374,usage_user=59.9394 2980000000000 +cpu,cpu=1 usage_idle=24.468,usage_system=36.0642,usage_user=5.05952 2981000000000 +cpu,cpu=2 usage_idle=48.4456,usage_system=55.003,usage_user=37.5048 2982000000000 +cpu,cpu=3 usage_idle=86.8377,usage_system=62.6983,usage_user=16.5939 2983000000000 +cpu,cpu=4 usage_idle=11.8697,usage_system=71.2248,usage_user=0.972536 2984000000000 +cpu,cpu=0 usage_idle=33.5314,usage_system=51.9465,usage_user=34.3267 2985000000000 +cpu,cpu=1 usage_idle=59.0433,usage_system=5.17102,usage_user=93.4469 2986000000000 +cpu,cpu=2 usage_idle=26.9518,usage_system=25.2356,usage_user=48.8263 2987000000000 +cpu,cpu=3 usage_idle=86.3609,usage_system=57.0023,usage_user=11.8549 2988000000000 +cpu,cpu=4 usage_idle=35.9704,usage_system=95.0775,usage_user=95.0777 2989000000000 +cpu,cpu=0 usage_idle=6.79053,usage_system=73.7314,usage_user=22.3152 2990000000000 +cpu,cpu=1 usage_idle=66.7299,usage_system=98.1994,usage_user=58.3794 2991000000000 +cpu,cpu=2 usage_idle=71.7894,usage_system=46.645,usage_user=13.3823 2992000000000 +cpu,cpu=3 usage_idle=9.29419,usage_system=33.4827,usage_user=76.0807 2993000000000 +cpu,cpu=4 usage_idle=25.8881,usage_system=45.3524,usage_user=47.3055 2994000000000 +cpu,cpu=0 usage_idle=26.8606,usage_system=78.8838,usage_user=99.252 2995000000000 +cpu,cpu=1 usage_idle=61.1873,usage_system=37.927,usage_user=4.42301 2996000000000 +cpu,cpu=2 usage_idle=54.6342,usage_system=64.8788,usage_user=29.6586 2997000000000 +cpu,cpu=3 usage_idle=3.46053,usage_system=51.2397,usage_user=86.6609 2998000000000 +cpu,cpu=4 usage_idle=15.3154,usage_system=87.2102,usage_user=81.7384 2999000000000 +cpu,cpu=0 usage_idle=10.3932,usage_system=94.0007,usage_user=55.4698 3000000000000 +cpu,cpu=1 usage_idle=32.7084,usage_system=60.7306,usage_user=53.6692 3001000000000 +cpu,cpu=2 usage_idle=91.0878,usage_system=32.52,usage_user=0.314147 3002000000000 +cpu,cpu=3 usage_idle=4.4701,usage_system=41.8142,usage_user=33.7968 3003000000000 +cpu,cpu=4 usage_idle=80.5508,usage_system=67.7023,usage_user=79.1492 3004000000000 +cpu,cpu=0 usage_idle=27.8563,usage_system=94.5629,usage_user=58.033 3005000000000 +cpu,cpu=1 usage_idle=27.1082,usage_system=55.7501,usage_user=95.96 3006000000000 +cpu,cpu=2 usage_idle=31.5313,usage_system=10.3844,usage_user=60.8389 3007000000000 +cpu,cpu=3 usage_idle=61.1899,usage_system=13.8449,usage_user=12.0786 3008000000000 +cpu,cpu=4 usage_idle=47.8508,usage_system=29.1603,usage_user=99.2888 3009000000000 +cpu,cpu=0 usage_idle=29.5892,usage_system=39.5535,usage_user=93.2895 3010000000000 +cpu,cpu=1 usage_idle=85.059,usage_system=72.2619,usage_user=54.02 3011000000000 +cpu,cpu=2 usage_idle=38.7281,usage_system=63.3497,usage_user=86.54 3012000000000 +cpu,cpu=3 usage_idle=39.0423,usage_system=67.8198,usage_user=28.3542 3013000000000 +cpu,cpu=4 usage_idle=72.8391,usage_system=48.3706,usage_user=96.0565 3014000000000 +cpu,cpu=0 usage_idle=51.9883,usage_system=76.2268,usage_user=90.6193 3015000000000 +cpu,cpu=1 usage_idle=10.0214,usage_system=3.33506,usage_user=46.3695 3016000000000 +cpu,cpu=2 usage_idle=5.9814,usage_system=34.8663,usage_user=56.7538 3017000000000 +cpu,cpu=3 usage_idle=66.8203,usage_system=96.0562,usage_user=70.5987 3018000000000 +cpu,cpu=4 usage_idle=78.8989,usage_system=43.907,usage_user=99.7591 3019000000000 +cpu,cpu=0 usage_idle=78.1877,usage_system=73.4961,usage_user=39.3126 3020000000000 +cpu,cpu=1 usage_idle=71.4771,usage_system=58.5551,usage_user=11.5746 3021000000000 +cpu,cpu=2 usage_idle=25.4972,usage_system=97.2832,usage_user=74.9243 3022000000000 +cpu,cpu=3 usage_idle=12.0372,usage_system=36.3255,usage_user=42.7441 3023000000000 +cpu,cpu=4 usage_idle=40.3914,usage_system=9.16457,usage_user=91.1146 3024000000000 +cpu,cpu=0 usage_idle=36.4479,usage_system=61.1529,usage_user=67.3415 3025000000000 +cpu,cpu=1 usage_idle=27.0672,usage_system=71.1743,usage_user=70.6765 3026000000000 +cpu,cpu=2 usage_idle=73.4367,usage_system=77.1557,usage_user=5.54283 3027000000000 +cpu,cpu=3 usage_idle=30.1905,usage_system=43.976,usage_user=1.59901 3028000000000 +cpu,cpu=4 usage_idle=0.78925,usage_system=22.8749,usage_user=45.506 3029000000000 +cpu,cpu=0 usage_idle=0.548334,usage_system=1.06253,usage_user=19.0021 3030000000000 +cpu,cpu=1 usage_idle=39.861,usage_system=72.5397,usage_user=77.5572 3031000000000 +cpu,cpu=2 usage_idle=51.4355,usage_system=98.0368,usage_user=74.8404 3032000000000 +cpu,cpu=3 usage_idle=26.3598,usage_system=10.074,usage_user=11.1658 3033000000000 +cpu,cpu=4 usage_idle=69.1039,usage_system=50.4654,usage_user=20.3304 3034000000000 +cpu,cpu=0 usage_idle=60.2185,usage_system=86.9133,usage_user=81.4833 3035000000000 +cpu,cpu=1 usage_idle=27.5599,usage_system=13.9805,usage_user=52.6576 3036000000000 +cpu,cpu=2 usage_idle=98.2365,usage_system=87.4172,usage_user=29.8133 3037000000000 +cpu,cpu=3 usage_idle=3.77928,usage_system=17.6077,usage_user=73.7893 3038000000000 +cpu,cpu=4 usage_idle=5.37829,usage_system=18.3969,usage_user=96.6641 3039000000000 +cpu,cpu=0 usage_idle=50.8843,usage_system=18.9453,usage_user=97.7267 3040000000000 +cpu,cpu=1 usage_idle=69.8864,usage_system=58.8062,usage_user=70.2663 3041000000000 +cpu,cpu=2 usage_idle=47.4435,usage_system=10.2418,usage_user=68.3032 3042000000000 +cpu,cpu=3 usage_idle=22.2839,usage_system=36.6015,usage_user=78.3772 3043000000000 +cpu,cpu=4 usage_idle=33.4498,usage_system=5.7054,usage_user=28.8426 3044000000000 +cpu,cpu=0 usage_idle=53.7802,usage_system=65.9239,usage_user=15.7559 3045000000000 +cpu,cpu=1 usage_idle=35.2635,usage_system=93.4838,usage_user=29.7364 3046000000000 +cpu,cpu=2 usage_idle=87.9212,usage_system=91.7203,usage_user=17.1536 3047000000000 +cpu,cpu=3 usage_idle=17.7345,usage_system=95.4996,usage_user=34.7613 3048000000000 +cpu,cpu=4 usage_idle=91.5238,usage_system=0.877866,usage_user=53.1582 3049000000000 +cpu,cpu=0 usage_idle=88.1879,usage_system=51.7621,usage_user=72.1035 3050000000000 +cpu,cpu=1 usage_idle=85.9146,usage_system=21.6485,usage_user=30.9097 3051000000000 +cpu,cpu=2 usage_idle=56.1809,usage_system=69.092,usage_user=41.1515 3052000000000 +cpu,cpu=3 usage_idle=24.4841,usage_system=91.376,usage_user=77.753 3053000000000 +cpu,cpu=4 usage_idle=2.86126,usage_system=24.8258,usage_user=83.4584 3054000000000 +cpu,cpu=0 usage_idle=31.7039,usage_system=78.606,usage_user=49.3823 3055000000000 +cpu,cpu=1 usage_idle=47.4598,usage_system=13.8695,usage_user=42.8662 3056000000000 +cpu,cpu=2 usage_idle=77.1963,usage_system=1.79067,usage_user=34.5865 3057000000000 +cpu,cpu=3 usage_idle=94.3499,usage_system=19.5252,usage_user=30.086 3058000000000 +cpu,cpu=4 usage_idle=29.1112,usage_system=11.0489,usage_user=30.9639 3059000000000 +cpu,cpu=0 usage_idle=82.2694,usage_system=99.2368,usage_user=82.726 3060000000000 +cpu,cpu=1 usage_idle=54.3729,usage_system=85.1514,usage_user=4.37453 3061000000000 +cpu,cpu=2 usage_idle=85.2826,usage_system=41.3323,usage_user=73.4666 3062000000000 +cpu,cpu=3 usage_idle=26.4341,usage_system=65.8163,usage_user=64.8426 3063000000000 +cpu,cpu=4 usage_idle=4.18717,usage_system=68.6776,usage_user=89.6683 3064000000000 +cpu,cpu=0 usage_idle=87.6456,usage_system=0.381478,usage_user=68.2743 3065000000000 +cpu,cpu=1 usage_idle=37.028,usage_system=47.8413,usage_user=82.1438 3066000000000 +cpu,cpu=2 usage_idle=79.8941,usage_system=25.0376,usage_user=83.9344 3067000000000 +cpu,cpu=3 usage_idle=14.4806,usage_system=19.3874,usage_user=3.4596 3068000000000 +cpu,cpu=4 usage_idle=44.5666,usage_system=48.4986,usage_user=14.5085 3069000000000 +cpu,cpu=0 usage_idle=75.5305,usage_system=30.768,usage_user=13.7453 3070000000000 +cpu,cpu=1 usage_idle=58.2566,usage_system=85.1409,usage_user=98.8967 3071000000000 +cpu,cpu=2 usage_idle=62.6311,usage_system=70.4235,usage_user=40.229 3072000000000 +cpu,cpu=3 usage_idle=36.0977,usage_system=96.8577,usage_user=6.0453 3073000000000 +cpu,cpu=4 usage_idle=0.940229,usage_system=1.04483,usage_user=74.7229 3074000000000 +cpu,cpu=0 usage_idle=90.6085,usage_system=88.6905,usage_user=75.1044 3075000000000 +cpu,cpu=1 usage_idle=58.8828,usage_system=25.7184,usage_user=22.9457 3076000000000 +cpu,cpu=2 usage_idle=41.0266,usage_system=5.61255,usage_user=47.9832 3077000000000 +cpu,cpu=3 usage_idle=24.961,usage_system=20.0931,usage_user=67.3706 3078000000000 +cpu,cpu=4 usage_idle=28.4206,usage_system=64.6598,usage_user=15.8692 3079000000000 +cpu,cpu=0 usage_idle=42.9292,usage_system=40.1903,usage_user=46.6372 3080000000000 +cpu,cpu=1 usage_idle=56.6745,usage_system=98.4468,usage_user=31.7781 3081000000000 +cpu,cpu=2 usage_idle=55.5712,usage_system=61.0779,usage_user=2.20164 3082000000000 +cpu,cpu=3 usage_idle=95.8001,usage_system=97.1756,usage_user=99.0593 3083000000000 +cpu,cpu=4 usage_idle=1.84543,usage_system=98.1158,usage_user=0.104131 3084000000000 +cpu,cpu=0 usage_idle=76.5683,usage_system=88.7244,usage_user=88.7946 3085000000000 +cpu,cpu=1 usage_idle=51.6727,usage_system=47.6072,usage_user=14.513 3086000000000 +cpu,cpu=2 usage_idle=74.6183,usage_system=88.6338,usage_user=20.1256 3087000000000 +cpu,cpu=3 usage_idle=22.6016,usage_system=13.5948,usage_user=40.2187 3088000000000 +cpu,cpu=4 usage_idle=89.9722,usage_system=42.0155,usage_user=4.87847 3089000000000 +cpu,cpu=0 usage_idle=5.84144,usage_system=84.9446,usage_user=45.0688 3090000000000 +cpu,cpu=1 usage_idle=52.4787,usage_system=41.6191,usage_user=43.5156 3091000000000 +cpu,cpu=2 usage_idle=84.2568,usage_system=97.1903,usage_user=4.59354 3092000000000 +cpu,cpu=3 usage_idle=86.4584,usage_system=92.9904,usage_user=1.76915 3093000000000 +cpu,cpu=4 usage_idle=85.5177,usage_system=94.8358,usage_user=99.885 3094000000000 +cpu,cpu=0 usage_idle=85.6219,usage_system=71.4042,usage_user=88.6094 3095000000000 +cpu,cpu=1 usage_idle=74.4164,usage_system=23.0768,usage_user=36.2166 3096000000000 +cpu,cpu=2 usage_idle=88.9294,usage_system=97.6952,usage_user=24.8504 3097000000000 +cpu,cpu=3 usage_idle=9.05499,usage_system=20.2967,usage_user=38.4452 3098000000000 +cpu,cpu=4 usage_idle=49.2737,usage_system=10.2689,usage_user=80.4607 3099000000000 +cpu,cpu=0 usage_idle=54.1521,usage_system=16.1104,usage_user=65.4053 3100000000000 +cpu,cpu=1 usage_idle=99.2209,usage_system=68.589,usage_user=7.02442 3101000000000 +cpu,cpu=2 usage_idle=42.7365,usage_system=52.8458,usage_user=4.2147 3102000000000 +cpu,cpu=3 usage_idle=47.3301,usage_system=39.3042,usage_user=97.2051 3103000000000 +cpu,cpu=4 usage_idle=49.0992,usage_system=24.822,usage_user=92.041 3104000000000 +cpu,cpu=0 usage_idle=48.9842,usage_system=10.4438,usage_user=63.4451 3105000000000 +cpu,cpu=1 usage_idle=37.5935,usage_system=84.8602,usage_user=86.5219 3106000000000 +cpu,cpu=2 usage_idle=73.8101,usage_system=73.7897,usage_user=84.2171 3107000000000 +cpu,cpu=3 usage_idle=98.6604,usage_system=82.8447,usage_user=4.51384 3108000000000 +cpu,cpu=4 usage_idle=37.1056,usage_system=32.1183,usage_user=14.7828 3109000000000 +cpu,cpu=0 usage_idle=17.5663,usage_system=86.2705,usage_user=30.8931 3110000000000 +cpu,cpu=1 usage_idle=82.9716,usage_system=85.4914,usage_user=99.4822 3111000000000 +cpu,cpu=2 usage_idle=89.996,usage_system=28.2279,usage_user=52.328 3112000000000 +cpu,cpu=3 usage_idle=94.2107,usage_system=75.558,usage_user=91.6322 3113000000000 +cpu,cpu=4 usage_idle=91.4158,usage_system=24.6572,usage_user=16.4542 3114000000000 +cpu,cpu=0 usage_idle=83.4568,usage_system=73.6413,usage_user=26.898 3115000000000 +cpu,cpu=1 usage_idle=46.9019,usage_system=11.2349,usage_user=11.7582 3116000000000 +cpu,cpu=2 usage_idle=33.4238,usage_system=85.045,usage_user=85.5479 3117000000000 +cpu,cpu=3 usage_idle=17.641,usage_system=83.7054,usage_user=68.3926 3118000000000 +cpu,cpu=4 usage_idle=22.1548,usage_system=20.8111,usage_user=0.510916 3119000000000 +cpu,cpu=0 usage_idle=36.9376,usage_system=38.3774,usage_user=86.7814 3120000000000 +cpu,cpu=1 usage_idle=67.8307,usage_system=21.3489,usage_user=72.2728 3121000000000 +cpu,cpu=2 usage_idle=67.3129,usage_system=11.345,usage_user=0.500733 3122000000000 +cpu,cpu=3 usage_idle=19.6409,usage_system=5.55568,usage_user=76.0587 3123000000000 +cpu,cpu=4 usage_idle=11.2731,usage_system=96.9715,usage_user=0.715868 3124000000000 +cpu,cpu=0 usage_idle=27.7273,usage_system=80.4283,usage_user=74.3572 3125000000000 +cpu,cpu=1 usage_idle=54.6253,usage_system=27.3302,usage_user=85.5921 3126000000000 +cpu,cpu=2 usage_idle=66.3835,usage_system=60.7541,usage_user=70.6371 3127000000000 +cpu,cpu=3 usage_idle=51.9314,usage_system=78.395,usage_user=54.3425 3128000000000 +cpu,cpu=4 usage_idle=20.324,usage_system=0.549801,usage_user=75.1535 3129000000000 +cpu,cpu=0 usage_idle=20.8349,usage_system=37.4874,usage_user=13.5309 3130000000000 +cpu,cpu=1 usage_idle=7.61631,usage_system=5.31807,usage_user=34.8798 3131000000000 +cpu,cpu=2 usage_idle=79.8891,usage_system=72.631,usage_user=46.2248 3132000000000 +cpu,cpu=3 usage_idle=80.3899,usage_system=92.2718,usage_user=51.7805 3133000000000 +cpu,cpu=4 usage_idle=56.4486,usage_system=3.54494,usage_user=48.752 3134000000000 +cpu,cpu=0 usage_idle=57.1644,usage_system=31.2722,usage_user=29.1803 3135000000000 +cpu,cpu=1 usage_idle=31.5216,usage_system=85.8975,usage_user=56.5105 3136000000000 +cpu,cpu=2 usage_idle=17.1137,usage_system=52.281,usage_user=17.2646 3137000000000 +cpu,cpu=3 usage_idle=87.7508,usage_system=4.21245,usage_user=95.6596 3138000000000 +cpu,cpu=4 usage_idle=42.0933,usage_system=24.5364,usage_user=96.2094 3139000000000 +cpu,cpu=0 usage_idle=17.2468,usage_system=45.3713,usage_user=33.6967 3140000000000 +cpu,cpu=1 usage_idle=30.7777,usage_system=52.9876,usage_user=39.0148 3141000000000 +cpu,cpu=2 usage_idle=65.6576,usage_system=32.8768,usage_user=11.6458 3142000000000 +cpu,cpu=3 usage_idle=11.8824,usage_system=13.2666,usage_user=3.9176 3143000000000 +cpu,cpu=4 usage_idle=63.6628,usage_system=69.7152,usage_user=7.46255 3144000000000 +cpu,cpu=0 usage_idle=12.4148,usage_system=26.8796,usage_user=38.7348 3145000000000 +cpu,cpu=1 usage_idle=41.5951,usage_system=58.4013,usage_user=24.6323 3146000000000 +cpu,cpu=2 usage_idle=98.1057,usage_system=75.515,usage_user=76.9133 3147000000000 +cpu,cpu=3 usage_idle=15.3702,usage_system=63.2658,usage_user=81.1258 3148000000000 +cpu,cpu=4 usage_idle=11.0298,usage_system=5.35911,usage_user=5.66223 3149000000000 +cpu,cpu=0 usage_idle=7.23922,usage_system=22.6059,usage_user=51.0336 3150000000000 +cpu,cpu=1 usage_idle=40.936,usage_system=53.3836,usage_user=4.02121 3151000000000 +cpu,cpu=2 usage_idle=79.9508,usage_system=19.0412,usage_user=36.898 3152000000000 +cpu,cpu=3 usage_idle=91.5966,usage_system=30.9236,usage_user=50.1646 3153000000000 +cpu,cpu=4 usage_idle=95.5142,usage_system=94.5864,usage_user=19.8798 3154000000000 +cpu,cpu=0 usage_idle=2.9767,usage_system=7.00123,usage_user=46.7595 3155000000000 +cpu,cpu=1 usage_idle=41.7115,usage_system=48.5964,usage_user=5.16077 3156000000000 +cpu,cpu=2 usage_idle=66.3438,usage_system=46.7021,usage_user=80.6758 3157000000000 +cpu,cpu=3 usage_idle=43.2571,usage_system=62.0723,usage_user=43.9416 3158000000000 +cpu,cpu=4 usage_idle=24.3829,usage_system=73.1021,usage_user=49.3007 3159000000000 +cpu,cpu=0 usage_idle=30.0452,usage_system=80.3413,usage_user=71.9067 3160000000000 +cpu,cpu=1 usage_idle=81.0787,usage_system=21.2773,usage_user=25.2903 3161000000000 +cpu,cpu=2 usage_idle=85.0999,usage_system=1.22809,usage_user=44.3315 3162000000000 +cpu,cpu=3 usage_idle=21.9979,usage_system=92.8246,usage_user=75.2551 3163000000000 +cpu,cpu=4 usage_idle=72.1625,usage_system=88.3388,usage_user=69.8414 3164000000000 +cpu,cpu=0 usage_idle=92.0424,usage_system=91.3155,usage_user=76.8427 3165000000000 +cpu,cpu=1 usage_idle=38.8019,usage_system=33.027,usage_user=25.4391 3166000000000 +cpu,cpu=2 usage_idle=43.9626,usage_system=99.3708,usage_user=72.1411 3167000000000 +cpu,cpu=3 usage_idle=24.6384,usage_system=42.6279,usage_user=34.2134 3168000000000 +cpu,cpu=4 usage_idle=68.58,usage_system=67.0108,usage_user=7.31555 3169000000000 +cpu,cpu=0 usage_idle=17.8808,usage_system=97.056,usage_user=87.6569 3170000000000 +cpu,cpu=1 usage_idle=89.7874,usage_system=78.1347,usage_user=8.9342 3171000000000 +cpu,cpu=2 usage_idle=15.0777,usage_system=63.2346,usage_user=10.1623 3172000000000 +cpu,cpu=3 usage_idle=59.4092,usage_system=85.2325,usage_user=2.98693 3173000000000 +cpu,cpu=4 usage_idle=34.6643,usage_system=57.3951,usage_user=91.3257 3174000000000 +cpu,cpu=0 usage_idle=4.50573,usage_system=49.4375,usage_user=82.6412 3175000000000 +cpu,cpu=1 usage_idle=81.3484,usage_system=88.2393,usage_user=15.6682 3176000000000 +cpu,cpu=2 usage_idle=6.78748,usage_system=32.2019,usage_user=15.039 3177000000000 +cpu,cpu=3 usage_idle=78.9286,usage_system=56.8404,usage_user=57.6669 3178000000000 +cpu,cpu=4 usage_idle=13.142,usage_system=25.4204,usage_user=24.6777 3179000000000 +cpu,cpu=0 usage_idle=20.4576,usage_system=43.3012,usage_user=21.7337 3180000000000 +cpu,cpu=1 usage_idle=8.11446,usage_system=33.0886,usage_user=99.8684 3181000000000 +cpu,cpu=2 usage_idle=17.0487,usage_system=48.1663,usage_user=63.1031 3182000000000 +cpu,cpu=3 usage_idle=27.211,usage_system=7.57552,usage_user=48.3356 3183000000000 +cpu,cpu=4 usage_idle=30.1979,usage_system=42.2398,usage_user=5.73069 3184000000000 +cpu,cpu=0 usage_idle=21.5236,usage_system=46.7455,usage_user=55.1681 3185000000000 +cpu,cpu=1 usage_idle=4.16483,usage_system=28.094,usage_user=43.4074 3186000000000 +cpu,cpu=2 usage_idle=19.833,usage_system=34.8814,usage_user=75.6094 3187000000000 +cpu,cpu=3 usage_idle=34.872,usage_system=13.81,usage_user=32.4497 3188000000000 +cpu,cpu=4 usage_idle=92.5389,usage_system=26.9521,usage_user=57.8701 3189000000000 +cpu,cpu=0 usage_idle=17.2166,usage_system=47.4096,usage_user=1.17127 3190000000000 +cpu,cpu=1 usage_idle=38.9503,usage_system=55.5241,usage_user=34.2598 3191000000000 +cpu,cpu=2 usage_idle=38.8188,usage_system=72.5727,usage_user=82.4261 3192000000000 +cpu,cpu=3 usage_idle=1.92185,usage_system=99.7837,usage_user=90.0017 3193000000000 +cpu,cpu=4 usage_idle=50.2575,usage_system=29.9816,usage_user=32.2415 3194000000000 +cpu,cpu=0 usage_idle=55.9882,usage_system=51.5052,usage_user=78.987 3195000000000 +cpu,cpu=1 usage_idle=11.1563,usage_system=55.67,usage_user=7.08096 3196000000000 +cpu,cpu=2 usage_idle=54.5637,usage_system=75.5031,usage_user=41.9624 3197000000000 +cpu,cpu=3 usage_idle=30.1731,usage_system=10.3751,usage_user=55.7724 3198000000000 +cpu,cpu=4 usage_idle=62.6229,usage_system=2.91397,usage_user=82.7245 3199000000000 +cpu,cpu=0 usage_idle=20.493,usage_system=20.1306,usage_user=30.1341 3200000000000 +cpu,cpu=1 usage_idle=21.6642,usage_system=59.0809,usage_user=85.6582 3201000000000 +cpu,cpu=2 usage_idle=55.9241,usage_system=97.8997,usage_user=58.231 3202000000000 +cpu,cpu=3 usage_idle=38.3502,usage_system=99.8216,usage_user=58.0147 3203000000000 +cpu,cpu=4 usage_idle=28.3519,usage_system=50.079,usage_user=87.9963 3204000000000 +cpu,cpu=0 usage_idle=60.5934,usage_system=6.06717,usage_user=39.5015 3205000000000 +cpu,cpu=1 usage_idle=39.5804,usage_system=17.2235,usage_user=95.1715 3206000000000 +cpu,cpu=2 usage_idle=46.6613,usage_system=71.7872,usage_user=70.6746 3207000000000 +cpu,cpu=3 usage_idle=88.6238,usage_system=1.96033,usage_user=81.0497 3208000000000 +cpu,cpu=4 usage_idle=44.3962,usage_system=64.5832,usage_user=83.9636 3209000000000 +cpu,cpu=0 usage_idle=27.1207,usage_system=85.0762,usage_user=4.09423 3210000000000 +cpu,cpu=1 usage_idle=57.2548,usage_system=6.7404,usage_user=63.1752 3211000000000 +cpu,cpu=2 usage_idle=42.9131,usage_system=62.6645,usage_user=61.0749 3212000000000 +cpu,cpu=3 usage_idle=1.14404,usage_system=1.01474,usage_user=60.8964 3213000000000 +cpu,cpu=4 usage_idle=59.1587,usage_system=29.3666,usage_user=10.9755 3214000000000 +cpu,cpu=0 usage_idle=47.155,usage_system=89.96,usage_user=17.0426 3215000000000 +cpu,cpu=1 usage_idle=86.6565,usage_system=29.5404,usage_user=34.2661 3216000000000 +cpu,cpu=2 usage_idle=81.828,usage_system=76.2017,usage_user=6.05329 3217000000000 +cpu,cpu=3 usage_idle=52.5025,usage_system=64.8255,usage_user=8.01361 3218000000000 +cpu,cpu=4 usage_idle=33.5522,usage_system=9.22169,usage_user=72.5968 3219000000000 +cpu,cpu=0 usage_idle=17.5158,usage_system=36.3424,usage_user=57.6729 3220000000000 +cpu,cpu=1 usage_idle=21.6101,usage_system=93.5972,usage_user=64.4134 3221000000000 +cpu,cpu=2 usage_idle=84.7852,usage_system=36.5103,usage_user=27.0779 3222000000000 +cpu,cpu=3 usage_idle=45.8601,usage_system=37.6543,usage_user=28.0926 3223000000000 +cpu,cpu=4 usage_idle=6.75653,usage_system=96.813,usage_user=57.4592 3224000000000 +cpu,cpu=0 usage_idle=17.732,usage_system=43.968,usage_user=47.4192 3225000000000 +cpu,cpu=1 usage_idle=34.7746,usage_system=30.6245,usage_user=76.9596 3226000000000 +cpu,cpu=2 usage_idle=69.0407,usage_system=12.4524,usage_user=53.1614 3227000000000 +cpu,cpu=3 usage_idle=75.094,usage_system=64.955,usage_user=17.9869 3228000000000 +cpu,cpu=4 usage_idle=83.1076,usage_system=98.5072,usage_user=27.2086 3229000000000 +cpu,cpu=0 usage_idle=55.7044,usage_system=16.023,usage_user=63.551 3230000000000 +cpu,cpu=1 usage_idle=13.3773,usage_system=37.6331,usage_user=57.1482 3231000000000 +cpu,cpu=2 usage_idle=77.7907,usage_system=22.4183,usage_user=93.6585 3232000000000 +cpu,cpu=3 usage_idle=4.86854,usage_system=68.2784,usage_user=31.3128 3233000000000 +cpu,cpu=4 usage_idle=32.9611,usage_system=75.0349,usage_user=28.1259 3234000000000 +cpu,cpu=0 usage_idle=90.4204,usage_system=92.7669,usage_user=72.0939 3235000000000 +cpu,cpu=1 usage_idle=37.8396,usage_system=27.5415,usage_user=2.71838 3236000000000 +cpu,cpu=2 usage_idle=14.7992,usage_system=96.5822,usage_user=15.1708 3237000000000 +cpu,cpu=3 usage_idle=67.9606,usage_system=71.6762,usage_user=80.1258 3238000000000 +cpu,cpu=4 usage_idle=85.9475,usage_system=54.7838,usage_user=78.633 3239000000000 +cpu,cpu=0 usage_idle=13.1561,usage_system=10.4882,usage_user=94.656 3240000000000 +cpu,cpu=1 usage_idle=76.7071,usage_system=23.8655,usage_user=32.2891 3241000000000 +cpu,cpu=2 usage_idle=33.8552,usage_system=1.65623,usage_user=54.7074 3242000000000 +cpu,cpu=3 usage_idle=27.5137,usage_system=6.52476,usage_user=22.9858 3243000000000 +cpu,cpu=4 usage_idle=58.8266,usage_system=39.4859,usage_user=98.0207 3244000000000 +cpu,cpu=0 usage_idle=86.9524,usage_system=29.9062,usage_user=90.7877 3245000000000 +cpu,cpu=1 usage_idle=59.0463,usage_system=67.7458,usage_user=18.3292 3246000000000 +cpu,cpu=2 usage_idle=61.7647,usage_system=82.5451,usage_user=14.9115 3247000000000 +cpu,cpu=3 usage_idle=76.9355,usage_system=50.5057,usage_user=86.5877 3248000000000 +cpu,cpu=4 usage_idle=57.0613,usage_system=36.4532,usage_user=41.3715 3249000000000 +cpu,cpu=0 usage_idle=35.6943,usage_system=49.6093,usage_user=51.8597 3250000000000 +cpu,cpu=1 usage_idle=30.3503,usage_system=26.3164,usage_user=75.7252 3251000000000 +cpu,cpu=2 usage_idle=62.6394,usage_system=60.1716,usage_user=77.3815 3252000000000 +cpu,cpu=3 usage_idle=17.3468,usage_system=87.6853,usage_user=83.9062 3253000000000 +cpu,cpu=4 usage_idle=40.3326,usage_system=46.5119,usage_user=23.3921 3254000000000 +cpu,cpu=0 usage_idle=38.3533,usage_system=33.4643,usage_user=53.2984 3255000000000 +cpu,cpu=1 usage_idle=29.141,usage_system=92.5107,usage_user=21.0442 3256000000000 +cpu,cpu=2 usage_idle=47.4702,usage_system=54.2754,usage_user=3.58929 3257000000000 +cpu,cpu=3 usage_idle=62.3817,usage_system=31.2109,usage_user=54.095 3258000000000 +cpu,cpu=4 usage_idle=48.9694,usage_system=88.2722,usage_user=90.5482 3259000000000 +cpu,cpu=0 usage_idle=90.3409,usage_system=23.9665,usage_user=40.1575 3260000000000 +cpu,cpu=1 usage_idle=42.2006,usage_system=54.3168,usage_user=66.4739 3261000000000 +cpu,cpu=2 usage_idle=17.9258,usage_system=16.9562,usage_user=26.6455 3262000000000 +cpu,cpu=3 usage_idle=95.3072,usage_system=34.303,usage_user=14.3308 3263000000000 +cpu,cpu=4 usage_idle=79.2135,usage_system=74.6355,usage_user=60.8427 3264000000000 +cpu,cpu=0 usage_idle=2.60558,usage_system=12.9889,usage_user=94.3071 3265000000000 +cpu,cpu=1 usage_idle=55.9039,usage_system=42.1299,usage_user=86.8177 3266000000000 +cpu,cpu=2 usage_idle=76.9481,usage_system=89.6001,usage_user=41.0931 3267000000000 +cpu,cpu=3 usage_idle=80.5374,usage_system=51.9818,usage_user=72.3039 3268000000000 +cpu,cpu=4 usage_idle=34.6324,usage_system=0.951167,usage_user=60.5761 3269000000000 +cpu,cpu=0 usage_idle=25.1806,usage_system=91.292,usage_user=84.5426 3270000000000 +cpu,cpu=1 usage_idle=65.3382,usage_system=33.4926,usage_user=38.8594 3271000000000 +cpu,cpu=2 usage_idle=31.8121,usage_system=51.4184,usage_user=55.8156 3272000000000 +cpu,cpu=3 usage_idle=58.4575,usage_system=46.7256,usage_user=90.1185 3273000000000 +cpu,cpu=4 usage_idle=72.7884,usage_system=25.9391,usage_user=64.7541 3274000000000 +cpu,cpu=0 usage_idle=33.6311,usage_system=28.5447,usage_user=77.7429 3275000000000 +cpu,cpu=1 usage_idle=27.9382,usage_system=84.4486,usage_user=19.8728 3276000000000 +cpu,cpu=2 usage_idle=14.7559,usage_system=61.3967,usage_user=9.47291 3277000000000 +cpu,cpu=3 usage_idle=55.8489,usage_system=41.9342,usage_user=61.4547 3278000000000 +cpu,cpu=4 usage_idle=28.1529,usage_system=76.5666,usage_user=62.4059 3279000000000 +cpu,cpu=0 usage_idle=88.729,usage_system=1.74723,usage_user=53.6979 3280000000000 +cpu,cpu=1 usage_idle=73.2716,usage_system=67.0854,usage_user=87.1905 3281000000000 +cpu,cpu=2 usage_idle=12.131,usage_system=98.8975,usage_user=38.6089 3282000000000 +cpu,cpu=3 usage_idle=67.9466,usage_system=57.355,usage_user=85.3345 3283000000000 +cpu,cpu=4 usage_idle=58.0652,usage_system=30.1434,usage_user=11.2735 3284000000000 +cpu,cpu=0 usage_idle=22.8193,usage_system=63.7745,usage_user=39.8182 3285000000000 +cpu,cpu=1 usage_idle=0.56219,usage_system=91.7126,usage_user=24.2668 3286000000000 +cpu,cpu=2 usage_idle=20.435,usage_system=6.4685,usage_user=85.6635 3287000000000 +cpu,cpu=3 usage_idle=29.9079,usage_system=62.3174,usage_user=27.5977 3288000000000 +cpu,cpu=4 usage_idle=91.3626,usage_system=90.4703,usage_user=4.16425 3289000000000 +cpu,cpu=0 usage_idle=53.7685,usage_system=79.1993,usage_user=5.91148 3290000000000 +cpu,cpu=1 usage_idle=7.46638,usage_system=52.4709,usage_user=72.9969 3291000000000 +cpu,cpu=2 usage_idle=94.6569,usage_system=64.602,usage_user=71.8943 3292000000000 +cpu,cpu=3 usage_idle=33.2657,usage_system=32.5486,usage_user=29.2493 3293000000000 +cpu,cpu=4 usage_idle=18.6002,usage_system=90.6138,usage_user=59.3927 3294000000000 +cpu,cpu=0 usage_idle=29.8737,usage_system=13.433,usage_user=23.1671 3295000000000 +cpu,cpu=1 usage_idle=69.6919,usage_system=13.9952,usage_user=14.8798 3296000000000 +cpu,cpu=2 usage_idle=93.9587,usage_system=34.4302,usage_user=21.3483 3297000000000 +cpu,cpu=3 usage_idle=79.6222,usage_system=64.3381,usage_user=83.6657 3298000000000 +cpu,cpu=4 usage_idle=7.21985,usage_system=55.7007,usage_user=74.136 3299000000000 +cpu,cpu=0 usage_idle=11.3841,usage_system=9.4692,usage_user=53.3353 3300000000000 +cpu,cpu=1 usage_idle=17.2956,usage_system=16.9356,usage_user=5.80626 3301000000000 +cpu,cpu=2 usage_idle=90.2925,usage_system=11.5924,usage_user=70.4082 3302000000000 +cpu,cpu=3 usage_idle=62.1868,usage_system=44.8581,usage_user=2.95683 3303000000000 +cpu,cpu=4 usage_idle=91.4361,usage_system=63.4583,usage_user=93.5706 3304000000000 +cpu,cpu=0 usage_idle=50.8288,usage_system=93.332,usage_user=7.00364 3305000000000 +cpu,cpu=1 usage_idle=73.9959,usage_system=63.0239,usage_user=20.9989 3306000000000 +cpu,cpu=2 usage_idle=88.8757,usage_system=56.9826,usage_user=55.4291 3307000000000 +cpu,cpu=3 usage_idle=10.2239,usage_system=36.6048,usage_user=19.7672 3308000000000 +cpu,cpu=4 usage_idle=93.8896,usage_system=43.8247,usage_user=75.4679 3309000000000 +cpu,cpu=0 usage_idle=68.0257,usage_system=55.2088,usage_user=84.9371 3310000000000 +cpu,cpu=1 usage_idle=21.361,usage_system=72.5043,usage_user=1.8727 3311000000000 +cpu,cpu=2 usage_idle=27.1673,usage_system=62.7968,usage_user=13.4651 3312000000000 +cpu,cpu=3 usage_idle=97.5755,usage_system=24.9836,usage_user=58.3233 3313000000000 +cpu,cpu=4 usage_idle=0.532318,usage_system=16.4197,usage_user=21.7816 3314000000000 +cpu,cpu=0 usage_idle=94.1029,usage_system=67.2485,usage_user=15.1136 3315000000000 +cpu,cpu=1 usage_idle=1.10657,usage_system=41.2444,usage_user=78.1376 3316000000000 +cpu,cpu=2 usage_idle=22.1054,usage_system=30.1201,usage_user=35.1202 3317000000000 +cpu,cpu=3 usage_idle=77.5345,usage_system=40.344,usage_user=71.725 3318000000000 +cpu,cpu=4 usage_idle=97.3017,usage_system=34.2337,usage_user=15.5497 3319000000000 +cpu,cpu=0 usage_idle=72.7696,usage_system=2.25934,usage_user=70.7585 3320000000000 +cpu,cpu=1 usage_idle=57.7068,usage_system=23.6203,usage_user=43.2628 3321000000000 +cpu,cpu=2 usage_idle=59.5795,usage_system=50.7876,usage_user=6.05962 3322000000000 +cpu,cpu=3 usage_idle=73.0446,usage_system=48.3631,usage_user=31.0432 3323000000000 +cpu,cpu=4 usage_idle=31.3679,usage_system=48.8954,usage_user=47.4629 3324000000000 +cpu,cpu=0 usage_idle=53.1495,usage_system=42.9983,usage_user=14.7114 3325000000000 +cpu,cpu=1 usage_idle=68.2631,usage_system=44.1049,usage_user=55.9558 3326000000000 +cpu,cpu=2 usage_idle=46.4007,usage_system=66.2103,usage_user=86.0759 3327000000000 +cpu,cpu=3 usage_idle=81.5209,usage_system=43.7449,usage_user=26.4199 3328000000000 +cpu,cpu=4 usage_idle=53.2459,usage_system=41.0466,usage_user=60.6536 3329000000000 +cpu,cpu=0 usage_idle=68.7956,usage_system=13.8162,usage_user=62.9129 3330000000000 +cpu,cpu=1 usage_idle=39.5541,usage_system=71.523,usage_user=86.5333 3331000000000 +cpu,cpu=2 usage_idle=82.8169,usage_system=31.1025,usage_user=37.3209 3332000000000 +cpu,cpu=3 usage_idle=88.8766,usage_system=4.14706,usage_user=85.6839 3333000000000 +cpu,cpu=4 usage_idle=19.9198,usage_system=35.5149,usage_user=34.5793 3334000000000 +cpu,cpu=0 usage_idle=67.3827,usage_system=88.6644,usage_user=77.5776 3335000000000 +cpu,cpu=1 usage_idle=82.0941,usage_system=56.9276,usage_user=21.6825 3336000000000 +cpu,cpu=2 usage_idle=38.0499,usage_system=3.32826,usage_user=87.8929 3337000000000 +cpu,cpu=3 usage_idle=24.1258,usage_system=84.8492,usage_user=31.6377 3338000000000 +cpu,cpu=4 usage_idle=50.5457,usage_system=38.0951,usage_user=72.6843 3339000000000 +cpu,cpu=0 usage_idle=11.1993,usage_system=6.89077,usage_user=86.5005 3340000000000 +cpu,cpu=1 usage_idle=74.1122,usage_system=46.4449,usage_user=58.0235 3341000000000 +cpu,cpu=2 usage_idle=60.6455,usage_system=29.2618,usage_user=89.126 3342000000000 +cpu,cpu=3 usage_idle=97.9663,usage_system=18.1384,usage_user=93.273 3343000000000 +cpu,cpu=4 usage_idle=83.6502,usage_system=38.0581,usage_user=28.788 3344000000000 +cpu,cpu=0 usage_idle=18.2296,usage_system=5.44081,usage_user=17.4524 3345000000000 +cpu,cpu=1 usage_idle=95.8072,usage_system=87.5349,usage_user=74.38 3346000000000 +cpu,cpu=2 usage_idle=17.4897,usage_system=25.5848,usage_user=77.7082 3347000000000 +cpu,cpu=3 usage_idle=5.38262,usage_system=49.7105,usage_user=62.5574 3348000000000 +cpu,cpu=4 usage_idle=37.0203,usage_system=0.256172,usage_user=0.652534 3349000000000 +cpu,cpu=0 usage_idle=9.70464,usage_system=11.4554,usage_user=7.5433 3350000000000 +cpu,cpu=1 usage_idle=96.2052,usage_system=85.5676,usage_user=53.9882 3351000000000 +cpu,cpu=2 usage_idle=54.2287,usage_system=46.2131,usage_user=83.25 3352000000000 +cpu,cpu=3 usage_idle=43.3546,usage_system=44.1794,usage_user=1.38836 3353000000000 +cpu,cpu=4 usage_idle=36.6277,usage_system=27.8296,usage_user=39.4465 3354000000000 +cpu,cpu=0 usage_idle=65.4157,usage_system=46.0592,usage_user=44.8873 3355000000000 +cpu,cpu=1 usage_idle=82.8681,usage_system=41.8664,usage_user=32.4222 3356000000000 +cpu,cpu=2 usage_idle=57.248,usage_system=59.3561,usage_user=58.007 3357000000000 +cpu,cpu=3 usage_idle=34.9563,usage_system=64.7388,usage_user=7.71747 3358000000000 +cpu,cpu=4 usage_idle=97.5137,usage_system=1.75909,usage_user=7.97364 3359000000000 +cpu,cpu=0 usage_idle=98.1662,usage_system=11.4637,usage_user=19.4291 3360000000000 +cpu,cpu=1 usage_idle=5.70952,usage_system=7.66888,usage_user=4.99668 3361000000000 +cpu,cpu=2 usage_idle=59.6977,usage_system=61.8976,usage_user=51.2097 3362000000000 +cpu,cpu=3 usage_idle=42.9477,usage_system=5.25219,usage_user=95.3891 3363000000000 +cpu,cpu=4 usage_idle=44.3361,usage_system=41.8799,usage_user=23.2187 3364000000000 +cpu,cpu=0 usage_idle=83.7826,usage_system=7.29553,usage_user=69.2779 3365000000000 +cpu,cpu=1 usage_idle=28.6699,usage_system=90.1636,usage_user=11.1443 3366000000000 +cpu,cpu=2 usage_idle=61.0921,usage_system=47.4117,usage_user=70.5004 3367000000000 +cpu,cpu=3 usage_idle=19.099,usage_system=82.3679,usage_user=35.2392 3368000000000 +cpu,cpu=4 usage_idle=26.8165,usage_system=79.8816,usage_user=36.9983 3369000000000 +cpu,cpu=0 usage_idle=34.7902,usage_system=78.0478,usage_user=48.462 3370000000000 +cpu,cpu=1 usage_idle=54.2192,usage_system=83.7573,usage_user=56.1309 3371000000000 +cpu,cpu=2 usage_idle=59.2159,usage_system=43.4551,usage_user=18.0285 3372000000000 +cpu,cpu=3 usage_idle=10.4256,usage_system=86.4028,usage_user=23.2806 3373000000000 +cpu,cpu=4 usage_idle=5.81475,usage_system=30.7388,usage_user=65.1605 3374000000000 +cpu,cpu=0 usage_idle=29.0335,usage_system=14.5214,usage_user=72.456 3375000000000 +cpu,cpu=1 usage_idle=98.3114,usage_system=43.1913,usage_user=62.6196 3376000000000 +cpu,cpu=2 usage_idle=9.45568,usage_system=4.28336,usage_user=10.0313 3377000000000 +cpu,cpu=3 usage_idle=79.9561,usage_system=23.3824,usage_user=92.3992 3378000000000 +cpu,cpu=4 usage_idle=15.1953,usage_system=50.1989,usage_user=72.2808 3379000000000 +cpu,cpu=0 usage_idle=52.1936,usage_system=84.9891,usage_user=50.3287 3380000000000 +cpu,cpu=1 usage_idle=0.65561,usage_system=39.2083,usage_user=34.086 3381000000000 +cpu,cpu=2 usage_idle=56.7865,usage_system=98.4242,usage_user=77.5411 3382000000000 +cpu,cpu=3 usage_idle=74.815,usage_system=8.84986,usage_user=63.9438 3383000000000 +cpu,cpu=4 usage_idle=98.0956,usage_system=14.6646,usage_user=94.6827 3384000000000 +cpu,cpu=0 usage_idle=63.2561,usage_system=43.6981,usage_user=9.20406 3385000000000 +cpu,cpu=1 usage_idle=35.7121,usage_system=42.0095,usage_user=52.3953 3386000000000 +cpu,cpu=2 usage_idle=98.3318,usage_system=51.4652,usage_user=56.6787 3387000000000 +cpu,cpu=3 usage_idle=8.36309,usage_system=31.4213,usage_user=80.0611 3388000000000 +cpu,cpu=4 usage_idle=0.76232,usage_system=46.6166,usage_user=30.26 3389000000000 +cpu,cpu=0 usage_idle=73.0432,usage_system=98.8102,usage_user=15.2491 3390000000000 +cpu,cpu=1 usage_idle=23.3718,usage_system=99.4658,usage_user=54.4574 3391000000000 +cpu,cpu=2 usage_idle=57.4578,usage_system=56.2523,usage_user=52.8817 3392000000000 +cpu,cpu=3 usage_idle=34.9989,usage_system=31.0673,usage_user=61.7315 3393000000000 +cpu,cpu=4 usage_idle=98.9427,usage_system=29.1629,usage_user=76.3961 3394000000000 +cpu,cpu=0 usage_idle=93.6254,usage_system=92.419,usage_user=20.0942 3395000000000 +cpu,cpu=1 usage_idle=2.82944,usage_system=28.1311,usage_user=62.1037 3396000000000 +cpu,cpu=2 usage_idle=55.2248,usage_system=26.4629,usage_user=13.5689 3397000000000 +cpu,cpu=3 usage_idle=11.9035,usage_system=34.826,usage_user=44.9901 3398000000000 +cpu,cpu=4 usage_idle=91.9646,usage_system=35.5883,usage_user=91.6067 3399000000000 +cpu,cpu=0 usage_idle=22.2246,usage_system=8.6315,usage_user=90.4169 3400000000000 +cpu,cpu=1 usage_idle=37.4738,usage_system=32.0033,usage_user=89.8827 3401000000000 +cpu,cpu=2 usage_idle=91.9312,usage_system=89.4612,usage_user=46.135 3402000000000 +cpu,cpu=3 usage_idle=44.8129,usage_system=24.46,usage_user=77.2023 3403000000000 +cpu,cpu=4 usage_idle=6.54438,usage_system=23.4028,usage_user=6.36517 3404000000000 +cpu,cpu=0 usage_idle=82.9405,usage_system=17.0282,usage_user=98.7842 3405000000000 +cpu,cpu=1 usage_idle=3.03472,usage_system=19.8576,usage_user=26.9153 3406000000000 +cpu,cpu=2 usage_idle=65.1384,usage_system=75.0824,usage_user=53.3782 3407000000000 +cpu,cpu=3 usage_idle=78.7073,usage_system=86.9859,usage_user=88.2042 3408000000000 +cpu,cpu=4 usage_idle=23.6974,usage_system=78.9505,usage_user=23.7926 3409000000000 +cpu,cpu=0 usage_idle=15.3042,usage_system=1.17514,usage_user=32.4241 3410000000000 +cpu,cpu=1 usage_idle=5.72109,usage_system=38.6489,usage_user=64.4274 3411000000000 +cpu,cpu=2 usage_idle=95.6038,usage_system=30.5801,usage_user=53.8885 3412000000000 +cpu,cpu=3 usage_idle=41.7388,usage_system=75.393,usage_user=78.3486 3413000000000 +cpu,cpu=4 usage_idle=18.9411,usage_system=81.9374,usage_user=1.75134 3414000000000 +cpu,cpu=0 usage_idle=25.3063,usage_system=64.8779,usage_user=18.7795 3415000000000 +cpu,cpu=1 usage_idle=24.0905,usage_system=67.9126,usage_user=38.6371 3416000000000 +cpu,cpu=2 usage_idle=51.0057,usage_system=33.051,usage_user=13.7195 3417000000000 +cpu,cpu=3 usage_idle=4.38394,usage_system=11.7583,usage_user=0.705367 3418000000000 +cpu,cpu=4 usage_idle=92.5882,usage_system=35.4557,usage_user=79.6559 3419000000000 +cpu,cpu=0 usage_idle=16.3807,usage_system=50.7599,usage_user=80.831 3420000000000 +cpu,cpu=1 usage_idle=48.8048,usage_system=56.481,usage_user=19.4799 3421000000000 +cpu,cpu=2 usage_idle=13.2322,usage_system=52.0848,usage_user=50.06 3422000000000 +cpu,cpu=3 usage_idle=67.1207,usage_system=93.8236,usage_user=25.453 3423000000000 +cpu,cpu=4 usage_idle=45.4693,usage_system=12.7648,usage_user=7.39036 3424000000000 +cpu,cpu=0 usage_idle=47.2206,usage_system=38.0711,usage_user=72.2682 3425000000000 +cpu,cpu=1 usage_idle=66.0001,usage_system=62.1615,usage_user=40.1808 3426000000000 +cpu,cpu=2 usage_idle=4.63719,usage_system=13.1673,usage_user=73.2318 3427000000000 +cpu,cpu=3 usage_idle=18.3567,usage_system=17.5512,usage_user=84.9901 3428000000000 +cpu,cpu=4 usage_idle=19.062,usage_system=10.1394,usage_user=20.4458 3429000000000 +cpu,cpu=0 usage_idle=98.7179,usage_system=26.5201,usage_user=71.2057 3430000000000 +cpu,cpu=1 usage_idle=79.5489,usage_system=75.3249,usage_user=27.6867 3431000000000 +cpu,cpu=2 usage_idle=99.0288,usage_system=88.5571,usage_user=79.7715 3432000000000 +cpu,cpu=3 usage_idle=49.0888,usage_system=55.6777,usage_user=73.5951 3433000000000 +cpu,cpu=4 usage_idle=74.5418,usage_system=1.14699,usage_user=86.3599 3434000000000 +cpu,cpu=0 usage_idle=81.9322,usage_system=48.3676,usage_user=24.431 3435000000000 +cpu,cpu=1 usage_idle=54.2004,usage_system=14.3677,usage_user=86.5926 3436000000000 +cpu,cpu=2 usage_idle=94.3812,usage_system=19.0049,usage_user=99.7598 3437000000000 +cpu,cpu=3 usage_idle=67.613,usage_system=37.3616,usage_user=17.3111 3438000000000 +cpu,cpu=4 usage_idle=52.6031,usage_system=56.4236,usage_user=27.4505 3439000000000 +cpu,cpu=0 usage_idle=73.0489,usage_system=55.1415,usage_user=53.9706 3440000000000 +cpu,cpu=1 usage_idle=44.2547,usage_system=34.6904,usage_user=29.2955 3441000000000 +cpu,cpu=2 usage_idle=71.9414,usage_system=33.7192,usage_user=17.8526 3442000000000 +cpu,cpu=3 usage_idle=51.7129,usage_system=82.808,usage_user=73.5303 3443000000000 +cpu,cpu=4 usage_idle=25.308,usage_system=57.3499,usage_user=74.6773 3444000000000 +cpu,cpu=0 usage_idle=11.6679,usage_system=39.282,usage_user=23.0449 3445000000000 +cpu,cpu=1 usage_idle=36.0989,usage_system=93.4824,usage_user=37.4126 3446000000000 +cpu,cpu=2 usage_idle=22.6915,usage_system=87.8636,usage_user=56.4174 3447000000000 +cpu,cpu=3 usage_idle=22.4513,usage_system=55.4766,usage_user=93.779 3448000000000 +cpu,cpu=4 usage_idle=39.7624,usage_system=8.07974,usage_user=50.2026 3449000000000 +cpu,cpu=0 usage_idle=67.2129,usage_system=81.1287,usage_user=5.34412 3450000000000 +cpu,cpu=1 usage_idle=21.1834,usage_system=25.3833,usage_user=40.0345 3451000000000 +cpu,cpu=2 usage_idle=50.4789,usage_system=97.3247,usage_user=73.7537 3452000000000 +cpu,cpu=3 usage_idle=68.3315,usage_system=49.0376,usage_user=56.5618 3453000000000 +cpu,cpu=4 usage_idle=41.8618,usage_system=74.3456,usage_user=13.9116 3454000000000 +cpu,cpu=0 usage_idle=16.5391,usage_system=86.0135,usage_user=53.1936 3455000000000 +cpu,cpu=1 usage_idle=39.584,usage_system=22.1124,usage_user=46.6761 3456000000000 +cpu,cpu=2 usage_idle=76.9966,usage_system=44.8039,usage_user=34.5397 3457000000000 +cpu,cpu=3 usage_idle=33.414,usage_system=67.2552,usage_user=90.0163 3458000000000 +cpu,cpu=4 usage_idle=27.193,usage_system=7.01761,usage_user=98.0961 3459000000000 +cpu,cpu=0 usage_idle=77.3956,usage_system=74.2305,usage_user=79.2247 3460000000000 +cpu,cpu=1 usage_idle=82.7397,usage_system=95.4139,usage_user=4.60808 3461000000000 +cpu,cpu=2 usage_idle=22.7743,usage_system=45.8929,usage_user=1.93278 3462000000000 +cpu,cpu=3 usage_idle=96.528,usage_system=14.2244,usage_user=50.9703 3463000000000 +cpu,cpu=4 usage_idle=53.0898,usage_system=56.0862,usage_user=25.3159 3464000000000 +cpu,cpu=0 usage_idle=67.0014,usage_system=72.6253,usage_user=11.3294 3465000000000 +cpu,cpu=1 usage_idle=20.195,usage_system=12.2093,usage_user=33.4418 3466000000000 +cpu,cpu=2 usage_idle=66.8711,usage_system=89.2059,usage_user=78.2457 3467000000000 +cpu,cpu=3 usage_idle=1.41077,usage_system=22.6199,usage_user=45.5009 3468000000000 +cpu,cpu=4 usage_idle=91.4271,usage_system=49.8129,usage_user=52.5185 3469000000000 +cpu,cpu=0 usage_idle=89.5232,usage_system=27.2085,usage_user=26.749 3470000000000 +cpu,cpu=1 usage_idle=68.7479,usage_system=9.94829,usage_user=22.1629 3471000000000 +cpu,cpu=2 usage_idle=73.356,usage_system=32.7226,usage_user=68.0558 3472000000000 +cpu,cpu=3 usage_idle=75.2888,usage_system=29.2506,usage_user=82.2802 3473000000000 +cpu,cpu=4 usage_idle=26.2591,usage_system=82.3403,usage_user=38.3663 3474000000000 +cpu,cpu=0 usage_idle=51.575,usage_system=49.3417,usage_user=10.9916 3475000000000 +cpu,cpu=1 usage_idle=62.9044,usage_system=69.5367,usage_user=23.2009 3476000000000 +cpu,cpu=2 usage_idle=96.3463,usage_system=36.4078,usage_user=12.4068 3477000000000 +cpu,cpu=3 usage_idle=74.592,usage_system=37.8185,usage_user=35.0267 3478000000000 +cpu,cpu=4 usage_idle=20.0929,usage_system=29.2456,usage_user=84.8396 3479000000000 +cpu,cpu=0 usage_idle=72.6115,usage_system=18.7688,usage_user=12.0481 3480000000000 +cpu,cpu=1 usage_idle=99.3605,usage_system=87.5167,usage_user=21.9964 3481000000000 +cpu,cpu=2 usage_idle=21.5234,usage_system=60.8727,usage_user=54.719 3482000000000 +cpu,cpu=3 usage_idle=89.5792,usage_system=36.1615,usage_user=83.9695 3483000000000 +cpu,cpu=4 usage_idle=71.8593,usage_system=62.4206,usage_user=66.3099 3484000000000 +cpu,cpu=0 usage_idle=10.2257,usage_system=13.9957,usage_user=15.6515 3485000000000 +cpu,cpu=1 usage_idle=21.2173,usage_system=76.9001,usage_user=85.1882 3486000000000 +cpu,cpu=2 usage_idle=44.4182,usage_system=73.2464,usage_user=21.596 3487000000000 +cpu,cpu=3 usage_idle=56.825,usage_system=47.8384,usage_user=59.4146 3488000000000 +cpu,cpu=4 usage_idle=91.8517,usage_system=67.9313,usage_user=88.6602 3489000000000 +cpu,cpu=0 usage_idle=76.6913,usage_system=40.5427,usage_user=7.42902 3490000000000 +cpu,cpu=1 usage_idle=88.7395,usage_system=39.9032,usage_user=94.9458 3491000000000 +cpu,cpu=2 usage_idle=10.7359,usage_system=61.4266,usage_user=55.8185 3492000000000 +cpu,cpu=3 usage_idle=65.4549,usage_system=51.0058,usage_user=91.98 3493000000000 +cpu,cpu=4 usage_idle=49.4245,usage_system=22.8651,usage_user=54.4006 3494000000000 +cpu,cpu=0 usage_idle=15.7343,usage_system=33.0907,usage_user=68.3963 3495000000000 +cpu,cpu=1 usage_idle=31.3859,usage_system=54.308,usage_user=45.2964 3496000000000 +cpu,cpu=2 usage_idle=16.5741,usage_system=98.7262,usage_user=18.5428 3497000000000 +cpu,cpu=3 usage_idle=38.1701,usage_system=55.5513,usage_user=66.3812 3498000000000 +cpu,cpu=4 usage_idle=97.5847,usage_system=47.403,usage_user=34.3125 3499000000000 +cpu,cpu=0 usage_idle=86.2449,usage_system=24.0944,usage_user=74.8552 3500000000000 +cpu,cpu=1 usage_idle=93.6739,usage_system=12.8338,usage_user=14.7584 3501000000000 +cpu,cpu=2 usage_idle=88.6196,usage_system=23.5698,usage_user=76.185 3502000000000 +cpu,cpu=3 usage_idle=44.4381,usage_system=89.0247,usage_user=27.1907 3503000000000 +cpu,cpu=4 usage_idle=36.4181,usage_system=38.4491,usage_user=50.0558 3504000000000 +cpu,cpu=0 usage_idle=90.8188,usage_system=54.1835,usage_user=83.1465 3505000000000 +cpu,cpu=1 usage_idle=59.2151,usage_system=85.5693,usage_user=37.4545 3506000000000 +cpu,cpu=2 usage_idle=4.51153,usage_system=2.14342,usage_user=36.1808 3507000000000 +cpu,cpu=3 usage_idle=23.0544,usage_system=40.3135,usage_user=91.732 3508000000000 +cpu,cpu=4 usage_idle=89.4355,usage_system=37.8982,usage_user=39.1351 3509000000000 +cpu,cpu=0 usage_idle=23.748,usage_system=24.1431,usage_user=63.2294 3510000000000 +cpu,cpu=1 usage_idle=98.6032,usage_system=17.8169,usage_user=76.0633 3511000000000 +cpu,cpu=2 usage_idle=13.3615,usage_system=6.43659,usage_user=99.633 3512000000000 +cpu,cpu=3 usage_idle=89.5465,usage_system=50.8747,usage_user=88.6577 3513000000000 +cpu,cpu=4 usage_idle=16.7372,usage_system=87.2928,usage_user=27.1069 3514000000000 +cpu,cpu=0 usage_idle=66.793,usage_system=78.1116,usage_user=81.2903 3515000000000 +cpu,cpu=1 usage_idle=49.9395,usage_system=37.3267,usage_user=66.8597 3516000000000 +cpu,cpu=2 usage_idle=87.394,usage_system=41.8382,usage_user=69.0031 3517000000000 +cpu,cpu=3 usage_idle=23.5748,usage_system=64.8925,usage_user=9.31661 3518000000000 +cpu,cpu=4 usage_idle=15.3068,usage_system=54.3281,usage_user=47.2148 3519000000000 +cpu,cpu=0 usage_idle=54.4419,usage_system=78.0761,usage_user=71.3579 3520000000000 +cpu,cpu=1 usage_idle=17.6713,usage_system=76.6792,usage_user=89.1748 3521000000000 +cpu,cpu=2 usage_idle=93.7345,usage_system=90.0408,usage_user=95.6114 3522000000000 +cpu,cpu=3 usage_idle=93.3676,usage_system=79.5873,usage_user=46.4861 3523000000000 +cpu,cpu=4 usage_idle=82.0253,usage_system=96.3245,usage_user=33.7789 3524000000000 +cpu,cpu=0 usage_idle=9.13219,usage_system=63.1174,usage_user=11.8905 3525000000000 +cpu,cpu=1 usage_idle=90.4225,usage_system=13.0569,usage_user=49.2172 3526000000000 +cpu,cpu=2 usage_idle=57.2822,usage_system=0.450908,usage_user=91.0554 3527000000000 +cpu,cpu=3 usage_idle=26.2853,usage_system=24.0257,usage_user=55.9479 3528000000000 +cpu,cpu=4 usage_idle=35.6019,usage_system=39.3325,usage_user=10.276 3529000000000 +cpu,cpu=0 usage_idle=82.8167,usage_system=93.7743,usage_user=88.352 3530000000000 +cpu,cpu=1 usage_idle=54.1746,usage_system=11.4456,usage_user=65.0313 3531000000000 +cpu,cpu=2 usage_idle=43.3494,usage_system=5.18016,usage_user=55.0721 3532000000000 +cpu,cpu=3 usage_idle=38.9608,usage_system=98.5477,usage_user=34.6594 3533000000000 +cpu,cpu=4 usage_idle=85.4469,usage_system=80.5731,usage_user=30.9838 3534000000000 +cpu,cpu=0 usage_idle=19.2258,usage_system=89.7052,usage_user=94.1013 3535000000000 +cpu,cpu=1 usage_idle=31.1163,usage_system=80.1278,usage_user=7.15819 3536000000000 +cpu,cpu=2 usage_idle=80.3335,usage_system=37.41,usage_user=7.6091 3537000000000 +cpu,cpu=3 usage_idle=71.3889,usage_system=63.6953,usage_user=31.6348 3538000000000 +cpu,cpu=4 usage_idle=27.3368,usage_system=99.2972,usage_user=70.9672 3539000000000 +cpu,cpu=0 usage_idle=37.6127,usage_system=82.1139,usage_user=64.7416 3540000000000 +cpu,cpu=1 usage_idle=25.9648,usage_system=36.2885,usage_user=76.1872 3541000000000 +cpu,cpu=2 usage_idle=90.9961,usage_system=79.6378,usage_user=81.3673 3542000000000 +cpu,cpu=3 usage_idle=46.0682,usage_system=18.5986,usage_user=79.9151 3543000000000 +cpu,cpu=4 usage_idle=80.7275,usage_system=4.0455,usage_user=60.4881 3544000000000 +cpu,cpu=0 usage_idle=11.7113,usage_system=23.2713,usage_user=50.1934 3545000000000 +cpu,cpu=1 usage_idle=5.8126,usage_system=54.3876,usage_user=30.3211 3546000000000 +cpu,cpu=2 usage_idle=12.9708,usage_system=34.7211,usage_user=67.7311 3547000000000 +cpu,cpu=3 usage_idle=20.5799,usage_system=6.10999,usage_user=31.4264 3548000000000 +cpu,cpu=4 usage_idle=52.2147,usage_system=33.4468,usage_user=30.7236 3549000000000 +cpu,cpu=0 usage_idle=23.1819,usage_system=71.0595,usage_user=12.8375 3550000000000 +cpu,cpu=1 usage_idle=87.9234,usage_system=97.0243,usage_user=49.1259 3551000000000 +cpu,cpu=2 usage_idle=64.1106,usage_system=88.0204,usage_user=28.7638 3552000000000 +cpu,cpu=3 usage_idle=45.4779,usage_system=34.0885,usage_user=47.3624 3553000000000 +cpu,cpu=4 usage_idle=25.393,usage_system=14.816,usage_user=51.4079 3554000000000 +cpu,cpu=0 usage_idle=85.8811,usage_system=26.5274,usage_user=74.6792 3555000000000 +cpu,cpu=1 usage_idle=36.0745,usage_system=32.34,usage_user=29.0668 3556000000000 +cpu,cpu=2 usage_idle=66.3956,usage_system=45.3108,usage_user=63.788 3557000000000 +cpu,cpu=3 usage_idle=34.1268,usage_system=65.8907,usage_user=69.898 3558000000000 +cpu,cpu=4 usage_idle=65.5532,usage_system=18.1053,usage_user=3.34473 3559000000000 +cpu,cpu=0 usage_idle=96.2768,usage_system=41.2872,usage_user=74.4042 3560000000000 +cpu,cpu=1 usage_idle=9.11424,usage_system=29.2106,usage_user=71.4285 3561000000000 +cpu,cpu=2 usage_idle=58.2402,usage_system=93.3212,usage_user=59.4489 3562000000000 +cpu,cpu=3 usage_idle=87.004,usage_system=38.7992,usage_user=93.5374 3563000000000 +cpu,cpu=4 usage_idle=34.3664,usage_system=64.1922,usage_user=8.35347 3564000000000 +cpu,cpu=0 usage_idle=85.7743,usage_system=50.0733,usage_user=34.8808 3565000000000 +cpu,cpu=1 usage_idle=60.4535,usage_system=86.1478,usage_user=67.2208 3566000000000 +cpu,cpu=2 usage_idle=89.5204,usage_system=52.5434,usage_user=12.5316 3567000000000 +cpu,cpu=3 usage_idle=53.3083,usage_system=86.6701,usage_user=78.4222 3568000000000 +cpu,cpu=4 usage_idle=23.2063,usage_system=52.2233,usage_user=96.5275 3569000000000 +cpu,cpu=0 usage_idle=26.5511,usage_system=48.5,usage_user=37.8147 3570000000000 +cpu,cpu=1 usage_idle=0.955287,usage_system=57.6143,usage_user=67.0253 3571000000000 +cpu,cpu=2 usage_idle=72.3838,usage_system=15.8545,usage_user=60.3465 3572000000000 +cpu,cpu=3 usage_idle=31.8327,usage_system=2.85846,usage_user=99.1457 3573000000000 +cpu,cpu=4 usage_idle=25.3702,usage_system=37.2248,usage_user=63.3379 3574000000000 +cpu,cpu=0 usage_idle=33.7236,usage_system=22.9991,usage_user=13.4111 3575000000000 +cpu,cpu=1 usage_idle=68.6045,usage_system=83.4527,usage_user=99.5589 3576000000000 +cpu,cpu=2 usage_idle=35.8253,usage_system=72.973,usage_user=52.1023 3577000000000 +cpu,cpu=3 usage_idle=48.3568,usage_system=26.2814,usage_user=38.7724 3578000000000 +cpu,cpu=4 usage_idle=26.7791,usage_system=49.4877,usage_user=90.9957 3579000000000 +cpu,cpu=0 usage_idle=23.3066,usage_system=76.0387,usage_user=39.4957 3580000000000 +cpu,cpu=1 usage_idle=61.1213,usage_system=76.994,usage_user=97.11 3581000000000 +cpu,cpu=2 usage_idle=28.1466,usage_system=49.3778,usage_user=12.9645 3582000000000 +cpu,cpu=3 usage_idle=88.4931,usage_system=81.2106,usage_user=15.823 3583000000000 +cpu,cpu=4 usage_idle=87.6388,usage_system=6.58072,usage_user=53.0478 3584000000000 +cpu,cpu=0 usage_idle=50.9767,usage_system=40.3044,usage_user=76.047 3585000000000 +cpu,cpu=1 usage_idle=64.3878,usage_system=8.90881,usage_user=59.4996 3586000000000 +cpu,cpu=2 usage_idle=63.9467,usage_system=44.7341,usage_user=32.4726 3587000000000 +cpu,cpu=3 usage_idle=16.049,usage_system=93.0909,usage_user=58.754 3588000000000 +cpu,cpu=4 usage_idle=54.8214,usage_system=19.87,usage_user=8.2417 3589000000000 +cpu,cpu=0 usage_idle=45.817,usage_system=43.1766,usage_user=84.2804 3590000000000 +cpu,cpu=1 usage_idle=85.3128,usage_system=4.29784,usage_user=61.2745 3591000000000 +cpu,cpu=2 usage_idle=82.4228,usage_system=32.4444,usage_user=10.6523 3592000000000 +cpu,cpu=3 usage_idle=95.3873,usage_system=20.9376,usage_user=91.8629 3593000000000 +cpu,cpu=4 usage_idle=11.2103,usage_system=8.57643,usage_user=98.4436 3594000000000 +cpu,cpu=0 usage_idle=64.2581,usage_system=59.5531,usage_user=38.748 3595000000000 +cpu,cpu=1 usage_idle=40.305,usage_system=23.9409,usage_user=47.6568 3596000000000 +cpu,cpu=2 usage_idle=99.8046,usage_system=87.8876,usage_user=92.3909 3597000000000 +cpu,cpu=3 usage_idle=32.2773,usage_system=3.93661,usage_user=85.4818 3598000000000 +cpu,cpu=4 usage_idle=91.0313,usage_system=58.758,usage_user=5.35176 3599000000000 +cpu,cpu=0 usage_idle=99.273,usage_system=4.57501,usage_user=48.5283 3600000000000 +cpu,cpu=1 usage_idle=83.5534,usage_system=89.8878,usage_user=52.8262 3601000000000 +cpu,cpu=2 usage_idle=44.8279,usage_system=72.3106,usage_user=85.2706 3602000000000 +cpu,cpu=3 usage_idle=55.4802,usage_system=67.6979,usage_user=6.20819 3603000000000 +cpu,cpu=4 usage_idle=47.3431,usage_system=78.9082,usage_user=14.7846 3604000000000 +cpu,cpu=0 usage_idle=45.7867,usage_system=43.1662,usage_user=74.3377 3605000000000 +cpu,cpu=1 usage_idle=84.5347,usage_system=83.4712,usage_user=98.2787 3606000000000 +cpu,cpu=2 usage_idle=32.1915,usage_system=83.2759,usage_user=86.1663 3607000000000 +cpu,cpu=3 usage_idle=24.5823,usage_system=15.5532,usage_user=90.1029 3608000000000 +cpu,cpu=4 usage_idle=10.0641,usage_system=6.58444,usage_user=48.8609 3609000000000 +cpu,cpu=0 usage_idle=15.4159,usage_system=5.85743,usage_user=53.4359 3610000000000 +cpu,cpu=1 usage_idle=63.9442,usage_system=89.4109,usage_user=43.3237 3611000000000 +cpu,cpu=2 usage_idle=16.7704,usage_system=34.2388,usage_user=15.6343 3612000000000 +cpu,cpu=3 usage_idle=2.04096,usage_system=89.719,usage_user=83.3322 3613000000000 +cpu,cpu=4 usage_idle=8.24915,usage_system=37.0621,usage_user=62.2403 3614000000000 +cpu,cpu=0 usage_idle=23.0338,usage_system=82.8489,usage_user=5.40657 3615000000000 +cpu,cpu=1 usage_idle=97.3715,usage_system=67.3835,usage_user=88.8778 3616000000000 +cpu,cpu=2 usage_idle=95.6502,usage_system=99.575,usage_user=72.1537 3617000000000 +cpu,cpu=3 usage_idle=81.8165,usage_system=24.1573,usage_user=87.7068 3618000000000 +cpu,cpu=4 usage_idle=71.9195,usage_system=34.2214,usage_user=94.2913 3619000000000 +cpu,cpu=0 usage_idle=20.7804,usage_system=49.6373,usage_user=0.148724 3620000000000 +cpu,cpu=1 usage_idle=74.2163,usage_system=13.5815,usage_user=89.5596 3621000000000 +cpu,cpu=2 usage_idle=17.54,usage_system=30.3519,usage_user=23.7984 3622000000000 +cpu,cpu=3 usage_idle=33.1743,usage_system=32.3928,usage_user=13.5174 3623000000000 +cpu,cpu=4 usage_idle=16.5065,usage_system=40.642,usage_user=50.5795 3624000000000 +cpu,cpu=0 usage_idle=78.7469,usage_system=63.6757,usage_user=33.4283 3625000000000 +cpu,cpu=1 usage_idle=84.1534,usage_system=61.0473,usage_user=0.811888 3626000000000 +cpu,cpu=2 usage_idle=73.0313,usage_system=56.6975,usage_user=0.386893 3627000000000 +cpu,cpu=3 usage_idle=45.1849,usage_system=38.514,usage_user=24.5442 3628000000000 +cpu,cpu=4 usage_idle=32.8918,usage_system=10.4335,usage_user=58.7657 3629000000000 +cpu,cpu=0 usage_idle=27.1831,usage_system=31.2139,usage_user=8.40297 3630000000000 +cpu,cpu=1 usage_idle=27.3318,usage_system=5.43021,usage_user=21.9845 3631000000000 +cpu,cpu=2 usage_idle=16.8914,usage_system=22.9702,usage_user=52.3363 3632000000000 +cpu,cpu=3 usage_idle=40.6898,usage_system=56.1446,usage_user=84.7291 3633000000000 +cpu,cpu=4 usage_idle=54.2071,usage_system=72.6511,usage_user=25.3711 3634000000000 +cpu,cpu=0 usage_idle=4.78665,usage_system=51.398,usage_user=89.0469 3635000000000 +cpu,cpu=1 usage_idle=38.215,usage_system=35.5514,usage_user=50.0941 3636000000000 +cpu,cpu=2 usage_idle=39.0269,usage_system=8.58265,usage_user=6.79157 3637000000000 +cpu,cpu=3 usage_idle=39.4138,usage_system=53.7676,usage_user=45.3056 3638000000000 +cpu,cpu=4 usage_idle=63.958,usage_system=86.6594,usage_user=55.739 3639000000000 +cpu,cpu=0 usage_idle=22.7237,usage_system=13.8425,usage_user=86.9529 3640000000000 +cpu,cpu=1 usage_idle=31.1266,usage_system=41.1743,usage_user=92.3831 3641000000000 +cpu,cpu=2 usage_idle=53.1111,usage_system=58.0657,usage_user=15.3534 3642000000000 +cpu,cpu=3 usage_idle=5.44741,usage_system=98.7555,usage_user=71.4979 3643000000000 +cpu,cpu=4 usage_idle=90.1766,usage_system=52.9626,usage_user=44.149 3644000000000 +cpu,cpu=0 usage_idle=15.5477,usage_system=57.7493,usage_user=95.547 3645000000000 +cpu,cpu=1 usage_idle=4.59453,usage_system=95.9643,usage_user=31.0984 3646000000000 +cpu,cpu=2 usage_idle=54.6886,usage_system=34.9912,usage_user=39.6811 3647000000000 +cpu,cpu=3 usage_idle=61.4802,usage_system=74.4049,usage_user=93.4487 3648000000000 +cpu,cpu=4 usage_idle=6.78576,usage_system=38.3629,usage_user=80.1081 3649000000000 +cpu,cpu=0 usage_idle=62.5248,usage_system=61.0866,usage_user=93.9506 3650000000000 +cpu,cpu=1 usage_idle=49.4777,usage_system=92.2132,usage_user=35.1249 3651000000000 +cpu,cpu=2 usage_idle=41.8609,usage_system=45.3243,usage_user=93.1906 3652000000000 +cpu,cpu=3 usage_idle=57.2142,usage_system=50.7717,usage_user=91.9461 3653000000000 +cpu,cpu=4 usage_idle=28.7122,usage_system=40.9483,usage_user=44.9087 3654000000000 +cpu,cpu=0 usage_idle=72.8612,usage_system=56.4959,usage_user=2.65797 3655000000000 +cpu,cpu=1 usage_idle=68.4082,usage_system=61.0905,usage_user=98.6222 3656000000000 +cpu,cpu=2 usage_idle=99.5066,usage_system=15.7791,usage_user=33.6134 3657000000000 +cpu,cpu=3 usage_idle=39.1877,usage_system=77.2593,usage_user=8.01833 3658000000000 +cpu,cpu=4 usage_idle=32.6363,usage_system=84.0451,usage_user=46.3813 3659000000000 +cpu,cpu=0 usage_idle=12.7444,usage_system=46.5699,usage_user=7.46784 3660000000000 +cpu,cpu=1 usage_idle=6.69493,usage_system=96.0476,usage_user=99.681 3661000000000 +cpu,cpu=2 usage_idle=41.8198,usage_system=37.9085,usage_user=45.0053 3662000000000 +cpu,cpu=3 usage_idle=35.0104,usage_system=95.1227,usage_user=95.777 3663000000000 +cpu,cpu=4 usage_idle=26.9564,usage_system=23.8349,usage_user=36.7253 3664000000000 +cpu,cpu=0 usage_idle=71.8651,usage_system=96.6961,usage_user=93.2212 3665000000000 +cpu,cpu=1 usage_idle=74.5231,usage_system=65.1043,usage_user=54.3117 3666000000000 +cpu,cpu=2 usage_idle=73.1453,usage_system=64.6109,usage_user=70.0908 3667000000000 +cpu,cpu=3 usage_idle=6.75874,usage_system=3.79858,usage_user=47.3501 3668000000000 +cpu,cpu=4 usage_idle=14.7771,usage_system=36.4349,usage_user=31.3952 3669000000000 +cpu,cpu=0 usage_idle=61.1583,usage_system=49.1793,usage_user=77.965 3670000000000 +cpu,cpu=1 usage_idle=68.6262,usage_system=55.8742,usage_user=74.0127 3671000000000 +cpu,cpu=2 usage_idle=68.3072,usage_system=97.694,usage_user=11.9211 3672000000000 +cpu,cpu=3 usage_idle=13.3125,usage_system=32.7043,usage_user=7.04382 3673000000000 +cpu,cpu=4 usage_idle=9.08957,usage_system=59.6608,usage_user=30.8787 3674000000000 +cpu,cpu=0 usage_idle=45.8149,usage_system=31.5259,usage_user=27.5748 3675000000000 +cpu,cpu=1 usage_idle=39.0361,usage_system=6.04896,usage_user=92.6791 3676000000000 +cpu,cpu=2 usage_idle=93.3478,usage_system=79.1943,usage_user=57.29 3677000000000 +cpu,cpu=3 usage_idle=63.4385,usage_system=85.953,usage_user=61.0886 3678000000000 +cpu,cpu=4 usage_idle=10.7886,usage_system=0.730106,usage_user=97.5235 3679000000000 +cpu,cpu=0 usage_idle=42.1838,usage_system=61.8884,usage_user=46.7028 3680000000000 +cpu,cpu=1 usage_idle=20.1488,usage_system=30.5146,usage_user=2.57696 3681000000000 +cpu,cpu=2 usage_idle=94.1615,usage_system=98.8218,usage_user=0.270948 3682000000000 +cpu,cpu=3 usage_idle=6.08261,usage_system=12.1344,usage_user=32.9753 3683000000000 +cpu,cpu=4 usage_idle=13.1264,usage_system=21.2239,usage_user=92.6361 3684000000000 +cpu,cpu=0 usage_idle=44.0051,usage_system=67.0388,usage_user=24.1619 3685000000000 +cpu,cpu=1 usage_idle=71.5799,usage_system=6.07487,usage_user=30.2109 3686000000000 +cpu,cpu=2 usage_idle=64.259,usage_system=99.4226,usage_user=9.40519 3687000000000 +cpu,cpu=3 usage_idle=21.549,usage_system=62.8612,usage_user=95.3582 3688000000000 +cpu,cpu=4 usage_idle=82.6376,usage_system=73.6498,usage_user=96.0883 3689000000000 +cpu,cpu=0 usage_idle=80.1611,usage_system=15.8336,usage_user=57.9768 3690000000000 +cpu,cpu=1 usage_idle=26.8639,usage_system=35.9825,usage_user=88.4914 3691000000000 +cpu,cpu=2 usage_idle=29.4408,usage_system=30.144,usage_user=87.3132 3692000000000 +cpu,cpu=3 usage_idle=29.7118,usage_system=36.2266,usage_user=99.4475 3693000000000 +cpu,cpu=4 usage_idle=62.6871,usage_system=49.353,usage_user=20.6715 3694000000000 +cpu,cpu=0 usage_idle=55.3231,usage_system=93.3581,usage_user=87.7103 3695000000000 +cpu,cpu=1 usage_idle=79.4851,usage_system=64.938,usage_user=93.7851 3696000000000 +cpu,cpu=2 usage_idle=9.69595,usage_system=29.197,usage_user=93.2077 3697000000000 +cpu,cpu=3 usage_idle=19.1011,usage_system=50.7461,usage_user=56.0689 3698000000000 +cpu,cpu=4 usage_idle=14.4594,usage_system=33.3837,usage_user=29.7187 3699000000000 +cpu,cpu=0 usage_idle=10.5477,usage_system=13.5448,usage_user=45.5523 3700000000000 +cpu,cpu=1 usage_idle=68.5245,usage_system=40.4086,usage_user=81.5348 3701000000000 +cpu,cpu=2 usage_idle=57.0158,usage_system=69.8495,usage_user=11.6787 3702000000000 +cpu,cpu=3 usage_idle=44.329,usage_system=99.5612,usage_user=47.9053 3703000000000 +cpu,cpu=4 usage_idle=43.7766,usage_system=62.2483,usage_user=97.2583 3704000000000 +cpu,cpu=0 usage_idle=64.448,usage_system=17.5714,usage_user=90.6164 3705000000000 +cpu,cpu=1 usage_idle=52.1583,usage_system=97.0565,usage_user=55.5545 3706000000000 +cpu,cpu=2 usage_idle=45.9434,usage_system=6.75243,usage_user=84.7515 3707000000000 +cpu,cpu=3 usage_idle=39.1512,usage_system=25.8536,usage_user=35.4976 3708000000000 +cpu,cpu=4 usage_idle=95.2201,usage_system=40.3129,usage_user=68.8813 3709000000000 +cpu,cpu=0 usage_idle=24.9388,usage_system=50.8607,usage_user=82.4261 3710000000000 +cpu,cpu=1 usage_idle=70.4911,usage_system=19.3851,usage_user=22.8347 3711000000000 +cpu,cpu=2 usage_idle=52.0259,usage_system=76.401,usage_user=92.6842 3712000000000 +cpu,cpu=3 usage_idle=63.7047,usage_system=20.73,usage_user=92.2454 3713000000000 +cpu,cpu=4 usage_idle=11.61,usage_system=64.5066,usage_user=54.4937 3714000000000 +cpu,cpu=0 usage_idle=8.86831,usage_system=28.9546,usage_user=72.0651 3715000000000 +cpu,cpu=1 usage_idle=99.4847,usage_system=81.1129,usage_user=69.1216 3716000000000 +cpu,cpu=2 usage_idle=55.0392,usage_system=27.0563,usage_user=75.874 3717000000000 +cpu,cpu=3 usage_idle=39.7907,usage_system=66.2075,usage_user=1.72761 3718000000000 +cpu,cpu=4 usage_idle=75.2883,usage_system=61.4276,usage_user=42.0406 3719000000000 +cpu,cpu=0 usage_idle=44.1696,usage_system=86.3664,usage_user=92.9012 3720000000000 +cpu,cpu=1 usage_idle=26.5957,usage_system=56.8575,usage_user=12.2864 3721000000000 +cpu,cpu=2 usage_idle=49.4304,usage_system=8.88345,usage_user=88.6873 3722000000000 +cpu,cpu=3 usage_idle=42.1145,usage_system=72.5881,usage_user=9.41735 3723000000000 +cpu,cpu=4 usage_idle=34.36,usage_system=84.1981,usage_user=73.9239 3724000000000 +cpu,cpu=0 usage_idle=88.8537,usage_system=93.0664,usage_user=2.87857 3725000000000 +cpu,cpu=1 usage_idle=60.9188,usage_system=92.5512,usage_user=83.9915 3726000000000 +cpu,cpu=2 usage_idle=30.0404,usage_system=47.5904,usage_user=11.0478 3727000000000 +cpu,cpu=3 usage_idle=5.91445,usage_system=87.3811,usage_user=77.2553 3728000000000 +cpu,cpu=4 usage_idle=7.64206,usage_system=62.6694,usage_user=38.6829 3729000000000 +cpu,cpu=0 usage_idle=49.6826,usage_system=6.83903,usage_user=25.0492 3730000000000 +cpu,cpu=1 usage_idle=42.5838,usage_system=33.4347,usage_user=81.9068 3731000000000 +cpu,cpu=2 usage_idle=54.8702,usage_system=82.8651,usage_user=90.7902 3732000000000 +cpu,cpu=3 usage_idle=43.5575,usage_system=24.9796,usage_user=63.3783 3733000000000 +cpu,cpu=4 usage_idle=52.9749,usage_system=59.3395,usage_user=47.5765 3734000000000 +cpu,cpu=0 usage_idle=26.8988,usage_system=48.1932,usage_user=40.6429 3735000000000 +cpu,cpu=1 usage_idle=29.7774,usage_system=9.112,usage_user=33.1941 3736000000000 +cpu,cpu=2 usage_idle=13.7689,usage_system=39.1524,usage_user=80.7845 3737000000000 +cpu,cpu=3 usage_idle=24.8167,usage_system=45.0669,usage_user=68.1656 3738000000000 +cpu,cpu=4 usage_idle=2.072,usage_system=52.7089,usage_user=30.8351 3739000000000 +cpu,cpu=0 usage_idle=40.7549,usage_system=2.39154,usage_user=37.6741 3740000000000 +cpu,cpu=1 usage_idle=65.8041,usage_system=44.9754,usage_user=71.1088 3741000000000 +cpu,cpu=2 usage_idle=47.7109,usage_system=99.8456,usage_user=53.9738 3742000000000 +cpu,cpu=3 usage_idle=38.5011,usage_system=43.4031,usage_user=78.9534 3743000000000 +cpu,cpu=4 usage_idle=1.87942,usage_system=96.378,usage_user=38.293 3744000000000 +cpu,cpu=0 usage_idle=49.4559,usage_system=23.2768,usage_user=86.4862 3745000000000 +cpu,cpu=1 usage_idle=90.0988,usage_system=53.0542,usage_user=95.5982 3746000000000 +cpu,cpu=2 usage_idle=23.2929,usage_system=66.8231,usage_user=34.7506 3747000000000 +cpu,cpu=3 usage_idle=4.07745,usage_system=91.6398,usage_user=79.8174 3748000000000 +cpu,cpu=4 usage_idle=72.2431,usage_system=93.7118,usage_user=32.5264 3749000000000 +cpu,cpu=0 usage_idle=3.07813,usage_system=34.4666,usage_user=34.9179 3750000000000 +cpu,cpu=1 usage_idle=40.7522,usage_system=0.270744,usage_user=79.8933 3751000000000 +cpu,cpu=2 usage_idle=11.861,usage_system=47.9816,usage_user=79.7388 3752000000000 +cpu,cpu=3 usage_idle=65.8348,usage_system=86.4827,usage_user=23.1419 3753000000000 +cpu,cpu=4 usage_idle=44.7883,usage_system=88.3621,usage_user=19.5199 3754000000000 +cpu,cpu=0 usage_idle=83.0812,usage_system=37.818,usage_user=42.7967 3755000000000 +cpu,cpu=1 usage_idle=69.5674,usage_system=27.9169,usage_user=95.8509 3756000000000 +cpu,cpu=2 usage_idle=65.1656,usage_system=51.2098,usage_user=62.6739 3757000000000 +cpu,cpu=3 usage_idle=99.9162,usage_system=55.2872,usage_user=54.3137 3758000000000 +cpu,cpu=4 usage_idle=79.7336,usage_system=27.5303,usage_user=48.0254 3759000000000 +cpu,cpu=0 usage_idle=12.26,usage_system=30.6084,usage_user=82.4921 3760000000000 +cpu,cpu=1 usage_idle=47.1779,usage_system=71.3607,usage_user=82.7628 3761000000000 +cpu,cpu=2 usage_idle=27.0712,usage_system=83.2217,usage_user=30.7444 3762000000000 +cpu,cpu=3 usage_idle=6.81,usage_system=49.0565,usage_user=17.2271 3763000000000 +cpu,cpu=4 usage_idle=29.9519,usage_system=93.8447,usage_user=5.58922 3764000000000 +cpu,cpu=0 usage_idle=49.4718,usage_system=76.926,usage_user=43.4072 3765000000000 +cpu,cpu=1 usage_idle=92.2685,usage_system=46.4934,usage_user=71.3241 3766000000000 +cpu,cpu=2 usage_idle=88.1194,usage_system=11.6589,usage_user=22.5339 3767000000000 +cpu,cpu=3 usage_idle=50.7933,usage_system=11.5751,usage_user=77.8211 3768000000000 +cpu,cpu=4 usage_idle=5.107,usage_system=91.3088,usage_user=5.35145 3769000000000 +cpu,cpu=0 usage_idle=53.1324,usage_system=3.56874,usage_user=35.9599 3770000000000 +cpu,cpu=1 usage_idle=35.6245,usage_system=50.7466,usage_user=7.32055 3771000000000 +cpu,cpu=2 usage_idle=18.3873,usage_system=77.8178,usage_user=90.5422 3772000000000 +cpu,cpu=3 usage_idle=49.1318,usage_system=84.6278,usage_user=39.5987 3773000000000 +cpu,cpu=4 usage_idle=66.3589,usage_system=14.5797,usage_user=33.4434 3774000000000 +cpu,cpu=0 usage_idle=71.9481,usage_system=64.0516,usage_user=10.3694 3775000000000 +cpu,cpu=1 usage_idle=15.3553,usage_system=56.3201,usage_user=56.8627 3776000000000 +cpu,cpu=2 usage_idle=86.6794,usage_system=44.4395,usage_user=68.5217 3777000000000 +cpu,cpu=3 usage_idle=9.21331,usage_system=95.2328,usage_user=80.0968 3778000000000 +cpu,cpu=4 usage_idle=87.0344,usage_system=0.339806,usage_user=71.4056 3779000000000 +cpu,cpu=0 usage_idle=92.3859,usage_system=53.4723,usage_user=74.9743 3780000000000 +cpu,cpu=1 usage_idle=28.3458,usage_system=89.0968,usage_user=25.7209 3781000000000 +cpu,cpu=2 usage_idle=35.6663,usage_system=7.48412,usage_user=3.5387 3782000000000 +cpu,cpu=3 usage_idle=26.2085,usage_system=56.6159,usage_user=88.1665 3783000000000 +cpu,cpu=4 usage_idle=65.8072,usage_system=22.9748,usage_user=2.7462 3784000000000 +cpu,cpu=0 usage_idle=99.2506,usage_system=94.9229,usage_user=66.7978 3785000000000 +cpu,cpu=1 usage_idle=9.61998,usage_system=10.2782,usage_user=23.1179 3786000000000 +cpu,cpu=2 usage_idle=66.4827,usage_system=96.9577,usage_user=67.5573 3787000000000 +cpu,cpu=3 usage_idle=35.0044,usage_system=6.17098,usage_user=62.7901 3788000000000 +cpu,cpu=4 usage_idle=15.1012,usage_system=93.2054,usage_user=63.13 3789000000000 +cpu,cpu=0 usage_idle=86.5068,usage_system=85.5913,usage_user=16.6022 3790000000000 +cpu,cpu=1 usage_idle=61.4811,usage_system=13.9371,usage_user=5.69898 3791000000000 +cpu,cpu=2 usage_idle=87.202,usage_system=49.6034,usage_user=13.1831 3792000000000 +cpu,cpu=3 usage_idle=90.7407,usage_system=75.8119,usage_user=69.799 3793000000000 +cpu,cpu=4 usage_idle=78.9072,usage_system=41.6191,usage_user=92.7738 3794000000000 +cpu,cpu=0 usage_idle=81.6534,usage_system=40.8697,usage_user=87.6967 3795000000000 +cpu,cpu=1 usage_idle=48.4511,usage_system=50.4897,usage_user=97.9749 3796000000000 +cpu,cpu=2 usage_idle=71.569,usage_system=16.9724,usage_user=94.9326 3797000000000 +cpu,cpu=3 usage_idle=39.1263,usage_system=51.9768,usage_user=1.10356 3798000000000 +cpu,cpu=4 usage_idle=1.91647,usage_system=67.078,usage_user=94.309 3799000000000 +cpu,cpu=0 usage_idle=65.0464,usage_system=53.5848,usage_user=79.9003 3800000000000 +cpu,cpu=1 usage_idle=81.6486,usage_system=15.0659,usage_user=93.8374 3801000000000 +cpu,cpu=2 usage_idle=87.3476,usage_system=2.26785,usage_user=43.4408 3802000000000 +cpu,cpu=3 usage_idle=0.530696,usage_system=93.0085,usage_user=19.2527 3803000000000 +cpu,cpu=4 usage_idle=70.3297,usage_system=71.9157,usage_user=60.8719 3804000000000 +cpu,cpu=0 usage_idle=63.1035,usage_system=53.5691,usage_user=1.74162 3805000000000 +cpu,cpu=1 usage_idle=50.8001,usage_system=2.02021,usage_user=52.2313 3806000000000 +cpu,cpu=2 usage_idle=48.775,usage_system=73.5892,usage_user=69.2038 3807000000000 +cpu,cpu=3 usage_idle=43.7076,usage_system=12.7155,usage_user=21.1806 3808000000000 +cpu,cpu=4 usage_idle=44.8112,usage_system=14.632,usage_user=88.2587 3809000000000 +cpu,cpu=0 usage_idle=39.1202,usage_system=79.6784,usage_user=41.8435 3810000000000 +cpu,cpu=1 usage_idle=19.0205,usage_system=61.3271,usage_user=56.9093 3811000000000 +cpu,cpu=2 usage_idle=12.8578,usage_system=48.6747,usage_user=59.1772 3812000000000 +cpu,cpu=3 usage_idle=56.2986,usage_system=49.2054,usage_user=52.1857 3813000000000 +cpu,cpu=4 usage_idle=75.5514,usage_system=19.535,usage_user=24.1014 3814000000000 +cpu,cpu=0 usage_idle=36.4232,usage_system=82.6385,usage_user=77.6705 3815000000000 +cpu,cpu=1 usage_idle=38.1649,usage_system=33.4386,usage_user=79.6907 3816000000000 +cpu,cpu=2 usage_idle=90.3962,usage_system=82.2137,usage_user=53.2799 3817000000000 +cpu,cpu=3 usage_idle=59.6,usage_system=25.9213,usage_user=65.9954 3818000000000 +cpu,cpu=4 usage_idle=80.7806,usage_system=70.7324,usage_user=80.6275 3819000000000 +cpu,cpu=0 usage_idle=69.0393,usage_system=9.8526,usage_user=60.3059 3820000000000 +cpu,cpu=1 usage_idle=10.8827,usage_system=28.8731,usage_user=21.6329 3821000000000 +cpu,cpu=2 usage_idle=67.792,usage_system=41.7309,usage_user=70.3076 3822000000000 +cpu,cpu=3 usage_idle=26.9692,usage_system=98.0295,usage_user=19.513 3823000000000 +cpu,cpu=4 usage_idle=79.1549,usage_system=73.5809,usage_user=39.048 3824000000000 +cpu,cpu=0 usage_idle=3.25636,usage_system=10.0042,usage_user=21.6865 3825000000000 +cpu,cpu=1 usage_idle=80.9269,usage_system=48.169,usage_user=55.1251 3826000000000 +cpu,cpu=2 usage_idle=60.6176,usage_system=38.5652,usage_user=37.3388 3827000000000 +cpu,cpu=3 usage_idle=13.8975,usage_system=98.1652,usage_user=63.2601 3828000000000 +cpu,cpu=4 usage_idle=79.8929,usage_system=78.9458,usage_user=33.9925 3829000000000 +cpu,cpu=0 usage_idle=60.5204,usage_system=47.9851,usage_user=43.8451 3830000000000 +cpu,cpu=1 usage_idle=20.8263,usage_system=58.8678,usage_user=72.7182 3831000000000 +cpu,cpu=2 usage_idle=42.4592,usage_system=26.6598,usage_user=14.4491 3832000000000 +cpu,cpu=3 usage_idle=12.7668,usage_system=53.629,usage_user=12.4786 3833000000000 +cpu,cpu=4 usage_idle=32.2798,usage_system=32.784,usage_user=86.0595 3834000000000 +cpu,cpu=0 usage_idle=71.3278,usage_system=36.0403,usage_user=96.0637 3835000000000 +cpu,cpu=1 usage_idle=93.0143,usage_system=16.9672,usage_user=44.2327 3836000000000 +cpu,cpu=2 usage_idle=48.1394,usage_system=77.5848,usage_user=82.798 3837000000000 +cpu,cpu=3 usage_idle=85.4782,usage_system=91.4823,usage_user=80.9632 3838000000000 +cpu,cpu=4 usage_idle=48.7383,usage_system=71.3752,usage_user=59.909 3839000000000 +cpu,cpu=0 usage_idle=82.7308,usage_system=31.8956,usage_user=7.89411 3840000000000 +cpu,cpu=1 usage_idle=26.5759,usage_system=52.7219,usage_user=66.7619 3841000000000 +cpu,cpu=2 usage_idle=99.294,usage_system=95.1811,usage_user=93.4217 3842000000000 +cpu,cpu=3 usage_idle=13.7431,usage_system=7.94797,usage_user=47.0508 3843000000000 +cpu,cpu=4 usage_idle=26.2217,usage_system=40.2278,usage_user=79.8348 3844000000000 +cpu,cpu=0 usage_idle=12.2812,usage_system=11.5556,usage_user=15.8751 3845000000000 +cpu,cpu=1 usage_idle=8.34492,usage_system=4.56986,usage_user=32.8423 3846000000000 +cpu,cpu=2 usage_idle=52.5776,usage_system=52.7093,usage_user=10.4271 3847000000000 +cpu,cpu=3 usage_idle=35.3756,usage_system=38.1875,usage_user=1.90939 3848000000000 +cpu,cpu=4 usage_idle=16.3388,usage_system=86.9258,usage_user=73.2846 3849000000000 +cpu,cpu=0 usage_idle=76.2478,usage_system=69.6565,usage_user=5.18025 3850000000000 +cpu,cpu=1 usage_idle=84.1419,usage_system=96.2324,usage_user=57.9022 3851000000000 +cpu,cpu=2 usage_idle=50.9038,usage_system=95.5264,usage_user=53.0833 3852000000000 +cpu,cpu=3 usage_idle=44.3256,usage_system=9.26953,usage_user=61.0313 3853000000000 +cpu,cpu=4 usage_idle=91.3763,usage_system=35.4912,usage_user=1.25903 3854000000000 +cpu,cpu=0 usage_idle=71.2111,usage_system=47.7725,usage_user=12.8146 3855000000000 +cpu,cpu=1 usage_idle=87.0862,usage_system=56.1174,usage_user=17.3845 3856000000000 +cpu,cpu=2 usage_idle=19.9285,usage_system=8.69502,usage_user=70.0938 3857000000000 +cpu,cpu=3 usage_idle=30.3556,usage_system=44.0706,usage_user=8.28125 3858000000000 +cpu,cpu=4 usage_idle=32.265,usage_system=60.4094,usage_user=95.207 3859000000000 +cpu,cpu=0 usage_idle=5.54961,usage_system=36.6573,usage_user=64.8636 3860000000000 +cpu,cpu=1 usage_idle=10.7299,usage_system=20.7992,usage_user=61.096 3861000000000 +cpu,cpu=2 usage_idle=68.632,usage_system=71.703,usage_user=56.6224 3862000000000 +cpu,cpu=3 usage_idle=21.7153,usage_system=16.0286,usage_user=65.8919 3863000000000 +cpu,cpu=4 usage_idle=82.7466,usage_system=7.40495,usage_user=1.38314 3864000000000 +cpu,cpu=0 usage_idle=84.0056,usage_system=78.616,usage_user=49.1556 3865000000000 +cpu,cpu=1 usage_idle=96.8202,usage_system=65.7022,usage_user=5.27297 3866000000000 +cpu,cpu=2 usage_idle=14.2047,usage_system=85.6307,usage_user=13.968 3867000000000 +cpu,cpu=3 usage_idle=84.2984,usage_system=15.9863,usage_user=58.0386 3868000000000 +cpu,cpu=4 usage_idle=92.5797,usage_system=48.2513,usage_user=18.4481 3869000000000 +cpu,cpu=0 usage_idle=87.7867,usage_system=53.8009,usage_user=55.1053 3870000000000 +cpu,cpu=1 usage_idle=52.6503,usage_system=64.5308,usage_user=75.9045 3871000000000 +cpu,cpu=2 usage_idle=13.7462,usage_system=33.1628,usage_user=47.6076 3872000000000 +cpu,cpu=3 usage_idle=70.3686,usage_system=54.8781,usage_user=63.6362 3873000000000 +cpu,cpu=4 usage_idle=36.2605,usage_system=37.6247,usage_user=71.0412 3874000000000 +cpu,cpu=0 usage_idle=37.6436,usage_system=21.6303,usage_user=49.6572 3875000000000 +cpu,cpu=1 usage_idle=86.7992,usage_system=18.4505,usage_user=15.3594 3876000000000 +cpu,cpu=2 usage_idle=92.0722,usage_system=32.6552,usage_user=0.990141 3877000000000 +cpu,cpu=3 usage_idle=6.0402,usage_system=16.9536,usage_user=16.9765 3878000000000 +cpu,cpu=4 usage_idle=64.0788,usage_system=9.53331,usage_user=65.2278 3879000000000 +cpu,cpu=0 usage_idle=82.5269,usage_system=97.32,usage_user=19.0287 3880000000000 +cpu,cpu=1 usage_idle=37.6322,usage_system=49.9703,usage_user=83.5595 3881000000000 +cpu,cpu=2 usage_idle=13.5368,usage_system=63.7165,usage_user=16.7223 3882000000000 +cpu,cpu=3 usage_idle=61.1444,usage_system=34.0851,usage_user=71.6004 3883000000000 +cpu,cpu=4 usage_idle=24.7806,usage_system=70.3456,usage_user=9.22508 3884000000000 +cpu,cpu=0 usage_idle=95.8217,usage_system=7.98921,usage_user=30.8554 3885000000000 +cpu,cpu=1 usage_idle=45.4789,usage_system=94.7885,usage_user=49.3059 3886000000000 +cpu,cpu=2 usage_idle=60.8383,usage_system=86.8607,usage_user=81.9611 3887000000000 +cpu,cpu=3 usage_idle=61.8285,usage_system=92.9009,usage_user=98.9147 3888000000000 +cpu,cpu=4 usage_idle=78.8049,usage_system=56.9797,usage_user=8.44802 3889000000000 +cpu,cpu=0 usage_idle=44.0327,usage_system=39.5066,usage_user=5.76804 3890000000000 +cpu,cpu=1 usage_idle=63.0614,usage_system=77.1388,usage_user=55.7383 3891000000000 +cpu,cpu=2 usage_idle=46.6209,usage_system=90.6755,usage_user=19.4548 3892000000000 +cpu,cpu=3 usage_idle=63.3432,usage_system=51.8199,usage_user=53.5398 3893000000000 +cpu,cpu=4 usage_idle=34.9436,usage_system=76.6005,usage_user=23.8854 3894000000000 +cpu,cpu=0 usage_idle=44.1687,usage_system=72.4222,usage_user=31.8746 3895000000000 +cpu,cpu=1 usage_idle=75.0241,usage_system=17.9011,usage_user=26.6631 3896000000000 +cpu,cpu=2 usage_idle=24.33,usage_system=78.7394,usage_user=13.5237 3897000000000 +cpu,cpu=3 usage_idle=6.29104,usage_system=40.5678,usage_user=6.4246 3898000000000 +cpu,cpu=4 usage_idle=5.20576,usage_system=19.3728,usage_user=63.4043 3899000000000 +cpu,cpu=0 usage_idle=13.6538,usage_system=63.4055,usage_user=2.91086 3900000000000 +cpu,cpu=1 usage_idle=19.4218,usage_system=26.4669,usage_user=80.0496 3901000000000 +cpu,cpu=2 usage_idle=75.1601,usage_system=73.0878,usage_user=70.7252 3902000000000 +cpu,cpu=3 usage_idle=94.6149,usage_system=36.4311,usage_user=22.5451 3903000000000 +cpu,cpu=4 usage_idle=48.1547,usage_system=71.3747,usage_user=99.1455 3904000000000 +cpu,cpu=0 usage_idle=72.0401,usage_system=15.5433,usage_user=71.5677 3905000000000 +cpu,cpu=1 usage_idle=3.91476,usage_system=90.5674,usage_user=89.4688 3906000000000 +cpu,cpu=2 usage_idle=30.5778,usage_system=14.8974,usage_user=68.2082 3907000000000 +cpu,cpu=3 usage_idle=44.1016,usage_system=21.1884,usage_user=8.776 3908000000000 +cpu,cpu=4 usage_idle=50.5262,usage_system=26.3942,usage_user=28.1488 3909000000000 +cpu,cpu=0 usage_idle=13.9305,usage_system=40.0479,usage_user=91.5543 3910000000000 +cpu,cpu=1 usage_idle=16.8413,usage_system=59.4698,usage_user=18.0212 3911000000000 +cpu,cpu=2 usage_idle=96.891,usage_system=34.6299,usage_user=91.109 3912000000000 +cpu,cpu=3 usage_idle=67.6161,usage_system=29.2448,usage_user=27.5401 3913000000000 +cpu,cpu=4 usage_idle=90.1612,usage_system=77.3995,usage_user=98.9147 3914000000000 +cpu,cpu=0 usage_idle=89.3067,usage_system=49.4397,usage_user=14.4581 3915000000000 +cpu,cpu=1 usage_idle=60.8744,usage_system=53.3544,usage_user=5.02549 3916000000000 +cpu,cpu=2 usage_idle=50.3432,usage_system=83.9323,usage_user=19.9229 3917000000000 +cpu,cpu=3 usage_idle=18.5513,usage_system=28.0339,usage_user=41.1113 3918000000000 +cpu,cpu=4 usage_idle=27.3273,usage_system=78.56,usage_user=67.5054 3919000000000 +cpu,cpu=0 usage_idle=55.4761,usage_system=92.4905,usage_user=7.55337 3920000000000 +cpu,cpu=1 usage_idle=47.0303,usage_system=9.33182,usage_user=67.0231 3921000000000 +cpu,cpu=2 usage_idle=65.0515,usage_system=6.22277,usage_user=1.65302 3922000000000 +cpu,cpu=3 usage_idle=56.1606,usage_system=73.8389,usage_user=30.8978 3923000000000 +cpu,cpu=4 usage_idle=83.7006,usage_system=64.0001,usage_user=8.29734 3924000000000 +cpu,cpu=0 usage_idle=82.6154,usage_system=53.3068,usage_user=57.737 3925000000000 +cpu,cpu=1 usage_idle=97.0735,usage_system=14.1812,usage_user=11.0915 3926000000000 +cpu,cpu=2 usage_idle=2.09897,usage_system=64.5244,usage_user=95.0237 3927000000000 +cpu,cpu=3 usage_idle=22.0218,usage_system=83.0757,usage_user=23.0576 3928000000000 +cpu,cpu=4 usage_idle=63.1331,usage_system=10.403,usage_user=1.61763 3929000000000 +cpu,cpu=0 usage_idle=30.6385,usage_system=65.8791,usage_user=94.1081 3930000000000 +cpu,cpu=1 usage_idle=38.1919,usage_system=12.9094,usage_user=3.43994 3931000000000 +cpu,cpu=2 usage_idle=5.215,usage_system=77.961,usage_user=9.66272 3932000000000 +cpu,cpu=3 usage_idle=6.86802,usage_system=34.1215,usage_user=83.5016 3933000000000 +cpu,cpu=4 usage_idle=37.7658,usage_system=17.8222,usage_user=47.5017 3934000000000 +cpu,cpu=0 usage_idle=46.0632,usage_system=0.437554,usage_user=0.808517 3935000000000 +cpu,cpu=1 usage_idle=3.8002,usage_system=97.511,usage_user=14.9897 3936000000000 +cpu,cpu=2 usage_idle=14.8917,usage_system=99.61,usage_user=79.5141 3937000000000 +cpu,cpu=3 usage_idle=9.91542,usage_system=21.6318,usage_user=62.5898 3938000000000 +cpu,cpu=4 usage_idle=32.973,usage_system=84.7649,usage_user=72.9928 3939000000000 +cpu,cpu=0 usage_idle=34.5906,usage_system=15.4034,usage_user=38.8719 3940000000000 +cpu,cpu=1 usage_idle=28.6988,usage_system=53.5953,usage_user=51.7813 3941000000000 +cpu,cpu=2 usage_idle=32.1387,usage_system=58.8103,usage_user=29.7423 3942000000000 +cpu,cpu=3 usage_idle=41.8014,usage_system=65.6783,usage_user=63.8638 3943000000000 +cpu,cpu=4 usage_idle=25.3031,usage_system=3.44416,usage_user=81.686 3944000000000 +cpu,cpu=0 usage_idle=72.8048,usage_system=49.5073,usage_user=82.1236 3945000000000 +cpu,cpu=1 usage_idle=73.6133,usage_system=53.3075,usage_user=79.6346 3946000000000 +cpu,cpu=2 usage_idle=88.603,usage_system=68.1992,usage_user=79.2446 3947000000000 +cpu,cpu=3 usage_idle=68.1171,usage_system=78.1146,usage_user=0.876439 3948000000000 +cpu,cpu=4 usage_idle=30.7069,usage_system=11.0877,usage_user=85.6414 3949000000000 +cpu,cpu=0 usage_idle=3.69971,usage_system=45.6783,usage_user=1.04478 3950000000000 +cpu,cpu=1 usage_idle=42.5716,usage_system=74.3771,usage_user=54.6401 3951000000000 +cpu,cpu=2 usage_idle=94.353,usage_system=6.51579,usage_user=13.4504 3952000000000 +cpu,cpu=3 usage_idle=24.0953,usage_system=48.3172,usage_user=79.1287 3953000000000 +cpu,cpu=4 usage_idle=87.9591,usage_system=73.6203,usage_user=82.5729 3954000000000 +cpu,cpu=0 usage_idle=69.6451,usage_system=46.425,usage_user=32.0802 3955000000000 +cpu,cpu=1 usage_idle=51.7687,usage_system=20.0383,usage_user=85.3877 3956000000000 +cpu,cpu=2 usage_idle=31.4033,usage_system=8.64132,usage_user=53.5869 3957000000000 +cpu,cpu=3 usage_idle=10.6479,usage_system=76.7584,usage_user=31.7016 3958000000000 +cpu,cpu=4 usage_idle=11.5244,usage_system=7.46533,usage_user=42.7892 3959000000000 +cpu,cpu=0 usage_idle=97.1657,usage_system=11.165,usage_user=88.4675 3960000000000 +cpu,cpu=1 usage_idle=98.2105,usage_system=53.7367,usage_user=62.8446 3961000000000 +cpu,cpu=2 usage_idle=52.8506,usage_system=48.0896,usage_user=69.3604 3962000000000 +cpu,cpu=3 usage_idle=66.301,usage_system=72.1849,usage_user=17.6776 3963000000000 +cpu,cpu=4 usage_idle=45.4297,usage_system=60.144,usage_user=91.2979 3964000000000 +cpu,cpu=0 usage_idle=28.0025,usage_system=29.7892,usage_user=37.7229 3965000000000 +cpu,cpu=1 usage_idle=60.0827,usage_system=81.5579,usage_user=57.7612 3966000000000 +cpu,cpu=2 usage_idle=45.4704,usage_system=12.9612,usage_user=66.4026 3967000000000 +cpu,cpu=3 usage_idle=99.0574,usage_system=23.6091,usage_user=43.161 3968000000000 +cpu,cpu=4 usage_idle=30.759,usage_system=35.1335,usage_user=50.6263 3969000000000 +cpu,cpu=0 usage_idle=73.5482,usage_system=32.2992,usage_user=61.7913 3970000000000 +cpu,cpu=1 usage_idle=62.0157,usage_system=30.5097,usage_user=15.528 3971000000000 +cpu,cpu=2 usage_idle=24.8603,usage_system=83.3603,usage_user=63.6176 3972000000000 +cpu,cpu=3 usage_idle=94.2207,usage_system=49.6612,usage_user=35.8025 3973000000000 +cpu,cpu=4 usage_idle=11.8983,usage_system=95.0909,usage_user=95.9466 3974000000000 +cpu,cpu=0 usage_idle=3.19623,usage_system=23.0934,usage_user=25.7358 3975000000000 +cpu,cpu=1 usage_idle=40.9192,usage_system=83.1761,usage_user=7.29366 3976000000000 +cpu,cpu=2 usage_idle=98.6804,usage_system=28.6466,usage_user=20.2549 3977000000000 +cpu,cpu=3 usage_idle=65.083,usage_system=27.704,usage_user=43.864 3978000000000 +cpu,cpu=4 usage_idle=8.24394,usage_system=58.4629,usage_user=78.9975 3979000000000 +cpu,cpu=0 usage_idle=58.8702,usage_system=32.0111,usage_user=11.2967 3980000000000 +cpu,cpu=1 usage_idle=20.6616,usage_system=94.0269,usage_user=41.8064 3981000000000 +cpu,cpu=2 usage_idle=36.1896,usage_system=18.8872,usage_user=25.1667 3982000000000 +cpu,cpu=3 usage_idle=99.8072,usage_system=13.1079,usage_user=74.828 3983000000000 +cpu,cpu=4 usage_idle=35.6097,usage_system=25.0063,usage_user=69.9189 3984000000000 +cpu,cpu=0 usage_idle=31.5563,usage_system=28.2025,usage_user=93.0123 3985000000000 +cpu,cpu=1 usage_idle=57.2921,usage_system=69.1217,usage_user=76.1884 3986000000000 +cpu,cpu=2 usage_idle=64.5857,usage_system=67.8021,usage_user=4.835 3987000000000 +cpu,cpu=3 usage_idle=84.8406,usage_system=32.885,usage_user=32.539 3988000000000 +cpu,cpu=4 usage_idle=28.7046,usage_system=41.1289,usage_user=91.0019 3989000000000 +cpu,cpu=0 usage_idle=7.70213,usage_system=99.9992,usage_user=23.013 3990000000000 +cpu,cpu=1 usage_idle=18.9989,usage_system=20.6608,usage_user=17.0399 3991000000000 +cpu,cpu=2 usage_idle=60.8053,usage_system=56.8504,usage_user=35.9271 3992000000000 +cpu,cpu=3 usage_idle=85.972,usage_system=56.6576,usage_user=49.035 3993000000000 +cpu,cpu=4 usage_idle=60.8,usage_system=92.2673,usage_user=74.0413 3994000000000 +cpu,cpu=0 usage_idle=30.7189,usage_system=23.8237,usage_user=2.24378 3995000000000 +cpu,cpu=1 usage_idle=23.7312,usage_system=81.1157,usage_user=71.3654 3996000000000 +cpu,cpu=2 usage_idle=99.9196,usage_system=45.7014,usage_user=39.1675 3997000000000 +cpu,cpu=3 usage_idle=4.75465,usage_system=30.542,usage_user=72.0525 3998000000000 +cpu,cpu=4 usage_idle=37.2936,usage_system=59.2467,usage_user=13.1815 3999000000000 +cpu,cpu=0 usage_idle=28.2955,usage_system=66.9488,usage_user=13.1806 4000000000000 +cpu,cpu=1 usage_idle=51.3085,usage_system=85.9476,usage_user=33.8414 4001000000000 +cpu,cpu=2 usage_idle=68.3484,usage_system=46.7529,usage_user=90.6918 4002000000000 +cpu,cpu=3 usage_idle=4.27546,usage_system=32.725,usage_user=47.3494 4003000000000 +cpu,cpu=4 usage_idle=53.3105,usage_system=93.525,usage_user=39.6167 4004000000000 +cpu,cpu=0 usage_idle=27.3517,usage_system=24.2439,usage_user=63.4404 4005000000000 +cpu,cpu=1 usage_idle=29.5955,usage_system=47.9751,usage_user=44.5561 4006000000000 +cpu,cpu=2 usage_idle=0.960964,usage_system=47.8948,usage_user=90.2576 4007000000000 +cpu,cpu=3 usage_idle=40.1285,usage_system=52.6494,usage_user=20.7996 4008000000000 +cpu,cpu=4 usage_idle=12.181,usage_system=89.943,usage_user=80.0462 4009000000000 +cpu,cpu=0 usage_idle=25.3624,usage_system=18.2385,usage_user=46.995 4010000000000 +cpu,cpu=1 usage_idle=38.5431,usage_system=69.547,usage_user=32.9427 4011000000000 +cpu,cpu=2 usage_idle=72.3845,usage_system=37.8954,usage_user=79.6956 4012000000000 +cpu,cpu=3 usage_idle=63.0763,usage_system=42.1709,usage_user=12.4206 4013000000000 +cpu,cpu=4 usage_idle=10.4257,usage_system=95.4813,usage_user=5.94555 4014000000000 +cpu,cpu=0 usage_idle=50.0424,usage_system=22.8331,usage_user=30.1895 4015000000000 +cpu,cpu=1 usage_idle=13.4828,usage_system=52.4286,usage_user=78.1646 4016000000000 +cpu,cpu=2 usage_idle=58.0389,usage_system=53.3896,usage_user=26.0593 4017000000000 +cpu,cpu=3 usage_idle=48.2965,usage_system=93.518,usage_user=78.7087 4018000000000 +cpu,cpu=4 usage_idle=69.0961,usage_system=5.699,usage_user=68.6518 4019000000000 +cpu,cpu=0 usage_idle=49.1423,usage_system=31.0614,usage_user=86.8903 4020000000000 +cpu,cpu=1 usage_idle=96.1374,usage_system=69.6045,usage_user=56.4373 4021000000000 +cpu,cpu=2 usage_idle=29.08,usage_system=41.989,usage_user=94.3327 4022000000000 +cpu,cpu=3 usage_idle=8.77561,usage_system=5.06526,usage_user=36.5036 4023000000000 +cpu,cpu=4 usage_idle=21.1962,usage_system=15.491,usage_user=31.9849 4024000000000 +cpu,cpu=0 usage_idle=27.1417,usage_system=65.5334,usage_user=54.818 4025000000000 +cpu,cpu=1 usage_idle=57.3312,usage_system=79.0162,usage_user=7.2466 4026000000000 +cpu,cpu=2 usage_idle=35.4957,usage_system=37.0552,usage_user=60.6362 4027000000000 +cpu,cpu=3 usage_idle=61.5551,usage_system=85.3517,usage_user=54.1542 4028000000000 +cpu,cpu=4 usage_idle=40.2638,usage_system=54.4478,usage_user=59.8532 4029000000000 +cpu,cpu=0 usage_idle=8.91558,usage_system=3.59011,usage_user=90.9146 4030000000000 +cpu,cpu=1 usage_idle=95.8058,usage_system=99.7275,usage_user=60.5191 4031000000000 +cpu,cpu=2 usage_idle=52.2431,usage_system=28.8075,usage_user=2.50809 4032000000000 +cpu,cpu=3 usage_idle=46.5758,usage_system=37.5831,usage_user=7.57335 4033000000000 +cpu,cpu=4 usage_idle=83.0794,usage_system=58.7793,usage_user=23.0643 4034000000000 +cpu,cpu=0 usage_idle=15.0643,usage_system=85.921,usage_user=88.5977 4035000000000 +cpu,cpu=1 usage_idle=69.8823,usage_system=43.2522,usage_user=67.6139 4036000000000 +cpu,cpu=2 usage_idle=77.1289,usage_system=78.7479,usage_user=4.66909 4037000000000 +cpu,cpu=3 usage_idle=37.7651,usage_system=40.303,usage_user=90.0208 4038000000000 +cpu,cpu=4 usage_idle=91.9193,usage_system=80.5668,usage_user=44.4685 4039000000000 +cpu,cpu=0 usage_idle=51.7725,usage_system=89.4824,usage_user=48.0586 4040000000000 +cpu,cpu=1 usage_idle=42.6871,usage_system=85.2882,usage_user=47.7861 4041000000000 +cpu,cpu=2 usage_idle=3.20625,usage_system=37.5314,usage_user=76.5936 4042000000000 +cpu,cpu=3 usage_idle=5.71434,usage_system=84.1072,usage_user=14.1768 4043000000000 +cpu,cpu=4 usage_idle=13.2877,usage_system=67.1866,usage_user=72.9561 4044000000000 +cpu,cpu=0 usage_idle=36.352,usage_system=82.251,usage_user=58.8771 4045000000000 +cpu,cpu=1 usage_idle=24.9497,usage_system=52.1333,usage_user=2.12927 4046000000000 +cpu,cpu=2 usage_idle=92.5636,usage_system=29.2622,usage_user=80.8772 4047000000000 +cpu,cpu=3 usage_idle=97.2327,usage_system=67.0273,usage_user=21.1802 4048000000000 +cpu,cpu=4 usage_idle=87.2535,usage_system=58.9467,usage_user=1.74702 4049000000000 +cpu,cpu=0 usage_idle=31.722,usage_system=10.7192,usage_user=91.2294 4050000000000 +cpu,cpu=1 usage_idle=79.7806,usage_system=53.4063,usage_user=76.5176 4051000000000 +cpu,cpu=2 usage_idle=27.5668,usage_system=56.6126,usage_user=14.049 4052000000000 +cpu,cpu=3 usage_idle=4.16041,usage_system=62.3269,usage_user=98.1562 4053000000000 +cpu,cpu=4 usage_idle=18.3372,usage_system=75.6146,usage_user=65.3429 4054000000000 +cpu,cpu=0 usage_idle=91.2932,usage_system=11.9666,usage_user=47.5939 4055000000000 +cpu,cpu=1 usage_idle=50.1703,usage_system=36.9163,usage_user=99.7272 4056000000000 +cpu,cpu=2 usage_idle=52.2996,usage_system=29.4799,usage_user=28.9894 4057000000000 +cpu,cpu=3 usage_idle=33.1768,usage_system=26.7126,usage_user=96.0167 4058000000000 +cpu,cpu=4 usage_idle=54.357,usage_system=13.966,usage_user=54.9634 4059000000000 +cpu,cpu=0 usage_idle=56.104,usage_system=45.688,usage_user=65.6826 4060000000000 +cpu,cpu=1 usage_idle=47.3334,usage_system=25.4687,usage_user=19.0889 4061000000000 +cpu,cpu=2 usage_idle=23.8511,usage_system=53.0354,usage_user=75.7014 4062000000000 +cpu,cpu=3 usage_idle=37.9001,usage_system=57.1959,usage_user=38.0283 4063000000000 +cpu,cpu=4 usage_idle=36.0563,usage_system=75.533,usage_user=13.6429 4064000000000 +cpu,cpu=0 usage_idle=1.39921,usage_system=66.8263,usage_user=25.6095 4065000000000 +cpu,cpu=1 usage_idle=48.9931,usage_system=16.9966,usage_user=62.5258 4066000000000 +cpu,cpu=2 usage_idle=48.7202,usage_system=69.2962,usage_user=92.0056 4067000000000 +cpu,cpu=3 usage_idle=77.7096,usage_system=2.47298,usage_user=18.7182 4068000000000 +cpu,cpu=4 usage_idle=73.7264,usage_system=56.83,usage_user=32.6842 4069000000000 +cpu,cpu=0 usage_idle=28.6898,usage_system=12.934,usage_user=78.3723 4070000000000 +cpu,cpu=1 usage_idle=94.3723,usage_system=60.2674,usage_user=3.84095 4071000000000 +cpu,cpu=2 usage_idle=13.4612,usage_system=84.1184,usage_user=56.8764 4072000000000 +cpu,cpu=3 usage_idle=89.1627,usage_system=22.0185,usage_user=14.0723 4073000000000 +cpu,cpu=4 usage_idle=27.191,usage_system=58.0748,usage_user=89.6053 4074000000000 +cpu,cpu=0 usage_idle=40.8339,usage_system=59.474,usage_user=56.4316 4075000000000 +cpu,cpu=1 usage_idle=66.4434,usage_system=8.46709,usage_user=73.4282 4076000000000 +cpu,cpu=2 usage_idle=28.9692,usage_system=57.1873,usage_user=42.7244 4077000000000 +cpu,cpu=3 usage_idle=20.9749,usage_system=34.8969,usage_user=45.1974 4078000000000 +cpu,cpu=4 usage_idle=39.6931,usage_system=8.62329,usage_user=2.02732 4079000000000 +cpu,cpu=0 usage_idle=72.3773,usage_system=37.3131,usage_user=14.9613 4080000000000 +cpu,cpu=1 usage_idle=50.7496,usage_system=31.6854,usage_user=75.2286 4081000000000 +cpu,cpu=2 usage_idle=54.5905,usage_system=45.1466,usage_user=59.3471 4082000000000 +cpu,cpu=3 usage_idle=11.4669,usage_system=34.3093,usage_user=81.3655 4083000000000 +cpu,cpu=4 usage_idle=25.5392,usage_system=61.5003,usage_user=39.4404 4084000000000 +cpu,cpu=0 usage_idle=15.1445,usage_system=2.33425,usage_user=98.9144 4085000000000 +cpu,cpu=1 usage_idle=71.5761,usage_system=68.7777,usage_user=7.38149 4086000000000 +cpu,cpu=2 usage_idle=45.0042,usage_system=97.7469,usage_user=64.5688 4087000000000 +cpu,cpu=3 usage_idle=87.7286,usage_system=18.7218,usage_user=99.4657 4088000000000 +cpu,cpu=4 usage_idle=32.926,usage_system=58.4148,usage_user=8.08901 4089000000000 +cpu,cpu=0 usage_idle=34.9533,usage_system=30.7921,usage_user=45.4021 4090000000000 +cpu,cpu=1 usage_idle=49.9146,usage_system=81.5417,usage_user=77.0875 4091000000000 +cpu,cpu=2 usage_idle=25.1432,usage_system=36.1323,usage_user=22.2341 4092000000000 +cpu,cpu=3 usage_idle=84.4902,usage_system=47.5992,usage_user=56.5434 4093000000000 +cpu,cpu=4 usage_idle=65.8558,usage_system=73.1384,usage_user=18.0437 4094000000000 +cpu,cpu=0 usage_idle=5.29617,usage_system=88.2829,usage_user=20.378 4095000000000 +cpu,cpu=1 usage_idle=4.21057,usage_system=59.859,usage_user=89.1557 4096000000000 +cpu,cpu=2 usage_idle=11.5921,usage_system=4.86322,usage_user=86.9026 4097000000000 +cpu,cpu=3 usage_idle=76.1609,usage_system=92.5918,usage_user=5.62432 4098000000000 +cpu,cpu=4 usage_idle=75.6266,usage_system=25.5178,usage_user=64.0392 4099000000000 +cpu,cpu=0 usage_idle=83.7156,usage_system=60.4711,usage_user=94.8313 4100000000000 +cpu,cpu=1 usage_idle=29.1176,usage_system=10.3857,usage_user=76.373 4101000000000 +cpu,cpu=2 usage_idle=6.20511,usage_system=35.5289,usage_user=12.5053 4102000000000 +cpu,cpu=3 usage_idle=28.4392,usage_system=20.0191,usage_user=60.1046 4103000000000 +cpu,cpu=4 usage_idle=84.9826,usage_system=85.8749,usage_user=33.243 4104000000000 +cpu,cpu=0 usage_idle=3.02628,usage_system=91.1711,usage_user=21.5259 4105000000000 +cpu,cpu=1 usage_idle=23.4042,usage_system=95.3816,usage_user=81.3849 4106000000000 +cpu,cpu=2 usage_idle=12.5599,usage_system=6.97371,usage_user=86.2481 4107000000000 +cpu,cpu=3 usage_idle=99.4624,usage_system=83.1346,usage_user=78.8399 4108000000000 +cpu,cpu=4 usage_idle=5.08677,usage_system=58.7612,usage_user=4.35773 4109000000000 +cpu,cpu=0 usage_idle=69.1259,usage_system=42.4767,usage_user=64.8288 4110000000000 +cpu,cpu=1 usage_idle=63.9572,usage_system=71.5944,usage_user=75.2145 4111000000000 +cpu,cpu=2 usage_idle=40.3303,usage_system=77.7995,usage_user=10.7434 4112000000000 +cpu,cpu=3 usage_idle=52.8356,usage_system=6.23869,usage_user=30.7625 4113000000000 +cpu,cpu=4 usage_idle=12.9401,usage_system=91.2213,usage_user=16.6374 4114000000000 +cpu,cpu=0 usage_idle=46.1831,usage_system=94.2475,usage_user=7.80844 4115000000000 +cpu,cpu=1 usage_idle=67.709,usage_system=17.6518,usage_user=3.19008 4116000000000 +cpu,cpu=2 usage_idle=49.0939,usage_system=30.2117,usage_user=10.1638 4117000000000 +cpu,cpu=3 usage_idle=35.342,usage_system=29.6741,usage_user=93.2984 4118000000000 +cpu,cpu=4 usage_idle=14.1819,usage_system=34.7609,usage_user=52.0595 4119000000000 +cpu,cpu=0 usage_idle=18.5396,usage_system=3.8868,usage_user=94.5363 4120000000000 +cpu,cpu=1 usage_idle=83.3685,usage_system=67.844,usage_user=66.1306 4121000000000 +cpu,cpu=2 usage_idle=58.583,usage_system=8.17427,usage_user=43.9301 4122000000000 +cpu,cpu=3 usage_idle=69.3263,usage_system=61.0099,usage_user=50.1688 4123000000000 +cpu,cpu=4 usage_idle=0.0887994,usage_system=73.95,usage_user=41.3901 4124000000000 +cpu,cpu=0 usage_idle=16.7262,usage_system=20.1331,usage_user=35.6377 4125000000000 +cpu,cpu=1 usage_idle=24.5346,usage_system=87.8422,usage_user=53.2894 4126000000000 +cpu,cpu=2 usage_idle=27.7247,usage_system=36.9361,usage_user=83.5011 4127000000000 +cpu,cpu=3 usage_idle=37.8885,usage_system=72.2781,usage_user=13.1752 4128000000000 +cpu,cpu=4 usage_idle=31.1868,usage_system=86.46,usage_user=47.9361 4129000000000 +cpu,cpu=0 usage_idle=83.2463,usage_system=4.99962,usage_user=51.8229 4130000000000 +cpu,cpu=1 usage_idle=77.7826,usage_system=88.3681,usage_user=19.6669 4131000000000 +cpu,cpu=2 usage_idle=43.9132,usage_system=46.9511,usage_user=27.8412 4132000000000 +cpu,cpu=3 usage_idle=87.8434,usage_system=16.2774,usage_user=88.851 4133000000000 +cpu,cpu=4 usage_idle=38.0122,usage_system=16.3662,usage_user=62.801 4134000000000 +cpu,cpu=0 usage_idle=79.4023,usage_system=33.0924,usage_user=82.9342 4135000000000 +cpu,cpu=1 usage_idle=15.04,usage_system=57.627,usage_user=70.7763 4136000000000 +cpu,cpu=2 usage_idle=68.3294,usage_system=85.3517,usage_user=7.71241 4137000000000 +cpu,cpu=3 usage_idle=51.8305,usage_system=23.2401,usage_user=79.9905 4138000000000 +cpu,cpu=4 usage_idle=65.0057,usage_system=54.427,usage_user=66.4504 4139000000000 +cpu,cpu=0 usage_idle=12.9418,usage_system=37.6733,usage_user=71.4501 4140000000000 +cpu,cpu=1 usage_idle=64.7647,usage_system=15.4559,usage_user=59.8182 4141000000000 +cpu,cpu=2 usage_idle=84.4316,usage_system=59.3692,usage_user=6.76925 4142000000000 +cpu,cpu=3 usage_idle=12.2728,usage_system=47.2125,usage_user=23.0467 4143000000000 +cpu,cpu=4 usage_idle=1.12378,usage_system=85.2248,usage_user=39.4129 4144000000000 +cpu,cpu=0 usage_idle=63.9248,usage_system=64.6271,usage_user=72.5053 4145000000000 +cpu,cpu=1 usage_idle=46.859,usage_system=79.6671,usage_user=30.1323 4146000000000 +cpu,cpu=2 usage_idle=17.6353,usage_system=47.9965,usage_user=15.4839 4147000000000 +cpu,cpu=3 usage_idle=25.3477,usage_system=99.827,usage_user=38.7241 4148000000000 +cpu,cpu=4 usage_idle=5.3382,usage_system=64.8327,usage_user=93.151 4149000000000 +cpu,cpu=0 usage_idle=71.7886,usage_system=77.7746,usage_user=30.8244 4150000000000 +cpu,cpu=1 usage_idle=43.2387,usage_system=42.5392,usage_user=46.2803 4151000000000 +cpu,cpu=2 usage_idle=3.05687,usage_system=26.9708,usage_user=5.64944 4152000000000 +cpu,cpu=3 usage_idle=9.82611,usage_system=39.2436,usage_user=52.862 4153000000000 +cpu,cpu=4 usage_idle=32.8728,usage_system=40.3674,usage_user=38.0867 4154000000000 +cpu,cpu=0 usage_idle=72.2857,usage_system=4.29219,usage_user=2.71383 4155000000000 +cpu,cpu=1 usage_idle=44.7909,usage_system=51.1512,usage_user=82.3809 4156000000000 +cpu,cpu=2 usage_idle=74.9232,usage_system=68.7865,usage_user=30.3774 4157000000000 +cpu,cpu=3 usage_idle=90.4071,usage_system=94.1342,usage_user=30.2044 4158000000000 +cpu,cpu=4 usage_idle=29.1312,usage_system=99.4724,usage_user=95.0371 4159000000000 +cpu,cpu=0 usage_idle=22.2822,usage_system=71.261,usage_user=72.8117 4160000000000 +cpu,cpu=1 usage_idle=53.1066,usage_system=14.4997,usage_user=15.3509 4161000000000 +cpu,cpu=2 usage_idle=99.3869,usage_system=17.5566,usage_user=42.3218 4162000000000 +cpu,cpu=3 usage_idle=5.03634,usage_system=27.3827,usage_user=81.5654 4163000000000 +cpu,cpu=4 usage_idle=57.8983,usage_system=60.2555,usage_user=21.9327 4164000000000 +cpu,cpu=0 usage_idle=95.9851,usage_system=32.5412,usage_user=26.2249 4165000000000 +cpu,cpu=1 usage_idle=98.6989,usage_system=77.3321,usage_user=77.3761 4166000000000 +cpu,cpu=2 usage_idle=81.0798,usage_system=52.2553,usage_user=46.1626 4167000000000 +cpu,cpu=3 usage_idle=11.4572,usage_system=42.6624,usage_user=40.2968 4168000000000 +cpu,cpu=4 usage_idle=41.6616,usage_system=71.7936,usage_user=39.7692 4169000000000 +cpu,cpu=0 usage_idle=36.6987,usage_system=94.0758,usage_user=11.0303 4170000000000 +cpu,cpu=1 usage_idle=9.51038,usage_system=47.1824,usage_user=25.53 4171000000000 +cpu,cpu=2 usage_idle=24.8613,usage_system=46.5693,usage_user=43.0866 4172000000000 +cpu,cpu=3 usage_idle=67.1831,usage_system=51.6057,usage_user=70.4693 4173000000000 +cpu,cpu=4 usage_idle=48.7484,usage_system=9.50399,usage_user=30.7248 4174000000000 +cpu,cpu=0 usage_idle=70.6812,usage_system=5.48905,usage_user=63.266 4175000000000 +cpu,cpu=1 usage_idle=96.9061,usage_system=4.18795,usage_user=40.5981 4176000000000 +cpu,cpu=2 usage_idle=74.2822,usage_system=85.2677,usage_user=92.8534 4177000000000 +cpu,cpu=3 usage_idle=20.4448,usage_system=96.7249,usage_user=35.5158 4178000000000 +cpu,cpu=4 usage_idle=60.7416,usage_system=38.3865,usage_user=7.30939 4179000000000 +cpu,cpu=0 usage_idle=0.510802,usage_system=75.0852,usage_user=1.38522 4180000000000 +cpu,cpu=1 usage_idle=11.5411,usage_system=84.5956,usage_user=48.5677 4181000000000 +cpu,cpu=2 usage_idle=37.0711,usage_system=9.45689,usage_user=95.137 4182000000000 +cpu,cpu=3 usage_idle=80.1577,usage_system=76.64,usage_user=46.7426 4183000000000 +cpu,cpu=4 usage_idle=50.627,usage_system=25.3884,usage_user=56.2466 4184000000000 +cpu,cpu=0 usage_idle=81.3518,usage_system=96.0696,usage_user=61.7357 4185000000000 +cpu,cpu=1 usage_idle=44.6178,usage_system=92.9757,usage_user=65.9236 4186000000000 +cpu,cpu=2 usage_idle=85.2159,usage_system=67.2579,usage_user=51.1914 4187000000000 +cpu,cpu=3 usage_idle=78.0693,usage_system=87.7027,usage_user=47.9163 4188000000000 +cpu,cpu=4 usage_idle=13.5851,usage_system=48.4443,usage_user=86.3028 4189000000000 +cpu,cpu=0 usage_idle=20.8945,usage_system=48.9551,usage_user=61.388 4190000000000 +cpu,cpu=1 usage_idle=22.2798,usage_system=60.4962,usage_user=45.9836 4191000000000 +cpu,cpu=2 usage_idle=70.8474,usage_system=97.5672,usage_user=55.4405 4192000000000 +cpu,cpu=3 usage_idle=65.9844,usage_system=77.7249,usage_user=32.0805 4193000000000 +cpu,cpu=4 usage_idle=12.7271,usage_system=28.3519,usage_user=57.4689 4194000000000 +cpu,cpu=0 usage_idle=68.9737,usage_system=9.70372,usage_user=53.5385 4195000000000 +cpu,cpu=1 usage_idle=30.7094,usage_system=54.3216,usage_user=46.5142 4196000000000 +cpu,cpu=2 usage_idle=96.633,usage_system=39.5375,usage_user=13.7721 4197000000000 +cpu,cpu=3 usage_idle=47.8244,usage_system=17.6068,usage_user=1.47486 4198000000000 +cpu,cpu=4 usage_idle=95.7407,usage_system=31.192,usage_user=49.9192 4199000000000 +cpu,cpu=0 usage_idle=82.0436,usage_system=52.0865,usage_user=98.8743 4200000000000 +cpu,cpu=1 usage_idle=43.4316,usage_system=74.3663,usage_user=59.3705 4201000000000 +cpu,cpu=2 usage_idle=89.4152,usage_system=45.2137,usage_user=56.9377 4202000000000 +cpu,cpu=3 usage_idle=44.8557,usage_system=11.1981,usage_user=34.6626 4203000000000 +cpu,cpu=4 usage_idle=76.9362,usage_system=23.9252,usage_user=63.0145 4204000000000 +cpu,cpu=0 usage_idle=34.4051,usage_system=92.8989,usage_user=72.7182 4205000000000 +cpu,cpu=1 usage_idle=87.9435,usage_system=23.6082,usage_user=27.0398 4206000000000 +cpu,cpu=2 usage_idle=34.4577,usage_system=20.2413,usage_user=66.5773 4207000000000 +cpu,cpu=3 usage_idle=48.2299,usage_system=68.0657,usage_user=84.1841 4208000000000 +cpu,cpu=4 usage_idle=49.7047,usage_system=63.8064,usage_user=15.3761 4209000000000 +cpu,cpu=0 usage_idle=99.6239,usage_system=45.85,usage_user=67.4626 4210000000000 +cpu,cpu=1 usage_idle=98.4982,usage_system=89.2816,usage_user=41.8289 4211000000000 +cpu,cpu=2 usage_idle=57.8687,usage_system=78.6968,usage_user=87.0427 4212000000000 +cpu,cpu=3 usage_idle=14.8064,usage_system=23.5525,usage_user=98.2408 4213000000000 +cpu,cpu=4 usage_idle=49.469,usage_system=0.48865,usage_user=22.1659 4214000000000 +cpu,cpu=0 usage_idle=12.4835,usage_system=34.8937,usage_user=15.0648 4215000000000 +cpu,cpu=1 usage_idle=85.2017,usage_system=22.8372,usage_user=38.6731 4216000000000 +cpu,cpu=2 usage_idle=12.2415,usage_system=57.295,usage_user=58.9143 4217000000000 +cpu,cpu=3 usage_idle=78.8188,usage_system=5.52487,usage_user=26.98 4218000000000 +cpu,cpu=4 usage_idle=63.0029,usage_system=55.2296,usage_user=90.7865 4219000000000 +cpu,cpu=0 usage_idle=78.379,usage_system=54.8535,usage_user=36.6364 4220000000000 +cpu,cpu=1 usage_idle=45.8416,usage_system=53.3517,usage_user=25.918 4221000000000 +cpu,cpu=2 usage_idle=87.6706,usage_system=11.2204,usage_user=4.61481 4222000000000 +cpu,cpu=3 usage_idle=74.7132,usage_system=26.0268,usage_user=28.1673 4223000000000 +cpu,cpu=4 usage_idle=72.954,usage_system=75.4958,usage_user=28.6559 4224000000000 +cpu,cpu=0 usage_idle=95.1199,usage_system=87.9793,usage_user=63.5496 4225000000000 +cpu,cpu=1 usage_idle=10.1847,usage_system=73.1811,usage_user=86.3869 4226000000000 +cpu,cpu=2 usage_idle=48.8578,usage_system=85.4225,usage_user=43.6819 4227000000000 +cpu,cpu=3 usage_idle=7.77214,usage_system=64.2413,usage_user=49.2068 4228000000000 +cpu,cpu=4 usage_idle=34.7522,usage_system=27.2442,usage_user=4.43636 4229000000000 +cpu,cpu=0 usage_idle=25.5386,usage_system=5.62317,usage_user=59.2899 4230000000000 +cpu,cpu=1 usage_idle=62.1751,usage_system=51.4648,usage_user=12.6416 4231000000000 +cpu,cpu=2 usage_idle=88.0931,usage_system=39.1354,usage_user=23.862 4232000000000 +cpu,cpu=3 usage_idle=92.7079,usage_system=13.8486,usage_user=49.8888 4233000000000 +cpu,cpu=4 usage_idle=20.8752,usage_system=86.8026,usage_user=25.3847 4234000000000 +cpu,cpu=0 usage_idle=49.5311,usage_system=81.9225,usage_user=13.364 4235000000000 +cpu,cpu=1 usage_idle=13.0808,usage_system=92.1073,usage_user=86.5451 4236000000000 +cpu,cpu=2 usage_idle=99.4677,usage_system=40.9651,usage_user=71.9676 4237000000000 +cpu,cpu=3 usage_idle=43.1496,usage_system=48.7372,usage_user=36.2089 4238000000000 +cpu,cpu=4 usage_idle=92.3563,usage_system=83.4894,usage_user=63.4531 4239000000000 +cpu,cpu=0 usage_idle=96.7927,usage_system=9.028,usage_user=69.0763 4240000000000 +cpu,cpu=1 usage_idle=56.0826,usage_system=71.2031,usage_user=20.5411 4241000000000 +cpu,cpu=2 usage_idle=68.7242,usage_system=59.2961,usage_user=59.6765 4242000000000 +cpu,cpu=3 usage_idle=92.5862,usage_system=52.004,usage_user=73.525 4243000000000 +cpu,cpu=4 usage_idle=42.475,usage_system=72.8792,usage_user=60.3276 4244000000000 +cpu,cpu=0 usage_idle=67.8597,usage_system=22.4104,usage_user=42.2502 4245000000000 +cpu,cpu=1 usage_idle=81.2237,usage_system=35.4912,usage_user=34.3574 4246000000000 +cpu,cpu=2 usage_idle=67.7688,usage_system=34.9589,usage_user=75.3225 4247000000000 +cpu,cpu=3 usage_idle=39.7365,usage_system=78.1084,usage_user=24.0597 4248000000000 +cpu,cpu=4 usage_idle=75.9454,usage_system=70.4648,usage_user=7.54911 4249000000000 +cpu,cpu=0 usage_idle=39.3985,usage_system=67.2575,usage_user=16.5771 4250000000000 +cpu,cpu=1 usage_idle=8.47482,usage_system=23.34,usage_user=87.7802 4251000000000 +cpu,cpu=2 usage_idle=29.0159,usage_system=92.0642,usage_user=47.0763 4252000000000 +cpu,cpu=3 usage_idle=88.6924,usage_system=84.6504,usage_user=99.0803 4253000000000 +cpu,cpu=4 usage_idle=62.2174,usage_system=27.1254,usage_user=71.9596 4254000000000 +cpu,cpu=0 usage_idle=22.545,usage_system=94.9851,usage_user=94.37 4255000000000 +cpu,cpu=1 usage_idle=64.7952,usage_system=76.2088,usage_user=29.8612 4256000000000 +cpu,cpu=2 usage_idle=99.1526,usage_system=43.9776,usage_user=64.82 4257000000000 +cpu,cpu=3 usage_idle=74.4751,usage_system=83.7141,usage_user=42.9285 4258000000000 +cpu,cpu=4 usage_idle=98.5348,usage_system=59.6595,usage_user=13.3932 4259000000000 +cpu,cpu=0 usage_idle=6.08394,usage_system=99.058,usage_user=80.6507 4260000000000 +cpu,cpu=1 usage_idle=22.661,usage_system=7.53282,usage_user=3.99074 4261000000000 +cpu,cpu=2 usage_idle=10.4412,usage_system=36.5487,usage_user=96.0549 4262000000000 +cpu,cpu=3 usage_idle=57.5175,usage_system=25.2411,usage_user=80.7053 4263000000000 +cpu,cpu=4 usage_idle=56.5979,usage_system=87.4585,usage_user=7.83066 4264000000000 +cpu,cpu=0 usage_idle=28.5575,usage_system=10.0035,usage_user=2.81572 4265000000000 +cpu,cpu=1 usage_idle=22.9274,usage_system=74.7987,usage_user=79.0245 4266000000000 +cpu,cpu=2 usage_idle=52.7886,usage_system=73.9513,usage_user=23.0021 4267000000000 +cpu,cpu=3 usage_idle=17.6086,usage_system=48.4264,usage_user=6.71619 4268000000000 +cpu,cpu=4 usage_idle=60.537,usage_system=46.9612,usage_user=66.3757 4269000000000 +cpu,cpu=0 usage_idle=73.9303,usage_system=53.0452,usage_user=65.4337 4270000000000 +cpu,cpu=1 usage_idle=54.581,usage_system=75.7062,usage_user=72.9665 4271000000000 +cpu,cpu=2 usage_idle=58.5717,usage_system=86.1474,usage_user=9.51523 4272000000000 +cpu,cpu=3 usage_idle=54.6266,usage_system=43.6649,usage_user=34.7563 4273000000000 +cpu,cpu=4 usage_idle=35.3319,usage_system=0.2628,usage_user=22.2148 4274000000000 +cpu,cpu=0 usage_idle=43.1626,usage_system=28.8203,usage_user=32.2183 4275000000000 +cpu,cpu=1 usage_idle=45.9783,usage_system=51.7477,usage_user=7.01701 4276000000000 +cpu,cpu=2 usage_idle=25.0028,usage_system=4.53626,usage_user=80.9683 4277000000000 +cpu,cpu=3 usage_idle=48.005,usage_system=22.1449,usage_user=29.3947 4278000000000 +cpu,cpu=4 usage_idle=54.7211,usage_system=82.6819,usage_user=76.356 4279000000000 +cpu,cpu=0 usage_idle=21.0968,usage_system=56.6122,usage_user=29.4011 4280000000000 +cpu,cpu=1 usage_idle=86.5305,usage_system=11.1932,usage_user=5.10736 4281000000000 +cpu,cpu=2 usage_idle=59.497,usage_system=69.7649,usage_user=91.2548 4282000000000 +cpu,cpu=3 usage_idle=69.0122,usage_system=24.3915,usage_user=34.9197 4283000000000 +cpu,cpu=4 usage_idle=3.76852,usage_system=59.7235,usage_user=35.1825 4284000000000 +cpu,cpu=0 usage_idle=25.9833,usage_system=2.88606,usage_user=64.0028 4285000000000 +cpu,cpu=1 usage_idle=58.2016,usage_system=48.8644,usage_user=15.7505 4286000000000 +cpu,cpu=2 usage_idle=65.2186,usage_system=73.8672,usage_user=20.2867 4287000000000 +cpu,cpu=3 usage_idle=46.1869,usage_system=21.8722,usage_user=42.4316 4288000000000 +cpu,cpu=4 usage_idle=75.5817,usage_system=76.5933,usage_user=25.1135 4289000000000 +cpu,cpu=0 usage_idle=51.9376,usage_system=97.6901,usage_user=81.7257 4290000000000 +cpu,cpu=1 usage_idle=81.3387,usage_system=84.2206,usage_user=92.9188 4291000000000 +cpu,cpu=2 usage_idle=86.4461,usage_system=43.7176,usage_user=62.6837 4292000000000 +cpu,cpu=3 usage_idle=77.7009,usage_system=12.7298,usage_user=87.0752 4293000000000 +cpu,cpu=4 usage_idle=12.6206,usage_system=16.4983,usage_user=46.7987 4294000000000 +cpu,cpu=0 usage_idle=47.8032,usage_system=42.4816,usage_user=49.6848 4295000000000 +cpu,cpu=1 usage_idle=11.806,usage_system=0.683264,usage_user=98.5492 4296000000000 +cpu,cpu=2 usage_idle=27.5564,usage_system=65.9019,usage_user=72.4164 4297000000000 +cpu,cpu=3 usage_idle=47.8432,usage_system=12.0888,usage_user=94.2885 4298000000000 +cpu,cpu=4 usage_idle=90.2747,usage_system=87.6705,usage_user=70.8818 4299000000000 +cpu,cpu=0 usage_idle=15.3882,usage_system=39.6081,usage_user=68.572 4300000000000 +cpu,cpu=1 usage_idle=97.1139,usage_system=20.9469,usage_user=52.7926 4301000000000 +cpu,cpu=2 usage_idle=90.0327,usage_system=7.39296,usage_user=96.5101 4302000000000 +cpu,cpu=3 usage_idle=52.7164,usage_system=85.0939,usage_user=9.23995 4303000000000 +cpu,cpu=4 usage_idle=39.7917,usage_system=97.7145,usage_user=25.7383 4304000000000 +cpu,cpu=0 usage_idle=86.5904,usage_system=45.5177,usage_user=68.2199 4305000000000 +cpu,cpu=1 usage_idle=36.2752,usage_system=57.3237,usage_user=68.9032 4306000000000 +cpu,cpu=2 usage_idle=34.8243,usage_system=84.8801,usage_user=34.8051 4307000000000 +cpu,cpu=3 usage_idle=7.2407,usage_system=32.7233,usage_user=46.8939 4308000000000 +cpu,cpu=4 usage_idle=1.52923,usage_system=22.998,usage_user=34.5644 4309000000000 +cpu,cpu=0 usage_idle=72.4111,usage_system=38.3863,usage_user=74.1725 4310000000000 +cpu,cpu=1 usage_idle=40.983,usage_system=35.5001,usage_user=95.1194 4311000000000 +cpu,cpu=2 usage_idle=93.7756,usage_system=25.5328,usage_user=2.51232 4312000000000 +cpu,cpu=3 usage_idle=90.2857,usage_system=78.2493,usage_user=87.6062 4313000000000 +cpu,cpu=4 usage_idle=99.5257,usage_system=18.0409,usage_user=85.3207 4314000000000 +cpu,cpu=0 usage_idle=25.2639,usage_system=4.6313,usage_user=30.8384 4315000000000 +cpu,cpu=1 usage_idle=93.4838,usage_system=40.9065,usage_user=88.1621 4316000000000 +cpu,cpu=2 usage_idle=62.387,usage_system=75.7308,usage_user=73.0422 4317000000000 +cpu,cpu=3 usage_idle=97.1921,usage_system=82.9715,usage_user=5.7655 4318000000000 +cpu,cpu=4 usage_idle=44.086,usage_system=84.5007,usage_user=28.7635 4319000000000 +cpu,cpu=0 usage_idle=78.6504,usage_system=56.9118,usage_user=67.1498 4320000000000 +cpu,cpu=1 usage_idle=52.8229,usage_system=97.8948,usage_user=2.64992 4321000000000 +cpu,cpu=2 usage_idle=47.9423,usage_system=91.6704,usage_user=28.1828 4322000000000 +cpu,cpu=3 usage_idle=50.4546,usage_system=81.9561,usage_user=6.432 4323000000000 +cpu,cpu=4 usage_idle=38.0608,usage_system=81.4818,usage_user=24.4729 4324000000000 +cpu,cpu=0 usage_idle=23.3815,usage_system=6.74572,usage_user=29.1042 4325000000000 +cpu,cpu=1 usage_idle=54.2199,usage_system=0.22957,usage_user=70.0107 4326000000000 +cpu,cpu=2 usage_idle=42.382,usage_system=62.6166,usage_user=45.7415 4327000000000 +cpu,cpu=3 usage_idle=15.4242,usage_system=59.8087,usage_user=28.713 4328000000000 +cpu,cpu=4 usage_idle=21.1897,usage_system=3.89469,usage_user=13.2137 4329000000000 +cpu,cpu=0 usage_idle=49.9533,usage_system=82.5451,usage_user=70.1255 4330000000000 +cpu,cpu=1 usage_idle=17.1031,usage_system=35.368,usage_user=68.0203 4331000000000 +cpu,cpu=2 usage_idle=19.753,usage_system=83.3103,usage_user=59.6907 4332000000000 +cpu,cpu=3 usage_idle=47.9357,usage_system=33.7649,usage_user=41.6468 4333000000000 +cpu,cpu=4 usage_idle=54.3677,usage_system=71.8257,usage_user=23.1286 4334000000000 +cpu,cpu=0 usage_idle=78.8406,usage_system=95.2072,usage_user=29.8743 4335000000000 +cpu,cpu=1 usage_idle=7.94486,usage_system=49.4271,usage_user=30.1039 4336000000000 +cpu,cpu=2 usage_idle=77.9555,usage_system=91.8091,usage_user=92.7204 4337000000000 +cpu,cpu=3 usage_idle=23.697,usage_system=7.23337,usage_user=52.5291 4338000000000 +cpu,cpu=4 usage_idle=52.41,usage_system=28.4231,usage_user=56.4238 4339000000000 +cpu,cpu=0 usage_idle=65.6237,usage_system=78.3764,usage_user=38.9689 4340000000000 +cpu,cpu=1 usage_idle=35.7492,usage_system=95.4794,usage_user=74.3369 4341000000000 +cpu,cpu=2 usage_idle=3.76945,usage_system=15.2324,usage_user=57.6472 4342000000000 +cpu,cpu=3 usage_idle=63.4601,usage_system=63.1682,usage_user=91.4121 4343000000000 +cpu,cpu=4 usage_idle=5.10691,usage_system=17.5359,usage_user=63.2377 4344000000000 +cpu,cpu=0 usage_idle=28.2355,usage_system=96.3765,usage_user=58.4449 4345000000000 +cpu,cpu=1 usage_idle=58.1098,usage_system=4.32139,usage_user=7.87204 4346000000000 +cpu,cpu=2 usage_idle=88.2136,usage_system=82.2769,usage_user=99.6812 4347000000000 +cpu,cpu=3 usage_idle=80.934,usage_system=5.97395,usage_user=6.91454 4348000000000 +cpu,cpu=4 usage_idle=33.4632,usage_system=58.3839,usage_user=35.3377 4349000000000 +cpu,cpu=0 usage_idle=89.887,usage_system=24.0076,usage_user=13.714 4350000000000 +cpu,cpu=1 usage_idle=28.8559,usage_system=59.7568,usage_user=9.19349 4351000000000 +cpu,cpu=2 usage_idle=3.19279,usage_system=63.5262,usage_user=24.4259 4352000000000 +cpu,cpu=3 usage_idle=60.84,usage_system=26.9864,usage_user=87.5941 4353000000000 +cpu,cpu=4 usage_idle=52.2521,usage_system=32.0933,usage_user=5.12994 4354000000000 +cpu,cpu=0 usage_idle=15.4898,usage_system=60.3287,usage_user=1.50647 4355000000000 +cpu,cpu=1 usage_idle=73.9347,usage_system=18.4385,usage_user=5.82785 4356000000000 +cpu,cpu=2 usage_idle=81.8068,usage_system=6.65209,usage_user=88.1048 4357000000000 +cpu,cpu=3 usage_idle=81.488,usage_system=87.5861,usage_user=94.0787 4358000000000 +cpu,cpu=4 usage_idle=88.4025,usage_system=21.0493,usage_user=52.4627 4359000000000 +cpu,cpu=0 usage_idle=23.7402,usage_system=10.9363,usage_user=76.4703 4360000000000 +cpu,cpu=1 usage_idle=37.4542,usage_system=39.7922,usage_user=36.2271 4361000000000 +cpu,cpu=2 usage_idle=46.6477,usage_system=42.985,usage_user=99.7533 4362000000000 +cpu,cpu=3 usage_idle=71.0736,usage_system=3.82495,usage_user=26.7396 4363000000000 +cpu,cpu=4 usage_idle=58.6677,usage_system=56.077,usage_user=58.8329 4364000000000 +cpu,cpu=0 usage_idle=63.7976,usage_system=71.5668,usage_user=19.1616 4365000000000 +cpu,cpu=1 usage_idle=65.3041,usage_system=45.5015,usage_user=37.6001 4366000000000 +cpu,cpu=2 usage_idle=71.1319,usage_system=27.3083,usage_user=44.2522 4367000000000 +cpu,cpu=3 usage_idle=59.2367,usage_system=8.79628,usage_user=31.8384 4368000000000 +cpu,cpu=4 usage_idle=53.3154,usage_system=97.1988,usage_user=52.8877 4369000000000 +cpu,cpu=0 usage_idle=5.7781,usage_system=20.9389,usage_user=63.8239 4370000000000 +cpu,cpu=1 usage_idle=82.2484,usage_system=58.3931,usage_user=3.61611 4371000000000 +cpu,cpu=2 usage_idle=18.4755,usage_system=5.0408,usage_user=46.6011 4372000000000 +cpu,cpu=3 usage_idle=18.2288,usage_system=76.1144,usage_user=50.426 4373000000000 +cpu,cpu=4 usage_idle=44.9684,usage_system=34.782,usage_user=6.50303 4374000000000 +cpu,cpu=0 usage_idle=3.80131,usage_system=98.5796,usage_user=78.0698 4375000000000 +cpu,cpu=1 usage_idle=22.963,usage_system=63.8837,usage_user=23.5714 4376000000000 +cpu,cpu=2 usage_idle=60.5631,usage_system=35.0156,usage_user=50.8797 4377000000000 +cpu,cpu=3 usage_idle=4.8153,usage_system=94.2523,usage_user=59.676 4378000000000 +cpu,cpu=4 usage_idle=36.6536,usage_system=47.5677,usage_user=56.8748 4379000000000 +cpu,cpu=0 usage_idle=89.5413,usage_system=53.3458,usage_user=77.8137 4380000000000 +cpu,cpu=1 usage_idle=53.3652,usage_system=35.5942,usage_user=36.2068 4381000000000 +cpu,cpu=2 usage_idle=56.9814,usage_system=54.0697,usage_user=41.2476 4382000000000 +cpu,cpu=3 usage_idle=3.58243,usage_system=72.2984,usage_user=17.362 4383000000000 +cpu,cpu=4 usage_idle=54.0085,usage_system=17.2668,usage_user=52.144 4384000000000 +cpu,cpu=0 usage_idle=60.5115,usage_system=21.0681,usage_user=50.7237 4385000000000 +cpu,cpu=1 usage_idle=38.5813,usage_system=44.0311,usage_user=14.6074 4386000000000 +cpu,cpu=2 usage_idle=62.1527,usage_system=4.59418,usage_user=49.623 4387000000000 +cpu,cpu=3 usage_idle=13.0324,usage_system=9.40948,usage_user=43.8753 4388000000000 +cpu,cpu=4 usage_idle=72.7084,usage_system=46.0631,usage_user=91.443 4389000000000 +cpu,cpu=0 usage_idle=29.5831,usage_system=35.6044,usage_user=44.7889 4390000000000 +cpu,cpu=1 usage_idle=7.39682,usage_system=88.9697,usage_user=80.3831 4391000000000 +cpu,cpu=2 usage_idle=43.6036,usage_system=45.951,usage_user=34.4528 4392000000000 +cpu,cpu=3 usage_idle=84.8512,usage_system=49.5335,usage_user=6.75123 4393000000000 +cpu,cpu=4 usage_idle=2.2132,usage_system=3.54191,usage_user=24.0181 4394000000000 +cpu,cpu=0 usage_idle=54.3572,usage_system=64.0534,usage_user=45.0862 4395000000000 +cpu,cpu=1 usage_idle=5.08088,usage_system=2.6347,usage_user=89.1173 4396000000000 +cpu,cpu=2 usage_idle=19.6882,usage_system=64.7874,usage_user=93.7115 4397000000000 +cpu,cpu=3 usage_idle=69.3112,usage_system=77.8198,usage_user=3.12097 4398000000000 +cpu,cpu=4 usage_idle=13.1865,usage_system=50.5282,usage_user=49.1841 4399000000000 +cpu,cpu=0 usage_idle=4.62948,usage_system=80.1113,usage_user=84.7885 4400000000000 +cpu,cpu=1 usage_idle=49.4183,usage_system=87.5081,usage_user=73.7582 4401000000000 +cpu,cpu=2 usage_idle=29.8014,usage_system=31.1117,usage_user=19.7092 4402000000000 +cpu,cpu=3 usage_idle=64.2542,usage_system=15.963,usage_user=69.2427 4403000000000 +cpu,cpu=4 usage_idle=71.0054,usage_system=18.1762,usage_user=72.7846 4404000000000 +cpu,cpu=0 usage_idle=95.0235,usage_system=72.5334,usage_user=36.838 4405000000000 +cpu,cpu=1 usage_idle=40.1097,usage_system=77.6143,usage_user=39.4727 4406000000000 +cpu,cpu=2 usage_idle=29.227,usage_system=97.3025,usage_user=4.26006 4407000000000 +cpu,cpu=3 usage_idle=22.9385,usage_system=66.6137,usage_user=82.0798 4408000000000 +cpu,cpu=4 usage_idle=26.0595,usage_system=79.8002,usage_user=32.608 4409000000000 +cpu,cpu=0 usage_idle=75.2436,usage_system=84.4297,usage_user=12.7193 4410000000000 +cpu,cpu=1 usage_idle=60.0321,usage_system=33.848,usage_user=0.227431 4411000000000 +cpu,cpu=2 usage_idle=33.7903,usage_system=63.6494,usage_user=31.3392 4412000000000 +cpu,cpu=3 usage_idle=53.4996,usage_system=27.9037,usage_user=47.3021 4413000000000 +cpu,cpu=4 usage_idle=22.7422,usage_system=98.9091,usage_user=65.4783 4414000000000 +cpu,cpu=0 usage_idle=95.5268,usage_system=93.9326,usage_user=38.0117 4415000000000 +cpu,cpu=1 usage_idle=32.3648,usage_system=34.0424,usage_user=15.626 4416000000000 +cpu,cpu=2 usage_idle=71.8375,usage_system=63.2694,usage_user=12.9285 4417000000000 +cpu,cpu=3 usage_idle=76.0976,usage_system=86.2079,usage_user=79.5422 4418000000000 +cpu,cpu=4 usage_idle=58.1774,usage_system=12.2674,usage_user=59.3424 4419000000000 +cpu,cpu=0 usage_idle=90.7854,usage_system=87.511,usage_user=43.7721 4420000000000 +cpu,cpu=1 usage_idle=3.50472,usage_system=47.5432,usage_user=77.6201 4421000000000 +cpu,cpu=2 usage_idle=3.73215,usage_system=81.3335,usage_user=41.2695 4422000000000 +cpu,cpu=3 usage_idle=35.0713,usage_system=34.8331,usage_user=69.1732 4423000000000 +cpu,cpu=4 usage_idle=82.3735,usage_system=57.5753,usage_user=68.0823 4424000000000 +cpu,cpu=0 usage_idle=47.8518,usage_system=53.1021,usage_user=62.0149 4425000000000 +cpu,cpu=1 usage_idle=85.8635,usage_system=85.467,usage_user=96.0573 4426000000000 +cpu,cpu=2 usage_idle=1.48949,usage_system=57.3044,usage_user=59.3267 4427000000000 +cpu,cpu=3 usage_idle=14.418,usage_system=33.402,usage_user=45.5346 4428000000000 +cpu,cpu=4 usage_idle=93.9602,usage_system=91.5794,usage_user=57.802 4429000000000 +cpu,cpu=0 usage_idle=53.3026,usage_system=82.3648,usage_user=45.3131 4430000000000 +cpu,cpu=1 usage_idle=97.0747,usage_system=85.8695,usage_user=92.8563 4431000000000 +cpu,cpu=2 usage_idle=74.6948,usage_system=89.6017,usage_user=74.1898 4432000000000 +cpu,cpu=3 usage_idle=15.9643,usage_system=24.673,usage_user=9.02281 4433000000000 +cpu,cpu=4 usage_idle=85.1375,usage_system=7.0465,usage_user=66.5981 4434000000000 +cpu,cpu=0 usage_idle=53.2198,usage_system=54.8983,usage_user=19.7002 4435000000000 +cpu,cpu=1 usage_idle=15.2347,usage_system=40.7618,usage_user=5.16718 4436000000000 +cpu,cpu=2 usage_idle=11.2919,usage_system=42.2513,usage_user=62.4716 4437000000000 +cpu,cpu=3 usage_idle=70.6186,usage_system=56.6693,usage_user=95.8736 4438000000000 +cpu,cpu=4 usage_idle=16.1532,usage_system=50.6295,usage_user=87.4531 4439000000000 +cpu,cpu=0 usage_idle=73.9552,usage_system=3.93205,usage_user=69.8179 4440000000000 +cpu,cpu=1 usage_idle=19.2683,usage_system=1.00672,usage_user=55.6874 4441000000000 +cpu,cpu=2 usage_idle=12.1245,usage_system=75.7015,usage_user=45.2891 4442000000000 +cpu,cpu=3 usage_idle=86.3143,usage_system=91.6658,usage_user=69.9621 4443000000000 +cpu,cpu=4 usage_idle=95.3371,usage_system=76.8032,usage_user=77.0086 4444000000000 +cpu,cpu=0 usage_idle=61.9352,usage_system=30.023,usage_user=31.9069 4445000000000 +cpu,cpu=1 usage_idle=81.6354,usage_system=45.2576,usage_user=72.6687 4446000000000 +cpu,cpu=2 usage_idle=86.8026,usage_system=56.5495,usage_user=14.92 4447000000000 +cpu,cpu=3 usage_idle=49.2743,usage_system=27.1681,usage_user=71.5892 4448000000000 +cpu,cpu=4 usage_idle=45.1479,usage_system=43.3213,usage_user=22.2187 4449000000000 +cpu,cpu=0 usage_idle=32.6009,usage_system=17.2765,usage_user=26.1507 4450000000000 +cpu,cpu=1 usage_idle=2.41882,usage_system=36.5447,usage_user=27.1575 4451000000000 +cpu,cpu=2 usage_idle=58.1062,usage_system=48.6693,usage_user=2.85895 4452000000000 +cpu,cpu=3 usage_idle=3.39535,usage_system=34.9836,usage_user=94.5247 4453000000000 +cpu,cpu=4 usage_idle=73.3575,usage_system=30.3207,usage_user=71.3279 4454000000000 +cpu,cpu=0 usage_idle=50.3661,usage_system=92.2559,usage_user=1.35092 4455000000000 +cpu,cpu=1 usage_idle=82.273,usage_system=73.8913,usage_user=46.6086 4456000000000 +cpu,cpu=2 usage_idle=54.9417,usage_system=60.694,usage_user=3.1581 4457000000000 +cpu,cpu=3 usage_idle=69.8617,usage_system=9.9682,usage_user=30.3262 4458000000000 +cpu,cpu=4 usage_idle=41.4509,usage_system=55.1161,usage_user=73.6475 4459000000000 +cpu,cpu=0 usage_idle=63.6696,usage_system=87.717,usage_user=90.9239 4460000000000 +cpu,cpu=1 usage_idle=89.8204,usage_system=90.1359,usage_user=27.4687 4461000000000 +cpu,cpu=2 usage_idle=16.9778,usage_system=48.2421,usage_user=76.1379 4462000000000 +cpu,cpu=3 usage_idle=19.8368,usage_system=51.6374,usage_user=11.1215 4463000000000 +cpu,cpu=4 usage_idle=14.3615,usage_system=24.9949,usage_user=41.4422 4464000000000 +cpu,cpu=0 usage_idle=85.6894,usage_system=75.361,usage_user=33.6981 4465000000000 +cpu,cpu=1 usage_idle=87.0404,usage_system=57.634,usage_user=7.58939 4466000000000 +cpu,cpu=2 usage_idle=33.6489,usage_system=12.5757,usage_user=68.2833 4467000000000 +cpu,cpu=3 usage_idle=36.807,usage_system=82.4374,usage_user=78.2515 4468000000000 +cpu,cpu=4 usage_idle=67.1332,usage_system=23.8884,usage_user=33.3676 4469000000000 +cpu,cpu=0 usage_idle=40.7807,usage_system=87.558,usage_user=21.0847 4470000000000 +cpu,cpu=1 usage_idle=31.7046,usage_system=77.3784,usage_user=11.2205 4471000000000 +cpu,cpu=2 usage_idle=59.1733,usage_system=94.3562,usage_user=59.4626 4472000000000 +cpu,cpu=3 usage_idle=35.3112,usage_system=14.193,usage_user=11.1001 4473000000000 +cpu,cpu=4 usage_idle=46.4327,usage_system=28.5545,usage_user=36.095 4474000000000 +cpu,cpu=0 usage_idle=87.8749,usage_system=14.244,usage_user=11.456 4475000000000 +cpu,cpu=1 usage_idle=21.573,usage_system=1.28433,usage_user=69.0901 4476000000000 +cpu,cpu=2 usage_idle=29.1624,usage_system=34.9333,usage_user=81.6658 4477000000000 +cpu,cpu=3 usage_idle=97.4457,usage_system=71.7403,usage_user=64.1032 4478000000000 +cpu,cpu=4 usage_idle=75.6973,usage_system=38.8735,usage_user=87.9916 4479000000000 +cpu,cpu=0 usage_idle=9.0649,usage_system=79.6542,usage_user=75.5496 4480000000000 +cpu,cpu=1 usage_idle=30.1496,usage_system=11.3589,usage_user=52.9279 4481000000000 +cpu,cpu=2 usage_idle=41.3701,usage_system=70.5322,usage_user=47.2841 4482000000000 +cpu,cpu=3 usage_idle=0.832783,usage_system=5.84341,usage_user=61.4771 4483000000000 +cpu,cpu=4 usage_idle=11.9329,usage_system=52.2762,usage_user=90.0316 4484000000000 +cpu,cpu=0 usage_idle=48.0279,usage_system=40.1511,usage_user=4.27559 4485000000000 +cpu,cpu=1 usage_idle=59.4839,usage_system=61.7241,usage_user=5.55992 4486000000000 +cpu,cpu=2 usage_idle=28.574,usage_system=90.8864,usage_user=40.4932 4487000000000 +cpu,cpu=3 usage_idle=10.2398,usage_system=88.3321,usage_user=12.2334 4488000000000 +cpu,cpu=4 usage_idle=74.343,usage_system=64.0294,usage_user=51.107 4489000000000 +cpu,cpu=0 usage_idle=62.3346,usage_system=73.0943,usage_user=30.7612 4490000000000 +cpu,cpu=1 usage_idle=37.8841,usage_system=3.2439,usage_user=42.1201 4491000000000 +cpu,cpu=2 usage_idle=90.8121,usage_system=44.614,usage_user=12.6522 4492000000000 +cpu,cpu=3 usage_idle=38.0962,usage_system=45.4468,usage_user=18.4956 4493000000000 +cpu,cpu=4 usage_idle=99.5733,usage_system=57.3797,usage_user=70.7718 4494000000000 +cpu,cpu=0 usage_idle=89.6049,usage_system=5.40758,usage_user=10.9229 4495000000000 +cpu,cpu=1 usage_idle=93.8805,usage_system=64.8915,usage_user=72.6469 4496000000000 +cpu,cpu=2 usage_idle=99.4405,usage_system=93.4655,usage_user=63.5334 4497000000000 +cpu,cpu=3 usage_idle=39.9336,usage_system=3.70525,usage_user=51.8655 4498000000000 +cpu,cpu=4 usage_idle=52.1671,usage_system=78.0482,usage_user=15.8949 4499000000000 +cpu,cpu=0 usage_idle=3.27404,usage_system=40.3828,usage_user=88.9892 4500000000000 +cpu,cpu=1 usage_idle=34.0352,usage_system=78.267,usage_user=92.2331 4501000000000 +cpu,cpu=2 usage_idle=76.1553,usage_system=69.079,usage_user=36.8472 4502000000000 +cpu,cpu=3 usage_idle=88.8075,usage_system=7.1752,usage_user=82.294 4503000000000 +cpu,cpu=4 usage_idle=7.30314,usage_system=6.74851,usage_user=39.6737 4504000000000 +cpu,cpu=0 usage_idle=78.0749,usage_system=96.3535,usage_user=45.0812 4505000000000 +cpu,cpu=1 usage_idle=88.9978,usage_system=90.234,usage_user=9.97274 4506000000000 +cpu,cpu=2 usage_idle=61.6447,usage_system=89.6745,usage_user=3.43822 4507000000000 +cpu,cpu=3 usage_idle=25.1781,usage_system=29.6081,usage_user=7.14346 4508000000000 +cpu,cpu=4 usage_idle=77.0436,usage_system=81.7752,usage_user=85.1917 4509000000000 +cpu,cpu=0 usage_idle=92.9385,usage_system=85.0492,usage_user=25.5745 4510000000000 +cpu,cpu=1 usage_idle=81.9278,usage_system=19.0845,usage_user=3.84147 4511000000000 +cpu,cpu=2 usage_idle=74.1609,usage_system=95.2397,usage_user=72.9205 4512000000000 +cpu,cpu=3 usage_idle=11.0081,usage_system=84.0472,usage_user=80.0957 4513000000000 +cpu,cpu=4 usage_idle=93.302,usage_system=91.3504,usage_user=86.8442 4514000000000 +cpu,cpu=0 usage_idle=32.9757,usage_system=69.4253,usage_user=83.1976 4515000000000 +cpu,cpu=1 usage_idle=78.0569,usage_system=58.4231,usage_user=73.4316 4516000000000 +cpu,cpu=2 usage_idle=88.0297,usage_system=20.0679,usage_user=63.1061 4517000000000 +cpu,cpu=3 usage_idle=91.4679,usage_system=45.246,usage_user=92.7142 4518000000000 +cpu,cpu=4 usage_idle=98.6114,usage_system=22.2896,usage_user=74.4894 4519000000000 +cpu,cpu=0 usage_idle=83.8031,usage_system=15.2281,usage_user=59.5386 4520000000000 +cpu,cpu=1 usage_idle=9.37758,usage_system=97.1559,usage_user=78.6231 4521000000000 +cpu,cpu=2 usage_idle=13.219,usage_system=71.3168,usage_user=73.8628 4522000000000 +cpu,cpu=3 usage_idle=86.1395,usage_system=82.3248,usage_user=57.91 4523000000000 +cpu,cpu=4 usage_idle=66.2352,usage_system=75.6269,usage_user=49.2604 4524000000000 +cpu,cpu=0 usage_idle=53.0794,usage_system=8.60255,usage_user=18.6857 4525000000000 +cpu,cpu=1 usage_idle=36.277,usage_system=86.6595,usage_user=77.1089 4526000000000 +cpu,cpu=2 usage_idle=9.70869,usage_system=74.6892,usage_user=97.1767 4527000000000 +cpu,cpu=3 usage_idle=72.8148,usage_system=66.157,usage_user=42.4227 4528000000000 +cpu,cpu=4 usage_idle=65.529,usage_system=64.7684,usage_user=64.7122 4529000000000 +cpu,cpu=0 usage_idle=40.0184,usage_system=48.5715,usage_user=79.9403 4530000000000 +cpu,cpu=1 usage_idle=99.557,usage_system=57.949,usage_user=77.0962 4531000000000 +cpu,cpu=2 usage_idle=78.1801,usage_system=71.1681,usage_user=48.413 4532000000000 +cpu,cpu=3 usage_idle=52.0429,usage_system=57.3076,usage_user=30.7378 4533000000000 +cpu,cpu=4 usage_idle=9.95295,usage_system=23.5428,usage_user=6.36465 4534000000000 +cpu,cpu=0 usage_idle=59.2134,usage_system=76.6222,usage_user=14.9672 4535000000000 +cpu,cpu=1 usage_idle=77.8991,usage_system=12.8992,usage_user=1.62668 4536000000000 +cpu,cpu=2 usage_idle=55.008,usage_system=22.6079,usage_user=76.3158 4537000000000 +cpu,cpu=3 usage_idle=52.1847,usage_system=95.4227,usage_user=42.4729 4538000000000 +cpu,cpu=4 usage_idle=94.6074,usage_system=60.9517,usage_user=7.24128 4539000000000 +cpu,cpu=0 usage_idle=59.3196,usage_system=0.970153,usage_user=55.8127 4540000000000 +cpu,cpu=1 usage_idle=39.26,usage_system=0.527177,usage_user=13.7618 4541000000000 +cpu,cpu=2 usage_idle=16.3562,usage_system=78.7073,usage_user=84.9298 4542000000000 +cpu,cpu=3 usage_idle=64.7691,usage_system=30.7502,usage_user=42.2375 4543000000000 +cpu,cpu=4 usage_idle=95.5069,usage_system=40.7031,usage_user=65.7803 4544000000000 +cpu,cpu=0 usage_idle=1.87159,usage_system=99.9165,usage_user=42.4025 4545000000000 +cpu,cpu=1 usage_idle=16.8388,usage_system=77.8157,usage_user=55.3017 4546000000000 +cpu,cpu=2 usage_idle=18.4655,usage_system=32.8237,usage_user=77.9096 4547000000000 +cpu,cpu=3 usage_idle=94.7813,usage_system=85.0084,usage_user=73.3324 4548000000000 +cpu,cpu=4 usage_idle=37.2542,usage_system=79.6158,usage_user=34.2841 4549000000000 +cpu,cpu=0 usage_idle=44.4954,usage_system=38.9354,usage_user=35.2543 4550000000000 +cpu,cpu=1 usage_idle=0.308174,usage_system=78.1954,usage_user=35.7815 4551000000000 +cpu,cpu=2 usage_idle=14.0699,usage_system=94.5515,usage_user=14.4887 4552000000000 +cpu,cpu=3 usage_idle=98.9998,usage_system=59.3207,usage_user=45.2389 4553000000000 +cpu,cpu=4 usage_idle=41.2372,usage_system=54.8276,usage_user=85.942 4554000000000 +cpu,cpu=0 usage_idle=7.01751,usage_system=56.6992,usage_user=85.8586 4555000000000 +cpu,cpu=1 usage_idle=49.42,usage_system=73.538,usage_user=63.6742 4556000000000 +cpu,cpu=2 usage_idle=4.72169,usage_system=92.0034,usage_user=96.4979 4557000000000 +cpu,cpu=3 usage_idle=82.6313,usage_system=86.7847,usage_user=81.5063 4558000000000 +cpu,cpu=4 usage_idle=55.9637,usage_system=24.0389,usage_user=61.122 4559000000000 +cpu,cpu=0 usage_idle=90.2478,usage_system=68.5343,usage_user=0.0574419 4560000000000 +cpu,cpu=1 usage_idle=25.5021,usage_system=68.8425,usage_user=78.2528 4561000000000 +cpu,cpu=2 usage_idle=61.2836,usage_system=82.9125,usage_user=72.8044 4562000000000 +cpu,cpu=3 usage_idle=75.7723,usage_system=81.9122,usage_user=32.125 4563000000000 +cpu,cpu=4 usage_idle=21.0112,usage_system=23.1495,usage_user=86.9527 4564000000000 +cpu,cpu=0 usage_idle=6.95327,usage_system=30.167,usage_user=43.6519 4565000000000 +cpu,cpu=1 usage_idle=92.8118,usage_system=79.587,usage_user=17.1898 4566000000000 +cpu,cpu=2 usage_idle=56.4861,usage_system=84.3087,usage_user=9.19328 4567000000000 +cpu,cpu=3 usage_idle=52.9839,usage_system=66.94,usage_user=95.978 4568000000000 +cpu,cpu=4 usage_idle=34.4902,usage_system=22.9037,usage_user=20.0169 4569000000000 +cpu,cpu=0 usage_idle=95.6122,usage_system=13.1516,usage_user=88.5512 4570000000000 +cpu,cpu=1 usage_idle=95.6697,usage_system=38.6537,usage_user=57.3938 4571000000000 +cpu,cpu=2 usage_idle=73.9225,usage_system=99.9373,usage_user=40.3062 4572000000000 +cpu,cpu=3 usage_idle=46.7268,usage_system=75.7096,usage_user=22.2185 4573000000000 +cpu,cpu=4 usage_idle=78.8519,usage_system=96.7208,usage_user=45.3679 4574000000000 +cpu,cpu=0 usage_idle=65.8045,usage_system=3.6741,usage_user=75.5349 4575000000000 +cpu,cpu=1 usage_idle=9.45637,usage_system=96.4859,usage_user=55.1219 4576000000000 +cpu,cpu=2 usage_idle=26.6462,usage_system=52.972,usage_user=39.4306 4577000000000 +cpu,cpu=3 usage_idle=35.8395,usage_system=5.95592,usage_user=6.37061 4578000000000 +cpu,cpu=4 usage_idle=31.8175,usage_system=40.4461,usage_user=29.2743 4579000000000 +cpu,cpu=0 usage_idle=51.8344,usage_system=36.0583,usage_user=42.4259 4580000000000 +cpu,cpu=1 usage_idle=40.3857,usage_system=31.728,usage_user=81.0796 4581000000000 +cpu,cpu=2 usage_idle=97.7794,usage_system=5.65048,usage_user=81.0169 4582000000000 +cpu,cpu=3 usage_idle=38.0856,usage_system=52.3773,usage_user=56.7265 4583000000000 +cpu,cpu=4 usage_idle=60.3041,usage_system=31.2292,usage_user=53.4473 4584000000000 +cpu,cpu=0 usage_idle=5.67204,usage_system=97.0337,usage_user=57.1214 4585000000000 +cpu,cpu=1 usage_idle=81.207,usage_system=6.49007,usage_user=53.6074 4586000000000 +cpu,cpu=2 usage_idle=36.3289,usage_system=33.1363,usage_user=6.57937 4587000000000 +cpu,cpu=3 usage_idle=75.7595,usage_system=68.9758,usage_user=12.5353 4588000000000 +cpu,cpu=4 usage_idle=82.1301,usage_system=0.793308,usage_user=52.9814 4589000000000 +cpu,cpu=0 usage_idle=11.4045,usage_system=52.6277,usage_user=89.0397 4590000000000 +cpu,cpu=1 usage_idle=53.8304,usage_system=93.0134,usage_user=20.7677 4591000000000 +cpu,cpu=2 usage_idle=34.91,usage_system=90.7929,usage_user=26.4182 4592000000000 +cpu,cpu=3 usage_idle=15.9269,usage_system=28.8785,usage_user=78.7955 4593000000000 +cpu,cpu=4 usage_idle=72.6534,usage_system=89.1826,usage_user=10.0247 4594000000000 +cpu,cpu=0 usage_idle=26.1008,usage_system=94.8546,usage_user=7.0584 4595000000000 +cpu,cpu=1 usage_idle=83.2222,usage_system=76.0616,usage_user=13.5485 4596000000000 +cpu,cpu=2 usage_idle=36.8296,usage_system=12.3906,usage_user=46.6848 4597000000000 +cpu,cpu=3 usage_idle=43.409,usage_system=88.1501,usage_user=15.6606 4598000000000 +cpu,cpu=4 usage_idle=55.9442,usage_system=70.2802,usage_user=16.4539 4599000000000 +cpu,cpu=0 usage_idle=8.92564,usage_system=81.6847,usage_user=69.0816 4600000000000 +cpu,cpu=1 usage_idle=97.9654,usage_system=35.5151,usage_user=62.095 4601000000000 +cpu,cpu=2 usage_idle=18.7331,usage_system=70.4252,usage_user=52.8879 4602000000000 +cpu,cpu=3 usage_idle=45.1513,usage_system=86.3521,usage_user=81.7664 4603000000000 +cpu,cpu=4 usage_idle=23.9468,usage_system=59.0055,usage_user=70.949 4604000000000 +cpu,cpu=0 usage_idle=33.9715,usage_system=85.1063,usage_user=65.8036 4605000000000 +cpu,cpu=1 usage_idle=41.0299,usage_system=68.3285,usage_user=41.8653 4606000000000 +cpu,cpu=2 usage_idle=54.5784,usage_system=5.1581,usage_user=54.2558 4607000000000 +cpu,cpu=3 usage_idle=1.26317,usage_system=48.5671,usage_user=42.4059 4608000000000 +cpu,cpu=4 usage_idle=16.9237,usage_system=4.51129,usage_user=12.6861 4609000000000 +cpu,cpu=0 usage_idle=33.3776,usage_system=13.4369,usage_user=94.3709 4610000000000 +cpu,cpu=1 usage_idle=2.45919,usage_system=11.4023,usage_user=29.886 4611000000000 +cpu,cpu=2 usage_idle=64.5542,usage_system=30.1354,usage_user=0.311138 4612000000000 +cpu,cpu=3 usage_idle=17.4421,usage_system=75.2867,usage_user=86.6632 4613000000000 +cpu,cpu=4 usage_idle=99.2085,usage_system=99.2336,usage_user=45.6687 4614000000000 +cpu,cpu=0 usage_idle=70.1575,usage_system=33.2051,usage_user=30.775 4615000000000 +cpu,cpu=1 usage_idle=35.9611,usage_system=74.235,usage_user=99.1036 4616000000000 +cpu,cpu=2 usage_idle=77.8263,usage_system=28.8134,usage_user=4.26166 4617000000000 +cpu,cpu=3 usage_idle=32.0821,usage_system=30.0766,usage_user=52.8287 4618000000000 +cpu,cpu=4 usage_idle=74.488,usage_system=47.0003,usage_user=57.34 4619000000000 +cpu,cpu=0 usage_idle=87.1742,usage_system=80.3779,usage_user=70.7769 4620000000000 +cpu,cpu=1 usage_idle=81.545,usage_system=82.8371,usage_user=82.1792 4621000000000 +cpu,cpu=2 usage_idle=11.431,usage_system=47.3913,usage_user=12.3146 4622000000000 +cpu,cpu=3 usage_idle=11.7422,usage_system=64.8334,usage_user=87.6014 4623000000000 +cpu,cpu=4 usage_idle=98.4054,usage_system=64.0419,usage_user=86.8349 4624000000000 +cpu,cpu=0 usage_idle=44.0741,usage_system=34.1994,usage_user=20.04 4625000000000 +cpu,cpu=1 usage_idle=74.8492,usage_system=70.1604,usage_user=94.275 4626000000000 +cpu,cpu=2 usage_idle=73.9527,usage_system=47.9867,usage_user=23.0885 4627000000000 +cpu,cpu=3 usage_idle=78.2144,usage_system=80.0689,usage_user=53.165 4628000000000 +cpu,cpu=4 usage_idle=31.0431,usage_system=54.5569,usage_user=0.165374 4629000000000 +cpu,cpu=0 usage_idle=88.3831,usage_system=41.7311,usage_user=80.5433 4630000000000 +cpu,cpu=1 usage_idle=59.16,usage_system=23.2761,usage_user=63.3804 4631000000000 +cpu,cpu=2 usage_idle=41.3393,usage_system=34.7072,usage_user=10.7717 4632000000000 +cpu,cpu=3 usage_idle=53.6539,usage_system=46.4493,usage_user=75.6052 4633000000000 +cpu,cpu=4 usage_idle=41.2553,usage_system=44.8547,usage_user=39.6471 4634000000000 +cpu,cpu=0 usage_idle=28.0902,usage_system=88.9288,usage_user=73.8464 4635000000000 +cpu,cpu=1 usage_idle=48.1302,usage_system=63.778,usage_user=44.0068 4636000000000 +cpu,cpu=2 usage_idle=42.4052,usage_system=37.7308,usage_user=91.9936 4637000000000 +cpu,cpu=3 usage_idle=65.4937,usage_system=15.9452,usage_user=72.0625 4638000000000 +cpu,cpu=4 usage_idle=18.6587,usage_system=46.9883,usage_user=26.6194 4639000000000 +cpu,cpu=0 usage_idle=18.8241,usage_system=35.3714,usage_user=68.3505 4640000000000 +cpu,cpu=1 usage_idle=99.3674,usage_system=94.5314,usage_user=91.6266 4641000000000 +cpu,cpu=2 usage_idle=62.7478,usage_system=35.8707,usage_user=26.3338 4642000000000 +cpu,cpu=3 usage_idle=73.5195,usage_system=89.5246,usage_user=72.7831 4643000000000 +cpu,cpu=4 usage_idle=49.1247,usage_system=30.7799,usage_user=17.6378 4644000000000 +cpu,cpu=0 usage_idle=88.7717,usage_system=58.8701,usage_user=6.56667 4645000000000 +cpu,cpu=1 usage_idle=62.6182,usage_system=7.00032,usage_user=70.3447 4646000000000 +cpu,cpu=2 usage_idle=6.62498,usage_system=49.4056,usage_user=8.07547 4647000000000 +cpu,cpu=3 usage_idle=98.6185,usage_system=14.8992,usage_user=24.0206 4648000000000 +cpu,cpu=4 usage_idle=70.681,usage_system=33.558,usage_user=71.0089 4649000000000 +cpu,cpu=0 usage_idle=97.3004,usage_system=52.3821,usage_user=6.38026 4650000000000 +cpu,cpu=1 usage_idle=65.6509,usage_system=51.7495,usage_user=0.911667 4651000000000 +cpu,cpu=2 usage_idle=57.2775,usage_system=14.4973,usage_user=36.7824 4652000000000 +cpu,cpu=3 usage_idle=83.6113,usage_system=88.0168,usage_user=26.307 4653000000000 +cpu,cpu=4 usage_idle=56.3944,usage_system=37.1415,usage_user=57.0869 4654000000000 +cpu,cpu=0 usage_idle=74.0322,usage_system=25.9133,usage_user=15.957 4655000000000 +cpu,cpu=1 usage_idle=80.5989,usage_system=88.5314,usage_user=22.9573 4656000000000 +cpu,cpu=2 usage_idle=50.9436,usage_system=95.1564,usage_user=72.3628 4657000000000 +cpu,cpu=3 usage_idle=59.019,usage_system=93.7749,usage_user=87.2621 4658000000000 +cpu,cpu=4 usage_idle=83.0397,usage_system=64.4559,usage_user=20.82 4659000000000 +cpu,cpu=0 usage_idle=54.0485,usage_system=61.7563,usage_user=73.2021 4660000000000 +cpu,cpu=1 usage_idle=60.4288,usage_system=27.4072,usage_user=24.9516 4661000000000 +cpu,cpu=2 usage_idle=61.3405,usage_system=84.6846,usage_user=39.4489 4662000000000 +cpu,cpu=3 usage_idle=98.1228,usage_system=68.2959,usage_user=27.4658 4663000000000 +cpu,cpu=4 usage_idle=24.4298,usage_system=24.6903,usage_user=64.6073 4664000000000 +cpu,cpu=0 usage_idle=81.5166,usage_system=98.7225,usage_user=90.5205 4665000000000 +cpu,cpu=1 usage_idle=97.4736,usage_system=79.3213,usage_user=79.052 4666000000000 +cpu,cpu=2 usage_idle=20.4309,usage_system=30.2649,usage_user=74.2083 4667000000000 +cpu,cpu=3 usage_idle=92.7937,usage_system=89.2839,usage_user=67.9833 4668000000000 +cpu,cpu=4 usage_idle=80.0558,usage_system=72.3236,usage_user=32.4392 4669000000000 +cpu,cpu=0 usage_idle=0.875828,usage_system=26.3721,usage_user=94.1956 4670000000000 +cpu,cpu=1 usage_idle=74.078,usage_system=86.801,usage_user=21.6027 4671000000000 +cpu,cpu=2 usage_idle=99.0296,usage_system=48.1414,usage_user=6.28737 4672000000000 +cpu,cpu=3 usage_idle=38.4785,usage_system=46.2643,usage_user=74.5833 4673000000000 +cpu,cpu=4 usage_idle=65.9443,usage_system=70.694,usage_user=99.2735 4674000000000 +cpu,cpu=0 usage_idle=30.5516,usage_system=52.2107,usage_user=97.996 4675000000000 +cpu,cpu=1 usage_idle=21.0721,usage_system=49.6843,usage_user=77.3173 4676000000000 +cpu,cpu=2 usage_idle=0.12406,usage_system=70.1152,usage_user=7.58222 4677000000000 +cpu,cpu=3 usage_idle=74.3324,usage_system=62.9089,usage_user=96.8662 4678000000000 +cpu,cpu=4 usage_idle=42.3157,usage_system=42.9646,usage_user=69.1898 4679000000000 +cpu,cpu=0 usage_idle=74.7549,usage_system=43.8405,usage_user=95.5619 4680000000000 +cpu,cpu=1 usage_idle=68.9505,usage_system=17.9184,usage_user=82.3629 4681000000000 +cpu,cpu=2 usage_idle=90.5532,usage_system=16.948,usage_user=30.5043 4682000000000 +cpu,cpu=3 usage_idle=96.8406,usage_system=55.4266,usage_user=76.7685 4683000000000 +cpu,cpu=4 usage_idle=71.4238,usage_system=21.3709,usage_user=47.4626 4684000000000 +cpu,cpu=0 usage_idle=70.6974,usage_system=51.9224,usage_user=99.6732 4685000000000 +cpu,cpu=1 usage_idle=68.6934,usage_system=72.9945,usage_user=49.3575 4686000000000 +cpu,cpu=2 usage_idle=46.0107,usage_system=73.1186,usage_user=19.4727 4687000000000 +cpu,cpu=3 usage_idle=53.5929,usage_system=47.451,usage_user=82.3816 4688000000000 +cpu,cpu=4 usage_idle=50.4591,usage_system=89.7667,usage_user=25.3462 4689000000000 +cpu,cpu=0 usage_idle=19.6488,usage_system=64.5216,usage_user=69.1867 4690000000000 +cpu,cpu=1 usage_idle=15.2107,usage_system=33.4721,usage_user=87.1051 4691000000000 +cpu,cpu=2 usage_idle=97.5736,usage_system=24.0253,usage_user=4.05315 4692000000000 +cpu,cpu=3 usage_idle=28.0779,usage_system=20.8659,usage_user=59.4797 4693000000000 +cpu,cpu=4 usage_idle=4.84638,usage_system=92.2898,usage_user=80.8506 4694000000000 +cpu,cpu=0 usage_idle=52.3089,usage_system=62.9871,usage_user=32.773 4695000000000 +cpu,cpu=1 usage_idle=51.9822,usage_system=31.6805,usage_user=5.76751 4696000000000 +cpu,cpu=2 usage_idle=1.33971,usage_system=77.6912,usage_user=78.8861 4697000000000 +cpu,cpu=3 usage_idle=20.8124,usage_system=31.2841,usage_user=26.3371 4698000000000 +cpu,cpu=4 usage_idle=3.19395,usage_system=81.7432,usage_user=16.1038 4699000000000 +cpu,cpu=0 usage_idle=28.5402,usage_system=1.392,usage_user=80.6254 4700000000000 +cpu,cpu=1 usage_idle=97.7268,usage_system=16.6027,usage_user=14.0975 4701000000000 +cpu,cpu=2 usage_idle=84.8319,usage_system=14.1763,usage_user=38.1228 4702000000000 +cpu,cpu=3 usage_idle=88.8851,usage_system=42.2542,usage_user=58.9888 4703000000000 +cpu,cpu=4 usage_idle=48.3648,usage_system=47.1005,usage_user=51.2785 4704000000000 +cpu,cpu=0 usage_idle=29.2154,usage_system=99.4095,usage_user=14.2657 4705000000000 +cpu,cpu=1 usage_idle=61.9884,usage_system=51.3917,usage_user=45.9462 4706000000000 +cpu,cpu=2 usage_idle=67.7559,usage_system=52.7314,usage_user=23.6374 4707000000000 +cpu,cpu=3 usage_idle=46.6419,usage_system=73.5438,usage_user=54.9215 4708000000000 +cpu,cpu=4 usage_idle=72.979,usage_system=76.7377,usage_user=36.6646 4709000000000 +cpu,cpu=0 usage_idle=89.0828,usage_system=5.27787,usage_user=38.0567 4710000000000 +cpu,cpu=1 usage_idle=69.7082,usage_system=3.00469,usage_user=54.6594 4711000000000 +cpu,cpu=2 usage_idle=83.8057,usage_system=87.8366,usage_user=68.8357 4712000000000 +cpu,cpu=3 usage_idle=21.9286,usage_system=76.7217,usage_user=11.0898 4713000000000 +cpu,cpu=4 usage_idle=80.9173,usage_system=25.0865,usage_user=58.1904 4714000000000 +cpu,cpu=0 usage_idle=32.1958,usage_system=54.3019,usage_user=57.5998 4715000000000 +cpu,cpu=1 usage_idle=46.4615,usage_system=16.2902,usage_user=8.99148 4716000000000 +cpu,cpu=2 usage_idle=92.4077,usage_system=84.0461,usage_user=61.7229 4717000000000 +cpu,cpu=3 usage_idle=16.045,usage_system=30.688,usage_user=35.2666 4718000000000 +cpu,cpu=4 usage_idle=70.9665,usage_system=3.66705,usage_user=12.0043 4719000000000 +cpu,cpu=0 usage_idle=7.63116,usage_system=92.7498,usage_user=17.2822 4720000000000 +cpu,cpu=1 usage_idle=45.6878,usage_system=62.458,usage_user=20.2869 4721000000000 +cpu,cpu=2 usage_idle=0.34719,usage_system=46.2637,usage_user=8.12354 4722000000000 +cpu,cpu=3 usage_idle=69.1829,usage_system=68.1923,usage_user=84.8452 4723000000000 +cpu,cpu=4 usage_idle=80.2727,usage_system=49.1096,usage_user=9.93174 4724000000000 +cpu,cpu=0 usage_idle=38.4631,usage_system=81.3055,usage_user=64.2336 4725000000000 +cpu,cpu=1 usage_idle=96.0629,usage_system=27.767,usage_user=80.5238 4726000000000 +cpu,cpu=2 usage_idle=5.05436,usage_system=20.1746,usage_user=64.5699 4727000000000 +cpu,cpu=3 usage_idle=66.7772,usage_system=36.2197,usage_user=95.2579 4728000000000 +cpu,cpu=4 usage_idle=2.04384,usage_system=7.1862,usage_user=98.925 4729000000000 +cpu,cpu=0 usage_idle=14.0482,usage_system=14.8174,usage_user=91.6748 4730000000000 +cpu,cpu=1 usage_idle=31.3304,usage_system=60.5052,usage_user=54.1328 4731000000000 +cpu,cpu=2 usage_idle=51.6173,usage_system=60.8524,usage_user=0.396585 4732000000000 +cpu,cpu=3 usage_idle=59.7409,usage_system=30.0352,usage_user=68.5889 4733000000000 +cpu,cpu=4 usage_idle=44.5861,usage_system=10.3079,usage_user=17.6985 4734000000000 +cpu,cpu=0 usage_idle=54.5178,usage_system=48.771,usage_user=99.004 4735000000000 +cpu,cpu=1 usage_idle=18.7514,usage_system=44.8339,usage_user=26.7709 4736000000000 +cpu,cpu=2 usage_idle=99.2753,usage_system=49.8882,usage_user=46.9456 4737000000000 +cpu,cpu=3 usage_idle=63.8452,usage_system=16.6654,usage_user=83.1653 4738000000000 +cpu,cpu=4 usage_idle=59.1031,usage_system=18.7093,usage_user=90.3515 4739000000000 +cpu,cpu=0 usage_idle=58.028,usage_system=32.7575,usage_user=5.16883 4740000000000 +cpu,cpu=1 usage_idle=49.7029,usage_system=64.0879,usage_user=65.674 4741000000000 +cpu,cpu=2 usage_idle=3.8357,usage_system=15.7052,usage_user=26.5264 4742000000000 +cpu,cpu=3 usage_idle=4.23229,usage_system=75.446,usage_user=56.5616 4743000000000 +cpu,cpu=4 usage_idle=72.8212,usage_system=20.0321,usage_user=66.8695 4744000000000 +cpu,cpu=0 usage_idle=90.5197,usage_system=74.55,usage_user=15.6405 4745000000000 +cpu,cpu=1 usage_idle=89.5236,usage_system=93.3014,usage_user=60.4744 4746000000000 +cpu,cpu=2 usage_idle=16.2946,usage_system=92.5767,usage_user=10.3626 4747000000000 +cpu,cpu=3 usage_idle=63.2402,usage_system=56.4218,usage_user=27.028 4748000000000 +cpu,cpu=4 usage_idle=46.4054,usage_system=15.5249,usage_user=45.7373 4749000000000 +cpu,cpu=0 usage_idle=36.7569,usage_system=73.553,usage_user=78.4948 4750000000000 +cpu,cpu=1 usage_idle=41.9257,usage_system=23.2558,usage_user=42.5826 4751000000000 +cpu,cpu=2 usage_idle=7.59971,usage_system=27.0915,usage_user=58.2878 4752000000000 +cpu,cpu=3 usage_idle=34.1261,usage_system=31.3238,usage_user=33.7339 4753000000000 +cpu,cpu=4 usage_idle=90.6877,usage_system=4.14497,usage_user=53.766 4754000000000 +cpu,cpu=0 usage_idle=57.5572,usage_system=94.6646,usage_user=28.316 4755000000000 +cpu,cpu=1 usage_idle=73.1977,usage_system=84.1883,usage_user=21.6174 4756000000000 +cpu,cpu=2 usage_idle=33.672,usage_system=0.482862,usage_user=14.1941 4757000000000 +cpu,cpu=3 usage_idle=44.0346,usage_system=63.723,usage_user=70.6159 4758000000000 +cpu,cpu=4 usage_idle=71.0626,usage_system=10.1284,usage_user=86.1408 4759000000000 +cpu,cpu=0 usage_idle=16.7999,usage_system=46.8853,usage_user=59.6937 4760000000000 +cpu,cpu=1 usage_idle=95.2947,usage_system=88.811,usage_user=82.9496 4761000000000 +cpu,cpu=2 usage_idle=37.8773,usage_system=96.4108,usage_user=10.0411 4762000000000 +cpu,cpu=3 usage_idle=96.1652,usage_system=30.5368,usage_user=41.3649 4763000000000 +cpu,cpu=4 usage_idle=29.899,usage_system=21.2245,usage_user=45.5098 4764000000000 +cpu,cpu=0 usage_idle=83.665,usage_system=78.7817,usage_user=40.1745 4765000000000 +cpu,cpu=1 usage_idle=11.981,usage_system=51.9794,usage_user=24.3628 4766000000000 +cpu,cpu=2 usage_idle=33.5984,usage_system=85.6514,usage_user=24.8456 4767000000000 +cpu,cpu=3 usage_idle=47.7925,usage_system=29.6861,usage_user=88.5687 4768000000000 +cpu,cpu=4 usage_idle=18.4084,usage_system=0.74871,usage_user=98.6971 4769000000000 +cpu,cpu=0 usage_idle=4.54915,usage_system=17.5486,usage_user=45.5824 4770000000000 +cpu,cpu=1 usage_idle=64.2429,usage_system=12.8433,usage_user=34.3935 4771000000000 +cpu,cpu=2 usage_idle=47.1924,usage_system=50.7207,usage_user=30.8042 4772000000000 +cpu,cpu=3 usage_idle=57.2335,usage_system=46.8858,usage_user=61.3411 4773000000000 +cpu,cpu=4 usage_idle=98.5984,usage_system=76.7849,usage_user=82.5656 4774000000000 +cpu,cpu=0 usage_idle=44.1082,usage_system=60.4499,usage_user=61.3473 4775000000000 +cpu,cpu=1 usage_idle=84.2827,usage_system=72.4309,usage_user=13.3267 4776000000000 +cpu,cpu=2 usage_idle=8.6455,usage_system=6.02933,usage_user=98.9781 4777000000000 +cpu,cpu=3 usage_idle=33.4911,usage_system=53.8218,usage_user=28.6642 4778000000000 +cpu,cpu=4 usage_idle=22.0598,usage_system=72.2302,usage_user=29.4129 4779000000000 +cpu,cpu=0 usage_idle=20.7569,usage_system=76.7793,usage_user=46.9615 4780000000000 +cpu,cpu=1 usage_idle=66.3393,usage_system=41.0222,usage_user=59.8049 4781000000000 +cpu,cpu=2 usage_idle=0.732811,usage_system=88.2146,usage_user=10.5256 4782000000000 +cpu,cpu=3 usage_idle=31.537,usage_system=45.4482,usage_user=57.4114 4783000000000 +cpu,cpu=4 usage_idle=92.8781,usage_system=44.0465,usage_user=34.1962 4784000000000 +cpu,cpu=0 usage_idle=75.4437,usage_system=88.1548,usage_user=94.6461 4785000000000 +cpu,cpu=1 usage_idle=36.791,usage_system=72.4375,usage_user=67.0771 4786000000000 +cpu,cpu=2 usage_idle=50.1176,usage_system=81.083,usage_user=73.1064 4787000000000 +cpu,cpu=3 usage_idle=49.0957,usage_system=14.5741,usage_user=26.9282 4788000000000 +cpu,cpu=4 usage_idle=77.7599,usage_system=36.6339,usage_user=99.1583 4789000000000 +cpu,cpu=0 usage_idle=7.17282,usage_system=57.3908,usage_user=75.9377 4790000000000 +cpu,cpu=1 usage_idle=54.1344,usage_system=23.7302,usage_user=16.9599 4791000000000 +cpu,cpu=2 usage_idle=13.9392,usage_system=24.463,usage_user=5.17449 4792000000000 +cpu,cpu=3 usage_idle=24.4648,usage_system=56,usage_user=50.6226 4793000000000 +cpu,cpu=4 usage_idle=81.8762,usage_system=48.8781,usage_user=94.6692 4794000000000 +cpu,cpu=0 usage_idle=16.0724,usage_system=24.3218,usage_user=82.824 4795000000000 +cpu,cpu=1 usage_idle=10.7185,usage_system=61.1128,usage_user=55.2615 4796000000000 +cpu,cpu=2 usage_idle=77.7956,usage_system=11.2304,usage_user=36.3444 4797000000000 +cpu,cpu=3 usage_idle=50.902,usage_system=60.3262,usage_user=50.9186 4798000000000 +cpu,cpu=4 usage_idle=77.8302,usage_system=38.0861,usage_user=87.5525 4799000000000 +cpu,cpu=0 usage_idle=76.9885,usage_system=45.2589,usage_user=44.9434 4800000000000 +cpu,cpu=1 usage_idle=52.9262,usage_system=99.3933,usage_user=68.6735 4801000000000 +cpu,cpu=2 usage_idle=69.886,usage_system=13.3325,usage_user=93.1365 4802000000000 +cpu,cpu=3 usage_idle=75.0605,usage_system=37.7973,usage_user=49.1366 4803000000000 +cpu,cpu=4 usage_idle=25.6832,usage_system=19.6735,usage_user=98.0147 4804000000000 +cpu,cpu=0 usage_idle=20.3523,usage_system=35.7459,usage_user=22.3365 4805000000000 +cpu,cpu=1 usage_idle=3.17631,usage_system=46.4644,usage_user=83.4493 4806000000000 +cpu,cpu=2 usage_idle=58.4378,usage_system=24.26,usage_user=94.6797 4807000000000 +cpu,cpu=3 usage_idle=94.7822,usage_system=75.162,usage_user=55.0059 4808000000000 +cpu,cpu=4 usage_idle=45.7008,usage_system=52.9922,usage_user=93.092 4809000000000 +cpu,cpu=0 usage_idle=33.2533,usage_system=29.9807,usage_user=38.3509 4810000000000 +cpu,cpu=1 usage_idle=78.1967,usage_system=82.9068,usage_user=37.7442 4811000000000 +cpu,cpu=2 usage_idle=46.8702,usage_system=52.7929,usage_user=51.0767 4812000000000 +cpu,cpu=3 usage_idle=40.0067,usage_system=27.8534,usage_user=88.874 4813000000000 +cpu,cpu=4 usage_idle=89.1433,usage_system=53.5365,usage_user=8.54747 4814000000000 +cpu,cpu=0 usage_idle=87.158,usage_system=73.8889,usage_user=44.2934 4815000000000 +cpu,cpu=1 usage_idle=9.49454,usage_system=77.0652,usage_user=90.7578 4816000000000 +cpu,cpu=2 usage_idle=92.9439,usage_system=35.5029,usage_user=15.0178 4817000000000 +cpu,cpu=3 usage_idle=87.6236,usage_system=30.2851,usage_user=90.1798 4818000000000 +cpu,cpu=4 usage_idle=42.6295,usage_system=75.9859,usage_user=43.172 4819000000000 +cpu,cpu=0 usage_idle=35.7215,usage_system=9.23923,usage_user=73.1527 4820000000000 +cpu,cpu=1 usage_idle=74.0724,usage_system=87.4359,usage_user=56.0595 4821000000000 +cpu,cpu=2 usage_idle=11.8166,usage_system=34.3061,usage_user=8.8524 4822000000000 +cpu,cpu=3 usage_idle=62.8933,usage_system=74.3128,usage_user=36.7058 4823000000000 +cpu,cpu=4 usage_idle=51.7673,usage_system=63.4561,usage_user=90.2423 4824000000000 +cpu,cpu=0 usage_idle=60.3148,usage_system=50.6142,usage_user=64.1312 4825000000000 +cpu,cpu=1 usage_idle=4.60813,usage_system=60.1087,usage_user=41.1963 4826000000000 +cpu,cpu=2 usage_idle=95.3659,usage_system=53.0526,usage_user=76.6993 4827000000000 +cpu,cpu=3 usage_idle=10.3837,usage_system=40.6762,usage_user=6.98441 4828000000000 +cpu,cpu=4 usage_idle=0.563576,usage_system=83.3057,usage_user=82.9703 4829000000000 +cpu,cpu=0 usage_idle=43.7356,usage_system=19.0272,usage_user=92.2096 4830000000000 +cpu,cpu=1 usage_idle=16.8883,usage_system=93.0996,usage_user=79.6455 4831000000000 +cpu,cpu=2 usage_idle=72.9478,usage_system=4.91619,usage_user=13.9516 4832000000000 +cpu,cpu=3 usage_idle=81.8002,usage_system=67.8095,usage_user=88.2644 4833000000000 +cpu,cpu=4 usage_idle=18.506,usage_system=19.5768,usage_user=51.7206 4834000000000 +cpu,cpu=0 usage_idle=8.74828,usage_system=79.8916,usage_user=2.33471 4835000000000 +cpu,cpu=1 usage_idle=72.8794,usage_system=84.4997,usage_user=62.4434 4836000000000 +cpu,cpu=2 usage_idle=14.0758,usage_system=79.8656,usage_user=15.496 4837000000000 +cpu,cpu=3 usage_idle=90.7751,usage_system=90.2494,usage_user=56.1721 4838000000000 +cpu,cpu=4 usage_idle=97.7595,usage_system=90.813,usage_user=39.4778 4839000000000 +cpu,cpu=0 usage_idle=80.7298,usage_system=34.5485,usage_user=58.5049 4840000000000 +cpu,cpu=1 usage_idle=72.9393,usage_system=51.4368,usage_user=51.6045 4841000000000 +cpu,cpu=2 usage_idle=52.5848,usage_system=24.3846,usage_user=56.5207 4842000000000 +cpu,cpu=3 usage_idle=66.5364,usage_system=6.18483,usage_user=24.3302 4843000000000 +cpu,cpu=4 usage_idle=54.8008,usage_system=24.6908,usage_user=43.907 4844000000000 +cpu,cpu=0 usage_idle=6.52133,usage_system=33.4391,usage_user=23.7986 4845000000000 +cpu,cpu=1 usage_idle=8.85604,usage_system=6.31854,usage_user=8.29829 4846000000000 +cpu,cpu=2 usage_idle=71.2994,usage_system=20.3943,usage_user=88.1639 4847000000000 +cpu,cpu=3 usage_idle=86.7954,usage_system=11.1694,usage_user=78.4133 4848000000000 +cpu,cpu=4 usage_idle=42.9675,usage_system=8.92884,usage_user=69.2262 4849000000000 +cpu,cpu=0 usage_idle=82.4453,usage_system=89.6586,usage_user=3.77478 4850000000000 +cpu,cpu=1 usage_idle=40.9502,usage_system=62.598,usage_user=55.2116 4851000000000 +cpu,cpu=2 usage_idle=92.5547,usage_system=15.1828,usage_user=79.5962 4852000000000 +cpu,cpu=3 usage_idle=49.0754,usage_system=81.7191,usage_user=85.781 4853000000000 +cpu,cpu=4 usage_idle=73.4057,usage_system=36.5199,usage_user=10.4718 4854000000000 +cpu,cpu=0 usage_idle=17.3127,usage_system=43.0412,usage_user=43.9109 4855000000000 +cpu,cpu=1 usage_idle=41.1113,usage_system=51.8973,usage_user=50.2295 4856000000000 +cpu,cpu=2 usage_idle=49.4095,usage_system=23.1967,usage_user=70.6238 4857000000000 +cpu,cpu=3 usage_idle=37.5735,usage_system=9.9921,usage_user=81.7932 4858000000000 +cpu,cpu=4 usage_idle=15.9868,usage_system=52.9596,usage_user=90.722 4859000000000 +cpu,cpu=0 usage_idle=85.213,usage_system=35.4049,usage_user=80.3806 4860000000000 +cpu,cpu=1 usage_idle=88.9878,usage_system=76.3551,usage_user=42.9786 4861000000000 +cpu,cpu=2 usage_idle=44.1994,usage_system=68.9098,usage_user=58.1614 4862000000000 +cpu,cpu=3 usage_idle=23.7956,usage_system=17.9852,usage_user=39.8805 4863000000000 +cpu,cpu=4 usage_idle=9.57659,usage_system=91.3909,usage_user=76.4004 4864000000000 +cpu,cpu=0 usage_idle=20.0484,usage_system=8.70359,usage_user=19.4417 4865000000000 +cpu,cpu=1 usage_idle=63.9594,usage_system=49.8148,usage_user=71.339 4866000000000 +cpu,cpu=2 usage_idle=14.1889,usage_system=99.2244,usage_user=94.5357 4867000000000 +cpu,cpu=3 usage_idle=84.8127,usage_system=36.7979,usage_user=4.52778 4868000000000 +cpu,cpu=4 usage_idle=66.6058,usage_system=52.7846,usage_user=57.4874 4869000000000 +cpu,cpu=0 usage_idle=57.3279,usage_system=37.9976,usage_user=92.8923 4870000000000 +cpu,cpu=1 usage_idle=37.7085,usage_system=26.9854,usage_user=69.2473 4871000000000 +cpu,cpu=2 usage_idle=80.6871,usage_system=71.1848,usage_user=38.1571 4872000000000 +cpu,cpu=3 usage_idle=38.8485,usage_system=94.9804,usage_user=56.1424 4873000000000 +cpu,cpu=4 usage_idle=78.729,usage_system=4.55695,usage_user=47.5333 4874000000000 +cpu,cpu=0 usage_idle=55.1295,usage_system=24.6054,usage_user=56.2369 4875000000000 +cpu,cpu=1 usage_idle=74.5712,usage_system=88.5648,usage_user=6.05172 4876000000000 +cpu,cpu=2 usage_idle=45.9101,usage_system=2.75362,usage_user=5.27611 4877000000000 +cpu,cpu=3 usage_idle=40.4458,usage_system=87.5663,usage_user=42.074 4878000000000 +cpu,cpu=4 usage_idle=44.9736,usage_system=54.1721,usage_user=94.8586 4879000000000 +cpu,cpu=0 usage_idle=2.46098,usage_system=11.5,usage_user=32.8562 4880000000000 +cpu,cpu=1 usage_idle=95.3532,usage_system=49.2085,usage_user=59.8417 4881000000000 +cpu,cpu=2 usage_idle=64.6006,usage_system=29.8956,usage_user=31.0264 4882000000000 +cpu,cpu=3 usage_idle=2.75767,usage_system=68.7442,usage_user=26.0068 4883000000000 +cpu,cpu=4 usage_idle=58.9,usage_system=47.4732,usage_user=30.5638 4884000000000 +cpu,cpu=0 usage_idle=6.43332,usage_system=2.6027,usage_user=55.1691 4885000000000 +cpu,cpu=1 usage_idle=62.6702,usage_system=77.1739,usage_user=43.7339 4886000000000 +cpu,cpu=2 usage_idle=68.7219,usage_system=23.084,usage_user=46.4875 4887000000000 +cpu,cpu=3 usage_idle=73.998,usage_system=63.5298,usage_user=34.0538 4888000000000 +cpu,cpu=4 usage_idle=16.072,usage_system=8.50344,usage_user=88.2259 4889000000000 +cpu,cpu=0 usage_idle=10.9306,usage_system=10.9644,usage_user=99.7259 4890000000000 +cpu,cpu=1 usage_idle=43.7868,usage_system=6.31765,usage_user=48.9344 4891000000000 +cpu,cpu=2 usage_idle=3.62849,usage_system=70.9182,usage_user=78.8301 4892000000000 +cpu,cpu=3 usage_idle=34.6549,usage_system=73.6759,usage_user=47.5742 4893000000000 +cpu,cpu=4 usage_idle=60.6617,usage_system=32.5759,usage_user=95.0474 4894000000000 +cpu,cpu=0 usage_idle=91.2255,usage_system=39.0092,usage_user=97.6501 4895000000000 +cpu,cpu=1 usage_idle=46.3946,usage_system=1.67942,usage_user=74.824 4896000000000 +cpu,cpu=2 usage_idle=90.1285,usage_system=70.4013,usage_user=97.908 4897000000000 +cpu,cpu=3 usage_idle=36.6161,usage_system=44.3993,usage_user=61.4379 4898000000000 +cpu,cpu=4 usage_idle=70.6699,usage_system=60.4713,usage_user=69.9413 4899000000000 +cpu,cpu=0 usage_idle=58.8958,usage_system=71.4019,usage_user=80.9057 4900000000000 +cpu,cpu=1 usage_idle=58.6218,usage_system=15.1888,usage_user=87.2234 4901000000000 +cpu,cpu=2 usage_idle=7.5562,usage_system=18.8172,usage_user=58.1416 4902000000000 +cpu,cpu=3 usage_idle=86.3863,usage_system=53.4722,usage_user=31.8175 4903000000000 +cpu,cpu=4 usage_idle=33.9605,usage_system=14.1339,usage_user=64.3934 4904000000000 +cpu,cpu=0 usage_idle=29.008,usage_system=5.35944,usage_user=3.40261 4905000000000 +cpu,cpu=1 usage_idle=26.6581,usage_system=51.7541,usage_user=5.08203 4906000000000 +cpu,cpu=2 usage_idle=1.4821,usage_system=41.8826,usage_user=75.4833 4907000000000 +cpu,cpu=3 usage_idle=99.3901,usage_system=78.4987,usage_user=19.8827 4908000000000 +cpu,cpu=4 usage_idle=60.828,usage_system=49.1686,usage_user=80.354 4909000000000 +cpu,cpu=0 usage_idle=30.7693,usage_system=8.06439,usage_user=51.7559 4910000000000 +cpu,cpu=1 usage_idle=11.675,usage_system=66.6861,usage_user=66.9447 4911000000000 +cpu,cpu=2 usage_idle=98.8984,usage_system=74.2423,usage_user=85.7619 4912000000000 +cpu,cpu=3 usage_idle=57.04,usage_system=60.6286,usage_user=39.2341 4913000000000 +cpu,cpu=4 usage_idle=88.8574,usage_system=94.5891,usage_user=53.3681 4914000000000 +cpu,cpu=0 usage_idle=53.2508,usage_system=23.5971,usage_user=58.7275 4915000000000 +cpu,cpu=1 usage_idle=56.6534,usage_system=50.2552,usage_user=10.4816 4916000000000 +cpu,cpu=2 usage_idle=61.7354,usage_system=51.7373,usage_user=52.3642 4917000000000 +cpu,cpu=3 usage_idle=37.2188,usage_system=51.1274,usage_user=30.8629 4918000000000 +cpu,cpu=4 usage_idle=57.1014,usage_system=11.9554,usage_user=80.0315 4919000000000 +cpu,cpu=0 usage_idle=37.4554,usage_system=42.7247,usage_user=88.0959 4920000000000 +cpu,cpu=1 usage_idle=89.2114,usage_system=54.3997,usage_user=54.782 4921000000000 +cpu,cpu=2 usage_idle=56.156,usage_system=53.2981,usage_user=29.0244 4922000000000 +cpu,cpu=3 usage_idle=41.918,usage_system=10.338,usage_user=89.653 4923000000000 +cpu,cpu=4 usage_idle=81.1521,usage_system=99.1954,usage_user=84.2421 4924000000000 +cpu,cpu=0 usage_idle=34.5201,usage_system=52.4462,usage_user=7.83924 4925000000000 +cpu,cpu=1 usage_idle=93.2476,usage_system=9.09957,usage_user=58.0944 4926000000000 +cpu,cpu=2 usage_idle=3.72921,usage_system=70.835,usage_user=9.8317 4927000000000 +cpu,cpu=3 usage_idle=56.0934,usage_system=8.05372,usage_user=60.9591 4928000000000 +cpu,cpu=4 usage_idle=86.9563,usage_system=65.1552,usage_user=72.9145 4929000000000 +cpu,cpu=0 usage_idle=66.9878,usage_system=2.6106,usage_user=15.6392 4930000000000 +cpu,cpu=1 usage_idle=55.0837,usage_system=91.822,usage_user=70.0389 4931000000000 +cpu,cpu=2 usage_idle=9.8657,usage_system=47.978,usage_user=23.3369 4932000000000 +cpu,cpu=3 usage_idle=38.8901,usage_system=89.896,usage_user=33.6749 4933000000000 +cpu,cpu=4 usage_idle=28.5431,usage_system=71.0481,usage_user=32.8703 4934000000000 +cpu,cpu=0 usage_idle=12.7852,usage_system=5.56819,usage_user=85.3165 4935000000000 +cpu,cpu=1 usage_idle=20.6245,usage_system=98.8158,usage_user=94.4161 4936000000000 +cpu,cpu=2 usage_idle=78.7189,usage_system=2.54502,usage_user=65.2511 4937000000000 +cpu,cpu=3 usage_idle=88.5506,usage_system=58.6384,usage_user=73.3048 4938000000000 +cpu,cpu=4 usage_idle=49.5097,usage_system=45.5948,usage_user=38.4599 4939000000000 +cpu,cpu=0 usage_idle=22.4242,usage_system=12.5826,usage_user=41.0705 4940000000000 +cpu,cpu=1 usage_idle=38.0634,usage_system=67.6662,usage_user=32.8925 4941000000000 +cpu,cpu=2 usage_idle=8.10222,usage_system=77.5319,usage_user=80.8705 4942000000000 +cpu,cpu=3 usage_idle=31.4391,usage_system=16.422,usage_user=70.7665 4943000000000 +cpu,cpu=4 usage_idle=65.114,usage_system=44.9651,usage_user=41.8145 4944000000000 +cpu,cpu=0 usage_idle=97.9844,usage_system=57.7503,usage_user=47.3827 4945000000000 +cpu,cpu=1 usage_idle=83.3009,usage_system=78.3748,usage_user=46.1985 4946000000000 +cpu,cpu=2 usage_idle=77.717,usage_system=57.0937,usage_user=48.7435 4947000000000 +cpu,cpu=3 usage_idle=42.968,usage_system=45.6443,usage_user=7.38198 4948000000000 +cpu,cpu=4 usage_idle=16.2728,usage_system=95.154,usage_user=52.9767 4949000000000 +cpu,cpu=0 usage_idle=54.7327,usage_system=17.5782,usage_user=65.5593 4950000000000 +cpu,cpu=1 usage_idle=95.8033,usage_system=55.6416,usage_user=33.2255 4951000000000 +cpu,cpu=2 usage_idle=28.6957,usage_system=63.7438,usage_user=10.7575 4952000000000 +cpu,cpu=3 usage_idle=9.56624,usage_system=95.1829,usage_user=27.1795 4953000000000 +cpu,cpu=4 usage_idle=80.3327,usage_system=60.297,usage_user=72.1446 4954000000000 +cpu,cpu=0 usage_idle=22.1472,usage_system=58.2813,usage_user=29.8949 4955000000000 +cpu,cpu=1 usage_idle=69.5299,usage_system=41.5822,usage_user=8.26969 4956000000000 +cpu,cpu=2 usage_idle=15.7284,usage_system=19.2992,usage_user=65.3634 4957000000000 +cpu,cpu=3 usage_idle=64.472,usage_system=62.2672,usage_user=11.0077 4958000000000 +cpu,cpu=4 usage_idle=71.854,usage_system=78.54,usage_user=6.16166 4959000000000 +cpu,cpu=0 usage_idle=24.8307,usage_system=33.2728,usage_user=23.7398 4960000000000 +cpu,cpu=1 usage_idle=90.39,usage_system=29.076,usage_user=79.3814 4961000000000 +cpu,cpu=2 usage_idle=23.6155,usage_system=57.7718,usage_user=43.1252 4962000000000 +cpu,cpu=3 usage_idle=34.373,usage_system=67.338,usage_user=38.3081 4963000000000 +cpu,cpu=4 usage_idle=61.5525,usage_system=47.6707,usage_user=98.6051 4964000000000 +cpu,cpu=0 usage_idle=33.697,usage_system=69.8179,usage_user=56.8864 4965000000000 +cpu,cpu=1 usage_idle=63.5919,usage_system=39.3478,usage_user=98.4687 4966000000000 +cpu,cpu=2 usage_idle=71.8616,usage_system=55.0763,usage_user=17.7679 4967000000000 +cpu,cpu=3 usage_idle=37.225,usage_system=19.5482,usage_user=80.0351 4968000000000 +cpu,cpu=4 usage_idle=48.2327,usage_system=91.4022,usage_user=58.5751 4969000000000 +cpu,cpu=0 usage_idle=54.3943,usage_system=16.2329,usage_user=91.8479 4970000000000 +cpu,cpu=1 usage_idle=78.1342,usage_system=6.62287,usage_user=20.9239 4971000000000 +cpu,cpu=2 usage_idle=57.5156,usage_system=30.2384,usage_user=78.6957 4972000000000 +cpu,cpu=3 usage_idle=0.640772,usage_system=64.6114,usage_user=46.0337 4973000000000 +cpu,cpu=4 usage_idle=38.9489,usage_system=26.1638,usage_user=93.7044 4974000000000 +cpu,cpu=0 usage_idle=37.554,usage_system=59.8608,usage_user=63.5224 4975000000000 +cpu,cpu=1 usage_idle=94.4404,usage_system=23.4528,usage_user=2.87018 4976000000000 +cpu,cpu=2 usage_idle=92.9091,usage_system=95.3144,usage_user=57.9464 4977000000000 +cpu,cpu=3 usage_idle=10.6769,usage_system=32.5394,usage_user=77.4947 4978000000000 +cpu,cpu=4 usage_idle=90.712,usage_system=80.7721,usage_user=68.8969 4979000000000 +cpu,cpu=0 usage_idle=49.2872,usage_system=35.1664,usage_user=85.1298 4980000000000 +cpu,cpu=1 usage_idle=41.1351,usage_system=13.3005,usage_user=91.7526 4981000000000 +cpu,cpu=2 usage_idle=62.059,usage_system=70.8161,usage_user=21.991 4982000000000 +cpu,cpu=3 usage_idle=40.7547,usage_system=71.4569,usage_user=86.6024 4983000000000 +cpu,cpu=4 usage_idle=86.7885,usage_system=10.4058,usage_user=12.7662 4984000000000 +cpu,cpu=0 usage_idle=80.4929,usage_system=47.9597,usage_user=72.627 4985000000000 +cpu,cpu=1 usage_idle=44.0153,usage_system=42.4001,usage_user=96.0798 4986000000000 +cpu,cpu=2 usage_idle=46.8855,usage_system=35.3092,usage_user=91.3942 4987000000000 +cpu,cpu=3 usage_idle=4.83191,usage_system=45.9861,usage_user=23.9336 4988000000000 +cpu,cpu=4 usage_idle=82.3266,usage_system=36.6982,usage_user=4.70564 4989000000000 +cpu,cpu=0 usage_idle=51.2235,usage_system=85.9853,usage_user=39.872 4990000000000 +cpu,cpu=1 usage_idle=36.3532,usage_system=27.1204,usage_user=53.1726 4991000000000 +cpu,cpu=2 usage_idle=28.1059,usage_system=89.1795,usage_user=23.9887 4992000000000 +cpu,cpu=3 usage_idle=50.0969,usage_system=29.9342,usage_user=95.4456 4993000000000 +cpu,cpu=4 usage_idle=36.6993,usage_system=16.7227,usage_user=5.85138 4994000000000 +cpu,cpu=0 usage_idle=49.4654,usage_system=97.2156,usage_user=53.8111 4995000000000 +cpu,cpu=1 usage_idle=22.0925,usage_system=41.2309,usage_user=96.2113 4996000000000 +cpu,cpu=2 usage_idle=18.1723,usage_system=88.1163,usage_user=31.5205 4997000000000 +cpu,cpu=3 usage_idle=9.56647,usage_system=92.9483,usage_user=77.5066 4998000000000 +cpu,cpu=4 usage_idle=33.5,usage_system=75.2748,usage_user=14.2047 4999000000000 +cpu,cpu=0 usage_idle=38.2057,usage_system=26.4983,usage_user=0.19008 5000000000000 +cpu,cpu=1 usage_idle=78.0777,usage_system=62.8515,usage_user=27.3105 5001000000000 +cpu,cpu=2 usage_idle=31.2503,usage_system=90.9574,usage_user=16.49 5002000000000 +cpu,cpu=3 usage_idle=55.239,usage_system=41.0543,usage_user=46.4242 5003000000000 +cpu,cpu=4 usage_idle=50.6846,usage_system=77.7535,usage_user=63.1469 5004000000000 +cpu,cpu=0 usage_idle=56.536,usage_system=27.219,usage_user=60.3625 5005000000000 +cpu,cpu=1 usage_idle=10.3471,usage_system=49.3115,usage_user=1.59334 5006000000000 +cpu,cpu=2 usage_idle=6.55837,usage_system=67.4837,usage_user=89.7097 5007000000000 +cpu,cpu=3 usage_idle=38.0788,usage_system=77.0502,usage_user=82.6579 5008000000000 +cpu,cpu=4 usage_idle=15.5854,usage_system=10.5503,usage_user=57.9328 5009000000000 +cpu,cpu=0 usage_idle=29.7902,usage_system=48.756,usage_user=84.4311 5010000000000 +cpu,cpu=1 usage_idle=29.9803,usage_system=26.8337,usage_user=47.2826 5011000000000 +cpu,cpu=2 usage_idle=57.2908,usage_system=58.084,usage_user=38.24 5012000000000 +cpu,cpu=3 usage_idle=73.7807,usage_system=13.3229,usage_user=79.2943 5013000000000 +cpu,cpu=4 usage_idle=20.2049,usage_system=64.0075,usage_user=57.0478 5014000000000 +cpu,cpu=0 usage_idle=83.3517,usage_system=20.5435,usage_user=84.2668 5015000000000 +cpu,cpu=1 usage_idle=43.7142,usage_system=30.8906,usage_user=33.5783 5016000000000 +cpu,cpu=2 usage_idle=45.3075,usage_system=37.449,usage_user=1.06201 5017000000000 +cpu,cpu=3 usage_idle=35.0172,usage_system=75.5278,usage_user=78.1122 5018000000000 +cpu,cpu=4 usage_idle=17.6752,usage_system=91.1133,usage_user=88.6625 5019000000000 +cpu,cpu=0 usage_idle=75.6079,usage_system=20.9034,usage_user=37.4184 5020000000000 +cpu,cpu=1 usage_idle=60.039,usage_system=50.8837,usage_user=64.2521 5021000000000 +cpu,cpu=2 usage_idle=7.32163,usage_system=8.17444,usage_user=22.3361 5022000000000 +cpu,cpu=3 usage_idle=45.5616,usage_system=81.9552,usage_user=35.659 5023000000000 +cpu,cpu=4 usage_idle=24.8559,usage_system=2.16005,usage_user=99.6665 5024000000000 +cpu,cpu=0 usage_idle=81.9037,usage_system=85.5118,usage_user=20.21 5025000000000 +cpu,cpu=1 usage_idle=66.1705,usage_system=29.226,usage_user=51.1007 5026000000000 +cpu,cpu=2 usage_idle=99.7488,usage_system=74.5335,usage_user=88.5496 5027000000000 +cpu,cpu=3 usage_idle=0.810804,usage_system=9.55074,usage_user=64.0775 5028000000000 +cpu,cpu=4 usage_idle=78.923,usage_system=27.2259,usage_user=55.1907 5029000000000 +cpu,cpu=0 usage_idle=67.5855,usage_system=2.83385,usage_user=76.0942 5030000000000 +cpu,cpu=1 usage_idle=5.00392,usage_system=62.8729,usage_user=26.9778 5031000000000 +cpu,cpu=2 usage_idle=69.256,usage_system=70.1945,usage_user=35.1523 5032000000000 +cpu,cpu=3 usage_idle=91.5921,usage_system=15.7561,usage_user=17.1074 5033000000000 +cpu,cpu=4 usage_idle=27.2511,usage_system=40.6121,usage_user=19.2675 5034000000000 +cpu,cpu=0 usage_idle=26.9176,usage_system=22.5158,usage_user=4.77927 5035000000000 +cpu,cpu=1 usage_idle=47.1277,usage_system=88.6863,usage_user=34.0052 5036000000000 +cpu,cpu=2 usage_idle=98.2283,usage_system=88.4351,usage_user=8.53876 5037000000000 +cpu,cpu=3 usage_idle=86.778,usage_system=89.2459,usage_user=18.0895 5038000000000 +cpu,cpu=4 usage_idle=50.8554,usage_system=68.1689,usage_user=45.3154 5039000000000 +cpu,cpu=0 usage_idle=6.04617,usage_system=35.7544,usage_user=48.1492 5040000000000 +cpu,cpu=1 usage_idle=82.1403,usage_system=40.7583,usage_user=11.0221 5041000000000 +cpu,cpu=2 usage_idle=9.11817,usage_system=10.0144,usage_user=81.2166 5042000000000 +cpu,cpu=3 usage_idle=44.2704,usage_system=1.60642,usage_user=96.9728 5043000000000 +cpu,cpu=4 usage_idle=61.3779,usage_system=28.8575,usage_user=37.5848 5044000000000 +cpu,cpu=0 usage_idle=80.6454,usage_system=55.7751,usage_user=60.1006 5045000000000 +cpu,cpu=1 usage_idle=85.4246,usage_system=2.90276,usage_user=48.7869 5046000000000 +cpu,cpu=2 usage_idle=19.4299,usage_system=1.13108,usage_user=37.222 5047000000000 +cpu,cpu=3 usage_idle=27.9686,usage_system=87.909,usage_user=26.4679 5048000000000 +cpu,cpu=4 usage_idle=46.0581,usage_system=38.7645,usage_user=94.6368 5049000000000 +cpu,cpu=0 usage_idle=91.3735,usage_system=44.8107,usage_user=30.3912 5050000000000 +cpu,cpu=1 usage_idle=39.5228,usage_system=26.951,usage_user=71.1496 5051000000000 +cpu,cpu=2 usage_idle=50.5449,usage_system=36.0692,usage_user=81.1639 5052000000000 +cpu,cpu=3 usage_idle=31.7615,usage_system=80.3396,usage_user=82.7703 5053000000000 +cpu,cpu=4 usage_idle=28.7343,usage_system=41.7175,usage_user=11.6278 5054000000000 +cpu,cpu=0 usage_idle=66.3191,usage_system=22.3629,usage_user=67.4029 5055000000000 +cpu,cpu=1 usage_idle=26.4197,usage_system=7.78751,usage_user=70.3057 5056000000000 +cpu,cpu=2 usage_idle=75.2066,usage_system=27.2174,usage_user=71.4368 5057000000000 +cpu,cpu=3 usage_idle=12.4286,usage_system=55.186,usage_user=59.3458 5058000000000 +cpu,cpu=4 usage_idle=38.8965,usage_system=1.24416,usage_user=98.1103 5059000000000 +cpu,cpu=0 usage_idle=33.5334,usage_system=92.6177,usage_user=42.921 5060000000000 +cpu,cpu=1 usage_idle=63.9246,usage_system=32.1405,usage_user=69.872 5061000000000 +cpu,cpu=2 usage_idle=35.0742,usage_system=82.6854,usage_user=5.94115 5062000000000 +cpu,cpu=3 usage_idle=16.2381,usage_system=14.4469,usage_user=86.2808 5063000000000 +cpu,cpu=4 usage_idle=99.0084,usage_system=43.1812,usage_user=27.9983 5064000000000 +cpu,cpu=0 usage_idle=10.6363,usage_system=9.50039,usage_user=50.3611 5065000000000 +cpu,cpu=1 usage_idle=78.0392,usage_system=35.9201,usage_user=58.1487 5066000000000 +cpu,cpu=2 usage_idle=48.3449,usage_system=11.1268,usage_user=85.366 5067000000000 +cpu,cpu=3 usage_idle=19.7817,usage_system=23.5554,usage_user=40.5521 5068000000000 +cpu,cpu=4 usage_idle=79.1275,usage_system=62.452,usage_user=41.7962 5069000000000 +cpu,cpu=0 usage_idle=77.2378,usage_system=95.9853,usage_user=34.4139 5070000000000 +cpu,cpu=1 usage_idle=20.1588,usage_system=59.9099,usage_user=66.5544 5071000000000 +cpu,cpu=2 usage_idle=90.0307,usage_system=94.9841,usage_user=49.2398 5072000000000 +cpu,cpu=3 usage_idle=95.9719,usage_system=11.2222,usage_user=63.6867 5073000000000 +cpu,cpu=4 usage_idle=82.2526,usage_system=10.2307,usage_user=6.86799 5074000000000 +cpu,cpu=0 usage_idle=10.2509,usage_system=20.8669,usage_user=16.3684 5075000000000 +cpu,cpu=1 usage_idle=60.6121,usage_system=98.9062,usage_user=52.2885 5076000000000 +cpu,cpu=2 usage_idle=18.7607,usage_system=47.2511,usage_user=63.4153 5077000000000 +cpu,cpu=3 usage_idle=4.12676,usage_system=67.0327,usage_user=86.9707 5078000000000 +cpu,cpu=4 usage_idle=44.6788,usage_system=46.1602,usage_user=49.4227 5079000000000 +cpu,cpu=0 usage_idle=86.4751,usage_system=23.398,usage_user=45.408 5080000000000 +cpu,cpu=1 usage_idle=20.889,usage_system=43.5568,usage_user=5.31799 5081000000000 +cpu,cpu=2 usage_idle=87.4434,usage_system=33.5875,usage_user=0.302104 5082000000000 +cpu,cpu=3 usage_idle=36.6832,usage_system=29.5594,usage_user=11.5243 5083000000000 +cpu,cpu=4 usage_idle=0.369965,usage_system=11.812,usage_user=21.755 5084000000000 +cpu,cpu=0 usage_idle=7.23796,usage_system=22.0629,usage_user=42.6219 5085000000000 +cpu,cpu=1 usage_idle=23.6063,usage_system=82.675,usage_user=41.5281 5086000000000 +cpu,cpu=2 usage_idle=75.8949,usage_system=1.43573,usage_user=88.7792 5087000000000 +cpu,cpu=3 usage_idle=39.3102,usage_system=5.56249,usage_user=55.8119 5088000000000 +cpu,cpu=4 usage_idle=26.2809,usage_system=50.2413,usage_user=1.97209 5089000000000 +cpu,cpu=0 usage_idle=75.7036,usage_system=36.7164,usage_user=25.3701 5090000000000 +cpu,cpu=1 usage_idle=21.1116,usage_system=57.6054,usage_user=68.9268 5091000000000 +cpu,cpu=2 usage_idle=26.4296,usage_system=45.0488,usage_user=2.51434 5092000000000 +cpu,cpu=3 usage_idle=26.7317,usage_system=81.732,usage_user=32.0737 5093000000000 +cpu,cpu=4 usage_idle=38.2561,usage_system=82.102,usage_user=43.8858 5094000000000 +cpu,cpu=0 usage_idle=60.011,usage_system=89.3399,usage_user=65.9487 5095000000000 +cpu,cpu=1 usage_idle=2.63297,usage_system=12.9463,usage_user=48.6237 5096000000000 +cpu,cpu=2 usage_idle=44.1611,usage_system=88.8411,usage_user=50.0594 5097000000000 +cpu,cpu=3 usage_idle=32.9402,usage_system=28.1513,usage_user=55.6219 5098000000000 +cpu,cpu=4 usage_idle=88.7521,usage_system=54.4322,usage_user=5.86325 5099000000000 +cpu,cpu=0 usage_idle=90.7242,usage_system=30.1358,usage_user=42.5796 5100000000000 +cpu,cpu=1 usage_idle=16.0943,usage_system=51.2474,usage_user=0.184986 5101000000000 +cpu,cpu=2 usage_idle=85.0211,usage_system=77.677,usage_user=45.2338 5102000000000 +cpu,cpu=3 usage_idle=87.5355,usage_system=4.40874,usage_user=26.9657 5103000000000 +cpu,cpu=4 usage_idle=19.6092,usage_system=42.6648,usage_user=9.0677 5104000000000 +cpu,cpu=0 usage_idle=63.4949,usage_system=2.67583,usage_user=98.4076 5105000000000 +cpu,cpu=1 usage_idle=29.4436,usage_system=5.3088,usage_user=11.3539 5106000000000 +cpu,cpu=2 usage_idle=78.0673,usage_system=49.4699,usage_user=0.194985 5107000000000 +cpu,cpu=3 usage_idle=28.1268,usage_system=82.4101,usage_user=28.3463 5108000000000 +cpu,cpu=4 usage_idle=83.7487,usage_system=71.1622,usage_user=82.7784 5109000000000 +cpu,cpu=0 usage_idle=89.612,usage_system=61.8864,usage_user=12.9142 5110000000000 +cpu,cpu=1 usage_idle=32.1916,usage_system=77.9806,usage_user=64.1616 5111000000000 +cpu,cpu=2 usage_idle=32.3766,usage_system=63.0017,usage_user=41.8386 5112000000000 +cpu,cpu=3 usage_idle=77.6103,usage_system=50.5372,usage_user=46.2473 5113000000000 +cpu,cpu=4 usage_idle=4.57608,usage_system=70.1464,usage_user=88.9121 5114000000000 +cpu,cpu=0 usage_idle=13.6438,usage_system=33.6413,usage_user=91.588 5115000000000 +cpu,cpu=1 usage_idle=12.0514,usage_system=63.0849,usage_user=96.8968 5116000000000 +cpu,cpu=2 usage_idle=23.4053,usage_system=41.1523,usage_user=46.3666 5117000000000 +cpu,cpu=3 usage_idle=23.6002,usage_system=69.279,usage_user=28.7767 5118000000000 +cpu,cpu=4 usage_idle=51.9465,usage_system=53.0278,usage_user=99.9389 5119000000000 +cpu,cpu=0 usage_idle=34.7249,usage_system=42.6397,usage_user=61.8252 5120000000000 +cpu,cpu=1 usage_idle=47.6391,usage_system=74.8313,usage_user=39.8059 5121000000000 +cpu,cpu=2 usage_idle=11.8007,usage_system=7.20789,usage_user=2.80759 5122000000000 +cpu,cpu=3 usage_idle=53.6393,usage_system=84.8182,usage_user=53.3448 5123000000000 +cpu,cpu=4 usage_idle=99.8866,usage_system=89.3943,usage_user=23.4911 5124000000000 +cpu,cpu=0 usage_idle=88.7987,usage_system=3.03808,usage_user=57.1324 5125000000000 +cpu,cpu=1 usage_idle=80.3867,usage_system=15.0895,usage_user=20.2173 5126000000000 +cpu,cpu=2 usage_idle=77.2834,usage_system=38.4947,usage_user=61.3696 5127000000000 +cpu,cpu=3 usage_idle=23.6501,usage_system=62.095,usage_user=30.6487 5128000000000 +cpu,cpu=4 usage_idle=52.4268,usage_system=14.0415,usage_user=83.6764 5129000000000 +cpu,cpu=0 usage_idle=52.3656,usage_system=48.7664,usage_user=26.3161 5130000000000 +cpu,cpu=1 usage_idle=14.1909,usage_system=96.4055,usage_user=1.14746 5131000000000 +cpu,cpu=2 usage_idle=53.9967,usage_system=8.20619,usage_user=8.35536 5132000000000 +cpu,cpu=3 usage_idle=56.8043,usage_system=61.8455,usage_user=93.1736 5133000000000 +cpu,cpu=4 usage_idle=10.1491,usage_system=61.732,usage_user=82.5679 5134000000000 +cpu,cpu=0 usage_idle=33.6402,usage_system=50.5307,usage_user=85.606 5135000000000 +cpu,cpu=1 usage_idle=90.7727,usage_system=30.9174,usage_user=0.695434 5136000000000 +cpu,cpu=2 usage_idle=10.99,usage_system=8.20084,usage_user=39.1902 5137000000000 +cpu,cpu=3 usage_idle=72.3596,usage_system=31.8509,usage_user=1.28515 5138000000000 +cpu,cpu=4 usage_idle=3.00827,usage_system=84.2777,usage_user=15.3266 5139000000000 +cpu,cpu=0 usage_idle=86.6847,usage_system=36.6433,usage_user=64.0931 5140000000000 +cpu,cpu=1 usage_idle=13.0008,usage_system=50.8342,usage_user=60.4986 5141000000000 +cpu,cpu=2 usage_idle=14.1483,usage_system=4.83091,usage_user=68.7048 5142000000000 +cpu,cpu=3 usage_idle=22.5036,usage_system=61.6352,usage_user=30.5502 5143000000000 +cpu,cpu=4 usage_idle=15.6772,usage_system=71.7843,usage_user=92.2823 5144000000000 +cpu,cpu=0 usage_idle=98.2451,usage_system=5.42456,usage_user=42.813 5145000000000 +cpu,cpu=1 usage_idle=83.8511,usage_system=96.1972,usage_user=73.7304 5146000000000 +cpu,cpu=2 usage_idle=84.5465,usage_system=7.18723,usage_user=81.9313 5147000000000 +cpu,cpu=3 usage_idle=23.7367,usage_system=79.5468,usage_user=13.7822 5148000000000 +cpu,cpu=4 usage_idle=25.0218,usage_system=82.5551,usage_user=98.0598 5149000000000 +cpu,cpu=0 usage_idle=40.3485,usage_system=69.2398,usage_user=34.7031 5150000000000 +cpu,cpu=1 usage_idle=4.44151,usage_system=82.2406,usage_user=85.5373 5151000000000 +cpu,cpu=2 usage_idle=64.9401,usage_system=96.3889,usage_user=90.3682 5152000000000 +cpu,cpu=3 usage_idle=33.6449,usage_system=18.8925,usage_user=52.0034 5153000000000 +cpu,cpu=4 usage_idle=64.1951,usage_system=34.5698,usage_user=23.7877 5154000000000 +cpu,cpu=0 usage_idle=56.4773,usage_system=32.8149,usage_user=29.2123 5155000000000 +cpu,cpu=1 usage_idle=99.2903,usage_system=16.6659,usage_user=25.4095 5156000000000 +cpu,cpu=2 usage_idle=73.0208,usage_system=1.21244,usage_user=32.5968 5157000000000 +cpu,cpu=3 usage_idle=54.952,usage_system=24.9491,usage_user=12.1436 5158000000000 +cpu,cpu=4 usage_idle=68.7342,usage_system=49.9709,usage_user=94.6987 5159000000000 +cpu,cpu=0 usage_idle=66.794,usage_system=90.3194,usage_user=63.9385 5160000000000 +cpu,cpu=1 usage_idle=1.49709,usage_system=94.7609,usage_user=46.1791 5161000000000 +cpu,cpu=2 usage_idle=87.0344,usage_system=59.701,usage_user=42.568 5162000000000 +cpu,cpu=3 usage_idle=77.4026,usage_system=93.3458,usage_user=61.4606 5163000000000 +cpu,cpu=4 usage_idle=29.406,usage_system=57.5409,usage_user=96.0303 5164000000000 +cpu,cpu=0 usage_idle=53.1937,usage_system=14.0183,usage_user=28.8452 5165000000000 +cpu,cpu=1 usage_idle=82.406,usage_system=13.3086,usage_user=45.5112 5166000000000 +cpu,cpu=2 usage_idle=7.81554,usage_system=86.3294,usage_user=46.7236 5167000000000 +cpu,cpu=3 usage_idle=40.4123,usage_system=41.2814,usage_user=71.6727 5168000000000 +cpu,cpu=4 usage_idle=52.5559,usage_system=10.0156,usage_user=21.6436 5169000000000 +cpu,cpu=0 usage_idle=47.2546,usage_system=76.8096,usage_user=11.963 5170000000000 +cpu,cpu=1 usage_idle=11.1931,usage_system=78.3067,usage_user=6.72391 5171000000000 +cpu,cpu=2 usage_idle=57.3722,usage_system=65.341,usage_user=66.4249 5172000000000 +cpu,cpu=3 usage_idle=99.9402,usage_system=42.7436,usage_user=59.7707 5173000000000 +cpu,cpu=4 usage_idle=61.4008,usage_system=72.1496,usage_user=17.3117 5174000000000 +cpu,cpu=0 usage_idle=57.4312,usage_system=25.3433,usage_user=31.3299 5175000000000 +cpu,cpu=1 usage_idle=86.2764,usage_system=7.74928,usage_user=44.6385 5176000000000 +cpu,cpu=2 usage_idle=31.7875,usage_system=15.5648,usage_user=30.9679 5177000000000 +cpu,cpu=3 usage_idle=78.5111,usage_system=55.9771,usage_user=72.2493 5178000000000 +cpu,cpu=4 usage_idle=50.1838,usage_system=8.533,usage_user=82.2649 5179000000000 +cpu,cpu=0 usage_idle=71.8275,usage_system=55.7876,usage_user=59.0745 5180000000000 +cpu,cpu=1 usage_idle=83.7905,usage_system=66.9807,usage_user=37.3811 5181000000000 +cpu,cpu=2 usage_idle=90.5144,usage_system=24.3529,usage_user=2.72214 5182000000000 +cpu,cpu=3 usage_idle=56.9393,usage_system=24.2931,usage_user=45.4657 5183000000000 +cpu,cpu=4 usage_idle=16.71,usage_system=85.694,usage_user=17.6153 5184000000000 +cpu,cpu=0 usage_idle=34.0217,usage_system=43.1251,usage_user=42.9585 5185000000000 +cpu,cpu=1 usage_idle=65.3516,usage_system=29.4015,usage_user=50.7078 5186000000000 +cpu,cpu=2 usage_idle=9.9901,usage_system=61.189,usage_user=66.2726 5187000000000 +cpu,cpu=3 usage_idle=40.958,usage_system=39.7001,usage_user=22.2497 5188000000000 +cpu,cpu=4 usage_idle=13.2073,usage_system=89.884,usage_user=30.7827 5189000000000 +cpu,cpu=0 usage_idle=95.4722,usage_system=61.7115,usage_user=86.5703 5190000000000 +cpu,cpu=1 usage_idle=54.5467,usage_system=45.5019,usage_user=53.551 5191000000000 +cpu,cpu=2 usage_idle=91.9278,usage_system=36.0163,usage_user=77.9039 5192000000000 +cpu,cpu=3 usage_idle=94.6499,usage_system=92.9556,usage_user=2.19707 5193000000000 +cpu,cpu=4 usage_idle=40.1156,usage_system=9.66562,usage_user=87.891 5194000000000 +cpu,cpu=0 usage_idle=57.7309,usage_system=43.6873,usage_user=31.0161 5195000000000 +cpu,cpu=1 usage_idle=0.689455,usage_system=9.03886,usage_user=60.4176 5196000000000 +cpu,cpu=2 usage_idle=51.3973,usage_system=19.029,usage_user=21.6066 5197000000000 +cpu,cpu=3 usage_idle=17.6699,usage_system=59.987,usage_user=61.3068 5198000000000 +cpu,cpu=4 usage_idle=39.9197,usage_system=73.1943,usage_user=51.1907 5199000000000 +cpu,cpu=0 usage_idle=70.7024,usage_system=68.6665,usage_user=12.9022 5200000000000 +cpu,cpu=1 usage_idle=57.2727,usage_system=23.2131,usage_user=58.4041 5201000000000 +cpu,cpu=2 usage_idle=10.8238,usage_system=15.1409,usage_user=94.4205 5202000000000 +cpu,cpu=3 usage_idle=88.7277,usage_system=9.7908,usage_user=87.3761 5203000000000 +cpu,cpu=4 usage_idle=90.9248,usage_system=49.9064,usage_user=97.0417 5204000000000 +cpu,cpu=0 usage_idle=78.8158,usage_system=7.63735,usage_user=40.729 5205000000000 +cpu,cpu=1 usage_idle=9.83192,usage_system=8.3268,usage_user=49.7679 5206000000000 +cpu,cpu=2 usage_idle=70.2495,usage_system=59.7241,usage_user=68.7968 5207000000000 +cpu,cpu=3 usage_idle=91.8562,usage_system=77.394,usage_user=28.7838 5208000000000 +cpu,cpu=4 usage_idle=53.1629,usage_system=17.3136,usage_user=1.97806 5209000000000 +cpu,cpu=0 usage_idle=4.35367,usage_system=88.016,usage_user=70.6445 5210000000000 +cpu,cpu=1 usage_idle=17.2559,usage_system=45.2888,usage_user=93.8577 5211000000000 +cpu,cpu=2 usage_idle=75.66,usage_system=56.1125,usage_user=8.99855 5212000000000 +cpu,cpu=3 usage_idle=70.0805,usage_system=44.8402,usage_user=18.7893 5213000000000 +cpu,cpu=4 usage_idle=57.4566,usage_system=35.765,usage_user=68.6958 5214000000000 +cpu,cpu=0 usage_idle=54.4983,usage_system=14.5808,usage_user=76.3331 5215000000000 +cpu,cpu=1 usage_idle=95.2273,usage_system=24.4127,usage_user=84.6599 5216000000000 +cpu,cpu=2 usage_idle=44.9951,usage_system=94.6622,usage_user=44.384 5217000000000 +cpu,cpu=3 usage_idle=13.792,usage_system=86.5184,usage_user=21.778 5218000000000 +cpu,cpu=4 usage_idle=42.5757,usage_system=39.6813,usage_user=39.0916 5219000000000 +cpu,cpu=0 usage_idle=44.5538,usage_system=44.035,usage_user=27.1077 5220000000000 +cpu,cpu=1 usage_idle=15.1983,usage_system=61.2909,usage_user=72.3965 5221000000000 +cpu,cpu=2 usage_idle=9.056,usage_system=36.9509,usage_user=28.509 5222000000000 +cpu,cpu=3 usage_idle=18.0545,usage_system=7.03137,usage_user=73.3492 5223000000000 +cpu,cpu=4 usage_idle=36.8439,usage_system=64.4879,usage_user=9.11423 5224000000000 +cpu,cpu=0 usage_idle=5.53967,usage_system=18.9862,usage_user=23.695 5225000000000 +cpu,cpu=1 usage_idle=81.8728,usage_system=14.2135,usage_user=48.1077 5226000000000 +cpu,cpu=2 usage_idle=66.5327,usage_system=59.2087,usage_user=42.7699 5227000000000 +cpu,cpu=3 usage_idle=10.9167,usage_system=73.0006,usage_user=29.2883 5228000000000 +cpu,cpu=4 usage_idle=32.6947,usage_system=15.5764,usage_user=68.9696 5229000000000 +cpu,cpu=0 usage_idle=71.7864,usage_system=60.1302,usage_user=13.0046 5230000000000 +cpu,cpu=1 usage_idle=98.8941,usage_system=75.3285,usage_user=74.2955 5231000000000 +cpu,cpu=2 usage_idle=71.2906,usage_system=84.3845,usage_user=11.2464 5232000000000 +cpu,cpu=3 usage_idle=99.7996,usage_system=2.43905,usage_user=18.2777 5233000000000 +cpu,cpu=4 usage_idle=73.1488,usage_system=39.2829,usage_user=82.7657 5234000000000 +cpu,cpu=0 usage_idle=82.2631,usage_system=44.8226,usage_user=1.7519 5235000000000 +cpu,cpu=1 usage_idle=5.95806,usage_system=26.6954,usage_user=15.9654 5236000000000 +cpu,cpu=2 usage_idle=54.0658,usage_system=93.2281,usage_user=75.1741 5237000000000 +cpu,cpu=3 usage_idle=96.8357,usage_system=4.14489,usage_user=48.1747 5238000000000 +cpu,cpu=4 usage_idle=26.124,usage_system=36.8396,usage_user=63.7511 5239000000000 +cpu,cpu=0 usage_idle=95.0937,usage_system=8.62603,usage_user=23.8812 5240000000000 +cpu,cpu=1 usage_idle=8.09829,usage_system=7.52011,usage_user=99.2097 5241000000000 +cpu,cpu=2 usage_idle=82.3938,usage_system=78.8107,usage_user=83.5942 5242000000000 +cpu,cpu=3 usage_idle=93.6401,usage_system=78.6103,usage_user=86.0333 5243000000000 +cpu,cpu=4 usage_idle=11.9178,usage_system=51.7591,usage_user=25.3162 5244000000000 +cpu,cpu=0 usage_idle=94.6835,usage_system=34.0221,usage_user=70.1388 5245000000000 +cpu,cpu=1 usage_idle=96.4354,usage_system=39.9802,usage_user=96.8342 5246000000000 +cpu,cpu=2 usage_idle=12.4008,usage_system=94.046,usage_user=90.0624 5247000000000 +cpu,cpu=3 usage_idle=87.5749,usage_system=90.8817,usage_user=94.2073 5248000000000 +cpu,cpu=4 usage_idle=35.7496,usage_system=17.0057,usage_user=31.0469 5249000000000 +cpu,cpu=0 usage_idle=99.5006,usage_system=12.0994,usage_user=39.6729 5250000000000 +cpu,cpu=1 usage_idle=23.3819,usage_system=20.1977,usage_user=47.1931 5251000000000 +cpu,cpu=2 usage_idle=22.5916,usage_system=2.59147,usage_user=26.0037 5252000000000 +cpu,cpu=3 usage_idle=6.18584,usage_system=96.2316,usage_user=4.61399 5253000000000 +cpu,cpu=4 usage_idle=92.2191,usage_system=8.14942,usage_user=56.3731 5254000000000 +cpu,cpu=0 usage_idle=17.5354,usage_system=2.83292,usage_user=90.3952 5255000000000 +cpu,cpu=1 usage_idle=87.6742,usage_system=99.2683,usage_user=30.3754 5256000000000 +cpu,cpu=2 usage_idle=84.5084,usage_system=11.6691,usage_user=24.4214 5257000000000 +cpu,cpu=3 usage_idle=74.5708,usage_system=99.244,usage_user=15.3031 5258000000000 +cpu,cpu=4 usage_idle=68.7781,usage_system=34.9936,usage_user=32.3088 5259000000000 +cpu,cpu=0 usage_idle=99.825,usage_system=34.4942,usage_user=44.4082 5260000000000 +cpu,cpu=1 usage_idle=39.4979,usage_system=57.8761,usage_user=64.6059 5261000000000 +cpu,cpu=2 usage_idle=86.691,usage_system=80.4677,usage_user=67.1974 5262000000000 +cpu,cpu=3 usage_idle=12.6947,usage_system=86.6536,usage_user=63.429 5263000000000 +cpu,cpu=4 usage_idle=17.3087,usage_system=78.8727,usage_user=71.5784 5264000000000 +cpu,cpu=0 usage_idle=73.6818,usage_system=96.408,usage_user=74.4113 5265000000000 +cpu,cpu=1 usage_idle=64.077,usage_system=84.0822,usage_user=73.6796 5266000000000 +cpu,cpu=2 usage_idle=94.4524,usage_system=68.5907,usage_user=85.3487 5267000000000 +cpu,cpu=3 usage_idle=18.8738,usage_system=43.1615,usage_user=84.5928 5268000000000 +cpu,cpu=4 usage_idle=34.1769,usage_system=11.9396,usage_user=19.5864 5269000000000 +cpu,cpu=0 usage_idle=66.4857,usage_system=11.7646,usage_user=54.0806 5270000000000 +cpu,cpu=1 usage_idle=10.8939,usage_system=51.2625,usage_user=11.9567 5271000000000 +cpu,cpu=2 usage_idle=75.4998,usage_system=37.9535,usage_user=92.4245 5272000000000 +cpu,cpu=3 usage_idle=42.6972,usage_system=50.6482,usage_user=79.078 5273000000000 +cpu,cpu=4 usage_idle=6.12611,usage_system=67.9569,usage_user=57.9507 5274000000000 +cpu,cpu=0 usage_idle=77.7045,usage_system=41.6387,usage_user=54.3588 5275000000000 +cpu,cpu=1 usage_idle=52.1158,usage_system=5.71573,usage_user=38.441 5276000000000 +cpu,cpu=2 usage_idle=25.7954,usage_system=0.168147,usage_user=7.03166 5277000000000 +cpu,cpu=3 usage_idle=11.1441,usage_system=19.042,usage_user=50.1931 5278000000000 +cpu,cpu=4 usage_idle=95.7369,usage_system=53.2188,usage_user=62.1327 5279000000000 +cpu,cpu=0 usage_idle=15.3233,usage_system=19.7045,usage_user=73.8973 5280000000000 +cpu,cpu=1 usage_idle=69.4039,usage_system=30.5984,usage_user=25.1598 5281000000000 +cpu,cpu=2 usage_idle=81.3606,usage_system=6.09821,usage_user=63.1133 5282000000000 +cpu,cpu=3 usage_idle=73.7851,usage_system=48.7954,usage_user=13.7615 5283000000000 +cpu,cpu=4 usage_idle=52.8631,usage_system=54.9215,usage_user=81.7185 5284000000000 +cpu,cpu=0 usage_idle=10.8138,usage_system=32.626,usage_user=23.3572 5285000000000 +cpu,cpu=1 usage_idle=65.1726,usage_system=84.7417,usage_user=29.073 5286000000000 +cpu,cpu=2 usage_idle=3.61357,usage_system=10.5371,usage_user=29.2411 5287000000000 +cpu,cpu=3 usage_idle=10.6452,usage_system=21.6813,usage_user=48.2831 5288000000000 +cpu,cpu=4 usage_idle=60.8384,usage_system=17.4182,usage_user=1.50189 5289000000000 +cpu,cpu=0 usage_idle=22.9711,usage_system=32.7414,usage_user=21.2064 5290000000000 +cpu,cpu=1 usage_idle=96.8683,usage_system=2.1453,usage_user=51.8048 5291000000000 +cpu,cpu=2 usage_idle=22.0281,usage_system=83.5059,usage_user=57.903 5292000000000 +cpu,cpu=3 usage_idle=85.1414,usage_system=57.291,usage_user=6.6984 5293000000000 +cpu,cpu=4 usage_idle=98.903,usage_system=10.154,usage_user=61.6199 5294000000000 +cpu,cpu=0 usage_idle=80.6215,usage_system=20.9678,usage_user=94.2458 5295000000000 +cpu,cpu=1 usage_idle=3.9787,usage_system=86.1404,usage_user=78.9876 5296000000000 +cpu,cpu=2 usage_idle=33.0517,usage_system=89.754,usage_user=89.5247 5297000000000 +cpu,cpu=3 usage_idle=62.2928,usage_system=0.3992,usage_user=11.206 5298000000000 +cpu,cpu=4 usage_idle=10.5758,usage_system=61.2376,usage_user=28.6242 5299000000000 +cpu,cpu=0 usage_idle=12.0777,usage_system=84.2086,usage_user=61.3656 5300000000000 +cpu,cpu=1 usage_idle=33.2841,usage_system=81.0769,usage_user=63.5109 5301000000000 +cpu,cpu=2 usage_idle=85.089,usage_system=3.10508,usage_user=47.0168 5302000000000 +cpu,cpu=3 usage_idle=42.992,usage_system=88.2465,usage_user=4.30778 5303000000000 +cpu,cpu=4 usage_idle=49.6904,usage_system=87.1495,usage_user=14.4618 5304000000000 +cpu,cpu=0 usage_idle=11.3103,usage_system=67.771,usage_user=35.4297 5305000000000 +cpu,cpu=1 usage_idle=5.55613,usage_system=71.7497,usage_user=21.5701 5306000000000 +cpu,cpu=2 usage_idle=84.5437,usage_system=4.80135,usage_user=11.324 5307000000000 +cpu,cpu=3 usage_idle=74.0685,usage_system=67.0941,usage_user=11.7232 5308000000000 +cpu,cpu=4 usage_idle=85.2745,usage_system=77.67,usage_user=72.9608 5309000000000 +cpu,cpu=0 usage_idle=13.8987,usage_system=89.7477,usage_user=57.1694 5310000000000 +cpu,cpu=1 usage_idle=75.2643,usage_system=23.0318,usage_user=38.2464 5311000000000 +cpu,cpu=2 usage_idle=38.7752,usage_system=8.12081,usage_user=41.3514 5312000000000 +cpu,cpu=3 usage_idle=85.792,usage_system=51.1128,usage_user=29.598 5313000000000 +cpu,cpu=4 usage_idle=90.0998,usage_system=0.803216,usage_user=16.7475 5314000000000 +cpu,cpu=0 usage_idle=4.56161,usage_system=12.1135,usage_user=84.5184 5315000000000 +cpu,cpu=1 usage_idle=39.9913,usage_system=17.6696,usage_user=56.2681 5316000000000 +cpu,cpu=2 usage_idle=61.5613,usage_system=2.21336,usage_user=61.0695 5317000000000 +cpu,cpu=3 usage_idle=72.8854,usage_system=76.2818,usage_user=28.1636 5318000000000 +cpu,cpu=4 usage_idle=84.6086,usage_system=61.5563,usage_user=5.83354 5319000000000 +cpu,cpu=0 usage_idle=57.5694,usage_system=75.455,usage_user=95.5812 5320000000000 +cpu,cpu=1 usage_idle=14.7389,usage_system=50.7192,usage_user=18.6131 5321000000000 +cpu,cpu=2 usage_idle=52.9852,usage_system=89.4944,usage_user=26.7339 5322000000000 +cpu,cpu=3 usage_idle=94.3367,usage_system=75.2864,usage_user=77.8467 5323000000000 +cpu,cpu=4 usage_idle=23.9346,usage_system=65.3862,usage_user=78.6499 5324000000000 +cpu,cpu=0 usage_idle=40.6821,usage_system=69.9478,usage_user=90.7634 5325000000000 +cpu,cpu=1 usage_idle=25.2005,usage_system=9.9391,usage_user=8.43304 5326000000000 +cpu,cpu=2 usage_idle=81.4686,usage_system=71.5004,usage_user=10.6464 5327000000000 +cpu,cpu=3 usage_idle=42.5381,usage_system=44.3858,usage_user=86.9282 5328000000000 +cpu,cpu=4 usage_idle=70.7017,usage_system=28.9945,usage_user=48.4845 5329000000000 +cpu,cpu=0 usage_idle=76.5352,usage_system=86.5639,usage_user=23.9395 5330000000000 +cpu,cpu=1 usage_idle=72.1164,usage_system=1.30276,usage_user=74.6587 5331000000000 +cpu,cpu=2 usage_idle=90.7295,usage_system=54.288,usage_user=64.1532 5332000000000 +cpu,cpu=3 usage_idle=17.4634,usage_system=48.6247,usage_user=39.4396 5333000000000 +cpu,cpu=4 usage_idle=95.3101,usage_system=72.5593,usage_user=4.82583 5334000000000 +cpu,cpu=0 usage_idle=73.96,usage_system=13.2414,usage_user=74.7737 5335000000000 +cpu,cpu=1 usage_idle=64.7234,usage_system=38.4419,usage_user=84.7127 5336000000000 +cpu,cpu=2 usage_idle=73.1565,usage_system=19.9105,usage_user=56.2132 5337000000000 +cpu,cpu=3 usage_idle=83.8029,usage_system=62.4486,usage_user=0.599016 5338000000000 +cpu,cpu=4 usage_idle=70.7311,usage_system=33.1502,usage_user=29.5935 5339000000000 +cpu,cpu=0 usage_idle=19.2156,usage_system=9.68545,usage_user=16.1574 5340000000000 +cpu,cpu=1 usage_idle=43.1551,usage_system=81.8019,usage_user=17.4602 5341000000000 +cpu,cpu=2 usage_idle=17.8139,usage_system=72.5314,usage_user=71.7481 5342000000000 +cpu,cpu=3 usage_idle=81.967,usage_system=89.9948,usage_user=20.3728 5343000000000 +cpu,cpu=4 usage_idle=21.4066,usage_system=85.3049,usage_user=92.9321 5344000000000 +cpu,cpu=0 usage_idle=26.2325,usage_system=59.2649,usage_user=6.17342 5345000000000 +cpu,cpu=1 usage_idle=1.00612,usage_system=23.9884,usage_user=44.6153 5346000000000 +cpu,cpu=2 usage_idle=85.7189,usage_system=97.1448,usage_user=64.5258 5347000000000 +cpu,cpu=3 usage_idle=41.9321,usage_system=80.9477,usage_user=26.9744 5348000000000 +cpu,cpu=4 usage_idle=42.5311,usage_system=51.6788,usage_user=60.1246 5349000000000 +cpu,cpu=0 usage_idle=72.1246,usage_system=70.8944,usage_user=69.8101 5350000000000 +cpu,cpu=1 usage_idle=88.2819,usage_system=14.0496,usage_user=51.612 5351000000000 +cpu,cpu=2 usage_idle=5.7421,usage_system=31.8634,usage_user=24.1434 5352000000000 +cpu,cpu=3 usage_idle=77.4902,usage_system=13.8305,usage_user=14.1382 5353000000000 +cpu,cpu=4 usage_idle=97.863,usage_system=35.2371,usage_user=99.4431 5354000000000 +cpu,cpu=0 usage_idle=90.7951,usage_system=61.4696,usage_user=58.7081 5355000000000 +cpu,cpu=1 usage_idle=96.9685,usage_system=62.4757,usage_user=82.6964 5356000000000 +cpu,cpu=2 usage_idle=41.5838,usage_system=48.1946,usage_user=79.8413 5357000000000 +cpu,cpu=3 usage_idle=6.1096,usage_system=90.1267,usage_user=60.789 5358000000000 +cpu,cpu=4 usage_idle=33.084,usage_system=32.6577,usage_user=12.4678 5359000000000 +cpu,cpu=0 usage_idle=93.2086,usage_system=4.78229,usage_user=83.3622 5360000000000 +cpu,cpu=1 usage_idle=63.0186,usage_system=93.0642,usage_user=97.4118 5361000000000 +cpu,cpu=2 usage_idle=14.6306,usage_system=98.8063,usage_user=29.2752 5362000000000 +cpu,cpu=3 usage_idle=38.774,usage_system=76.2966,usage_user=43.1057 5363000000000 +cpu,cpu=4 usage_idle=52.9122,usage_system=74.1596,usage_user=78.3428 5364000000000 +cpu,cpu=0 usage_idle=52.3553,usage_system=64.9547,usage_user=39.8124 5365000000000 +cpu,cpu=1 usage_idle=11.0633,usage_system=61.9232,usage_user=2.28814 5366000000000 +cpu,cpu=2 usage_idle=93.7598,usage_system=3.50704,usage_user=50.4827 5367000000000 +cpu,cpu=3 usage_idle=73.601,usage_system=9.61664,usage_user=40.6094 5368000000000 +cpu,cpu=4 usage_idle=34.39,usage_system=42.7006,usage_user=73.2671 5369000000000 +cpu,cpu=0 usage_idle=46.8578,usage_system=35.9092,usage_user=78.0494 5370000000000 +cpu,cpu=1 usage_idle=30.22,usage_system=98.9278,usage_user=71.1136 5371000000000 +cpu,cpu=2 usage_idle=27.6318,usage_system=13.5584,usage_user=69.92 5372000000000 +cpu,cpu=3 usage_idle=56.907,usage_system=52.3323,usage_user=46.2166 5373000000000 +cpu,cpu=4 usage_idle=0.0126784,usage_system=5.2445,usage_user=20.3762 5374000000000 +cpu,cpu=0 usage_idle=78.3555,usage_system=57.5998,usage_user=85.3309 5375000000000 +cpu,cpu=1 usage_idle=18.1679,usage_system=68.6631,usage_user=47.2541 5376000000000 +cpu,cpu=2 usage_idle=20.4561,usage_system=62.4229,usage_user=50.7611 5377000000000 +cpu,cpu=3 usage_idle=70.9388,usage_system=36.0239,usage_user=60.3778 5378000000000 +cpu,cpu=4 usage_idle=11.5482,usage_system=70.4139,usage_user=3.07838 5379000000000 +cpu,cpu=0 usage_idle=84.8153,usage_system=17.2717,usage_user=38.9876 5380000000000 +cpu,cpu=1 usage_idle=62.8647,usage_system=47.4917,usage_user=37.9154 5381000000000 +cpu,cpu=2 usage_idle=33.9784,usage_system=75.1234,usage_user=51.4737 5382000000000 +cpu,cpu=3 usage_idle=3.89835,usage_system=32.0304,usage_user=3.80609 5383000000000 +cpu,cpu=4 usage_idle=50.1149,usage_system=32.0431,usage_user=9.05059 5384000000000 +cpu,cpu=0 usage_idle=70.4911,usage_system=10.3986,usage_user=66.6504 5385000000000 +cpu,cpu=1 usage_idle=55.8219,usage_system=28.5665,usage_user=35.3135 5386000000000 +cpu,cpu=2 usage_idle=3.07602,usage_system=49.0226,usage_user=97.7364 5387000000000 +cpu,cpu=3 usage_idle=53.8372,usage_system=19.9614,usage_user=33.7603 5388000000000 +cpu,cpu=4 usage_idle=14.2149,usage_system=31.5096,usage_user=4.17422 5389000000000 +cpu,cpu=0 usage_idle=17.2933,usage_system=16.3249,usage_user=21.4459 5390000000000 +cpu,cpu=1 usage_idle=56.2809,usage_system=79.1896,usage_user=68.9376 5391000000000 +cpu,cpu=2 usage_idle=94.1962,usage_system=13.1679,usage_user=44.061 5392000000000 +cpu,cpu=3 usage_idle=45.67,usage_system=17.0663,usage_user=76.0914 5393000000000 +cpu,cpu=4 usage_idle=49.4761,usage_system=67.1812,usage_user=8.13455 5394000000000 +cpu,cpu=0 usage_idle=58.5266,usage_system=37.6723,usage_user=18.5331 5395000000000 +cpu,cpu=1 usage_idle=25.177,usage_system=93.4942,usage_user=47.0997 5396000000000 +cpu,cpu=2 usage_idle=60.4905,usage_system=96.5702,usage_user=96.1222 5397000000000 +cpu,cpu=3 usage_idle=58.2269,usage_system=50.4074,usage_user=16.0836 5398000000000 +cpu,cpu=4 usage_idle=91.9872,usage_system=64.6223,usage_user=47.5932 5399000000000 +cpu,cpu=0 usage_idle=96.1614,usage_system=81.9156,usage_user=63.918 5400000000000 +cpu,cpu=1 usage_idle=17.6074,usage_system=38.1965,usage_user=43.1076 5401000000000 +cpu,cpu=2 usage_idle=86.5449,usage_system=32.3927,usage_user=56.2755 5402000000000 +cpu,cpu=3 usage_idle=30.606,usage_system=78.0627,usage_user=73.3418 5403000000000 +cpu,cpu=4 usage_idle=6.69741,usage_system=27.5387,usage_user=40.523 5404000000000 +cpu,cpu=0 usage_idle=14.832,usage_system=86.0654,usage_user=78.1953 5405000000000 +cpu,cpu=1 usage_idle=33.3651,usage_system=11.2424,usage_user=71.6895 5406000000000 +cpu,cpu=2 usage_idle=80.4648,usage_system=71.7329,usage_user=68.2597 5407000000000 +cpu,cpu=3 usage_idle=76.587,usage_system=29.9598,usage_user=18.667 5408000000000 +cpu,cpu=4 usage_idle=92.6706,usage_system=21.947,usage_user=83.2893 5409000000000 +cpu,cpu=0 usage_idle=40.2638,usage_system=18.1085,usage_user=65.2049 5410000000000 +cpu,cpu=1 usage_idle=4.1818,usage_system=35.7158,usage_user=3.40134 5411000000000 +cpu,cpu=2 usage_idle=47.2894,usage_system=22.2608,usage_user=35.794 5412000000000 +cpu,cpu=3 usage_idle=3.56493,usage_system=52.8667,usage_user=13.8567 5413000000000 +cpu,cpu=4 usage_idle=76.9068,usage_system=59.5642,usage_user=41.3954 5414000000000 +cpu,cpu=0 usage_idle=17.4298,usage_system=74.3961,usage_user=27.4607 5415000000000 +cpu,cpu=1 usage_idle=95.625,usage_system=7.76122,usage_user=38.7031 5416000000000 +cpu,cpu=2 usage_idle=67.3145,usage_system=88.226,usage_user=10.436 5417000000000 +cpu,cpu=3 usage_idle=35.5742,usage_system=64.813,usage_user=40.3958 5418000000000 +cpu,cpu=4 usage_idle=54.2412,usage_system=57.4836,usage_user=62.3429 5419000000000 +cpu,cpu=0 usage_idle=37.5305,usage_system=97.7474,usage_user=80.4514 5420000000000 +cpu,cpu=1 usage_idle=2.73534,usage_system=1.92923,usage_user=16.1672 5421000000000 +cpu,cpu=2 usage_idle=6.13668,usage_system=49.2186,usage_user=38.428 5422000000000 +cpu,cpu=3 usage_idle=41.9307,usage_system=52.7835,usage_user=91.2947 5423000000000 +cpu,cpu=4 usage_idle=55.7874,usage_system=29.6903,usage_user=50.8589 5424000000000 +cpu,cpu=0 usage_idle=97.1828,usage_system=47.1201,usage_user=25.255 5425000000000 +cpu,cpu=1 usage_idle=24.6435,usage_system=42.7451,usage_user=33.0162 5426000000000 +cpu,cpu=2 usage_idle=63.3466,usage_system=10.0596,usage_user=21.2422 5427000000000 +cpu,cpu=3 usage_idle=73.7826,usage_system=45.6338,usage_user=86.0553 5428000000000 +cpu,cpu=4 usage_idle=14.1785,usage_system=99.8749,usage_user=43.5389 5429000000000 +cpu,cpu=0 usage_idle=76.5213,usage_system=37.4054,usage_user=41.2863 5430000000000 +cpu,cpu=1 usage_idle=56.9727,usage_system=40.1407,usage_user=43.2155 5431000000000 +cpu,cpu=2 usage_idle=73.1399,usage_system=46.2774,usage_user=92.4342 5432000000000 +cpu,cpu=3 usage_idle=11.5679,usage_system=88.2081,usage_user=45.2177 5433000000000 +cpu,cpu=4 usage_idle=2.86266,usage_system=43.9955,usage_user=74.908 5434000000000 +cpu,cpu=0 usage_idle=53.7216,usage_system=41.1782,usage_user=22.0281 5435000000000 +cpu,cpu=1 usage_idle=78.9766,usage_system=65.8217,usage_user=64.7732 5436000000000 +cpu,cpu=2 usage_idle=11.9928,usage_system=29.1683,usage_user=74.8328 5437000000000 +cpu,cpu=3 usage_idle=33.2351,usage_system=2.95096,usage_user=20.4665 5438000000000 +cpu,cpu=4 usage_idle=19.2903,usage_system=17.1294,usage_user=20.3415 5439000000000 +cpu,cpu=0 usage_idle=62.8292,usage_system=93.6508,usage_user=57.7468 5440000000000 +cpu,cpu=1 usage_idle=4.11554,usage_system=50.6235,usage_user=97.8876 5441000000000 +cpu,cpu=2 usage_idle=47.3311,usage_system=23.7634,usage_user=44.165 5442000000000 +cpu,cpu=3 usage_idle=39.7653,usage_system=35.3313,usage_user=32.3731 5443000000000 +cpu,cpu=4 usage_idle=84.983,usage_system=38.194,usage_user=76.3686 5444000000000 +cpu,cpu=0 usage_idle=59.891,usage_system=91.9155,usage_user=17.5468 5445000000000 +cpu,cpu=1 usage_idle=81.9191,usage_system=70.8921,usage_user=83.3685 5446000000000 +cpu,cpu=2 usage_idle=46.6922,usage_system=82.8849,usage_user=12.5369 5447000000000 +cpu,cpu=3 usage_idle=21.525,usage_system=16.12,usage_user=15.4878 5448000000000 +cpu,cpu=4 usage_idle=41.9916,usage_system=35.4103,usage_user=32.6173 5449000000000 +cpu,cpu=0 usage_idle=62.333,usage_system=98.2395,usage_user=26.268 5450000000000 +cpu,cpu=1 usage_idle=20.0799,usage_system=2.35508,usage_user=76.8915 5451000000000 +cpu,cpu=2 usage_idle=17.9674,usage_system=49.6862,usage_user=0.654862 5452000000000 +cpu,cpu=3 usage_idle=62.1324,usage_system=89.4514,usage_user=35.9862 5453000000000 +cpu,cpu=4 usage_idle=94.5055,usage_system=74.4344,usage_user=74.1801 5454000000000 +cpu,cpu=0 usage_idle=70.874,usage_system=34.3254,usage_user=66.0956 5455000000000 +cpu,cpu=1 usage_idle=88.4208,usage_system=16.2444,usage_user=36.9877 5456000000000 +cpu,cpu=2 usage_idle=71.7894,usage_system=62.9366,usage_user=19.8726 5457000000000 +cpu,cpu=3 usage_idle=84.3263,usage_system=84.4617,usage_user=35.9926 5458000000000 +cpu,cpu=4 usage_idle=99.8141,usage_system=26.4532,usage_user=71.4029 5459000000000 +cpu,cpu=0 usage_idle=32.4314,usage_system=88.7862,usage_user=69.6425 5460000000000 +cpu,cpu=1 usage_idle=58.6994,usage_system=8.8661,usage_user=71.9976 5461000000000 +cpu,cpu=2 usage_idle=35.5909,usage_system=26.8335,usage_user=21.6837 5462000000000 +cpu,cpu=3 usage_idle=36.2457,usage_system=88.9659,usage_user=11.1352 5463000000000 +cpu,cpu=4 usage_idle=72.2319,usage_system=83.4714,usage_user=85.5696 5464000000000 +cpu,cpu=0 usage_idle=46.412,usage_system=54.3454,usage_user=19.8949 5465000000000 +cpu,cpu=1 usage_idle=12.5076,usage_system=42.7663,usage_user=36.1393 5466000000000 +cpu,cpu=2 usage_idle=49.4953,usage_system=14.5556,usage_user=99.076 5467000000000 +cpu,cpu=3 usage_idle=69.368,usage_system=98.8819,usage_user=83.5376 5468000000000 +cpu,cpu=4 usage_idle=5.36058,usage_system=98.696,usage_user=9.99087 5469000000000 +cpu,cpu=0 usage_idle=76.7635,usage_system=31.1274,usage_user=98.7771 5470000000000 +cpu,cpu=1 usage_idle=46.406,usage_system=89.8268,usage_user=7.6432 5471000000000 +cpu,cpu=2 usage_idle=18.4036,usage_system=25.4176,usage_user=34.4767 5472000000000 +cpu,cpu=3 usage_idle=40.0873,usage_system=61.6634,usage_user=23.4426 5473000000000 +cpu,cpu=4 usage_idle=51.2225,usage_system=33.8953,usage_user=6.91403 5474000000000 +cpu,cpu=0 usage_idle=36.792,usage_system=80.3073,usage_user=61.2594 5475000000000 +cpu,cpu=1 usage_idle=56.687,usage_system=92.8149,usage_user=4.02571 5476000000000 +cpu,cpu=2 usage_idle=92.8263,usage_system=42.3102,usage_user=18.5814 5477000000000 +cpu,cpu=3 usage_idle=91.9023,usage_system=11.6781,usage_user=17.4633 5478000000000 +cpu,cpu=4 usage_idle=75.4399,usage_system=17.0387,usage_user=16.1593 5479000000000 +cpu,cpu=0 usage_idle=85.4308,usage_system=93.8022,usage_user=47.2867 5480000000000 +cpu,cpu=1 usage_idle=84.2079,usage_system=40.2083,usage_user=37.1135 5481000000000 +cpu,cpu=2 usage_idle=91.8511,usage_system=58.6118,usage_user=62.5311 5482000000000 +cpu,cpu=3 usage_idle=26.3278,usage_system=98.6991,usage_user=24.1945 5483000000000 +cpu,cpu=4 usage_idle=49.7705,usage_system=49.9216,usage_user=58.0897 5484000000000 +cpu,cpu=0 usage_idle=56.6845,usage_system=86.7137,usage_user=38.397 5485000000000 +cpu,cpu=1 usage_idle=17.9439,usage_system=43.4006,usage_user=31.2119 5486000000000 +cpu,cpu=2 usage_idle=21.9697,usage_system=36.2269,usage_user=73.5221 5487000000000 +cpu,cpu=3 usage_idle=40.551,usage_system=28.1292,usage_user=85.2002 5488000000000 +cpu,cpu=4 usage_idle=58.0143,usage_system=3.5691,usage_user=2.23895 5489000000000 +cpu,cpu=0 usage_idle=74.1736,usage_system=88.9999,usage_user=96.0412 5490000000000 +cpu,cpu=1 usage_idle=21.4603,usage_system=73.2078,usage_user=36.2494 5491000000000 +cpu,cpu=2 usage_idle=58.5737,usage_system=65.0589,usage_user=94.8613 5492000000000 +cpu,cpu=3 usage_idle=21.1048,usage_system=91.3867,usage_user=93.5604 5493000000000 +cpu,cpu=4 usage_idle=45.2993,usage_system=41.1572,usage_user=43.482 5494000000000 +cpu,cpu=0 usage_idle=3.38902,usage_system=97.8417,usage_user=30.1957 5495000000000 +cpu,cpu=1 usage_idle=41.786,usage_system=15.7856,usage_user=73.5963 5496000000000 +cpu,cpu=2 usage_idle=72.9979,usage_system=37.7553,usage_user=9.82322 5497000000000 +cpu,cpu=3 usage_idle=46.52,usage_system=78.3063,usage_user=37.9524 5498000000000 +cpu,cpu=4 usage_idle=31.7202,usage_system=36.3206,usage_user=41.5215 5499000000000 +cpu,cpu=0 usage_idle=33.9591,usage_system=10.4941,usage_user=30.5214 5500000000000 +cpu,cpu=1 usage_idle=30.0003,usage_system=31.9544,usage_user=3.72916 5501000000000 +cpu,cpu=2 usage_idle=66.2498,usage_system=90.5281,usage_user=68.788 5502000000000 +cpu,cpu=3 usage_idle=61.1111,usage_system=11.6329,usage_user=60.1747 5503000000000 +cpu,cpu=4 usage_idle=54.6715,usage_system=56.9322,usage_user=1.33191 5504000000000 +cpu,cpu=0 usage_idle=98.1535,usage_system=60.3212,usage_user=99.1736 5505000000000 +cpu,cpu=1 usage_idle=28.3492,usage_system=2.10722,usage_user=14.9592 5506000000000 +cpu,cpu=2 usage_idle=1.94553,usage_system=75.1051,usage_user=52.7144 5507000000000 +cpu,cpu=3 usage_idle=11.7688,usage_system=21.6251,usage_user=31.0207 5508000000000 +cpu,cpu=4 usage_idle=49.7212,usage_system=53.3453,usage_user=67.3412 5509000000000 +cpu,cpu=0 usage_idle=91.2427,usage_system=87.3044,usage_user=77.8354 5510000000000 +cpu,cpu=1 usage_idle=21.764,usage_system=17.3047,usage_user=9.78977 5511000000000 +cpu,cpu=2 usage_idle=25.4932,usage_system=83.5545,usage_user=0.317871 5512000000000 +cpu,cpu=3 usage_idle=94.2812,usage_system=44.6656,usage_user=11.9508 5513000000000 +cpu,cpu=4 usage_idle=54.456,usage_system=99.337,usage_user=68.883 5514000000000 +cpu,cpu=0 usage_idle=55.7879,usage_system=97.4905,usage_user=29.2042 5515000000000 +cpu,cpu=1 usage_idle=54.9614,usage_system=25.8398,usage_user=31.3114 5516000000000 +cpu,cpu=2 usage_idle=69.9206,usage_system=27.7853,usage_user=6.41649 5517000000000 +cpu,cpu=3 usage_idle=22.635,usage_system=39.554,usage_user=28.0416 5518000000000 +cpu,cpu=4 usage_idle=53.6557,usage_system=89.2752,usage_user=81.3868 5519000000000 +cpu,cpu=0 usage_idle=20.9969,usage_system=80.5179,usage_user=68.6912 5520000000000 +cpu,cpu=1 usage_idle=98.8323,usage_system=2.28189,usage_user=85.9959 5521000000000 +cpu,cpu=2 usage_idle=8.62207,usage_system=27.7751,usage_user=69.5504 5522000000000 +cpu,cpu=3 usage_idle=8.93994,usage_system=22.0563,usage_user=14.216 5523000000000 +cpu,cpu=4 usage_idle=20.8907,usage_system=76.5123,usage_user=13.553 5524000000000 +cpu,cpu=0 usage_idle=89.7737,usage_system=32.3001,usage_user=11.0436 5525000000000 +cpu,cpu=1 usage_idle=18.9778,usage_system=87.2616,usage_user=36.8833 5526000000000 +cpu,cpu=2 usage_idle=50.2892,usage_system=57.1822,usage_user=64.6686 5527000000000 +cpu,cpu=3 usage_idle=56.7057,usage_system=79.8172,usage_user=4.22267 5528000000000 +cpu,cpu=4 usage_idle=84.7473,usage_system=33.4729,usage_user=93.4979 5529000000000 +cpu,cpu=0 usage_idle=66.1341,usage_system=54.4698,usage_user=74.0157 5530000000000 +cpu,cpu=1 usage_idle=34.8253,usage_system=53.3021,usage_user=76.2976 5531000000000 +cpu,cpu=2 usage_idle=20.8213,usage_system=61.9242,usage_user=4.07269 5532000000000 +cpu,cpu=3 usage_idle=90.3717,usage_system=70.8641,usage_user=26.129 5533000000000 +cpu,cpu=4 usage_idle=4.58772,usage_system=91.7548,usage_user=2.64127 5534000000000 +cpu,cpu=0 usage_idle=18.1408,usage_system=81.5285,usage_user=34.9414 5535000000000 +cpu,cpu=1 usage_idle=29.1843,usage_system=0.506346,usage_user=22.203 5536000000000 +cpu,cpu=2 usage_idle=66.0677,usage_system=50.7956,usage_user=79.3852 5537000000000 +cpu,cpu=3 usage_idle=30.7363,usage_system=7.50126,usage_user=59.2024 5538000000000 +cpu,cpu=4 usage_idle=34.959,usage_system=92.2485,usage_user=92.6753 5539000000000 +cpu,cpu=0 usage_idle=28.4568,usage_system=58.3826,usage_user=47.1451 5540000000000 +cpu,cpu=1 usage_idle=2.47257,usage_system=93.208,usage_user=0.447183 5541000000000 +cpu,cpu=2 usage_idle=78.7702,usage_system=14.0292,usage_user=62.3714 5542000000000 +cpu,cpu=3 usage_idle=82.8429,usage_system=4.40095,usage_user=33.2355 5543000000000 +cpu,cpu=4 usage_idle=8.97188,usage_system=8.98867,usage_user=24.9903 5544000000000 +cpu,cpu=0 usage_idle=11.6131,usage_system=27.1294,usage_user=6.51884 5545000000000 +cpu,cpu=1 usage_idle=46.5546,usage_system=56.3137,usage_user=7.02519 5546000000000 +cpu,cpu=2 usage_idle=68.7575,usage_system=22.3814,usage_user=57.8207 5547000000000 +cpu,cpu=3 usage_idle=48.1427,usage_system=53.1177,usage_user=65.322 5548000000000 +cpu,cpu=4 usage_idle=7.34509,usage_system=88.0766,usage_user=57.5705 5549000000000 +cpu,cpu=0 usage_idle=0.020338,usage_system=16.5335,usage_user=15.9532 5550000000000 +cpu,cpu=1 usage_idle=47.1654,usage_system=19.006,usage_user=9.16112 5551000000000 +cpu,cpu=2 usage_idle=47.6126,usage_system=97.7762,usage_user=23.1903 5552000000000 +cpu,cpu=3 usage_idle=9.98396,usage_system=80.6191,usage_user=27.5913 5553000000000 +cpu,cpu=4 usage_idle=43.2194,usage_system=89.591,usage_user=36.58 5554000000000 +cpu,cpu=0 usage_idle=68.2098,usage_system=1.20413,usage_user=63.7094 5555000000000 +cpu,cpu=1 usage_idle=74.7286,usage_system=47.7587,usage_user=20.0231 5556000000000 +cpu,cpu=2 usage_idle=81.7538,usage_system=16.5162,usage_user=42.4046 5557000000000 +cpu,cpu=3 usage_idle=39.5746,usage_system=64.659,usage_user=95.5222 5558000000000 +cpu,cpu=4 usage_idle=4.89656,usage_system=72.004,usage_user=83.5989 5559000000000 +cpu,cpu=0 usage_idle=62.4671,usage_system=72.0244,usage_user=0.132339 5560000000000 +cpu,cpu=1 usage_idle=78.4203,usage_system=19.1898,usage_user=19.1384 5561000000000 +cpu,cpu=2 usage_idle=87.5814,usage_system=66.8024,usage_user=16.9146 5562000000000 +cpu,cpu=3 usage_idle=10.7717,usage_system=76.7863,usage_user=97.5337 5563000000000 +cpu,cpu=4 usage_idle=38.363,usage_system=20.0058,usage_user=87.1247 5564000000000 +cpu,cpu=0 usage_idle=74.943,usage_system=88.2155,usage_user=88.3288 5565000000000 +cpu,cpu=1 usage_idle=38.6524,usage_system=62.9442,usage_user=36.0875 5566000000000 +cpu,cpu=2 usage_idle=58.6755,usage_system=44.698,usage_user=52.6037 5567000000000 +cpu,cpu=3 usage_idle=1.08008,usage_system=84.2725,usage_user=17.2627 5568000000000 +cpu,cpu=4 usage_idle=96.6023,usage_system=89.1691,usage_user=89.2667 5569000000000 +cpu,cpu=0 usage_idle=80.2012,usage_system=51.6362,usage_user=61.2911 5570000000000 +cpu,cpu=1 usage_idle=80.3335,usage_system=30.0565,usage_user=80.4809 5571000000000 +cpu,cpu=2 usage_idle=99.4719,usage_system=17.6378,usage_user=47.2832 5572000000000 +cpu,cpu=3 usage_idle=16.3865,usage_system=28.4096,usage_user=24.0696 5573000000000 +cpu,cpu=4 usage_idle=13.9202,usage_system=66.7726,usage_user=44.0753 5574000000000 +cpu,cpu=0 usage_idle=1.04488,usage_system=41.7156,usage_user=32.2909 5575000000000 +cpu,cpu=1 usage_idle=89.3737,usage_system=80.3679,usage_user=95.235 5576000000000 +cpu,cpu=2 usage_idle=25.4612,usage_system=39.0435,usage_user=39.933 5577000000000 +cpu,cpu=3 usage_idle=78.0649,usage_system=40.1236,usage_user=24.2056 5578000000000 +cpu,cpu=4 usage_idle=95.3276,usage_system=36.7259,usage_user=13.3747 5579000000000 +cpu,cpu=0 usage_idle=84.5943,usage_system=16.9271,usage_user=65.0109 5580000000000 +cpu,cpu=1 usage_idle=45.8854,usage_system=97.2606,usage_user=95.0673 5581000000000 +cpu,cpu=2 usage_idle=26.3663,usage_system=96.7325,usage_user=12.7051 5582000000000 +cpu,cpu=3 usage_idle=73.6495,usage_system=13.119,usage_user=41.1147 5583000000000 +cpu,cpu=4 usage_idle=97.7191,usage_system=27.0392,usage_user=7.88728 5584000000000 +cpu,cpu=0 usage_idle=41.7944,usage_system=28.0841,usage_user=49.6028 5585000000000 +cpu,cpu=1 usage_idle=74.0853,usage_system=17.4577,usage_user=29.9708 5586000000000 +cpu,cpu=2 usage_idle=69.3203,usage_system=42.9189,usage_user=69.0143 5587000000000 +cpu,cpu=3 usage_idle=9.25331,usage_system=20.9839,usage_user=9.13783 5588000000000 +cpu,cpu=4 usage_idle=33.4589,usage_system=16.3115,usage_user=45.8637 5589000000000 +cpu,cpu=0 usage_idle=46.8335,usage_system=0.905763,usage_user=62.7908 5590000000000 +cpu,cpu=1 usage_idle=11.8444,usage_system=46.7912,usage_user=60.0514 5591000000000 +cpu,cpu=2 usage_idle=6.91169,usage_system=73.1574,usage_user=56.7838 5592000000000 +cpu,cpu=3 usage_idle=19.6168,usage_system=46.8069,usage_user=69.9028 5593000000000 +cpu,cpu=4 usage_idle=60.7315,usage_system=44.526,usage_user=96.942 5594000000000 +cpu,cpu=0 usage_idle=68.6188,usage_system=86.3204,usage_user=25.026 5595000000000 +cpu,cpu=1 usage_idle=18.2217,usage_system=60.4056,usage_user=42.4838 5596000000000 +cpu,cpu=2 usage_idle=48.1924,usage_system=29.7259,usage_user=85.4027 5597000000000 +cpu,cpu=3 usage_idle=17.2067,usage_system=38.9792,usage_user=6.38657 5598000000000 +cpu,cpu=4 usage_idle=26.3445,usage_system=72.4381,usage_user=22.698 5599000000000 +cpu,cpu=0 usage_idle=72.2083,usage_system=19.2716,usage_user=23.6038 5600000000000 +cpu,cpu=1 usage_idle=34.999,usage_system=31.116,usage_user=70.3949 5601000000000 +cpu,cpu=2 usage_idle=95.0504,usage_system=38.0277,usage_user=43.5524 5602000000000 +cpu,cpu=3 usage_idle=51.8342,usage_system=57.6445,usage_user=90.3593 5603000000000 +cpu,cpu=4 usage_idle=21.737,usage_system=18.376,usage_user=34.8853 5604000000000 +cpu,cpu=0 usage_idle=18.679,usage_system=86.9948,usage_user=21.2057 5605000000000 +cpu,cpu=1 usage_idle=43.705,usage_system=5.2165,usage_user=81.6113 5606000000000 +cpu,cpu=2 usage_idle=86.1888,usage_system=53.4089,usage_user=11.3372 5607000000000 +cpu,cpu=3 usage_idle=71.5915,usage_system=70.6157,usage_user=50.3164 5608000000000 +cpu,cpu=4 usage_idle=77.9781,usage_system=96.9602,usage_user=22.7545 5609000000000 +cpu,cpu=0 usage_idle=0.676118,usage_system=69.1685,usage_user=42.0261 5610000000000 +cpu,cpu=1 usage_idle=24.2799,usage_system=4.16748,usage_user=73.1421 5611000000000 +cpu,cpu=2 usage_idle=94.6748,usage_system=99.2179,usage_user=11.1698 5612000000000 +cpu,cpu=3 usage_idle=38.2272,usage_system=51.0521,usage_user=68.8143 5613000000000 +cpu,cpu=4 usage_idle=28.5865,usage_system=72.7891,usage_user=87.1903 5614000000000 +cpu,cpu=0 usage_idle=63.4718,usage_system=91.4681,usage_user=74.1851 5615000000000 +cpu,cpu=1 usage_idle=84.6775,usage_system=35.1731,usage_user=79.4016 5616000000000 +cpu,cpu=2 usage_idle=66.2888,usage_system=21.3619,usage_user=32.8106 5617000000000 +cpu,cpu=3 usage_idle=77.626,usage_system=92.9535,usage_user=3.42624 5618000000000 +cpu,cpu=4 usage_idle=27.9425,usage_system=70.9316,usage_user=0.38645 5619000000000 +cpu,cpu=0 usage_idle=50.697,usage_system=71.6077,usage_user=69.5549 5620000000000 +cpu,cpu=1 usage_idle=92.7231,usage_system=95.8876,usage_user=73.7224 5621000000000 +cpu,cpu=2 usage_idle=65.8652,usage_system=90.5624,usage_user=72.9402 5622000000000 +cpu,cpu=3 usage_idle=77.035,usage_system=28.7897,usage_user=23.9923 5623000000000 +cpu,cpu=4 usage_idle=45.8492,usage_system=57.3762,usage_user=96.7814 5624000000000 +cpu,cpu=0 usage_idle=33.0395,usage_system=20.848,usage_user=88.2495 5625000000000 +cpu,cpu=1 usage_idle=7.22464,usage_system=5.52551,usage_user=23.4226 5626000000000 +cpu,cpu=2 usage_idle=86.6263,usage_system=71.8143,usage_user=44.7846 5627000000000 +cpu,cpu=3 usage_idle=19.4369,usage_system=49.4403,usage_user=37.738 5628000000000 +cpu,cpu=4 usage_idle=22.8631,usage_system=77.3828,usage_user=8.66961 5629000000000 +cpu,cpu=0 usage_idle=23.2496,usage_system=28.0798,usage_user=80.2773 5630000000000 +cpu,cpu=1 usage_idle=92.8045,usage_system=20.8029,usage_user=76.1649 5631000000000 +cpu,cpu=2 usage_idle=66.5269,usage_system=86.6681,usage_user=66.7273 5632000000000 +cpu,cpu=3 usage_idle=39.4671,usage_system=63.7031,usage_user=95.517 5633000000000 +cpu,cpu=4 usage_idle=63.4594,usage_system=9.55234,usage_user=52.8932 5634000000000 +cpu,cpu=0 usage_idle=60.2408,usage_system=42.5918,usage_user=73.7412 5635000000000 +cpu,cpu=1 usage_idle=48.4903,usage_system=49.8165,usage_user=79.2667 5636000000000 +cpu,cpu=2 usage_idle=71.9129,usage_system=36.4428,usage_user=51.081 5637000000000 +cpu,cpu=3 usage_idle=16.6974,usage_system=55.8796,usage_user=0.521355 5638000000000 +cpu,cpu=4 usage_idle=54.4355,usage_system=78.7427,usage_user=77.9042 5639000000000 +cpu,cpu=0 usage_idle=63.1051,usage_system=1.99228,usage_user=5.98395 5640000000000 +cpu,cpu=1 usage_idle=43.3824,usage_system=94.7967,usage_user=26.7869 5641000000000 +cpu,cpu=2 usage_idle=19.5473,usage_system=61.3236,usage_user=13.455 5642000000000 +cpu,cpu=3 usage_idle=86.2746,usage_system=0.790702,usage_user=77.1581 5643000000000 +cpu,cpu=4 usage_idle=81.7916,usage_system=64.2501,usage_user=86.7104 5644000000000 +cpu,cpu=0 usage_idle=34.6848,usage_system=24.4909,usage_user=29.3023 5645000000000 +cpu,cpu=1 usage_idle=8.42601,usage_system=72.9812,usage_user=79.1188 5646000000000 +cpu,cpu=2 usage_idle=87.6927,usage_system=44.8941,usage_user=15.5616 5647000000000 +cpu,cpu=3 usage_idle=38.7737,usage_system=61.5915,usage_user=71.4412 5648000000000 +cpu,cpu=4 usage_idle=39.2951,usage_system=16.027,usage_user=50.1839 5649000000000 +cpu,cpu=0 usage_idle=17.1992,usage_system=79.1321,usage_user=52.1762 5650000000000 +cpu,cpu=1 usage_idle=23.1832,usage_system=22.5145,usage_user=46.973 5651000000000 +cpu,cpu=2 usage_idle=49.9701,usage_system=42.0618,usage_user=8.29656 5652000000000 +cpu,cpu=3 usage_idle=63.4251,usage_system=28.3364,usage_user=9.08726 5653000000000 +cpu,cpu=4 usage_idle=40.5832,usage_system=10.128,usage_user=73.3374 5654000000000 +cpu,cpu=0 usage_idle=27.2936,usage_system=44.8129,usage_user=97.8283 5655000000000 +cpu,cpu=1 usage_idle=56.5959,usage_system=53.2389,usage_user=70.8095 5656000000000 +cpu,cpu=2 usage_idle=35.7147,usage_system=40.9316,usage_user=15.7036 5657000000000 +cpu,cpu=3 usage_idle=51.2763,usage_system=79.7053,usage_user=77.2951 5658000000000 +cpu,cpu=4 usage_idle=22.7175,usage_system=19.0004,usage_user=93.3222 5659000000000 +cpu,cpu=0 usage_idle=72.9014,usage_system=36.1997,usage_user=72.4542 5660000000000 +cpu,cpu=1 usage_idle=25.0776,usage_system=59.3829,usage_user=94.9687 5661000000000 +cpu,cpu=2 usage_idle=72.0506,usage_system=9.35293,usage_user=37.0305 5662000000000 +cpu,cpu=3 usage_idle=80.3471,usage_system=72.778,usage_user=65.3669 5663000000000 +cpu,cpu=4 usage_idle=89.4344,usage_system=13.3612,usage_user=75.4949 5664000000000 +cpu,cpu=0 usage_idle=62.7718,usage_system=40.6548,usage_user=20.3078 5665000000000 +cpu,cpu=1 usage_idle=60.6001,usage_system=97.2508,usage_user=73.5467 5666000000000 +cpu,cpu=2 usage_idle=31.4096,usage_system=32.9655,usage_user=14.4782 5667000000000 +cpu,cpu=3 usage_idle=47.1132,usage_system=84.2417,usage_user=94.1836 5668000000000 +cpu,cpu=4 usage_idle=24.4083,usage_system=6.95921,usage_user=13.184 5669000000000 +cpu,cpu=0 usage_idle=17.7304,usage_system=79.8606,usage_user=49.3836 5670000000000 +cpu,cpu=1 usage_idle=90.1847,usage_system=4.93821,usage_user=8.76649 5671000000000 +cpu,cpu=2 usage_idle=85.1534,usage_system=76.9888,usage_user=18.1194 5672000000000 +cpu,cpu=3 usage_idle=22.1839,usage_system=57.3359,usage_user=90.8974 5673000000000 +cpu,cpu=4 usage_idle=87.5508,usage_system=46.7703,usage_user=4.25862 5674000000000 +cpu,cpu=0 usage_idle=63.0457,usage_system=9.54203,usage_user=44.9134 5675000000000 +cpu,cpu=1 usage_idle=83.3535,usage_system=70.1421,usage_user=42.1642 5676000000000 +cpu,cpu=2 usage_idle=56.9002,usage_system=1.55164,usage_user=75.1297 5677000000000 +cpu,cpu=3 usage_idle=71.3784,usage_system=48.6648,usage_user=59.3714 5678000000000 +cpu,cpu=4 usage_idle=65.562,usage_system=73.0731,usage_user=66.3306 5679000000000 +cpu,cpu=0 usage_idle=78.7459,usage_system=90.8035,usage_user=46.1912 5680000000000 +cpu,cpu=1 usage_idle=28.1296,usage_system=80.9882,usage_user=51.1294 5681000000000 +cpu,cpu=2 usage_idle=36.896,usage_system=66.1416,usage_user=28.1182 5682000000000 +cpu,cpu=3 usage_idle=55.0155,usage_system=88.3256,usage_user=85.4541 5683000000000 +cpu,cpu=4 usage_idle=45.9129,usage_system=75.8763,usage_user=32.2244 5684000000000 +cpu,cpu=0 usage_idle=50.1715,usage_system=38.9221,usage_user=41.7664 5685000000000 +cpu,cpu=1 usage_idle=95.085,usage_system=22.2756,usage_user=11.9085 5686000000000 +cpu,cpu=2 usage_idle=37.2492,usage_system=79.1758,usage_user=13.4601 5687000000000 +cpu,cpu=3 usage_idle=12.3788,usage_system=50.5542,usage_user=62.1249 5688000000000 +cpu,cpu=4 usage_idle=71.7502,usage_system=16.1161,usage_user=35.198 5689000000000 +cpu,cpu=0 usage_idle=38.0809,usage_system=94.8621,usage_user=26.0016 5690000000000 +cpu,cpu=1 usage_idle=84.2721,usage_system=22.9916,usage_user=6.98983 5691000000000 +cpu,cpu=2 usage_idle=35.4015,usage_system=59.8877,usage_user=73.1315 5692000000000 +cpu,cpu=3 usage_idle=63.5197,usage_system=14.9031,usage_user=61.457 5693000000000 +cpu,cpu=4 usage_idle=48.9738,usage_system=60.816,usage_user=37.3334 5694000000000 +cpu,cpu=0 usage_idle=81.1982,usage_system=10.9875,usage_user=76.2554 5695000000000 +cpu,cpu=1 usage_idle=22.9646,usage_system=6.07252,usage_user=98.531 5696000000000 +cpu,cpu=2 usage_idle=34.8731,usage_system=43.3217,usage_user=77.7068 5697000000000 +cpu,cpu=3 usage_idle=48.3333,usage_system=55.7005,usage_user=28.2609 5698000000000 +cpu,cpu=4 usage_idle=10.4582,usage_system=27.4508,usage_user=44.3771 5699000000000 +cpu,cpu=0 usage_idle=45.6563,usage_system=65.5316,usage_user=39.2391 5700000000000 +cpu,cpu=1 usage_idle=71.6579,usage_system=49.8037,usage_user=62.2307 5701000000000 +cpu,cpu=2 usage_idle=78.6477,usage_system=85.2052,usage_user=22.1184 5702000000000 +cpu,cpu=3 usage_idle=51.7792,usage_system=48.725,usage_user=37.0215 5703000000000 +cpu,cpu=4 usage_idle=13.2362,usage_system=97.6988,usage_user=97.8376 5704000000000 +cpu,cpu=0 usage_idle=50.5696,usage_system=78.897,usage_user=8.82511 5705000000000 +cpu,cpu=1 usage_idle=26.825,usage_system=1.86163,usage_user=14.8976 5706000000000 +cpu,cpu=2 usage_idle=25.356,usage_system=36.7348,usage_user=58.2193 5707000000000 +cpu,cpu=3 usage_idle=3.06283,usage_system=85.068,usage_user=13.9198 5708000000000 +cpu,cpu=4 usage_idle=31.3238,usage_system=95.5263,usage_user=41.3706 5709000000000 +cpu,cpu=0 usage_idle=75.7009,usage_system=41.1825,usage_user=6.90226 5710000000000 +cpu,cpu=1 usage_idle=14.94,usage_system=12.8404,usage_user=56.706 5711000000000 +cpu,cpu=2 usage_idle=77.1707,usage_system=91.4881,usage_user=41.9112 5712000000000 +cpu,cpu=3 usage_idle=99.2891,usage_system=43.2672,usage_user=90.6362 5713000000000 +cpu,cpu=4 usage_idle=36.3107,usage_system=56.5034,usage_user=88.335 5714000000000 +cpu,cpu=0 usage_idle=34.1482,usage_system=7.07296,usage_user=67.232 5715000000000 +cpu,cpu=1 usage_idle=42.9733,usage_system=33.898,usage_user=69.0936 5716000000000 +cpu,cpu=2 usage_idle=57.871,usage_system=59.254,usage_user=5.8284 5717000000000 +cpu,cpu=3 usage_idle=16.0903,usage_system=62.3168,usage_user=90.8964 5718000000000 +cpu,cpu=4 usage_idle=30.0101,usage_system=93.6406,usage_user=86.4227 5719000000000 +cpu,cpu=0 usage_idle=71.3808,usage_system=69.3415,usage_user=27.6052 5720000000000 +cpu,cpu=1 usage_idle=78.283,usage_system=84.2815,usage_user=40.4456 5721000000000 +cpu,cpu=2 usage_idle=34.989,usage_system=61.4522,usage_user=31.9336 5722000000000 +cpu,cpu=3 usage_idle=76.9002,usage_system=60.7413,usage_user=75.2009 5723000000000 +cpu,cpu=4 usage_idle=67.5364,usage_system=97.052,usage_user=31.7043 5724000000000 +cpu,cpu=0 usage_idle=55.8714,usage_system=31.2002,usage_user=38.7772 5725000000000 +cpu,cpu=1 usage_idle=23.1034,usage_system=74.1735,usage_user=72.6752 5726000000000 +cpu,cpu=2 usage_idle=92.1971,usage_system=32.0445,usage_user=31.9292 5727000000000 +cpu,cpu=3 usage_idle=98.0255,usage_system=48.1348,usage_user=94.246 5728000000000 +cpu,cpu=4 usage_idle=88.9219,usage_system=78.1449,usage_user=87.8866 5729000000000 +cpu,cpu=0 usage_idle=75.3446,usage_system=49.5257,usage_user=57.2281 5730000000000 +cpu,cpu=1 usage_idle=2.94977,usage_system=27.8087,usage_user=41.5096 5731000000000 +cpu,cpu=2 usage_idle=43.3953,usage_system=62.7977,usage_user=2.96175 5732000000000 +cpu,cpu=3 usage_idle=75.329,usage_system=39.6979,usage_user=63.7031 5733000000000 +cpu,cpu=4 usage_idle=50.5298,usage_system=7.23434,usage_user=60.755 5734000000000 +cpu,cpu=0 usage_idle=82.2341,usage_system=63.1057,usage_user=91.9552 5735000000000 +cpu,cpu=1 usage_idle=21.0113,usage_system=86.2092,usage_user=66.1288 5736000000000 +cpu,cpu=2 usage_idle=93.6865,usage_system=78.4062,usage_user=98.1733 5737000000000 +cpu,cpu=3 usage_idle=25.6157,usage_system=76.4317,usage_user=46.3081 5738000000000 +cpu,cpu=4 usage_idle=19.8617,usage_system=65.3536,usage_user=24.453 5739000000000 +cpu,cpu=0 usage_idle=7.74833,usage_system=40.6982,usage_user=73.9787 5740000000000 +cpu,cpu=1 usage_idle=64.9764,usage_system=43.6479,usage_user=1.78746 5741000000000 +cpu,cpu=2 usage_idle=6.48602,usage_system=87.0433,usage_user=64.5852 5742000000000 +cpu,cpu=3 usage_idle=9.44777,usage_system=62.3723,usage_user=4.2831 5743000000000 +cpu,cpu=4 usage_idle=73.1508,usage_system=12.9021,usage_user=11.5174 5744000000000 +cpu,cpu=0 usage_idle=33.9059,usage_system=95.1362,usage_user=74.6232 5745000000000 +cpu,cpu=1 usage_idle=25.8611,usage_system=16.1475,usage_user=60.8323 5746000000000 +cpu,cpu=2 usage_idle=91.9899,usage_system=9.83395,usage_user=39.2386 5747000000000 +cpu,cpu=3 usage_idle=90.1632,usage_system=35.4496,usage_user=15.6703 5748000000000 +cpu,cpu=4 usage_idle=36.4713,usage_system=55.3113,usage_user=81.0239 5749000000000 +cpu,cpu=0 usage_idle=60.9243,usage_system=63.0596,usage_user=21.722 5750000000000 +cpu,cpu=1 usage_idle=34.9031,usage_system=28.0361,usage_user=65.37 5751000000000 +cpu,cpu=2 usage_idle=36.6905,usage_system=34.5221,usage_user=52.4133 5752000000000 +cpu,cpu=3 usage_idle=1.27572,usage_system=43.9698,usage_user=14.7855 5753000000000 +cpu,cpu=4 usage_idle=5.55882,usage_system=17.1207,usage_user=27.6876 5754000000000 +cpu,cpu=0 usage_idle=17.0763,usage_system=51.0266,usage_user=22.8238 5755000000000 +cpu,cpu=1 usage_idle=91.6994,usage_system=76.8877,usage_user=38.9713 5756000000000 +cpu,cpu=2 usage_idle=52.5318,usage_system=68.8776,usage_user=48.8052 5757000000000 +cpu,cpu=3 usage_idle=91.7704,usage_system=59.0407,usage_user=84.2549 5758000000000 +cpu,cpu=4 usage_idle=7.44064,usage_system=95.512,usage_user=39.5662 5759000000000 +cpu,cpu=0 usage_idle=88.4645,usage_system=56.4364,usage_user=2.62577 5760000000000 +cpu,cpu=1 usage_idle=10.1865,usage_system=91.3395,usage_user=30.6618 5761000000000 +cpu,cpu=2 usage_idle=75.5565,usage_system=28.03,usage_user=65.1839 5762000000000 +cpu,cpu=3 usage_idle=27.9698,usage_system=29.3057,usage_user=9.15376 5763000000000 +cpu,cpu=4 usage_idle=42.7553,usage_system=34.8646,usage_user=26.2744 5764000000000 +cpu,cpu=0 usage_idle=70.4429,usage_system=51.9408,usage_user=77.301 5765000000000 +cpu,cpu=1 usage_idle=93.2667,usage_system=43.6402,usage_user=54.1887 5766000000000 +cpu,cpu=2 usage_idle=32.238,usage_system=96.172,usage_user=23.0662 5767000000000 +cpu,cpu=3 usage_idle=81.0433,usage_system=87.9424,usage_user=82.107 5768000000000 +cpu,cpu=4 usage_idle=65.2981,usage_system=95.383,usage_user=77.619 5769000000000 +cpu,cpu=0 usage_idle=4.86429,usage_system=83.8475,usage_user=34.0554 5770000000000 +cpu,cpu=1 usage_idle=7.49006,usage_system=94.0341,usage_user=25.3948 5771000000000 +cpu,cpu=2 usage_idle=38.1519,usage_system=69.5906,usage_user=53.4249 5772000000000 +cpu,cpu=3 usage_idle=3.3358,usage_system=97.5603,usage_user=82.7306 5773000000000 +cpu,cpu=4 usage_idle=12.4896,usage_system=40.3156,usage_user=17.5951 5774000000000 +cpu,cpu=0 usage_idle=38.764,usage_system=10.7585,usage_user=69.5359 5775000000000 +cpu,cpu=1 usage_idle=16.065,usage_system=4.02529,usage_user=13.1762 5776000000000 +cpu,cpu=2 usage_idle=70.2537,usage_system=36.2633,usage_user=9.34821 5777000000000 +cpu,cpu=3 usage_idle=93.3199,usage_system=17.3066,usage_user=97.2906 5778000000000 +cpu,cpu=4 usage_idle=75.4268,usage_system=82.6047,usage_user=92.6736 5779000000000 +cpu,cpu=0 usage_idle=53.0458,usage_system=87.469,usage_user=76.5211 5780000000000 +cpu,cpu=1 usage_idle=87.1012,usage_system=94.9591,usage_user=70.5552 5781000000000 +cpu,cpu=2 usage_idle=12.4961,usage_system=33.111,usage_user=40.1458 5782000000000 +cpu,cpu=3 usage_idle=65.9209,usage_system=36.4468,usage_user=37.7061 5783000000000 +cpu,cpu=4 usage_idle=48.6515,usage_system=48.9364,usage_user=78.0217 5784000000000 +cpu,cpu=0 usage_idle=66.2467,usage_system=87.7004,usage_user=88.7803 5785000000000 +cpu,cpu=1 usage_idle=35.7826,usage_system=3.76536,usage_user=92.8056 5786000000000 +cpu,cpu=2 usage_idle=48.9588,usage_system=74.019,usage_user=29.0689 5787000000000 +cpu,cpu=3 usage_idle=58.307,usage_system=67.3389,usage_user=46.3755 5788000000000 +cpu,cpu=4 usage_idle=55.5976,usage_system=42.7657,usage_user=28.9802 5789000000000 +cpu,cpu=0 usage_idle=48.2712,usage_system=95.8116,usage_user=16.4493 5790000000000 +cpu,cpu=1 usage_idle=24.7924,usage_system=82.9128,usage_user=11.4084 5791000000000 +cpu,cpu=2 usage_idle=95.3476,usage_system=95.4089,usage_user=44.5194 5792000000000 +cpu,cpu=3 usage_idle=35.4934,usage_system=61.3298,usage_user=80.9662 5793000000000 +cpu,cpu=4 usage_idle=73.1995,usage_system=9.98133,usage_user=29.9026 5794000000000 +cpu,cpu=0 usage_idle=51.2212,usage_system=76.228,usage_user=17.6029 5795000000000 +cpu,cpu=1 usage_idle=40.0015,usage_system=12.0106,usage_user=21.3683 5796000000000 +cpu,cpu=2 usage_idle=32.8071,usage_system=60.9694,usage_user=95.3873 5797000000000 +cpu,cpu=3 usage_idle=61.876,usage_system=19.2765,usage_user=62.7262 5798000000000 +cpu,cpu=4 usage_idle=8.25145,usage_system=74.8741,usage_user=5.4919 5799000000000 +cpu,cpu=0 usage_idle=37.2317,usage_system=23.1453,usage_user=1.30347 5800000000000 +cpu,cpu=1 usage_idle=53.681,usage_system=47.9377,usage_user=84.2163 5801000000000 +cpu,cpu=2 usage_idle=65.0893,usage_system=43.2853,usage_user=79.6251 5802000000000 +cpu,cpu=3 usage_idle=9.60872,usage_system=78.7787,usage_user=40.9549 5803000000000 +cpu,cpu=4 usage_idle=90.5749,usage_system=51.9782,usage_user=50.9363 5804000000000 +cpu,cpu=0 usage_idle=20.4775,usage_system=3.1994,usage_user=27.1643 5805000000000 +cpu,cpu=1 usage_idle=38.0804,usage_system=43.2009,usage_user=39.1749 5806000000000 +cpu,cpu=2 usage_idle=59.4487,usage_system=76.008,usage_user=0.14435 5807000000000 +cpu,cpu=3 usage_idle=54.836,usage_system=37.8839,usage_user=19.4208 5808000000000 +cpu,cpu=4 usage_idle=17.5621,usage_system=46.1354,usage_user=94.2949 5809000000000 +cpu,cpu=0 usage_idle=23.0541,usage_system=83.3671,usage_user=17.4402 5810000000000 +cpu,cpu=1 usage_idle=24.3575,usage_system=37.048,usage_user=65.3779 5811000000000 +cpu,cpu=2 usage_idle=8.57377,usage_system=2.13738,usage_user=8.66326 5812000000000 +cpu,cpu=3 usage_idle=88.1989,usage_system=11.7461,usage_user=87.4419 5813000000000 +cpu,cpu=4 usage_idle=29.1538,usage_system=2.321,usage_user=39.4201 5814000000000 +cpu,cpu=0 usage_idle=80.0901,usage_system=22.7985,usage_user=42.6195 5815000000000 +cpu,cpu=1 usage_idle=7.25433,usage_system=60.8788,usage_user=85.8204 5816000000000 +cpu,cpu=2 usage_idle=46.4292,usage_system=20.3275,usage_user=61.8284 5817000000000 +cpu,cpu=3 usage_idle=46.5736,usage_system=75.1635,usage_user=99.7124 5818000000000 +cpu,cpu=4 usage_idle=65.9944,usage_system=92.7256,usage_user=45.8478 5819000000000 +cpu,cpu=0 usage_idle=60.2893,usage_system=15.7797,usage_user=29.2148 5820000000000 +cpu,cpu=1 usage_idle=77.7295,usage_system=40.1372,usage_user=66.2629 5821000000000 +cpu,cpu=2 usage_idle=43.1075,usage_system=48.7109,usage_user=68.4002 5822000000000 +cpu,cpu=3 usage_idle=51.7708,usage_system=36.9098,usage_user=80.1463 5823000000000 +cpu,cpu=4 usage_idle=39.2127,usage_system=66.0636,usage_user=82.4674 5824000000000 +cpu,cpu=0 usage_idle=78.6328,usage_system=46.1537,usage_user=5.26581 5825000000000 +cpu,cpu=1 usage_idle=21.2524,usage_system=53.408,usage_user=66.1446 5826000000000 +cpu,cpu=2 usage_idle=7.0728,usage_system=99.8373,usage_user=86.4721 5827000000000 +cpu,cpu=3 usage_idle=68.9012,usage_system=46.4108,usage_user=61.6356 5828000000000 +cpu,cpu=4 usage_idle=68.6136,usage_system=12.4052,usage_user=54.3612 5829000000000 +cpu,cpu=0 usage_idle=14.4613,usage_system=72.6946,usage_user=70.1409 5830000000000 +cpu,cpu=1 usage_idle=43.6762,usage_system=50.4241,usage_user=10.2781 5831000000000 +cpu,cpu=2 usage_idle=9.93904,usage_system=93.5316,usage_user=58.989 5832000000000 +cpu,cpu=3 usage_idle=78.3393,usage_system=45.3023,usage_user=95.8988 5833000000000 +cpu,cpu=4 usage_idle=58.4856,usage_system=84.515,usage_user=61.9625 5834000000000 +cpu,cpu=0 usage_idle=40.953,usage_system=63.1479,usage_user=8.11619 5835000000000 +cpu,cpu=1 usage_idle=46.2188,usage_system=84.4002,usage_user=61.5242 5836000000000 +cpu,cpu=2 usage_idle=12.3634,usage_system=91.473,usage_user=61.3615 5837000000000 +cpu,cpu=3 usage_idle=98.8356,usage_system=60.3743,usage_user=7.77233 5838000000000 +cpu,cpu=4 usage_idle=60.4712,usage_system=28.9878,usage_user=20.1776 5839000000000 +cpu,cpu=0 usage_idle=14.8324,usage_system=43.4492,usage_user=92.8721 5840000000000 +cpu,cpu=1 usage_idle=84.9733,usage_system=87.1254,usage_user=43.2962 5841000000000 +cpu,cpu=2 usage_idle=95.2513,usage_system=97.0644,usage_user=36.8278 5842000000000 +cpu,cpu=3 usage_idle=54.2403,usage_system=75.4037,usage_user=82.1302 5843000000000 +cpu,cpu=4 usage_idle=50.1392,usage_system=33.8893,usage_user=66.6452 5844000000000 +cpu,cpu=0 usage_idle=12.1017,usage_system=74.8423,usage_user=29.7931 5845000000000 +cpu,cpu=1 usage_idle=20.2178,usage_system=21.0611,usage_user=14.1933 5846000000000 +cpu,cpu=2 usage_idle=81.7421,usage_system=33.4245,usage_user=5.66637 5847000000000 +cpu,cpu=3 usage_idle=43.1036,usage_system=32.2601,usage_user=66.0406 5848000000000 +cpu,cpu=4 usage_idle=50.8759,usage_system=92.7313,usage_user=95.0285 5849000000000 +cpu,cpu=0 usage_idle=71.0535,usage_system=7.56374,usage_user=38.4777 5850000000000 +cpu,cpu=1 usage_idle=63.9256,usage_system=92.537,usage_user=25.603 5851000000000 +cpu,cpu=2 usage_idle=7.22179,usage_system=87.7884,usage_user=22.6674 5852000000000 +cpu,cpu=3 usage_idle=44.0496,usage_system=42.0287,usage_user=98.0711 5853000000000 +cpu,cpu=4 usage_idle=26.1798,usage_system=92.1679,usage_user=31.9604 5854000000000 +cpu,cpu=0 usage_idle=92.825,usage_system=4.26954,usage_user=6.8027 5855000000000 +cpu,cpu=1 usage_idle=22.618,usage_system=24.4874,usage_user=27.8638 5856000000000 +cpu,cpu=2 usage_idle=36.8114,usage_system=6.22946,usage_user=61.2883 5857000000000 +cpu,cpu=3 usage_idle=42.4777,usage_system=49.333,usage_user=93.5484 5858000000000 +cpu,cpu=4 usage_idle=8.51837,usage_system=0.208909,usage_user=86.2798 5859000000000 +cpu,cpu=0 usage_idle=3.54686,usage_system=71.2624,usage_user=93.8435 5860000000000 +cpu,cpu=1 usage_idle=42.0245,usage_system=35.1879,usage_user=86.3805 5861000000000 +cpu,cpu=2 usage_idle=67.6276,usage_system=42.4097,usage_user=74.1689 5862000000000 +cpu,cpu=3 usage_idle=90.295,usage_system=86.4593,usage_user=16.1976 5863000000000 +cpu,cpu=4 usage_idle=88.3661,usage_system=12.6391,usage_user=8.36547 5864000000000 +cpu,cpu=0 usage_idle=20.3265,usage_system=5.46405,usage_user=12.635 5865000000000 +cpu,cpu=1 usage_idle=27.1292,usage_system=28.0821,usage_user=37.1224 5866000000000 +cpu,cpu=2 usage_idle=54.993,usage_system=64.8934,usage_user=43.3518 5867000000000 +cpu,cpu=3 usage_idle=16.2813,usage_system=7.37118,usage_user=92.6849 5868000000000 +cpu,cpu=4 usage_idle=9.82976,usage_system=15.8896,usage_user=92.8938 5869000000000 +cpu,cpu=0 usage_idle=96.1095,usage_system=19.4364,usage_user=64.1561 5870000000000 +cpu,cpu=1 usage_idle=89.953,usage_system=61.461,usage_user=99.3441 5871000000000 +cpu,cpu=2 usage_idle=76.3336,usage_system=29.0885,usage_user=41.7538 5872000000000 +cpu,cpu=3 usage_idle=50.5025,usage_system=19.3835,usage_user=28.2132 5873000000000 +cpu,cpu=4 usage_idle=66.7,usage_system=7.7496,usage_user=40.8523 5874000000000 +cpu,cpu=0 usage_idle=75.0655,usage_system=28.0761,usage_user=46.3163 5875000000000 +cpu,cpu=1 usage_idle=87.7005,usage_system=55.2053,usage_user=74.3984 5876000000000 +cpu,cpu=2 usage_idle=24.8229,usage_system=10.1983,usage_user=39.2918 5877000000000 +cpu,cpu=3 usage_idle=68.1747,usage_system=26.4796,usage_user=46.663 5878000000000 +cpu,cpu=4 usage_idle=60.8596,usage_system=36.3094,usage_user=62.5526 5879000000000 +cpu,cpu=0 usage_idle=53.7534,usage_system=32.4189,usage_user=81.989 5880000000000 +cpu,cpu=1 usage_idle=17.9095,usage_system=22.3719,usage_user=43.4499 5881000000000 +cpu,cpu=2 usage_idle=17.2536,usage_system=98.7055,usage_user=72.5384 5882000000000 +cpu,cpu=3 usage_idle=59.0074,usage_system=49.2079,usage_user=91.9219 5883000000000 +cpu,cpu=4 usage_idle=87.2206,usage_system=15.908,usage_user=99.6715 5884000000000 +cpu,cpu=0 usage_idle=28.0729,usage_system=90.9735,usage_user=27.7476 5885000000000 +cpu,cpu=1 usage_idle=74.3892,usage_system=78.674,usage_user=82.9529 5886000000000 +cpu,cpu=2 usage_idle=48.7875,usage_system=3.49687,usage_user=93.1512 5887000000000 +cpu,cpu=3 usage_idle=88.0794,usage_system=71.6716,usage_user=19.6308 5888000000000 +cpu,cpu=4 usage_idle=34.7424,usage_system=32.5312,usage_user=55.9402 5889000000000 +cpu,cpu=0 usage_idle=97.2949,usage_system=86.2846,usage_user=88.359 5890000000000 +cpu,cpu=1 usage_idle=79.2839,usage_system=4.19409,usage_user=10.731 5891000000000 +cpu,cpu=2 usage_idle=22.7338,usage_system=21.4477,usage_user=9.43644 5892000000000 +cpu,cpu=3 usage_idle=95.2722,usage_system=80.4551,usage_user=58.6444 5893000000000 +cpu,cpu=4 usage_idle=87.1942,usage_system=67.6757,usage_user=74.5523 5894000000000 +cpu,cpu=0 usage_idle=86.8657,usage_system=95.7486,usage_user=65.5258 5895000000000 +cpu,cpu=1 usage_idle=14.6134,usage_system=70.1377,usage_user=44.1998 5896000000000 +cpu,cpu=2 usage_idle=97.5663,usage_system=18.9253,usage_user=47.6966 5897000000000 +cpu,cpu=3 usage_idle=90.7175,usage_system=7.00462,usage_user=19.3683 5898000000000 +cpu,cpu=4 usage_idle=10.3483,usage_system=41.747,usage_user=51.8995 5899000000000 +cpu,cpu=0 usage_idle=66.2885,usage_system=39.0419,usage_user=38.184 5900000000000 +cpu,cpu=1 usage_idle=54.6475,usage_system=18.3258,usage_user=42.3781 5901000000000 +cpu,cpu=2 usage_idle=65.3785,usage_system=41.0596,usage_user=63.8258 5902000000000 +cpu,cpu=3 usage_idle=74.8149,usage_system=36.3319,usage_user=44.2809 5903000000000 +cpu,cpu=4 usage_idle=33.4593,usage_system=23.526,usage_user=11.9567 5904000000000 +cpu,cpu=0 usage_idle=8.01164,usage_system=10.3918,usage_user=7.70522 5905000000000 +cpu,cpu=1 usage_idle=73.5374,usage_system=25.0051,usage_user=77.8429 5906000000000 +cpu,cpu=2 usage_idle=17.7372,usage_system=22.5714,usage_user=96.7682 5907000000000 +cpu,cpu=3 usage_idle=65.4339,usage_system=13.289,usage_user=3.77282 5908000000000 +cpu,cpu=4 usage_idle=84.8021,usage_system=23.6373,usage_user=45.5198 5909000000000 +cpu,cpu=0 usage_idle=36.7016,usage_system=89.9258,usage_user=84.5617 5910000000000 +cpu,cpu=1 usage_idle=74.8856,usage_system=44.5733,usage_user=2.88754 5911000000000 +cpu,cpu=2 usage_idle=17.2638,usage_system=9.95185,usage_user=43.9472 5912000000000 +cpu,cpu=3 usage_idle=81.0896,usage_system=84.7668,usage_user=80.279 5913000000000 +cpu,cpu=4 usage_idle=25.3705,usage_system=18.2261,usage_user=3.80506 5914000000000 +cpu,cpu=0 usage_idle=37.3272,usage_system=26.2378,usage_user=14.1968 5915000000000 +cpu,cpu=1 usage_idle=45.0324,usage_system=99.7752,usage_user=39.202 5916000000000 +cpu,cpu=2 usage_idle=22.8754,usage_system=17.5124,usage_user=61.7734 5917000000000 +cpu,cpu=3 usage_idle=19.6436,usage_system=82.9463,usage_user=75.0624 5918000000000 +cpu,cpu=4 usage_idle=23.4164,usage_system=67.7484,usage_user=98.6997 5919000000000 +cpu,cpu=0 usage_idle=68.9362,usage_system=4.45003,usage_user=88.6255 5920000000000 +cpu,cpu=1 usage_idle=53.4979,usage_system=79.3357,usage_user=33.1988 5921000000000 +cpu,cpu=2 usage_idle=56.3855,usage_system=96.5994,usage_user=43.1507 5922000000000 +cpu,cpu=3 usage_idle=0.332631,usage_system=77.689,usage_user=27.9175 5923000000000 +cpu,cpu=4 usage_idle=80.6116,usage_system=3.05956,usage_user=46.1436 5924000000000 +cpu,cpu=0 usage_idle=84.4167,usage_system=40.3868,usage_user=72.3813 5925000000000 +cpu,cpu=1 usage_idle=98.6135,usage_system=85.4192,usage_user=72.1565 5926000000000 +cpu,cpu=2 usage_idle=37.8155,usage_system=8.29455,usage_user=89.669 5927000000000 +cpu,cpu=3 usage_idle=99.5889,usage_system=27.9381,usage_user=72.6153 5928000000000 +cpu,cpu=4 usage_idle=74.6513,usage_system=51.3545,usage_user=40.3637 5929000000000 +cpu,cpu=0 usage_idle=73.3511,usage_system=20.2907,usage_user=44.8137 5930000000000 +cpu,cpu=1 usage_idle=61.9766,usage_system=73.7886,usage_user=24.1494 5931000000000 +cpu,cpu=2 usage_idle=95.1754,usage_system=30.1741,usage_user=20.7488 5932000000000 +cpu,cpu=3 usage_idle=38.3261,usage_system=30.5067,usage_user=98.4378 5933000000000 +cpu,cpu=4 usage_idle=66.2436,usage_system=11.1184,usage_user=1.49739 5934000000000 +cpu,cpu=0 usage_idle=12.3872,usage_system=95.5351,usage_user=41.8842 5935000000000 +cpu,cpu=1 usage_idle=84.7685,usage_system=94.1486,usage_user=27.3033 5936000000000 +cpu,cpu=2 usage_idle=56.9251,usage_system=31.9641,usage_user=35.5979 5937000000000 +cpu,cpu=3 usage_idle=46.5941,usage_system=31.5531,usage_user=63.536 5938000000000 +cpu,cpu=4 usage_idle=19.2093,usage_system=6.20444,usage_user=14.8905 5939000000000 +cpu,cpu=0 usage_idle=59.573,usage_system=79.5555,usage_user=35.1812 5940000000000 +cpu,cpu=1 usage_idle=4.38679,usage_system=41.532,usage_user=8.96985 5941000000000 +cpu,cpu=2 usage_idle=28.5362,usage_system=36.7074,usage_user=39.144 5942000000000 +cpu,cpu=3 usage_idle=49.285,usage_system=75.0335,usage_user=69.6507 5943000000000 +cpu,cpu=4 usage_idle=47.7228,usage_system=41.2771,usage_user=80.7691 5944000000000 +cpu,cpu=0 usage_idle=49.2202,usage_system=53.6643,usage_user=76.3042 5945000000000 +cpu,cpu=1 usage_idle=91.1044,usage_system=38.4329,usage_user=70.4528 5946000000000 +cpu,cpu=2 usage_idle=18.4077,usage_system=95.3579,usage_user=2.41691 5947000000000 +cpu,cpu=3 usage_idle=54.0056,usage_system=41.952,usage_user=33.97 5948000000000 +cpu,cpu=4 usage_idle=17.5416,usage_system=61.1613,usage_user=40.1744 5949000000000 +cpu,cpu=0 usage_idle=32.4322,usage_system=20.7344,usage_user=19.7299 5950000000000 +cpu,cpu=1 usage_idle=67.6134,usage_system=25.1212,usage_user=61.262 5951000000000 +cpu,cpu=2 usage_idle=76.5832,usage_system=53.6573,usage_user=97.9694 5952000000000 +cpu,cpu=3 usage_idle=15.7272,usage_system=2.94235,usage_user=73.003 5953000000000 +cpu,cpu=4 usage_idle=85.3779,usage_system=50.6652,usage_user=14.2801 5954000000000 +cpu,cpu=0 usage_idle=66.1469,usage_system=99.8854,usage_user=67.9444 5955000000000 +cpu,cpu=1 usage_idle=42.4511,usage_system=90.9898,usage_user=6.37729 5956000000000 +cpu,cpu=2 usage_idle=12.9039,usage_system=9.3975,usage_user=1.73523 5957000000000 +cpu,cpu=3 usage_idle=15.3208,usage_system=63.4031,usage_user=43.6872 5958000000000 +cpu,cpu=4 usage_idle=49.2908,usage_system=80.9448,usage_user=4.84856 5959000000000 +cpu,cpu=0 usage_idle=89.4652,usage_system=13.3769,usage_user=25.5829 5960000000000 +cpu,cpu=1 usage_idle=9.19512,usage_system=80.9903,usage_user=50.7041 5961000000000 +cpu,cpu=2 usage_idle=70.4571,usage_system=57.5735,usage_user=4.36146 5962000000000 +cpu,cpu=3 usage_idle=68.4265,usage_system=73.3007,usage_user=7.30381 5963000000000 +cpu,cpu=4 usage_idle=41.4295,usage_system=58.6785,usage_user=57.969 5964000000000 +cpu,cpu=0 usage_idle=55.7096,usage_system=24.8255,usage_user=57.8544 5965000000000 +cpu,cpu=1 usage_idle=23.654,usage_system=67.2765,usage_user=48.8442 5966000000000 +cpu,cpu=2 usage_idle=30.0313,usage_system=80.1804,usage_user=58.2417 5967000000000 +cpu,cpu=3 usage_idle=31.7665,usage_system=95.5012,usage_user=21.6448 5968000000000 +cpu,cpu=4 usage_idle=75.4538,usage_system=44.7919,usage_user=2.58953 5969000000000 +cpu,cpu=0 usage_idle=80.3023,usage_system=34.2571,usage_user=15.9664 5970000000000 +cpu,cpu=1 usage_idle=5.88526,usage_system=43.4522,usage_user=96.9567 5971000000000 +cpu,cpu=2 usage_idle=56.5894,usage_system=13.9093,usage_user=54.5302 5972000000000 +cpu,cpu=3 usage_idle=60.9508,usage_system=82.3358,usage_user=27.8309 5973000000000 +cpu,cpu=4 usage_idle=68.2547,usage_system=23.7653,usage_user=86.5094 5974000000000 +cpu,cpu=0 usage_idle=26.2236,usage_system=79.4749,usage_user=11.3349 5975000000000 +cpu,cpu=1 usage_idle=84.078,usage_system=3.12886,usage_user=78.6114 5976000000000 +cpu,cpu=2 usage_idle=32.9222,usage_system=33.1601,usage_user=58.7918 5977000000000 +cpu,cpu=3 usage_idle=91.1638,usage_system=64.9267,usage_user=54.293 5978000000000 +cpu,cpu=4 usage_idle=12.8086,usage_system=40.3804,usage_user=99.085 5979000000000 +cpu,cpu=0 usage_idle=15.3981,usage_system=20.6827,usage_user=33.3421 5980000000000 +cpu,cpu=1 usage_idle=31.3646,usage_system=26.568,usage_user=76.7943 5981000000000 +cpu,cpu=2 usage_idle=28.3213,usage_system=83.1574,usage_user=90.7037 5982000000000 +cpu,cpu=3 usage_idle=82.8515,usage_system=44.1082,usage_user=73.0395 5983000000000 +cpu,cpu=4 usage_idle=10.6824,usage_system=12.3629,usage_user=96.8048 5984000000000 +cpu,cpu=0 usage_idle=97.1919,usage_system=38.5865,usage_user=76.2796 5985000000000 +cpu,cpu=1 usage_idle=8.52678,usage_system=22.6645,usage_user=79.4085 5986000000000 +cpu,cpu=2 usage_idle=87.1382,usage_system=55.5867,usage_user=12.5687 5987000000000 +cpu,cpu=3 usage_idle=45.9301,usage_system=46.7505,usage_user=77.4953 5988000000000 +cpu,cpu=4 usage_idle=0.223091,usage_system=59.5591,usage_user=17.8757 5989000000000 +cpu,cpu=0 usage_idle=99.308,usage_system=74.9573,usage_user=38.5585 5990000000000 +cpu,cpu=1 usage_idle=32.6501,usage_system=6.32182,usage_user=65.1265 5991000000000 +cpu,cpu=2 usage_idle=9.44446,usage_system=34.6431,usage_user=48.2838 5992000000000 +cpu,cpu=3 usage_idle=0.148124,usage_system=17.4947,usage_user=92.392 5993000000000 +cpu,cpu=4 usage_idle=73.1876,usage_system=28.1771,usage_user=4.75492 5994000000000 +cpu,cpu=0 usage_idle=69.9924,usage_system=25.369,usage_user=43.3414 5995000000000 +cpu,cpu=1 usage_idle=46.272,usage_system=33.8958,usage_user=66.006 5996000000000 +cpu,cpu=2 usage_idle=25.6806,usage_system=21.034,usage_user=21.5927 5997000000000 +cpu,cpu=3 usage_idle=38.2492,usage_system=66.9641,usage_user=68.3432 5998000000000 +cpu,cpu=4 usage_idle=15.7445,usage_system=67.1871,usage_user=27.9023 5999000000000 +cpu,cpu=0 usage_idle=33.6203,usage_system=66.4952,usage_user=2.85957 6000000000000 +cpu,cpu=1 usage_idle=72.1787,usage_system=99.1453,usage_user=9.1814 6001000000000 +cpu,cpu=2 usage_idle=37.3052,usage_system=8.58978,usage_user=43.8245 6002000000000 +cpu,cpu=3 usage_idle=85.589,usage_system=8.7379,usage_user=61.3192 6003000000000 +cpu,cpu=4 usage_idle=77.9811,usage_system=81.9255,usage_user=89.4963 6004000000000 +cpu,cpu=0 usage_idle=82.736,usage_system=51.9179,usage_user=14.8653 6005000000000 +cpu,cpu=1 usage_idle=26.0774,usage_system=98.19,usage_user=48.761 6006000000000 +cpu,cpu=2 usage_idle=92.0834,usage_system=23.8705,usage_user=69.795 6007000000000 +cpu,cpu=3 usage_idle=13.676,usage_system=62.1197,usage_user=36.7591 6008000000000 +cpu,cpu=4 usage_idle=82.0192,usage_system=77.8642,usage_user=3.9462 6009000000000 +cpu,cpu=0 usage_idle=9.92153,usage_system=11.4845,usage_user=70.4414 6010000000000 +cpu,cpu=1 usage_idle=12.7811,usage_system=83.6632,usage_user=69.5867 6011000000000 +cpu,cpu=2 usage_idle=21.9625,usage_system=20.9684,usage_user=78.1765 6012000000000 +cpu,cpu=3 usage_idle=65.787,usage_system=6.55739,usage_user=86.9144 6013000000000 +cpu,cpu=4 usage_idle=27.1062,usage_system=84.5385,usage_user=68.8399 6014000000000 +cpu,cpu=0 usage_idle=16.6025,usage_system=67.2744,usage_user=20.7578 6015000000000 +cpu,cpu=1 usage_idle=31.4678,usage_system=93.3518,usage_user=18.9478 6016000000000 +cpu,cpu=2 usage_idle=80.2288,usage_system=85.4352,usage_user=42.8183 6017000000000 +cpu,cpu=3 usage_idle=50.0238,usage_system=99.1112,usage_user=4.93803 6018000000000 +cpu,cpu=4 usage_idle=86.7828,usage_system=81.1304,usage_user=82.8023 6019000000000 +cpu,cpu=0 usage_idle=90.729,usage_system=91.052,usage_user=94.2868 6020000000000 +cpu,cpu=1 usage_idle=61.1704,usage_system=3.83306,usage_user=77.95 6021000000000 +cpu,cpu=2 usage_idle=30.7571,usage_system=25.7956,usage_user=98.9184 6022000000000 +cpu,cpu=3 usage_idle=8.9336,usage_system=91.5826,usage_user=5.47577 6023000000000 +cpu,cpu=4 usage_idle=95.848,usage_system=18.6888,usage_user=90.0142 6024000000000 +cpu,cpu=0 usage_idle=64.6879,usage_system=35.2913,usage_user=57.2886 6025000000000 +cpu,cpu=1 usage_idle=85.4457,usage_system=66.7591,usage_user=50.6405 6026000000000 +cpu,cpu=2 usage_idle=4.39346,usage_system=46.9879,usage_user=36.0757 6027000000000 +cpu,cpu=3 usage_idle=47.2118,usage_system=97.0117,usage_user=35.1869 6028000000000 +cpu,cpu=4 usage_idle=52.1498,usage_system=83.7945,usage_user=16.3173 6029000000000 +cpu,cpu=0 usage_idle=34.9521,usage_system=74.5235,usage_user=7.36924 6030000000000 +cpu,cpu=1 usage_idle=29.2388,usage_system=35.694,usage_user=11.2023 6031000000000 +cpu,cpu=2 usage_idle=7.18883,usage_system=66.4511,usage_user=36.9979 6032000000000 +cpu,cpu=3 usage_idle=6.10721,usage_system=75.3847,usage_user=28.5805 6033000000000 +cpu,cpu=4 usage_idle=11.583,usage_system=71.2327,usage_user=47.2693 6034000000000 +cpu,cpu=0 usage_idle=1.5972,usage_system=35.9205,usage_user=82.5606 6035000000000 +cpu,cpu=1 usage_idle=58.8858,usage_system=21.3662,usage_user=49.3196 6036000000000 +cpu,cpu=2 usage_idle=9.52633,usage_system=25.7597,usage_user=96.3075 6037000000000 +cpu,cpu=3 usage_idle=45.602,usage_system=72.9714,usage_user=93.3191 6038000000000 +cpu,cpu=4 usage_idle=80.7889,usage_system=25.1212,usage_user=77.1136 6039000000000 +cpu,cpu=0 usage_idle=97.1062,usage_system=60.0733,usage_user=51.6372 6040000000000 +cpu,cpu=1 usage_idle=4.47539,usage_system=89.3121,usage_user=87.3311 6041000000000 +cpu,cpu=2 usage_idle=15.6777,usage_system=96.501,usage_user=53.7822 6042000000000 +cpu,cpu=3 usage_idle=52.6756,usage_system=2.60817,usage_user=29.1669 6043000000000 +cpu,cpu=4 usage_idle=81.256,usage_system=14.1912,usage_user=0.399552 6044000000000 +cpu,cpu=0 usage_idle=28.5253,usage_system=15.7884,usage_user=36.3201 6045000000000 +cpu,cpu=1 usage_idle=11.0858,usage_system=74.6742,usage_user=57.6863 6046000000000 +cpu,cpu=2 usage_idle=60.4054,usage_system=84.2005,usage_user=83.4459 6047000000000 +cpu,cpu=3 usage_idle=56.7129,usage_system=29.8025,usage_user=56.4173 6048000000000 +cpu,cpu=4 usage_idle=50.0321,usage_system=10.5914,usage_user=81.5386 6049000000000 +cpu,cpu=0 usage_idle=27.1457,usage_system=7.69753,usage_user=41.6118 6050000000000 +cpu,cpu=1 usage_idle=78.7829,usage_system=12.1729,usage_user=30.924 6051000000000 +cpu,cpu=2 usage_idle=66.114,usage_system=27.8506,usage_user=27.4249 6052000000000 +cpu,cpu=3 usage_idle=19.8962,usage_system=80.5262,usage_user=30.0331 6053000000000 +cpu,cpu=4 usage_idle=49.0631,usage_system=61.7822,usage_user=44.2243 6054000000000 +cpu,cpu=0 usage_idle=49.4627,usage_system=90.3074,usage_user=60.0126 6055000000000 +cpu,cpu=1 usage_idle=85.7827,usage_system=1.39323,usage_user=34.6868 6056000000000 +cpu,cpu=2 usage_idle=43.469,usage_system=61.7987,usage_user=18.8873 6057000000000 +cpu,cpu=3 usage_idle=26.9149,usage_system=18.5116,usage_user=48.6899 6058000000000 +cpu,cpu=4 usage_idle=83.3323,usage_system=68.5436,usage_user=59.2812 6059000000000 +cpu,cpu=0 usage_idle=64.8708,usage_system=95.6893,usage_user=66.9788 6060000000000 +cpu,cpu=1 usage_idle=6.48269,usage_system=74.4722,usage_user=79.1517 6061000000000 +cpu,cpu=2 usage_idle=37.4067,usage_system=40.5862,usage_user=7.00229 6062000000000 +cpu,cpu=3 usage_idle=64.8316,usage_system=60.4824,usage_user=87.5285 6063000000000 +cpu,cpu=4 usage_idle=94.8647,usage_system=9.5455,usage_user=49.3106 6064000000000 +cpu,cpu=0 usage_idle=39.089,usage_system=59.0082,usage_user=39.618 6065000000000 +cpu,cpu=1 usage_idle=99.1016,usage_system=44.7909,usage_user=41.0113 6066000000000 +cpu,cpu=2 usage_idle=33.7884,usage_system=88.2599,usage_user=2.80996 6067000000000 +cpu,cpu=3 usage_idle=52.6757,usage_system=15.1748,usage_user=21.3215 6068000000000 +cpu,cpu=4 usage_idle=1.36559,usage_system=98.5071,usage_user=89.8652 6069000000000 +cpu,cpu=0 usage_idle=60.6468,usage_system=63.3779,usage_user=85.5545 6070000000000 +cpu,cpu=1 usage_idle=27.6256,usage_system=69.8606,usage_user=60.0267 6071000000000 +cpu,cpu=2 usage_idle=6.77726,usage_system=7.2673,usage_user=0.612891 6072000000000 +cpu,cpu=3 usage_idle=13.7796,usage_system=72.0989,usage_user=61.0953 6073000000000 +cpu,cpu=4 usage_idle=1.30801,usage_system=66.9636,usage_user=70.6408 6074000000000 +cpu,cpu=0 usage_idle=50.6186,usage_system=6.0526,usage_user=29.6489 6075000000000 +cpu,cpu=1 usage_idle=90.2367,usage_system=5.15419,usage_user=74.4398 6076000000000 +cpu,cpu=2 usage_idle=31.248,usage_system=38.9426,usage_user=62.6997 6077000000000 +cpu,cpu=3 usage_idle=34.0579,usage_system=91.6183,usage_user=77.8745 6078000000000 +cpu,cpu=4 usage_idle=55.3795,usage_system=92.9839,usage_user=76.3816 6079000000000 +cpu,cpu=0 usage_idle=45.2447,usage_system=53.6307,usage_user=39.7596 6080000000000 +cpu,cpu=1 usage_idle=30.7992,usage_system=81.2563,usage_user=9.62019 6081000000000 +cpu,cpu=2 usage_idle=90.8259,usage_system=88.0336,usage_user=16.8875 6082000000000 +cpu,cpu=3 usage_idle=91.4388,usage_system=1.81313,usage_user=88.9864 6083000000000 +cpu,cpu=4 usage_idle=52.5341,usage_system=3.12114,usage_user=55.95 6084000000000 +cpu,cpu=0 usage_idle=23.1748,usage_system=53.7398,usage_user=62.0026 6085000000000 +cpu,cpu=1 usage_idle=52.8238,usage_system=43.9765,usage_user=67.1568 6086000000000 +cpu,cpu=2 usage_idle=27.2636,usage_system=75.2244,usage_user=6.09942 6087000000000 +cpu,cpu=3 usage_idle=89.9633,usage_system=9.28235,usage_user=97.7177 6088000000000 +cpu,cpu=4 usage_idle=67.8378,usage_system=64.6618,usage_user=90.7017 6089000000000 +cpu,cpu=0 usage_idle=44.2194,usage_system=9.90648,usage_user=44.3324 6090000000000 +cpu,cpu=1 usage_idle=83.979,usage_system=40.7057,usage_user=25.5887 6091000000000 +cpu,cpu=2 usage_idle=93.5992,usage_system=31.5316,usage_user=13.6223 6092000000000 +cpu,cpu=3 usage_idle=10.4867,usage_system=22.9703,usage_user=15.4354 6093000000000 +cpu,cpu=4 usage_idle=99.4731,usage_system=75.5044,usage_user=18.5566 6094000000000 +cpu,cpu=0 usage_idle=55.4231,usage_system=98.6793,usage_user=72.2963 6095000000000 +cpu,cpu=1 usage_idle=17.4257,usage_system=51.503,usage_user=16.2728 6096000000000 +cpu,cpu=2 usage_idle=84.5826,usage_system=78.7666,usage_user=91.4972 6097000000000 +cpu,cpu=3 usage_idle=90.682,usage_system=68.7299,usage_user=0.779556 6098000000000 +cpu,cpu=4 usage_idle=88.3997,usage_system=36.5677,usage_user=65.4414 6099000000000 +cpu,cpu=0 usage_idle=79.1014,usage_system=80.7871,usage_user=75.3479 6100000000000 +cpu,cpu=1 usage_idle=23.4338,usage_system=64.7661,usage_user=16.0535 6101000000000 +cpu,cpu=2 usage_idle=49.0225,usage_system=58.3653,usage_user=47.5851 6102000000000 +cpu,cpu=3 usage_idle=62.6448,usage_system=68.852,usage_user=70.5554 6103000000000 +cpu,cpu=4 usage_idle=78.0802,usage_system=68.325,usage_user=46.0598 6104000000000 +cpu,cpu=0 usage_idle=96.6368,usage_system=23.7482,usage_user=44.7391 6105000000000 +cpu,cpu=1 usage_idle=68.9331,usage_system=41.1739,usage_user=96.2421 6106000000000 +cpu,cpu=2 usage_idle=85.2059,usage_system=25.7565,usage_user=75.0087 6107000000000 +cpu,cpu=3 usage_idle=76.7031,usage_system=16.4384,usage_user=43.7386 6108000000000 +cpu,cpu=4 usage_idle=77.4827,usage_system=4.83815,usage_user=80.3063 6109000000000 +cpu,cpu=0 usage_idle=42.9241,usage_system=83.9395,usage_user=61.0934 6110000000000 +cpu,cpu=1 usage_idle=18.2719,usage_system=7.37334,usage_user=25.8595 6111000000000 +cpu,cpu=2 usage_idle=34.3254,usage_system=56.3959,usage_user=84.2248 6112000000000 +cpu,cpu=3 usage_idle=81.9105,usage_system=19.0407,usage_user=53.0768 6113000000000 +cpu,cpu=4 usage_idle=52.4659,usage_system=97.1209,usage_user=21.4019 6114000000000 +cpu,cpu=0 usage_idle=98.5258,usage_system=93.7577,usage_user=45.15 6115000000000 +cpu,cpu=1 usage_idle=43.2649,usage_system=62.6909,usage_user=86.3239 6116000000000 +cpu,cpu=2 usage_idle=39.507,usage_system=47.8968,usage_user=12.0804 6117000000000 +cpu,cpu=3 usage_idle=14.5157,usage_system=24.5999,usage_user=28.5188 6118000000000 +cpu,cpu=4 usage_idle=58.2543,usage_system=2.08262,usage_user=33.3569 6119000000000 +cpu,cpu=0 usage_idle=38.5606,usage_system=45.0067,usage_user=17.2965 6120000000000 +cpu,cpu=1 usage_idle=99.6541,usage_system=63.2786,usage_user=24.6698 6121000000000 +cpu,cpu=2 usage_idle=25.5136,usage_system=97.604,usage_user=81.0657 6122000000000 +cpu,cpu=3 usage_idle=9.73847,usage_system=79.5146,usage_user=0.106348 6123000000000 +cpu,cpu=4 usage_idle=62.8153,usage_system=31.9805,usage_user=97.2273 6124000000000 +cpu,cpu=0 usage_idle=84.2171,usage_system=30.5063,usage_user=90.985 6125000000000 +cpu,cpu=1 usage_idle=29.3672,usage_system=73.7711,usage_user=53.6759 6126000000000 +cpu,cpu=2 usage_idle=15.6911,usage_system=13.2781,usage_user=1.57266 6127000000000 +cpu,cpu=3 usage_idle=27.7714,usage_system=27.7938,usage_user=26.1726 6128000000000 +cpu,cpu=4 usage_idle=56.2902,usage_system=86.0481,usage_user=28.2552 6129000000000 +cpu,cpu=0 usage_idle=89.6472,usage_system=24.6088,usage_user=73.2619 6130000000000 +cpu,cpu=1 usage_idle=6.94363,usage_system=24.2629,usage_user=36.5405 6131000000000 +cpu,cpu=2 usage_idle=31.6134,usage_system=49.7765,usage_user=34.1445 6132000000000 +cpu,cpu=3 usage_idle=12.6791,usage_system=59.5149,usage_user=13.6591 6133000000000 +cpu,cpu=4 usage_idle=12.7855,usage_system=22.3302,usage_user=45.6396 6134000000000 +cpu,cpu=0 usage_idle=10.0127,usage_system=6.54736,usage_user=76.1459 6135000000000 +cpu,cpu=1 usage_idle=0.997738,usage_system=35.9145,usage_user=49.917 6136000000000 +cpu,cpu=2 usage_idle=54.6736,usage_system=51.6056,usage_user=63.1951 6137000000000 +cpu,cpu=3 usage_idle=56.2463,usage_system=79.377,usage_user=90.9889 6138000000000 +cpu,cpu=4 usage_idle=82.4189,usage_system=35.6672,usage_user=77.0371 6139000000000 +cpu,cpu=0 usage_idle=10.6741,usage_system=25.3144,usage_user=1.64586 6140000000000 +cpu,cpu=1 usage_idle=83.936,usage_system=32.258,usage_user=25.9087 6141000000000 +cpu,cpu=2 usage_idle=20.4765,usage_system=63.8715,usage_user=75.6852 6142000000000 +cpu,cpu=3 usage_idle=54.621,usage_system=76.5506,usage_user=35.2001 6143000000000 +cpu,cpu=4 usage_idle=68.2801,usage_system=89.3361,usage_user=57.5304 6144000000000 +cpu,cpu=0 usage_idle=13.9197,usage_system=99.3488,usage_user=64.0777 6145000000000 +cpu,cpu=1 usage_idle=90.0656,usage_system=0.346528,usage_user=99.9922 6146000000000 +cpu,cpu=2 usage_idle=39.9826,usage_system=55.0201,usage_user=51.5978 6147000000000 +cpu,cpu=3 usage_idle=3.17771,usage_system=11.2664,usage_user=30.9748 6148000000000 +cpu,cpu=4 usage_idle=94.1666,usage_system=93.6853,usage_user=66.6421 6149000000000 +cpu,cpu=0 usage_idle=71.2037,usage_system=4.35934,usage_user=91.9564 6150000000000 +cpu,cpu=1 usage_idle=72.8496,usage_system=88.2953,usage_user=24.2144 6151000000000 +cpu,cpu=2 usage_idle=98.7583,usage_system=8.77179,usage_user=88.0859 6152000000000 +cpu,cpu=3 usage_idle=74.4435,usage_system=63.3928,usage_user=64.6365 6153000000000 +cpu,cpu=4 usage_idle=9.64362,usage_system=31.673,usage_user=53.9725 6154000000000 +cpu,cpu=0 usage_idle=67.174,usage_system=45.5927,usage_user=53.3213 6155000000000 +cpu,cpu=1 usage_idle=31.2517,usage_system=35.6583,usage_user=53.6678 6156000000000 +cpu,cpu=2 usage_idle=31.2439,usage_system=75.6409,usage_user=8.68798 6157000000000 +cpu,cpu=3 usage_idle=82.8418,usage_system=78.8186,usage_user=19.9544 6158000000000 +cpu,cpu=4 usage_idle=13.8166,usage_system=72.9853,usage_user=13.6396 6159000000000 +cpu,cpu=0 usage_idle=80.4587,usage_system=44.189,usage_user=17.999 6160000000000 +cpu,cpu=1 usage_idle=72.4151,usage_system=17.0386,usage_user=6.29429 6161000000000 +cpu,cpu=2 usage_idle=96.6295,usage_system=15.7969,usage_user=15.0661 6162000000000 +cpu,cpu=3 usage_idle=84.7154,usage_system=90.2403,usage_user=78.4589 6163000000000 +cpu,cpu=4 usage_idle=49.3519,usage_system=99.884,usage_user=10.1319 6164000000000 +cpu,cpu=0 usage_idle=3.32444,usage_system=67.0579,usage_user=55.7246 6165000000000 +cpu,cpu=1 usage_idle=56.6458,usage_system=98.3096,usage_user=91.3829 6166000000000 +cpu,cpu=2 usage_idle=10.3136,usage_system=29.5536,usage_user=67.0238 6167000000000 +cpu,cpu=3 usage_idle=19.0016,usage_system=12.3954,usage_user=45.8424 6168000000000 +cpu,cpu=4 usage_idle=38.956,usage_system=26.212,usage_user=18.8276 6169000000000 +cpu,cpu=0 usage_idle=52.5956,usage_system=6.67061,usage_user=63.0166 6170000000000 +cpu,cpu=1 usage_idle=70.5946,usage_system=79.0857,usage_user=80.0552 6171000000000 +cpu,cpu=2 usage_idle=76.8889,usage_system=75.7152,usage_user=95.852 6172000000000 +cpu,cpu=3 usage_idle=91.955,usage_system=60.4306,usage_user=86.0924 6173000000000 +cpu,cpu=4 usage_idle=70.4139,usage_system=9.78254,usage_user=85.9763 6174000000000 +cpu,cpu=0 usage_idle=80.5458,usage_system=13.107,usage_user=53.0343 6175000000000 +cpu,cpu=1 usage_idle=36.2703,usage_system=69.7527,usage_user=51.3439 6176000000000 +cpu,cpu=2 usage_idle=27.6532,usage_system=80.0663,usage_user=80.8975 6177000000000 +cpu,cpu=3 usage_idle=94.677,usage_system=99.0679,usage_user=93.2929 6178000000000 +cpu,cpu=4 usage_idle=40.5194,usage_system=38.0239,usage_user=19.5048 6179000000000 +cpu,cpu=0 usage_idle=59.347,usage_system=90.6195,usage_user=26.1754 6180000000000 +cpu,cpu=1 usage_idle=22.3636,usage_system=61.2141,usage_user=5.26113 6181000000000 +cpu,cpu=2 usage_idle=2.4188,usage_system=38.103,usage_user=80.9763 6182000000000 +cpu,cpu=3 usage_idle=98.2708,usage_system=30.058,usage_user=41.407 6183000000000 +cpu,cpu=4 usage_idle=84.3632,usage_system=0.471855,usage_user=51.1895 6184000000000 +cpu,cpu=0 usage_idle=70.3395,usage_system=81.0176,usage_user=64.2965 6185000000000 +cpu,cpu=1 usage_idle=23.3738,usage_system=17.288,usage_user=34.0492 6186000000000 +cpu,cpu=2 usage_idle=74.7177,usage_system=44.9412,usage_user=14.1156 6187000000000 +cpu,cpu=3 usage_idle=55.6153,usage_system=39.6182,usage_user=13.1835 6188000000000 +cpu,cpu=4 usage_idle=48.9081,usage_system=80.1376,usage_user=51.2074 6189000000000 +cpu,cpu=0 usage_idle=68.413,usage_system=39.4846,usage_user=41.8269 6190000000000 +cpu,cpu=1 usage_idle=94.5884,usage_system=61.8482,usage_user=3.041 6191000000000 +cpu,cpu=2 usage_idle=99.8495,usage_system=64.267,usage_user=41.144 6192000000000 +cpu,cpu=3 usage_idle=80.8259,usage_system=62.5378,usage_user=71.202 6193000000000 +cpu,cpu=4 usage_idle=22.2328,usage_system=46.901,usage_user=71.6738 6194000000000 +cpu,cpu=0 usage_idle=73.4224,usage_system=17.2406,usage_user=52.6914 6195000000000 +cpu,cpu=1 usage_idle=37.7188,usage_system=40.6144,usage_user=69.9794 6196000000000 +cpu,cpu=2 usage_idle=71.7681,usage_system=15.3321,usage_user=14.9206 6197000000000 +cpu,cpu=3 usage_idle=85.8836,usage_system=70.9474,usage_user=54.5388 6198000000000 +cpu,cpu=4 usage_idle=99.0671,usage_system=19.8555,usage_user=34.6764 6199000000000 +cpu,cpu=0 usage_idle=50.2745,usage_system=88.2685,usage_user=74.161 6200000000000 +cpu,cpu=1 usage_idle=92.1014,usage_system=82.8569,usage_user=36.0092 6201000000000 +cpu,cpu=2 usage_idle=95.1424,usage_system=82.7064,usage_user=0.276177 6202000000000 +cpu,cpu=3 usage_idle=36.2864,usage_system=63.5323,usage_user=62.814 6203000000000 +cpu,cpu=4 usage_idle=7.48836,usage_system=85.7651,usage_user=9.71505 6204000000000 +cpu,cpu=0 usage_idle=79.1622,usage_system=59.1875,usage_user=26.9556 6205000000000 +cpu,cpu=1 usage_idle=31.8536,usage_system=96.9063,usage_user=67.57 6206000000000 +cpu,cpu=2 usage_idle=1.83301,usage_system=68.6744,usage_user=82.9022 6207000000000 +cpu,cpu=3 usage_idle=16.7536,usage_system=54.558,usage_user=53.8496 6208000000000 +cpu,cpu=4 usage_idle=71.2924,usage_system=53.6251,usage_user=73.7051 6209000000000 +cpu,cpu=0 usage_idle=5.96878,usage_system=3.89964,usage_user=61.9736 6210000000000 +cpu,cpu=1 usage_idle=80.1297,usage_system=96.001,usage_user=44.8305 6211000000000 +cpu,cpu=2 usage_idle=16.1389,usage_system=91.1434,usage_user=27.5369 6212000000000 +cpu,cpu=3 usage_idle=16.4151,usage_system=27.4298,usage_user=91.0692 6213000000000 +cpu,cpu=4 usage_idle=79.2291,usage_system=34.9182,usage_user=76.8343 6214000000000 +cpu,cpu=0 usage_idle=88.9442,usage_system=14.0804,usage_user=36.0217 6215000000000 +cpu,cpu=1 usage_idle=15.8998,usage_system=45.934,usage_user=32.928 6216000000000 +cpu,cpu=2 usage_idle=83.4698,usage_system=47.767,usage_user=1.60241 6217000000000 +cpu,cpu=3 usage_idle=66.372,usage_system=64.5206,usage_user=56.1604 6218000000000 +cpu,cpu=4 usage_idle=20.2216,usage_system=35.813,usage_user=9.78555 6219000000000 +cpu,cpu=0 usage_idle=93.9267,usage_system=41.7818,usage_user=13.6852 6220000000000 +cpu,cpu=1 usage_idle=55.9003,usage_system=21.9115,usage_user=9.68624 6221000000000 +cpu,cpu=2 usage_idle=0.730831,usage_system=38.0504,usage_user=0.829682 6222000000000 +cpu,cpu=3 usage_idle=28.2677,usage_system=54.4655,usage_user=28.2595 6223000000000 +cpu,cpu=4 usage_idle=19.3369,usage_system=33.6946,usage_user=63.1777 6224000000000 +cpu,cpu=0 usage_idle=96.1712,usage_system=22.6388,usage_user=77.2581 6225000000000 +cpu,cpu=1 usage_idle=32.1929,usage_system=38.5386,usage_user=23.1921 6226000000000 +cpu,cpu=2 usage_idle=65.121,usage_system=22.0084,usage_user=70.959 6227000000000 +cpu,cpu=3 usage_idle=66.7234,usage_system=88.3804,usage_user=35.4796 6228000000000 +cpu,cpu=4 usage_idle=22.8838,usage_system=8.60195,usage_user=71.2927 6229000000000 +cpu,cpu=0 usage_idle=32.6694,usage_system=2.52865,usage_user=13.0745 6230000000000 +cpu,cpu=1 usage_idle=46.3545,usage_system=58.429,usage_user=34.986 6231000000000 +cpu,cpu=2 usage_idle=56.0408,usage_system=59.1598,usage_user=73.0364 6232000000000 +cpu,cpu=3 usage_idle=56.8705,usage_system=87.4276,usage_user=27.5019 6233000000000 +cpu,cpu=4 usage_idle=85.13,usage_system=6.76448,usage_user=61.1966 6234000000000 +cpu,cpu=0 usage_idle=48.3077,usage_system=2.93568,usage_user=83.8353 6235000000000 +cpu,cpu=1 usage_idle=25.5658,usage_system=35.1286,usage_user=22.3739 6236000000000 +cpu,cpu=2 usage_idle=48.7578,usage_system=0.2496,usage_user=44.3822 6237000000000 +cpu,cpu=3 usage_idle=19.7169,usage_system=66.973,usage_user=32.7626 6238000000000 +cpu,cpu=4 usage_idle=55.1965,usage_system=89.8568,usage_user=41.3646 6239000000000 +cpu,cpu=0 usage_idle=26.4892,usage_system=22.5261,usage_user=43.8932 6240000000000 +cpu,cpu=1 usage_idle=39.5637,usage_system=68.8807,usage_user=2.3222 6241000000000 +cpu,cpu=2 usage_idle=74.5496,usage_system=24.9215,usage_user=61.482 6242000000000 +cpu,cpu=3 usage_idle=47.5861,usage_system=81.7919,usage_user=48.9096 6243000000000 +cpu,cpu=4 usage_idle=75.088,usage_system=66.9219,usage_user=55.674 6244000000000 +cpu,cpu=0 usage_idle=36.2846,usage_system=15.2296,usage_user=58.6097 6245000000000 +cpu,cpu=1 usage_idle=20.1199,usage_system=40.7954,usage_user=93.7384 6246000000000 +cpu,cpu=2 usage_idle=42.4938,usage_system=89.5532,usage_user=93.988 6247000000000 +cpu,cpu=3 usage_idle=86.876,usage_system=9.27014,usage_user=60.9609 6248000000000 +cpu,cpu=4 usage_idle=19.6386,usage_system=64.4667,usage_user=50.8177 6249000000000 +cpu,cpu=0 usage_idle=61.0032,usage_system=90.9559,usage_user=73.3439 6250000000000 +cpu,cpu=1 usage_idle=4.89641,usage_system=30.5195,usage_user=42.2245 6251000000000 +cpu,cpu=2 usage_idle=7.21861,usage_system=5.06916,usage_user=67.146 6252000000000 +cpu,cpu=3 usage_idle=68.7006,usage_system=52.6552,usage_user=48.9379 6253000000000 +cpu,cpu=4 usage_idle=17.6102,usage_system=27.7432,usage_user=15.8598 6254000000000 +cpu,cpu=0 usage_idle=73.2842,usage_system=64.0278,usage_user=31.0895 6255000000000 +cpu,cpu=1 usage_idle=31.894,usage_system=84.1476,usage_user=71.8849 6256000000000 +cpu,cpu=2 usage_idle=25.6323,usage_system=26.6414,usage_user=61.4381 6257000000000 +cpu,cpu=3 usage_idle=19.6203,usage_system=13.5174,usage_user=70.7082 6258000000000 +cpu,cpu=4 usage_idle=80.5812,usage_system=33.156,usage_user=35.1749 6259000000000 +cpu,cpu=0 usage_idle=31.3989,usage_system=94.1592,usage_user=26.1308 6260000000000 +cpu,cpu=1 usage_idle=4.74276,usage_system=99.0556,usage_user=56.6503 6261000000000 +cpu,cpu=2 usage_idle=46.9673,usage_system=6.27425,usage_user=61.7195 6262000000000 +cpu,cpu=3 usage_idle=14.1133,usage_system=74.9749,usage_user=14.3747 6263000000000 +cpu,cpu=4 usage_idle=63.0512,usage_system=92.5851,usage_user=42.1179 6264000000000 +cpu,cpu=0 usage_idle=78.9111,usage_system=65.8693,usage_user=6.14563 6265000000000 +cpu,cpu=1 usage_idle=10.0005,usage_system=97.7632,usage_user=90.2933 6266000000000 +cpu,cpu=2 usage_idle=81.8854,usage_system=23.3956,usage_user=16.9347 6267000000000 +cpu,cpu=3 usage_idle=43.3235,usage_system=43.0158,usage_user=30.4521 6268000000000 +cpu,cpu=4 usage_idle=14.0317,usage_system=23.597,usage_user=63.6081 6269000000000 +cpu,cpu=0 usage_idle=49.2066,usage_system=54.9959,usage_user=57.7673 6270000000000 +cpu,cpu=1 usage_idle=75.3374,usage_system=59.7387,usage_user=56.823 6271000000000 +cpu,cpu=2 usage_idle=31.9877,usage_system=6.70597,usage_user=63.0972 6272000000000 +cpu,cpu=3 usage_idle=93.7071,usage_system=20.8193,usage_user=38.0721 6273000000000 +cpu,cpu=4 usage_idle=8.08179,usage_system=83.8705,usage_user=30.6572 6274000000000 +cpu,cpu=0 usage_idle=50.1997,usage_system=62.7816,usage_user=96.5265 6275000000000 +cpu,cpu=1 usage_idle=56.3453,usage_system=72.7821,usage_user=94.2897 6276000000000 +cpu,cpu=2 usage_idle=46.6386,usage_system=54.6674,usage_user=17.6853 6277000000000 +cpu,cpu=3 usage_idle=63.5732,usage_system=97.9909,usage_user=60.7011 6278000000000 +cpu,cpu=4 usage_idle=94.0253,usage_system=12.0226,usage_user=84.2981 6279000000000 +cpu,cpu=0 usage_idle=57.6334,usage_system=61.2292,usage_user=39.294 6280000000000 +cpu,cpu=1 usage_idle=15.4008,usage_system=36.5665,usage_user=99.0326 6281000000000 +cpu,cpu=2 usage_idle=72.2237,usage_system=68.5542,usage_user=5.73861 6282000000000 +cpu,cpu=3 usage_idle=35.321,usage_system=62.2613,usage_user=26.5579 6283000000000 +cpu,cpu=4 usage_idle=73.3931,usage_system=70.3431,usage_user=10.4284 6284000000000 +cpu,cpu=0 usage_idle=4.05022,usage_system=20.5428,usage_user=73.2099 6285000000000 +cpu,cpu=1 usage_idle=0.576675,usage_system=76.8881,usage_user=45.992 6286000000000 +cpu,cpu=2 usage_idle=94.8664,usage_system=23.5267,usage_user=0.659458 6287000000000 +cpu,cpu=3 usage_idle=12.5516,usage_system=87.0999,usage_user=98.6504 6288000000000 +cpu,cpu=4 usage_idle=73.2527,usage_system=81.1252,usage_user=10.6729 6289000000000 +cpu,cpu=0 usage_idle=57.5507,usage_system=38.7586,usage_user=71.9021 6290000000000 +cpu,cpu=1 usage_idle=96.8447,usage_system=54.1594,usage_user=8.46865 6291000000000 +cpu,cpu=2 usage_idle=95.8774,usage_system=26.3831,usage_user=77.0229 6292000000000 +cpu,cpu=3 usage_idle=1.61596,usage_system=61.7041,usage_user=39.2842 6293000000000 +cpu,cpu=4 usage_idle=28.1739,usage_system=35.0971,usage_user=9.62732 6294000000000 +cpu,cpu=0 usage_idle=38.6022,usage_system=39.1473,usage_user=30.1701 6295000000000 +cpu,cpu=1 usage_idle=11.8122,usage_system=39.724,usage_user=7.0582 6296000000000 +cpu,cpu=2 usage_idle=57.8042,usage_system=34.5904,usage_user=30.5849 6297000000000 +cpu,cpu=3 usage_idle=58.4637,usage_system=47.142,usage_user=17.6848 6298000000000 +cpu,cpu=4 usage_idle=57.114,usage_system=20.3947,usage_user=98.81 6299000000000 +cpu,cpu=0 usage_idle=67.787,usage_system=77.9454,usage_user=37.5686 6300000000000 +cpu,cpu=1 usage_idle=39.6891,usage_system=74.7902,usage_user=91.728 6301000000000 +cpu,cpu=2 usage_idle=48.1577,usage_system=70.6675,usage_user=18.1111 6302000000000 +cpu,cpu=3 usage_idle=25.1806,usage_system=72.2835,usage_user=79.8151 6303000000000 +cpu,cpu=4 usage_idle=64.4648,usage_system=0.457321,usage_user=14.9122 6304000000000 +cpu,cpu=0 usage_idle=74.0921,usage_system=39.0596,usage_user=54.0596 6305000000000 +cpu,cpu=1 usage_idle=4.26219,usage_system=50.8717,usage_user=93.7836 6306000000000 +cpu,cpu=2 usage_idle=11.3204,usage_system=8.67595,usage_user=28.374 6307000000000 +cpu,cpu=3 usage_idle=41.9053,usage_system=67.1396,usage_user=75.516 6308000000000 +cpu,cpu=4 usage_idle=59.59,usage_system=24.2536,usage_user=95.9107 6309000000000 +cpu,cpu=0 usage_idle=58.4,usage_system=92.0406,usage_user=73.8561 6310000000000 +cpu,cpu=1 usage_idle=95.9685,usage_system=31.7296,usage_user=48.6463 6311000000000 +cpu,cpu=2 usage_idle=87.6965,usage_system=79.8873,usage_user=19.3138 6312000000000 +cpu,cpu=3 usage_idle=5.80757,usage_system=5.06792,usage_user=91.5973 6313000000000 +cpu,cpu=4 usage_idle=85.6227,usage_system=69.5327,usage_user=92.0546 6314000000000 +cpu,cpu=0 usage_idle=0.534931,usage_system=43.6248,usage_user=31.1141 6315000000000 +cpu,cpu=1 usage_idle=54.5945,usage_system=47.887,usage_user=81.9859 6316000000000 +cpu,cpu=2 usage_idle=48.3781,usage_system=59.2074,usage_user=90.6618 6317000000000 +cpu,cpu=3 usage_idle=76.752,usage_system=1.1126,usage_user=57.8014 6318000000000 +cpu,cpu=4 usage_idle=52.268,usage_system=60.7026,usage_user=82.0551 6319000000000 +cpu,cpu=0 usage_idle=48.1787,usage_system=19.1026,usage_user=74.0956 6320000000000 +cpu,cpu=1 usage_idle=22.0348,usage_system=15.0711,usage_user=5.82527 6321000000000 +cpu,cpu=2 usage_idle=70.6811,usage_system=2.76761,usage_user=85.7126 6322000000000 +cpu,cpu=3 usage_idle=89.9949,usage_system=8.57518,usage_user=90.7805 6323000000000 +cpu,cpu=4 usage_idle=81.5921,usage_system=94.1979,usage_user=60.3132 6324000000000 +cpu,cpu=0 usage_idle=73.6467,usage_system=94.7328,usage_user=3.93798 6325000000000 +cpu,cpu=1 usage_idle=4.76084,usage_system=49.3273,usage_user=51.8249 6326000000000 +cpu,cpu=2 usage_idle=86.7467,usage_system=97.7054,usage_user=11.0323 6327000000000 +cpu,cpu=3 usage_idle=77.4085,usage_system=74.4574,usage_user=12.1449 6328000000000 +cpu,cpu=4 usage_idle=35.21,usage_system=26.7254,usage_user=72.8475 6329000000000 +cpu,cpu=0 usage_idle=17.265,usage_system=74.9041,usage_user=91.9501 6330000000000 +cpu,cpu=1 usage_idle=91.3607,usage_system=96.939,usage_user=7.02118 6331000000000 +cpu,cpu=2 usage_idle=97.1859,usage_system=67.6201,usage_user=9.78879 6332000000000 +cpu,cpu=3 usage_idle=82.8986,usage_system=57.6149,usage_user=18.364 6333000000000 +cpu,cpu=4 usage_idle=73.6791,usage_system=39.2071,usage_user=12.5618 6334000000000 +cpu,cpu=0 usage_idle=33.9923,usage_system=12.8538,usage_user=7.29464 6335000000000 +cpu,cpu=1 usage_idle=37.9303,usage_system=17.6146,usage_user=56.6219 6336000000000 +cpu,cpu=2 usage_idle=89.7552,usage_system=4.36132,usage_user=54.3273 6337000000000 +cpu,cpu=3 usage_idle=0.787536,usage_system=81.7699,usage_user=28.7848 6338000000000 +cpu,cpu=4 usage_idle=12.9324,usage_system=16.9798,usage_user=55.5102 6339000000000 +cpu,cpu=0 usage_idle=85.7799,usage_system=34.2449,usage_user=30.4143 6340000000000 +cpu,cpu=1 usage_idle=77.73,usage_system=25.6055,usage_user=27.3533 6341000000000 +cpu,cpu=2 usage_idle=84.7512,usage_system=22.7915,usage_user=94.9734 6342000000000 +cpu,cpu=3 usage_idle=94.54,usage_system=5.69002,usage_user=52.5883 6343000000000 +cpu,cpu=4 usage_idle=12.904,usage_system=79.3691,usage_user=91.7953 6344000000000 +cpu,cpu=0 usage_idle=25.4658,usage_system=13.3614,usage_user=4.64911 6345000000000 +cpu,cpu=1 usage_idle=32.7604,usage_system=51.2917,usage_user=22.2637 6346000000000 +cpu,cpu=2 usage_idle=89.3824,usage_system=41.047,usage_user=26.625 6347000000000 +cpu,cpu=3 usage_idle=43.7097,usage_system=41.8345,usage_user=8.39489 6348000000000 +cpu,cpu=4 usage_idle=72.4945,usage_system=54.7669,usage_user=25.3747 6349000000000 +cpu,cpu=0 usage_idle=28.0047,usage_system=40.5469,usage_user=59.6196 6350000000000 +cpu,cpu=1 usage_idle=58.419,usage_system=18.2769,usage_user=85.2251 6351000000000 +cpu,cpu=2 usage_idle=85.7723,usage_system=3.02809,usage_user=8.01655 6352000000000 +cpu,cpu=3 usage_idle=80.7457,usage_system=97.5681,usage_user=13.7066 6353000000000 +cpu,cpu=4 usage_idle=33.3339,usage_system=10.472,usage_user=93.0757 6354000000000 +cpu,cpu=0 usage_idle=25.1293,usage_system=35.9378,usage_user=6.43711 6355000000000 +cpu,cpu=1 usage_idle=29.7784,usage_system=68.6982,usage_user=57.7288 6356000000000 +cpu,cpu=2 usage_idle=52.0421,usage_system=58.0806,usage_user=98.7758 6357000000000 +cpu,cpu=3 usage_idle=78.6671,usage_system=1.79032,usage_user=40.6103 6358000000000 +cpu,cpu=4 usage_idle=87.062,usage_system=74.2848,usage_user=95.3772 6359000000000 +cpu,cpu=0 usage_idle=12.4367,usage_system=2.28943,usage_user=35.9241 6360000000000 +cpu,cpu=1 usage_idle=72.0563,usage_system=60.7084,usage_user=54.201 6361000000000 +cpu,cpu=2 usage_idle=57.2814,usage_system=46.4807,usage_user=57.2291 6362000000000 +cpu,cpu=3 usage_idle=65.298,usage_system=27.2264,usage_user=54.7971 6363000000000 +cpu,cpu=4 usage_idle=79.0045,usage_system=60.5603,usage_user=65.2692 6364000000000 +cpu,cpu=0 usage_idle=72.0802,usage_system=85.6896,usage_user=1.20699 6365000000000 +cpu,cpu=1 usage_idle=78.5173,usage_system=15.468,usage_user=69.9052 6366000000000 +cpu,cpu=2 usage_idle=36.2461,usage_system=67.5101,usage_user=27.9859 6367000000000 +cpu,cpu=3 usage_idle=35.0219,usage_system=46.1772,usage_user=29.7762 6368000000000 +cpu,cpu=4 usage_idle=75.6322,usage_system=33.2392,usage_user=4.06095 6369000000000 +cpu,cpu=0 usage_idle=71.0094,usage_system=45.676,usage_user=6.35038 6370000000000 +cpu,cpu=1 usage_idle=6.93349,usage_system=17.7323,usage_user=67.0588 6371000000000 +cpu,cpu=2 usage_idle=61.1345,usage_system=75.0137,usage_user=13.5395 6372000000000 +cpu,cpu=3 usage_idle=18.3635,usage_system=40.3116,usage_user=40.7659 6373000000000 +cpu,cpu=4 usage_idle=73.1607,usage_system=19.3161,usage_user=1.3262 6374000000000 +cpu,cpu=0 usage_idle=38.4298,usage_system=91.3963,usage_user=87.0158 6375000000000 +cpu,cpu=1 usage_idle=39.6368,usage_system=69.9136,usage_user=2.48375 6376000000000 +cpu,cpu=2 usage_idle=9.54207,usage_system=6.15978,usage_user=69.9938 6377000000000 +cpu,cpu=3 usage_idle=37.5279,usage_system=41.1817,usage_user=16.171 6378000000000 +cpu,cpu=4 usage_idle=67.3041,usage_system=16.8139,usage_user=49.4102 6379000000000 +cpu,cpu=0 usage_idle=71.3651,usage_system=87.8233,usage_user=95.0862 6380000000000 +cpu,cpu=1 usage_idle=77.7154,usage_system=94.7568,usage_user=12.8184 6381000000000 +cpu,cpu=2 usage_idle=44.7743,usage_system=55.8913,usage_user=87.8321 6382000000000 +cpu,cpu=3 usage_idle=58.3138,usage_system=74.2548,usage_user=28.1437 6383000000000 +cpu,cpu=4 usage_idle=99.0797,usage_system=47.4154,usage_user=47.4598 6384000000000 +cpu,cpu=0 usage_idle=0.405879,usage_system=85.8453,usage_user=38.8562 6385000000000 +cpu,cpu=1 usage_idle=87.4217,usage_system=25.4821,usage_user=8.76981 6386000000000 +cpu,cpu=2 usage_idle=89.9054,usage_system=35.0242,usage_user=14.9296 6387000000000 +cpu,cpu=3 usage_idle=59.8992,usage_system=72.5521,usage_user=56.1113 6388000000000 +cpu,cpu=4 usage_idle=76.0702,usage_system=39.8562,usage_user=72.9252 6389000000000 +cpu,cpu=0 usage_idle=25.4805,usage_system=11.2213,usage_user=60.7485 6390000000000 +cpu,cpu=1 usage_idle=20.5666,usage_system=88.9368,usage_user=55.5053 6391000000000 +cpu,cpu=2 usage_idle=33.3851,usage_system=33.711,usage_user=11.3965 6392000000000 +cpu,cpu=3 usage_idle=21.2172,usage_system=92.0248,usage_user=85.6513 6393000000000 +cpu,cpu=4 usage_idle=49.3609,usage_system=91.1045,usage_user=33.0668 6394000000000 +cpu,cpu=0 usage_idle=96.8207,usage_system=91.5103,usage_user=18.9121 6395000000000 +cpu,cpu=1 usage_idle=35.6768,usage_system=78.932,usage_user=44.3942 6396000000000 +cpu,cpu=2 usage_idle=44.4467,usage_system=68.8374,usage_user=79.4184 6397000000000 +cpu,cpu=3 usage_idle=59.3762,usage_system=28.7366,usage_user=51.9705 6398000000000 +cpu,cpu=4 usage_idle=15.4875,usage_system=4.80685,usage_user=91.8267 6399000000000 +cpu,cpu=0 usage_idle=88.4127,usage_system=30.2873,usage_user=3.04805 6400000000000 +cpu,cpu=1 usage_idle=49.1612,usage_system=50.8539,usage_user=91.9848 6401000000000 +cpu,cpu=2 usage_idle=4.66654,usage_system=84.239,usage_user=25.6958 6402000000000 +cpu,cpu=3 usage_idle=16.0631,usage_system=5.45616,usage_user=17.7206 6403000000000 +cpu,cpu=4 usage_idle=1.71441,usage_system=54.817,usage_user=8.82504 6404000000000 +cpu,cpu=0 usage_idle=34.7812,usage_system=51.6377,usage_user=0.335375 6405000000000 +cpu,cpu=1 usage_idle=53.6932,usage_system=87.3145,usage_user=79.2674 6406000000000 +cpu,cpu=2 usage_idle=98.0874,usage_system=31.7612,usage_user=48.1048 6407000000000 +cpu,cpu=3 usage_idle=77.5058,usage_system=91.1375,usage_user=76.8414 6408000000000 +cpu,cpu=4 usage_idle=29.4763,usage_system=6.625,usage_user=81.6483 6409000000000 +cpu,cpu=0 usage_idle=21.303,usage_system=95.0377,usage_user=11.9356 6410000000000 +cpu,cpu=1 usage_idle=24.3511,usage_system=44.199,usage_user=62.7895 6411000000000 +cpu,cpu=2 usage_idle=16.3359,usage_system=48.8655,usage_user=47.0285 6412000000000 +cpu,cpu=3 usage_idle=42.0317,usage_system=64.9286,usage_user=52.4847 6413000000000 +cpu,cpu=4 usage_idle=59.7523,usage_system=66.643,usage_user=7.30166 6414000000000 +cpu,cpu=0 usage_idle=68.5773,usage_system=1.42421,usage_user=58.9394 6415000000000 +cpu,cpu=1 usage_idle=68.9127,usage_system=55.1175,usage_user=46.2539 6416000000000 +cpu,cpu=2 usage_idle=48.1801,usage_system=53.2049,usage_user=78.0151 6417000000000 +cpu,cpu=3 usage_idle=96.2849,usage_system=30.7107,usage_user=69.1526 6418000000000 +cpu,cpu=4 usage_idle=73.1263,usage_system=60.187,usage_user=75.7776 6419000000000 +cpu,cpu=0 usage_idle=54.7745,usage_system=81.49,usage_user=70.8153 6420000000000 +cpu,cpu=1 usage_idle=66.7101,usage_system=5.84111,usage_user=15.0143 6421000000000 +cpu,cpu=2 usage_idle=29.4996,usage_system=22.177,usage_user=63.8798 6422000000000 +cpu,cpu=3 usage_idle=76.5281,usage_system=64.2087,usage_user=28.8085 6423000000000 +cpu,cpu=4 usage_idle=29.0127,usage_system=23.961,usage_user=95.4515 6424000000000 +cpu,cpu=0 usage_idle=36.3144,usage_system=92.5384,usage_user=96.8757 6425000000000 +cpu,cpu=1 usage_idle=95.2538,usage_system=61.4511,usage_user=51.9932 6426000000000 +cpu,cpu=2 usage_idle=41.5077,usage_system=9.63118,usage_user=5.19805 6427000000000 +cpu,cpu=3 usage_idle=19.5228,usage_system=5.91604,usage_user=35.9087 6428000000000 +cpu,cpu=4 usage_idle=88.6754,usage_system=79.0423,usage_user=96.0957 6429000000000 +cpu,cpu=0 usage_idle=64.4529,usage_system=33.8168,usage_user=77.5857 6430000000000 +cpu,cpu=1 usage_idle=35.2682,usage_system=0.526913,usage_user=83.4268 6431000000000 +cpu,cpu=2 usage_idle=50.2825,usage_system=30.0265,usage_user=5.60382 6432000000000 +cpu,cpu=3 usage_idle=14.1624,usage_system=6.55457,usage_user=69.8125 6433000000000 +cpu,cpu=4 usage_idle=42.9709,usage_system=35.5673,usage_user=93.7736 6434000000000 +cpu,cpu=0 usage_idle=38.4224,usage_system=71.8817,usage_user=86.312 6435000000000 +cpu,cpu=1 usage_idle=35.2981,usage_system=67.1354,usage_user=47.7631 6436000000000 +cpu,cpu=2 usage_idle=87.2913,usage_system=8.6431,usage_user=57.3942 6437000000000 +cpu,cpu=3 usage_idle=92.4893,usage_system=28.1659,usage_user=63.3103 6438000000000 +cpu,cpu=4 usage_idle=28.398,usage_system=16.8412,usage_user=42.3526 6439000000000 +cpu,cpu=0 usage_idle=24.4937,usage_system=81.2942,usage_user=76.1694 6440000000000 +cpu,cpu=1 usage_idle=2.0794,usage_system=16.5624,usage_user=76.6963 6441000000000 +cpu,cpu=2 usage_idle=85.5062,usage_system=66.8449,usage_user=6.72282 6442000000000 +cpu,cpu=3 usage_idle=91.11,usage_system=81.0073,usage_user=13.2774 6443000000000 +cpu,cpu=4 usage_idle=60.9226,usage_system=23.9782,usage_user=48.8447 6444000000000 +cpu,cpu=0 usage_idle=54.6961,usage_system=62.4006,usage_user=20.7264 6445000000000 +cpu,cpu=1 usage_idle=41.0081,usage_system=97.6987,usage_user=87.8618 6446000000000 +cpu,cpu=2 usage_idle=88.7712,usage_system=84.99,usage_user=96.5049 6447000000000 +cpu,cpu=3 usage_idle=46.1654,usage_system=77.4793,usage_user=24.6708 6448000000000 +cpu,cpu=4 usage_idle=9.47567,usage_system=5.87738,usage_user=41.512 6449000000000 +cpu,cpu=0 usage_idle=51.8283,usage_system=30.3711,usage_user=22.8062 6450000000000 +cpu,cpu=1 usage_idle=27.9977,usage_system=32.4505,usage_user=39.3685 6451000000000 +cpu,cpu=2 usage_idle=4.694,usage_system=17.9567,usage_user=6.21349 6452000000000 +cpu,cpu=3 usage_idle=11.4168,usage_system=9.06671,usage_user=87.2208 6453000000000 +cpu,cpu=4 usage_idle=24.6942,usage_system=69.9893,usage_user=11.199 6454000000000 +cpu,cpu=0 usage_idle=73.5389,usage_system=24.6854,usage_user=73.5996 6455000000000 +cpu,cpu=1 usage_idle=94.2652,usage_system=65.6935,usage_user=71.2984 6456000000000 +cpu,cpu=2 usage_idle=82.127,usage_system=54.4647,usage_user=56.2884 6457000000000 +cpu,cpu=3 usage_idle=78.6319,usage_system=0.630077,usage_user=33.7677 6458000000000 +cpu,cpu=4 usage_idle=3.30269,usage_system=10.1057,usage_user=39.6451 6459000000000 +cpu,cpu=0 usage_idle=44.8147,usage_system=61.934,usage_user=70.0162 6460000000000 +cpu,cpu=1 usage_idle=67.6209,usage_system=89.9317,usage_user=2.46669 6461000000000 +cpu,cpu=2 usage_idle=6.9894,usage_system=94.6257,usage_user=20.4234 6462000000000 +cpu,cpu=3 usage_idle=13.2029,usage_system=6.04249,usage_user=29.4901 6463000000000 +cpu,cpu=4 usage_idle=0.423714,usage_system=30.7367,usage_user=99.4794 6464000000000 +cpu,cpu=0 usage_idle=11.6228,usage_system=4.27558,usage_user=24.1648 6465000000000 +cpu,cpu=1 usage_idle=85.2224,usage_system=98.5408,usage_user=89.8583 6466000000000 +cpu,cpu=2 usage_idle=56.5208,usage_system=80.6679,usage_user=44.323 6467000000000 +cpu,cpu=3 usage_idle=12.8091,usage_system=59.2998,usage_user=44.9531 6468000000000 +cpu,cpu=4 usage_idle=46.5768,usage_system=62.6025,usage_user=55.0588 6469000000000 +cpu,cpu=0 usage_idle=86.2219,usage_system=7.41716,usage_user=16.9928 6470000000000 +cpu,cpu=1 usage_idle=56.2381,usage_system=75.038,usage_user=6.92449 6471000000000 +cpu,cpu=2 usage_idle=58.7048,usage_system=82.0274,usage_user=1.55017 6472000000000 +cpu,cpu=3 usage_idle=79.1281,usage_system=95.2303,usage_user=7.59266 6473000000000 +cpu,cpu=4 usage_idle=8.61824,usage_system=95.654,usage_user=38.3294 6474000000000 +cpu,cpu=0 usage_idle=8.0976,usage_system=7.27677,usage_user=42.6049 6475000000000 +cpu,cpu=1 usage_idle=32.2624,usage_system=92.4992,usage_user=41.1458 6476000000000 +cpu,cpu=2 usage_idle=22.1207,usage_system=49.0199,usage_user=21.8136 6477000000000 +cpu,cpu=3 usage_idle=66.4437,usage_system=61.829,usage_user=81.1134 6478000000000 +cpu,cpu=4 usage_idle=11.3968,usage_system=8.40583,usage_user=43.7158 6479000000000 +cpu,cpu=0 usage_idle=66.4556,usage_system=94.6277,usage_user=51.133 6480000000000 +cpu,cpu=1 usage_idle=83.4484,usage_system=50.8658,usage_user=26.171 6481000000000 +cpu,cpu=2 usage_idle=90.3729,usage_system=9.57055,usage_user=8.19844 6482000000000 +cpu,cpu=3 usage_idle=91.9231,usage_system=88.6987,usage_user=3.42875 6483000000000 +cpu,cpu=4 usage_idle=99.5157,usage_system=97.3169,usage_user=99.0828 6484000000000 +cpu,cpu=0 usage_idle=37.8451,usage_system=5.41454,usage_user=6.35954 6485000000000 +cpu,cpu=1 usage_idle=80.45,usage_system=37.6769,usage_user=98.8587 6486000000000 +cpu,cpu=2 usage_idle=21.5958,usage_system=59.7976,usage_user=47.8786 6487000000000 +cpu,cpu=3 usage_idle=43.4094,usage_system=26.2413,usage_user=9.70765 6488000000000 +cpu,cpu=4 usage_idle=24.5228,usage_system=37.6381,usage_user=18.1135 6489000000000 +cpu,cpu=0 usage_idle=68.2386,usage_system=4.09366,usage_user=12.7412 6490000000000 +cpu,cpu=1 usage_idle=19.3716,usage_system=87.5421,usage_user=63.607 6491000000000 +cpu,cpu=2 usage_idle=45.5426,usage_system=77.915,usage_user=73.1776 6492000000000 +cpu,cpu=3 usage_idle=53.7411,usage_system=69.838,usage_user=61.8763 6493000000000 +cpu,cpu=4 usage_idle=57.1698,usage_system=69.3538,usage_user=59.1932 6494000000000 +cpu,cpu=0 usage_idle=56.2526,usage_system=7.19883,usage_user=64.6077 6495000000000 +cpu,cpu=1 usage_idle=62.6121,usage_system=87.6488,usage_user=2.28465 6496000000000 +cpu,cpu=2 usage_idle=61.4708,usage_system=9.24463,usage_user=62.0823 6497000000000 +cpu,cpu=3 usage_idle=9.34946,usage_system=52.654,usage_user=88.3236 6498000000000 +cpu,cpu=4 usage_idle=19.0571,usage_system=77.1768,usage_user=25.9617 6499000000000 +cpu,cpu=0 usage_idle=37.1706,usage_system=45.4154,usage_user=30.0553 6500000000000 +cpu,cpu=1 usage_idle=49.9118,usage_system=64.787,usage_user=17.5974 6501000000000 +cpu,cpu=2 usage_idle=13.5188,usage_system=10.3296,usage_user=95.5124 6502000000000 +cpu,cpu=3 usage_idle=86.6964,usage_system=64.0707,usage_user=65.3504 6503000000000 +cpu,cpu=4 usage_idle=48.5726,usage_system=21.2406,usage_user=34.7041 6504000000000 +cpu,cpu=0 usage_idle=7.76582,usage_system=77.4932,usage_user=41.903 6505000000000 +cpu,cpu=1 usage_idle=72.3735,usage_system=40.1053,usage_user=29.5518 6506000000000 +cpu,cpu=2 usage_idle=74.6582,usage_system=1.57612,usage_user=38.7965 6507000000000 +cpu,cpu=3 usage_idle=36.7405,usage_system=10.9256,usage_user=91.4505 6508000000000 +cpu,cpu=4 usage_idle=25.0641,usage_system=29.9827,usage_user=68.6272 6509000000000 +cpu,cpu=0 usage_idle=51.0257,usage_system=67.1533,usage_user=14.0426 6510000000000 +cpu,cpu=1 usage_idle=81.0811,usage_system=17.0651,usage_user=78.8296 6511000000000 +cpu,cpu=2 usage_idle=98.6785,usage_system=30.5839,usage_user=89.1592 6512000000000 +cpu,cpu=3 usage_idle=94.1909,usage_system=17.2803,usage_user=53.23 6513000000000 +cpu,cpu=4 usage_idle=59.5413,usage_system=65.8529,usage_user=74.4705 6514000000000 +cpu,cpu=0 usage_idle=94.2454,usage_system=73.6187,usage_user=51.9637 6515000000000 +cpu,cpu=1 usage_idle=36.1484,usage_system=45.9923,usage_user=92.069 6516000000000 +cpu,cpu=2 usage_idle=65.7002,usage_system=20.6505,usage_user=93.6451 6517000000000 +cpu,cpu=3 usage_idle=4.49666,usage_system=57.3909,usage_user=4.57066 6518000000000 +cpu,cpu=4 usage_idle=95.9471,usage_system=82.455,usage_user=34.5533 6519000000000 +cpu,cpu=0 usage_idle=64.5744,usage_system=33.4807,usage_user=1.70663 6520000000000 +cpu,cpu=1 usage_idle=78.617,usage_system=14.5618,usage_user=18.7717 6521000000000 +cpu,cpu=2 usage_idle=57.4466,usage_system=13.2403,usage_user=49.3556 6522000000000 +cpu,cpu=3 usage_idle=46.6058,usage_system=7.43116,usage_user=66.6359 6523000000000 +cpu,cpu=4 usage_idle=99.8358,usage_system=66.9724,usage_user=32.4888 6524000000000 +cpu,cpu=0 usage_idle=74.3063,usage_system=61.2178,usage_user=6.10753 6525000000000 +cpu,cpu=1 usage_idle=26.27,usage_system=97.3662,usage_user=52.0998 6526000000000 +cpu,cpu=2 usage_idle=18.339,usage_system=63.0664,usage_user=72.7503 6527000000000 +cpu,cpu=3 usage_idle=11.9841,usage_system=67.5631,usage_user=30.1412 6528000000000 +cpu,cpu=4 usage_idle=16.5547,usage_system=63.5102,usage_user=12.5962 6529000000000 +cpu,cpu=0 usage_idle=51.1081,usage_system=28.0845,usage_user=46.0769 6530000000000 +cpu,cpu=1 usage_idle=52.8147,usage_system=6.7015,usage_user=60.6387 6531000000000 +cpu,cpu=2 usage_idle=71.5864,usage_system=64.1481,usage_user=73.8791 6532000000000 +cpu,cpu=3 usage_idle=20.942,usage_system=10.7539,usage_user=81.3102 6533000000000 +cpu,cpu=4 usage_idle=87.5779,usage_system=10.5897,usage_user=48.2826 6534000000000 +cpu,cpu=0 usage_idle=20.0667,usage_system=84.896,usage_user=9.50044 6535000000000 +cpu,cpu=1 usage_idle=26.1743,usage_system=11.1661,usage_user=6.86662 6536000000000 +cpu,cpu=2 usage_idle=78.274,usage_system=29.505,usage_user=69.933 6537000000000 +cpu,cpu=3 usage_idle=51.0243,usage_system=41.4891,usage_user=37.4961 6538000000000 +cpu,cpu=4 usage_idle=81.1655,usage_system=58.0438,usage_user=1.00625 6539000000000 +cpu,cpu=0 usage_idle=93.7617,usage_system=9.15186,usage_user=29.0908 6540000000000 +cpu,cpu=1 usage_idle=39.8386,usage_system=61.9665,usage_user=35.7923 6541000000000 +cpu,cpu=2 usage_idle=0.477333,usage_system=33.5529,usage_user=99.9404 6542000000000 +cpu,cpu=3 usage_idle=74.3564,usage_system=54.495,usage_user=10.6943 6543000000000 +cpu,cpu=4 usage_idle=55.6666,usage_system=42.0729,usage_user=21.284 6544000000000 +cpu,cpu=0 usage_idle=3.94922,usage_system=62.1396,usage_user=6.18002 6545000000000 +cpu,cpu=1 usage_idle=13.4497,usage_system=88.3139,usage_user=17.3461 6546000000000 +cpu,cpu=2 usage_idle=20.3163,usage_system=66.5879,usage_user=46.8511 6547000000000 +cpu,cpu=3 usage_idle=90.2493,usage_system=17.6122,usage_user=88.3402 6548000000000 +cpu,cpu=4 usage_idle=27.7454,usage_system=98.7777,usage_user=46.384 6549000000000 +cpu,cpu=0 usage_idle=28.7516,usage_system=92.5394,usage_user=55.5359 6550000000000 +cpu,cpu=1 usage_idle=57.8424,usage_system=32.3779,usage_user=17.5024 6551000000000 +cpu,cpu=2 usage_idle=93.6347,usage_system=32.8553,usage_user=51.0553 6552000000000 +cpu,cpu=3 usage_idle=93.5751,usage_system=7.21166,usage_user=5.55028 6553000000000 +cpu,cpu=4 usage_idle=4.26935,usage_system=62.8783,usage_user=47.6232 6554000000000 +cpu,cpu=0 usage_idle=25.5533,usage_system=66.8275,usage_user=9.76277 6555000000000 +cpu,cpu=1 usage_idle=31.7334,usage_system=80.2771,usage_user=98.0766 6556000000000 +cpu,cpu=2 usage_idle=49.0794,usage_system=0.593414,usage_user=64.6645 6557000000000 +cpu,cpu=3 usage_idle=95.9305,usage_system=90.8427,usage_user=82.2767 6558000000000 +cpu,cpu=4 usage_idle=84.2707,usage_system=18.5881,usage_user=81.0544 6559000000000 +cpu,cpu=0 usage_idle=30.6547,usage_system=47.3397,usage_user=73.5938 6560000000000 +cpu,cpu=1 usage_idle=86.1906,usage_system=5.18214,usage_user=5.97174 6561000000000 +cpu,cpu=2 usage_idle=3.69299,usage_system=98.8168,usage_user=38.827 6562000000000 +cpu,cpu=3 usage_idle=54.7483,usage_system=92.3919,usage_user=46.0387 6563000000000 +cpu,cpu=4 usage_idle=60.2986,usage_system=96.6613,usage_user=8.91694 6564000000000 +cpu,cpu=0 usage_idle=7.92177,usage_system=22.2146,usage_user=75.7444 6565000000000 +cpu,cpu=1 usage_idle=17.6845,usage_system=53.948,usage_user=56.0216 6566000000000 +cpu,cpu=2 usage_idle=15.7612,usage_system=3.02738,usage_user=56.615 6567000000000 +cpu,cpu=3 usage_idle=80.4257,usage_system=98.9579,usage_user=47.4577 6568000000000 +cpu,cpu=4 usage_idle=62.7024,usage_system=83.2287,usage_user=66.0458 6569000000000 +cpu,cpu=0 usage_idle=43.7569,usage_system=13.8834,usage_user=13.3855 6570000000000 +cpu,cpu=1 usage_idle=17.3507,usage_system=0.0739934,usage_user=18.5676 6571000000000 +cpu,cpu=2 usage_idle=23.3224,usage_system=3.76699,usage_user=17.3845 6572000000000 +cpu,cpu=3 usage_idle=62.1494,usage_system=58.5153,usage_user=9.7764 6573000000000 +cpu,cpu=4 usage_idle=8.18812,usage_system=18.8139,usage_user=6.43767 6574000000000 +cpu,cpu=0 usage_idle=17.1051,usage_system=26.7357,usage_user=28.6523 6575000000000 +cpu,cpu=1 usage_idle=92.8495,usage_system=44.4202,usage_user=82.6002 6576000000000 +cpu,cpu=2 usage_idle=48.871,usage_system=60.1814,usage_user=85.6276 6577000000000 +cpu,cpu=3 usage_idle=5.48601,usage_system=40.6071,usage_user=84.5855 6578000000000 +cpu,cpu=4 usage_idle=52.9437,usage_system=3.30952,usage_user=67.8142 6579000000000 +cpu,cpu=0 usage_idle=18.9895,usage_system=47.0664,usage_user=81.6976 6580000000000 +cpu,cpu=1 usage_idle=32.375,usage_system=64.4171,usage_user=81.7716 6581000000000 +cpu,cpu=2 usage_idle=50.9426,usage_system=87.7395,usage_user=85.5386 6582000000000 +cpu,cpu=3 usage_idle=68.3271,usage_system=49.8889,usage_user=44.0539 6583000000000 +cpu,cpu=4 usage_idle=78.1035,usage_system=58.077,usage_user=62.8678 6584000000000 +cpu,cpu=0 usage_idle=84.5412,usage_system=75.1821,usage_user=89.6035 6585000000000 +cpu,cpu=1 usage_idle=13.1934,usage_system=68.0316,usage_user=34.0237 6586000000000 +cpu,cpu=2 usage_idle=95.7936,usage_system=16.9026,usage_user=94.205 6587000000000 +cpu,cpu=3 usage_idle=81.4212,usage_system=22.3886,usage_user=34.8121 6588000000000 +cpu,cpu=4 usage_idle=66.0068,usage_system=75.3323,usage_user=38.1216 6589000000000 +cpu,cpu=0 usage_idle=33.8209,usage_system=94.3218,usage_user=85.1881 6590000000000 +cpu,cpu=1 usage_idle=15.5185,usage_system=26.6968,usage_user=49.6051 6591000000000 +cpu,cpu=2 usage_idle=97.2901,usage_system=77.6394,usage_user=37.3446 6592000000000 +cpu,cpu=3 usage_idle=82.8286,usage_system=45.9665,usage_user=87.2336 6593000000000 +cpu,cpu=4 usage_idle=26.8825,usage_system=24.07,usage_user=45.3106 6594000000000 +cpu,cpu=0 usage_idle=89.7502,usage_system=8.61113,usage_user=20.4927 6595000000000 +cpu,cpu=1 usage_idle=79.3537,usage_system=21.8045,usage_user=88.5243 6596000000000 +cpu,cpu=2 usage_idle=13.3774,usage_system=17.5982,usage_user=5.42692 6597000000000 +cpu,cpu=3 usage_idle=7.58241,usage_system=99.0194,usage_user=27.8156 6598000000000 +cpu,cpu=4 usage_idle=42.3945,usage_system=65.0262,usage_user=3.14791 6599000000000 +cpu,cpu=0 usage_idle=80.5162,usage_system=98.8471,usage_user=97.4697 6600000000000 +cpu,cpu=1 usage_idle=65.7042,usage_system=14.3656,usage_user=24.1665 6601000000000 +cpu,cpu=2 usage_idle=15.3094,usage_system=11.6557,usage_user=1.80592 6602000000000 +cpu,cpu=3 usage_idle=52.654,usage_system=94.4843,usage_user=47.7724 6603000000000 +cpu,cpu=4 usage_idle=39.8875,usage_system=21.3668,usage_user=71.8424 6604000000000 +cpu,cpu=0 usage_idle=85.1981,usage_system=11.117,usage_user=80.4535 6605000000000 +cpu,cpu=1 usage_idle=5.69083,usage_system=90.4707,usage_user=2.25806 6606000000000 +cpu,cpu=2 usage_idle=94.2151,usage_system=3.8481,usage_user=19.8563 6607000000000 +cpu,cpu=3 usage_idle=99.642,usage_system=11.4305,usage_user=18.8757 6608000000000 +cpu,cpu=4 usage_idle=27.4576,usage_system=53.825,usage_user=83.9019 6609000000000 +cpu,cpu=0 usage_idle=30.6055,usage_system=34.3412,usage_user=82.749 6610000000000 +cpu,cpu=1 usage_idle=28.0752,usage_system=0.0454585,usage_user=97.1146 6611000000000 +cpu,cpu=2 usage_idle=52.2418,usage_system=15.3548,usage_user=8.7703 6612000000000 +cpu,cpu=3 usage_idle=54.0477,usage_system=68.0088,usage_user=3.25461 6613000000000 +cpu,cpu=4 usage_idle=1.82011,usage_system=7.89634,usage_user=24.6214 6614000000000 +cpu,cpu=0 usage_idle=73.6625,usage_system=93.0945,usage_user=35.7384 6615000000000 +cpu,cpu=1 usage_idle=54.116,usage_system=98.7853,usage_user=26.2092 6616000000000 +cpu,cpu=2 usage_idle=56.3741,usage_system=93.0004,usage_user=30.0573 6617000000000 +cpu,cpu=3 usage_idle=76.2303,usage_system=92.6425,usage_user=41.4878 6618000000000 +cpu,cpu=4 usage_idle=95.106,usage_system=20.1001,usage_user=95.3128 6619000000000 +cpu,cpu=0 usage_idle=79.0079,usage_system=50.7056,usage_user=29.6541 6620000000000 +cpu,cpu=1 usage_idle=61.7568,usage_system=78.7808,usage_user=29.6995 6621000000000 +cpu,cpu=2 usage_idle=58.8715,usage_system=31.0226,usage_user=45.0543 6622000000000 +cpu,cpu=3 usage_idle=67.6418,usage_system=85.0703,usage_user=13.0632 6623000000000 +cpu,cpu=4 usage_idle=70.8964,usage_system=86.8904,usage_user=20.9595 6624000000000 +cpu,cpu=0 usage_idle=95.5178,usage_system=60.5529,usage_user=14.054 6625000000000 +cpu,cpu=1 usage_idle=31.2562,usage_system=14.6689,usage_user=12.8393 6626000000000 +cpu,cpu=2 usage_idle=57.4654,usage_system=71.043,usage_user=5.83967 6627000000000 +cpu,cpu=3 usage_idle=87.5227,usage_system=47.2733,usage_user=98.4821 6628000000000 +cpu,cpu=4 usage_idle=29.0105,usage_system=42.3793,usage_user=18.5822 6629000000000 +cpu,cpu=0 usage_idle=24.3233,usage_system=21.3872,usage_user=69.2878 6630000000000 +cpu,cpu=1 usage_idle=53.9774,usage_system=83.144,usage_user=48.0686 6631000000000 +cpu,cpu=2 usage_idle=83.6769,usage_system=42.0155,usage_user=79.0912 6632000000000 +cpu,cpu=3 usage_idle=28.7313,usage_system=9.65723,usage_user=64.1615 6633000000000 +cpu,cpu=4 usage_idle=41.7944,usage_system=80.5536,usage_user=51.052 6634000000000 +cpu,cpu=0 usage_idle=62.7539,usage_system=76.0714,usage_user=11.6049 6635000000000 +cpu,cpu=1 usage_idle=76.8078,usage_system=7.32756,usage_user=26.2738 6636000000000 +cpu,cpu=2 usage_idle=89.6471,usage_system=64.7929,usage_user=97.3168 6637000000000 +cpu,cpu=3 usage_idle=95.4868,usage_system=52.3156,usage_user=44.5901 6638000000000 +cpu,cpu=4 usage_idle=93.9689,usage_system=81.3261,usage_user=86.9694 6639000000000 +cpu,cpu=0 usage_idle=12.5511,usage_system=5.64936,usage_user=8.35655 6640000000000 +cpu,cpu=1 usage_idle=81.8389,usage_system=59.6267,usage_user=91.5006 6641000000000 +cpu,cpu=2 usage_idle=29.9075,usage_system=43.3036,usage_user=33.516 6642000000000 +cpu,cpu=3 usage_idle=8.99875,usage_system=72.0349,usage_user=43.1733 6643000000000 +cpu,cpu=4 usage_idle=73.1603,usage_system=13.8293,usage_user=23.7269 6644000000000 +cpu,cpu=0 usage_idle=24.2122,usage_system=76.5832,usage_user=99.7982 6645000000000 +cpu,cpu=1 usage_idle=35.8171,usage_system=53.391,usage_user=7.12577 6646000000000 +cpu,cpu=2 usage_idle=62.0909,usage_system=43.0382,usage_user=71.9187 6647000000000 +cpu,cpu=3 usage_idle=59.4076,usage_system=38.5249,usage_user=24.2343 6648000000000 +cpu,cpu=4 usage_idle=3.99769,usage_system=32.4938,usage_user=5.56037 6649000000000 +cpu,cpu=0 usage_idle=90.9671,usage_system=45.0449,usage_user=11.2097 6650000000000 +cpu,cpu=1 usage_idle=99.3236,usage_system=26.8838,usage_user=70.8365 6651000000000 +cpu,cpu=2 usage_idle=90.8242,usage_system=56.7913,usage_user=14.1401 6652000000000 +cpu,cpu=3 usage_idle=24.3402,usage_system=65.7901,usage_user=86.175 6653000000000 +cpu,cpu=4 usage_idle=67.5135,usage_system=38.9504,usage_user=0.00432152 6654000000000 +cpu,cpu=0 usage_idle=91.2404,usage_system=63.1626,usage_user=76.5875 6655000000000 +cpu,cpu=1 usage_idle=91.0386,usage_system=98.9797,usage_user=29.9786 6656000000000 +cpu,cpu=2 usage_idle=98.1643,usage_system=61.0706,usage_user=73.0167 6657000000000 +cpu,cpu=3 usage_idle=70.0831,usage_system=20.4782,usage_user=11.5416 6658000000000 +cpu,cpu=4 usage_idle=94.3174,usage_system=24.4759,usage_user=44.0355 6659000000000 +cpu,cpu=0 usage_idle=99.8777,usage_system=15.443,usage_user=89.0804 6660000000000 +cpu,cpu=1 usage_idle=11.0875,usage_system=14.7666,usage_user=15.9642 6661000000000 +cpu,cpu=2 usage_idle=81.9239,usage_system=5.59076,usage_user=72.7555 6662000000000 +cpu,cpu=3 usage_idle=96.0641,usage_system=29.931,usage_user=38.5456 6663000000000 +cpu,cpu=4 usage_idle=82.2391,usage_system=97.4445,usage_user=77.496 6664000000000 +cpu,cpu=0 usage_idle=82.2434,usage_system=88.6848,usage_user=40.6586 6665000000000 +cpu,cpu=1 usage_idle=58.8309,usage_system=79.7234,usage_user=39.6383 6666000000000 +cpu,cpu=2 usage_idle=88.8095,usage_system=77.8878,usage_user=0.708943 6667000000000 +cpu,cpu=3 usage_idle=61.8262,usage_system=47.9708,usage_user=21.1872 6668000000000 +cpu,cpu=4 usage_idle=73.3679,usage_system=42.2882,usage_user=45.6631 6669000000000 +cpu,cpu=0 usage_idle=17.4033,usage_system=42.1659,usage_user=61.106 6670000000000 +cpu,cpu=1 usage_idle=6.48371,usage_system=53.2534,usage_user=75.8726 6671000000000 +cpu,cpu=2 usage_idle=22.4479,usage_system=35.1773,usage_user=81.4634 6672000000000 +cpu,cpu=3 usage_idle=95.2034,usage_system=31.2414,usage_user=11.3944 6673000000000 +cpu,cpu=4 usage_idle=33.7491,usage_system=13.4804,usage_user=8.83887 6674000000000 +cpu,cpu=0 usage_idle=11.2451,usage_system=95.7238,usage_user=97.5237 6675000000000 +cpu,cpu=1 usage_idle=51.9037,usage_system=54.5547,usage_user=77.2471 6676000000000 +cpu,cpu=2 usage_idle=91.5421,usage_system=43.3642,usage_user=55.1349 6677000000000 +cpu,cpu=3 usage_idle=92.251,usage_system=5.19044,usage_user=3.10571 6678000000000 +cpu,cpu=4 usage_idle=13.4382,usage_system=78.5583,usage_user=45.3939 6679000000000 +cpu,cpu=0 usage_idle=59.1012,usage_system=95.9616,usage_user=87.5598 6680000000000 +cpu,cpu=1 usage_idle=20.2073,usage_system=2.44531,usage_user=40.8132 6681000000000 +cpu,cpu=2 usage_idle=96.0799,usage_system=24.8932,usage_user=75.9905 6682000000000 +cpu,cpu=3 usage_idle=77.5433,usage_system=20.0967,usage_user=7.23186 6683000000000 +cpu,cpu=4 usage_idle=88.9377,usage_system=53.8457,usage_user=20.7123 6684000000000 +cpu,cpu=0 usage_idle=97.7766,usage_system=65.0908,usage_user=16.4361 6685000000000 +cpu,cpu=1 usage_idle=95.3003,usage_system=16.9945,usage_user=70.9909 6686000000000 +cpu,cpu=2 usage_idle=72.5474,usage_system=8.53659,usage_user=14.3551 6687000000000 +cpu,cpu=3 usage_idle=27.6823,usage_system=0.787587,usage_user=19.5456 6688000000000 +cpu,cpu=4 usage_idle=30.788,usage_system=14.2257,usage_user=98.1038 6689000000000 +cpu,cpu=0 usage_idle=76.1819,usage_system=73.327,usage_user=94.0655 6690000000000 +cpu,cpu=1 usage_idle=63.7417,usage_system=93.5343,usage_user=96.5108 6691000000000 +cpu,cpu=2 usage_idle=4.55489,usage_system=89.6142,usage_user=21.404 6692000000000 +cpu,cpu=3 usage_idle=80.5454,usage_system=67.1575,usage_user=41.5007 6693000000000 +cpu,cpu=4 usage_idle=87.7772,usage_system=56.0952,usage_user=95.3464 6694000000000 +cpu,cpu=0 usage_idle=8.48955,usage_system=53.8717,usage_user=60.4372 6695000000000 +cpu,cpu=1 usage_idle=24.9257,usage_system=49.172,usage_user=77.4318 6696000000000 +cpu,cpu=2 usage_idle=95.9166,usage_system=21.7194,usage_user=85.9683 6697000000000 +cpu,cpu=3 usage_idle=10.2717,usage_system=49.4017,usage_user=86.7559 6698000000000 +cpu,cpu=4 usage_idle=29.8172,usage_system=80.1897,usage_user=0.981685 6699000000000 +cpu,cpu=0 usage_idle=27.9211,usage_system=56.3716,usage_user=74.3087 6700000000000 +cpu,cpu=1 usage_idle=21.9865,usage_system=20.1133,usage_user=67.8429 6701000000000 +cpu,cpu=2 usage_idle=18.4973,usage_system=24.6682,usage_user=57.4571 6702000000000 +cpu,cpu=3 usage_idle=39.9013,usage_system=5.21362,usage_user=24.6146 6703000000000 +cpu,cpu=4 usage_idle=81.4019,usage_system=92.9909,usage_user=80.7098 6704000000000 +cpu,cpu=0 usage_idle=76.7483,usage_system=1.48043,usage_user=34.5815 6705000000000 +cpu,cpu=1 usage_idle=37.1856,usage_system=26.4061,usage_user=83.7535 6706000000000 +cpu,cpu=2 usage_idle=14.6173,usage_system=22.3227,usage_user=5.4729 6707000000000 +cpu,cpu=3 usage_idle=0.585678,usage_system=32.5944,usage_user=54.8746 6708000000000 +cpu,cpu=4 usage_idle=87.3416,usage_system=62.4116,usage_user=35.0644 6709000000000 +cpu,cpu=0 usage_idle=88.3233,usage_system=90.3327,usage_user=91.436 6710000000000 +cpu,cpu=1 usage_idle=62.632,usage_system=12.3193,usage_user=11.5493 6711000000000 +cpu,cpu=2 usage_idle=30.4749,usage_system=30.8166,usage_user=36.2176 6712000000000 +cpu,cpu=3 usage_idle=87.932,usage_system=70.7178,usage_user=41.4312 6713000000000 +cpu,cpu=4 usage_idle=12.5466,usage_system=52.1198,usage_user=34.4221 6714000000000 +cpu,cpu=0 usage_idle=93.2564,usage_system=28.8681,usage_user=35.9025 6715000000000 +cpu,cpu=1 usage_idle=27.8378,usage_system=66.0537,usage_user=62.3086 6716000000000 +cpu,cpu=2 usage_idle=11.5913,usage_system=80.671,usage_user=84.6313 6717000000000 +cpu,cpu=3 usage_idle=17.0642,usage_system=81.2567,usage_user=17.2257 6718000000000 +cpu,cpu=4 usage_idle=71.9389,usage_system=68.5983,usage_user=79.6373 6719000000000 +cpu,cpu=0 usage_idle=7.00322,usage_system=56.9216,usage_user=69.97 6720000000000 +cpu,cpu=1 usage_idle=98.4392,usage_system=19.5536,usage_user=82.2893 6721000000000 +cpu,cpu=2 usage_idle=9.98854,usage_system=50.0285,usage_user=13.1058 6722000000000 +cpu,cpu=3 usage_idle=46.2061,usage_system=37.9605,usage_user=83.8237 6723000000000 +cpu,cpu=4 usage_idle=87.6373,usage_system=50.5071,usage_user=35.9434 6724000000000 +cpu,cpu=0 usage_idle=22.0594,usage_system=43.7634,usage_user=64.8116 6725000000000 +cpu,cpu=1 usage_idle=57.9619,usage_system=71.6013,usage_user=30.8652 6726000000000 +cpu,cpu=2 usage_idle=20.2705,usage_system=83.1926,usage_user=11.5363 6727000000000 +cpu,cpu=3 usage_idle=4.90179,usage_system=0.256862,usage_user=92.793 6728000000000 +cpu,cpu=4 usage_idle=22.1275,usage_system=72.1957,usage_user=61.3913 6729000000000 +cpu,cpu=0 usage_idle=1.76479,usage_system=79.1989,usage_user=18.3129 6730000000000 +cpu,cpu=1 usage_idle=71.7348,usage_system=77.6381,usage_user=37.8664 6731000000000 +cpu,cpu=2 usage_idle=54.0241,usage_system=87.6267,usage_user=87.8949 6732000000000 +cpu,cpu=3 usage_idle=67.1299,usage_system=33.8328,usage_user=25.8554 6733000000000 +cpu,cpu=4 usage_idle=50.9536,usage_system=21.4701,usage_user=76.3625 6734000000000 +cpu,cpu=0 usage_idle=86.897,usage_system=43.5295,usage_user=20.1259 6735000000000 +cpu,cpu=1 usage_idle=51.7086,usage_system=1.49138,usage_user=91.7272 6736000000000 +cpu,cpu=2 usage_idle=82.5739,usage_system=21.7619,usage_user=74.9198 6737000000000 +cpu,cpu=3 usage_idle=94.1101,usage_system=26.6637,usage_user=75.1766 6738000000000 +cpu,cpu=4 usage_idle=86.9031,usage_system=48.7911,usage_user=47.3724 6739000000000 +cpu,cpu=0 usage_idle=48.2943,usage_system=50.5559,usage_user=26.5713 6740000000000 +cpu,cpu=1 usage_idle=66.6072,usage_system=22.2908,usage_user=4.20946 6741000000000 +cpu,cpu=2 usage_idle=4.47362,usage_system=76.3149,usage_user=91.8362 6742000000000 +cpu,cpu=3 usage_idle=92.3685,usage_system=43.4448,usage_user=25.669 6743000000000 +cpu,cpu=4 usage_idle=18.2239,usage_system=94.3984,usage_user=47.1391 6744000000000 +cpu,cpu=0 usage_idle=94.5864,usage_system=81.2954,usage_user=90.6686 6745000000000 +cpu,cpu=1 usage_idle=14.7123,usage_system=33.004,usage_user=92.16 6746000000000 +cpu,cpu=2 usage_idle=6.43942,usage_system=15.5779,usage_user=13.9218 6747000000000 +cpu,cpu=3 usage_idle=81.3592,usage_system=9.68803,usage_user=40.5855 6748000000000 +cpu,cpu=4 usage_idle=56.5359,usage_system=96.5911,usage_user=89.3766 6749000000000 +cpu,cpu=0 usage_idle=3.90824,usage_system=44.8854,usage_user=39.9326 6750000000000 +cpu,cpu=1 usage_idle=30.4796,usage_system=11.4926,usage_user=62.2233 6751000000000 +cpu,cpu=2 usage_idle=34.689,usage_system=15.9662,usage_user=38.5382 6752000000000 +cpu,cpu=3 usage_idle=26.5252,usage_system=8.33474,usage_user=81.983 6753000000000 +cpu,cpu=4 usage_idle=52.1941,usage_system=26.5586,usage_user=76.3814 6754000000000 +cpu,cpu=0 usage_idle=99.3332,usage_system=21.145,usage_user=57.6768 6755000000000 +cpu,cpu=1 usage_idle=90.0018,usage_system=35.8573,usage_user=90.6809 6756000000000 +cpu,cpu=2 usage_idle=82.1618,usage_system=42.2967,usage_user=6.25878 6757000000000 +cpu,cpu=3 usage_idle=96.0836,usage_system=23.6559,usage_user=15.9468 6758000000000 +cpu,cpu=4 usage_idle=36.6691,usage_system=80.1918,usage_user=12.5379 6759000000000 +cpu,cpu=0 usage_idle=26.0457,usage_system=84.1,usage_user=57.4233 6760000000000 +cpu,cpu=1 usage_idle=65.9783,usage_system=14.5795,usage_user=68.9159 6761000000000 +cpu,cpu=2 usage_idle=28.2017,usage_system=49.2686,usage_user=84.8822 6762000000000 +cpu,cpu=3 usage_idle=66.7399,usage_system=75.7937,usage_user=93.2169 6763000000000 +cpu,cpu=4 usage_idle=48.7229,usage_system=27.9879,usage_user=19.7755 6764000000000 +cpu,cpu=0 usage_idle=25.1043,usage_system=27.3211,usage_user=40.9205 6765000000000 +cpu,cpu=1 usage_idle=82.7811,usage_system=17.3229,usage_user=76.7778 6766000000000 +cpu,cpu=2 usage_idle=73.462,usage_system=99.4846,usage_user=19.0745 6767000000000 +cpu,cpu=3 usage_idle=79.7208,usage_system=95.5682,usage_user=42.7304 6768000000000 +cpu,cpu=4 usage_idle=95.6676,usage_system=32.2373,usage_user=22.9221 6769000000000 +cpu,cpu=0 usage_idle=8.20548,usage_system=58.283,usage_user=7.02213 6770000000000 +cpu,cpu=1 usage_idle=65.6288,usage_system=24.2614,usage_user=21.6017 6771000000000 +cpu,cpu=2 usage_idle=34.5447,usage_system=52.4631,usage_user=70.8702 6772000000000 +cpu,cpu=3 usage_idle=19.4269,usage_system=19.2029,usage_user=46.664 6773000000000 +cpu,cpu=4 usage_idle=12.6438,usage_system=67.9258,usage_user=74.6518 6774000000000 +cpu,cpu=0 usage_idle=32.4193,usage_system=93.0301,usage_user=1.97289 6775000000000 +cpu,cpu=1 usage_idle=73.3399,usage_system=75.8112,usage_user=19.2957 6776000000000 +cpu,cpu=2 usage_idle=50.1177,usage_system=49.2732,usage_user=18.7804 6777000000000 +cpu,cpu=3 usage_idle=69.1922,usage_system=28.994,usage_user=14.3486 6778000000000 +cpu,cpu=4 usage_idle=11.9226,usage_system=24.6615,usage_user=46.5859 6779000000000 +cpu,cpu=0 usage_idle=34.8447,usage_system=32.867,usage_user=4.86889 6780000000000 +cpu,cpu=1 usage_idle=41.8668,usage_system=98.4958,usage_user=29.1303 6781000000000 +cpu,cpu=2 usage_idle=63.4685,usage_system=33.0406,usage_user=81.5933 6782000000000 +cpu,cpu=3 usage_idle=34.3387,usage_system=52.4675,usage_user=0.796269 6783000000000 +cpu,cpu=4 usage_idle=81.0027,usage_system=65.1113,usage_user=68.7221 6784000000000 +cpu,cpu=0 usage_idle=55.6545,usage_system=97.5306,usage_user=61.7522 6785000000000 +cpu,cpu=1 usage_idle=57.6274,usage_system=70.8705,usage_user=37.5634 6786000000000 +cpu,cpu=2 usage_idle=76.9232,usage_system=20.9882,usage_user=86.8366 6787000000000 +cpu,cpu=3 usage_idle=95.7035,usage_system=90.1804,usage_user=15.8306 6788000000000 +cpu,cpu=4 usage_idle=10.0521,usage_system=2.10298,usage_user=40.4921 6789000000000 +cpu,cpu=0 usage_idle=56.6379,usage_system=36.9477,usage_user=73.3591 6790000000000 +cpu,cpu=1 usage_idle=61.5068,usage_system=78.8145,usage_user=71.8549 6791000000000 +cpu,cpu=2 usage_idle=90.6371,usage_system=42.283,usage_user=4.89549 6792000000000 +cpu,cpu=3 usage_idle=72.2304,usage_system=76.6218,usage_user=57.363 6793000000000 +cpu,cpu=4 usage_idle=73.0267,usage_system=57.6245,usage_user=22.4742 6794000000000 +cpu,cpu=0 usage_idle=41.7488,usage_system=13.279,usage_user=20.0048 6795000000000 +cpu,cpu=1 usage_idle=3.50099,usage_system=70.9064,usage_user=90.8753 6796000000000 +cpu,cpu=2 usage_idle=41.0644,usage_system=47.8296,usage_user=11.8636 6797000000000 +cpu,cpu=3 usage_idle=27.9011,usage_system=43.5331,usage_user=2.04396 6798000000000 +cpu,cpu=4 usage_idle=43.7316,usage_system=53.5852,usage_user=4.14694 6799000000000 +cpu,cpu=0 usage_idle=84.2238,usage_system=10.2231,usage_user=41.0946 6800000000000 +cpu,cpu=1 usage_idle=57.5829,usage_system=71.7299,usage_user=19.9092 6801000000000 +cpu,cpu=2 usage_idle=29.4378,usage_system=62.367,usage_user=62.1922 6802000000000 +cpu,cpu=3 usage_idle=34.3333,usage_system=34.5974,usage_user=38.814 6803000000000 +cpu,cpu=4 usage_idle=91.6963,usage_system=7.62401,usage_user=96.4385 6804000000000 +cpu,cpu=0 usage_idle=14.1705,usage_system=49.3728,usage_user=9.71752 6805000000000 +cpu,cpu=1 usage_idle=34.1753,usage_system=52.8738,usage_user=80.624 6806000000000 +cpu,cpu=2 usage_idle=25.0507,usage_system=93.9382,usage_user=28.4536 6807000000000 +cpu,cpu=3 usage_idle=36.9142,usage_system=21.8392,usage_user=71.9867 6808000000000 +cpu,cpu=4 usage_idle=38.9582,usage_system=65.5709,usage_user=25.5718 6809000000000 +cpu,cpu=0 usage_idle=43.1051,usage_system=49.7946,usage_user=35.7949 6810000000000 +cpu,cpu=1 usage_idle=84.1998,usage_system=7.3775,usage_user=7.52481 6811000000000 +cpu,cpu=2 usage_idle=4.10895,usage_system=36.8153,usage_user=69.8918 6812000000000 +cpu,cpu=3 usage_idle=66.3012,usage_system=71.1486,usage_user=4.48913 6813000000000 +cpu,cpu=4 usage_idle=5.11517,usage_system=62.8448,usage_user=12.1131 6814000000000 +cpu,cpu=0 usage_idle=1.55367,usage_system=77.0153,usage_user=61.4859 6815000000000 +cpu,cpu=1 usage_idle=11.2712,usage_system=11.1906,usage_user=14.3597 6816000000000 +cpu,cpu=2 usage_idle=91.8952,usage_system=36.2413,usage_user=8.29787 6817000000000 +cpu,cpu=3 usage_idle=20.3487,usage_system=73.1555,usage_user=30.1371 6818000000000 +cpu,cpu=4 usage_idle=92.3354,usage_system=12.1137,usage_user=95.708 6819000000000 +cpu,cpu=0 usage_idle=17.9072,usage_system=55.2189,usage_user=45.5026 6820000000000 +cpu,cpu=1 usage_idle=53.7021,usage_system=39.4186,usage_user=52.8801 6821000000000 +cpu,cpu=2 usage_idle=61.2269,usage_system=43.5276,usage_user=89.6954 6822000000000 +cpu,cpu=3 usage_idle=31.1187,usage_system=9.82875,usage_user=60.844 6823000000000 +cpu,cpu=4 usage_idle=35.6078,usage_system=14.9439,usage_user=23.6888 6824000000000 +cpu,cpu=0 usage_idle=47.721,usage_system=16.4976,usage_user=0.704168 6825000000000 +cpu,cpu=1 usage_idle=9.2069,usage_system=27.7688,usage_user=11.8948 6826000000000 +cpu,cpu=2 usage_idle=23.5666,usage_system=19.6639,usage_user=48.1361 6827000000000 +cpu,cpu=3 usage_idle=31.8645,usage_system=40.0127,usage_user=21.2917 6828000000000 +cpu,cpu=4 usage_idle=62.0016,usage_system=32.348,usage_user=33.4054 6829000000000 +cpu,cpu=0 usage_idle=57.7096,usage_system=50.2553,usage_user=88.6243 6830000000000 +cpu,cpu=1 usage_idle=3.21217,usage_system=3.95739,usage_user=28.0429 6831000000000 +cpu,cpu=2 usage_idle=56.0923,usage_system=65.1843,usage_user=71.5705 6832000000000 +cpu,cpu=3 usage_idle=45.7877,usage_system=96.303,usage_user=81.3993 6833000000000 +cpu,cpu=4 usage_idle=6.63169,usage_system=31.9109,usage_user=96.3432 6834000000000 +cpu,cpu=0 usage_idle=30.3205,usage_system=79.6319,usage_user=12.8408 6835000000000 +cpu,cpu=1 usage_idle=31.0247,usage_system=88.8388,usage_user=40.6096 6836000000000 +cpu,cpu=2 usage_idle=42.9195,usage_system=12.4053,usage_user=60.2735 6837000000000 +cpu,cpu=3 usage_idle=91.0556,usage_system=44.2698,usage_user=0.286176 6838000000000 +cpu,cpu=4 usage_idle=12.3473,usage_system=6.27136,usage_user=32.6342 6839000000000 +cpu,cpu=0 usage_idle=45.7527,usage_system=63.9809,usage_user=82.8895 6840000000000 +cpu,cpu=1 usage_idle=34.377,usage_system=67.1931,usage_user=86.8469 6841000000000 +cpu,cpu=2 usage_idle=62.4199,usage_system=23.2854,usage_user=52.0312 6842000000000 +cpu,cpu=3 usage_idle=33.9904,usage_system=69.0731,usage_user=48.3342 6843000000000 +cpu,cpu=4 usage_idle=15.3896,usage_system=75.7048,usage_user=80.2451 6844000000000 +cpu,cpu=0 usage_idle=11.7328,usage_system=6.0253,usage_user=59.877 6845000000000 +cpu,cpu=1 usage_idle=24.5736,usage_system=37.05,usage_user=48.7157 6846000000000 +cpu,cpu=2 usage_idle=65.1831,usage_system=79.9695,usage_user=61.1211 6847000000000 +cpu,cpu=3 usage_idle=25.4567,usage_system=71.0252,usage_user=5.39085 6848000000000 +cpu,cpu=4 usage_idle=25.7428,usage_system=83.3725,usage_user=11.6622 6849000000000 +cpu,cpu=0 usage_idle=58.377,usage_system=29.1252,usage_user=75.6431 6850000000000 +cpu,cpu=1 usage_idle=41.2665,usage_system=63.5021,usage_user=42.8362 6851000000000 +cpu,cpu=2 usage_idle=28.1134,usage_system=25.922,usage_user=66.1216 6852000000000 +cpu,cpu=3 usage_idle=80.1446,usage_system=59.9124,usage_user=35.1946 6853000000000 +cpu,cpu=4 usage_idle=28.4788,usage_system=75.302,usage_user=10.8994 6854000000000 +cpu,cpu=0 usage_idle=8.72397,usage_system=87.0348,usage_user=16.9247 6855000000000 +cpu,cpu=1 usage_idle=68.6009,usage_system=11.6084,usage_user=53.9747 6856000000000 +cpu,cpu=2 usage_idle=17.3167,usage_system=76.7915,usage_user=33.9442 6857000000000 +cpu,cpu=3 usage_idle=78.4377,usage_system=2.24819,usage_user=4.9694 6858000000000 +cpu,cpu=4 usage_idle=83.8286,usage_system=27.991,usage_user=88.3419 6859000000000 +cpu,cpu=0 usage_idle=95.4908,usage_system=86.3681,usage_user=17.467 6860000000000 +cpu,cpu=1 usage_idle=71.1339,usage_system=27.6346,usage_user=80.9692 6861000000000 +cpu,cpu=2 usage_idle=13.9701,usage_system=55.748,usage_user=6.8912 6862000000000 +cpu,cpu=3 usage_idle=80.0917,usage_system=35.8926,usage_user=66.8036 6863000000000 +cpu,cpu=4 usage_idle=15.2863,usage_system=64.3715,usage_user=42.1056 6864000000000 +cpu,cpu=0 usage_idle=26.1857,usage_system=73.0954,usage_user=29.1404 6865000000000 +cpu,cpu=1 usage_idle=43.1104,usage_system=41.6964,usage_user=40.7488 6866000000000 +cpu,cpu=2 usage_idle=97.0851,usage_system=59.013,usage_user=17.5403 6867000000000 +cpu,cpu=3 usage_idle=31.0293,usage_system=37.4507,usage_user=19.7885 6868000000000 +cpu,cpu=4 usage_idle=35.9987,usage_system=21.2793,usage_user=47.7796 6869000000000 +cpu,cpu=0 usage_idle=24.3406,usage_system=16.7701,usage_user=34.1476 6870000000000 +cpu,cpu=1 usage_idle=41.8076,usage_system=87.904,usage_user=61.7822 6871000000000 +cpu,cpu=2 usage_idle=22.7768,usage_system=1.87405,usage_user=17.5302 6872000000000 +cpu,cpu=3 usage_idle=29.668,usage_system=81.9657,usage_user=53.4228 6873000000000 +cpu,cpu=4 usage_idle=96.4716,usage_system=97.252,usage_user=17.7943 6874000000000 +cpu,cpu=0 usage_idle=38.5772,usage_system=23.4377,usage_user=90.8897 6875000000000 +cpu,cpu=1 usage_idle=67.7176,usage_system=66.5481,usage_user=32.5861 6876000000000 +cpu,cpu=2 usage_idle=8.46639,usage_system=63.6331,usage_user=91.5991 6877000000000 +cpu,cpu=3 usage_idle=26.0067,usage_system=94.6624,usage_user=29.0498 6878000000000 +cpu,cpu=4 usage_idle=45.7953,usage_system=30.6612,usage_user=50.3292 6879000000000 +cpu,cpu=0 usage_idle=93.5748,usage_system=55.0017,usage_user=67.0992 6880000000000 +cpu,cpu=1 usage_idle=27.7225,usage_system=96.8094,usage_user=55.0032 6881000000000 +cpu,cpu=2 usage_idle=89.5047,usage_system=19.5862,usage_user=56.8773 6882000000000 +cpu,cpu=3 usage_idle=7.0349,usage_system=49.2542,usage_user=38.843 6883000000000 +cpu,cpu=4 usage_idle=60.4577,usage_system=45.7258,usage_user=36.0949 6884000000000 +cpu,cpu=0 usage_idle=78.252,usage_system=84.303,usage_user=59.5326 6885000000000 +cpu,cpu=1 usage_idle=69.1417,usage_system=52.0206,usage_user=26.0807 6886000000000 +cpu,cpu=2 usage_idle=1.72778,usage_system=60.487,usage_user=89.7138 6887000000000 +cpu,cpu=3 usage_idle=93.3269,usage_system=86.4937,usage_user=84.3762 6888000000000 +cpu,cpu=4 usage_idle=22.3767,usage_system=32.289,usage_user=15.0374 6889000000000 +cpu,cpu=0 usage_idle=72.7059,usage_system=25.8638,usage_user=70.0391 6890000000000 +cpu,cpu=1 usage_idle=39.8051,usage_system=53.5862,usage_user=66.8485 6891000000000 +cpu,cpu=2 usage_idle=94.8083,usage_system=43.0909,usage_user=86.4347 6892000000000 +cpu,cpu=3 usage_idle=51.6856,usage_system=50.1258,usage_user=35.6889 6893000000000 +cpu,cpu=4 usage_idle=90.5285,usage_system=10.5835,usage_user=81.4147 6894000000000 +cpu,cpu=0 usage_idle=26.6235,usage_system=88.8356,usage_user=65.7177 6895000000000 +cpu,cpu=1 usage_idle=86.1561,usage_system=57.9773,usage_user=17.7382 6896000000000 +cpu,cpu=2 usage_idle=12.2368,usage_system=59.7051,usage_user=78.2252 6897000000000 +cpu,cpu=3 usage_idle=1.95057,usage_system=53.0319,usage_user=64.7189 6898000000000 +cpu,cpu=4 usage_idle=86.3268,usage_system=75.4087,usage_user=97.0078 6899000000000 +cpu,cpu=0 usage_idle=1.36422,usage_system=48.1145,usage_user=22.8716 6900000000000 +cpu,cpu=1 usage_idle=71.4034,usage_system=87.9196,usage_user=76.4579 6901000000000 +cpu,cpu=2 usage_idle=38.2519,usage_system=82.7279,usage_user=19.5488 6902000000000 +cpu,cpu=3 usage_idle=24.6866,usage_system=34.4135,usage_user=69.6746 6903000000000 +cpu,cpu=4 usage_idle=60.3755,usage_system=24.9421,usage_user=80.2581 6904000000000 +cpu,cpu=0 usage_idle=41.7902,usage_system=51.5655,usage_user=69.0937 6905000000000 +cpu,cpu=1 usage_idle=7.50789,usage_system=37.7216,usage_user=27.071 6906000000000 +cpu,cpu=2 usage_idle=25.2461,usage_system=49.9584,usage_user=86.776 6907000000000 +cpu,cpu=3 usage_idle=3.47129,usage_system=51.909,usage_user=39.808 6908000000000 +cpu,cpu=4 usage_idle=68.1902,usage_system=38.2358,usage_user=15.2166 6909000000000 +cpu,cpu=0 usage_idle=65.198,usage_system=39.6,usage_user=63.3312 6910000000000 +cpu,cpu=1 usage_idle=88.0696,usage_system=11.0034,usage_user=51.2508 6911000000000 +cpu,cpu=2 usage_idle=64.5275,usage_system=49.2553,usage_user=33.9787 6912000000000 +cpu,cpu=3 usage_idle=84.0762,usage_system=73.9419,usage_user=68.3922 6913000000000 +cpu,cpu=4 usage_idle=53.7508,usage_system=34.3174,usage_user=93.3343 6914000000000 +cpu,cpu=0 usage_idle=34.009,usage_system=76.1076,usage_user=44.8998 6915000000000 +cpu,cpu=1 usage_idle=3.10266,usage_system=83.6155,usage_user=82.6215 6916000000000 +cpu,cpu=2 usage_idle=30.1736,usage_system=8.86161,usage_user=32.5798 6917000000000 +cpu,cpu=3 usage_idle=16.9497,usage_system=12.3329,usage_user=84.4888 6918000000000 +cpu,cpu=4 usage_idle=56.7577,usage_system=80.5231,usage_user=22.7246 6919000000000 +cpu,cpu=0 usage_idle=71.9743,usage_system=45.721,usage_user=62.3246 6920000000000 +cpu,cpu=1 usage_idle=35.3055,usage_system=33.7907,usage_user=73.328 6921000000000 +cpu,cpu=2 usage_idle=86.5563,usage_system=98.3181,usage_user=22.5833 6922000000000 +cpu,cpu=3 usage_idle=20.535,usage_system=82.3943,usage_user=96.5251 6923000000000 +cpu,cpu=4 usage_idle=88.9272,usage_system=36.1452,usage_user=30.8425 6924000000000 +cpu,cpu=0 usage_idle=82.2615,usage_system=70.1541,usage_user=6.95014 6925000000000 +cpu,cpu=1 usage_idle=27.1613,usage_system=73.2568,usage_user=90.5656 6926000000000 +cpu,cpu=2 usage_idle=9.78279,usage_system=3.43045,usage_user=99.4273 6927000000000 +cpu,cpu=3 usage_idle=42.3626,usage_system=20.3801,usage_user=11.7602 6928000000000 +cpu,cpu=4 usage_idle=26.8514,usage_system=77.1378,usage_user=92.2832 6929000000000 +cpu,cpu=0 usage_idle=49.576,usage_system=49.1121,usage_user=38.0043 6930000000000 +cpu,cpu=1 usage_idle=11.9006,usage_system=84.4176,usage_user=71.7949 6931000000000 +cpu,cpu=2 usage_idle=85.2286,usage_system=70.9739,usage_user=70.113 6932000000000 +cpu,cpu=3 usage_idle=7.81187,usage_system=91.5088,usage_user=52.5074 6933000000000 +cpu,cpu=4 usage_idle=4.33701,usage_system=80.4361,usage_user=88.6525 6934000000000 +cpu,cpu=0 usage_idle=35.1795,usage_system=62.6976,usage_user=58.8067 6935000000000 +cpu,cpu=1 usage_idle=42.1297,usage_system=89.8589,usage_user=32.0635 6936000000000 +cpu,cpu=2 usage_idle=32.6953,usage_system=99.6417,usage_user=35.4939 6937000000000 +cpu,cpu=3 usage_idle=32.1226,usage_system=42.0043,usage_user=55.8741 6938000000000 +cpu,cpu=4 usage_idle=43.8827,usage_system=68.8558,usage_user=33.0119 6939000000000 +cpu,cpu=0 usage_idle=36.1659,usage_system=18.4318,usage_user=82.124 6940000000000 +cpu,cpu=1 usage_idle=74.1702,usage_system=30.3325,usage_user=66.5417 6941000000000 +cpu,cpu=2 usage_idle=45.9651,usage_system=15.5611,usage_user=37.5155 6942000000000 +cpu,cpu=3 usage_idle=16.0781,usage_system=23.3729,usage_user=29.0244 6943000000000 +cpu,cpu=4 usage_idle=68.5855,usage_system=27.71,usage_user=9.46043 6944000000000 +cpu,cpu=0 usage_idle=57.238,usage_system=62.8895,usage_user=72.158 6945000000000 +cpu,cpu=1 usage_idle=16.0447,usage_system=5.01918,usage_user=62.0169 6946000000000 +cpu,cpu=2 usage_idle=48.1082,usage_system=37.7145,usage_user=61.6586 6947000000000 +cpu,cpu=3 usage_idle=83.6021,usage_system=69.8371,usage_user=3.66296 6948000000000 +cpu,cpu=4 usage_idle=39.4762,usage_system=13.7198,usage_user=72.5187 6949000000000 +cpu,cpu=0 usage_idle=72.4881,usage_system=49.8858,usage_user=90.9506 6950000000000 +cpu,cpu=1 usage_idle=54.6122,usage_system=24.056,usage_user=21.283 6951000000000 +cpu,cpu=2 usage_idle=21.1538,usage_system=70.0211,usage_user=36.8441 6952000000000 +cpu,cpu=3 usage_idle=58.6693,usage_system=86.0992,usage_user=60.217 6953000000000 +cpu,cpu=4 usage_idle=87.6937,usage_system=54.6847,usage_user=87.927 6954000000000 +cpu,cpu=0 usage_idle=97.1541,usage_system=11.9227,usage_user=50.8165 6955000000000 +cpu,cpu=1 usage_idle=69.3121,usage_system=27.9675,usage_user=55.8356 6956000000000 +cpu,cpu=2 usage_idle=31.329,usage_system=76.0757,usage_user=93.5501 6957000000000 +cpu,cpu=3 usage_idle=92.9877,usage_system=59.6778,usage_user=63.3872 6958000000000 +cpu,cpu=4 usage_idle=96.6506,usage_system=99.1541,usage_user=77.107 6959000000000 +cpu,cpu=0 usage_idle=69.1694,usage_system=71.6422,usage_user=26.9928 6960000000000 +cpu,cpu=1 usage_idle=60.1199,usage_system=26.2543,usage_user=51.0488 6961000000000 +cpu,cpu=2 usage_idle=81.4029,usage_system=47.4081,usage_user=21.0698 6962000000000 +cpu,cpu=3 usage_idle=18.247,usage_system=6.07745,usage_user=7.169 6963000000000 +cpu,cpu=4 usage_idle=78.464,usage_system=93.7711,usage_user=61.8537 6964000000000 +cpu,cpu=0 usage_idle=66.391,usage_system=90.9252,usage_user=73.7764 6965000000000 +cpu,cpu=1 usage_idle=17.2074,usage_system=60.2374,usage_user=1.74388 6966000000000 +cpu,cpu=2 usage_idle=73.043,usage_system=91.5664,usage_user=77.8196 6967000000000 +cpu,cpu=3 usage_idle=66.5932,usage_system=84.554,usage_user=37.4974 6968000000000 +cpu,cpu=4 usage_idle=29.9804,usage_system=81.2047,usage_user=36.6514 6969000000000 +cpu,cpu=0 usage_idle=7.08747,usage_system=50.374,usage_user=8.29362 6970000000000 +cpu,cpu=1 usage_idle=34.0803,usage_system=10.4939,usage_user=34.5479 6971000000000 +cpu,cpu=2 usage_idle=85.129,usage_system=91.8968,usage_user=81.9561 6972000000000 +cpu,cpu=3 usage_idle=6.19882,usage_system=10.1438,usage_user=88.0335 6973000000000 +cpu,cpu=4 usage_idle=13.3678,usage_system=88.6078,usage_user=81.8047 6974000000000 +cpu,cpu=0 usage_idle=75.2215,usage_system=54.9987,usage_user=72.7299 6975000000000 +cpu,cpu=1 usage_idle=48.9979,usage_system=72.2062,usage_user=32.9673 6976000000000 +cpu,cpu=2 usage_idle=50.7418,usage_system=45.2492,usage_user=24.5336 6977000000000 +cpu,cpu=3 usage_idle=28.5614,usage_system=11.8424,usage_user=9.0877 6978000000000 +cpu,cpu=4 usage_idle=66.0588,usage_system=41.8228,usage_user=90.2924 6979000000000 +cpu,cpu=0 usage_idle=2.71022,usage_system=48.9103,usage_user=40.6664 6980000000000 +cpu,cpu=1 usage_idle=11.0038,usage_system=82.9905,usage_user=51.1603 6981000000000 +cpu,cpu=2 usage_idle=45.5518,usage_system=68.1196,usage_user=43.0571 6982000000000 +cpu,cpu=3 usage_idle=27.5078,usage_system=74.3184,usage_user=53.2009 6983000000000 +cpu,cpu=4 usage_idle=15.5414,usage_system=87.6862,usage_user=41.8087 6984000000000 +cpu,cpu=0 usage_idle=97.346,usage_system=62.9077,usage_user=96.8075 6985000000000 +cpu,cpu=1 usage_idle=70.0759,usage_system=11.9056,usage_user=69.0136 6986000000000 +cpu,cpu=2 usage_idle=3.04317,usage_system=62.6474,usage_user=14.2628 6987000000000 +cpu,cpu=3 usage_idle=27.5768,usage_system=91.2088,usage_user=26.1052 6988000000000 +cpu,cpu=4 usage_idle=36.6645,usage_system=57.2676,usage_user=67.928 6989000000000 +cpu,cpu=0 usage_idle=26.9569,usage_system=59.9778,usage_user=16.8383 6990000000000 +cpu,cpu=1 usage_idle=67.6233,usage_system=70.9816,usage_user=99.8288 6991000000000 +cpu,cpu=2 usage_idle=18.7836,usage_system=16.5334,usage_user=67.9484 6992000000000 +cpu,cpu=3 usage_idle=61.8407,usage_system=44.0412,usage_user=42.2668 6993000000000 +cpu,cpu=4 usage_idle=15.0416,usage_system=59.5826,usage_user=29.953 6994000000000 +cpu,cpu=0 usage_idle=56.8503,usage_system=56.9286,usage_user=92.8607 6995000000000 +cpu,cpu=1 usage_idle=53.6578,usage_system=27.0046,usage_user=4.76632 6996000000000 +cpu,cpu=2 usage_idle=22.6714,usage_system=30.0477,usage_user=67.4137 6997000000000 +cpu,cpu=3 usage_idle=36.9342,usage_system=57.6245,usage_user=58.6225 6998000000000 +cpu,cpu=4 usage_idle=63.0394,usage_system=94.2891,usage_user=15.8901 6999000000000 +cpu,cpu=0 usage_idle=30.9674,usage_system=21.2459,usage_user=75.8679 7000000000000 +cpu,cpu=1 usage_idle=47.8057,usage_system=88.8692,usage_user=46.8495 7001000000000 +cpu,cpu=2 usage_idle=47.6346,usage_system=7.65276,usage_user=63.3829 7002000000000 +cpu,cpu=3 usage_idle=15.583,usage_system=69.4934,usage_user=7.42413 7003000000000 +cpu,cpu=4 usage_idle=57.8498,usage_system=84.535,usage_user=67.0067 7004000000000 +cpu,cpu=0 usage_idle=87.8028,usage_system=41.3854,usage_user=23.9354 7005000000000 +cpu,cpu=1 usage_idle=80.6635,usage_system=95.0431,usage_user=50.9399 7006000000000 +cpu,cpu=2 usage_idle=85.4298,usage_system=17.7145,usage_user=80.9876 7007000000000 +cpu,cpu=3 usage_idle=52.8435,usage_system=54.6487,usage_user=38.6122 7008000000000 +cpu,cpu=4 usage_idle=11.466,usage_system=17.6881,usage_user=32.9013 7009000000000 +cpu,cpu=0 usage_idle=27.3561,usage_system=48.6556,usage_user=54.1472 7010000000000 +cpu,cpu=1 usage_idle=3.22403,usage_system=96.4613,usage_user=43.0164 7011000000000 +cpu,cpu=2 usage_idle=50.0735,usage_system=44.0959,usage_user=50.6692 7012000000000 +cpu,cpu=3 usage_idle=13.4564,usage_system=59.6788,usage_user=20.1626 7013000000000 +cpu,cpu=4 usage_idle=20.8805,usage_system=17.5286,usage_user=4.69766 7014000000000 +cpu,cpu=0 usage_idle=87.8873,usage_system=5.33137,usage_user=46.083 7015000000000 +cpu,cpu=1 usage_idle=11.8227,usage_system=85.9948,usage_user=41.1261 7016000000000 +cpu,cpu=2 usage_idle=62.7626,usage_system=71.4246,usage_user=58.8407 7017000000000 +cpu,cpu=3 usage_idle=43.7502,usage_system=24.2681,usage_user=13.4894 7018000000000 +cpu,cpu=4 usage_idle=82.3624,usage_system=35.7342,usage_user=31.1775 7019000000000 +cpu,cpu=0 usage_idle=15.2637,usage_system=63.0903,usage_user=79.8331 7020000000000 +cpu,cpu=1 usage_idle=69.4109,usage_system=66.3143,usage_user=76.2944 7021000000000 +cpu,cpu=2 usage_idle=12.4273,usage_system=16.3879,usage_user=20.3902 7022000000000 +cpu,cpu=3 usage_idle=63.0965,usage_system=29.8443,usage_user=80.0691 7023000000000 +cpu,cpu=4 usage_idle=83.2591,usage_system=50.7248,usage_user=97.5977 7024000000000 +cpu,cpu=0 usage_idle=87.9568,usage_system=38.6121,usage_user=2.92904 7025000000000 +cpu,cpu=1 usage_idle=34.0398,usage_system=50.4348,usage_user=88.9239 7026000000000 +cpu,cpu=2 usage_idle=75.1659,usage_system=13.1973,usage_user=60.3485 7027000000000 +cpu,cpu=3 usage_idle=34.0066,usage_system=56.9476,usage_user=84.6166 7028000000000 +cpu,cpu=4 usage_idle=47.496,usage_system=39.31,usage_user=20.3507 7029000000000 +cpu,cpu=0 usage_idle=78.6735,usage_system=54.5737,usage_user=83.441 7030000000000 +cpu,cpu=1 usage_idle=58.5066,usage_system=23.9846,usage_user=49.7554 7031000000000 +cpu,cpu=2 usage_idle=34.8009,usage_system=36.4119,usage_user=66.1432 7032000000000 +cpu,cpu=3 usage_idle=55.1911,usage_system=99.5084,usage_user=95.9875 7033000000000 +cpu,cpu=4 usage_idle=35.2602,usage_system=82.7675,usage_user=46.7123 7034000000000 +cpu,cpu=0 usage_idle=32.8579,usage_system=70.7243,usage_user=85.3244 7035000000000 +cpu,cpu=1 usage_idle=35.7869,usage_system=4.76409,usage_user=35.7592 7036000000000 +cpu,cpu=2 usage_idle=24.7108,usage_system=79.93,usage_user=48.9565 7037000000000 +cpu,cpu=3 usage_idle=85.0592,usage_system=13.9366,usage_user=5.90407 7038000000000 +cpu,cpu=4 usage_idle=69.6758,usage_system=61.4326,usage_user=45.2141 7039000000000 +cpu,cpu=0 usage_idle=90.0266,usage_system=40.1061,usage_user=99.7878 7040000000000 +cpu,cpu=1 usage_idle=73.4676,usage_system=98.6126,usage_user=23.7723 7041000000000 +cpu,cpu=2 usage_idle=23.223,usage_system=33.4136,usage_user=60.1843 7042000000000 +cpu,cpu=3 usage_idle=89.3662,usage_system=88.6047,usage_user=59.6927 7043000000000 +cpu,cpu=4 usage_idle=85.3537,usage_system=23.8649,usage_user=42.4602 7044000000000 +cpu,cpu=0 usage_idle=32.066,usage_system=56.7228,usage_user=13.1845 7045000000000 +cpu,cpu=1 usage_idle=17.3904,usage_system=92.5097,usage_user=17.9486 7046000000000 +cpu,cpu=2 usage_idle=53.1496,usage_system=17.2205,usage_user=97.8786 7047000000000 +cpu,cpu=3 usage_idle=2.10611,usage_system=2.27971,usage_user=11.8152 7048000000000 +cpu,cpu=4 usage_idle=8.01017,usage_system=71.9555,usage_user=73.2478 7049000000000 +cpu,cpu=0 usage_idle=53.2242,usage_system=61.9821,usage_user=13.3539 7050000000000 +cpu,cpu=1 usage_idle=53.012,usage_system=35.4497,usage_user=11.9665 7051000000000 +cpu,cpu=2 usage_idle=76.7843,usage_system=58.6727,usage_user=45.38 7052000000000 +cpu,cpu=3 usage_idle=36.9686,usage_system=48.0389,usage_user=33.9847 7053000000000 +cpu,cpu=4 usage_idle=96.6613,usage_system=33.3926,usage_user=57.8496 7054000000000 +cpu,cpu=0 usage_idle=39.1215,usage_system=65.4587,usage_user=14.5724 7055000000000 +cpu,cpu=1 usage_idle=52.306,usage_system=82.8491,usage_user=7.08209 7056000000000 +cpu,cpu=2 usage_idle=70.2545,usage_system=35.9987,usage_user=24.3026 7057000000000 +cpu,cpu=3 usage_idle=68.1332,usage_system=38.1048,usage_user=26.5823 7058000000000 +cpu,cpu=4 usage_idle=79.9484,usage_system=46.115,usage_user=98.5378 7059000000000 +cpu,cpu=0 usage_idle=53.1962,usage_system=99.3392,usage_user=60.5199 7060000000000 +cpu,cpu=1 usage_idle=66.55,usage_system=52.3512,usage_user=95.9696 7061000000000 +cpu,cpu=2 usage_idle=78.5165,usage_system=29.1355,usage_user=54.6423 7062000000000 +cpu,cpu=3 usage_idle=23.8966,usage_system=66.1041,usage_user=2.68116 7063000000000 +cpu,cpu=4 usage_idle=57.8813,usage_system=62.7654,usage_user=36.0738 7064000000000 +cpu,cpu=0 usage_idle=15.7309,usage_system=1.88682,usage_user=1.53244 7065000000000 +cpu,cpu=1 usage_idle=30.3033,usage_system=54.1928,usage_user=84.3815 7066000000000 +cpu,cpu=2 usage_idle=37.3854,usage_system=24.4473,usage_user=20.3803 7067000000000 +cpu,cpu=3 usage_idle=61.688,usage_system=92.5805,usage_user=58.4851 7068000000000 +cpu,cpu=4 usage_idle=88.2702,usage_system=72.5288,usage_user=4.60008 7069000000000 +cpu,cpu=0 usage_idle=86.8081,usage_system=25.725,usage_user=3.9393 7070000000000 +cpu,cpu=1 usage_idle=47.3279,usage_system=92.275,usage_user=56.2905 7071000000000 +cpu,cpu=2 usage_idle=43.2975,usage_system=70.7915,usage_user=85.426 7072000000000 +cpu,cpu=3 usage_idle=97.9398,usage_system=94.6881,usage_user=51.5302 7073000000000 +cpu,cpu=4 usage_idle=0.620946,usage_system=52.5693,usage_user=14.2955 7074000000000 +cpu,cpu=0 usage_idle=36.6947,usage_system=68.3003,usage_user=16.1824 7075000000000 +cpu,cpu=1 usage_idle=38.2272,usage_system=98.6036,usage_user=70.3751 7076000000000 +cpu,cpu=2 usage_idle=22.6087,usage_system=35.989,usage_user=94.8225 7077000000000 +cpu,cpu=3 usage_idle=42.989,usage_system=97.677,usage_user=87.4029 7078000000000 +cpu,cpu=4 usage_idle=1.47406,usage_system=85.9472,usage_user=59.9318 7079000000000 +cpu,cpu=0 usage_idle=6.07414,usage_system=72.7553,usage_user=85.6568 7080000000000 +cpu,cpu=1 usage_idle=10.0134,usage_system=20.0832,usage_user=77.9318 7081000000000 +cpu,cpu=2 usage_idle=66.304,usage_system=63.3808,usage_user=48.7233 7082000000000 +cpu,cpu=3 usage_idle=51.73,usage_system=61.3206,usage_user=43.4113 7083000000000 +cpu,cpu=4 usage_idle=3.26018,usage_system=61.9415,usage_user=95.9807 7084000000000 +cpu,cpu=0 usage_idle=17.5557,usage_system=98.6362,usage_user=64.281 7085000000000 +cpu,cpu=1 usage_idle=33.7381,usage_system=36.8634,usage_user=62.8846 7086000000000 +cpu,cpu=2 usage_idle=4.11322,usage_system=59.4721,usage_user=98.8736 7087000000000 +cpu,cpu=3 usage_idle=98.9357,usage_system=2.46109,usage_user=96.5506 7088000000000 +cpu,cpu=4 usage_idle=86.3386,usage_system=3.93515,usage_user=82.4978 7089000000000 +cpu,cpu=0 usage_idle=46.2704,usage_system=10.0093,usage_user=55.2531 7090000000000 +cpu,cpu=1 usage_idle=31.9272,usage_system=20.0227,usage_user=75.3364 7091000000000 +cpu,cpu=2 usage_idle=9.85895,usage_system=86.3267,usage_user=38.7172 7092000000000 +cpu,cpu=3 usage_idle=58.5822,usage_system=38.0567,usage_user=0.0377197 7093000000000 +cpu,cpu=4 usage_idle=1.99358,usage_system=41.3169,usage_user=61.9792 7094000000000 +cpu,cpu=0 usage_idle=97.9743,usage_system=58.8726,usage_user=60.6155 7095000000000 +cpu,cpu=1 usage_idle=62.2552,usage_system=92.6107,usage_user=97.4789 7096000000000 +cpu,cpu=2 usage_idle=25.1398,usage_system=96.7239,usage_user=56.951 7097000000000 +cpu,cpu=3 usage_idle=24.0134,usage_system=95.6596,usage_user=59.4121 7098000000000 +cpu,cpu=4 usage_idle=20.564,usage_system=81.9982,usage_user=63.3472 7099000000000 +cpu,cpu=0 usage_idle=3.0618,usage_system=28.2686,usage_user=73.3565 7100000000000 +cpu,cpu=1 usage_idle=58.3149,usage_system=60.1958,usage_user=93.3792 7101000000000 +cpu,cpu=2 usage_idle=33.6513,usage_system=70.0547,usage_user=79.7059 7102000000000 +cpu,cpu=3 usage_idle=72.3685,usage_system=28.637,usage_user=17.7626 7103000000000 +cpu,cpu=4 usage_idle=72.4062,usage_system=30.6306,usage_user=59.0795 7104000000000 +cpu,cpu=0 usage_idle=34.3854,usage_system=28.6048,usage_user=17.9521 7105000000000 +cpu,cpu=1 usage_idle=95.0009,usage_system=90.8601,usage_user=10.5628 7106000000000 +cpu,cpu=2 usage_idle=92.4798,usage_system=15.9999,usage_user=7.28667 7107000000000 +cpu,cpu=3 usage_idle=49.4307,usage_system=40.0133,usage_user=2.94625 7108000000000 +cpu,cpu=4 usage_idle=8.84281,usage_system=60.5772,usage_user=84.9445 7109000000000 +cpu,cpu=0 usage_idle=72.19,usage_system=63.639,usage_user=13.2131 7110000000000 +cpu,cpu=1 usage_idle=45.5466,usage_system=21.954,usage_user=73.4089 7111000000000 +cpu,cpu=2 usage_idle=38.9258,usage_system=55.6053,usage_user=43.4636 7112000000000 +cpu,cpu=3 usage_idle=18.6317,usage_system=27.9737,usage_user=72.1006 7113000000000 +cpu,cpu=4 usage_idle=36.3944,usage_system=0.379902,usage_user=2.73115 7114000000000 +cpu,cpu=0 usage_idle=95.4739,usage_system=34.7653,usage_user=31.336 7115000000000 +cpu,cpu=1 usage_idle=13.426,usage_system=29.7662,usage_user=22.196 7116000000000 +cpu,cpu=2 usage_idle=23.9888,usage_system=22.2459,usage_user=38.1959 7117000000000 +cpu,cpu=3 usage_idle=31.2754,usage_system=71.6767,usage_user=78.2092 7118000000000 +cpu,cpu=4 usage_idle=34.2217,usage_system=80.5195,usage_user=38.7864 7119000000000 +cpu,cpu=0 usage_idle=19.1661,usage_system=52.7095,usage_user=2.42547 7120000000000 +cpu,cpu=1 usage_idle=32.3792,usage_system=98.2561,usage_user=24.3794 7121000000000 +cpu,cpu=2 usage_idle=5.7881,usage_system=37.1819,usage_user=79.9847 7122000000000 +cpu,cpu=3 usage_idle=49.2517,usage_system=55.8136,usage_user=7.95843 7123000000000 +cpu,cpu=4 usage_idle=21.3523,usage_system=92.208,usage_user=8.33833 7124000000000 +cpu,cpu=0 usage_idle=24.0835,usage_system=87.6819,usage_user=43.1036 7125000000000 +cpu,cpu=1 usage_idle=55.4194,usage_system=1.1079,usage_user=72.8698 7126000000000 +cpu,cpu=2 usage_idle=77.6155,usage_system=25.0967,usage_user=95.1158 7127000000000 +cpu,cpu=3 usage_idle=15.8114,usage_system=56.3721,usage_user=66.7924 7128000000000 +cpu,cpu=4 usage_idle=94.0206,usage_system=90.5938,usage_user=47.3119 7129000000000 +cpu,cpu=0 usage_idle=32.807,usage_system=9.75994,usage_user=0.0214639 7130000000000 +cpu,cpu=1 usage_idle=35.2325,usage_system=42.1392,usage_user=98.2775 7131000000000 +cpu,cpu=2 usage_idle=59.6119,usage_system=47.9273,usage_user=35.4594 7132000000000 +cpu,cpu=3 usage_idle=39.5966,usage_system=97.179,usage_user=91.273 7133000000000 +cpu,cpu=4 usage_idle=47.5551,usage_system=18.5313,usage_user=83.481 7134000000000 +cpu,cpu=0 usage_idle=55.8934,usage_system=42.6148,usage_user=71.1629 7135000000000 +cpu,cpu=1 usage_idle=98.997,usage_system=98.0342,usage_user=72.2708 7136000000000 +cpu,cpu=2 usage_idle=71.8669,usage_system=75.6497,usage_user=97.3675 7137000000000 +cpu,cpu=3 usage_idle=66.9826,usage_system=91.4611,usage_user=53.7396 7138000000000 +cpu,cpu=4 usage_idle=33.7751,usage_system=85.4817,usage_user=44.3334 7139000000000 +cpu,cpu=0 usage_idle=81.087,usage_system=18.2888,usage_user=54.0933 7140000000000 +cpu,cpu=1 usage_idle=81.1085,usage_system=53.5213,usage_user=96.2325 7141000000000 +cpu,cpu=2 usage_idle=79.386,usage_system=13.1332,usage_user=44.1598 7142000000000 +cpu,cpu=3 usage_idle=14.8455,usage_system=52.7298,usage_user=41.3387 7143000000000 +cpu,cpu=4 usage_idle=6.1185,usage_system=0.284902,usage_user=59.87 7144000000000 +cpu,cpu=0 usage_idle=89.5995,usage_system=56.1783,usage_user=2.48482 7145000000000 +cpu,cpu=1 usage_idle=60.7625,usage_system=55.1753,usage_user=0.519032 7146000000000 +cpu,cpu=2 usage_idle=33.0333,usage_system=27.0422,usage_user=76.1687 7147000000000 +cpu,cpu=3 usage_idle=30.4008,usage_system=94.0248,usage_user=67.6299 7148000000000 +cpu,cpu=4 usage_idle=84.1404,usage_system=27.7999,usage_user=53.1116 7149000000000 +cpu,cpu=0 usage_idle=28.4738,usage_system=8.88697,usage_user=71.4004 7150000000000 +cpu,cpu=1 usage_idle=82.5672,usage_system=89.9955,usage_user=24.9216 7151000000000 +cpu,cpu=2 usage_idle=78.7997,usage_system=69.3815,usage_user=38.0548 7152000000000 +cpu,cpu=3 usage_idle=22.9594,usage_system=84.227,usage_user=90.7847 7153000000000 +cpu,cpu=4 usage_idle=64.2982,usage_system=90.3455,usage_user=91.0696 7154000000000 +cpu,cpu=0 usage_idle=24.1682,usage_system=79.945,usage_user=47.2479 7155000000000 +cpu,cpu=1 usage_idle=26.653,usage_system=40.7075,usage_user=2.42322 7156000000000 +cpu,cpu=2 usage_idle=27.1721,usage_system=73.7408,usage_user=29.4654 7157000000000 +cpu,cpu=3 usage_idle=3.3408,usage_system=4.14161,usage_user=23.4903 7158000000000 +cpu,cpu=4 usage_idle=70.9707,usage_system=88.282,usage_user=51.2902 7159000000000 +cpu,cpu=0 usage_idle=24.0823,usage_system=16.7559,usage_user=60.1772 7160000000000 +cpu,cpu=1 usage_idle=95.4827,usage_system=99.323,usage_user=50.1727 7161000000000 +cpu,cpu=2 usage_idle=20.4043,usage_system=78.1227,usage_user=19.5542 7162000000000 +cpu,cpu=3 usage_idle=58.4592,usage_system=1.08208,usage_user=3.78112 7163000000000 +cpu,cpu=4 usage_idle=49.2438,usage_system=65.3802,usage_user=94.1266 7164000000000 +cpu,cpu=0 usage_idle=40.3134,usage_system=89.5485,usage_user=74.0716 7165000000000 +cpu,cpu=1 usage_idle=87.5613,usage_system=16.2015,usage_user=14.779 7166000000000 +cpu,cpu=2 usage_idle=89.9845,usage_system=43.3736,usage_user=88.5198 7167000000000 +cpu,cpu=3 usage_idle=19.45,usage_system=46.7144,usage_user=92.6614 7168000000000 +cpu,cpu=4 usage_idle=42.9403,usage_system=17.685,usage_user=80.9434 7169000000000 +cpu,cpu=0 usage_idle=94.2305,usage_system=41.7673,usage_user=97.6993 7170000000000 +cpu,cpu=1 usage_idle=54.4077,usage_system=37.25,usage_user=97.0223 7171000000000 +cpu,cpu=2 usage_idle=4.58033,usage_system=57.6543,usage_user=75.145 7172000000000 +cpu,cpu=3 usage_idle=24.1345,usage_system=16.1135,usage_user=76.2271 7173000000000 +cpu,cpu=4 usage_idle=27.9156,usage_system=65.3573,usage_user=41.6073 7174000000000 +cpu,cpu=0 usage_idle=22.0422,usage_system=5.67075,usage_user=31.1558 7175000000000 +cpu,cpu=1 usage_idle=96.1137,usage_system=93.2321,usage_user=47.3573 7176000000000 +cpu,cpu=2 usage_idle=10.8928,usage_system=83.2166,usage_user=90.7308 7177000000000 +cpu,cpu=3 usage_idle=99.4126,usage_system=2.6666,usage_user=37.4452 7178000000000 +cpu,cpu=4 usage_idle=92.074,usage_system=45.6069,usage_user=55.1302 7179000000000 +cpu,cpu=0 usage_idle=73.0174,usage_system=39.8373,usage_user=96.8975 7180000000000 +cpu,cpu=1 usage_idle=70.7167,usage_system=94.245,usage_user=34.1475 7181000000000 +cpu,cpu=2 usage_idle=67.7391,usage_system=98.8253,usage_user=91.8018 7182000000000 +cpu,cpu=3 usage_idle=42.884,usage_system=22.9598,usage_user=7.91527 7183000000000 +cpu,cpu=4 usage_idle=19.1111,usage_system=50.8754,usage_user=73.2726 7184000000000 +cpu,cpu=0 usage_idle=60.7184,usage_system=72.9176,usage_user=78.9433 7185000000000 +cpu,cpu=1 usage_idle=91.8742,usage_system=69.0314,usage_user=72.1754 7186000000000 +cpu,cpu=2 usage_idle=39.2314,usage_system=79.9241,usage_user=55.392 7187000000000 +cpu,cpu=3 usage_idle=29.9623,usage_system=79.3367,usage_user=58.0586 7188000000000 +cpu,cpu=4 usage_idle=67.4074,usage_system=71.4107,usage_user=3.66548 7189000000000 +cpu,cpu=0 usage_idle=22.5376,usage_system=44.4281,usage_user=43.5028 7190000000000 +cpu,cpu=1 usage_idle=19.4351,usage_system=15.1449,usage_user=37.7478 7191000000000 +cpu,cpu=2 usage_idle=53.5827,usage_system=82.884,usage_user=36.5732 7192000000000 +cpu,cpu=3 usage_idle=45.3845,usage_system=25.768,usage_user=59.533 7193000000000 +cpu,cpu=4 usage_idle=53.2997,usage_system=44.8791,usage_user=10.4084 7194000000000 +cpu,cpu=0 usage_idle=26.5723,usage_system=5.59751,usage_user=83.326 7195000000000 +cpu,cpu=1 usage_idle=5.51565,usage_system=97.4717,usage_user=52.3574 7196000000000 +cpu,cpu=2 usage_idle=77.6911,usage_system=36.7031,usage_user=32.2815 7197000000000 +cpu,cpu=3 usage_idle=33.0831,usage_system=66.6654,usage_user=11.6182 7198000000000 +cpu,cpu=4 usage_idle=91.1417,usage_system=34.0728,usage_user=83.0289 7199000000000 +cpu,cpu=0 usage_idle=94.8072,usage_system=56.6105,usage_user=27.4571 7200000000000 +cpu,cpu=1 usage_idle=38.31,usage_system=76.0456,usage_user=42.6019 7201000000000 +cpu,cpu=2 usage_idle=76.0578,usage_system=29.6283,usage_user=25.4859 7202000000000 +cpu,cpu=3 usage_idle=12.631,usage_system=75.0127,usage_user=51.2539 7203000000000 +cpu,cpu=4 usage_idle=72.1639,usage_system=28.3124,usage_user=96.133 7204000000000 +cpu,cpu=0 usage_idle=82.5724,usage_system=54.8848,usage_user=1.7305 7205000000000 +cpu,cpu=1 usage_idle=65.8984,usage_system=60.4004,usage_user=99.2022 7206000000000 +cpu,cpu=2 usage_idle=18.2558,usage_system=38.0915,usage_user=35.9053 7207000000000 +cpu,cpu=3 usage_idle=50.5373,usage_system=71.1746,usage_user=2.57074 7208000000000 +cpu,cpu=4 usage_idle=62.1555,usage_system=62.3163,usage_user=36.6436 7209000000000 +cpu,cpu=0 usage_idle=45.1844,usage_system=57.1235,usage_user=93.254 7210000000000 +cpu,cpu=1 usage_idle=72.6415,usage_system=95.4335,usage_user=69.2996 7211000000000 +cpu,cpu=2 usage_idle=15.2434,usage_system=71.4913,usage_user=98.9279 7212000000000 +cpu,cpu=3 usage_idle=40.7293,usage_system=84.1222,usage_user=73.9406 7213000000000 +cpu,cpu=4 usage_idle=91.9832,usage_system=56.2862,usage_user=2.25304 7214000000000 +cpu,cpu=0 usage_idle=88.1162,usage_system=38.8585,usage_user=57.1378 7215000000000 +cpu,cpu=1 usage_idle=89.8467,usage_system=4.75693,usage_user=17.5382 7216000000000 +cpu,cpu=2 usage_idle=89.0489,usage_system=23.0127,usage_user=55.6297 7217000000000 +cpu,cpu=3 usage_idle=24.9542,usage_system=73.5501,usage_user=26.8043 7218000000000 +cpu,cpu=4 usage_idle=27.525,usage_system=35.7056,usage_user=89.1205 7219000000000 +cpu,cpu=0 usage_idle=64.1685,usage_system=80.89,usage_user=46.244 7220000000000 +cpu,cpu=1 usage_idle=57.4226,usage_system=53.5315,usage_user=41.6775 7221000000000 +cpu,cpu=2 usage_idle=26.7222,usage_system=68.775,usage_user=13.1687 7222000000000 +cpu,cpu=3 usage_idle=25.6501,usage_system=9.50432,usage_user=97.291 7223000000000 +cpu,cpu=4 usage_idle=99.5907,usage_system=1.48754,usage_user=53.5771 7224000000000 +cpu,cpu=0 usage_idle=1.8437,usage_system=89.6038,usage_user=92.4356 7225000000000 +cpu,cpu=1 usage_idle=58.9815,usage_system=79.4505,usage_user=97.1926 7226000000000 +cpu,cpu=2 usage_idle=76.5197,usage_system=68.4994,usage_user=20.2053 7227000000000 +cpu,cpu=3 usage_idle=32.1494,usage_system=93.4536,usage_user=93.7553 7228000000000 +cpu,cpu=4 usage_idle=58.9537,usage_system=20.9786,usage_user=29.4609 7229000000000 +cpu,cpu=0 usage_idle=48.0743,usage_system=85.1471,usage_user=10.351 7230000000000 +cpu,cpu=1 usage_idle=94.3183,usage_system=42.5697,usage_user=63.8825 7231000000000 +cpu,cpu=2 usage_idle=35.9957,usage_system=69.2919,usage_user=32.6575 7232000000000 +cpu,cpu=3 usage_idle=49.1645,usage_system=94.9419,usage_user=42.1618 7233000000000 +cpu,cpu=4 usage_idle=46.4554,usage_system=94.5326,usage_user=43.6494 7234000000000 +cpu,cpu=0 usage_idle=0.0325315,usage_system=96.3763,usage_user=33.2531 7235000000000 +cpu,cpu=1 usage_idle=92.4682,usage_system=55.3578,usage_user=12.7036 7236000000000 +cpu,cpu=2 usage_idle=89.6607,usage_system=31.8775,usage_user=81.203 7237000000000 +cpu,cpu=3 usage_idle=9.86602,usage_system=64.0269,usage_user=74.6566 7238000000000 +cpu,cpu=4 usage_idle=3.62136,usage_system=22.9806,usage_user=95.6352 7239000000000 +cpu,cpu=0 usage_idle=33.0823,usage_system=71.0549,usage_user=80.7823 7240000000000 +cpu,cpu=1 usage_idle=43.4333,usage_system=65.3732,usage_user=23.352 7241000000000 +cpu,cpu=2 usage_idle=7.31581,usage_system=1.36889,usage_user=92.6438 7242000000000 +cpu,cpu=3 usage_idle=39.9733,usage_system=50.5334,usage_user=87.5857 7243000000000 +cpu,cpu=4 usage_idle=82.1352,usage_system=96.9888,usage_user=82.1183 7244000000000 +cpu,cpu=0 usage_idle=25.7845,usage_system=97.0213,usage_user=78.4946 7245000000000 +cpu,cpu=1 usage_idle=59.0377,usage_system=89.4895,usage_user=33.8523 7246000000000 +cpu,cpu=2 usage_idle=71.7413,usage_system=79.1502,usage_user=65.7298 7247000000000 +cpu,cpu=3 usage_idle=52.9442,usage_system=89.0162,usage_user=29.7568 7248000000000 +cpu,cpu=4 usage_idle=27.6008,usage_system=92.6376,usage_user=52.7374 7249000000000 +cpu,cpu=0 usage_idle=23.236,usage_system=25.7199,usage_user=23.7923 7250000000000 +cpu,cpu=1 usage_idle=4.01826,usage_system=69.1532,usage_user=89.1654 7251000000000 +cpu,cpu=2 usage_idle=27.3702,usage_system=76.469,usage_user=90.5343 7252000000000 +cpu,cpu=3 usage_idle=20.014,usage_system=16.4423,usage_user=41.0677 7253000000000 +cpu,cpu=4 usage_idle=7.59977,usage_system=98.5774,usage_user=38.0564 7254000000000 +cpu,cpu=0 usage_idle=89.7181,usage_system=24.362,usage_user=35.0777 7255000000000 +cpu,cpu=1 usage_idle=68.2126,usage_system=83.3996,usage_user=24.5672 7256000000000 +cpu,cpu=2 usage_idle=2.06493,usage_system=55.1409,usage_user=3.7174 7257000000000 +cpu,cpu=3 usage_idle=67.7947,usage_system=8.08512,usage_user=92.7336 7258000000000 +cpu,cpu=4 usage_idle=97.5515,usage_system=35.6859,usage_user=85.3712 7259000000000 +cpu,cpu=0 usage_idle=50.2889,usage_system=58.9219,usage_user=11.0911 7260000000000 +cpu,cpu=1 usage_idle=74.0812,usage_system=62.9402,usage_user=80.2442 7261000000000 +cpu,cpu=2 usage_idle=63.2466,usage_system=90.3104,usage_user=56.7132 7262000000000 +cpu,cpu=3 usage_idle=53.7809,usage_system=10.3244,usage_user=73.1555 7263000000000 +cpu,cpu=4 usage_idle=94.8486,usage_system=17.9242,usage_user=71.7329 7264000000000 +cpu,cpu=0 usage_idle=32.905,usage_system=7.64225,usage_user=96.0949 7265000000000 +cpu,cpu=1 usage_idle=67.9828,usage_system=75.8549,usage_user=79.4945 7266000000000 +cpu,cpu=2 usage_idle=92.55,usage_system=77.9198,usage_user=34.6354 7267000000000 +cpu,cpu=3 usage_idle=96.2674,usage_system=45.7145,usage_user=42.7206 7268000000000 +cpu,cpu=4 usage_idle=89.001,usage_system=43.266,usage_user=78.4065 7269000000000 +cpu,cpu=0 usage_idle=74.3722,usage_system=93.5549,usage_user=37.3284 7270000000000 +cpu,cpu=1 usage_idle=85.4632,usage_system=67.6361,usage_user=0.26856 7271000000000 +cpu,cpu=2 usage_idle=65.7074,usage_system=30.8827,usage_user=90.5789 7272000000000 +cpu,cpu=3 usage_idle=22.4206,usage_system=84.6636,usage_user=0.903378 7273000000000 +cpu,cpu=4 usage_idle=95.5761,usage_system=79.5122,usage_user=18.8276 7274000000000 +cpu,cpu=0 usage_idle=67.309,usage_system=12.4173,usage_user=26.4698 7275000000000 +cpu,cpu=1 usage_idle=63.4039,usage_system=80.4,usage_user=2.32469 7276000000000 +cpu,cpu=2 usage_idle=42.8985,usage_system=72.95,usage_user=80.2445 7277000000000 +cpu,cpu=3 usage_idle=77.5339,usage_system=69.2174,usage_user=25.959 7278000000000 +cpu,cpu=4 usage_idle=20.2545,usage_system=58.2184,usage_user=69.2251 7279000000000 +cpu,cpu=0 usage_idle=98.6609,usage_system=32.5905,usage_user=62.78 7280000000000 +cpu,cpu=1 usage_idle=35.9893,usage_system=18.0537,usage_user=30.4161 7281000000000 +cpu,cpu=2 usage_idle=36.2579,usage_system=83.7612,usage_user=61.2988 7282000000000 +cpu,cpu=3 usage_idle=26.8368,usage_system=6.18179,usage_user=45.9625 7283000000000 +cpu,cpu=4 usage_idle=27.7402,usage_system=1.75789,usage_user=25.4747 7284000000000 +cpu,cpu=0 usage_idle=46.5678,usage_system=69.0669,usage_user=37.8919 7285000000000 +cpu,cpu=1 usage_idle=73.0376,usage_system=32.4709,usage_user=18.2919 7286000000000 +cpu,cpu=2 usage_idle=75.3623,usage_system=75.3693,usage_user=91.2419 7287000000000 +cpu,cpu=3 usage_idle=55.6068,usage_system=52.9033,usage_user=60.4593 7288000000000 +cpu,cpu=4 usage_idle=81.5658,usage_system=73.1577,usage_user=18.6777 7289000000000 +cpu,cpu=0 usage_idle=50.7909,usage_system=71.8187,usage_user=51.2682 7290000000000 +cpu,cpu=1 usage_idle=13.5709,usage_system=7.808,usage_user=69.3219 7291000000000 +cpu,cpu=2 usage_idle=43.987,usage_system=44.0659,usage_user=53.0831 7292000000000 +cpu,cpu=3 usage_idle=5.28586,usage_system=70.9027,usage_user=59.2649 7293000000000 +cpu,cpu=4 usage_idle=51.2483,usage_system=98.643,usage_user=61.0228 7294000000000 +cpu,cpu=0 usage_idle=76.723,usage_system=45.2108,usage_user=30.0897 7295000000000 +cpu,cpu=1 usage_idle=14.6149,usage_system=18.2484,usage_user=62.5606 7296000000000 +cpu,cpu=2 usage_idle=32.9069,usage_system=93.6107,usage_user=37.9299 7297000000000 +cpu,cpu=3 usage_idle=24.1488,usage_system=49.2175,usage_user=90.8332 7298000000000 +cpu,cpu=4 usage_idle=84.6081,usage_system=30.7834,usage_user=63.9909 7299000000000 +cpu,cpu=0 usage_idle=3.28581,usage_system=81.5743,usage_user=35.8095 7300000000000 +cpu,cpu=1 usage_idle=54.554,usage_system=95.1452,usage_user=43.6175 7301000000000 +cpu,cpu=2 usage_idle=23.8759,usage_system=39.1323,usage_user=87.6834 7302000000000 +cpu,cpu=3 usage_idle=76.959,usage_system=44.4181,usage_user=58.5862 7303000000000 +cpu,cpu=4 usage_idle=36.2239,usage_system=95.6664,usage_user=57.2292 7304000000000 +cpu,cpu=0 usage_idle=97.2467,usage_system=72.3894,usage_user=2.43994 7305000000000 +cpu,cpu=1 usage_idle=27.3364,usage_system=87.0043,usage_user=20.6884 7306000000000 +cpu,cpu=2 usage_idle=89.897,usage_system=19.9112,usage_user=14.2991 7307000000000 +cpu,cpu=3 usage_idle=27.8269,usage_system=44.06,usage_user=63.5166 7308000000000 +cpu,cpu=4 usage_idle=18.6601,usage_system=28.6681,usage_user=94.3 7309000000000 +cpu,cpu=0 usage_idle=82.6509,usage_system=31.954,usage_user=75.8743 7310000000000 +cpu,cpu=1 usage_idle=18.4605,usage_system=86.508,usage_user=71.0195 7311000000000 +cpu,cpu=2 usage_idle=62.078,usage_system=10.3839,usage_user=10.1518 7312000000000 +cpu,cpu=3 usage_idle=49.7614,usage_system=87.3429,usage_user=54.5699 7313000000000 +cpu,cpu=4 usage_idle=8.34764,usage_system=23.5669,usage_user=50.2364 7314000000000 +cpu,cpu=0 usage_idle=65.5768,usage_system=20.8136,usage_user=22.6258 7315000000000 +cpu,cpu=1 usage_idle=68.0167,usage_system=48.15,usage_user=9.63013 7316000000000 +cpu,cpu=2 usage_idle=88.7051,usage_system=38.0469,usage_user=29.5413 7317000000000 +cpu,cpu=3 usage_idle=3.00417,usage_system=65.8738,usage_user=73.6014 7318000000000 +cpu,cpu=4 usage_idle=66.5208,usage_system=84.5339,usage_user=2.26949 7319000000000 +cpu,cpu=0 usage_idle=60.8208,usage_system=67.1848,usage_user=34.2234 7320000000000 +cpu,cpu=1 usage_idle=36.6951,usage_system=85.6453,usage_user=20.7314 7321000000000 +cpu,cpu=2 usage_idle=7.71458,usage_system=47.7233,usage_user=31.1153 7322000000000 +cpu,cpu=3 usage_idle=17.8664,usage_system=97.4848,usage_user=18.4582 7323000000000 +cpu,cpu=4 usage_idle=72.4363,usage_system=5.83239,usage_user=42.0251 7324000000000 +cpu,cpu=0 usage_idle=22.6726,usage_system=71.4092,usage_user=62.8387 7325000000000 +cpu,cpu=1 usage_idle=45.2984,usage_system=39.4259,usage_user=10.9886 7326000000000 +cpu,cpu=2 usage_idle=54.9285,usage_system=28.131,usage_user=49.0356 7327000000000 +cpu,cpu=3 usage_idle=84.4699,usage_system=31.1352,usage_user=14.9094 7328000000000 +cpu,cpu=4 usage_idle=58.0712,usage_system=97.656,usage_user=99.4433 7329000000000 +cpu,cpu=0 usage_idle=60.3407,usage_system=58.4768,usage_user=66.6282 7330000000000 +cpu,cpu=1 usage_idle=94.5642,usage_system=95.1718,usage_user=52.2735 7331000000000 +cpu,cpu=2 usage_idle=15.2956,usage_system=2.88642,usage_user=99.9968 7332000000000 +cpu,cpu=3 usage_idle=46.4109,usage_system=20.7528,usage_user=97.4815 7333000000000 +cpu,cpu=4 usage_idle=64.8691,usage_system=93.1891,usage_user=3.31391 7334000000000 +cpu,cpu=0 usage_idle=6.89426,usage_system=15.8617,usage_user=74.7231 7335000000000 +cpu,cpu=1 usage_idle=69.7329,usage_system=61.1601,usage_user=14.149 7336000000000 +cpu,cpu=2 usage_idle=80.7216,usage_system=16.0886,usage_user=42.2801 7337000000000 +cpu,cpu=3 usage_idle=29.7572,usage_system=0.558527,usage_user=73.4153 7338000000000 +cpu,cpu=4 usage_idle=44.6666,usage_system=58.6298,usage_user=71.0713 7339000000000 +cpu,cpu=0 usage_idle=44.1099,usage_system=18.9705,usage_user=29.5481 7340000000000 +cpu,cpu=1 usage_idle=10.7381,usage_system=13.5347,usage_user=24.7199 7341000000000 +cpu,cpu=2 usage_idle=63.0116,usage_system=28.8303,usage_user=27.6063 7342000000000 +cpu,cpu=3 usage_idle=63.0083,usage_system=75.2412,usage_user=48.3591 7343000000000 +cpu,cpu=4 usage_idle=60.4898,usage_system=40.1103,usage_user=41.5482 7344000000000 +cpu,cpu=0 usage_idle=63.8038,usage_system=47.0046,usage_user=57.4098 7345000000000 +cpu,cpu=1 usage_idle=38.5269,usage_system=16.7375,usage_user=18.5699 7346000000000 +cpu,cpu=2 usage_idle=52.6759,usage_system=97.4591,usage_user=34.6586 7347000000000 +cpu,cpu=3 usage_idle=94.956,usage_system=27.2163,usage_user=35.2171 7348000000000 +cpu,cpu=4 usage_idle=68.3713,usage_system=71.8829,usage_user=93.8469 7349000000000 +cpu,cpu=0 usage_idle=39.4426,usage_system=15.9928,usage_user=12.8174 7350000000000 +cpu,cpu=1 usage_idle=68.9906,usage_system=26.7309,usage_user=26.352 7351000000000 +cpu,cpu=2 usage_idle=93.7105,usage_system=89.7425,usage_user=55.1823 7352000000000 +cpu,cpu=3 usage_idle=21.3169,usage_system=52.7508,usage_user=30.4234 7353000000000 +cpu,cpu=4 usage_idle=69.676,usage_system=13.2407,usage_user=70.5337 7354000000000 +cpu,cpu=0 usage_idle=11.2242,usage_system=77.0444,usage_user=17.5383 7355000000000 +cpu,cpu=1 usage_idle=68.634,usage_system=15.5713,usage_user=34.2758 7356000000000 +cpu,cpu=2 usage_idle=87.2039,usage_system=68.2472,usage_user=31.7349 7357000000000 +cpu,cpu=3 usage_idle=21.8625,usage_system=63.2032,usage_user=58.9512 7358000000000 +cpu,cpu=4 usage_idle=57.0796,usage_system=31.5744,usage_user=30.8341 7359000000000 +cpu,cpu=0 usage_idle=50.9265,usage_system=71.017,usage_user=46.8269 7360000000000 +cpu,cpu=1 usage_idle=63.7438,usage_system=40.0076,usage_user=73.5578 7361000000000 +cpu,cpu=2 usage_idle=90.0959,usage_system=33.7181,usage_user=63.3003 7362000000000 +cpu,cpu=3 usage_idle=45.2782,usage_system=55.035,usage_user=16.0512 7363000000000 +cpu,cpu=4 usage_idle=75.7016,usage_system=24.711,usage_user=29.2918 7364000000000 +cpu,cpu=0 usage_idle=46.2354,usage_system=35.9351,usage_user=6.33625 7365000000000 +cpu,cpu=1 usage_idle=63.7737,usage_system=4.56914,usage_user=21.9075 7366000000000 +cpu,cpu=2 usage_idle=98.0495,usage_system=91.7731,usage_user=90.1547 7367000000000 +cpu,cpu=3 usage_idle=29.7844,usage_system=13.6356,usage_user=53.3579 7368000000000 +cpu,cpu=4 usage_idle=88.7355,usage_system=70.7152,usage_user=84.9323 7369000000000 +cpu,cpu=0 usage_idle=19.5696,usage_system=21.6417,usage_user=55.9493 7370000000000 +cpu,cpu=1 usage_idle=66.3965,usage_system=85.3855,usage_user=95.9569 7371000000000 +cpu,cpu=2 usage_idle=39.9543,usage_system=75.4814,usage_user=29.675 7372000000000 +cpu,cpu=3 usage_idle=3.25463,usage_system=20.7595,usage_user=84.71 7373000000000 +cpu,cpu=4 usage_idle=19.3058,usage_system=96.4611,usage_user=9.421 7374000000000 +cpu,cpu=0 usage_idle=48.5976,usage_system=42.6965,usage_user=45.3561 7375000000000 +cpu,cpu=1 usage_idle=54.9339,usage_system=6.47018,usage_user=49.9253 7376000000000 +cpu,cpu=2 usage_idle=76.8414,usage_system=4.51965,usage_user=41.6984 7377000000000 +cpu,cpu=3 usage_idle=66.9961,usage_system=34.304,usage_user=55.334 7378000000000 +cpu,cpu=4 usage_idle=20.354,usage_system=23.0396,usage_user=26.0491 7379000000000 +cpu,cpu=0 usage_idle=5.28627,usage_system=42.6091,usage_user=47.6908 7380000000000 +cpu,cpu=1 usage_idle=61.2355,usage_system=9.00562,usage_user=33.0763 7381000000000 +cpu,cpu=2 usage_idle=57.1924,usage_system=48.9599,usage_user=8.5577 7382000000000 +cpu,cpu=3 usage_idle=86.8674,usage_system=52.2145,usage_user=29.3172 7383000000000 +cpu,cpu=4 usage_idle=71.5774,usage_system=71.5203,usage_user=25.7784 7384000000000 +cpu,cpu=0 usage_idle=80.9984,usage_system=20.118,usage_user=68.4749 7385000000000 +cpu,cpu=1 usage_idle=26.3546,usage_system=75.0518,usage_user=74.9451 7386000000000 +cpu,cpu=2 usage_idle=76.2799,usage_system=51.8932,usage_user=79.4647 7387000000000 +cpu,cpu=3 usage_idle=17.9783,usage_system=18.8893,usage_user=13.7687 7388000000000 +cpu,cpu=4 usage_idle=73.3122,usage_system=39.2433,usage_user=36.8083 7389000000000 +cpu,cpu=0 usage_idle=99.3614,usage_system=44.5296,usage_user=79.4174 7390000000000 +cpu,cpu=1 usage_idle=47.0522,usage_system=5.76513,usage_user=88.4231 7391000000000 +cpu,cpu=2 usage_idle=80.1285,usage_system=62.9576,usage_user=37.383 7392000000000 +cpu,cpu=3 usage_idle=88.6862,usage_system=49.825,usage_user=89.5975 7393000000000 +cpu,cpu=4 usage_idle=18.0034,usage_system=21.4024,usage_user=61.1179 7394000000000 +cpu,cpu=0 usage_idle=43.7818,usage_system=2.40088,usage_user=81.2358 7395000000000 +cpu,cpu=1 usage_idle=12.2567,usage_system=28.7555,usage_user=56.2876 7396000000000 +cpu,cpu=2 usage_idle=87.2018,usage_system=5.03537,usage_user=8.18085 7397000000000 +cpu,cpu=3 usage_idle=66.6665,usage_system=23.0136,usage_user=27.0702 7398000000000 +cpu,cpu=4 usage_idle=80.4352,usage_system=96.3258,usage_user=66.3135 7399000000000 +cpu,cpu=0 usage_idle=17.2435,usage_system=95.6872,usage_user=10.8431 7400000000000 +cpu,cpu=1 usage_idle=96.661,usage_system=42.7394,usage_user=16.6082 7401000000000 +cpu,cpu=2 usage_idle=85.084,usage_system=22.8679,usage_user=79.5657 7402000000000 +cpu,cpu=3 usage_idle=22.467,usage_system=11.5541,usage_user=29.3907 7403000000000 +cpu,cpu=4 usage_idle=12.0646,usage_system=29.5575,usage_user=50.7932 7404000000000 +cpu,cpu=0 usage_idle=73.1824,usage_system=73.3393,usage_user=53.194 7405000000000 +cpu,cpu=1 usage_idle=54.4182,usage_system=85.596,usage_user=81.9495 7406000000000 +cpu,cpu=2 usage_idle=10.7059,usage_system=72.7978,usage_user=86.9849 7407000000000 +cpu,cpu=3 usage_idle=18.8867,usage_system=39.4643,usage_user=9.99851 7408000000000 +cpu,cpu=4 usage_idle=45.9569,usage_system=19.8995,usage_user=6.32434 7409000000000 +cpu,cpu=0 usage_idle=12.2704,usage_system=37.1431,usage_user=2.01154 7410000000000 +cpu,cpu=1 usage_idle=23.1134,usage_system=33.804,usage_user=44.7509 7411000000000 +cpu,cpu=2 usage_idle=39.7216,usage_system=18.8881,usage_user=67.6188 7412000000000 +cpu,cpu=3 usage_idle=19.2873,usage_system=41.3551,usage_user=79.1729 7413000000000 +cpu,cpu=4 usage_idle=48.6781,usage_system=53.4197,usage_user=8.73038 7414000000000 +cpu,cpu=0 usage_idle=99.4712,usage_system=26.6021,usage_user=82.0697 7415000000000 +cpu,cpu=1 usage_idle=52.6652,usage_system=81.0203,usage_user=67.6658 7416000000000 +cpu,cpu=2 usage_idle=34.6148,usage_system=91.7262,usage_user=40.4636 7417000000000 +cpu,cpu=3 usage_idle=21.5996,usage_system=10.6129,usage_user=79.9279 7418000000000 +cpu,cpu=4 usage_idle=31.5981,usage_system=56.5699,usage_user=99.8274 7419000000000 +cpu,cpu=0 usage_idle=37.9225,usage_system=68.8402,usage_user=36.9704 7420000000000 +cpu,cpu=1 usage_idle=39.934,usage_system=91.9537,usage_user=70.7745 7421000000000 +cpu,cpu=2 usage_idle=84.6849,usage_system=31.6753,usage_user=89.6625 7422000000000 +cpu,cpu=3 usage_idle=52.3037,usage_system=50.9626,usage_user=31.0176 7423000000000 +cpu,cpu=4 usage_idle=31.4766,usage_system=99.6407,usage_user=84.4373 7424000000000 +cpu,cpu=0 usage_idle=40.207,usage_system=99.1119,usage_user=11.0394 7425000000000 +cpu,cpu=1 usage_idle=22.2767,usage_system=51.7771,usage_user=92.0597 7426000000000 +cpu,cpu=2 usage_idle=89.9425,usage_system=86.3919,usage_user=83.7859 7427000000000 +cpu,cpu=3 usage_idle=30.406,usage_system=7.99152,usage_user=94.3989 7428000000000 +cpu,cpu=4 usage_idle=10.3339,usage_system=39.5897,usage_user=50.9687 7429000000000 +cpu,cpu=0 usage_idle=10.1613,usage_system=77.5122,usage_user=19.809 7430000000000 +cpu,cpu=1 usage_idle=47.1317,usage_system=17.4462,usage_user=11.7626 7431000000000 +cpu,cpu=2 usage_idle=17.9062,usage_system=2.13112,usage_user=43.4379 7432000000000 +cpu,cpu=3 usage_idle=7.56874,usage_system=54.4348,usage_user=94.4005 7433000000000 +cpu,cpu=4 usage_idle=38.5864,usage_system=85.9114,usage_user=94.0412 7434000000000 +cpu,cpu=0 usage_idle=23.0237,usage_system=26.1184,usage_user=93.1531 7435000000000 +cpu,cpu=1 usage_idle=34.0631,usage_system=48.3951,usage_user=44.9302 7436000000000 +cpu,cpu=2 usage_idle=26.1228,usage_system=38.3376,usage_user=31.3221 7437000000000 +cpu,cpu=3 usage_idle=9.90868,usage_system=68.7436,usage_user=39.3136 7438000000000 +cpu,cpu=4 usage_idle=4.30755,usage_system=79.0775,usage_user=78.9033 7439000000000 +cpu,cpu=0 usage_idle=55.2763,usage_system=89.2388,usage_user=56.4154 7440000000000 +cpu,cpu=1 usage_idle=75.0852,usage_system=36.3705,usage_user=73.8616 7441000000000 +cpu,cpu=2 usage_idle=86.8478,usage_system=54.2767,usage_user=75.9927 7442000000000 +cpu,cpu=3 usage_idle=30.2857,usage_system=61.8454,usage_user=30.4275 7443000000000 +cpu,cpu=4 usage_idle=24.6863,usage_system=0.431817,usage_user=16.339 7444000000000 +cpu,cpu=0 usage_idle=18.7275,usage_system=23.4555,usage_user=42.4574 7445000000000 +cpu,cpu=1 usage_idle=11.8806,usage_system=57.5185,usage_user=90.8525 7446000000000 +cpu,cpu=2 usage_idle=56.8107,usage_system=83.6413,usage_user=29.1901 7447000000000 +cpu,cpu=3 usage_idle=88.1328,usage_system=93.55,usage_user=97.9337 7448000000000 +cpu,cpu=4 usage_idle=27.4464,usage_system=97.8575,usage_user=77.0112 7449000000000 +cpu,cpu=0 usage_idle=6.34968,usage_system=53.1338,usage_user=66.25 7450000000000 +cpu,cpu=1 usage_idle=62.7651,usage_system=28.219,usage_user=2.62046 7451000000000 +cpu,cpu=2 usage_idle=36.6267,usage_system=15.0669,usage_user=56.8972 7452000000000 +cpu,cpu=3 usage_idle=12.6194,usage_system=45.3526,usage_user=18.7426 7453000000000 +cpu,cpu=4 usage_idle=43.0469,usage_system=70.0389,usage_user=19.1744 7454000000000 +cpu,cpu=0 usage_idle=59.3859,usage_system=88.7663,usage_user=42.6299 7455000000000 +cpu,cpu=1 usage_idle=1.84332,usage_system=0.64689,usage_user=0.148456 7456000000000 +cpu,cpu=2 usage_idle=92.6958,usage_system=57.4576,usage_user=83.7898 7457000000000 +cpu,cpu=3 usage_idle=21.8859,usage_system=45.5905,usage_user=77.3397 7458000000000 +cpu,cpu=4 usage_idle=19.8196,usage_system=73.0369,usage_user=75.1973 7459000000000 +cpu,cpu=0 usage_idle=96.8308,usage_system=79.3866,usage_user=28.3311 7460000000000 +cpu,cpu=1 usage_idle=63.0807,usage_system=42.1516,usage_user=56.5501 7461000000000 +cpu,cpu=2 usage_idle=65.7012,usage_system=78.7783,usage_user=71.6169 7462000000000 +cpu,cpu=3 usage_idle=22.5983,usage_system=91.3977,usage_user=16.9695 7463000000000 +cpu,cpu=4 usage_idle=41.3409,usage_system=34.4447,usage_user=87.0084 7464000000000 +cpu,cpu=0 usage_idle=60.5154,usage_system=93.8306,usage_user=75.7747 7465000000000 +cpu,cpu=1 usage_idle=3.14528,usage_system=95.6739,usage_user=76.4216 7466000000000 +cpu,cpu=2 usage_idle=3.29373,usage_system=88.3697,usage_user=33.8793 7467000000000 +cpu,cpu=3 usage_idle=87.0835,usage_system=10.2556,usage_user=79.4697 7468000000000 +cpu,cpu=4 usage_idle=64.4232,usage_system=30.0752,usage_user=52.5066 7469000000000 +cpu,cpu=0 usage_idle=39.6205,usage_system=26.906,usage_user=31.8932 7470000000000 +cpu,cpu=1 usage_idle=67.9516,usage_system=89.9867,usage_user=74.0448 7471000000000 +cpu,cpu=2 usage_idle=24.5017,usage_system=55.6879,usage_user=52.8231 7472000000000 +cpu,cpu=3 usage_idle=96.1186,usage_system=78.2862,usage_user=44.2209 7473000000000 +cpu,cpu=4 usage_idle=13.0881,usage_system=19.6272,usage_user=78.6655 7474000000000 +cpu,cpu=0 usage_idle=0.0965364,usage_system=80.1425,usage_user=72.4961 7475000000000 +cpu,cpu=1 usage_idle=75.8713,usage_system=83.2878,usage_user=68.17 7476000000000 +cpu,cpu=2 usage_idle=52.2929,usage_system=86.5815,usage_user=56.5397 7477000000000 +cpu,cpu=3 usage_idle=86.1722,usage_system=73.665,usage_user=66.7954 7478000000000 +cpu,cpu=4 usage_idle=65.6419,usage_system=38.0883,usage_user=96.8706 7479000000000 +cpu,cpu=0 usage_idle=18.1485,usage_system=77.7088,usage_user=23.7766 7480000000000 +cpu,cpu=1 usage_idle=50.0417,usage_system=45.6604,usage_user=13.7633 7481000000000 +cpu,cpu=2 usage_idle=24.0865,usage_system=70.1621,usage_user=69.4511 7482000000000 +cpu,cpu=3 usage_idle=76.9096,usage_system=66.2807,usage_user=47.7373 7483000000000 +cpu,cpu=4 usage_idle=21.1305,usage_system=79.3688,usage_user=67.3645 7484000000000 +cpu,cpu=0 usage_idle=99.796,usage_system=79.4653,usage_user=47.507 7485000000000 +cpu,cpu=1 usage_idle=72.2921,usage_system=55.3366,usage_user=30.7948 7486000000000 +cpu,cpu=2 usage_idle=40.4621,usage_system=7.62952,usage_user=17.3763 7487000000000 +cpu,cpu=3 usage_idle=97.0018,usage_system=93.8017,usage_user=91.0414 7488000000000 +cpu,cpu=4 usage_idle=63.7972,usage_system=59.4436,usage_user=29.1296 7489000000000 +cpu,cpu=0 usage_idle=60.6678,usage_system=77.5921,usage_user=6.83842 7490000000000 +cpu,cpu=1 usage_idle=84.4443,usage_system=27.6337,usage_user=52.4988 7491000000000 +cpu,cpu=2 usage_idle=98.2076,usage_system=51.7202,usage_user=22.6609 7492000000000 +cpu,cpu=3 usage_idle=67.6587,usage_system=28.6298,usage_user=88.9415 7493000000000 +cpu,cpu=4 usage_idle=15.396,usage_system=49.7603,usage_user=68.3104 7494000000000 +cpu,cpu=0 usage_idle=82.7605,usage_system=49.5563,usage_user=47.7757 7495000000000 +cpu,cpu=1 usage_idle=30.2675,usage_system=21.8484,usage_user=3.11233 7496000000000 +cpu,cpu=2 usage_idle=61.0623,usage_system=62.3105,usage_user=10.7419 7497000000000 +cpu,cpu=3 usage_idle=78.4386,usage_system=59.3123,usage_user=4.54353 7498000000000 +cpu,cpu=4 usage_idle=69.48,usage_system=23.1095,usage_user=63.9871 7499000000000 +cpu,cpu=0 usage_idle=98.6096,usage_system=83.7772,usage_user=41.5792 7500000000000 +cpu,cpu=1 usage_idle=5.44803,usage_system=68.2215,usage_user=69.2129 7501000000000 +cpu,cpu=2 usage_idle=57.9468,usage_system=66.4291,usage_user=20.9331 7502000000000 +cpu,cpu=3 usage_idle=80.6077,usage_system=34.0878,usage_user=49.563 7503000000000 +cpu,cpu=4 usage_idle=69.5493,usage_system=49.4838,usage_user=99.3233 7504000000000 +cpu,cpu=0 usage_idle=37.8596,usage_system=32.2443,usage_user=48.8795 7505000000000 +cpu,cpu=1 usage_idle=85.6353,usage_system=62.5118,usage_user=70.7279 7506000000000 +cpu,cpu=2 usage_idle=88.7477,usage_system=23.5741,usage_user=33.0384 7507000000000 +cpu,cpu=3 usage_idle=99.4895,usage_system=2.01267,usage_user=92.3507 7508000000000 +cpu,cpu=4 usage_idle=4.03304,usage_system=71.4926,usage_user=15.4601 7509000000000 +cpu,cpu=0 usage_idle=68.0202,usage_system=70.1022,usage_user=99.2373 7510000000000 +cpu,cpu=1 usage_idle=9.59933,usage_system=75.5503,usage_user=67.4589 7511000000000 +cpu,cpu=2 usage_idle=78.8122,usage_system=33.4971,usage_user=33.888 7512000000000 +cpu,cpu=3 usage_idle=99.7454,usage_system=14.1048,usage_user=67.9758 7513000000000 +cpu,cpu=4 usage_idle=49.3083,usage_system=83.6541,usage_user=17.4596 7514000000000 +cpu,cpu=0 usage_idle=48.6316,usage_system=21.5137,usage_user=49.7039 7515000000000 +cpu,cpu=1 usage_idle=97.5111,usage_system=7.14902,usage_user=12.2156 7516000000000 +cpu,cpu=2 usage_idle=68.2391,usage_system=95.8967,usage_user=35.7897 7517000000000 +cpu,cpu=3 usage_idle=1.27745,usage_system=95.3862,usage_user=37.8024 7518000000000 +cpu,cpu=4 usage_idle=93.6281,usage_system=99.4192,usage_user=9.29503 7519000000000 +cpu,cpu=0 usage_idle=9.08825,usage_system=67.4394,usage_user=79.3973 7520000000000 +cpu,cpu=1 usage_idle=8.3256,usage_system=77.0387,usage_user=54.9475 7521000000000 +cpu,cpu=2 usage_idle=75.7845,usage_system=55.851,usage_user=88.4447 7522000000000 +cpu,cpu=3 usage_idle=9.67247,usage_system=55.5963,usage_user=2.54948 7523000000000 +cpu,cpu=4 usage_idle=77.6482,usage_system=4.90467,usage_user=86.2036 7524000000000 +cpu,cpu=0 usage_idle=95.1078,usage_system=53.5363,usage_user=7.71724 7525000000000 +cpu,cpu=1 usage_idle=44.8117,usage_system=51.0474,usage_user=14.8663 7526000000000 +cpu,cpu=2 usage_idle=57.0273,usage_system=19.2865,usage_user=10.7629 7527000000000 +cpu,cpu=3 usage_idle=92.8171,usage_system=20.5639,usage_user=6.14911 7528000000000 +cpu,cpu=4 usage_idle=30.6194,usage_system=14.192,usage_user=5.56834 7529000000000 +cpu,cpu=0 usage_idle=39.9145,usage_system=23.2803,usage_user=73.0077 7530000000000 +cpu,cpu=1 usage_idle=19.3117,usage_system=31.6059,usage_user=50.0464 7531000000000 +cpu,cpu=2 usage_idle=74.2593,usage_system=7.39037,usage_user=5.89738 7532000000000 +cpu,cpu=3 usage_idle=62.7039,usage_system=17.0628,usage_user=61.4937 7533000000000 +cpu,cpu=4 usage_idle=65.2534,usage_system=94.7111,usage_user=66.3984 7534000000000 +cpu,cpu=0 usage_idle=51.457,usage_system=89.8189,usage_user=19.9346 7535000000000 +cpu,cpu=1 usage_idle=59.1742,usage_system=34.6306,usage_user=70.982 7536000000000 +cpu,cpu=2 usage_idle=74.0405,usage_system=91.6579,usage_user=90.2685 7537000000000 +cpu,cpu=3 usage_idle=84.8034,usage_system=84.475,usage_user=10.8324 7538000000000 +cpu,cpu=4 usage_idle=90.9525,usage_system=15.0944,usage_user=25.0244 7539000000000 +cpu,cpu=0 usage_idle=96.5209,usage_system=55.0089,usage_user=48.3047 7540000000000 +cpu,cpu=1 usage_idle=69.5286,usage_system=74.3206,usage_user=79.9106 7541000000000 +cpu,cpu=2 usage_idle=19.575,usage_system=48.5799,usage_user=87.301 7542000000000 +cpu,cpu=3 usage_idle=25.4724,usage_system=11.2839,usage_user=4.36382 7543000000000 +cpu,cpu=4 usage_idle=86.9661,usage_system=76.5373,usage_user=99.0749 7544000000000 +cpu,cpu=0 usage_idle=53.3645,usage_system=27.9943,usage_user=88.8938 7545000000000 +cpu,cpu=1 usage_idle=73.2991,usage_system=87.1685,usage_user=23.5244 7546000000000 +cpu,cpu=2 usage_idle=44.2812,usage_system=61.209,usage_user=15.1823 7547000000000 +cpu,cpu=3 usage_idle=34.5497,usage_system=46.0124,usage_user=99.6573 7548000000000 +cpu,cpu=4 usage_idle=45.3821,usage_system=36.9649,usage_user=14.7518 7549000000000 +cpu,cpu=0 usage_idle=70.4065,usage_system=33.4858,usage_user=69.7607 7550000000000 +cpu,cpu=1 usage_idle=18.7113,usage_system=3.01433,usage_user=44.0813 7551000000000 +cpu,cpu=2 usage_idle=98.6219,usage_system=22.5893,usage_user=92.6613 7552000000000 +cpu,cpu=3 usage_idle=85.9229,usage_system=48.0617,usage_user=3.94514 7553000000000 +cpu,cpu=4 usage_idle=90.2867,usage_system=35.0278,usage_user=80.4824 7554000000000 +cpu,cpu=0 usage_idle=89.3616,usage_system=88.3922,usage_user=8.47672 7555000000000 +cpu,cpu=1 usage_idle=78.2554,usage_system=61.6914,usage_user=95.6452 7556000000000 +cpu,cpu=2 usage_idle=1.7798,usage_system=5.97253,usage_user=56.8542 7557000000000 +cpu,cpu=3 usage_idle=16.9621,usage_system=40.5222,usage_user=2.86657 7558000000000 +cpu,cpu=4 usage_idle=16.6195,usage_system=85.9043,usage_user=39.8315 7559000000000 +cpu,cpu=0 usage_idle=31.3713,usage_system=56.3108,usage_user=73.3172 7560000000000 +cpu,cpu=1 usage_idle=1.13194,usage_system=75.0221,usage_user=76.3316 7561000000000 +cpu,cpu=2 usage_idle=45.2133,usage_system=73.644,usage_user=98.9209 7562000000000 +cpu,cpu=3 usage_idle=37.8745,usage_system=59.5668,usage_user=46.9826 7563000000000 +cpu,cpu=4 usage_idle=41.8197,usage_system=49.8535,usage_user=82.0103 7564000000000 +cpu,cpu=0 usage_idle=22.3021,usage_system=39.2151,usage_user=70.4026 7565000000000 +cpu,cpu=1 usage_idle=30.7788,usage_system=17.4706,usage_user=32.0939 7566000000000 +cpu,cpu=2 usage_idle=26.4241,usage_system=19.2504,usage_user=38.0665 7567000000000 +cpu,cpu=3 usage_idle=83.2782,usage_system=36.2125,usage_user=78.5887 7568000000000 +cpu,cpu=4 usage_idle=86.1448,usage_system=52.832,usage_user=64.4929 7569000000000 +cpu,cpu=0 usage_idle=25.9763,usage_system=84.2032,usage_user=20.8037 7570000000000 +cpu,cpu=1 usage_idle=99.2935,usage_system=85.3352,usage_user=95.8258 7571000000000 +cpu,cpu=2 usage_idle=75.6251,usage_system=30.5485,usage_user=69.4697 7572000000000 +cpu,cpu=3 usage_idle=74.5459,usage_system=68.423,usage_user=29.0366 7573000000000 +cpu,cpu=4 usage_idle=21.5285,usage_system=10.2427,usage_user=78.8901 7574000000000 +cpu,cpu=0 usage_idle=3.53881,usage_system=32.5448,usage_user=18.1052 7575000000000 +cpu,cpu=1 usage_idle=73.9414,usage_system=63.3236,usage_user=35.5758 7576000000000 +cpu,cpu=2 usage_idle=6.03532,usage_system=89.7477,usage_user=54.8262 7577000000000 +cpu,cpu=3 usage_idle=44.1018,usage_system=73.0259,usage_user=91.0387 7578000000000 +cpu,cpu=4 usage_idle=22.6904,usage_system=59.1707,usage_user=43.8706 7579000000000 +cpu,cpu=0 usage_idle=87.1834,usage_system=85.147,usage_user=28.0739 7580000000000 +cpu,cpu=1 usage_idle=7.98707,usage_system=84.4405,usage_user=13.4091 7581000000000 +cpu,cpu=2 usage_idle=3.81285,usage_system=60.0656,usage_user=43.9575 7582000000000 +cpu,cpu=3 usage_idle=73.2826,usage_system=34.6115,usage_user=12.3805 7583000000000 +cpu,cpu=4 usage_idle=2.31914,usage_system=56.14,usage_user=22.6232 7584000000000 +cpu,cpu=0 usage_idle=81.2092,usage_system=59.6788,usage_user=55.168 7585000000000 +cpu,cpu=1 usage_idle=99.3145,usage_system=33.6202,usage_user=18.4916 7586000000000 +cpu,cpu=2 usage_idle=34.8903,usage_system=39.6555,usage_user=8.2393 7587000000000 +cpu,cpu=3 usage_idle=89.7164,usage_system=83.7573,usage_user=81.2652 7588000000000 +cpu,cpu=4 usage_idle=80.7551,usage_system=6.44773,usage_user=40.436 7589000000000 +cpu,cpu=0 usage_idle=24.6258,usage_system=93.6311,usage_user=25.583 7590000000000 +cpu,cpu=1 usage_idle=52.6996,usage_system=1.61815,usage_user=10.0235 7591000000000 +cpu,cpu=2 usage_idle=66.1087,usage_system=5.431,usage_user=70.0891 7592000000000 +cpu,cpu=3 usage_idle=10.0663,usage_system=78.7136,usage_user=4.70063 7593000000000 +cpu,cpu=4 usage_idle=22.4468,usage_system=81.0327,usage_user=60.8406 7594000000000 +cpu,cpu=0 usage_idle=45.07,usage_system=62.242,usage_user=20.5194 7595000000000 +cpu,cpu=1 usage_idle=0.238015,usage_system=61.5564,usage_user=54.1396 7596000000000 +cpu,cpu=2 usage_idle=18.7296,usage_system=96.4467,usage_user=93.7952 7597000000000 +cpu,cpu=3 usage_idle=26.9689,usage_system=86.1632,usage_user=77.5525 7598000000000 +cpu,cpu=4 usage_idle=8.23416,usage_system=66.9183,usage_user=84.0002 7599000000000 +cpu,cpu=0 usage_idle=48.6701,usage_system=91.544,usage_user=77.6313 7600000000000 +cpu,cpu=1 usage_idle=74.2531,usage_system=44.2437,usage_user=79.2494 7601000000000 +cpu,cpu=2 usage_idle=84.2767,usage_system=10.3524,usage_user=84.6804 7602000000000 +cpu,cpu=3 usage_idle=54.3658,usage_system=20.4187,usage_user=63.394 7603000000000 +cpu,cpu=4 usage_idle=59.0664,usage_system=42.8655,usage_user=44.4267 7604000000000 +cpu,cpu=0 usage_idle=19.907,usage_system=87.9355,usage_user=6.66867 7605000000000 +cpu,cpu=1 usage_idle=40.4265,usage_system=88.1736,usage_user=68.2251 7606000000000 +cpu,cpu=2 usage_idle=94.5661,usage_system=6.90319,usage_user=64.6718 7607000000000 +cpu,cpu=3 usage_idle=88.3613,usage_system=33.8721,usage_user=50.835 7608000000000 +cpu,cpu=4 usage_idle=65.9137,usage_system=42.1063,usage_user=17.7533 7609000000000 +cpu,cpu=0 usage_idle=49.9139,usage_system=90.7764,usage_user=9.29735 7610000000000 +cpu,cpu=1 usage_idle=27.5452,usage_system=65.0296,usage_user=53.541 7611000000000 +cpu,cpu=2 usage_idle=6.79462,usage_system=49.3062,usage_user=63.8935 7612000000000 +cpu,cpu=3 usage_idle=91.475,usage_system=3.672,usage_user=84.3122 7613000000000 +cpu,cpu=4 usage_idle=54.869,usage_system=62.7384,usage_user=27.1777 7614000000000 +cpu,cpu=0 usage_idle=99.2958,usage_system=82.6454,usage_user=15.1132 7615000000000 +cpu,cpu=1 usage_idle=5.96442,usage_system=23.0719,usage_user=3.28678 7616000000000 +cpu,cpu=2 usage_idle=74.1895,usage_system=17.638,usage_user=10.19 7617000000000 +cpu,cpu=3 usage_idle=38.8614,usage_system=5.99929,usage_user=44.0621 7618000000000 +cpu,cpu=4 usage_idle=89.6964,usage_system=71.913,usage_user=86.1684 7619000000000 +cpu,cpu=0 usage_idle=7.44969,usage_system=21.8269,usage_user=76.9448 7620000000000 +cpu,cpu=1 usage_idle=16.747,usage_system=49.3721,usage_user=41.9744 7621000000000 +cpu,cpu=2 usage_idle=70.2881,usage_system=56.1667,usage_user=91.2806 7622000000000 +cpu,cpu=3 usage_idle=34.1815,usage_system=47.6418,usage_user=94.9526 7623000000000 +cpu,cpu=4 usage_idle=18.4937,usage_system=2.51081,usage_user=57.691 7624000000000 +cpu,cpu=0 usage_idle=45.6714,usage_system=1.80657,usage_user=40.3364 7625000000000 +cpu,cpu=1 usage_idle=60.7846,usage_system=7.771,usage_user=63.4083 7626000000000 +cpu,cpu=2 usage_idle=64.0714,usage_system=81.9605,usage_user=81.0464 7627000000000 +cpu,cpu=3 usage_idle=74.2613,usage_system=20.8219,usage_user=87.0457 7628000000000 +cpu,cpu=4 usage_idle=18.3234,usage_system=10.5183,usage_user=58.9587 7629000000000 +cpu,cpu=0 usage_idle=4.49182,usage_system=17.968,usage_user=80.7856 7630000000000 +cpu,cpu=1 usage_idle=81.4366,usage_system=34.715,usage_user=30.1577 7631000000000 +cpu,cpu=2 usage_idle=23.411,usage_system=5.00307,usage_user=86.3244 7632000000000 +cpu,cpu=3 usage_idle=14.6916,usage_system=39.1846,usage_user=33.9662 7633000000000 +cpu,cpu=4 usage_idle=9.64415,usage_system=57.6783,usage_user=36.477 7634000000000 +cpu,cpu=0 usage_idle=67.3351,usage_system=3.34964,usage_user=38.2836 7635000000000 +cpu,cpu=1 usage_idle=7.67155,usage_system=64.1342,usage_user=46.0546 7636000000000 +cpu,cpu=2 usage_idle=71.0799,usage_system=28.2056,usage_user=28.0151 7637000000000 +cpu,cpu=3 usage_idle=52.1263,usage_system=2.46693,usage_user=48.837 7638000000000 +cpu,cpu=4 usage_idle=39.1719,usage_system=20.7904,usage_user=59.3553 7639000000000 +cpu,cpu=0 usage_idle=98.1306,usage_system=25.2822,usage_user=77.3232 7640000000000 +cpu,cpu=1 usage_idle=78.9162,usage_system=6.71882,usage_user=12.0382 7641000000000 +cpu,cpu=2 usage_idle=9.07385,usage_system=30.1298,usage_user=17.0413 7642000000000 +cpu,cpu=3 usage_idle=95.3983,usage_system=44.8214,usage_user=56.2259 7643000000000 +cpu,cpu=4 usage_idle=29.3645,usage_system=54.4655,usage_user=13.9042 7644000000000 +cpu,cpu=0 usage_idle=65.8415,usage_system=21.8007,usage_user=17.2538 7645000000000 +cpu,cpu=1 usage_idle=4.12503,usage_system=29.4722,usage_user=81.3881 7646000000000 +cpu,cpu=2 usage_idle=50.1796,usage_system=0.552102,usage_user=9.59364 7647000000000 +cpu,cpu=3 usage_idle=78.1947,usage_system=52.6784,usage_user=12.0606 7648000000000 +cpu,cpu=4 usage_idle=27.0317,usage_system=91.8503,usage_user=32.8509 7649000000000 +cpu,cpu=0 usage_idle=86.387,usage_system=89.9808,usage_user=58.1331 7650000000000 +cpu,cpu=1 usage_idle=63.7102,usage_system=68.897,usage_user=64.852 7651000000000 +cpu,cpu=2 usage_idle=75.7485,usage_system=77.9708,usage_user=94.9818 7652000000000 +cpu,cpu=3 usage_idle=92.7898,usage_system=73.3691,usage_user=39.8031 7653000000000 +cpu,cpu=4 usage_idle=49.0157,usage_system=2.73356,usage_user=94.2687 7654000000000 +cpu,cpu=0 usage_idle=62.9199,usage_system=68.575,usage_user=16.0693 7655000000000 +cpu,cpu=1 usage_idle=80.1737,usage_system=72.7,usage_user=45.5415 7656000000000 +cpu,cpu=2 usage_idle=61.5618,usage_system=22.8796,usage_user=46.0936 7657000000000 +cpu,cpu=3 usage_idle=71.1554,usage_system=1.07434,usage_user=98.772 7658000000000 +cpu,cpu=4 usage_idle=83.216,usage_system=28.106,usage_user=90.6222 7659000000000 +cpu,cpu=0 usage_idle=16.0669,usage_system=14.493,usage_user=80.6031 7660000000000 +cpu,cpu=1 usage_idle=74.2001,usage_system=78.2032,usage_user=49.5001 7661000000000 +cpu,cpu=2 usage_idle=39.052,usage_system=53.9517,usage_user=27.4709 7662000000000 +cpu,cpu=3 usage_idle=34.0338,usage_system=46.7415,usage_user=0.839998 7663000000000 +cpu,cpu=4 usage_idle=73.8369,usage_system=95.7571,usage_user=3.57355 7664000000000 +cpu,cpu=0 usage_idle=68.1056,usage_system=58.677,usage_user=72.1486 7665000000000 +cpu,cpu=1 usage_idle=84.1749,usage_system=38.8507,usage_user=44.8486 7666000000000 +cpu,cpu=2 usage_idle=29.7164,usage_system=0.412504,usage_user=67.7282 7667000000000 +cpu,cpu=3 usage_idle=75.8101,usage_system=71.5679,usage_user=68.8026 7668000000000 +cpu,cpu=4 usage_idle=74.5821,usage_system=54.7839,usage_user=96.9086 7669000000000 +cpu,cpu=0 usage_idle=65.2043,usage_system=70.8508,usage_user=11.4016 7670000000000 +cpu,cpu=1 usage_idle=45.8074,usage_system=45.0509,usage_user=89.6048 7671000000000 +cpu,cpu=2 usage_idle=95.3074,usage_system=84.1029,usage_user=43.5565 7672000000000 +cpu,cpu=3 usage_idle=22.7783,usage_system=18.1367,usage_user=90.298 7673000000000 +cpu,cpu=4 usage_idle=23.6183,usage_system=91.9736,usage_user=86.0551 7674000000000 +cpu,cpu=0 usage_idle=27.1919,usage_system=60.0792,usage_user=44.7321 7675000000000 +cpu,cpu=1 usage_idle=99.3405,usage_system=44.2541,usage_user=83.5829 7676000000000 +cpu,cpu=2 usage_idle=44.1891,usage_system=73.9705,usage_user=83.9954 7677000000000 +cpu,cpu=3 usage_idle=11.9173,usage_system=49.7806,usage_user=55.5633 7678000000000 +cpu,cpu=4 usage_idle=80.7199,usage_system=24.3626,usage_user=10.3472 7679000000000 +cpu,cpu=0 usage_idle=77.6285,usage_system=89.5669,usage_user=81.198 7680000000000 +cpu,cpu=1 usage_idle=89.0301,usage_system=35.3743,usage_user=26.2489 7681000000000 +cpu,cpu=2 usage_idle=78.6349,usage_system=30.6818,usage_user=10.3518 7682000000000 +cpu,cpu=3 usage_idle=22.1914,usage_system=53.4601,usage_user=28.4885 7683000000000 +cpu,cpu=4 usage_idle=12.4894,usage_system=77.0784,usage_user=20.4621 7684000000000 +cpu,cpu=0 usage_idle=98.5445,usage_system=4.27033,usage_user=80.5413 7685000000000 +cpu,cpu=1 usage_idle=43.2766,usage_system=3.61079,usage_user=24.7954 7686000000000 +cpu,cpu=2 usage_idle=26.8595,usage_system=47.7998,usage_user=98.7659 7687000000000 +cpu,cpu=3 usage_idle=10.8549,usage_system=59.7171,usage_user=48.5465 7688000000000 +cpu,cpu=4 usage_idle=66.4182,usage_system=40.437,usage_user=72.9092 7689000000000 +cpu,cpu=0 usage_idle=76.7654,usage_system=18.0655,usage_user=62.4761 7690000000000 +cpu,cpu=1 usage_idle=57.9634,usage_system=7.09557,usage_user=97.8505 7691000000000 +cpu,cpu=2 usage_idle=84.2123,usage_system=85.7305,usage_user=28.5322 7692000000000 +cpu,cpu=3 usage_idle=94.5641,usage_system=7.92189,usage_user=81.9923 7693000000000 +cpu,cpu=4 usage_idle=23.0526,usage_system=20.4113,usage_user=59.0708 7694000000000 +cpu,cpu=0 usage_idle=43.5148,usage_system=18.9557,usage_user=63.3411 7695000000000 +cpu,cpu=1 usage_idle=24.0561,usage_system=62.2324,usage_user=66.9519 7696000000000 +cpu,cpu=2 usage_idle=48.8515,usage_system=89.0919,usage_user=14.7517 7697000000000 +cpu,cpu=3 usage_idle=47.6174,usage_system=99.9467,usage_user=74.4689 7698000000000 +cpu,cpu=4 usage_idle=96.164,usage_system=66.3649,usage_user=14.9059 7699000000000 +cpu,cpu=0 usage_idle=69.0732,usage_system=43.1303,usage_user=32.9714 7700000000000 +cpu,cpu=1 usage_idle=31.5493,usage_system=1.0937,usage_user=40.067 7701000000000 +cpu,cpu=2 usage_idle=29.3997,usage_system=85.306,usage_user=25.7974 7702000000000 +cpu,cpu=3 usage_idle=57.932,usage_system=79.8701,usage_user=33.7193 7703000000000 +cpu,cpu=4 usage_idle=39.9243,usage_system=2.92279,usage_user=54.1306 7704000000000 +cpu,cpu=0 usage_idle=98.9951,usage_system=46.4376,usage_user=73.0863 7705000000000 +cpu,cpu=1 usage_idle=62.3362,usage_system=70.4936,usage_user=35.3187 7706000000000 +cpu,cpu=2 usage_idle=29.2881,usage_system=19.3451,usage_user=24.4105 7707000000000 +cpu,cpu=3 usage_idle=44.0399,usage_system=66.9626,usage_user=24.3573 7708000000000 +cpu,cpu=4 usage_idle=18.5087,usage_system=63.1266,usage_user=90.7222 7709000000000 +cpu,cpu=0 usage_idle=33.4146,usage_system=32.1997,usage_user=33.8525 7710000000000 +cpu,cpu=1 usage_idle=66.386,usage_system=63.749,usage_user=34.9462 7711000000000 +cpu,cpu=2 usage_idle=6.45297,usage_system=93.1487,usage_user=20.2522 7712000000000 +cpu,cpu=3 usage_idle=32.2504,usage_system=51.0807,usage_user=0.122358 7713000000000 +cpu,cpu=4 usage_idle=65.9697,usage_system=91.005,usage_user=3.04515 7714000000000 +cpu,cpu=0 usage_idle=20.1003,usage_system=90.0001,usage_user=49.4827 7715000000000 +cpu,cpu=1 usage_idle=93.1866,usage_system=52.3364,usage_user=19.9764 7716000000000 +cpu,cpu=2 usage_idle=28.5053,usage_system=81.6245,usage_user=39.3215 7717000000000 +cpu,cpu=3 usage_idle=52.9158,usage_system=25.6643,usage_user=6.28408 7718000000000 +cpu,cpu=4 usage_idle=77.2731,usage_system=44.1731,usage_user=69.4106 7719000000000 +cpu,cpu=0 usage_idle=67.9953,usage_system=77.5877,usage_user=1.61034 7720000000000 +cpu,cpu=1 usage_idle=1.84779,usage_system=43.9737,usage_user=65.3593 7721000000000 +cpu,cpu=2 usage_idle=36.794,usage_system=50.4267,usage_user=58.5081 7722000000000 +cpu,cpu=3 usage_idle=57.0462,usage_system=82.6771,usage_user=9.58881 7723000000000 +cpu,cpu=4 usage_idle=57.1686,usage_system=48.6468,usage_user=0.593853 7724000000000 +cpu,cpu=0 usage_idle=60.2137,usage_system=68.7471,usage_user=90.594 7725000000000 +cpu,cpu=1 usage_idle=9.69642,usage_system=61.9337,usage_user=42.9304 7726000000000 +cpu,cpu=2 usage_idle=29.6728,usage_system=90.439,usage_user=24.5548 7727000000000 +cpu,cpu=3 usage_idle=68.9943,usage_system=43.3548,usage_user=50.2192 7728000000000 +cpu,cpu=4 usage_idle=75.2784,usage_system=20.6279,usage_user=94.3923 7729000000000 +cpu,cpu=0 usage_idle=44.689,usage_system=88.6232,usage_user=71.98 7730000000000 +cpu,cpu=1 usage_idle=46.2993,usage_system=90.471,usage_user=15.9537 7731000000000 +cpu,cpu=2 usage_idle=11.6587,usage_system=27.265,usage_user=66.3804 7732000000000 +cpu,cpu=3 usage_idle=70.1668,usage_system=84.3112,usage_user=49.0575 7733000000000 +cpu,cpu=4 usage_idle=79.7556,usage_system=41.4798,usage_user=97.7043 7734000000000 +cpu,cpu=0 usage_idle=80.3494,usage_system=1.69347,usage_user=66.4514 7735000000000 +cpu,cpu=1 usage_idle=70.9434,usage_system=11.3899,usage_user=28.3851 7736000000000 +cpu,cpu=2 usage_idle=13.8738,usage_system=41.0627,usage_user=18.8242 7737000000000 +cpu,cpu=3 usage_idle=38.4286,usage_system=10.0569,usage_user=62.179 7738000000000 +cpu,cpu=4 usage_idle=88.6478,usage_system=85.3353,usage_user=82.8069 7739000000000 +cpu,cpu=0 usage_idle=83.0401,usage_system=30.0243,usage_user=71.4302 7740000000000 +cpu,cpu=1 usage_idle=55.02,usage_system=76.3236,usage_user=61.9012 7741000000000 +cpu,cpu=2 usage_idle=70.9737,usage_system=87.9823,usage_user=89.1662 7742000000000 +cpu,cpu=3 usage_idle=37.3541,usage_system=58.1491,usage_user=73.4774 7743000000000 +cpu,cpu=4 usage_idle=86.4115,usage_system=37.9046,usage_user=14.9571 7744000000000 +cpu,cpu=0 usage_idle=84.1158,usage_system=18.254,usage_user=16.6506 7745000000000 +cpu,cpu=1 usage_idle=50.5672,usage_system=89.1974,usage_user=28.0405 7746000000000 +cpu,cpu=2 usage_idle=78.9523,usage_system=3.07122,usage_user=69.1031 7747000000000 +cpu,cpu=3 usage_idle=97.7765,usage_system=41.4998,usage_user=79.1601 7748000000000 +cpu,cpu=4 usage_idle=59.9555,usage_system=30.1477,usage_user=64.4954 7749000000000 +cpu,cpu=0 usage_idle=42.7624,usage_system=13.1877,usage_user=94.5197 7750000000000 +cpu,cpu=1 usage_idle=14.1926,usage_system=68.2077,usage_user=70.8433 7751000000000 +cpu,cpu=2 usage_idle=76.0938,usage_system=39.1814,usage_user=58.8256 7752000000000 +cpu,cpu=3 usage_idle=65.2599,usage_system=76.5355,usage_user=16.9747 7753000000000 +cpu,cpu=4 usage_idle=38.7373,usage_system=62.947,usage_user=54.8793 7754000000000 +cpu,cpu=0 usage_idle=53.6944,usage_system=47.0629,usage_user=73.1333 7755000000000 +cpu,cpu=1 usage_idle=70.345,usage_system=97.6301,usage_user=62.3307 7756000000000 +cpu,cpu=2 usage_idle=98.3854,usage_system=76.5824,usage_user=65.402 7757000000000 +cpu,cpu=3 usage_idle=67.4886,usage_system=74.3589,usage_user=6.90181 7758000000000 +cpu,cpu=4 usage_idle=46.6486,usage_system=34.3144,usage_user=37.0495 7759000000000 +cpu,cpu=0 usage_idle=11.144,usage_system=77.0768,usage_user=50.2372 7760000000000 +cpu,cpu=1 usage_idle=5.6637,usage_system=91.2694,usage_user=18.4449 7761000000000 +cpu,cpu=2 usage_idle=76.507,usage_system=67.3632,usage_user=57.6263 7762000000000 +cpu,cpu=3 usage_idle=35.3326,usage_system=32.6231,usage_user=34.1619 7763000000000 +cpu,cpu=4 usage_idle=52.3073,usage_system=71.3604,usage_user=97.1089 7764000000000 +cpu,cpu=0 usage_idle=7.18654,usage_system=25.0547,usage_user=44.1717 7765000000000 +cpu,cpu=1 usage_idle=80.3198,usage_system=95.3997,usage_user=41.8018 7766000000000 +cpu,cpu=2 usage_idle=42.6506,usage_system=93.7851,usage_user=18.3842 7767000000000 +cpu,cpu=3 usage_idle=8.05255,usage_system=61.2737,usage_user=92.7431 7768000000000 +cpu,cpu=4 usage_idle=14.9544,usage_system=7.92235,usage_user=27.0575 7769000000000 +cpu,cpu=0 usage_idle=52.0038,usage_system=19.0664,usage_user=4.13431 7770000000000 +cpu,cpu=1 usage_idle=2.24099,usage_system=24.7301,usage_user=95.4037 7771000000000 +cpu,cpu=2 usage_idle=20.6859,usage_system=1.23708,usage_user=62.7669 7772000000000 +cpu,cpu=3 usage_idle=78.3122,usage_system=36.5697,usage_user=95.39 7773000000000 +cpu,cpu=4 usage_idle=12.4741,usage_system=88.8769,usage_user=66.7504 7774000000000 +cpu,cpu=0 usage_idle=9.583,usage_system=96.0635,usage_user=91.8051 7775000000000 +cpu,cpu=1 usage_idle=53.7547,usage_system=76.3833,usage_user=87.2048 7776000000000 +cpu,cpu=2 usage_idle=95.5565,usage_system=19.0339,usage_user=80.99 7777000000000 +cpu,cpu=3 usage_idle=13.9407,usage_system=27.0865,usage_user=42.2637 7778000000000 +cpu,cpu=4 usage_idle=6.68383,usage_system=42.0408,usage_user=50.186 7779000000000 +cpu,cpu=0 usage_idle=33.7413,usage_system=94.0446,usage_user=69.2524 7780000000000 +cpu,cpu=1 usage_idle=37.8756,usage_system=96.2856,usage_user=93.9825 7781000000000 +cpu,cpu=2 usage_idle=33.2794,usage_system=16.9715,usage_user=95.2196 7782000000000 +cpu,cpu=3 usage_idle=96.0463,usage_system=95.2838,usage_user=31.7892 7783000000000 +cpu,cpu=4 usage_idle=91.4363,usage_system=7.75788,usage_user=20.6662 7784000000000 +cpu,cpu=0 usage_idle=58.1867,usage_system=17.3409,usage_user=16.7297 7785000000000 +cpu,cpu=1 usage_idle=49.9918,usage_system=71.0956,usage_user=93.113 7786000000000 +cpu,cpu=2 usage_idle=37.1967,usage_system=66.6522,usage_user=12.1469 7787000000000 +cpu,cpu=3 usage_idle=18.1866,usage_system=80.5929,usage_user=39.2334 7788000000000 +cpu,cpu=4 usage_idle=60.4503,usage_system=87.2767,usage_user=81.2742 7789000000000 +cpu,cpu=0 usage_idle=10.6363,usage_system=21.0181,usage_user=75.3188 7790000000000 +cpu,cpu=1 usage_idle=79.8887,usage_system=58.8937,usage_user=71.6045 7791000000000 +cpu,cpu=2 usage_idle=73.8712,usage_system=92.173,usage_user=88.576 7792000000000 +cpu,cpu=3 usage_idle=69.0908,usage_system=88.2193,usage_user=83.8598 7793000000000 +cpu,cpu=4 usage_idle=0.880026,usage_system=79.6557,usage_user=91.6177 7794000000000 +cpu,cpu=0 usage_idle=21.5462,usage_system=37.8424,usage_user=8.95853 7795000000000 +cpu,cpu=1 usage_idle=38.2759,usage_system=87.8342,usage_user=80.0542 7796000000000 +cpu,cpu=2 usage_idle=31.3889,usage_system=25.0309,usage_user=46.7063 7797000000000 +cpu,cpu=3 usage_idle=43.5358,usage_system=43.2175,usage_user=27.2992 7798000000000 +cpu,cpu=4 usage_idle=82.7692,usage_system=3.66783,usage_user=14.576 7799000000000 +cpu,cpu=0 usage_idle=64.0434,usage_system=14.3042,usage_user=35.594 7800000000000 +cpu,cpu=1 usage_idle=39.3622,usage_system=94.1929,usage_user=94.4877 7801000000000 +cpu,cpu=2 usage_idle=10.9667,usage_system=68.0641,usage_user=86.6608 7802000000000 +cpu,cpu=3 usage_idle=99.5427,usage_system=37.1549,usage_user=74.8801 7803000000000 +cpu,cpu=4 usage_idle=83.4025,usage_system=38.0349,usage_user=54.5358 7804000000000 +cpu,cpu=0 usage_idle=75.0201,usage_system=59.5812,usage_user=92.3781 7805000000000 +cpu,cpu=1 usage_idle=83.9787,usage_system=97.8571,usage_user=80.2124 7806000000000 +cpu,cpu=2 usage_idle=64.0328,usage_system=29.246,usage_user=5.24324 7807000000000 +cpu,cpu=3 usage_idle=10.7392,usage_system=72.7818,usage_user=48.4608 7808000000000 +cpu,cpu=4 usage_idle=38.0384,usage_system=55.551,usage_user=52.1286 7809000000000 +cpu,cpu=0 usage_idle=52.6144,usage_system=19.5944,usage_user=66.4327 7810000000000 +cpu,cpu=1 usage_idle=88.2084,usage_system=58.9566,usage_user=60.6256 7811000000000 +cpu,cpu=2 usage_idle=82.6962,usage_system=69.9233,usage_user=28.6898 7812000000000 +cpu,cpu=3 usage_idle=69.3569,usage_system=69.466,usage_user=65.8447 7813000000000 +cpu,cpu=4 usage_idle=44.237,usage_system=52.8685,usage_user=3.87961 7814000000000 +cpu,cpu=0 usage_idle=98.7728,usage_system=27.8886,usage_user=63.4608 7815000000000 +cpu,cpu=1 usage_idle=91.1509,usage_system=11.8673,usage_user=61.3178 7816000000000 +cpu,cpu=2 usage_idle=71.3633,usage_system=75.9001,usage_user=90.5638 7817000000000 +cpu,cpu=3 usage_idle=76.6065,usage_system=86.6393,usage_user=63.3456 7818000000000 +cpu,cpu=4 usage_idle=25.0673,usage_system=24.6777,usage_user=18.8965 7819000000000 +cpu,cpu=0 usage_idle=77.1959,usage_system=77.2921,usage_user=38.4909 7820000000000 +cpu,cpu=1 usage_idle=43.6286,usage_system=65.5005,usage_user=97.4475 7821000000000 +cpu,cpu=2 usage_idle=4.25426,usage_system=48.1967,usage_user=67.3709 7822000000000 +cpu,cpu=3 usage_idle=32.944,usage_system=17.5536,usage_user=36.8369 7823000000000 +cpu,cpu=4 usage_idle=98.7887,usage_system=61.7906,usage_user=89.7054 7824000000000 +cpu,cpu=0 usage_idle=2.66832,usage_system=60.5634,usage_user=17.594 7825000000000 +cpu,cpu=1 usage_idle=66.1291,usage_system=51.7143,usage_user=29.4613 7826000000000 +cpu,cpu=2 usage_idle=27.4469,usage_system=23.0776,usage_user=5.36147 7827000000000 +cpu,cpu=3 usage_idle=18.0107,usage_system=99.6841,usage_user=92.0008 7828000000000 +cpu,cpu=4 usage_idle=81.3562,usage_system=24.7514,usage_user=16.6785 7829000000000 +cpu,cpu=0 usage_idle=0.252763,usage_system=1.9473,usage_user=93.9706 7830000000000 +cpu,cpu=1 usage_idle=38.7437,usage_system=45.5759,usage_user=59.4711 7831000000000 +cpu,cpu=2 usage_idle=36.1912,usage_system=49.8302,usage_user=7.66776 7832000000000 +cpu,cpu=3 usage_idle=3.56208,usage_system=82.7742,usage_user=25.2213 7833000000000 +cpu,cpu=4 usage_idle=40.399,usage_system=81.5629,usage_user=87.012 7834000000000 +cpu,cpu=0 usage_idle=30.1043,usage_system=84.2312,usage_user=47.5753 7835000000000 +cpu,cpu=1 usage_idle=47.6984,usage_system=50.3603,usage_user=99.2897 7836000000000 +cpu,cpu=2 usage_idle=77.1597,usage_system=77.8072,usage_user=22.3673 7837000000000 +cpu,cpu=3 usage_idle=82.5212,usage_system=95.8179,usage_user=22.0514 7838000000000 +cpu,cpu=4 usage_idle=74.5219,usage_system=77.1741,usage_user=46.8029 7839000000000 +cpu,cpu=0 usage_idle=91.2004,usage_system=77.4269,usage_user=48.7502 7840000000000 +cpu,cpu=1 usage_idle=85.171,usage_system=16.1706,usage_user=94.3261 7841000000000 +cpu,cpu=2 usage_idle=44.6421,usage_system=52.3618,usage_user=44.1563 7842000000000 +cpu,cpu=3 usage_idle=52.3098,usage_system=55.9239,usage_user=26.9305 7843000000000 +cpu,cpu=4 usage_idle=77.5312,usage_system=96.3228,usage_user=8.49337 7844000000000 +cpu,cpu=0 usage_idle=64.5431,usage_system=26.4272,usage_user=92.7246 7845000000000 +cpu,cpu=1 usage_idle=12.1185,usage_system=74.1255,usage_user=43.0849 7846000000000 +cpu,cpu=2 usage_idle=11.4081,usage_system=51.2853,usage_user=20.8921 7847000000000 +cpu,cpu=3 usage_idle=33.7754,usage_system=33.8064,usage_user=16.71 7848000000000 +cpu,cpu=4 usage_idle=55.8269,usage_system=8.32838,usage_user=93.8841 7849000000000 +cpu,cpu=0 usage_idle=2.62972,usage_system=99.5288,usage_user=71.311 7850000000000 +cpu,cpu=1 usage_idle=51.3799,usage_system=84.6998,usage_user=87.4816 7851000000000 +cpu,cpu=2 usage_idle=45.706,usage_system=29.3418,usage_user=39.8433 7852000000000 +cpu,cpu=3 usage_idle=89.8622,usage_system=81.6516,usage_user=95.7672 7853000000000 +cpu,cpu=4 usage_idle=16.7927,usage_system=59.1828,usage_user=92.09 7854000000000 +cpu,cpu=0 usage_idle=25.286,usage_system=23.7259,usage_user=18.5172 7855000000000 +cpu,cpu=1 usage_idle=18.0106,usage_system=35.8443,usage_user=92.6428 7856000000000 +cpu,cpu=2 usage_idle=61.0956,usage_system=47.2525,usage_user=43.928 7857000000000 +cpu,cpu=3 usage_idle=81.9877,usage_system=81.0279,usage_user=77.7344 7858000000000 +cpu,cpu=4 usage_idle=98.6977,usage_system=36.8547,usage_user=86.0628 7859000000000 +cpu,cpu=0 usage_idle=92.5819,usage_system=39.4845,usage_user=85.5916 7860000000000 +cpu,cpu=1 usage_idle=63.8929,usage_system=90.8644,usage_user=70.2914 7861000000000 +cpu,cpu=2 usage_idle=51.3744,usage_system=36.5703,usage_user=99.6332 7862000000000 +cpu,cpu=3 usage_idle=91.2177,usage_system=26.4325,usage_user=81.2848 7863000000000 +cpu,cpu=4 usage_idle=86.9849,usage_system=43.2252,usage_user=40.4676 7864000000000 +cpu,cpu=0 usage_idle=79.075,usage_system=68.5112,usage_user=64.1935 7865000000000 +cpu,cpu=1 usage_idle=97.5922,usage_system=86.5219,usage_user=0.0378452 7866000000000 +cpu,cpu=2 usage_idle=90.2349,usage_system=47.6175,usage_user=47.2903 7867000000000 +cpu,cpu=3 usage_idle=34.1629,usage_system=29.6052,usage_user=28.3182 7868000000000 +cpu,cpu=4 usage_idle=11.8974,usage_system=28.3029,usage_user=65.173 7869000000000 +cpu,cpu=0 usage_idle=97.9602,usage_system=20.8847,usage_user=4.65742 7870000000000 +cpu,cpu=1 usage_idle=83.5518,usage_system=84.7776,usage_user=95.5218 7871000000000 +cpu,cpu=2 usage_idle=53.8432,usage_system=36.152,usage_user=32.0921 7872000000000 +cpu,cpu=3 usage_idle=53.4764,usage_system=27.3697,usage_user=58.5246 7873000000000 +cpu,cpu=4 usage_idle=34.7612,usage_system=14.3547,usage_user=1.74984 7874000000000 +cpu,cpu=0 usage_idle=75.2288,usage_system=93.4297,usage_user=70.2611 7875000000000 +cpu,cpu=1 usage_idle=39.4223,usage_system=91.0218,usage_user=56.783 7876000000000 +cpu,cpu=2 usage_idle=39.4602,usage_system=81.2567,usage_user=4.40044 7877000000000 +cpu,cpu=3 usage_idle=86.7505,usage_system=15.4197,usage_user=34.0056 7878000000000 +cpu,cpu=4 usage_idle=15.0687,usage_system=27.317,usage_user=62.3085 7879000000000 +cpu,cpu=0 usage_idle=80.2417,usage_system=25.2772,usage_user=83.1932 7880000000000 +cpu,cpu=1 usage_idle=84.8991,usage_system=8.82904,usage_user=67.9708 7881000000000 +cpu,cpu=2 usage_idle=80.4209,usage_system=62.6722,usage_user=4.12282 7882000000000 +cpu,cpu=3 usage_idle=12.513,usage_system=16.1486,usage_user=31.4926 7883000000000 +cpu,cpu=4 usage_idle=71.0376,usage_system=50.9098,usage_user=45.8472 7884000000000 +cpu,cpu=0 usage_idle=72.7874,usage_system=26.1387,usage_user=39.2769 7885000000000 +cpu,cpu=1 usage_idle=43.0485,usage_system=65.561,usage_user=30.2987 7886000000000 +cpu,cpu=2 usage_idle=99.8315,usage_system=5.02121,usage_user=11.5555 7887000000000 +cpu,cpu=3 usage_idle=4.23194,usage_system=91.7717,usage_user=26.9751 7888000000000 +cpu,cpu=4 usage_idle=38.2375,usage_system=6.84043,usage_user=54.2922 7889000000000 +cpu,cpu=0 usage_idle=0.546036,usage_system=87.0821,usage_user=79.5694 7890000000000 +cpu,cpu=1 usage_idle=83.7393,usage_system=71.9812,usage_user=88.3985 7891000000000 +cpu,cpu=2 usage_idle=51.7101,usage_system=52.402,usage_user=51.0707 7892000000000 +cpu,cpu=3 usage_idle=55.8329,usage_system=64.915,usage_user=67.2193 7893000000000 +cpu,cpu=4 usage_idle=87.3255,usage_system=35.9526,usage_user=18.1292 7894000000000 +cpu,cpu=0 usage_idle=33.1727,usage_system=8.74002,usage_user=44.2678 7895000000000 +cpu,cpu=1 usage_idle=72.4496,usage_system=51.7885,usage_user=9.82887 7896000000000 +cpu,cpu=2 usage_idle=2.74832,usage_system=51.62,usage_user=14.8501 7897000000000 +cpu,cpu=3 usage_idle=14.3038,usage_system=55.852,usage_user=6.6218 7898000000000 +cpu,cpu=4 usage_idle=41.2789,usage_system=94.0895,usage_user=13.4622 7899000000000 +cpu,cpu=0 usage_idle=95.5711,usage_system=94.6356,usage_user=0.544315 7900000000000 +cpu,cpu=1 usage_idle=75.1405,usage_system=78.3748,usage_user=72.5255 7901000000000 +cpu,cpu=2 usage_idle=63.539,usage_system=30.0849,usage_user=24.9275 7902000000000 +cpu,cpu=3 usage_idle=14.6096,usage_system=85.9178,usage_user=89.8425 7903000000000 +cpu,cpu=4 usage_idle=81.8289,usage_system=73.2433,usage_user=25.7951 7904000000000 +cpu,cpu=0 usage_idle=99.9581,usage_system=6.41599,usage_user=34.5351 7905000000000 +cpu,cpu=1 usage_idle=44.2259,usage_system=78.8656,usage_user=86.3237 7906000000000 +cpu,cpu=2 usage_idle=54.0548,usage_system=81.6139,usage_user=37.9437 7907000000000 +cpu,cpu=3 usage_idle=68.9049,usage_system=95.9177,usage_user=93.7957 7908000000000 +cpu,cpu=4 usage_idle=75.5267,usage_system=37.1966,usage_user=87.8852 7909000000000 +cpu,cpu=0 usage_idle=88.9889,usage_system=32.7677,usage_user=82.5208 7910000000000 +cpu,cpu=1 usage_idle=89.5332,usage_system=7.90819,usage_user=60.8956 7911000000000 +cpu,cpu=2 usage_idle=62.0587,usage_system=71.4472,usage_user=90.9806 7912000000000 +cpu,cpu=3 usage_idle=86.9862,usage_system=86.0568,usage_user=76.8984 7913000000000 +cpu,cpu=4 usage_idle=76.8288,usage_system=67.8857,usage_user=50.1417 7914000000000 +cpu,cpu=0 usage_idle=2.62391,usage_system=67.8438,usage_user=56.5576 7915000000000 +cpu,cpu=1 usage_idle=37.1591,usage_system=12.0698,usage_user=35.4232 7916000000000 +cpu,cpu=2 usage_idle=23.4827,usage_system=66.1246,usage_user=17.0371 7917000000000 +cpu,cpu=3 usage_idle=61.4265,usage_system=35.0295,usage_user=12.9548 7918000000000 +cpu,cpu=4 usage_idle=55.2222,usage_system=10.5561,usage_user=50.1514 7919000000000 +cpu,cpu=0 usage_idle=43.1074,usage_system=99.5451,usage_user=82.9191 7920000000000 +cpu,cpu=1 usage_idle=25.6282,usage_system=89.0783,usage_user=90.8273 7921000000000 +cpu,cpu=2 usage_idle=86.5239,usage_system=51.137,usage_user=62.2745 7922000000000 +cpu,cpu=3 usage_idle=77.5044,usage_system=38.1232,usage_user=48.3312 7923000000000 +cpu,cpu=4 usage_idle=54.4028,usage_system=14.952,usage_user=16.217 7924000000000 +cpu,cpu=0 usage_idle=4.54447,usage_system=17.5759,usage_user=84.0608 7925000000000 +cpu,cpu=1 usage_idle=61.1021,usage_system=54.735,usage_user=96.1306 7926000000000 +cpu,cpu=2 usage_idle=96.5254,usage_system=78.2177,usage_user=62.2552 7927000000000 +cpu,cpu=3 usage_idle=13.5625,usage_system=39.6442,usage_user=97.2846 7928000000000 +cpu,cpu=4 usage_idle=26.5173,usage_system=94.8664,usage_user=7.84079 7929000000000 +cpu,cpu=0 usage_idle=76.6688,usage_system=37.9738,usage_user=7.38584 7930000000000 +cpu,cpu=1 usage_idle=59.5879,usage_system=63.6021,usage_user=96.4641 7931000000000 +cpu,cpu=2 usage_idle=50.4152,usage_system=50.1259,usage_user=47.6011 7932000000000 +cpu,cpu=3 usage_idle=12.6896,usage_system=27.6304,usage_user=85.7243 7933000000000 +cpu,cpu=4 usage_idle=61.0209,usage_system=82.0332,usage_user=0.676337 7934000000000 +cpu,cpu=0 usage_idle=77.2378,usage_system=86.5777,usage_user=18.2523 7935000000000 +cpu,cpu=1 usage_idle=61.2987,usage_system=47.6798,usage_user=72.9872 7936000000000 +cpu,cpu=2 usage_idle=57.4293,usage_system=44.2052,usage_user=51.2049 7937000000000 +cpu,cpu=3 usage_idle=19.6844,usage_system=57.7677,usage_user=90.8491 7938000000000 +cpu,cpu=4 usage_idle=16.9691,usage_system=84.285,usage_user=85.7155 7939000000000 +cpu,cpu=0 usage_idle=24.8099,usage_system=60.9538,usage_user=23.6893 7940000000000 +cpu,cpu=1 usage_idle=32.1957,usage_system=20.5416,usage_user=87.2914 7941000000000 +cpu,cpu=2 usage_idle=28.6598,usage_system=70.9568,usage_user=37.4173 7942000000000 +cpu,cpu=3 usage_idle=76.2609,usage_system=83.6464,usage_user=65.0477 7943000000000 +cpu,cpu=4 usage_idle=61.9852,usage_system=44.6673,usage_user=47.0809 7944000000000 +cpu,cpu=0 usage_idle=62.6616,usage_system=21.9051,usage_user=33.6586 7945000000000 +cpu,cpu=1 usage_idle=80.9138,usage_system=83.2037,usage_user=81.3384 7946000000000 +cpu,cpu=2 usage_idle=53.901,usage_system=40.633,usage_user=25.5435 7947000000000 +cpu,cpu=3 usage_idle=5.10599,usage_system=60.3174,usage_user=83.3112 7948000000000 +cpu,cpu=4 usage_idle=95.9551,usage_system=77.2865,usage_user=67.5962 7949000000000 +cpu,cpu=0 usage_idle=81.6706,usage_system=2.09637,usage_user=28.55 7950000000000 +cpu,cpu=1 usage_idle=5.35997,usage_system=34.2921,usage_user=49.0916 7951000000000 +cpu,cpu=2 usage_idle=92.6514,usage_system=62.9519,usage_user=20.0483 7952000000000 +cpu,cpu=3 usage_idle=30.0687,usage_system=39.2128,usage_user=3.69474 7953000000000 +cpu,cpu=4 usage_idle=95.1164,usage_system=1.19801,usage_user=48.362 7954000000000 +cpu,cpu=0 usage_idle=42.1973,usage_system=63.8596,usage_user=70.2671 7955000000000 +cpu,cpu=1 usage_idle=75.8559,usage_system=44.7734,usage_user=53.4708 7956000000000 +cpu,cpu=2 usage_idle=57.1943,usage_system=98.6744,usage_user=94.1038 7957000000000 +cpu,cpu=3 usage_idle=82.7379,usage_system=3.78042,usage_user=54.4213 7958000000000 +cpu,cpu=4 usage_idle=66.0491,usage_system=99.7355,usage_user=31.7078 7959000000000 +cpu,cpu=0 usage_idle=33.6453,usage_system=81.4062,usage_user=33.8041 7960000000000 +cpu,cpu=1 usage_idle=62.1953,usage_system=86.7661,usage_user=68.0962 7961000000000 +cpu,cpu=2 usage_idle=11.2868,usage_system=79.4175,usage_user=31.0481 7962000000000 +cpu,cpu=3 usage_idle=31.3352,usage_system=9.4862,usage_user=70.2609 7963000000000 +cpu,cpu=4 usage_idle=35.0299,usage_system=4.60262,usage_user=71.4589 7964000000000 +cpu,cpu=0 usage_idle=83.3919,usage_system=46.8,usage_user=35.3184 7965000000000 +cpu,cpu=1 usage_idle=53.659,usage_system=22.6559,usage_user=80.0918 7966000000000 +cpu,cpu=2 usage_idle=7.12982,usage_system=79.8502,usage_user=78.7663 7967000000000 +cpu,cpu=3 usage_idle=1.23365,usage_system=62.5881,usage_user=82.5467 7968000000000 +cpu,cpu=4 usage_idle=55.6549,usage_system=28.6372,usage_user=82.2822 7969000000000 +cpu,cpu=0 usage_idle=87.3627,usage_system=62.2825,usage_user=63.6884 7970000000000 +cpu,cpu=1 usage_idle=21.1668,usage_system=24.4777,usage_user=50.4545 7971000000000 +cpu,cpu=2 usage_idle=89.263,usage_system=35.7646,usage_user=29.872 7972000000000 +cpu,cpu=3 usage_idle=20.3111,usage_system=67.0997,usage_user=39.3582 7973000000000 +cpu,cpu=4 usage_idle=90.572,usage_system=2.12964,usage_user=43.9608 7974000000000 +cpu,cpu=0 usage_idle=62.0308,usage_system=85.5215,usage_user=90.7608 7975000000000 +cpu,cpu=1 usage_idle=97.3492,usage_system=39.1805,usage_user=13.4167 7976000000000 +cpu,cpu=2 usage_idle=77.4411,usage_system=46.3104,usage_user=93.2669 7977000000000 +cpu,cpu=3 usage_idle=56.2073,usage_system=47.544,usage_user=55.855 7978000000000 +cpu,cpu=4 usage_idle=38.754,usage_system=3.19893,usage_user=84.4922 7979000000000 +cpu,cpu=0 usage_idle=21.0362,usage_system=90.5616,usage_user=46.7747 7980000000000 +cpu,cpu=1 usage_idle=84.7246,usage_system=11.7284,usage_user=71.2525 7981000000000 +cpu,cpu=2 usage_idle=35.1791,usage_system=0.99147,usage_user=7.01704 7982000000000 +cpu,cpu=3 usage_idle=65.0511,usage_system=21.3026,usage_user=74.1168 7983000000000 +cpu,cpu=4 usage_idle=4.40935,usage_system=11.8745,usage_user=76.2464 7984000000000 +cpu,cpu=0 usage_idle=48.3702,usage_system=73.9053,usage_user=61.768 7985000000000 +cpu,cpu=1 usage_idle=39.131,usage_system=71.2546,usage_user=0.9485 7986000000000 +cpu,cpu=2 usage_idle=52.5477,usage_system=48.6956,usage_user=47.2589 7987000000000 +cpu,cpu=3 usage_idle=45.8146,usage_system=4.90294,usage_user=94.8029 7988000000000 +cpu,cpu=4 usage_idle=1.66968,usage_system=43.6569,usage_user=98.0018 7989000000000 +cpu,cpu=0 usage_idle=86.1619,usage_system=64.6931,usage_user=88.5634 7990000000000 +cpu,cpu=1 usage_idle=32.9367,usage_system=49.4177,usage_user=0.29185 7991000000000 +cpu,cpu=2 usage_idle=4.18913,usage_system=84.5968,usage_user=1.28332 7992000000000 +cpu,cpu=3 usage_idle=11.2062,usage_system=49.6479,usage_user=22.5859 7993000000000 +cpu,cpu=4 usage_idle=85.3229,usage_system=54.0573,usage_user=34.4604 7994000000000 +cpu,cpu=0 usage_idle=61.5694,usage_system=2.42747,usage_user=8.36576 7995000000000 +cpu,cpu=1 usage_idle=23.3373,usage_system=41.5585,usage_user=79.6203 7996000000000 +cpu,cpu=2 usage_idle=24.2858,usage_system=94.1062,usage_user=28.316 7997000000000 +cpu,cpu=3 usage_idle=71.5447,usage_system=39.9208,usage_user=33.2189 7998000000000 +cpu,cpu=4 usage_idle=66.3475,usage_system=41.5905,usage_user=76.8758 7999000000000 +cpu,cpu=0 usage_idle=64.3493,usage_system=27.7524,usage_user=41.5689 8000000000000 +cpu,cpu=1 usage_idle=52.9127,usage_system=60.6891,usage_user=90.9866 8001000000000 +cpu,cpu=2 usage_idle=53.2046,usage_system=64.8782,usage_user=75.5835 8002000000000 +cpu,cpu=3 usage_idle=54.4879,usage_system=76.0844,usage_user=25.2314 8003000000000 +cpu,cpu=4 usage_idle=77.0738,usage_system=61.4073,usage_user=79.2887 8004000000000 +cpu,cpu=0 usage_idle=11.5342,usage_system=22.9767,usage_user=81.7161 8005000000000 +cpu,cpu=1 usage_idle=19.9,usage_system=46.314,usage_user=23.2746 8006000000000 +cpu,cpu=2 usage_idle=99.5203,usage_system=70.5998,usage_user=17.3808 8007000000000 +cpu,cpu=3 usage_idle=27.8363,usage_system=42.1445,usage_user=57.3015 8008000000000 +cpu,cpu=4 usage_idle=61.0552,usage_system=8.49201,usage_user=98.892 8009000000000 +cpu,cpu=0 usage_idle=37.931,usage_system=72.8413,usage_user=26.6444 8010000000000 +cpu,cpu=1 usage_idle=79.5,usage_system=25.7541,usage_user=87.3335 8011000000000 +cpu,cpu=2 usage_idle=70.4866,usage_system=78.9587,usage_user=52.2117 8012000000000 +cpu,cpu=3 usage_idle=46.07,usage_system=33.4466,usage_user=28.296 8013000000000 +cpu,cpu=4 usage_idle=71.3014,usage_system=10.5204,usage_user=89.7033 8014000000000 +cpu,cpu=0 usage_idle=50.5901,usage_system=22.0546,usage_user=12.68 8015000000000 +cpu,cpu=1 usage_idle=32.3062,usage_system=41.9546,usage_user=58.994 8016000000000 +cpu,cpu=2 usage_idle=55.5808,usage_system=41.4749,usage_user=29.5938 8017000000000 +cpu,cpu=3 usage_idle=72.9616,usage_system=69.3111,usage_user=71.7382 8018000000000 +cpu,cpu=4 usage_idle=30.2631,usage_system=30.3663,usage_user=80.2302 8019000000000 +cpu,cpu=0 usage_idle=29.1551,usage_system=68.2973,usage_user=53.0716 8020000000000 +cpu,cpu=1 usage_idle=55.7996,usage_system=47.7973,usage_user=78.8257 8021000000000 +cpu,cpu=2 usage_idle=43.1331,usage_system=18.2839,usage_user=57.7843 8022000000000 +cpu,cpu=3 usage_idle=95.3447,usage_system=64.3539,usage_user=91.2309 8023000000000 +cpu,cpu=4 usage_idle=23.6408,usage_system=35.6554,usage_user=1.75128 8024000000000 +cpu,cpu=0 usage_idle=13.3441,usage_system=86.2454,usage_user=23.8059 8025000000000 +cpu,cpu=1 usage_idle=26.0241,usage_system=18.5517,usage_user=65.7604 8026000000000 +cpu,cpu=2 usage_idle=85.0181,usage_system=74.1325,usage_user=7.23532 8027000000000 +cpu,cpu=3 usage_idle=14.6119,usage_system=47.0941,usage_user=76.5465 8028000000000 +cpu,cpu=4 usage_idle=86.3501,usage_system=77.3572,usage_user=6.91278 8029000000000 +cpu,cpu=0 usage_idle=66.5803,usage_system=6.51233,usage_user=75.2101 8030000000000 +cpu,cpu=1 usage_idle=19.6519,usage_system=62.3119,usage_user=23.0074 8031000000000 +cpu,cpu=2 usage_idle=98.4776,usage_system=5.44496,usage_user=41.2912 8032000000000 +cpu,cpu=3 usage_idle=56.2619,usage_system=0.789694,usage_user=5.64517 8033000000000 +cpu,cpu=4 usage_idle=47.4928,usage_system=24.4305,usage_user=41.3005 8034000000000 +cpu,cpu=0 usage_idle=49.2441,usage_system=37.7746,usage_user=27.546 8035000000000 +cpu,cpu=1 usage_idle=73.05,usage_system=63.7987,usage_user=46.0976 8036000000000 +cpu,cpu=2 usage_idle=38.8104,usage_system=48.8168,usage_user=20.2301 8037000000000 +cpu,cpu=3 usage_idle=46.0458,usage_system=63.4286,usage_user=67.3242 8038000000000 +cpu,cpu=4 usage_idle=22.5922,usage_system=49.7787,usage_user=44.6814 8039000000000 +cpu,cpu=0 usage_idle=29.505,usage_system=16.3591,usage_user=51.1937 8040000000000 +cpu,cpu=1 usage_idle=4.7151,usage_system=36.011,usage_user=13.5056 8041000000000 +cpu,cpu=2 usage_idle=27.7225,usage_system=34.4886,usage_user=18.9506 8042000000000 +cpu,cpu=3 usage_idle=69.0137,usage_system=90.7505,usage_user=19.7403 8043000000000 +cpu,cpu=4 usage_idle=74.6589,usage_system=38.2434,usage_user=44.1707 8044000000000 +cpu,cpu=0 usage_idle=15.9594,usage_system=87.4875,usage_user=81.9453 8045000000000 +cpu,cpu=1 usage_idle=43.5054,usage_system=60.5375,usage_user=45.744 8046000000000 +cpu,cpu=2 usage_idle=89.603,usage_system=99.3479,usage_user=94.5608 8047000000000 +cpu,cpu=3 usage_idle=9.83314,usage_system=45.3937,usage_user=57.9894 8048000000000 +cpu,cpu=4 usage_idle=77.1573,usage_system=67.9859,usage_user=7.76813 8049000000000 +cpu,cpu=0 usage_idle=21.8387,usage_system=97.4909,usage_user=24.1272 8050000000000 +cpu,cpu=1 usage_idle=73.0324,usage_system=2.206,usage_user=60.1382 8051000000000 +cpu,cpu=2 usage_idle=86.538,usage_system=29.9285,usage_user=94.6268 8052000000000 +cpu,cpu=3 usage_idle=5.4886,usage_system=98.9422,usage_user=85.3773 8053000000000 +cpu,cpu=4 usage_idle=25.2289,usage_system=73.6011,usage_user=23.6206 8054000000000 +cpu,cpu=0 usage_idle=69.3996,usage_system=89.5605,usage_user=11.1081 8055000000000 +cpu,cpu=1 usage_idle=51.3449,usage_system=33.0658,usage_user=71.6456 8056000000000 +cpu,cpu=2 usage_idle=97.0889,usage_system=22.6688,usage_user=70.9935 8057000000000 +cpu,cpu=3 usage_idle=91.6497,usage_system=32.502,usage_user=16.3872 8058000000000 +cpu,cpu=4 usage_idle=49.6391,usage_system=9.65929,usage_user=84.3731 8059000000000 +cpu,cpu=0 usage_idle=57.4072,usage_system=31.498,usage_user=81.864 8060000000000 +cpu,cpu=1 usage_idle=81.5344,usage_system=4.53043,usage_user=84.07 8061000000000 +cpu,cpu=2 usage_idle=41.6726,usage_system=91.0685,usage_user=13.9985 8062000000000 +cpu,cpu=3 usage_idle=36.2994,usage_system=96.5571,usage_user=12.9406 8063000000000 +cpu,cpu=4 usage_idle=21.6767,usage_system=21.7859,usage_user=86.5417 8064000000000 +cpu,cpu=0 usage_idle=45.2973,usage_system=91.1855,usage_user=76.1021 8065000000000 +cpu,cpu=1 usage_idle=56.4054,usage_system=42.5304,usage_user=9.16796 8066000000000 +cpu,cpu=2 usage_idle=28.051,usage_system=39.6193,usage_user=31.8368 8067000000000 +cpu,cpu=3 usage_idle=99.0445,usage_system=31.269,usage_user=64.3387 8068000000000 +cpu,cpu=4 usage_idle=15.4317,usage_system=80.9081,usage_user=73.998 8069000000000 +cpu,cpu=0 usage_idle=99.8048,usage_system=38.3153,usage_user=5.49603 8070000000000 +cpu,cpu=1 usage_idle=81.6688,usage_system=19.8497,usage_user=10.0265 8071000000000 +cpu,cpu=2 usage_idle=65.7387,usage_system=61.5224,usage_user=1.09493 8072000000000 +cpu,cpu=3 usage_idle=79.7372,usage_system=97.8217,usage_user=97.652 8073000000000 +cpu,cpu=4 usage_idle=92.6778,usage_system=19.4984,usage_user=19.4379 8074000000000 +cpu,cpu=0 usage_idle=79.2195,usage_system=64.7957,usage_user=10.6234 8075000000000 +cpu,cpu=1 usage_idle=55.3217,usage_system=21.2011,usage_user=53.1538 8076000000000 +cpu,cpu=2 usage_idle=64.4896,usage_system=49.2521,usage_user=92.7731 8077000000000 +cpu,cpu=3 usage_idle=96.3264,usage_system=48.2965,usage_user=24.0421 8078000000000 +cpu,cpu=4 usage_idle=60.6652,usage_system=63.7282,usage_user=4.95018 8079000000000 +cpu,cpu=0 usage_idle=34.6632,usage_system=63.533,usage_user=43.2655 8080000000000 +cpu,cpu=1 usage_idle=40.1592,usage_system=45.2017,usage_user=63.1153 8081000000000 +cpu,cpu=2 usage_idle=50.1857,usage_system=10.9405,usage_user=24.6376 8082000000000 +cpu,cpu=3 usage_idle=51.2806,usage_system=90.6777,usage_user=22.4593 8083000000000 +cpu,cpu=4 usage_idle=48.9326,usage_system=83.3555,usage_user=41.9577 8084000000000 +cpu,cpu=0 usage_idle=68.3705,usage_system=62.5751,usage_user=6.75339 8085000000000 +cpu,cpu=1 usage_idle=78.9939,usage_system=17.8967,usage_user=27.9545 8086000000000 +cpu,cpu=2 usage_idle=32.1477,usage_system=82.3864,usage_user=77.2065 8087000000000 +cpu,cpu=3 usage_idle=24.9208,usage_system=78.7128,usage_user=25.503 8088000000000 +cpu,cpu=4 usage_idle=48.9629,usage_system=39.378,usage_user=89.2313 8089000000000 +cpu,cpu=0 usage_idle=53.9131,usage_system=74.0411,usage_user=52.7642 8090000000000 +cpu,cpu=1 usage_idle=97.1786,usage_system=14.2004,usage_user=97.9659 8091000000000 +cpu,cpu=2 usage_idle=60.2938,usage_system=64.386,usage_user=8.90642 8092000000000 +cpu,cpu=3 usage_idle=84.9315,usage_system=15.6667,usage_user=99.5841 8093000000000 +cpu,cpu=4 usage_idle=7.39079,usage_system=64.5992,usage_user=82.9396 8094000000000 +cpu,cpu=0 usage_idle=49.3485,usage_system=32.9697,usage_user=45.5147 8095000000000 +cpu,cpu=1 usage_idle=56.1019,usage_system=11.9636,usage_user=63.4114 8096000000000 +cpu,cpu=2 usage_idle=84.0563,usage_system=44.1113,usage_user=45.7978 8097000000000 +cpu,cpu=3 usage_idle=61.2629,usage_system=69.0321,usage_user=24.5106 8098000000000 +cpu,cpu=4 usage_idle=86.7659,usage_system=17.995,usage_user=63.8885 8099000000000 +cpu,cpu=0 usage_idle=75.9972,usage_system=71.9081,usage_user=37.9297 8100000000000 +cpu,cpu=1 usage_idle=28.7614,usage_system=69.0867,usage_user=52.13 8101000000000 +cpu,cpu=2 usage_idle=26.7273,usage_system=29.3805,usage_user=16.5161 8102000000000 +cpu,cpu=3 usage_idle=35.6337,usage_system=14.312,usage_user=32.1827 8103000000000 +cpu,cpu=4 usage_idle=35.2178,usage_system=21.7028,usage_user=96.782 8104000000000 +cpu,cpu=0 usage_idle=18.1574,usage_system=71.0513,usage_user=29.7517 8105000000000 +cpu,cpu=1 usage_idle=63.6721,usage_system=27.1532,usage_user=41.7154 8106000000000 +cpu,cpu=2 usage_idle=27.0835,usage_system=11.2095,usage_user=85.8267 8107000000000 +cpu,cpu=3 usage_idle=72.8812,usage_system=72.4724,usage_user=54.8588 8108000000000 +cpu,cpu=4 usage_idle=97.3918,usage_system=59.2383,usage_user=72.8539 8109000000000 +cpu,cpu=0 usage_idle=61.2803,usage_system=35.2354,usage_user=44.762 8110000000000 +cpu,cpu=1 usage_idle=99.21,usage_system=63.9968,usage_user=13.8487 8111000000000 +cpu,cpu=2 usage_idle=51.3401,usage_system=90.7241,usage_user=43.2292 8112000000000 +cpu,cpu=3 usage_idle=67.8561,usage_system=26.3579,usage_user=57.5412 8113000000000 +cpu,cpu=4 usage_idle=0.0388877,usage_system=61.5757,usage_user=79.244 8114000000000 +cpu,cpu=0 usage_idle=96.8209,usage_system=79.7331,usage_user=50.2953 8115000000000 +cpu,cpu=1 usage_idle=26.5726,usage_system=43.4052,usage_user=77.4485 8116000000000 +cpu,cpu=2 usage_idle=68.288,usage_system=70.4887,usage_user=88.658 8117000000000 +cpu,cpu=3 usage_idle=54.1146,usage_system=43.3699,usage_user=61.1304 8118000000000 +cpu,cpu=4 usage_idle=8.97346,usage_system=40.7617,usage_user=20.3687 8119000000000 +cpu,cpu=0 usage_idle=81.8273,usage_system=2.04209,usage_user=55.6041 8120000000000 +cpu,cpu=1 usage_idle=26.5893,usage_system=1.25211,usage_user=19.601 8121000000000 +cpu,cpu=2 usage_idle=40.438,usage_system=52.5922,usage_user=10.3251 8122000000000 +cpu,cpu=3 usage_idle=83.6672,usage_system=20.4483,usage_user=36.683 8123000000000 +cpu,cpu=4 usage_idle=41.2084,usage_system=20.4872,usage_user=98.2587 8124000000000 +cpu,cpu=0 usage_idle=20.4524,usage_system=17.3081,usage_user=77.9918 8125000000000 +cpu,cpu=1 usage_idle=70.7477,usage_system=43.8807,usage_user=21.397 8126000000000 +cpu,cpu=2 usage_idle=48.1962,usage_system=12.1686,usage_user=91.8857 8127000000000 +cpu,cpu=3 usage_idle=36.8542,usage_system=66.2833,usage_user=35.2557 8128000000000 +cpu,cpu=4 usage_idle=97.9846,usage_system=75.2567,usage_user=76.0174 8129000000000 +cpu,cpu=0 usage_idle=18.3533,usage_system=57.084,usage_user=78.0595 8130000000000 +cpu,cpu=1 usage_idle=73.9575,usage_system=83.6733,usage_user=79.3116 8131000000000 +cpu,cpu=2 usage_idle=93.5584,usage_system=24.1113,usage_user=31.9038 8132000000000 +cpu,cpu=3 usage_idle=3.88351,usage_system=7.77845,usage_user=52.3521 8133000000000 +cpu,cpu=4 usage_idle=40.5665,usage_system=48.9868,usage_user=72.8393 8134000000000 +cpu,cpu=0 usage_idle=38.8252,usage_system=69.4392,usage_user=90.1474 8135000000000 +cpu,cpu=1 usage_idle=16.817,usage_system=40.1869,usage_user=34.0281 8136000000000 +cpu,cpu=2 usage_idle=38.214,usage_system=88.3831,usage_user=46.1967 8137000000000 +cpu,cpu=3 usage_idle=30.0998,usage_system=25.2373,usage_user=12.48 8138000000000 +cpu,cpu=4 usage_idle=65.3554,usage_system=23.2219,usage_user=87.7367 8139000000000 +cpu,cpu=0 usage_idle=41.3728,usage_system=41.5752,usage_user=44.8207 8140000000000 +cpu,cpu=1 usage_idle=19.4323,usage_system=15.5326,usage_user=28.4941 8141000000000 +cpu,cpu=2 usage_idle=98.7439,usage_system=9.09105,usage_user=52.6053 8142000000000 +cpu,cpu=3 usage_idle=30.6477,usage_system=12.9746,usage_user=60.3838 8143000000000 +cpu,cpu=4 usage_idle=82.9998,usage_system=53.541,usage_user=9.37064 8144000000000 +cpu,cpu=0 usage_idle=55.8391,usage_system=92.3662,usage_user=78.8099 8145000000000 +cpu,cpu=1 usage_idle=45.9865,usage_system=9.1832,usage_user=18.9968 8146000000000 +cpu,cpu=2 usage_idle=80.0146,usage_system=47.3972,usage_user=7.37984 8147000000000 +cpu,cpu=3 usage_idle=26.2113,usage_system=77.497,usage_user=32.6171 8148000000000 +cpu,cpu=4 usage_idle=38.6912,usage_system=42.8524,usage_user=55.839 8149000000000 +cpu,cpu=0 usage_idle=26.4279,usage_system=84.2252,usage_user=97.4142 8150000000000 +cpu,cpu=1 usage_idle=71.2486,usage_system=3.65755,usage_user=12.9468 8151000000000 +cpu,cpu=2 usage_idle=99.7427,usage_system=2.40149,usage_user=22.0379 8152000000000 +cpu,cpu=3 usage_idle=52.348,usage_system=33.0492,usage_user=35.0124 8153000000000 +cpu,cpu=4 usage_idle=12.7318,usage_system=16.049,usage_user=88.5535 8154000000000 +cpu,cpu=0 usage_idle=22.1025,usage_system=71.8881,usage_user=80.9197 8155000000000 +cpu,cpu=1 usage_idle=0.912336,usage_system=17.8747,usage_user=90.1029 8156000000000 +cpu,cpu=2 usage_idle=19.9091,usage_system=97.8892,usage_user=37.5001 8157000000000 +cpu,cpu=3 usage_idle=27.2889,usage_system=24.1005,usage_user=14.9971 8158000000000 +cpu,cpu=4 usage_idle=59.9061,usage_system=62.7917,usage_user=57.8495 8159000000000 +cpu,cpu=0 usage_idle=15.745,usage_system=89.2197,usage_user=42.0747 8160000000000 +cpu,cpu=1 usage_idle=13.1592,usage_system=60.4683,usage_user=45.7322 8161000000000 +cpu,cpu=2 usage_idle=26.106,usage_system=60.211,usage_user=48.1337 8162000000000 +cpu,cpu=3 usage_idle=48.1439,usage_system=12.5591,usage_user=81.1829 8163000000000 +cpu,cpu=4 usage_idle=83.1563,usage_system=25.2909,usage_user=97.2319 8164000000000 +cpu,cpu=0 usage_idle=71.7097,usage_system=47.3934,usage_user=69.1201 8165000000000 +cpu,cpu=1 usage_idle=52.6294,usage_system=48.3057,usage_user=86.9948 8166000000000 +cpu,cpu=2 usage_idle=42.7323,usage_system=68.2148,usage_user=84.884 8167000000000 +cpu,cpu=3 usage_idle=80.2323,usage_system=95.5038,usage_user=8.98452 8168000000000 +cpu,cpu=4 usage_idle=95.2294,usage_system=55.4098,usage_user=71.7763 8169000000000 +cpu,cpu=0 usage_idle=53.0789,usage_system=71.1548,usage_user=60.9959 8170000000000 +cpu,cpu=1 usage_idle=95.1536,usage_system=84.314,usage_user=21.4642 8171000000000 +cpu,cpu=2 usage_idle=40.8858,usage_system=10.4201,usage_user=81.6752 8172000000000 +cpu,cpu=3 usage_idle=89.0195,usage_system=58.5639,usage_user=94.2343 8173000000000 +cpu,cpu=4 usage_idle=70.2024,usage_system=41.7202,usage_user=19.5252 8174000000000 +cpu,cpu=0 usage_idle=67.4344,usage_system=13.4299,usage_user=66.9186 8175000000000 +cpu,cpu=1 usage_idle=36.5545,usage_system=66.0593,usage_user=15.2243 8176000000000 +cpu,cpu=2 usage_idle=23.5492,usage_system=8.79155,usage_user=83.4391 8177000000000 +cpu,cpu=3 usage_idle=8.43325,usage_system=89.0239,usage_user=78.9428 8178000000000 +cpu,cpu=4 usage_idle=17.4178,usage_system=84.2533,usage_user=34.3526 8179000000000 +cpu,cpu=0 usage_idle=89.194,usage_system=37.3322,usage_user=5.50748 8180000000000 +cpu,cpu=1 usage_idle=50.19,usage_system=32.4857,usage_user=89.8215 8181000000000 +cpu,cpu=2 usage_idle=71.6542,usage_system=73.3715,usage_user=0.241582 8182000000000 +cpu,cpu=3 usage_idle=53.3294,usage_system=62.391,usage_user=58.8055 8183000000000 +cpu,cpu=4 usage_idle=47.5637,usage_system=32.5935,usage_user=0.525672 8184000000000 +cpu,cpu=0 usage_idle=67.0889,usage_system=0.0278592,usage_user=13.9556 8185000000000 +cpu,cpu=1 usage_idle=34.0075,usage_system=36.5823,usage_user=80.0149 8186000000000 +cpu,cpu=2 usage_idle=49.2317,usage_system=60.1316,usage_user=88.8064 8187000000000 +cpu,cpu=3 usage_idle=32.6708,usage_system=68.5648,usage_user=77.8303 8188000000000 +cpu,cpu=4 usage_idle=11.6136,usage_system=85.9826,usage_user=62.0836 8189000000000 +cpu,cpu=0 usage_idle=45.9663,usage_system=75.1766,usage_user=99.4158 8190000000000 +cpu,cpu=1 usage_idle=51.4737,usage_system=25.3666,usage_user=31.9015 8191000000000 +cpu,cpu=2 usage_idle=41.2953,usage_system=97.0208,usage_user=5.27301 8192000000000 +cpu,cpu=3 usage_idle=41.5368,usage_system=50.3502,usage_user=67.664 8193000000000 +cpu,cpu=4 usage_idle=0.342337,usage_system=97.914,usage_user=0.257507 8194000000000 +cpu,cpu=0 usage_idle=0.868009,usage_system=65.0029,usage_user=0.285366 8195000000000 +cpu,cpu=1 usage_idle=14.8236,usage_system=99.0104,usage_user=36.8677 8196000000000 +cpu,cpu=2 usage_idle=94.8385,usage_system=48.2421,usage_user=96.9993 8197000000000 +cpu,cpu=3 usage_idle=83.6449,usage_system=80.9129,usage_user=65.5641 8198000000000 +cpu,cpu=4 usage_idle=61.4752,usage_system=92.5266,usage_user=51.5467 8199000000000 +cpu,cpu=0 usage_idle=23.5588,usage_system=38.4928,usage_user=26.7234 8200000000000 +cpu,cpu=1 usage_idle=22.9746,usage_system=89.9665,usage_user=52.09 8201000000000 +cpu,cpu=2 usage_idle=54.8761,usage_system=31.2618,usage_user=49.1108 8202000000000 +cpu,cpu=3 usage_idle=60.1491,usage_system=72.7987,usage_user=99.461 8203000000000 +cpu,cpu=4 usage_idle=27.8131,usage_system=73.141,usage_user=97.375 8204000000000 +cpu,cpu=0 usage_idle=28.0706,usage_system=74.009,usage_user=62.3779 8205000000000 +cpu,cpu=1 usage_idle=28.356,usage_system=88.8326,usage_user=61.3883 8206000000000 +cpu,cpu=2 usage_idle=65.2237,usage_system=83.671,usage_user=9.63045 8207000000000 +cpu,cpu=3 usage_idle=62.223,usage_system=67.3159,usage_user=90.5434 8208000000000 +cpu,cpu=4 usage_idle=27.7871,usage_system=28.7911,usage_user=83.0699 8209000000000 +cpu,cpu=0 usage_idle=79.3339,usage_system=52.3499,usage_user=21.5628 8210000000000 +cpu,cpu=1 usage_idle=6.05727,usage_system=75.3245,usage_user=11.5293 8211000000000 +cpu,cpu=2 usage_idle=58.1473,usage_system=30.2005,usage_user=42.7911 8212000000000 +cpu,cpu=3 usage_idle=7.25806,usage_system=90.3496,usage_user=15.5898 8213000000000 +cpu,cpu=4 usage_idle=6.7191,usage_system=18.1627,usage_user=88.7308 8214000000000 +cpu,cpu=0 usage_idle=4.09412,usage_system=46.2334,usage_user=62.7398 8215000000000 +cpu,cpu=1 usage_idle=66.4721,usage_system=74.5894,usage_user=51.5724 8216000000000 +cpu,cpu=2 usage_idle=27.8604,usage_system=39.8131,usage_user=35.2434 8217000000000 +cpu,cpu=3 usage_idle=37.4908,usage_system=2.03606,usage_user=2.55933 8218000000000 +cpu,cpu=4 usage_idle=28.0342,usage_system=29.8232,usage_user=31.3504 8219000000000 +cpu,cpu=0 usage_idle=11.1042,usage_system=9.15708,usage_user=83.7003 8220000000000 +cpu,cpu=1 usage_idle=32.6669,usage_system=15.2144,usage_user=59.0248 8221000000000 +cpu,cpu=2 usage_idle=44.1962,usage_system=73.3616,usage_user=89.2253 8222000000000 +cpu,cpu=3 usage_idle=86.9874,usage_system=80.6197,usage_user=79.575 8223000000000 +cpu,cpu=4 usage_idle=2.57713,usage_system=87.3388,usage_user=97.7377 8224000000000 +cpu,cpu=0 usage_idle=91.3079,usage_system=91.4329,usage_user=43.9711 8225000000000 +cpu,cpu=1 usage_idle=54.0477,usage_system=57.9049,usage_user=18.5604 8226000000000 +cpu,cpu=2 usage_idle=5.62006,usage_system=85.7653,usage_user=58.3735 8227000000000 +cpu,cpu=3 usage_idle=40.8635,usage_system=23.2561,usage_user=60.4095 8228000000000 +cpu,cpu=4 usage_idle=43.4228,usage_system=51.2904,usage_user=90.2327 8229000000000 +cpu,cpu=0 usage_idle=74.7732,usage_system=62.3945,usage_user=99.3898 8230000000000 +cpu,cpu=1 usage_idle=58.4736,usage_system=95.0614,usage_user=14.6042 8231000000000 +cpu,cpu=2 usage_idle=17.4984,usage_system=39.2577,usage_user=87.9658 8232000000000 +cpu,cpu=3 usage_idle=6.72373,usage_system=26.245,usage_user=68.5854 8233000000000 +cpu,cpu=4 usage_idle=86.2987,usage_system=28.8222,usage_user=55.9242 8234000000000 +cpu,cpu=0 usage_idle=84.0364,usage_system=20.1301,usage_user=47.3571 8235000000000 +cpu,cpu=1 usage_idle=28.0075,usage_system=74.1778,usage_user=5.26202 8236000000000 +cpu,cpu=2 usage_idle=46.5679,usage_system=79.7978,usage_user=91.0273 8237000000000 +cpu,cpu=3 usage_idle=4.94136,usage_system=20.6613,usage_user=14.2835 8238000000000 +cpu,cpu=4 usage_idle=65.3509,usage_system=64.0841,usage_user=65.5738 8239000000000 +cpu,cpu=0 usage_idle=55.5836,usage_system=38.8573,usage_user=27.9684 8240000000000 +cpu,cpu=1 usage_idle=54.9734,usage_system=97.3309,usage_user=23.0298 8241000000000 +cpu,cpu=2 usage_idle=69.5776,usage_system=14.8293,usage_user=62.2875 8242000000000 +cpu,cpu=3 usage_idle=57.5433,usage_system=21.553,usage_user=88.5325 8243000000000 +cpu,cpu=4 usage_idle=26.1288,usage_system=7.8517,usage_user=17.3547 8244000000000 +cpu,cpu=0 usage_idle=82.053,usage_system=91.8881,usage_user=37.4847 8245000000000 +cpu,cpu=1 usage_idle=29.4101,usage_system=19.8956,usage_user=11.6625 8246000000000 +cpu,cpu=2 usage_idle=34.6721,usage_system=66.4634,usage_user=91.4603 8247000000000 +cpu,cpu=3 usage_idle=25.6994,usage_system=71.4048,usage_user=12.1216 8248000000000 +cpu,cpu=4 usage_idle=39.9829,usage_system=36.7557,usage_user=76.2057 8249000000000 +cpu,cpu=0 usage_idle=5.55671,usage_system=92.3393,usage_user=15.063 8250000000000 +cpu,cpu=1 usage_idle=33.5251,usage_system=47.3127,usage_user=12.3939 8251000000000 +cpu,cpu=2 usage_idle=56.5549,usage_system=16.8903,usage_user=27.2232 8252000000000 +cpu,cpu=3 usage_idle=18.8423,usage_system=74.4336,usage_user=48.7762 8253000000000 +cpu,cpu=4 usage_idle=7.37485,usage_system=0.562384,usage_user=56.6279 8254000000000 +cpu,cpu=0 usage_idle=24.7295,usage_system=82.6154,usage_user=48.516 8255000000000 +cpu,cpu=1 usage_idle=62.2143,usage_system=12.0254,usage_user=68.4116 8256000000000 +cpu,cpu=2 usage_idle=73.8768,usage_system=46.6975,usage_user=34.875 8257000000000 +cpu,cpu=3 usage_idle=65.3371,usage_system=72.3969,usage_user=6.27981 8258000000000 +cpu,cpu=4 usage_idle=77.4587,usage_system=12.3798,usage_user=43.0355 8259000000000 +cpu,cpu=0 usage_idle=53.6644,usage_system=17.9365,usage_user=35.3748 8260000000000 +cpu,cpu=1 usage_idle=68.7274,usage_system=51.4615,usage_user=82.6875 8261000000000 +cpu,cpu=2 usage_idle=81.1213,usage_system=8.01639,usage_user=99.5778 8262000000000 +cpu,cpu=3 usage_idle=8.34451,usage_system=26.8587,usage_user=74.0114 8263000000000 +cpu,cpu=4 usage_idle=57.1207,usage_system=34.2336,usage_user=74.5738 8264000000000 +cpu,cpu=0 usage_idle=13.7486,usage_system=58.9631,usage_user=57.1891 8265000000000 +cpu,cpu=1 usage_idle=62.2646,usage_system=21.1774,usage_user=69.2145 8266000000000 +cpu,cpu=2 usage_idle=30.6762,usage_system=95.0541,usage_user=15.912 8267000000000 +cpu,cpu=3 usage_idle=65.5512,usage_system=60.3912,usage_user=88.3089 8268000000000 +cpu,cpu=4 usage_idle=71.831,usage_system=37.8498,usage_user=0.688661 8269000000000 +cpu,cpu=0 usage_idle=14.8665,usage_system=91.5142,usage_user=18.6251 8270000000000 +cpu,cpu=1 usage_idle=50.2413,usage_system=60.2416,usage_user=70.0867 8271000000000 +cpu,cpu=2 usage_idle=32.9288,usage_system=41.3629,usage_user=78.103 8272000000000 +cpu,cpu=3 usage_idle=32.5066,usage_system=49.7074,usage_user=4.96178 8273000000000 +cpu,cpu=4 usage_idle=6.51794,usage_system=6.82813,usage_user=39.1954 8274000000000 +cpu,cpu=0 usage_idle=81.0917,usage_system=20.5768,usage_user=98.1585 8275000000000 +cpu,cpu=1 usage_idle=38.2808,usage_system=82.8414,usage_user=19.3358 8276000000000 +cpu,cpu=2 usage_idle=7.49535,usage_system=13.5176,usage_user=14.3899 8277000000000 +cpu,cpu=3 usage_idle=23.4074,usage_system=79.0688,usage_user=74.7811 8278000000000 +cpu,cpu=4 usage_idle=11.7163,usage_system=50.8999,usage_user=12.6309 8279000000000 +cpu,cpu=0 usage_idle=12.4049,usage_system=65.7664,usage_user=4.14511 8280000000000 +cpu,cpu=1 usage_idle=31.0301,usage_system=16.0077,usage_user=64.3867 8281000000000 +cpu,cpu=2 usage_idle=1.11671,usage_system=48.9365,usage_user=5.74959 8282000000000 +cpu,cpu=3 usage_idle=79.2198,usage_system=81.4431,usage_user=55.457 8283000000000 +cpu,cpu=4 usage_idle=84.1815,usage_system=87.961,usage_user=62.2851 8284000000000 +cpu,cpu=0 usage_idle=23.3769,usage_system=69.0527,usage_user=82.8619 8285000000000 +cpu,cpu=1 usage_idle=21.5353,usage_system=7.33352,usage_user=65.7033 8286000000000 +cpu,cpu=2 usage_idle=40.8711,usage_system=14.8289,usage_user=79.2209 8287000000000 +cpu,cpu=3 usage_idle=55.261,usage_system=38.2362,usage_user=58.2898 8288000000000 +cpu,cpu=4 usage_idle=30.0421,usage_system=49.9525,usage_user=9.18963 8289000000000 +cpu,cpu=0 usage_idle=42.673,usage_system=62.3574,usage_user=74.956 8290000000000 +cpu,cpu=1 usage_idle=46.8182,usage_system=93.3875,usage_user=90.9637 8291000000000 +cpu,cpu=2 usage_idle=11.2048,usage_system=94.5042,usage_user=39.9002 8292000000000 +cpu,cpu=3 usage_idle=16.9544,usage_system=73.724,usage_user=21.3433 8293000000000 +cpu,cpu=4 usage_idle=72.4114,usage_system=57.9055,usage_user=9.30427 8294000000000 +cpu,cpu=0 usage_idle=34.6966,usage_system=81.2824,usage_user=78.357 8295000000000 +cpu,cpu=1 usage_idle=17.5585,usage_system=2.81771,usage_user=85.6905 8296000000000 +cpu,cpu=2 usage_idle=83.2618,usage_system=43.6888,usage_user=0.519366 8297000000000 +cpu,cpu=3 usage_idle=62.4827,usage_system=98.9499,usage_user=38.7556 8298000000000 +cpu,cpu=4 usage_idle=20.7725,usage_system=28.992,usage_user=88.7081 8299000000000 +cpu,cpu=0 usage_idle=29.9621,usage_system=71.6651,usage_user=51.0656 8300000000000 +cpu,cpu=1 usage_idle=4.91811,usage_system=18.4832,usage_user=44.453 8301000000000 +cpu,cpu=2 usage_idle=95.8818,usage_system=29.6881,usage_user=38.9573 8302000000000 +cpu,cpu=3 usage_idle=35.782,usage_system=46.6425,usage_user=12.6812 8303000000000 +cpu,cpu=4 usage_idle=57.1253,usage_system=19.0539,usage_user=70.5867 8304000000000 +cpu,cpu=0 usage_idle=66.4296,usage_system=53.7505,usage_user=51.8691 8305000000000 +cpu,cpu=1 usage_idle=44.7865,usage_system=71.309,usage_user=54.6868 8306000000000 +cpu,cpu=2 usage_idle=30.477,usage_system=54.5707,usage_user=98.3756 8307000000000 +cpu,cpu=3 usage_idle=30.9964,usage_system=17.0534,usage_user=97.3255 8308000000000 +cpu,cpu=4 usage_idle=69.752,usage_system=37.8259,usage_user=26.3175 8309000000000 +cpu,cpu=0 usage_idle=58.4601,usage_system=67.788,usage_user=97.9826 8310000000000 +cpu,cpu=1 usage_idle=9.52568,usage_system=72.7061,usage_user=16.4658 8311000000000 +cpu,cpu=2 usage_idle=53.9787,usage_system=68.5879,usage_user=46.1539 8312000000000 +cpu,cpu=3 usage_idle=92.936,usage_system=4.36998,usage_user=92.7964 8313000000000 +cpu,cpu=4 usage_idle=5.61719,usage_system=61.4953,usage_user=11.8503 8314000000000 +cpu,cpu=0 usage_idle=76.2039,usage_system=27.9249,usage_user=65.6008 8315000000000 +cpu,cpu=1 usage_idle=28.073,usage_system=72.7114,usage_user=36.9098 8316000000000 +cpu,cpu=2 usage_idle=82.7597,usage_system=3.18845,usage_user=91.4805 8317000000000 +cpu,cpu=3 usage_idle=81.1353,usage_system=34.1849,usage_user=8.53396 8318000000000 +cpu,cpu=4 usage_idle=78.4609,usage_system=3.93686,usage_user=46.3599 8319000000000 +cpu,cpu=0 usage_idle=4.77842,usage_system=62.397,usage_user=14.1479 8320000000000 +cpu,cpu=1 usage_idle=2.76103,usage_system=71.9227,usage_user=86.854 8321000000000 +cpu,cpu=2 usage_idle=19.2269,usage_system=25.9014,usage_user=55.4419 8322000000000 +cpu,cpu=3 usage_idle=65.3808,usage_system=18.8374,usage_user=59.8119 8323000000000 +cpu,cpu=4 usage_idle=58.1772,usage_system=24.4546,usage_user=21.3072 8324000000000 +cpu,cpu=0 usage_idle=70.0275,usage_system=0.658449,usage_user=49.2321 8325000000000 +cpu,cpu=1 usage_idle=35.6283,usage_system=28.7314,usage_user=21.9435 8326000000000 +cpu,cpu=2 usage_idle=72.5381,usage_system=11.4911,usage_user=25.1319 8327000000000 +cpu,cpu=3 usage_idle=64.0186,usage_system=92.6265,usage_user=59.3168 8328000000000 +cpu,cpu=4 usage_idle=72.5526,usage_system=71.0873,usage_user=63.2536 8329000000000 +cpu,cpu=0 usage_idle=18.9125,usage_system=75.8658,usage_user=25.6506 8330000000000 +cpu,cpu=1 usage_idle=33.0603,usage_system=78.6268,usage_user=97.5733 8331000000000 +cpu,cpu=2 usage_idle=19.9143,usage_system=97.8537,usage_user=23.4747 8332000000000 +cpu,cpu=3 usage_idle=75.3563,usage_system=63.2344,usage_user=42.312 8333000000000 +cpu,cpu=4 usage_idle=35.1682,usage_system=21.4116,usage_user=66.7666 8334000000000 +cpu,cpu=0 usage_idle=56.4754,usage_system=91.4391,usage_user=67.4251 8335000000000 +cpu,cpu=1 usage_idle=5.70743,usage_system=27.0674,usage_user=96.1565 8336000000000 +cpu,cpu=2 usage_idle=27.6509,usage_system=99.6055,usage_user=7.64758 8337000000000 +cpu,cpu=3 usage_idle=52.7828,usage_system=63.6241,usage_user=0.27406 8338000000000 +cpu,cpu=4 usage_idle=12.0996,usage_system=36.1767,usage_user=71.3614 8339000000000 +cpu,cpu=0 usage_idle=75.3532,usage_system=55.0891,usage_user=47.2272 8340000000000 +cpu,cpu=1 usage_idle=1.0038,usage_system=88.1495,usage_user=25.854 8341000000000 +cpu,cpu=2 usage_idle=98.5771,usage_system=8.0638,usage_user=23.7077 8342000000000 +cpu,cpu=3 usage_idle=22.0518,usage_system=83.4201,usage_user=86.9421 8343000000000 +cpu,cpu=4 usage_idle=64.3638,usage_system=18.5882,usage_user=8.35366 8344000000000 +cpu,cpu=0 usage_idle=31.1304,usage_system=75.0636,usage_user=99.7927 8345000000000 +cpu,cpu=1 usage_idle=98.5555,usage_system=80.7711,usage_user=26.8601 8346000000000 +cpu,cpu=2 usage_idle=94.7119,usage_system=8.42195,usage_user=26.4656 8347000000000 +cpu,cpu=3 usage_idle=2.3595,usage_system=61.2048,usage_user=90.0897 8348000000000 +cpu,cpu=4 usage_idle=2.63356,usage_system=73.3043,usage_user=26.2663 8349000000000 +cpu,cpu=0 usage_idle=73.995,usage_system=48.6575,usage_user=81.3555 8350000000000 +cpu,cpu=1 usage_idle=21.2221,usage_system=49.6613,usage_user=69.5049 8351000000000 +cpu,cpu=2 usage_idle=47.0761,usage_system=48.2384,usage_user=77.5688 8352000000000 +cpu,cpu=3 usage_idle=70.7838,usage_system=70.2902,usage_user=60.9888 8353000000000 +cpu,cpu=4 usage_idle=57.7259,usage_system=34.654,usage_user=79.5771 8354000000000 +cpu,cpu=0 usage_idle=66.0795,usage_system=65.7844,usage_user=54.6407 8355000000000 +cpu,cpu=1 usage_idle=65.8722,usage_system=64.3398,usage_user=35.4117 8356000000000 +cpu,cpu=2 usage_idle=92.7323,usage_system=59.0517,usage_user=43.8337 8357000000000 +cpu,cpu=3 usage_idle=19.1979,usage_system=61.4112,usage_user=5.03844 8358000000000 +cpu,cpu=4 usage_idle=9.28755,usage_system=64.0448,usage_user=78.3428 8359000000000 +cpu,cpu=0 usage_idle=35.5539,usage_system=38.0398,usage_user=27.0003 8360000000000 +cpu,cpu=1 usage_idle=16.9094,usage_system=59.2619,usage_user=76.6616 8361000000000 +cpu,cpu=2 usage_idle=86.4143,usage_system=6.33806,usage_user=24.9 8362000000000 +cpu,cpu=3 usage_idle=63.9831,usage_system=77.1218,usage_user=95.1901 8363000000000 +cpu,cpu=4 usage_idle=24.9719,usage_system=34.8477,usage_user=29.8441 8364000000000 +cpu,cpu=0 usage_idle=4.54893,usage_system=0.92723,usage_user=95.6285 8365000000000 +cpu,cpu=1 usage_idle=59.1896,usage_system=66.7995,usage_user=59.9683 8366000000000 +cpu,cpu=2 usage_idle=94.6013,usage_system=59.5318,usage_user=19.02 8367000000000 +cpu,cpu=3 usage_idle=38.435,usage_system=78.7297,usage_user=80.4313 8368000000000 +cpu,cpu=4 usage_idle=43.4734,usage_system=88.0173,usage_user=44.4761 8369000000000 +cpu,cpu=0 usage_idle=21.8162,usage_system=23.5712,usage_user=82.5158 8370000000000 +cpu,cpu=1 usage_idle=48.8165,usage_system=40.4805,usage_user=41.7778 8371000000000 +cpu,cpu=2 usage_idle=25.4781,usage_system=26.8948,usage_user=48.1158 8372000000000 +cpu,cpu=3 usage_idle=50.378,usage_system=90.8779,usage_user=25.2377 8373000000000 +cpu,cpu=4 usage_idle=45.5682,usage_system=15.8498,usage_user=60.0854 8374000000000 +cpu,cpu=0 usage_idle=75.4123,usage_system=20.3987,usage_user=61.0126 8375000000000 +cpu,cpu=1 usage_idle=71.0407,usage_system=79.5883,usage_user=27.8121 8376000000000 +cpu,cpu=2 usage_idle=31.009,usage_system=74.1896,usage_user=87.3439 8377000000000 +cpu,cpu=3 usage_idle=50.029,usage_system=12.6246,usage_user=66.0736 8378000000000 +cpu,cpu=4 usage_idle=30.4603,usage_system=56.0981,usage_user=54.0909 8379000000000 +cpu,cpu=0 usage_idle=74.9364,usage_system=77.9143,usage_user=77.662 8380000000000 +cpu,cpu=1 usage_idle=57.4522,usage_system=26.7308,usage_user=18.1425 8381000000000 +cpu,cpu=2 usage_idle=99.23,usage_system=52.2088,usage_user=45.0373 8382000000000 +cpu,cpu=3 usage_idle=47.3458,usage_system=2.58688,usage_user=35.9152 8383000000000 +cpu,cpu=4 usage_idle=72.5835,usage_system=48.1551,usage_user=51.765 8384000000000 +cpu,cpu=0 usage_idle=32.6688,usage_system=23.5673,usage_user=72.1637 8385000000000 +cpu,cpu=1 usage_idle=93.6814,usage_system=94.6081,usage_user=51.752 8386000000000 +cpu,cpu=2 usage_idle=21.4935,usage_system=25.6171,usage_user=25.9416 8387000000000 +cpu,cpu=3 usage_idle=8.83738,usage_system=75.6461,usage_user=38.5663 8388000000000 +cpu,cpu=4 usage_idle=74.911,usage_system=6.10645,usage_user=94.6644 8389000000000 +cpu,cpu=0 usage_idle=29.0018,usage_system=81.0428,usage_user=72.5787 8390000000000 +cpu,cpu=1 usage_idle=6.66385,usage_system=38.495,usage_user=99.3094 8391000000000 +cpu,cpu=2 usage_idle=24.8064,usage_system=37.725,usage_user=51.5183 8392000000000 +cpu,cpu=3 usage_idle=69.8437,usage_system=85.0708,usage_user=54.1051 8393000000000 +cpu,cpu=4 usage_idle=5.75896,usage_system=57.6543,usage_user=2.2602 8394000000000 +cpu,cpu=0 usage_idle=57.5239,usage_system=90.3231,usage_user=25.8275 8395000000000 +cpu,cpu=1 usage_idle=29.6876,usage_system=84.0045,usage_user=20.4356 8396000000000 +cpu,cpu=2 usage_idle=81.4396,usage_system=5.49799,usage_user=46.0527 8397000000000 +cpu,cpu=3 usage_idle=7.38122,usage_system=14.3354,usage_user=21.6989 8398000000000 +cpu,cpu=4 usage_idle=45.9475,usage_system=89.2463,usage_user=27.8053 8399000000000 +cpu,cpu=0 usage_idle=40.6118,usage_system=18.2482,usage_user=8.84812 8400000000000 +cpu,cpu=1 usage_idle=13.1905,usage_system=24.912,usage_user=47.3431 8401000000000 +cpu,cpu=2 usage_idle=12.4999,usage_system=49.7184,usage_user=85.0681 8402000000000 +cpu,cpu=3 usage_idle=64.0182,usage_system=19.5621,usage_user=70.1389 8403000000000 +cpu,cpu=4 usage_idle=18.1233,usage_system=25.3211,usage_user=27.7932 8404000000000 +cpu,cpu=0 usage_idle=20.3835,usage_system=82.845,usage_user=18.1163 8405000000000 +cpu,cpu=1 usage_idle=46.211,usage_system=12.5327,usage_user=2.12076 8406000000000 +cpu,cpu=2 usage_idle=66.6467,usage_system=93.9723,usage_user=7.61875 8407000000000 +cpu,cpu=3 usage_idle=12.6994,usage_system=1.3535,usage_user=21.9541 8408000000000 +cpu,cpu=4 usage_idle=34.3982,usage_system=47.301,usage_user=11.2005 8409000000000 +cpu,cpu=0 usage_idle=62.2035,usage_system=87.9128,usage_user=29.4486 8410000000000 +cpu,cpu=1 usage_idle=71.0516,usage_system=1.10328,usage_user=54.3607 8411000000000 +cpu,cpu=2 usage_idle=18.3948,usage_system=13.6032,usage_user=4.0791 8412000000000 +cpu,cpu=3 usage_idle=3.46293,usage_system=77.6214,usage_user=23.6412 8413000000000 +cpu,cpu=4 usage_idle=73.6019,usage_system=95.7447,usage_user=48.9623 8414000000000 +cpu,cpu=0 usage_idle=1.39506,usage_system=16.1282,usage_user=31.8074 8415000000000 +cpu,cpu=1 usage_idle=19.5113,usage_system=62.3392,usage_user=44.3401 8416000000000 +cpu,cpu=2 usage_idle=21.6321,usage_system=28.9859,usage_user=38.3123 8417000000000 +cpu,cpu=3 usage_idle=29.2508,usage_system=41.6852,usage_user=39.6658 8418000000000 +cpu,cpu=4 usage_idle=51.205,usage_system=76.0835,usage_user=86.9668 8419000000000 +cpu,cpu=0 usage_idle=62.4054,usage_system=38.287,usage_user=74.8796 8420000000000 +cpu,cpu=1 usage_idle=91.8541,usage_system=9.33863,usage_user=75.9829 8421000000000 +cpu,cpu=2 usage_idle=46.2148,usage_system=27.7334,usage_user=89.5861 8422000000000 +cpu,cpu=3 usage_idle=50.2939,usage_system=31.1963,usage_user=67.2074 8423000000000 +cpu,cpu=4 usage_idle=73.9351,usage_system=4.79821,usage_user=62.9521 8424000000000 +cpu,cpu=0 usage_idle=22.8974,usage_system=6.19327,usage_user=79.0803 8425000000000 +cpu,cpu=1 usage_idle=54.7048,usage_system=25.7046,usage_user=41.4195 8426000000000 +cpu,cpu=2 usage_idle=99.0449,usage_system=47.3367,usage_user=70.4053 8427000000000 +cpu,cpu=3 usage_idle=37.3572,usage_system=76.5875,usage_user=12.0906 8428000000000 +cpu,cpu=4 usage_idle=77.0231,usage_system=27.7925,usage_user=88.174 8429000000000 +cpu,cpu=0 usage_idle=63.9899,usage_system=90.1979,usage_user=26.461 8430000000000 +cpu,cpu=1 usage_idle=38.8695,usage_system=82.052,usage_user=35.7997 8431000000000 +cpu,cpu=2 usage_idle=14.8524,usage_system=28.2668,usage_user=63.5331 8432000000000 +cpu,cpu=3 usage_idle=4.43846,usage_system=78.5606,usage_user=94.7294 8433000000000 +cpu,cpu=4 usage_idle=71.6459,usage_system=52.4957,usage_user=99.5276 8434000000000 +cpu,cpu=0 usage_idle=34.598,usage_system=75.3932,usage_user=5.72089 8435000000000 +cpu,cpu=1 usage_idle=13.6783,usage_system=30.098,usage_user=31.4255 8436000000000 +cpu,cpu=2 usage_idle=55.0977,usage_system=29.1429,usage_user=78.7622 8437000000000 +cpu,cpu=3 usage_idle=25.5031,usage_system=66.5001,usage_user=55.3497 8438000000000 +cpu,cpu=4 usage_idle=37.5937,usage_system=43.5232,usage_user=83.1422 8439000000000 +cpu,cpu=0 usage_idle=25.7677,usage_system=7.51303,usage_user=73.3402 8440000000000 +cpu,cpu=1 usage_idle=52.2287,usage_system=46.3825,usage_user=55.3922 8441000000000 +cpu,cpu=2 usage_idle=88.0284,usage_system=61.2349,usage_user=83.6589 8442000000000 +cpu,cpu=3 usage_idle=51.5615,usage_system=65.6733,usage_user=62.2196 8443000000000 +cpu,cpu=4 usage_idle=46.2909,usage_system=37.3192,usage_user=14.7153 8444000000000 +cpu,cpu=0 usage_idle=45.8185,usage_system=71.9172,usage_user=90.1085 8445000000000 +cpu,cpu=1 usage_idle=51.5394,usage_system=85.5955,usage_user=20.2065 8446000000000 +cpu,cpu=2 usage_idle=82.9649,usage_system=40.6932,usage_user=49.3494 8447000000000 +cpu,cpu=3 usage_idle=61.727,usage_system=66.1963,usage_user=15.8495 8448000000000 +cpu,cpu=4 usage_idle=17.0768,usage_system=3.78999,usage_user=59.3726 8449000000000 +cpu,cpu=0 usage_idle=0.219013,usage_system=29.5577,usage_user=66.8857 8450000000000 +cpu,cpu=1 usage_idle=73.5592,usage_system=81.7864,usage_user=13.2682 8451000000000 +cpu,cpu=2 usage_idle=28.9513,usage_system=69.8148,usage_user=74.5031 8452000000000 +cpu,cpu=3 usage_idle=12.6103,usage_system=21.3763,usage_user=40.1764 8453000000000 +cpu,cpu=4 usage_idle=74.8299,usage_system=67.6671,usage_user=77.4956 8454000000000 +cpu,cpu=0 usage_idle=89.5452,usage_system=13.4856,usage_user=49.4129 8455000000000 +cpu,cpu=1 usage_idle=79.6536,usage_system=65.025,usage_user=35.0084 8456000000000 +cpu,cpu=2 usage_idle=99.8601,usage_system=47.9899,usage_user=75.7016 8457000000000 +cpu,cpu=3 usage_idle=49.2095,usage_system=9.7169,usage_user=41.8979 8458000000000 +cpu,cpu=4 usage_idle=65.059,usage_system=26.7937,usage_user=45.6879 8459000000000 +cpu,cpu=0 usage_idle=24.4316,usage_system=27.0127,usage_user=75.2456 8460000000000 +cpu,cpu=1 usage_idle=91.3173,usage_system=0.571871,usage_user=57.032 8461000000000 +cpu,cpu=2 usage_idle=4.58546,usage_system=29.5232,usage_user=26.8469 8462000000000 +cpu,cpu=3 usage_idle=79.0885,usage_system=42.1335,usage_user=48.2231 8463000000000 +cpu,cpu=4 usage_idle=19.2649,usage_system=16.9634,usage_user=15.8903 8464000000000 +cpu,cpu=0 usage_idle=96.7606,usage_system=6.50852,usage_user=29.3759 8465000000000 +cpu,cpu=1 usage_idle=46.1735,usage_system=86.1622,usage_user=94.4009 8466000000000 +cpu,cpu=2 usage_idle=81.1818,usage_system=86.0223,usage_user=42.3908 8467000000000 +cpu,cpu=3 usage_idle=56.8834,usage_system=35.2318,usage_user=52.1077 8468000000000 +cpu,cpu=4 usage_idle=98.7813,usage_system=0.290771,usage_user=78.9013 8469000000000 +cpu,cpu=0 usage_idle=44.4692,usage_system=24.7224,usage_user=5.91403 8470000000000 +cpu,cpu=1 usage_idle=19.7148,usage_system=16.0397,usage_user=6.4859 8471000000000 +cpu,cpu=2 usage_idle=76.7468,usage_system=20.6251,usage_user=36.0091 8472000000000 +cpu,cpu=3 usage_idle=3.5937,usage_system=99.7137,usage_user=78.1426 8473000000000 +cpu,cpu=4 usage_idle=51.8168,usage_system=18.9786,usage_user=95.106 8474000000000 +cpu,cpu=0 usage_idle=67.7071,usage_system=15.7392,usage_user=1.61452 8475000000000 +cpu,cpu=1 usage_idle=97.083,usage_system=61.9127,usage_user=87.7767 8476000000000 +cpu,cpu=2 usage_idle=91.4839,usage_system=43.0945,usage_user=73.799 8477000000000 +cpu,cpu=3 usage_idle=33.8747,usage_system=99.9779,usage_user=9.03077 8478000000000 +cpu,cpu=4 usage_idle=85.9823,usage_system=98.7592,usage_user=9.32154 8479000000000 +cpu,cpu=0 usage_idle=64.8836,usage_system=43.2284,usage_user=34.0439 8480000000000 +cpu,cpu=1 usage_idle=70.7977,usage_system=62.9433,usage_user=50.0836 8481000000000 +cpu,cpu=2 usage_idle=77.2836,usage_system=39.6901,usage_user=70.7087 8482000000000 +cpu,cpu=3 usage_idle=13.2927,usage_system=43.2838,usage_user=70.4224 8483000000000 +cpu,cpu=4 usage_idle=91.4353,usage_system=95.1006,usage_user=89.401 8484000000000 +cpu,cpu=0 usage_idle=86.5413,usage_system=62.8077,usage_user=5.14019 8485000000000 +cpu,cpu=1 usage_idle=88.1558,usage_system=59.8908,usage_user=67.0528 8486000000000 +cpu,cpu=2 usage_idle=75.9325,usage_system=51.3747,usage_user=10.1473 8487000000000 +cpu,cpu=3 usage_idle=49.7315,usage_system=85.2493,usage_user=10.1252 8488000000000 +cpu,cpu=4 usage_idle=58.7623,usage_system=71.2316,usage_user=8.88443 8489000000000 +cpu,cpu=0 usage_idle=68.0838,usage_system=36.1153,usage_user=52.1129 8490000000000 +cpu,cpu=1 usage_idle=2.12773,usage_system=6.91297,usage_user=15.0561 8491000000000 +cpu,cpu=2 usage_idle=52.2113,usage_system=84.1965,usage_user=54.7463 8492000000000 +cpu,cpu=3 usage_idle=22.9201,usage_system=97.4892,usage_user=98.0301 8493000000000 +cpu,cpu=4 usage_idle=93.3425,usage_system=88.9246,usage_user=93.1307 8494000000000 +cpu,cpu=0 usage_idle=82.7435,usage_system=75.4659,usage_user=55.9385 8495000000000 +cpu,cpu=1 usage_idle=87.8836,usage_system=63.6217,usage_user=15.8292 8496000000000 +cpu,cpu=2 usage_idle=54.9365,usage_system=39.5542,usage_user=67.2039 8497000000000 +cpu,cpu=3 usage_idle=65.0838,usage_system=89.2857,usage_user=52.4532 8498000000000 +cpu,cpu=4 usage_idle=75.209,usage_system=48.048,usage_user=23.6849 8499000000000 +cpu,cpu=0 usage_idle=84.0934,usage_system=16.1318,usage_user=59.8002 8500000000000 +cpu,cpu=1 usage_idle=36.2063,usage_system=18.2595,usage_user=66.7131 8501000000000 +cpu,cpu=2 usage_idle=51.2624,usage_system=70.4708,usage_user=50.9097 8502000000000 +cpu,cpu=3 usage_idle=6.0087,usage_system=93.3909,usage_user=48.3989 8503000000000 +cpu,cpu=4 usage_idle=4.03877,usage_system=86.7333,usage_user=37.3235 8504000000000 +cpu,cpu=0 usage_idle=97.1695,usage_system=69.4768,usage_user=12.7894 8505000000000 +cpu,cpu=1 usage_idle=53.1079,usage_system=57.3604,usage_user=76.4111 8506000000000 +cpu,cpu=2 usage_idle=68.9372,usage_system=12.2969,usage_user=15.9653 8507000000000 +cpu,cpu=3 usage_idle=36.141,usage_system=77.3807,usage_user=5.25101 8508000000000 +cpu,cpu=4 usage_idle=88.5943,usage_system=52.5897,usage_user=53.299 8509000000000 +cpu,cpu=0 usage_idle=12.2791,usage_system=36.6832,usage_user=69.4308 8510000000000 +cpu,cpu=1 usage_idle=72.0793,usage_system=72.8895,usage_user=87.6903 8511000000000 +cpu,cpu=2 usage_idle=38.7924,usage_system=24.1519,usage_user=58.1611 8512000000000 +cpu,cpu=3 usage_idle=89.7021,usage_system=30.1606,usage_user=51.552 8513000000000 +cpu,cpu=4 usage_idle=38.1011,usage_system=34.1994,usage_user=38.2853 8514000000000 +cpu,cpu=0 usage_idle=75.4245,usage_system=31.3688,usage_user=7.76212 8515000000000 +cpu,cpu=1 usage_idle=88.2139,usage_system=84.4768,usage_user=65.1226 8516000000000 +cpu,cpu=2 usage_idle=64.625,usage_system=53.4139,usage_user=77.4195 8517000000000 +cpu,cpu=3 usage_idle=80.5903,usage_system=89.555,usage_user=54.8002 8518000000000 +cpu,cpu=4 usage_idle=85.8413,usage_system=78.1493,usage_user=7.38993 8519000000000 +cpu,cpu=0 usage_idle=39.1403,usage_system=90.4284,usage_user=44.0731 8520000000000 +cpu,cpu=1 usage_idle=8.57105,usage_system=62.5077,usage_user=16.9625 8521000000000 +cpu,cpu=2 usage_idle=96.2613,usage_system=1.30013,usage_user=41.1145 8522000000000 +cpu,cpu=3 usage_idle=54.4224,usage_system=91.0022,usage_user=71.2751 8523000000000 +cpu,cpu=4 usage_idle=5.97439,usage_system=29.1033,usage_user=5.47442 8524000000000 +cpu,cpu=0 usage_idle=44.2597,usage_system=4.52784,usage_user=36.8433 8525000000000 +cpu,cpu=1 usage_idle=52.0218,usage_system=92.7418,usage_user=21.3201 8526000000000 +cpu,cpu=2 usage_idle=17.1444,usage_system=57.3667,usage_user=74.734 8527000000000 +cpu,cpu=3 usage_idle=94.5639,usage_system=37.957,usage_user=64.289 8528000000000 +cpu,cpu=4 usage_idle=49.3641,usage_system=23.7983,usage_user=42.4382 8529000000000 +cpu,cpu=0 usage_idle=56.754,usage_system=62.9386,usage_user=32.8666 8530000000000 +cpu,cpu=1 usage_idle=0.827113,usage_system=71.5097,usage_user=95.3743 8531000000000 +cpu,cpu=2 usage_idle=17.7897,usage_system=67.771,usage_user=96.6744 8532000000000 +cpu,cpu=3 usage_idle=58.9041,usage_system=22.1934,usage_user=87.6767 8533000000000 +cpu,cpu=4 usage_idle=30.1792,usage_system=28.1678,usage_user=16.78 8534000000000 +cpu,cpu=0 usage_idle=35.6536,usage_system=72.4275,usage_user=21.3078 8535000000000 +cpu,cpu=1 usage_idle=72.4969,usage_system=24.4493,usage_user=14.0496 8536000000000 +cpu,cpu=2 usage_idle=93.8169,usage_system=41.5938,usage_user=71.4163 8537000000000 +cpu,cpu=3 usage_idle=68.5509,usage_system=36.1576,usage_user=9.37334 8538000000000 +cpu,cpu=4 usage_idle=32.8399,usage_system=85.5217,usage_user=33.1717 8539000000000 +cpu,cpu=0 usage_idle=75.2781,usage_system=42.2758,usage_user=96.1103 8540000000000 +cpu,cpu=1 usage_idle=8.14473,usage_system=43.1029,usage_user=67.62 8541000000000 +cpu,cpu=2 usage_idle=3.51903,usage_system=60.8925,usage_user=35.3909 8542000000000 +cpu,cpu=3 usage_idle=0.193459,usage_system=19.7966,usage_user=57.5843 8543000000000 +cpu,cpu=4 usage_idle=87.8701,usage_system=49.9758,usage_user=85.7521 8544000000000 +cpu,cpu=0 usage_idle=4.65011,usage_system=85.6294,usage_user=58.1796 8545000000000 +cpu,cpu=1 usage_idle=25.9579,usage_system=58.1263,usage_user=82.629 8546000000000 +cpu,cpu=2 usage_idle=40.0075,usage_system=51.9432,usage_user=24.2227 8547000000000 +cpu,cpu=3 usage_idle=11.4238,usage_system=20.4941,usage_user=60.3804 8548000000000 +cpu,cpu=4 usage_idle=20.7971,usage_system=53.334,usage_user=45.9021 8549000000000 +cpu,cpu=0 usage_idle=53.9688,usage_system=28.6121,usage_user=88.1779 8550000000000 +cpu,cpu=1 usage_idle=50.0791,usage_system=36.7568,usage_user=31.2807 8551000000000 +cpu,cpu=2 usage_idle=17.6991,usage_system=40.2759,usage_user=92.1733 8552000000000 +cpu,cpu=3 usage_idle=53.09,usage_system=40.4693,usage_user=11.9699 8553000000000 +cpu,cpu=4 usage_idle=10.6744,usage_system=28.3394,usage_user=61.9457 8554000000000 +cpu,cpu=0 usage_idle=96.4265,usage_system=32.9896,usage_user=47.5751 8555000000000 +cpu,cpu=1 usage_idle=54.6061,usage_system=58.9475,usage_user=5.70138 8556000000000 +cpu,cpu=2 usage_idle=37.2351,usage_system=98.955,usage_user=57.6446 8557000000000 +cpu,cpu=3 usage_idle=61.4578,usage_system=10.3788,usage_user=78.1386 8558000000000 +cpu,cpu=4 usage_idle=21.8382,usage_system=31.1759,usage_user=31.4726 8559000000000 +cpu,cpu=0 usage_idle=67.7403,usage_system=85.1447,usage_user=60.0847 8560000000000 +cpu,cpu=1 usage_idle=55.9181,usage_system=35.2238,usage_user=96.8415 8561000000000 +cpu,cpu=2 usage_idle=87.1989,usage_system=52.9229,usage_user=37.1174 8562000000000 +cpu,cpu=3 usage_idle=79.3721,usage_system=6.01289,usage_user=77.5867 8563000000000 +cpu,cpu=4 usage_idle=91.3421,usage_system=16.6872,usage_user=5.92614 8564000000000 +cpu,cpu=0 usage_idle=53.2878,usage_system=13.1137,usage_user=38.9157 8565000000000 +cpu,cpu=1 usage_idle=0.862907,usage_system=67.7198,usage_user=97.8632 8566000000000 +cpu,cpu=2 usage_idle=6.56429,usage_system=4.95488,usage_user=96.8181 8567000000000 +cpu,cpu=3 usage_idle=64.2088,usage_system=66.4127,usage_user=7.19692 8568000000000 +cpu,cpu=4 usage_idle=42.3475,usage_system=88.2508,usage_user=38.3728 8569000000000 +cpu,cpu=0 usage_idle=73.8201,usage_system=55.9911,usage_user=23.5175 8570000000000 +cpu,cpu=1 usage_idle=33.9048,usage_system=11.9093,usage_user=58.7413 8571000000000 +cpu,cpu=2 usage_idle=30.7463,usage_system=99.1081,usage_user=11.6642 8572000000000 +cpu,cpu=3 usage_idle=67.8637,usage_system=78.4803,usage_user=17.6771 8573000000000 +cpu,cpu=4 usage_idle=45.4504,usage_system=69.8223,usage_user=34.3643 8574000000000 +cpu,cpu=0 usage_idle=51.3765,usage_system=23.1101,usage_user=47.478 8575000000000 +cpu,cpu=1 usage_idle=90.2922,usage_system=23.973,usage_user=15.1979 8576000000000 +cpu,cpu=2 usage_idle=88.1554,usage_system=30.5373,usage_user=20.1527 8577000000000 +cpu,cpu=3 usage_idle=84.9735,usage_system=94.7461,usage_user=86.5654 8578000000000 +cpu,cpu=4 usage_idle=92.1704,usage_system=37.0936,usage_user=74.8162 8579000000000 +cpu,cpu=0 usage_idle=30.5433,usage_system=10.9137,usage_user=30.8074 8580000000000 +cpu,cpu=1 usage_idle=54.0608,usage_system=44.8185,usage_user=42.7166 8581000000000 +cpu,cpu=2 usage_idle=12.8021,usage_system=75.5648,usage_user=41.8247 8582000000000 +cpu,cpu=3 usage_idle=24.4664,usage_system=43.4285,usage_user=20.305 8583000000000 +cpu,cpu=4 usage_idle=42.1435,usage_system=88.8788,usage_user=90.1273 8584000000000 +cpu,cpu=0 usage_idle=76.5078,usage_system=40.2553,usage_user=13.2375 8585000000000 +cpu,cpu=1 usage_idle=23.9858,usage_system=30.5475,usage_user=37.2105 8586000000000 +cpu,cpu=2 usage_idle=39.1837,usage_system=18.7029,usage_user=67.7478 8587000000000 +cpu,cpu=3 usage_idle=59.3364,usage_system=3.67644,usage_user=62.4939 8588000000000 +cpu,cpu=4 usage_idle=45.9018,usage_system=95.8469,usage_user=99.5876 8589000000000 +cpu,cpu=0 usage_idle=20.7181,usage_system=26.3902,usage_user=10.5013 8590000000000 +cpu,cpu=1 usage_idle=51.5254,usage_system=80.451,usage_user=55.3198 8591000000000 +cpu,cpu=2 usage_idle=94.242,usage_system=93.2531,usage_user=30.8845 8592000000000 +cpu,cpu=3 usage_idle=36.0668,usage_system=17.7195,usage_user=74.313 8593000000000 +cpu,cpu=4 usage_idle=56.3718,usage_system=59.8629,usage_user=63.1918 8594000000000 +cpu,cpu=0 usage_idle=46.4992,usage_system=36.3707,usage_user=3.44716 8595000000000 +cpu,cpu=1 usage_idle=59.7366,usage_system=60.3565,usage_user=33.9947 8596000000000 +cpu,cpu=2 usage_idle=96.9471,usage_system=99.5402,usage_user=52.6976 8597000000000 +cpu,cpu=3 usage_idle=64.6949,usage_system=58.8766,usage_user=56.374 8598000000000 +cpu,cpu=4 usage_idle=27.1889,usage_system=4.77844,usage_user=52.2209 8599000000000 +cpu,cpu=0 usage_idle=26.7764,usage_system=25.4965,usage_user=78.6111 8600000000000 +cpu,cpu=1 usage_idle=37.2777,usage_system=77.0219,usage_user=59.062 8601000000000 +cpu,cpu=2 usage_idle=92.5974,usage_system=71.264,usage_user=52.3151 8602000000000 +cpu,cpu=3 usage_idle=23.482,usage_system=7.33078,usage_user=70.0346 8603000000000 +cpu,cpu=4 usage_idle=97.795,usage_system=63.7026,usage_user=29.8975 8604000000000 +cpu,cpu=0 usage_idle=60.9868,usage_system=10.2017,usage_user=66.2682 8605000000000 +cpu,cpu=1 usage_idle=64.434,usage_system=69.9383,usage_user=26.6247 8606000000000 +cpu,cpu=2 usage_idle=98.4287,usage_system=66.8855,usage_user=26.1649 8607000000000 +cpu,cpu=3 usage_idle=51.1263,usage_system=31.5804,usage_user=85.0415 8608000000000 +cpu,cpu=4 usage_idle=7.50032,usage_system=58.7692,usage_user=89.82 8609000000000 +cpu,cpu=0 usage_idle=59.7212,usage_system=85.5456,usage_user=15.3165 8610000000000 +cpu,cpu=1 usage_idle=38.3323,usage_system=22.8233,usage_user=92.3384 8611000000000 +cpu,cpu=2 usage_idle=97.3944,usage_system=15.4208,usage_user=63.6024 8612000000000 +cpu,cpu=3 usage_idle=49.7095,usage_system=38.9028,usage_user=70.9332 8613000000000 +cpu,cpu=4 usage_idle=19.7441,usage_system=36.6977,usage_user=34.6358 8614000000000 +cpu,cpu=0 usage_idle=49.6415,usage_system=97.6846,usage_user=44.8375 8615000000000 +cpu,cpu=1 usage_idle=15.9097,usage_system=62.1185,usage_user=14.7759 8616000000000 +cpu,cpu=2 usage_idle=42.5344,usage_system=60.5472,usage_user=81.6613 8617000000000 +cpu,cpu=3 usage_idle=68.6993,usage_system=11.6735,usage_user=13.2417 8618000000000 +cpu,cpu=4 usage_idle=53.7409,usage_system=19.1738,usage_user=72.0109 8619000000000 +cpu,cpu=0 usage_idle=43.5609,usage_system=78.895,usage_user=57.5565 8620000000000 +cpu,cpu=1 usage_idle=58.8774,usage_system=17.2273,usage_user=80.3799 8621000000000 +cpu,cpu=2 usage_idle=51.2158,usage_system=14.6217,usage_user=95.8006 8622000000000 +cpu,cpu=3 usage_idle=14.8182,usage_system=64.3312,usage_user=34.7034 8623000000000 +cpu,cpu=4 usage_idle=85.7514,usage_system=84.0752,usage_user=71.4011 8624000000000 +cpu,cpu=0 usage_idle=20.3872,usage_system=33.7168,usage_user=69.0857 8625000000000 +cpu,cpu=1 usage_idle=65.2248,usage_system=49.6265,usage_user=31.2042 8626000000000 +cpu,cpu=2 usage_idle=80.0006,usage_system=92.1609,usage_user=91.7514 8627000000000 +cpu,cpu=3 usage_idle=61.6619,usage_system=60.8603,usage_user=3.42488 8628000000000 +cpu,cpu=4 usage_idle=74.9036,usage_system=14.6012,usage_user=22.5987 8629000000000 +cpu,cpu=0 usage_idle=46.9145,usage_system=58.162,usage_user=1.49368 8630000000000 +cpu,cpu=1 usage_idle=4.47107,usage_system=17.0394,usage_user=18.721 8631000000000 +cpu,cpu=2 usage_idle=84.8509,usage_system=68.2552,usage_user=33.3427 8632000000000 +cpu,cpu=3 usage_idle=80.6516,usage_system=83.0735,usage_user=97.6739 8633000000000 +cpu,cpu=4 usage_idle=15.355,usage_system=68.8249,usage_user=81.7492 8634000000000 +cpu,cpu=0 usage_idle=86.7561,usage_system=89.2121,usage_user=15.4659 8635000000000 +cpu,cpu=1 usage_idle=55.8418,usage_system=54.4369,usage_user=65.0924 8636000000000 +cpu,cpu=2 usage_idle=87.0461,usage_system=34.4375,usage_user=57.2534 8637000000000 +cpu,cpu=3 usage_idle=78.7975,usage_system=96.0995,usage_user=18.1136 8638000000000 +cpu,cpu=4 usage_idle=82.2224,usage_system=71.0031,usage_user=32.7148 8639000000000 +cpu,cpu=0 usage_idle=4.82101,usage_system=17.9176,usage_user=90.8768 8640000000000 +cpu,cpu=1 usage_idle=6.31469,usage_system=22.3887,usage_user=7.91621 8641000000000 +cpu,cpu=2 usage_idle=25.0357,usage_system=7.23965,usage_user=76.1714 8642000000000 +cpu,cpu=3 usage_idle=58.3785,usage_system=87.8912,usage_user=59.2449 8643000000000 +cpu,cpu=4 usage_idle=56.0524,usage_system=3.24623,usage_user=28.0698 8644000000000 +cpu,cpu=0 usage_idle=37.8015,usage_system=90.0024,usage_user=17.2819 8645000000000 +cpu,cpu=1 usage_idle=53.2675,usage_system=45.8442,usage_user=71.7189 8646000000000 +cpu,cpu=2 usage_idle=18.3599,usage_system=32.8903,usage_user=6.15638 8647000000000 +cpu,cpu=3 usage_idle=75.6133,usage_system=11.6878,usage_user=2.25586 8648000000000 +cpu,cpu=4 usage_idle=93.7269,usage_system=93.9101,usage_user=73.259 8649000000000 +cpu,cpu=0 usage_idle=26.4417,usage_system=98.7311,usage_user=91.1766 8650000000000 +cpu,cpu=1 usage_idle=17.3185,usage_system=5.04583,usage_user=13.5653 8651000000000 +cpu,cpu=2 usage_idle=25.2347,usage_system=30.0816,usage_user=20.805 8652000000000 +cpu,cpu=3 usage_idle=1.40616,usage_system=88.46,usage_user=8.69621 8653000000000 +cpu,cpu=4 usage_idle=60.651,usage_system=44.5124,usage_user=11.9424 8654000000000 +cpu,cpu=0 usage_idle=88.7208,usage_system=82.3139,usage_user=1.94481 8655000000000 +cpu,cpu=1 usage_idle=6.0028,usage_system=35.5814,usage_user=47.789 8656000000000 +cpu,cpu=2 usage_idle=77.7216,usage_system=53.9413,usage_user=80.6793 8657000000000 +cpu,cpu=3 usage_idle=83.878,usage_system=29.5546,usage_user=92.3671 8658000000000 +cpu,cpu=4 usage_idle=86.1339,usage_system=23.2815,usage_user=86.2772 8659000000000 +cpu,cpu=0 usage_idle=59.3929,usage_system=49.7232,usage_user=85.0084 8660000000000 +cpu,cpu=1 usage_idle=50.5695,usage_system=67.0417,usage_user=90.0542 8661000000000 +cpu,cpu=2 usage_idle=64.1348,usage_system=92.2765,usage_user=20.1357 8662000000000 +cpu,cpu=3 usage_idle=84.9398,usage_system=93.6826,usage_user=8.59575 8663000000000 +cpu,cpu=4 usage_idle=93.636,usage_system=54.3337,usage_user=53.1081 8664000000000 +cpu,cpu=0 usage_idle=5.57841,usage_system=43.0545,usage_user=35.422 8665000000000 +cpu,cpu=1 usage_idle=7.52322,usage_system=49.0573,usage_user=71.0034 8666000000000 +cpu,cpu=2 usage_idle=55.3123,usage_system=26.779,usage_user=24.9448 8667000000000 +cpu,cpu=3 usage_idle=35.9916,usage_system=10.657,usage_user=54.4994 8668000000000 +cpu,cpu=4 usage_idle=28.3587,usage_system=96.7909,usage_user=77.7809 8669000000000 +cpu,cpu=0 usage_idle=14.6359,usage_system=56.1838,usage_user=27.5041 8670000000000 +cpu,cpu=1 usage_idle=99.6442,usage_system=6.75323,usage_user=94.5459 8671000000000 +cpu,cpu=2 usage_idle=89.6984,usage_system=70.888,usage_user=86.8224 8672000000000 +cpu,cpu=3 usage_idle=9.83417,usage_system=55.8278,usage_user=80.505 8673000000000 +cpu,cpu=4 usage_idle=18.4299,usage_system=49.4638,usage_user=34.8387 8674000000000 +cpu,cpu=0 usage_idle=71.5381,usage_system=55.0422,usage_user=77.8932 8675000000000 +cpu,cpu=1 usage_idle=6.9601,usage_system=62.5654,usage_user=26.9505 8676000000000 +cpu,cpu=2 usage_idle=77.9635,usage_system=17.8776,usage_user=53.7295 8677000000000 +cpu,cpu=3 usage_idle=2.9083,usage_system=53.8692,usage_user=64.3865 8678000000000 +cpu,cpu=4 usage_idle=57.4077,usage_system=82.2279,usage_user=61.1774 8679000000000 +cpu,cpu=0 usage_idle=35.1886,usage_system=96.8638,usage_user=17.3612 8680000000000 +cpu,cpu=1 usage_idle=62.6927,usage_system=96.508,usage_user=24.1144 8681000000000 +cpu,cpu=2 usage_idle=57.2386,usage_system=86.2065,usage_user=95.0024 8682000000000 +cpu,cpu=3 usage_idle=44.0609,usage_system=96.0406,usage_user=50.8302 8683000000000 +cpu,cpu=4 usage_idle=24.5659,usage_system=14.4706,usage_user=0.293969 8684000000000 +cpu,cpu=0 usage_idle=59.4046,usage_system=86.0086,usage_user=55.3361 8685000000000 +cpu,cpu=1 usage_idle=37.2978,usage_system=92.9687,usage_user=17.9015 8686000000000 +cpu,cpu=2 usage_idle=64.2483,usage_system=70.9322,usage_user=35.7792 8687000000000 +cpu,cpu=3 usage_idle=17.9779,usage_system=73.8406,usage_user=89.6484 8688000000000 +cpu,cpu=4 usage_idle=82.3644,usage_system=31.2482,usage_user=71.8763 8689000000000 +cpu,cpu=0 usage_idle=43.5418,usage_system=66.4368,usage_user=68.7401 8690000000000 +cpu,cpu=1 usage_idle=60.903,usage_system=29.1295,usage_user=65.2481 8691000000000 +cpu,cpu=2 usage_idle=85.0174,usage_system=86.3681,usage_user=51.4546 8692000000000 +cpu,cpu=3 usage_idle=80.0198,usage_system=30.429,usage_user=47.4952 8693000000000 +cpu,cpu=4 usage_idle=30.85,usage_system=54.9949,usage_user=61.9658 8694000000000 +cpu,cpu=0 usage_idle=31.144,usage_system=14.3996,usage_user=47.9744 8695000000000 +cpu,cpu=1 usage_idle=86.4801,usage_system=51.6974,usage_user=40.9431 8696000000000 +cpu,cpu=2 usage_idle=4.38163,usage_system=15.9457,usage_user=11.8753 8697000000000 +cpu,cpu=3 usage_idle=40.1608,usage_system=33.9236,usage_user=85.7159 8698000000000 +cpu,cpu=4 usage_idle=29.8092,usage_system=16.2879,usage_user=16.9641 8699000000000 +cpu,cpu=0 usage_idle=1.68544,usage_system=59.8297,usage_user=83.4009 8700000000000 +cpu,cpu=1 usage_idle=70.4255,usage_system=20.7327,usage_user=12.5304 8701000000000 +cpu,cpu=2 usage_idle=35.6736,usage_system=5.75006,usage_user=98.8984 8702000000000 +cpu,cpu=3 usage_idle=87.1282,usage_system=85.7699,usage_user=29.3274 8703000000000 +cpu,cpu=4 usage_idle=34.6234,usage_system=16.6199,usage_user=84.3224 8704000000000 +cpu,cpu=0 usage_idle=96.5891,usage_system=47.7638,usage_user=98.7219 8705000000000 +cpu,cpu=1 usage_idle=44.5635,usage_system=34.244,usage_user=50.4193 8706000000000 +cpu,cpu=2 usage_idle=85.5065,usage_system=38.6256,usage_user=66.365 8707000000000 +cpu,cpu=3 usage_idle=97.3819,usage_system=78.7864,usage_user=0.288585 8708000000000 +cpu,cpu=4 usage_idle=83.0977,usage_system=8.59553,usage_user=16.5765 8709000000000 +cpu,cpu=0 usage_idle=0.0618079,usage_system=10.281,usage_user=76.4063 8710000000000 +cpu,cpu=1 usage_idle=83.4627,usage_system=80.7065,usage_user=97.1389 8711000000000 +cpu,cpu=2 usage_idle=95.993,usage_system=16.3801,usage_user=2.889 8712000000000 +cpu,cpu=3 usage_idle=94.8915,usage_system=3.50825,usage_user=88.6589 8713000000000 +cpu,cpu=4 usage_idle=24.2189,usage_system=38.1316,usage_user=5.27872 8714000000000 +cpu,cpu=0 usage_idle=8.54129,usage_system=34.7207,usage_user=53.0426 8715000000000 +cpu,cpu=1 usage_idle=7.26323,usage_system=79.2842,usage_user=87.2865 8716000000000 +cpu,cpu=2 usage_idle=57.6825,usage_system=64.7908,usage_user=25.9121 8717000000000 +cpu,cpu=3 usage_idle=24.0476,usage_system=62.1726,usage_user=4.69849 8718000000000 +cpu,cpu=4 usage_idle=24.3361,usage_system=45.2703,usage_user=13.294 8719000000000 +cpu,cpu=0 usage_idle=40.9127,usage_system=45.3322,usage_user=23.575 8720000000000 +cpu,cpu=1 usage_idle=17.3189,usage_system=28.7948,usage_user=4.28146 8721000000000 +cpu,cpu=2 usage_idle=14.4579,usage_system=24.7879,usage_user=20.6615 8722000000000 +cpu,cpu=3 usage_idle=17.3469,usage_system=19.6793,usage_user=24.1698 8723000000000 +cpu,cpu=4 usage_idle=6.00571,usage_system=43.8982,usage_user=62.3014 8724000000000 +cpu,cpu=0 usage_idle=11.2844,usage_system=52.4395,usage_user=97.0222 8725000000000 +cpu,cpu=1 usage_idle=64.327,usage_system=59.7028,usage_user=76.3064 8726000000000 +cpu,cpu=2 usage_idle=51.6135,usage_system=17.3853,usage_user=41.0971 8727000000000 +cpu,cpu=3 usage_idle=77.5257,usage_system=41.4329,usage_user=3.26977 8728000000000 +cpu,cpu=4 usage_idle=82.2241,usage_system=65.769,usage_user=48.5401 8729000000000 +cpu,cpu=0 usage_idle=95.5182,usage_system=6.68165,usage_user=93.8723 8730000000000 +cpu,cpu=1 usage_idle=19.0931,usage_system=24.0006,usage_user=22.6671 8731000000000 +cpu,cpu=2 usage_idle=23.3746,usage_system=38.4584,usage_user=47.455 8732000000000 +cpu,cpu=3 usage_idle=44.0362,usage_system=55.8053,usage_user=67.1343 8733000000000 +cpu,cpu=4 usage_idle=68.2059,usage_system=61.811,usage_user=11.0325 8734000000000 +cpu,cpu=0 usage_idle=30.5074,usage_system=73.0954,usage_user=63.4721 8735000000000 +cpu,cpu=1 usage_idle=27.5295,usage_system=37.4224,usage_user=23.1749 8736000000000 +cpu,cpu=2 usage_idle=3.83591,usage_system=89.036,usage_user=40.5602 8737000000000 +cpu,cpu=3 usage_idle=44.9331,usage_system=66.5616,usage_user=81.993 8738000000000 +cpu,cpu=4 usage_idle=48.2028,usage_system=48.7858,usage_user=47.762 8739000000000 +cpu,cpu=0 usage_idle=96.7429,usage_system=44.3039,usage_user=54.4437 8740000000000 +cpu,cpu=1 usage_idle=90.6152,usage_system=63.3971,usage_user=78.4442 8741000000000 +cpu,cpu=2 usage_idle=13.2823,usage_system=86.7717,usage_user=16.9026 8742000000000 +cpu,cpu=3 usage_idle=60.7372,usage_system=30.8079,usage_user=72.7079 8743000000000 +cpu,cpu=4 usage_idle=27.8715,usage_system=99.0138,usage_user=34.5189 8744000000000 +cpu,cpu=0 usage_idle=38.9041,usage_system=29.5212,usage_user=7.61431 8745000000000 +cpu,cpu=1 usage_idle=2.37619,usage_system=57.0507,usage_user=45.0367 8746000000000 +cpu,cpu=2 usage_idle=25.551,usage_system=60.8866,usage_user=34.0727 8747000000000 +cpu,cpu=3 usage_idle=66.1112,usage_system=5.81967,usage_user=0.634357 8748000000000 +cpu,cpu=4 usage_idle=48.1042,usage_system=54.0225,usage_user=49.4201 8749000000000 +cpu,cpu=0 usage_idle=95.8662,usage_system=50.7654,usage_user=93.7241 8750000000000 +cpu,cpu=1 usage_idle=50.3099,usage_system=41.3806,usage_user=57.1212 8751000000000 +cpu,cpu=2 usage_idle=28.7541,usage_system=54.6629,usage_user=43.8929 8752000000000 +cpu,cpu=3 usage_idle=45.6567,usage_system=15.4002,usage_user=74.7007 8753000000000 +cpu,cpu=4 usage_idle=18.3646,usage_system=43.2717,usage_user=73.7146 8754000000000 +cpu,cpu=0 usage_idle=52.8835,usage_system=82.1758,usage_user=3.23573 8755000000000 +cpu,cpu=1 usage_idle=60.4978,usage_system=84.552,usage_user=60.2864 8756000000000 +cpu,cpu=2 usage_idle=5.53455,usage_system=10.103,usage_user=21.1731 8757000000000 +cpu,cpu=3 usage_idle=39.6073,usage_system=76.2142,usage_user=26.9927 8758000000000 +cpu,cpu=4 usage_idle=40.2416,usage_system=24.3185,usage_user=81.0152 8759000000000 +cpu,cpu=0 usage_idle=89.6618,usage_system=20.1847,usage_user=31.7807 8760000000000 +cpu,cpu=1 usage_idle=83.3859,usage_system=70.4945,usage_user=73.1613 8761000000000 +cpu,cpu=2 usage_idle=40.507,usage_system=99.2486,usage_user=27.8242 8762000000000 +cpu,cpu=3 usage_idle=84.3999,usage_system=44.9053,usage_user=43.2244 8763000000000 +cpu,cpu=4 usage_idle=59.1007,usage_system=63.2699,usage_user=86.4961 8764000000000 +cpu,cpu=0 usage_idle=32.8152,usage_system=16.1534,usage_user=68.6719 8765000000000 +cpu,cpu=1 usage_idle=36.051,usage_system=76.6512,usage_user=53.2239 8766000000000 +cpu,cpu=2 usage_idle=96.3374,usage_system=82.1858,usage_user=63.3269 8767000000000 +cpu,cpu=3 usage_idle=17.5104,usage_system=21.793,usage_user=39.5411 8768000000000 +cpu,cpu=4 usage_idle=44.5032,usage_system=62.0347,usage_user=63.8596 8769000000000 +cpu,cpu=0 usage_idle=25.5184,usage_system=51.6964,usage_user=84.0443 8770000000000 +cpu,cpu=1 usage_idle=57.2991,usage_system=35.0823,usage_user=54.5388 8771000000000 +cpu,cpu=2 usage_idle=30.4603,usage_system=75.5893,usage_user=53.7874 8772000000000 +cpu,cpu=3 usage_idle=58.2845,usage_system=59.9893,usage_user=98.6927 8773000000000 +cpu,cpu=4 usage_idle=1.50888,usage_system=19.0899,usage_user=61.9627 8774000000000 +cpu,cpu=0 usage_idle=88.0049,usage_system=51.9052,usage_user=78.1161 8775000000000 +cpu,cpu=1 usage_idle=56.6768,usage_system=87.9561,usage_user=54.7673 8776000000000 +cpu,cpu=2 usage_idle=9.90066,usage_system=84.2935,usage_user=36.9531 8777000000000 +cpu,cpu=3 usage_idle=73.2276,usage_system=1.80398,usage_user=58.7461 8778000000000 +cpu,cpu=4 usage_idle=12.7687,usage_system=46.3072,usage_user=20.7808 8779000000000 +cpu,cpu=0 usage_idle=76.6283,usage_system=71.8256,usage_user=72.4772 8780000000000 +cpu,cpu=1 usage_idle=60.6726,usage_system=29.1246,usage_user=7.55955 8781000000000 +cpu,cpu=2 usage_idle=15.2114,usage_system=59.5849,usage_user=83.1489 8782000000000 +cpu,cpu=3 usage_idle=68.9988,usage_system=17.8695,usage_user=43.1382 8783000000000 +cpu,cpu=4 usage_idle=67.6915,usage_system=19.3784,usage_user=62.2281 8784000000000 +cpu,cpu=0 usage_idle=29.6542,usage_system=7.3833,usage_user=14.1333 8785000000000 +cpu,cpu=1 usage_idle=7.77023,usage_system=64.0601,usage_user=2.08941 8786000000000 +cpu,cpu=2 usage_idle=62.5375,usage_system=73.9608,usage_user=86.3829 8787000000000 +cpu,cpu=3 usage_idle=99.4906,usage_system=47.1883,usage_user=88.1869 8788000000000 +cpu,cpu=4 usage_idle=58.2367,usage_system=59.957,usage_user=34.4941 8789000000000 +cpu,cpu=0 usage_idle=79.0175,usage_system=36.5853,usage_user=6.31961 8790000000000 +cpu,cpu=1 usage_idle=51.4948,usage_system=97.2579,usage_user=35.4442 8791000000000 +cpu,cpu=2 usage_idle=59.0543,usage_system=12.4692,usage_user=95.0292 8792000000000 +cpu,cpu=3 usage_idle=42.2032,usage_system=81.468,usage_user=12.8986 8793000000000 +cpu,cpu=4 usage_idle=85.3414,usage_system=49.1595,usage_user=32.277 8794000000000 +cpu,cpu=0 usage_idle=47.5695,usage_system=78.8137,usage_user=39.6603 8795000000000 +cpu,cpu=1 usage_idle=61.7028,usage_system=86.5839,usage_user=3.7204 8796000000000 +cpu,cpu=2 usage_idle=63.7922,usage_system=49.1214,usage_user=77.6812 8797000000000 +cpu,cpu=3 usage_idle=50.1751,usage_system=48.612,usage_user=24.8695 8798000000000 +cpu,cpu=4 usage_idle=38.362,usage_system=6.84875,usage_user=84.8265 8799000000000 +cpu,cpu=0 usage_idle=72.8561,usage_system=85.8663,usage_user=21.4118 8800000000000 +cpu,cpu=1 usage_idle=79.1757,usage_system=37.3611,usage_user=18.6697 8801000000000 +cpu,cpu=2 usage_idle=14.6199,usage_system=96.4154,usage_user=31.139 8802000000000 +cpu,cpu=3 usage_idle=9.64908,usage_system=38.6186,usage_user=12.607 8803000000000 +cpu,cpu=4 usage_idle=22.5477,usage_system=23.96,usage_user=61.7665 8804000000000 +cpu,cpu=0 usage_idle=54.8247,usage_system=71.5295,usage_user=40.5801 8805000000000 +cpu,cpu=1 usage_idle=94.485,usage_system=33.2323,usage_user=27.164 8806000000000 +cpu,cpu=2 usage_idle=98.2054,usage_system=97.0245,usage_user=76.2854 8807000000000 +cpu,cpu=3 usage_idle=75.8866,usage_system=47.1996,usage_user=24.8975 8808000000000 +cpu,cpu=4 usage_idle=0.756088,usage_system=85.5616,usage_user=31.7462 8809000000000 +cpu,cpu=0 usage_idle=85.5826,usage_system=58.4177,usage_user=17.6125 8810000000000 +cpu,cpu=1 usage_idle=6.99445,usage_system=37.5934,usage_user=54.9736 8811000000000 +cpu,cpu=2 usage_idle=25.6642,usage_system=52.2133,usage_user=51.3889 8812000000000 +cpu,cpu=3 usage_idle=56.8031,usage_system=61.8624,usage_user=90.0076 8813000000000 +cpu,cpu=4 usage_idle=69.4101,usage_system=84.4101,usage_user=13.9676 8814000000000 +cpu,cpu=0 usage_idle=31.1765,usage_system=39.2348,usage_user=85.4971 8815000000000 +cpu,cpu=1 usage_idle=71.7567,usage_system=33.7199,usage_user=18.7294 8816000000000 +cpu,cpu=2 usage_idle=98.9207,usage_system=31.9253,usage_user=15.7539 8817000000000 +cpu,cpu=3 usage_idle=75.2061,usage_system=7.81189,usage_user=62.9534 8818000000000 +cpu,cpu=4 usage_idle=0.103548,usage_system=8.56798,usage_user=48.515 8819000000000 +cpu,cpu=0 usage_idle=31.8498,usage_system=94.1506,usage_user=6.93272 8820000000000 +cpu,cpu=1 usage_idle=49.4622,usage_system=1.14503,usage_user=44.5261 8821000000000 +cpu,cpu=2 usage_idle=4.43579,usage_system=26.8092,usage_user=96.7394 8822000000000 +cpu,cpu=3 usage_idle=55.8247,usage_system=83.6123,usage_user=58.6018 8823000000000 +cpu,cpu=4 usage_idle=45.8323,usage_system=53.0224,usage_user=43.0119 8824000000000 +cpu,cpu=0 usage_idle=59.7999,usage_system=84.1989,usage_user=82.2467 8825000000000 +cpu,cpu=1 usage_idle=45.297,usage_system=55.9556,usage_user=15.9666 8826000000000 +cpu,cpu=2 usage_idle=64.0264,usage_system=54.8763,usage_user=47.8919 8827000000000 +cpu,cpu=3 usage_idle=79.7802,usage_system=30.0824,usage_user=55.7037 8828000000000 +cpu,cpu=4 usage_idle=42.7337,usage_system=30.1859,usage_user=64.2717 8829000000000 +cpu,cpu=0 usage_idle=91.2487,usage_system=62.0357,usage_user=58.4223 8830000000000 +cpu,cpu=1 usage_idle=98.1814,usage_system=11.4979,usage_user=59.5673 8831000000000 +cpu,cpu=2 usage_idle=42.7075,usage_system=15.9337,usage_user=86.3765 8832000000000 +cpu,cpu=3 usage_idle=39.4469,usage_system=71.7584,usage_user=69.9889 8833000000000 +cpu,cpu=4 usage_idle=98.0487,usage_system=17.5908,usage_user=23.0113 8834000000000 +cpu,cpu=0 usage_idle=41.0605,usage_system=77.3907,usage_user=7.2102 8835000000000 +cpu,cpu=1 usage_idle=23.3072,usage_system=22.6877,usage_user=63.1658 8836000000000 +cpu,cpu=2 usage_idle=39.2738,usage_system=86.714,usage_user=18.0421 8837000000000 +cpu,cpu=3 usage_idle=87.1656,usage_system=66.4943,usage_user=48.1244 8838000000000 +cpu,cpu=4 usage_idle=42.8694,usage_system=9.22795,usage_user=78.3103 8839000000000 +cpu,cpu=0 usage_idle=7.14111,usage_system=0.476658,usage_user=40.346 8840000000000 +cpu,cpu=1 usage_idle=65.5634,usage_system=98.6581,usage_user=51.8439 8841000000000 +cpu,cpu=2 usage_idle=25.1308,usage_system=41.3656,usage_user=67.7776 8842000000000 +cpu,cpu=3 usage_idle=11.5073,usage_system=80.8125,usage_user=39.536 8843000000000 +cpu,cpu=4 usage_idle=81.4962,usage_system=78.8612,usage_user=57.1268 8844000000000 +cpu,cpu=0 usage_idle=4.50745,usage_system=19.9217,usage_user=34.5175 8845000000000 +cpu,cpu=1 usage_idle=11.7176,usage_system=43.2289,usage_user=57.2051 8846000000000 +cpu,cpu=2 usage_idle=74.8834,usage_system=82.5027,usage_user=43.9192 8847000000000 +cpu,cpu=3 usage_idle=92.9255,usage_system=69.6683,usage_user=10.4134 8848000000000 +cpu,cpu=4 usage_idle=41.0499,usage_system=12.5377,usage_user=19.6414 8849000000000 +cpu,cpu=0 usage_idle=19.3603,usage_system=19.6788,usage_user=20.1181 8850000000000 +cpu,cpu=1 usage_idle=59.7063,usage_system=85.2422,usage_user=18.7761 8851000000000 +cpu,cpu=2 usage_idle=11.5502,usage_system=10.373,usage_user=60.1417 8852000000000 +cpu,cpu=3 usage_idle=79.3278,usage_system=21.8803,usage_user=40.9542 8853000000000 +cpu,cpu=4 usage_idle=18.8638,usage_system=3.37652,usage_user=19.8154 8854000000000 +cpu,cpu=0 usage_idle=75.9906,usage_system=7.88397,usage_user=39.7371 8855000000000 +cpu,cpu=1 usage_idle=10.5081,usage_system=19.6016,usage_user=82.9659 8856000000000 +cpu,cpu=2 usage_idle=67.7132,usage_system=94.4851,usage_user=65.4686 8857000000000 +cpu,cpu=3 usage_idle=11.6323,usage_system=87.4106,usage_user=35.1369 8858000000000 +cpu,cpu=4 usage_idle=22.0458,usage_system=28.4605,usage_user=47.6746 8859000000000 +cpu,cpu=0 usage_idle=41.6872,usage_system=47.8207,usage_user=67.3534 8860000000000 +cpu,cpu=1 usage_idle=61.8052,usage_system=7.527,usage_user=52.5957 8861000000000 +cpu,cpu=2 usage_idle=80.5814,usage_system=19.0772,usage_user=62.9687 8862000000000 +cpu,cpu=3 usage_idle=40.7231,usage_system=98.4049,usage_user=84.849 8863000000000 +cpu,cpu=4 usage_idle=81.6773,usage_system=17.2687,usage_user=88.2255 8864000000000 +cpu,cpu=0 usage_idle=1.49269,usage_system=93.2593,usage_user=96.1095 8865000000000 +cpu,cpu=1 usage_idle=41.2297,usage_system=3.76742,usage_user=15.7111 8866000000000 +cpu,cpu=2 usage_idle=24.1957,usage_system=71.4806,usage_user=10.1962 8867000000000 +cpu,cpu=3 usage_idle=89.6643,usage_system=83.1129,usage_user=97.6067 8868000000000 +cpu,cpu=4 usage_idle=24.8012,usage_system=5.15874,usage_user=26.0672 8869000000000 +cpu,cpu=0 usage_idle=72.4759,usage_system=46.8459,usage_user=73.888 8870000000000 +cpu,cpu=1 usage_idle=39.8293,usage_system=8.65115,usage_user=81.415 8871000000000 +cpu,cpu=2 usage_idle=92.425,usage_system=89.2325,usage_user=0.492138 8872000000000 +cpu,cpu=3 usage_idle=55.3937,usage_system=29.9556,usage_user=98.8971 8873000000000 +cpu,cpu=4 usage_idle=40.2427,usage_system=11.6329,usage_user=16.1658 8874000000000 +cpu,cpu=0 usage_idle=28.4682,usage_system=13.1256,usage_user=9.42515 8875000000000 +cpu,cpu=1 usage_idle=24.5777,usage_system=54.3553,usage_user=13.1926 8876000000000 +cpu,cpu=2 usage_idle=40.2888,usage_system=78.551,usage_user=84.6732 8877000000000 +cpu,cpu=3 usage_idle=50.485,usage_system=68.2154,usage_user=67.7861 8878000000000 +cpu,cpu=4 usage_idle=48.0918,usage_system=93.0166,usage_user=72.9449 8879000000000 +cpu,cpu=0 usage_idle=74.159,usage_system=65.4925,usage_user=19.7908 8880000000000 +cpu,cpu=1 usage_idle=48.047,usage_system=5.32178,usage_user=28.4419 8881000000000 +cpu,cpu=2 usage_idle=29.4619,usage_system=97.7468,usage_user=17.6744 8882000000000 +cpu,cpu=3 usage_idle=29.9541,usage_system=53.1404,usage_user=47.63 8883000000000 +cpu,cpu=4 usage_idle=28.8511,usage_system=93.3831,usage_user=59.263 8884000000000 +cpu,cpu=0 usage_idle=45.0169,usage_system=21.8513,usage_user=72.3886 8885000000000 +cpu,cpu=1 usage_idle=54.4421,usage_system=46.429,usage_user=26.7439 8886000000000 +cpu,cpu=2 usage_idle=67.6346,usage_system=86.7179,usage_user=5.29495 8887000000000 +cpu,cpu=3 usage_idle=52.3078,usage_system=37.2029,usage_user=73.5103 8888000000000 +cpu,cpu=4 usage_idle=20.0939,usage_system=85.2946,usage_user=66.5269 8889000000000 +cpu,cpu=0 usage_idle=93.0388,usage_system=59.4536,usage_user=32.0194 8890000000000 +cpu,cpu=1 usage_idle=12.8295,usage_system=7.50056,usage_user=37.3411 8891000000000 +cpu,cpu=2 usage_idle=41.2715,usage_system=36.9625,usage_user=35.0879 8892000000000 +cpu,cpu=3 usage_idle=58.9459,usage_system=66.9165,usage_user=88.2283 8893000000000 +cpu,cpu=4 usage_idle=6.57594,usage_system=95.7677,usage_user=81.6114 8894000000000 +cpu,cpu=0 usage_idle=65.8389,usage_system=40.7846,usage_user=3.46271 8895000000000 +cpu,cpu=1 usage_idle=38.2275,usage_system=95.2267,usage_user=49.8917 8896000000000 +cpu,cpu=2 usage_idle=64.9714,usage_system=62.8613,usage_user=36.6096 8897000000000 +cpu,cpu=3 usage_idle=70.2663,usage_system=15.1691,usage_user=73.8125 8898000000000 +cpu,cpu=4 usage_idle=43.7766,usage_system=35.263,usage_user=59.1071 8899000000000 +cpu,cpu=0 usage_idle=10.3035,usage_system=28.3018,usage_user=18.5607 8900000000000 +cpu,cpu=1 usage_idle=42.3229,usage_system=41.1313,usage_user=26.0613 8901000000000 +cpu,cpu=2 usage_idle=79.664,usage_system=82.4028,usage_user=63.0237 8902000000000 +cpu,cpu=3 usage_idle=14.7519,usage_system=41.3487,usage_user=29.9403 8903000000000 +cpu,cpu=4 usage_idle=2.98022,usage_system=47.9246,usage_user=25.708 8904000000000 +cpu,cpu=0 usage_idle=84.5916,usage_system=13.7635,usage_user=66.4926 8905000000000 +cpu,cpu=1 usage_idle=88.0543,usage_system=51.991,usage_user=61.7192 8906000000000 +cpu,cpu=2 usage_idle=37.9461,usage_system=16.9623,usage_user=24.5805 8907000000000 +cpu,cpu=3 usage_idle=74.5556,usage_system=87.2287,usage_user=39.7496 8908000000000 +cpu,cpu=4 usage_idle=48.3681,usage_system=31.0053,usage_user=75.0127 8909000000000 +cpu,cpu=0 usage_idle=7.47519,usage_system=41.3088,usage_user=3.31445 8910000000000 +cpu,cpu=1 usage_idle=26.0359,usage_system=83.6316,usage_user=44.4458 8911000000000 +cpu,cpu=2 usage_idle=52.0971,usage_system=63.2957,usage_user=26.8486 8912000000000 +cpu,cpu=3 usage_idle=15.1209,usage_system=78.0476,usage_user=68.1972 8913000000000 +cpu,cpu=4 usage_idle=45.0612,usage_system=81.0278,usage_user=16.1219 8914000000000 +cpu,cpu=0 usage_idle=70.7691,usage_system=65.6194,usage_user=29.8854 8915000000000 +cpu,cpu=1 usage_idle=37.2617,usage_system=53.6738,usage_user=81.8763 8916000000000 +cpu,cpu=2 usage_idle=98.9809,usage_system=91.6198,usage_user=98.8387 8917000000000 +cpu,cpu=3 usage_idle=23.5614,usage_system=66.1755,usage_user=86.0673 8918000000000 +cpu,cpu=4 usage_idle=63.3111,usage_system=14.5436,usage_user=17.0726 8919000000000 +cpu,cpu=0 usage_idle=38.3237,usage_system=22.0188,usage_user=58.3814 8920000000000 +cpu,cpu=1 usage_idle=41.6382,usage_system=48.0547,usage_user=42.013 8921000000000 +cpu,cpu=2 usage_idle=86.084,usage_system=0.151786,usage_user=5.30869 8922000000000 +cpu,cpu=3 usage_idle=12.9325,usage_system=15.2727,usage_user=83.3563 8923000000000 +cpu,cpu=4 usage_idle=81.1298,usage_system=60.3338,usage_user=64.3841 8924000000000 +cpu,cpu=0 usage_idle=97.2516,usage_system=31.1029,usage_user=30.0035 8925000000000 +cpu,cpu=1 usage_idle=27.137,usage_system=68.3646,usage_user=83.6773 8926000000000 +cpu,cpu=2 usage_idle=9.01335,usage_system=67.3455,usage_user=75.2971 8927000000000 +cpu,cpu=3 usage_idle=7.85204,usage_system=90.9069,usage_user=41.4726 8928000000000 +cpu,cpu=4 usage_idle=93.9194,usage_system=54.218,usage_user=56.0161 8929000000000 +cpu,cpu=0 usage_idle=10.992,usage_system=92.5417,usage_user=78.0349 8930000000000 +cpu,cpu=1 usage_idle=69.3734,usage_system=34.1799,usage_user=26.0895 8931000000000 +cpu,cpu=2 usage_idle=11.3864,usage_system=20.2639,usage_user=26.2413 8932000000000 +cpu,cpu=3 usage_idle=16.6951,usage_system=33.1964,usage_user=41.514 8933000000000 +cpu,cpu=4 usage_idle=0.0513419,usage_system=14.3262,usage_user=1.8478 8934000000000 +cpu,cpu=0 usage_idle=64.4354,usage_system=11.5778,usage_user=32.9507 8935000000000 +cpu,cpu=1 usage_idle=94.4389,usage_system=38.7148,usage_user=1.31528 8936000000000 +cpu,cpu=2 usage_idle=78.1162,usage_system=47.7282,usage_user=68.6607 8937000000000 +cpu,cpu=3 usage_idle=53.4132,usage_system=55.5802,usage_user=59.5676 8938000000000 +cpu,cpu=4 usage_idle=94.8858,usage_system=49.4996,usage_user=13.7856 8939000000000 +cpu,cpu=0 usage_idle=50.9019,usage_system=60.4916,usage_user=6.32733 8940000000000 +cpu,cpu=1 usage_idle=28.9368,usage_system=29.8649,usage_user=40.5073 8941000000000 +cpu,cpu=2 usage_idle=55.0264,usage_system=41.2513,usage_user=60.7712 8942000000000 +cpu,cpu=3 usage_idle=81.2677,usage_system=57.9464,usage_user=93.9676 8943000000000 +cpu,cpu=4 usage_idle=22.7817,usage_system=57.9977,usage_user=8.29379 8944000000000 +cpu,cpu=0 usage_idle=24.6295,usage_system=22.4332,usage_user=19.8716 8945000000000 +cpu,cpu=1 usage_idle=57.5802,usage_system=16.8721,usage_user=58.5864 8946000000000 +cpu,cpu=2 usage_idle=58.8955,usage_system=94.9882,usage_user=6.31463 8947000000000 +cpu,cpu=3 usage_idle=27.5562,usage_system=48.4014,usage_user=61.8948 8948000000000 +cpu,cpu=4 usage_idle=87.1238,usage_system=43.2872,usage_user=11.3944 8949000000000 +cpu,cpu=0 usage_idle=0.909452,usage_system=94.1892,usage_user=71.886 8950000000000 +cpu,cpu=1 usage_idle=7.23678,usage_system=23.126,usage_user=1.75094 8951000000000 +cpu,cpu=2 usage_idle=47.744,usage_system=78.1524,usage_user=43.0023 8952000000000 +cpu,cpu=3 usage_idle=8.51518,usage_system=59.4201,usage_user=0.948667 8953000000000 +cpu,cpu=4 usage_idle=2.48277,usage_system=82.2018,usage_user=58.9464 8954000000000 +cpu,cpu=0 usage_idle=10.7766,usage_system=6.83125,usage_user=81.3796 8955000000000 +cpu,cpu=1 usage_idle=30.6482,usage_system=64.4114,usage_user=98.2516 8956000000000 +cpu,cpu=2 usage_idle=89.2346,usage_system=23.3069,usage_user=93.2398 8957000000000 +cpu,cpu=3 usage_idle=95.5493,usage_system=50.8631,usage_user=41.6413 8958000000000 +cpu,cpu=4 usage_idle=57.4441,usage_system=37.987,usage_user=84.9285 8959000000000 +cpu,cpu=0 usage_idle=68.8385,usage_system=38.8964,usage_user=79.1177 8960000000000 +cpu,cpu=1 usage_idle=40.7245,usage_system=46.1332,usage_user=2.24365 8961000000000 +cpu,cpu=2 usage_idle=42.4755,usage_system=93.8772,usage_user=80.396 8962000000000 +cpu,cpu=3 usage_idle=85.4777,usage_system=2.39243,usage_user=39.8161 8963000000000 +cpu,cpu=4 usage_idle=86.4264,usage_system=4.8752,usage_user=22.0178 8964000000000 +cpu,cpu=0 usage_idle=45.3728,usage_system=15.6518,usage_user=28.8491 8965000000000 +cpu,cpu=1 usage_idle=26.7524,usage_system=46.3,usage_user=93.2605 8966000000000 +cpu,cpu=2 usage_idle=25.004,usage_system=35.5346,usage_user=16.5674 8967000000000 +cpu,cpu=3 usage_idle=18.2438,usage_system=31.0838,usage_user=67.4306 8968000000000 +cpu,cpu=4 usage_idle=59.8851,usage_system=88.5279,usage_user=5.41756 8969000000000 +cpu,cpu=0 usage_idle=44.8136,usage_system=57.3665,usage_user=44.314 8970000000000 +cpu,cpu=1 usage_idle=23.9313,usage_system=98.091,usage_user=90.4472 8971000000000 +cpu,cpu=2 usage_idle=26.1749,usage_system=40.5664,usage_user=84.3245 8972000000000 +cpu,cpu=3 usage_idle=6.57091,usage_system=26.0442,usage_user=86.7169 8973000000000 +cpu,cpu=4 usage_idle=46.387,usage_system=12.4705,usage_user=91.5921 8974000000000 +cpu,cpu=0 usage_idle=68.4048,usage_system=57.8433,usage_user=7.24386 8975000000000 +cpu,cpu=1 usage_idle=97.2539,usage_system=84.5957,usage_user=53.5438 8976000000000 +cpu,cpu=2 usage_idle=90.5144,usage_system=9.59969,usage_user=89.0784 8977000000000 +cpu,cpu=3 usage_idle=7.08181,usage_system=27.8435,usage_user=20.1622 8978000000000 +cpu,cpu=4 usage_idle=74.5124,usage_system=87.7286,usage_user=8.69018 8979000000000 +cpu,cpu=0 usage_idle=79.9299,usage_system=32.5422,usage_user=66.0566 8980000000000 +cpu,cpu=1 usage_idle=24.2439,usage_system=56.4734,usage_user=64.1476 8981000000000 +cpu,cpu=2 usage_idle=14.6911,usage_system=82.6483,usage_user=4.71406 8982000000000 +cpu,cpu=3 usage_idle=99.0156,usage_system=89.2192,usage_user=30.7582 8983000000000 +cpu,cpu=4 usage_idle=85.7325,usage_system=35.6062,usage_user=43.2288 8984000000000 +cpu,cpu=0 usage_idle=77.3246,usage_system=4.01097,usage_user=1.0721 8985000000000 +cpu,cpu=1 usage_idle=84.5684,usage_system=1.26483,usage_user=85.6678 8986000000000 +cpu,cpu=2 usage_idle=38.1123,usage_system=91.7792,usage_user=95.2675 8987000000000 +cpu,cpu=3 usage_idle=27.1907,usage_system=98.861,usage_user=23.111 8988000000000 +cpu,cpu=4 usage_idle=47.3529,usage_system=73.3734,usage_user=10.8396 8989000000000 +cpu,cpu=0 usage_idle=56.0431,usage_system=53.3033,usage_user=43.3817 8990000000000 +cpu,cpu=1 usage_idle=22.0997,usage_system=77.5473,usage_user=99.8551 8991000000000 +cpu,cpu=2 usage_idle=86.2473,usage_system=92.2384,usage_user=82.5034 8992000000000 +cpu,cpu=3 usage_idle=90.9614,usage_system=91.254,usage_user=71.7226 8993000000000 +cpu,cpu=4 usage_idle=21.7196,usage_system=76.9865,usage_user=7.32882 8994000000000 +cpu,cpu=0 usage_idle=64.9484,usage_system=54.3111,usage_user=11.3398 8995000000000 +cpu,cpu=1 usage_idle=66.0205,usage_system=38.8795,usage_user=12.6046 8996000000000 +cpu,cpu=2 usage_idle=51.6883,usage_system=76.9918,usage_user=4.38381 8997000000000 +cpu,cpu=3 usage_idle=46.9558,usage_system=4.18244,usage_user=3.24482 8998000000000 +cpu,cpu=4 usage_idle=70.0668,usage_system=51.5353,usage_user=76.6182 8999000000000 +cpu,cpu=0 usage_idle=80.9063,usage_system=7.5784,usage_user=29.9215 9000000000000 +cpu,cpu=1 usage_idle=24.288,usage_system=29.6781,usage_user=7.4688 9001000000000 +cpu,cpu=2 usage_idle=24.1431,usage_system=15.9254,usage_user=99.7072 9002000000000 +cpu,cpu=3 usage_idle=6.64655,usage_system=6.88683,usage_user=90.9612 9003000000000 +cpu,cpu=4 usage_idle=78.3692,usage_system=28.6064,usage_user=67.9477 9004000000000 +cpu,cpu=0 usage_idle=85.698,usage_system=93.5548,usage_user=22.2588 9005000000000 +cpu,cpu=1 usage_idle=97.0378,usage_system=59.5753,usage_user=61.1383 9006000000000 +cpu,cpu=2 usage_idle=9.64241,usage_system=11.2635,usage_user=38.1301 9007000000000 +cpu,cpu=3 usage_idle=14.0262,usage_system=58.2193,usage_user=42.3125 9008000000000 +cpu,cpu=4 usage_idle=17.271,usage_system=28.286,usage_user=93.8479 9009000000000 +cpu,cpu=0 usage_idle=93.8892,usage_system=9.19236,usage_user=1.42627 9010000000000 +cpu,cpu=1 usage_idle=23.8108,usage_system=33.4804,usage_user=31.1044 9011000000000 +cpu,cpu=2 usage_idle=31.2796,usage_system=57.6235,usage_user=47.0298 9012000000000 +cpu,cpu=3 usage_idle=30.9868,usage_system=64.2701,usage_user=53.9167 9013000000000 +cpu,cpu=4 usage_idle=21.948,usage_system=42.6393,usage_user=82.5231 9014000000000 +cpu,cpu=0 usage_idle=89.8957,usage_system=28.3373,usage_user=76.0779 9015000000000 +cpu,cpu=1 usage_idle=12.1545,usage_system=25.3751,usage_user=35.6531 9016000000000 +cpu,cpu=2 usage_idle=73.2928,usage_system=35.0175,usage_user=46.9167 9017000000000 +cpu,cpu=3 usage_idle=11.4229,usage_system=49.0437,usage_user=5.13595 9018000000000 +cpu,cpu=4 usage_idle=53.7354,usage_system=66.3147,usage_user=33.422 9019000000000 +cpu,cpu=0 usage_idle=47.5833,usage_system=60.204,usage_user=42.6144 9020000000000 +cpu,cpu=1 usage_idle=49.0096,usage_system=84.0148,usage_user=76.0947 9021000000000 +cpu,cpu=2 usage_idle=80.114,usage_system=15.2944,usage_user=33.7183 9022000000000 +cpu,cpu=3 usage_idle=27.1438,usage_system=46.2811,usage_user=97.9883 9023000000000 +cpu,cpu=4 usage_idle=81.0605,usage_system=68.2291,usage_user=40.6276 9024000000000 +cpu,cpu=0 usage_idle=63.5836,usage_system=58.1248,usage_user=68.9648 9025000000000 +cpu,cpu=1 usage_idle=39.6614,usage_system=70.2793,usage_user=94.3399 9026000000000 +cpu,cpu=2 usage_idle=75.3146,usage_system=43.5721,usage_user=29.3574 9027000000000 +cpu,cpu=3 usage_idle=22.2312,usage_system=54.9951,usage_user=78.4011 9028000000000 +cpu,cpu=4 usage_idle=27.3672,usage_system=8.7305,usage_user=44.7158 9029000000000 +cpu,cpu=0 usage_idle=60.7892,usage_system=56.3138,usage_user=4.9198 9030000000000 +cpu,cpu=1 usage_idle=3.40353,usage_system=5.32341,usage_user=88.9346 9031000000000 +cpu,cpu=2 usage_idle=79.4983,usage_system=85.4374,usage_user=4.22893 9032000000000 +cpu,cpu=3 usage_idle=13.2165,usage_system=12.5812,usage_user=50.5101 9033000000000 +cpu,cpu=4 usage_idle=11.2048,usage_system=93.6417,usage_user=18.7392 9034000000000 +cpu,cpu=0 usage_idle=51.8324,usage_system=57.2252,usage_user=76.864 9035000000000 +cpu,cpu=1 usage_idle=20.7973,usage_system=96.8867,usage_user=47.1434 9036000000000 +cpu,cpu=2 usage_idle=15.1372,usage_system=72.2012,usage_user=90.7155 9037000000000 +cpu,cpu=3 usage_idle=44.4946,usage_system=94.4325,usage_user=45.7105 9038000000000 +cpu,cpu=4 usage_idle=22.8956,usage_system=21.7997,usage_user=54.441 9039000000000 +cpu,cpu=0 usage_idle=67.6115,usage_system=82.5888,usage_user=10.7549 9040000000000 +cpu,cpu=1 usage_idle=72.5313,usage_system=85.9924,usage_user=16.0783 9041000000000 +cpu,cpu=2 usage_idle=61.4658,usage_system=65.4906,usage_user=1.51565 9042000000000 +cpu,cpu=3 usage_idle=65.6948,usage_system=78.7072,usage_user=14.0968 9043000000000 +cpu,cpu=4 usage_idle=16.2048,usage_system=89.912,usage_user=7.7385 9044000000000 +cpu,cpu=0 usage_idle=34.944,usage_system=41.7444,usage_user=64.9637 9045000000000 +cpu,cpu=1 usage_idle=11.808,usage_system=62.5417,usage_user=61.8504 9046000000000 +cpu,cpu=2 usage_idle=58.9514,usage_system=77.6789,usage_user=34.0516 9047000000000 +cpu,cpu=3 usage_idle=49.6669,usage_system=22.1735,usage_user=28.4841 9048000000000 +cpu,cpu=4 usage_idle=95.3774,usage_system=45.0691,usage_user=50.2837 9049000000000 +cpu,cpu=0 usage_idle=49.8185,usage_system=12.6806,usage_user=32.8726 9050000000000 +cpu,cpu=1 usage_idle=60.5733,usage_system=85.2119,usage_user=18.8649 9051000000000 +cpu,cpu=2 usage_idle=76.6516,usage_system=46.6777,usage_user=84.3556 9052000000000 +cpu,cpu=3 usage_idle=78.1673,usage_system=12.3725,usage_user=63.0627 9053000000000 +cpu,cpu=4 usage_idle=92.2641,usage_system=28.5773,usage_user=52.9747 9054000000000 +cpu,cpu=0 usage_idle=0.00261571,usage_system=63.5213,usage_user=94.7192 9055000000000 +cpu,cpu=1 usage_idle=64.9663,usage_system=75.3294,usage_user=57.2609 9056000000000 +cpu,cpu=2 usage_idle=26.8167,usage_system=34.2808,usage_user=34.9398 9057000000000 +cpu,cpu=3 usage_idle=60.8683,usage_system=83.9477,usage_user=57.1132 9058000000000 +cpu,cpu=4 usage_idle=89.3524,usage_system=79.3251,usage_user=2.18234 9059000000000 +cpu,cpu=0 usage_idle=39.6361,usage_system=29.1436,usage_user=14.8629 9060000000000 +cpu,cpu=1 usage_idle=72.5087,usage_system=89.7169,usage_user=0.074776 9061000000000 +cpu,cpu=2 usage_idle=91.3737,usage_system=66.3685,usage_user=46.7525 9062000000000 +cpu,cpu=3 usage_idle=75.7292,usage_system=44.5358,usage_user=59.1249 9063000000000 +cpu,cpu=4 usage_idle=38.7919,usage_system=36.7999,usage_user=87.7022 9064000000000 +cpu,cpu=0 usage_idle=91.7667,usage_system=36.8025,usage_user=51.2236 9065000000000 +cpu,cpu=1 usage_idle=86.4858,usage_system=1.76888,usage_user=26.5529 9066000000000 +cpu,cpu=2 usage_idle=43.7467,usage_system=28.5856,usage_user=60.8337 9067000000000 +cpu,cpu=3 usage_idle=78.6864,usage_system=89.4539,usage_user=44.7813 9068000000000 +cpu,cpu=4 usage_idle=35.7997,usage_system=78.8063,usage_user=24.1064 9069000000000 +cpu,cpu=0 usage_idle=37.982,usage_system=18.4424,usage_user=53.25 9070000000000 +cpu,cpu=1 usage_idle=52.8449,usage_system=90.9512,usage_user=42.9669 9071000000000 +cpu,cpu=2 usage_idle=52.9197,usage_system=82.3248,usage_user=9.33544 9072000000000 +cpu,cpu=3 usage_idle=99.6722,usage_system=58.054,usage_user=53.8712 9073000000000 +cpu,cpu=4 usage_idle=58.7971,usage_system=96.846,usage_user=90.6712 9074000000000 +cpu,cpu=0 usage_idle=46.4994,usage_system=88.6127,usage_user=27.4737 9075000000000 +cpu,cpu=1 usage_idle=97.7229,usage_system=75.0985,usage_user=29.2426 9076000000000 +cpu,cpu=2 usage_idle=24.2758,usage_system=18.8452,usage_user=57.8282 9077000000000 +cpu,cpu=3 usage_idle=85.1095,usage_system=97.5316,usage_user=47.2821 9078000000000 +cpu,cpu=4 usage_idle=29.8908,usage_system=33.3313,usage_user=26.0884 9079000000000 +cpu,cpu=0 usage_idle=53.9972,usage_system=71.3133,usage_user=44.5308 9080000000000 +cpu,cpu=1 usage_idle=7.24721,usage_system=24.1582,usage_user=35.482 9081000000000 +cpu,cpu=2 usage_idle=50.2141,usage_system=77.078,usage_user=17.8068 9082000000000 +cpu,cpu=3 usage_idle=59.5495,usage_system=76.7502,usage_user=75.8609 9083000000000 +cpu,cpu=4 usage_idle=13.4208,usage_system=35.5473,usage_user=72.7068 9084000000000 +cpu,cpu=0 usage_idle=4.09197,usage_system=82.0467,usage_user=61.3195 9085000000000 +cpu,cpu=1 usage_idle=31.5657,usage_system=79.7696,usage_user=36.418 9086000000000 +cpu,cpu=2 usage_idle=60.8083,usage_system=4.0454,usage_user=55.2631 9087000000000 +cpu,cpu=3 usage_idle=18.6365,usage_system=89.1549,usage_user=52.7948 9088000000000 +cpu,cpu=4 usage_idle=65.9186,usage_system=19.0457,usage_user=86.126 9089000000000 +cpu,cpu=0 usage_idle=92.0069,usage_system=73.043,usage_user=57.4394 9090000000000 +cpu,cpu=1 usage_idle=36.5378,usage_system=80.2902,usage_user=81.5976 9091000000000 +cpu,cpu=2 usage_idle=72.0198,usage_system=30.5043,usage_user=58.6756 9092000000000 +cpu,cpu=3 usage_idle=89.8266,usage_system=90.0538,usage_user=35.4257 9093000000000 +cpu,cpu=4 usage_idle=65.6875,usage_system=3.47462,usage_user=70.973 9094000000000 +cpu,cpu=0 usage_idle=38.3943,usage_system=7.5666,usage_user=53.0197 9095000000000 +cpu,cpu=1 usage_idle=99.7138,usage_system=39.1323,usage_user=32.7892 9096000000000 +cpu,cpu=2 usage_idle=36.1318,usage_system=99.9406,usage_user=36.8346 9097000000000 +cpu,cpu=3 usage_idle=91.3949,usage_system=18.5771,usage_user=25.9895 9098000000000 +cpu,cpu=4 usage_idle=44.1897,usage_system=84.4956,usage_user=45.0353 9099000000000 +cpu,cpu=0 usage_idle=30.3157,usage_system=76.5026,usage_user=18.0782 9100000000000 +cpu,cpu=1 usage_idle=87.7551,usage_system=13.0404,usage_user=98.3684 9101000000000 +cpu,cpu=2 usage_idle=69.3527,usage_system=85.0601,usage_user=28.8727 9102000000000 +cpu,cpu=3 usage_idle=28.0283,usage_system=74.8867,usage_user=18.9265 9103000000000 +cpu,cpu=4 usage_idle=63.454,usage_system=40.5742,usage_user=22.4011 9104000000000 +cpu,cpu=0 usage_idle=34.427,usage_system=78.9685,usage_user=29.9677 9105000000000 +cpu,cpu=1 usage_idle=87.4467,usage_system=78.6823,usage_user=69.1 9106000000000 +cpu,cpu=2 usage_idle=20.236,usage_system=14.8141,usage_user=69.0406 9107000000000 +cpu,cpu=3 usage_idle=57.0706,usage_system=6.20903,usage_user=87.6177 9108000000000 +cpu,cpu=4 usage_idle=83.0601,usage_system=50.3987,usage_user=72.1133 9109000000000 +cpu,cpu=0 usage_idle=28.0954,usage_system=80.7145,usage_user=48.6159 9110000000000 +cpu,cpu=1 usage_idle=46.1736,usage_system=68.4696,usage_user=61.6562 9111000000000 +cpu,cpu=2 usage_idle=44.542,usage_system=37.8223,usage_user=46.7163 9112000000000 +cpu,cpu=3 usage_idle=73.4147,usage_system=65.8506,usage_user=21.6031 9113000000000 +cpu,cpu=4 usage_idle=92.3411,usage_system=29.3046,usage_user=62.1772 9114000000000 +cpu,cpu=0 usage_idle=14.7422,usage_system=63.7316,usage_user=41.1457 9115000000000 +cpu,cpu=1 usage_idle=44.7099,usage_system=51.1783,usage_user=19.828 9116000000000 +cpu,cpu=2 usage_idle=13.8099,usage_system=71.4143,usage_user=34.6421 9117000000000 +cpu,cpu=3 usage_idle=82.8505,usage_system=28.4849,usage_user=40.8512 9118000000000 +cpu,cpu=4 usage_idle=70.4682,usage_system=11.5451,usage_user=91.2499 9119000000000 +cpu,cpu=0 usage_idle=42.5815,usage_system=39.6405,usage_user=71.9644 9120000000000 +cpu,cpu=1 usage_idle=91.1973,usage_system=85.8141,usage_user=40.434 9121000000000 +cpu,cpu=2 usage_idle=52.8535,usage_system=30.3561,usage_user=78.2562 9122000000000 +cpu,cpu=3 usage_idle=99.5698,usage_system=3.77076,usage_user=44.1068 9123000000000 +cpu,cpu=4 usage_idle=21.1729,usage_system=96.1119,usage_user=73.4114 9124000000000 +cpu,cpu=0 usage_idle=83.3501,usage_system=10.8541,usage_user=37.143 9125000000000 +cpu,cpu=1 usage_idle=24.4959,usage_system=55.5641,usage_user=88.3213 9126000000000 +cpu,cpu=2 usage_idle=44.3239,usage_system=69.374,usage_user=59.7356 9127000000000 +cpu,cpu=3 usage_idle=78.966,usage_system=52.2245,usage_user=88.2205 9128000000000 +cpu,cpu=4 usage_idle=19.8172,usage_system=22.6927,usage_user=99.7656 9129000000000 +cpu,cpu=0 usage_idle=11.0671,usage_system=65.2742,usage_user=39.406 9130000000000 +cpu,cpu=1 usage_idle=83.0314,usage_system=56.4715,usage_user=25.2201 9131000000000 +cpu,cpu=2 usage_idle=23.4654,usage_system=9.32498,usage_user=55.5762 9132000000000 +cpu,cpu=3 usage_idle=1.72163,usage_system=8.89482,usage_user=59.347 9133000000000 +cpu,cpu=4 usage_idle=45.8284,usage_system=30.0677,usage_user=55.4589 9134000000000 +cpu,cpu=0 usage_idle=19.2398,usage_system=13.4179,usage_user=66.313 9135000000000 +cpu,cpu=1 usage_idle=56.3828,usage_system=37.9137,usage_user=21.8771 9136000000000 +cpu,cpu=2 usage_idle=44.7042,usage_system=82.2377,usage_user=91.2511 9137000000000 +cpu,cpu=3 usage_idle=4.43981,usage_system=61.2037,usage_user=43.4757 9138000000000 +cpu,cpu=4 usage_idle=92.6603,usage_system=81.0209,usage_user=66.1684 9139000000000 +cpu,cpu=0 usage_idle=92.4259,usage_system=92.0879,usage_user=31.4426 9140000000000 +cpu,cpu=1 usage_idle=31.832,usage_system=75.1194,usage_user=87.914 9141000000000 +cpu,cpu=2 usage_idle=57.0521,usage_system=98.5848,usage_user=97.239 9142000000000 +cpu,cpu=3 usage_idle=12.6283,usage_system=0.306398,usage_user=6.13383 9143000000000 +cpu,cpu=4 usage_idle=71.9753,usage_system=46.1348,usage_user=36.2016 9144000000000 +cpu,cpu=0 usage_idle=27.4342,usage_system=65.3747,usage_user=49.6194 9145000000000 +cpu,cpu=1 usage_idle=93.7472,usage_system=21.7575,usage_user=87.5332 9146000000000 +cpu,cpu=2 usage_idle=15.6244,usage_system=66.4617,usage_user=69.7708 9147000000000 +cpu,cpu=3 usage_idle=6.87552,usage_system=70.9015,usage_user=30.9745 9148000000000 +cpu,cpu=4 usage_idle=50.3512,usage_system=63.5618,usage_user=11.9954 9149000000000 +cpu,cpu=0 usage_idle=16.5196,usage_system=55.9877,usage_user=4.08331 9150000000000 +cpu,cpu=1 usage_idle=47.9622,usage_system=87.8197,usage_user=79.2027 9151000000000 +cpu,cpu=2 usage_idle=35.8762,usage_system=44.8718,usage_user=77.7875 9152000000000 +cpu,cpu=3 usage_idle=33.1152,usage_system=57.5001,usage_user=78.0938 9153000000000 +cpu,cpu=4 usage_idle=39.2491,usage_system=29.4755,usage_user=24.2287 9154000000000 +cpu,cpu=0 usage_idle=75.4506,usage_system=56.9097,usage_user=89.6034 9155000000000 +cpu,cpu=1 usage_idle=25.07,usage_system=50.6569,usage_user=11.3609 9156000000000 +cpu,cpu=2 usage_idle=12.6032,usage_system=66.2813,usage_user=77.8225 9157000000000 +cpu,cpu=3 usage_idle=82.374,usage_system=73.1568,usage_user=48.724 9158000000000 +cpu,cpu=4 usage_idle=13.3485,usage_system=23.508,usage_user=12.2859 9159000000000 +cpu,cpu=0 usage_idle=25.3439,usage_system=40.0276,usage_user=68.2736 9160000000000 +cpu,cpu=1 usage_idle=29.4272,usage_system=87.9898,usage_user=56.0933 9161000000000 +cpu,cpu=2 usage_idle=8.62991,usage_system=23.866,usage_user=0.965126 9162000000000 +cpu,cpu=3 usage_idle=86.4174,usage_system=56.9812,usage_user=58.4653 9163000000000 +cpu,cpu=4 usage_idle=64.5112,usage_system=96.2303,usage_user=87.9407 9164000000000 +cpu,cpu=0 usage_idle=88.7399,usage_system=71.6809,usage_user=44.8504 9165000000000 +cpu,cpu=1 usage_idle=78.3432,usage_system=96.7509,usage_user=95.5073 9166000000000 +cpu,cpu=2 usage_idle=89.7041,usage_system=9.35414,usage_user=61.7886 9167000000000 +cpu,cpu=3 usage_idle=67.5267,usage_system=91.7282,usage_user=34.9454 9168000000000 +cpu,cpu=4 usage_idle=16.2507,usage_system=5.07672,usage_user=58.4534 9169000000000 +cpu,cpu=0 usage_idle=28.5365,usage_system=30.4206,usage_user=98.4811 9170000000000 +cpu,cpu=1 usage_idle=96.8101,usage_system=59.8479,usage_user=86.4709 9171000000000 +cpu,cpu=2 usage_idle=52.9035,usage_system=68.4778,usage_user=10.3369 9172000000000 +cpu,cpu=3 usage_idle=53.8686,usage_system=54.8951,usage_user=67.3181 9173000000000 +cpu,cpu=4 usage_idle=12.3339,usage_system=19.4063,usage_user=63.5484 9174000000000 +cpu,cpu=0 usage_idle=0.274584,usage_system=8.14623,usage_user=35.2293 9175000000000 +cpu,cpu=1 usage_idle=45.125,usage_system=86.4895,usage_user=31.9802 9176000000000 +cpu,cpu=2 usage_idle=40.6323,usage_system=76.1936,usage_user=41.3343 9177000000000 +cpu,cpu=3 usage_idle=2.42091,usage_system=43.7202,usage_user=33.0625 9178000000000 +cpu,cpu=4 usage_idle=37.3663,usage_system=59.9709,usage_user=38.1392 9179000000000 +cpu,cpu=0 usage_idle=95.8198,usage_system=88.5075,usage_user=68.5599 9180000000000 +cpu,cpu=1 usage_idle=94.3008,usage_system=85.3176,usage_user=28.4077 9181000000000 +cpu,cpu=2 usage_idle=80.7717,usage_system=38.2211,usage_user=96.8855 9182000000000 +cpu,cpu=3 usage_idle=91.1086,usage_system=92.0897,usage_user=51.7806 9183000000000 +cpu,cpu=4 usage_idle=58.4267,usage_system=4.42352,usage_user=71.187 9184000000000 +cpu,cpu=0 usage_idle=21.9751,usage_system=4.6981,usage_user=79.3332 9185000000000 +cpu,cpu=1 usage_idle=57.2043,usage_system=49.8231,usage_user=65.8227 9186000000000 +cpu,cpu=2 usage_idle=89.1845,usage_system=90.4554,usage_user=42.0162 9187000000000 +cpu,cpu=3 usage_idle=30.5189,usage_system=92.8763,usage_user=85.7365 9188000000000 +cpu,cpu=4 usage_idle=63.5814,usage_system=30.2426,usage_user=45.7074 9189000000000 +cpu,cpu=0 usage_idle=1.72064,usage_system=26.0624,usage_user=34.2149 9190000000000 +cpu,cpu=1 usage_idle=70.2805,usage_system=20.3632,usage_user=19.5325 9191000000000 +cpu,cpu=2 usage_idle=98.6882,usage_system=1.13488,usage_user=57.7536 9192000000000 +cpu,cpu=3 usage_idle=95.5737,usage_system=92.2434,usage_user=49.8433 9193000000000 +cpu,cpu=4 usage_idle=47.3544,usage_system=50.6701,usage_user=54.2668 9194000000000 +cpu,cpu=0 usage_idle=18.5413,usage_system=72.6452,usage_user=58.9649 9195000000000 +cpu,cpu=1 usage_idle=97.8745,usage_system=29.8495,usage_user=8.78796 9196000000000 +cpu,cpu=2 usage_idle=63.6971,usage_system=19.034,usage_user=99.2434 9197000000000 +cpu,cpu=3 usage_idle=5.71339,usage_system=49.5529,usage_user=92.1197 9198000000000 +cpu,cpu=4 usage_idle=91.4499,usage_system=13.1343,usage_user=22.3623 9199000000000 +cpu,cpu=0 usage_idle=37.1573,usage_system=14.8549,usage_user=48.4247 9200000000000 +cpu,cpu=1 usage_idle=71.3722,usage_system=85.1354,usage_user=68.7879 9201000000000 +cpu,cpu=2 usage_idle=90.9047,usage_system=83.8237,usage_user=69.9227 9202000000000 +cpu,cpu=3 usage_idle=48.6583,usage_system=79.3974,usage_user=62.1662 9203000000000 +cpu,cpu=4 usage_idle=98.5016,usage_system=26.7518,usage_user=12.8363 9204000000000 +cpu,cpu=0 usage_idle=52.7684,usage_system=45.2931,usage_user=85.4814 9205000000000 +cpu,cpu=1 usage_idle=11.7333,usage_system=43.1676,usage_user=15.3309 9206000000000 +cpu,cpu=2 usage_idle=20.5212,usage_system=6.86471,usage_user=34.3649 9207000000000 +cpu,cpu=3 usage_idle=19.7646,usage_system=12.5781,usage_user=83.9178 9208000000000 +cpu,cpu=4 usage_idle=11.8842,usage_system=4.02799,usage_user=97.0521 9209000000000 +cpu,cpu=0 usage_idle=34.2465,usage_system=41.1853,usage_user=11.9071 9210000000000 +cpu,cpu=1 usage_idle=82.6712,usage_system=12.5575,usage_user=97.0425 9211000000000 +cpu,cpu=2 usage_idle=51.459,usage_system=3.46225,usage_user=80.8662 9212000000000 +cpu,cpu=3 usage_idle=21.3817,usage_system=52.1206,usage_user=60.2636 9213000000000 +cpu,cpu=4 usage_idle=83.5479,usage_system=50.6222,usage_user=87.0154 9214000000000 +cpu,cpu=0 usage_idle=96.3842,usage_system=3.39056,usage_user=32.3085 9215000000000 +cpu,cpu=1 usage_idle=81.8656,usage_system=15.1238,usage_user=75.476 9216000000000 +cpu,cpu=2 usage_idle=97.1965,usage_system=35.645,usage_user=82.3407 9217000000000 +cpu,cpu=3 usage_idle=31.5614,usage_system=55.4096,usage_user=94.9188 9218000000000 +cpu,cpu=4 usage_idle=15.4792,usage_system=67.2938,usage_user=98.9468 9219000000000 +cpu,cpu=0 usage_idle=12.5314,usage_system=1.54034,usage_user=40.1321 9220000000000 +cpu,cpu=1 usage_idle=24.4384,usage_system=84.2115,usage_user=52.6896 9221000000000 +cpu,cpu=2 usage_idle=21.481,usage_system=35.6705,usage_user=56.1519 9222000000000 +cpu,cpu=3 usage_idle=2.34715,usage_system=57.0522,usage_user=8.27248 9223000000000 +cpu,cpu=4 usage_idle=62.6108,usage_system=40.6001,usage_user=58.8947 9224000000000 +cpu,cpu=0 usage_idle=49.6261,usage_system=36.9843,usage_user=62.2852 9225000000000 +cpu,cpu=1 usage_idle=81.9346,usage_system=18.8499,usage_user=77.409 9226000000000 +cpu,cpu=2 usage_idle=57.4106,usage_system=16.0464,usage_user=13.0541 9227000000000 +cpu,cpu=3 usage_idle=39.7513,usage_system=47.6078,usage_user=68.4637 9228000000000 +cpu,cpu=4 usage_idle=34.6702,usage_system=63.087,usage_user=35.7575 9229000000000 +cpu,cpu=0 usage_idle=33.617,usage_system=75.6184,usage_user=37.2978 9230000000000 +cpu,cpu=1 usage_idle=73.7491,usage_system=0.0568365,usage_user=21.5093 9231000000000 +cpu,cpu=2 usage_idle=26.4388,usage_system=21.5378,usage_user=57.1798 9232000000000 +cpu,cpu=3 usage_idle=82.5907,usage_system=23.8849,usage_user=14.2321 9233000000000 +cpu,cpu=4 usage_idle=90.8632,usage_system=86.4957,usage_user=54.8322 9234000000000 +cpu,cpu=0 usage_idle=49.7578,usage_system=36.1218,usage_user=91.8165 9235000000000 +cpu,cpu=1 usage_idle=12.043,usage_system=18.0564,usage_user=10.6664 9236000000000 +cpu,cpu=2 usage_idle=89.4521,usage_system=75.4671,usage_user=26.7128 9237000000000 +cpu,cpu=3 usage_idle=2.50613,usage_system=15.2184,usage_user=74.3206 9238000000000 +cpu,cpu=4 usage_idle=70.9698,usage_system=49.8886,usage_user=37.4076 9239000000000 +cpu,cpu=0 usage_idle=6.7273,usage_system=83.5056,usage_user=13.026 9240000000000 +cpu,cpu=1 usage_idle=44.0251,usage_system=57.2547,usage_user=13.0829 9241000000000 +cpu,cpu=2 usage_idle=65.5345,usage_system=83.6935,usage_user=34.6206 9242000000000 +cpu,cpu=3 usage_idle=22.7143,usage_system=66.2842,usage_user=58.5056 9243000000000 +cpu,cpu=4 usage_idle=36.9464,usage_system=57.1473,usage_user=45.0013 9244000000000 +cpu,cpu=0 usage_idle=91.7786,usage_system=6.90512,usage_user=81.1231 9245000000000 +cpu,cpu=1 usage_idle=83.5951,usage_system=18.9482,usage_user=99.1796 9246000000000 +cpu,cpu=2 usage_idle=94.2615,usage_system=8.40022,usage_user=74.6466 9247000000000 +cpu,cpu=3 usage_idle=20.9743,usage_system=10.9063,usage_user=89.865 9248000000000 +cpu,cpu=4 usage_idle=95.2949,usage_system=81.8761,usage_user=39.7536 9249000000000 +cpu,cpu=0 usage_idle=32.7025,usage_system=88.6034,usage_user=23.2592 9250000000000 +cpu,cpu=1 usage_idle=45.7285,usage_system=32.6286,usage_user=80.5139 9251000000000 +cpu,cpu=2 usage_idle=58.8114,usage_system=98.163,usage_user=64.2073 9252000000000 +cpu,cpu=3 usage_idle=93.432,usage_system=20.8773,usage_user=30.4915 9253000000000 +cpu,cpu=4 usage_idle=51.9376,usage_system=57.8237,usage_user=87.6388 9254000000000 +cpu,cpu=0 usage_idle=96.9389,usage_system=49.6023,usage_user=94.5439 9255000000000 +cpu,cpu=1 usage_idle=78.062,usage_system=33.1974,usage_user=13.4921 9256000000000 +cpu,cpu=2 usage_idle=77.2415,usage_system=27.4589,usage_user=21.8923 9257000000000 +cpu,cpu=3 usage_idle=51.8882,usage_system=48.4333,usage_user=32.7986 9258000000000 +cpu,cpu=4 usage_idle=41.7532,usage_system=43.7281,usage_user=14.6748 9259000000000 +cpu,cpu=0 usage_idle=81.5068,usage_system=76.4306,usage_user=3.27822 9260000000000 +cpu,cpu=1 usage_idle=4.76591,usage_system=22.1592,usage_user=35.9068 9261000000000 +cpu,cpu=2 usage_idle=85.2798,usage_system=80.9705,usage_user=34.0698 9262000000000 +cpu,cpu=3 usage_idle=49.4871,usage_system=74.4025,usage_user=54.9472 9263000000000 +cpu,cpu=4 usage_idle=79.9786,usage_system=26.3401,usage_user=12.7709 9264000000000 +cpu,cpu=0 usage_idle=67.6174,usage_system=23.279,usage_user=62.3732 9265000000000 +cpu,cpu=1 usage_idle=62.1613,usage_system=1.34095,usage_user=95.5707 9266000000000 +cpu,cpu=2 usage_idle=75.6534,usage_system=78.5825,usage_user=23.0296 9267000000000 +cpu,cpu=3 usage_idle=97.5457,usage_system=30.4707,usage_user=71.4629 9268000000000 +cpu,cpu=4 usage_idle=30.3443,usage_system=72.2238,usage_user=15.191 9269000000000 +cpu,cpu=0 usage_idle=45.0191,usage_system=53.7306,usage_user=91.6216 9270000000000 +cpu,cpu=1 usage_idle=48.2973,usage_system=58.4965,usage_user=13.7808 9271000000000 +cpu,cpu=2 usage_idle=84.2041,usage_system=43.7763,usage_user=94.7513 9272000000000 +cpu,cpu=3 usage_idle=18.274,usage_system=93.2634,usage_user=69.1539 9273000000000 +cpu,cpu=4 usage_idle=73.2212,usage_system=73.242,usage_user=95.494 9274000000000 +cpu,cpu=0 usage_idle=85.9921,usage_system=40.8594,usage_user=18.773 9275000000000 +cpu,cpu=1 usage_idle=48.3653,usage_system=3.02075,usage_user=20.1139 9276000000000 +cpu,cpu=2 usage_idle=43.936,usage_system=78.6742,usage_user=98.6964 9277000000000 +cpu,cpu=3 usage_idle=66.9656,usage_system=76.2199,usage_user=29.1671 9278000000000 +cpu,cpu=4 usage_idle=38.4284,usage_system=6.56419,usage_user=1.39087 9279000000000 +cpu,cpu=0 usage_idle=53.6194,usage_system=51.5833,usage_user=55.1214 9280000000000 +cpu,cpu=1 usage_idle=45.2411,usage_system=99.8806,usage_user=13.6179 9281000000000 +cpu,cpu=2 usage_idle=59.0219,usage_system=84.0848,usage_user=57.3942 9282000000000 +cpu,cpu=3 usage_idle=53.7732,usage_system=2.35874,usage_user=50.6576 9283000000000 +cpu,cpu=4 usage_idle=22.9271,usage_system=75.5799,usage_user=23.8996 9284000000000 +cpu,cpu=0 usage_idle=18.4211,usage_system=61.572,usage_user=64.759 9285000000000 +cpu,cpu=1 usage_idle=37.194,usage_system=9.93728,usage_user=67.7798 9286000000000 +cpu,cpu=2 usage_idle=57.3079,usage_system=53.8733,usage_user=46.4539 9287000000000 +cpu,cpu=3 usage_idle=56.0043,usage_system=20.8388,usage_user=22.6738 9288000000000 +cpu,cpu=4 usage_idle=85.1714,usage_system=59.2673,usage_user=29.238 9289000000000 +cpu,cpu=0 usage_idle=86.5623,usage_system=12.8867,usage_user=80.8213 9290000000000 +cpu,cpu=1 usage_idle=41.6837,usage_system=58.1278,usage_user=80.7019 9291000000000 +cpu,cpu=2 usage_idle=55.3016,usage_system=17.1496,usage_user=64.7867 9292000000000 +cpu,cpu=3 usage_idle=12.6958,usage_system=70.9228,usage_user=67.1454 9293000000000 +cpu,cpu=4 usage_idle=63.3534,usage_system=93.8499,usage_user=42.7253 9294000000000 +cpu,cpu=0 usage_idle=87.253,usage_system=12.271,usage_user=4.29729 9295000000000 +cpu,cpu=1 usage_idle=52.012,usage_system=49.465,usage_user=14.2346 9296000000000 +cpu,cpu=2 usage_idle=19.7918,usage_system=6.77294,usage_user=68.1078 9297000000000 +cpu,cpu=3 usage_idle=66.2457,usage_system=62.7773,usage_user=88.9467 9298000000000 +cpu,cpu=4 usage_idle=88.9195,usage_system=47.9487,usage_user=48.2139 9299000000000 +cpu,cpu=0 usage_idle=18.1574,usage_system=34.5109,usage_user=61.1006 9300000000000 +cpu,cpu=1 usage_idle=98.9787,usage_system=76.1946,usage_user=19.2283 9301000000000 +cpu,cpu=2 usage_idle=79.6806,usage_system=31.4963,usage_user=36.378 9302000000000 +cpu,cpu=3 usage_idle=44.4673,usage_system=44.1921,usage_user=7.30083 9303000000000 +cpu,cpu=4 usage_idle=11.6127,usage_system=7.54556,usage_user=1.15076 9304000000000 +cpu,cpu=0 usage_idle=54.338,usage_system=94.7986,usage_user=13.4217 9305000000000 +cpu,cpu=1 usage_idle=58.6353,usage_system=46.8106,usage_user=62.8868 9306000000000 +cpu,cpu=2 usage_idle=72.8699,usage_system=66.6024,usage_user=69.6597 9307000000000 +cpu,cpu=3 usage_idle=40.9777,usage_system=32.8481,usage_user=32.437 9308000000000 +cpu,cpu=4 usage_idle=29.9244,usage_system=21.7676,usage_user=80.3856 9309000000000 +cpu,cpu=0 usage_idle=78.1383,usage_system=39.925,usage_user=14.8965 9310000000000 +cpu,cpu=1 usage_idle=39.2389,usage_system=38.9037,usage_user=91.0912 9311000000000 +cpu,cpu=2 usage_idle=58.4672,usage_system=18.5843,usage_user=22.5874 9312000000000 +cpu,cpu=3 usage_idle=94.8452,usage_system=63.0516,usage_user=66.7795 9313000000000 +cpu,cpu=4 usage_idle=2.14605,usage_system=74.6643,usage_user=74.3251 9314000000000 +cpu,cpu=0 usage_idle=3.29681,usage_system=29.0024,usage_user=69.1237 9315000000000 +cpu,cpu=1 usage_idle=16.7186,usage_system=87.6377,usage_user=15.9343 9316000000000 +cpu,cpu=2 usage_idle=79.6053,usage_system=60.5076,usage_user=82.5367 9317000000000 +cpu,cpu=3 usage_idle=49.265,usage_system=1.48535,usage_user=15.3848 9318000000000 +cpu,cpu=4 usage_idle=81.702,usage_system=31.4097,usage_user=37.1524 9319000000000 +cpu,cpu=0 usage_idle=62.0876,usage_system=9.54805,usage_user=77.0774 9320000000000 +cpu,cpu=1 usage_idle=76.9841,usage_system=48.7869,usage_user=15.9811 9321000000000 +cpu,cpu=2 usage_idle=68.0753,usage_system=7.25418,usage_user=34.5654 9322000000000 +cpu,cpu=3 usage_idle=90.6627,usage_system=2.0994,usage_user=97.617 9323000000000 +cpu,cpu=4 usage_idle=57.4423,usage_system=4.24545,usage_user=72.2814 9324000000000 +cpu,cpu=0 usage_idle=31.7674,usage_system=7.54226,usage_user=1.28374 9325000000000 +cpu,cpu=1 usage_idle=0.891058,usage_system=24.2608,usage_user=88.9214 9326000000000 +cpu,cpu=2 usage_idle=16.8254,usage_system=3.86611,usage_user=49.429 9327000000000 +cpu,cpu=3 usage_idle=99.3621,usage_system=53.1311,usage_user=50.9144 9328000000000 +cpu,cpu=4 usage_idle=14.7469,usage_system=34.8331,usage_user=82.3241 9329000000000 +cpu,cpu=0 usage_idle=51.8993,usage_system=96.9207,usage_user=91.8722 9330000000000 +cpu,cpu=1 usage_idle=28.9767,usage_system=73.9048,usage_user=40.6591 9331000000000 +cpu,cpu=2 usage_idle=44.9578,usage_system=41.9801,usage_user=47.9133 9332000000000 +cpu,cpu=3 usage_idle=79.5233,usage_system=32.6428,usage_user=50.0127 9333000000000 +cpu,cpu=4 usage_idle=77.1403,usage_system=90.085,usage_user=54.2582 9334000000000 +cpu,cpu=0 usage_idle=49.4217,usage_system=21.8524,usage_user=61.8004 9335000000000 +cpu,cpu=1 usage_idle=50.7054,usage_system=22.7435,usage_user=86.0612 9336000000000 +cpu,cpu=2 usage_idle=39.6268,usage_system=39.5688,usage_user=89.9273 9337000000000 +cpu,cpu=3 usage_idle=89.0559,usage_system=38.9309,usage_user=43.0584 9338000000000 +cpu,cpu=4 usage_idle=39.9703,usage_system=53.6778,usage_user=77.8915 9339000000000 +cpu,cpu=0 usage_idle=22.2944,usage_system=5.57717,usage_user=74.8122 9340000000000 +cpu,cpu=1 usage_idle=14.1666,usage_system=34.5539,usage_user=48.717 9341000000000 +cpu,cpu=2 usage_idle=54.8257,usage_system=79.5117,usage_user=90.697 9342000000000 +cpu,cpu=3 usage_idle=2.73902,usage_system=59.035,usage_user=23.3398 9343000000000 +cpu,cpu=4 usage_idle=52.7517,usage_system=36.1753,usage_user=13.4249 9344000000000 +cpu,cpu=0 usage_idle=7.00988,usage_system=85.5969,usage_user=35.2773 9345000000000 +cpu,cpu=1 usage_idle=68.8103,usage_system=36.3023,usage_user=58.0207 9346000000000 +cpu,cpu=2 usage_idle=54.8715,usage_system=75.9291,usage_user=97.5896 9347000000000 +cpu,cpu=3 usage_idle=44.7988,usage_system=64.985,usage_user=36.5205 9348000000000 +cpu,cpu=4 usage_idle=87.8573,usage_system=4.95528,usage_user=90.1983 9349000000000 +cpu,cpu=0 usage_idle=65.7488,usage_system=27.2497,usage_user=95.7755 9350000000000 +cpu,cpu=1 usage_idle=40.561,usage_system=41.4163,usage_user=30.3294 9351000000000 +cpu,cpu=2 usage_idle=89.278,usage_system=96.242,usage_user=9.8411 9352000000000 +cpu,cpu=3 usage_idle=79.975,usage_system=98.981,usage_user=68.8761 9353000000000 +cpu,cpu=4 usage_idle=3.31483,usage_system=51.7328,usage_user=5.05132 9354000000000 +cpu,cpu=0 usage_idle=16.7397,usage_system=58.7427,usage_user=90.6482 9355000000000 +cpu,cpu=1 usage_idle=52.017,usage_system=27.5529,usage_user=26.9505 9356000000000 +cpu,cpu=2 usage_idle=10.0377,usage_system=82.4244,usage_user=2.87967 9357000000000 +cpu,cpu=3 usage_idle=7.62724,usage_system=27.2233,usage_user=67.8647 9358000000000 +cpu,cpu=4 usage_idle=44.1477,usage_system=15.0805,usage_user=72.82 9359000000000 +cpu,cpu=0 usage_idle=34.3461,usage_system=80.8293,usage_user=0.0696586 9360000000000 +cpu,cpu=1 usage_idle=30.1216,usage_system=21.3903,usage_user=41.486 9361000000000 +cpu,cpu=2 usage_idle=60.4509,usage_system=10.6683,usage_user=37.728 9362000000000 +cpu,cpu=3 usage_idle=70.292,usage_system=90.6433,usage_user=36.709 9363000000000 +cpu,cpu=4 usage_idle=39.1681,usage_system=93.9581,usage_user=88.4418 9364000000000 +cpu,cpu=0 usage_idle=44.2194,usage_system=10.6978,usage_user=47.1844 9365000000000 +cpu,cpu=1 usage_idle=34.8677,usage_system=62.7148,usage_user=74.7374 9366000000000 +cpu,cpu=2 usage_idle=61.8182,usage_system=72.7524,usage_user=57.1618 9367000000000 +cpu,cpu=3 usage_idle=64.6979,usage_system=80.3797,usage_user=84.3851 9368000000000 +cpu,cpu=4 usage_idle=32.5625,usage_system=24.5274,usage_user=99.4656 9369000000000 +cpu,cpu=0 usage_idle=5.38249,usage_system=58.8735,usage_user=80.2949 9370000000000 +cpu,cpu=1 usage_idle=5.45214,usage_system=88.995,usage_user=1.68527 9371000000000 +cpu,cpu=2 usage_idle=46.9381,usage_system=49.4459,usage_user=12.3536 9372000000000 +cpu,cpu=3 usage_idle=84.6661,usage_system=19.738,usage_user=2.99684 9373000000000 +cpu,cpu=4 usage_idle=21.3751,usage_system=58.9061,usage_user=96.955 9374000000000 +cpu,cpu=0 usage_idle=9.81691,usage_system=3.1255,usage_user=7.65277 9375000000000 +cpu,cpu=1 usage_idle=57.0014,usage_system=37.9932,usage_user=70.3675 9376000000000 +cpu,cpu=2 usage_idle=31.7387,usage_system=99.8113,usage_user=43.12 9377000000000 +cpu,cpu=3 usage_idle=88.9006,usage_system=64.5092,usage_user=23.4997 9378000000000 +cpu,cpu=4 usage_idle=73.2856,usage_system=97.0717,usage_user=48.0271 9379000000000 +cpu,cpu=0 usage_idle=72.7513,usage_system=2.4542,usage_user=6.90053 9380000000000 +cpu,cpu=1 usage_idle=53.0462,usage_system=7.90634,usage_user=95.8955 9381000000000 +cpu,cpu=2 usage_idle=54.7315,usage_system=54.8444,usage_user=45.3415 9382000000000 +cpu,cpu=3 usage_idle=67.085,usage_system=39.5105,usage_user=65.0795 9383000000000 +cpu,cpu=4 usage_idle=70.0819,usage_system=60.8856,usage_user=23.9856 9384000000000 +cpu,cpu=0 usage_idle=67.0368,usage_system=70.7025,usage_user=27.1111 9385000000000 +cpu,cpu=1 usage_idle=74.6896,usage_system=27.7039,usage_user=65.1042 9386000000000 +cpu,cpu=2 usage_idle=45.0571,usage_system=59.4426,usage_user=64.9156 9387000000000 +cpu,cpu=3 usage_idle=88.1771,usage_system=48.3432,usage_user=29.4247 9388000000000 +cpu,cpu=4 usage_idle=11.6768,usage_system=21.6288,usage_user=26.4965 9389000000000 +cpu,cpu=0 usage_idle=59.7038,usage_system=94.3801,usage_user=28.9507 9390000000000 +cpu,cpu=1 usage_idle=66.6044,usage_system=47.4263,usage_user=36.857 9391000000000 +cpu,cpu=2 usage_idle=62.4999,usage_system=2.15776,usage_user=91.7015 9392000000000 +cpu,cpu=3 usage_idle=7.8414,usage_system=69.2428,usage_user=31.212 9393000000000 +cpu,cpu=4 usage_idle=72.9209,usage_system=39.3246,usage_user=92.0976 9394000000000 +cpu,cpu=0 usage_idle=96.9064,usage_system=6.36146,usage_user=62.8001 9395000000000 +cpu,cpu=1 usage_idle=24.0175,usage_system=81.0511,usage_user=90.504 9396000000000 +cpu,cpu=2 usage_idle=89.1217,usage_system=26.1082,usage_user=49.9467 9397000000000 +cpu,cpu=3 usage_idle=54.0373,usage_system=14.2853,usage_user=98.2899 9398000000000 +cpu,cpu=4 usage_idle=83.462,usage_system=25.962,usage_user=19.9187 9399000000000 +cpu,cpu=0 usage_idle=9.95847,usage_system=85.6659,usage_user=14.2988 9400000000000 +cpu,cpu=1 usage_idle=38.9091,usage_system=52.2702,usage_user=61.7251 9401000000000 +cpu,cpu=2 usage_idle=75.7661,usage_system=14.7701,usage_user=63.8828 9402000000000 +cpu,cpu=3 usage_idle=67.4676,usage_system=22.6115,usage_user=33.1256 9403000000000 +cpu,cpu=4 usage_idle=98.6796,usage_system=95.5324,usage_user=72.4502 9404000000000 +cpu,cpu=0 usage_idle=90.7772,usage_system=92.4388,usage_user=78.8117 9405000000000 +cpu,cpu=1 usage_idle=53.5773,usage_system=16.4563,usage_user=59.8627 9406000000000 +cpu,cpu=2 usage_idle=44.0814,usage_system=5.57804,usage_user=85.9709 9407000000000 +cpu,cpu=3 usage_idle=94.028,usage_system=59.6153,usage_user=0.256179 9408000000000 +cpu,cpu=4 usage_idle=92.3179,usage_system=43.0773,usage_user=26.2182 9409000000000 +cpu,cpu=0 usage_idle=12.2366,usage_system=53.0358,usage_user=11.8841 9410000000000 +cpu,cpu=1 usage_idle=26.5354,usage_system=91.9449,usage_user=64.1543 9411000000000 +cpu,cpu=2 usage_idle=88.2604,usage_system=67.7111,usage_user=78.9244 9412000000000 +cpu,cpu=3 usage_idle=52.1432,usage_system=35.1786,usage_user=1.53593 9413000000000 +cpu,cpu=4 usage_idle=85.2688,usage_system=33.8582,usage_user=97.0683 9414000000000 +cpu,cpu=0 usage_idle=57.7191,usage_system=24.6354,usage_user=89.5072 9415000000000 +cpu,cpu=1 usage_idle=36.5307,usage_system=78.2127,usage_user=5.9635 9416000000000 +cpu,cpu=2 usage_idle=96.3935,usage_system=22.2941,usage_user=11.5415 9417000000000 +cpu,cpu=3 usage_idle=82.3644,usage_system=16.3221,usage_user=71.1569 9418000000000 +cpu,cpu=4 usage_idle=82.6206,usage_system=8.64001,usage_user=14.2342 9419000000000 +cpu,cpu=0 usage_idle=8.83878,usage_system=20.8766,usage_user=67.27 9420000000000 +cpu,cpu=1 usage_idle=20.7228,usage_system=47.412,usage_user=59.2149 9421000000000 +cpu,cpu=2 usage_idle=84.8771,usage_system=35.6724,usage_user=26.9259 9422000000000 +cpu,cpu=3 usage_idle=63.8015,usage_system=87.8156,usage_user=62.1046 9423000000000 +cpu,cpu=4 usage_idle=65.3374,usage_system=73.0845,usage_user=95.9628 9424000000000 +cpu,cpu=0 usage_idle=62.4058,usage_system=30.8035,usage_user=20.5982 9425000000000 +cpu,cpu=1 usage_idle=51.9129,usage_system=67.3343,usage_user=98.8108 9426000000000 +cpu,cpu=2 usage_idle=57.8764,usage_system=63.7277,usage_user=21.1049 9427000000000 +cpu,cpu=3 usage_idle=69.418,usage_system=46.0921,usage_user=37.427 9428000000000 +cpu,cpu=4 usage_idle=40.5748,usage_system=28.7127,usage_user=46.067 9429000000000 +cpu,cpu=0 usage_idle=54.809,usage_system=37.5515,usage_user=66.9436 9430000000000 +cpu,cpu=1 usage_idle=22.079,usage_system=58.2743,usage_user=14.3556 9431000000000 +cpu,cpu=2 usage_idle=81.2939,usage_system=43.1515,usage_user=50.028 9432000000000 +cpu,cpu=3 usage_idle=8.2198,usage_system=6.95299,usage_user=37.8436 9433000000000 +cpu,cpu=4 usage_idle=70.3244,usage_system=72.2904,usage_user=10.9281 9434000000000 +cpu,cpu=0 usage_idle=66.2871,usage_system=34.6962,usage_user=41.7316 9435000000000 +cpu,cpu=1 usage_idle=86.8853,usage_system=86.6092,usage_user=9.06586 9436000000000 +cpu,cpu=2 usage_idle=85.6962,usage_system=44.4856,usage_user=72.7936 9437000000000 +cpu,cpu=3 usage_idle=6.80106,usage_system=13.9036,usage_user=18.8857 9438000000000 +cpu,cpu=4 usage_idle=44.2281,usage_system=54.4784,usage_user=47.5985 9439000000000 +cpu,cpu=0 usage_idle=90.2951,usage_system=9.28744,usage_user=85.15 9440000000000 +cpu,cpu=1 usage_idle=57.2387,usage_system=31.3664,usage_user=43.4243 9441000000000 +cpu,cpu=2 usage_idle=71.5943,usage_system=12.6603,usage_user=86.5758 9442000000000 +cpu,cpu=3 usage_idle=21.6223,usage_system=20.8801,usage_user=93.5288 9443000000000 +cpu,cpu=4 usage_idle=59.466,usage_system=91.2044,usage_user=65.8192 9444000000000 +cpu,cpu=0 usage_idle=70.394,usage_system=57.4916,usage_user=0.515409 9445000000000 +cpu,cpu=1 usage_idle=12.1256,usage_system=44.3769,usage_user=87.1246 9446000000000 +cpu,cpu=2 usage_idle=21.1915,usage_system=30.073,usage_user=31.6102 9447000000000 +cpu,cpu=3 usage_idle=93.9851,usage_system=36.8741,usage_user=45.5138 9448000000000 +cpu,cpu=4 usage_idle=12.8709,usage_system=81.1022,usage_user=99.9922 9449000000000 +cpu,cpu=0 usage_idle=60.4693,usage_system=71.3973,usage_user=9.27964 9450000000000 +cpu,cpu=1 usage_idle=45.6193,usage_system=28.636,usage_user=40.6461 9451000000000 +cpu,cpu=2 usage_idle=89.0436,usage_system=0.230364,usage_user=53.3063 9452000000000 +cpu,cpu=3 usage_idle=75.6194,usage_system=21.8527,usage_user=74.1864 9453000000000 +cpu,cpu=4 usage_idle=69.1481,usage_system=81.3187,usage_user=65.3908 9454000000000 +cpu,cpu=0 usage_idle=34.9673,usage_system=51.7127,usage_user=22.8824 9455000000000 +cpu,cpu=1 usage_idle=35.4827,usage_system=63.8384,usage_user=67.2593 9456000000000 +cpu,cpu=2 usage_idle=22.6073,usage_system=85.0299,usage_user=97.3324 9457000000000 +cpu,cpu=3 usage_idle=54.2175,usage_system=79.015,usage_user=34.2065 9458000000000 +cpu,cpu=4 usage_idle=99.7313,usage_system=91.8858,usage_user=15.3087 9459000000000 +cpu,cpu=0 usage_idle=99.7235,usage_system=52.3552,usage_user=86.706 9460000000000 +cpu,cpu=1 usage_idle=9.00309,usage_system=97.9745,usage_user=15.342 9461000000000 +cpu,cpu=2 usage_idle=49.6491,usage_system=87.0181,usage_user=15.5724 9462000000000 +cpu,cpu=3 usage_idle=2.95547,usage_system=62.6374,usage_user=37.4251 9463000000000 +cpu,cpu=4 usage_idle=77.1419,usage_system=31.7856,usage_user=18.7437 9464000000000 +cpu,cpu=0 usage_idle=42.5327,usage_system=66.7529,usage_user=70.4564 9465000000000 +cpu,cpu=1 usage_idle=65.4151,usage_system=2.23564,usage_user=34.2948 9466000000000 +cpu,cpu=2 usage_idle=32.6745,usage_system=24.8429,usage_user=19.3246 9467000000000 +cpu,cpu=3 usage_idle=30.0069,usage_system=79.0604,usage_user=98.3396 9468000000000 +cpu,cpu=4 usage_idle=64.2133,usage_system=78.7917,usage_user=90.2255 9469000000000 +cpu,cpu=0 usage_idle=79.522,usage_system=78.5151,usage_user=42.5806 9470000000000 +cpu,cpu=1 usage_idle=66.228,usage_system=87.5182,usage_user=40.5551 9471000000000 +cpu,cpu=2 usage_idle=81.57,usage_system=37.1674,usage_user=27.5731 9472000000000 +cpu,cpu=3 usage_idle=97.1423,usage_system=40.1228,usage_user=90.2106 9473000000000 +cpu,cpu=4 usage_idle=34.5674,usage_system=17.2647,usage_user=21.9961 9474000000000 +cpu,cpu=0 usage_idle=53.3111,usage_system=59.7974,usage_user=88.749 9475000000000 +cpu,cpu=1 usage_idle=23.7675,usage_system=25.2126,usage_user=90.9847 9476000000000 +cpu,cpu=2 usage_idle=58.0623,usage_system=57.887,usage_user=15.8276 9477000000000 +cpu,cpu=3 usage_idle=77.3869,usage_system=87.8939,usage_user=94.8881 9478000000000 +cpu,cpu=4 usage_idle=75.7266,usage_system=52.1072,usage_user=73.6798 9479000000000 +cpu,cpu=0 usage_idle=65.952,usage_system=31.6292,usage_user=52.1949 9480000000000 +cpu,cpu=1 usage_idle=8.53262,usage_system=97.8572,usage_user=39.7131 9481000000000 +cpu,cpu=2 usage_idle=49.0877,usage_system=79.4272,usage_user=76.8805 9482000000000 +cpu,cpu=3 usage_idle=76.6608,usage_system=76.5695,usage_user=17.0033 9483000000000 +cpu,cpu=4 usage_idle=66.8714,usage_system=11.1369,usage_user=34.268 9484000000000 +cpu,cpu=0 usage_idle=88.8675,usage_system=64.448,usage_user=94.0655 9485000000000 +cpu,cpu=1 usage_idle=77.6166,usage_system=88.2156,usage_user=19.278 9486000000000 +cpu,cpu=2 usage_idle=68.6013,usage_system=46.2779,usage_user=77.1651 9487000000000 +cpu,cpu=3 usage_idle=84.4289,usage_system=23.6648,usage_user=65.059 9488000000000 +cpu,cpu=4 usage_idle=79.3169,usage_system=99.3914,usage_user=17.1662 9489000000000 +cpu,cpu=0 usage_idle=52.9967,usage_system=65.3434,usage_user=48.7954 9490000000000 +cpu,cpu=1 usage_idle=5.19159,usage_system=73.876,usage_user=46.6526 9491000000000 +cpu,cpu=2 usage_idle=44.9047,usage_system=22.9637,usage_user=26.0798 9492000000000 +cpu,cpu=3 usage_idle=21.7852,usage_system=99.6245,usage_user=2.64936 9493000000000 +cpu,cpu=4 usage_idle=38.7885,usage_system=66.4959,usage_user=13.7863 9494000000000 +cpu,cpu=0 usage_idle=73.0566,usage_system=55.3634,usage_user=78.2343 9495000000000 +cpu,cpu=1 usage_idle=67.122,usage_system=32.98,usage_user=66.4499 9496000000000 +cpu,cpu=2 usage_idle=86.4,usage_system=1.58127,usage_user=12.7278 9497000000000 +cpu,cpu=3 usage_idle=63.5651,usage_system=86.0102,usage_user=36.3926 9498000000000 +cpu,cpu=4 usage_idle=28.6241,usage_system=65.3271,usage_user=35.784 9499000000000 +cpu,cpu=0 usage_idle=45.7903,usage_system=18.3238,usage_user=1.12733 9500000000000 +cpu,cpu=1 usage_idle=94.5857,usage_system=23.5154,usage_user=75.0033 9501000000000 +cpu,cpu=2 usage_idle=41.2383,usage_system=68.4201,usage_user=97.967 9502000000000 +cpu,cpu=3 usage_idle=67.3181,usage_system=90.2053,usage_user=97.5915 9503000000000 +cpu,cpu=4 usage_idle=69.9675,usage_system=28.9938,usage_user=64.0874 9504000000000 +cpu,cpu=0 usage_idle=83.7538,usage_system=2.05037,usage_user=19.4508 9505000000000 +cpu,cpu=1 usage_idle=61.9881,usage_system=69.1724,usage_user=52.4308 9506000000000 +cpu,cpu=2 usage_idle=28.438,usage_system=55.5724,usage_user=54.0121 9507000000000 +cpu,cpu=3 usage_idle=41.1658,usage_system=19.1375,usage_user=40.0223 9508000000000 +cpu,cpu=4 usage_idle=77.5584,usage_system=47.7616,usage_user=5.34937 9509000000000 +cpu,cpu=0 usage_idle=13.3424,usage_system=93.5519,usage_user=23.6732 9510000000000 +cpu,cpu=1 usage_idle=14.4697,usage_system=88.1375,usage_user=47.1886 9511000000000 +cpu,cpu=2 usage_idle=89.473,usage_system=29.3759,usage_user=15.6087 9512000000000 +cpu,cpu=3 usage_idle=87.44,usage_system=96.694,usage_user=5.81395 9513000000000 +cpu,cpu=4 usage_idle=85.0315,usage_system=66.6615,usage_user=34.8078 9514000000000 +cpu,cpu=0 usage_idle=49.1189,usage_system=50.4153,usage_user=36.8581 9515000000000 +cpu,cpu=1 usage_idle=68.5698,usage_system=12.4035,usage_user=6.03053 9516000000000 +cpu,cpu=2 usage_idle=21.0006,usage_system=40.8415,usage_user=61.603 9517000000000 +cpu,cpu=3 usage_idle=75.0127,usage_system=82.0073,usage_user=80.7405 9518000000000 +cpu,cpu=4 usage_idle=15.035,usage_system=59.5658,usage_user=28.5021 9519000000000 +cpu,cpu=0 usage_idle=20.3844,usage_system=72.9081,usage_user=22.054 9520000000000 +cpu,cpu=1 usage_idle=44.0576,usage_system=87.3779,usage_user=10.1915 9521000000000 +cpu,cpu=2 usage_idle=91.2461,usage_system=76.8509,usage_user=39.5674 9522000000000 +cpu,cpu=3 usage_idle=6.85479,usage_system=64.2909,usage_user=36.2614 9523000000000 +cpu,cpu=4 usage_idle=12.6687,usage_system=49.3225,usage_user=2.92294 9524000000000 +cpu,cpu=0 usage_idle=47.4765,usage_system=98.4414,usage_user=53.3383 9525000000000 +cpu,cpu=1 usage_idle=84.3346,usage_system=67.0112,usage_user=65.7417 9526000000000 +cpu,cpu=2 usage_idle=90.3652,usage_system=88.0118,usage_user=6.58326 9527000000000 +cpu,cpu=3 usage_idle=51.9681,usage_system=63.0246,usage_user=88.5906 9528000000000 +cpu,cpu=4 usage_idle=32.7086,usage_system=78.0596,usage_user=48.1564 9529000000000 +cpu,cpu=0 usage_idle=61.2107,usage_system=98.444,usage_user=21.0645 9530000000000 +cpu,cpu=1 usage_idle=83.2647,usage_system=42.5015,usage_user=8.44236 9531000000000 +cpu,cpu=2 usage_idle=93.4562,usage_system=33.7476,usage_user=85.2933 9532000000000 +cpu,cpu=3 usage_idle=33.0236,usage_system=40.6024,usage_user=49.5842 9533000000000 +cpu,cpu=4 usage_idle=69.285,usage_system=53.2712,usage_user=98.9066 9534000000000 +cpu,cpu=0 usage_idle=72.208,usage_system=0.747672,usage_user=97.3481 9535000000000 +cpu,cpu=1 usage_idle=25.5463,usage_system=85.0823,usage_user=64.3592 9536000000000 +cpu,cpu=2 usage_idle=91.288,usage_system=75.4475,usage_user=52.3711 9537000000000 +cpu,cpu=3 usage_idle=97.8713,usage_system=27.4156,usage_user=15.3956 9538000000000 +cpu,cpu=4 usage_idle=86.4619,usage_system=60.1242,usage_user=93.4552 9539000000000 +cpu,cpu=0 usage_idle=34.6182,usage_system=21.335,usage_user=91.8992 9540000000000 +cpu,cpu=1 usage_idle=55.6827,usage_system=4.59969,usage_user=34.4007 9541000000000 +cpu,cpu=2 usage_idle=64.1251,usage_system=98.0559,usage_user=68.1483 9542000000000 +cpu,cpu=3 usage_idle=49.4183,usage_system=31.0796,usage_user=8.75075 9543000000000 +cpu,cpu=4 usage_idle=99.0025,usage_system=0.364598,usage_user=62.0219 9544000000000 +cpu,cpu=0 usage_idle=97.9092,usage_system=72.5726,usage_user=62.7696 9545000000000 +cpu,cpu=1 usage_idle=95.2572,usage_system=98.1188,usage_user=47.8519 9546000000000 +cpu,cpu=2 usage_idle=59.6165,usage_system=89.4068,usage_user=23.2994 9547000000000 +cpu,cpu=3 usage_idle=11.9875,usage_system=87.2781,usage_user=50.715 9548000000000 +cpu,cpu=4 usage_idle=27.3831,usage_system=73.74,usage_user=10.8392 9549000000000 +cpu,cpu=0 usage_idle=20.8383,usage_system=8.35817,usage_user=32.1742 9550000000000 +cpu,cpu=1 usage_idle=12.7375,usage_system=64.0409,usage_user=36.7739 9551000000000 +cpu,cpu=2 usage_idle=47.1381,usage_system=28.166,usage_user=34.8298 9552000000000 +cpu,cpu=3 usage_idle=15.2865,usage_system=77.5843,usage_user=65.9094 9553000000000 +cpu,cpu=4 usage_idle=24.0372,usage_system=76.5869,usage_user=66.274 9554000000000 +cpu,cpu=0 usage_idle=86.0591,usage_system=74.496,usage_user=38.8465 9555000000000 +cpu,cpu=1 usage_idle=48.8287,usage_system=69.7533,usage_user=36.9654 9556000000000 +cpu,cpu=2 usage_idle=96.6806,usage_system=29.3697,usage_user=26.3722 9557000000000 +cpu,cpu=3 usage_idle=19.98,usage_system=41.3573,usage_user=13.6503 9558000000000 +cpu,cpu=4 usage_idle=70.695,usage_system=68.7404,usage_user=87.3903 9559000000000 +cpu,cpu=0 usage_idle=81.5342,usage_system=89.5787,usage_user=95.7484 9560000000000 +cpu,cpu=1 usage_idle=13.7084,usage_system=2.31618,usage_user=59.7893 9561000000000 +cpu,cpu=2 usage_idle=50.4823,usage_system=49.4543,usage_user=87.9553 9562000000000 +cpu,cpu=3 usage_idle=85.3121,usage_system=64.7408,usage_user=65.5396 9563000000000 +cpu,cpu=4 usage_idle=51.2215,usage_system=88.778,usage_user=42.1265 9564000000000 +cpu,cpu=0 usage_idle=17.4955,usage_system=74.8371,usage_user=16.6225 9565000000000 +cpu,cpu=1 usage_idle=56.342,usage_system=23.6659,usage_user=86.3758 9566000000000 +cpu,cpu=2 usage_idle=93.3074,usage_system=20.3465,usage_user=15.7455 9567000000000 +cpu,cpu=3 usage_idle=19.6796,usage_system=40.3265,usage_user=57.1028 9568000000000 +cpu,cpu=4 usage_idle=33.3299,usage_system=11.0216,usage_user=25.8432 9569000000000 +cpu,cpu=0 usage_idle=20.7202,usage_system=92.5558,usage_user=15.4219 9570000000000 +cpu,cpu=1 usage_idle=16.4686,usage_system=6.26425,usage_user=17.738 9571000000000 +cpu,cpu=2 usage_idle=76.2579,usage_system=56.7466,usage_user=67.1924 9572000000000 +cpu,cpu=3 usage_idle=64.2132,usage_system=42.0587,usage_user=31.9331 9573000000000 +cpu,cpu=4 usage_idle=29.7529,usage_system=93.2802,usage_user=20.7111 9574000000000 +cpu,cpu=0 usage_idle=71.8794,usage_system=10.7757,usage_user=95.5483 9575000000000 +cpu,cpu=1 usage_idle=88.5019,usage_system=67.1177,usage_user=19.2141 9576000000000 +cpu,cpu=2 usage_idle=74.8777,usage_system=60.4251,usage_user=39.5607 9577000000000 +cpu,cpu=3 usage_idle=90.6232,usage_system=80.1047,usage_user=79.8872 9578000000000 +cpu,cpu=4 usage_idle=47.726,usage_system=13.4346,usage_user=90.9087 9579000000000 +cpu,cpu=0 usage_idle=73.5691,usage_system=34.1548,usage_user=83.4645 9580000000000 +cpu,cpu=1 usage_idle=88.991,usage_system=50.6234,usage_user=89.7288 9581000000000 +cpu,cpu=2 usage_idle=6.72901,usage_system=26.8813,usage_user=46.4754 9582000000000 +cpu,cpu=3 usage_idle=73.9214,usage_system=91.0946,usage_user=88.5341 9583000000000 +cpu,cpu=4 usage_idle=5.85451,usage_system=20.8474,usage_user=81.8143 9584000000000 +cpu,cpu=0 usage_idle=26.5656,usage_system=92.7268,usage_user=92.59 9585000000000 +cpu,cpu=1 usage_idle=22.1139,usage_system=81.2286,usage_user=59.7077 9586000000000 +cpu,cpu=2 usage_idle=41.3281,usage_system=56.1063,usage_user=20.1328 9587000000000 +cpu,cpu=3 usage_idle=80.8887,usage_system=46.7295,usage_user=0.23752 9588000000000 +cpu,cpu=4 usage_idle=60.7759,usage_system=94.4555,usage_user=13.6721 9589000000000 +cpu,cpu=0 usage_idle=51.6846,usage_system=68.0246,usage_user=47.827 9590000000000 +cpu,cpu=1 usage_idle=35.1492,usage_system=57.0155,usage_user=98.4504 9591000000000 +cpu,cpu=2 usage_idle=24.878,usage_system=63.7446,usage_user=25.3317 9592000000000 +cpu,cpu=3 usage_idle=71.3533,usage_system=37.6659,usage_user=16.4262 9593000000000 +cpu,cpu=4 usage_idle=59.8874,usage_system=43.5204,usage_user=37.2737 9594000000000 +cpu,cpu=0 usage_idle=41.7017,usage_system=70.0861,usage_user=30.0004 9595000000000 +cpu,cpu=1 usage_idle=34.2917,usage_system=92.2,usage_user=11.2291 9596000000000 +cpu,cpu=2 usage_idle=93.9994,usage_system=33.5281,usage_user=67.3354 9597000000000 +cpu,cpu=3 usage_idle=14.1322,usage_system=14.4168,usage_user=14.0649 9598000000000 +cpu,cpu=4 usage_idle=14.3698,usage_system=75.1927,usage_user=8.52034 9599000000000 +cpu,cpu=0 usage_idle=28.0419,usage_system=26.8773,usage_user=76.5449 9600000000000 +cpu,cpu=1 usage_idle=75.8689,usage_system=62.0265,usage_user=33.5605 9601000000000 +cpu,cpu=2 usage_idle=74.3192,usage_system=86.9045,usage_user=97.305 9602000000000 +cpu,cpu=3 usage_idle=99.6509,usage_system=58.2579,usage_user=34.971 9603000000000 +cpu,cpu=4 usage_idle=16.0772,usage_system=18.1453,usage_user=78.4914 9604000000000 +cpu,cpu=0 usage_idle=53.3508,usage_system=59.847,usage_user=48.5775 9605000000000 +cpu,cpu=1 usage_idle=83.3512,usage_system=94.1387,usage_user=40.7775 9606000000000 +cpu,cpu=2 usage_idle=94.5803,usage_system=88.1382,usage_user=74.3055 9607000000000 +cpu,cpu=3 usage_idle=61.9157,usage_system=2.27042,usage_user=88.7223 9608000000000 +cpu,cpu=4 usage_idle=75.9806,usage_system=16.6402,usage_user=63.915 9609000000000 +cpu,cpu=0 usage_idle=84.5009,usage_system=44.6821,usage_user=90.7923 9610000000000 +cpu,cpu=1 usage_idle=61.0458,usage_system=20.551,usage_user=52.8188 9611000000000 +cpu,cpu=2 usage_idle=94.6063,usage_system=94.8702,usage_user=39.7233 9612000000000 +cpu,cpu=3 usage_idle=91.9113,usage_system=94.5211,usage_user=97.9812 9613000000000 +cpu,cpu=4 usage_idle=26.8823,usage_system=10.5982,usage_user=16.1265 9614000000000 +cpu,cpu=0 usage_idle=5.37364,usage_system=63.9491,usage_user=75.9735 9615000000000 +cpu,cpu=1 usage_idle=53.9511,usage_system=47.3003,usage_user=70.1122 9616000000000 +cpu,cpu=2 usage_idle=94.7286,usage_system=41.8806,usage_user=58.2504 9617000000000 +cpu,cpu=3 usage_idle=69.0341,usage_system=3.79627,usage_user=60.5208 9618000000000 +cpu,cpu=4 usage_idle=57.7564,usage_system=79.7768,usage_user=77.161 9619000000000 +cpu,cpu=0 usage_idle=21.6714,usage_system=64.2777,usage_user=21.8431 9620000000000 +cpu,cpu=1 usage_idle=12.4637,usage_system=25.3236,usage_user=42.394 9621000000000 +cpu,cpu=2 usage_idle=65.2825,usage_system=19.9298,usage_user=37.2642 9622000000000 +cpu,cpu=3 usage_idle=5.00586,usage_system=11.8411,usage_user=31.7853 9623000000000 +cpu,cpu=4 usage_idle=2.98705,usage_system=38.7234,usage_user=42.3836 9624000000000 +cpu,cpu=0 usage_idle=19.1135,usage_system=44.097,usage_user=6.33261 9625000000000 +cpu,cpu=1 usage_idle=95.087,usage_system=98.0481,usage_user=53.6329 9626000000000 +cpu,cpu=2 usage_idle=65.1992,usage_system=92.7767,usage_user=95.5135 9627000000000 +cpu,cpu=3 usage_idle=23.4496,usage_system=61.8108,usage_user=99.3097 9628000000000 +cpu,cpu=4 usage_idle=83.9704,usage_system=19.5672,usage_user=79.0866 9629000000000 +cpu,cpu=0 usage_idle=61.1314,usage_system=41.2385,usage_user=43.3643 9630000000000 +cpu,cpu=1 usage_idle=82.9745,usage_system=53.7022,usage_user=68.6879 9631000000000 +cpu,cpu=2 usage_idle=25.3686,usage_system=18.9847,usage_user=88.6177 9632000000000 +cpu,cpu=3 usage_idle=62.6328,usage_system=23.9905,usage_user=0.458845 9633000000000 +cpu,cpu=4 usage_idle=94.4181,usage_system=26.9776,usage_user=39.1822 9634000000000 +cpu,cpu=0 usage_idle=36.8017,usage_system=46.0911,usage_user=83.2793 9635000000000 +cpu,cpu=1 usage_idle=43.1343,usage_system=41.1781,usage_user=81.3274 9636000000000 +cpu,cpu=2 usage_idle=96.7672,usage_system=6.37736,usage_user=74.1041 9637000000000 +cpu,cpu=3 usage_idle=92.2806,usage_system=29.827,usage_user=35.9149 9638000000000 +cpu,cpu=4 usage_idle=91.5904,usage_system=13.7974,usage_user=55.482 9639000000000 +cpu,cpu=0 usage_idle=70.677,usage_system=74.9288,usage_user=96.7206 9640000000000 +cpu,cpu=1 usage_idle=14.0413,usage_system=57.9034,usage_user=50.4227 9641000000000 +cpu,cpu=2 usage_idle=82.7291,usage_system=83.2719,usage_user=69.4074 9642000000000 +cpu,cpu=3 usage_idle=71.3468,usage_system=45.9047,usage_user=93.398 9643000000000 +cpu,cpu=4 usage_idle=71.8057,usage_system=40.3228,usage_user=20.3756 9644000000000 +cpu,cpu=0 usage_idle=10.9879,usage_system=77.1245,usage_user=66.4667 9645000000000 +cpu,cpu=1 usage_idle=94.2672,usage_system=20.2587,usage_user=7.64481 9646000000000 +cpu,cpu=2 usage_idle=75.5946,usage_system=17.0259,usage_user=14.0222 9647000000000 +cpu,cpu=3 usage_idle=49.6987,usage_system=9.30652,usage_user=43.8492 9648000000000 +cpu,cpu=4 usage_idle=85.6136,usage_system=0.896894,usage_user=57.6466 9649000000000 +cpu,cpu=0 usage_idle=41.0957,usage_system=71.5738,usage_user=32.5754 9650000000000 +cpu,cpu=1 usage_idle=37.8162,usage_system=85.6151,usage_user=90.4788 9651000000000 +cpu,cpu=2 usage_idle=88.239,usage_system=68.3443,usage_user=73.7507 9652000000000 +cpu,cpu=3 usage_idle=57.6464,usage_system=39.6911,usage_user=19.6554 9653000000000 +cpu,cpu=4 usage_idle=51.0444,usage_system=11.4968,usage_user=59.9782 9654000000000 +cpu,cpu=0 usage_idle=71.4199,usage_system=22.4847,usage_user=37.1027 9655000000000 +cpu,cpu=1 usage_idle=37.8866,usage_system=16.7519,usage_user=57.3614 9656000000000 +cpu,cpu=2 usage_idle=45.5314,usage_system=92.3465,usage_user=74.3873 9657000000000 +cpu,cpu=3 usage_idle=59.5536,usage_system=42.0453,usage_user=83.6938 9658000000000 +cpu,cpu=4 usage_idle=3.40277,usage_system=27.6589,usage_user=84.5907 9659000000000 +cpu,cpu=0 usage_idle=61.0493,usage_system=68.7546,usage_user=56.1646 9660000000000 +cpu,cpu=1 usage_idle=93.6248,usage_system=6.57086,usage_user=41.7797 9661000000000 +cpu,cpu=2 usage_idle=84.1035,usage_system=94.8098,usage_user=10.1239 9662000000000 +cpu,cpu=3 usage_idle=57.8543,usage_system=52.4563,usage_user=49.815 9663000000000 +cpu,cpu=4 usage_idle=77.5097,usage_system=3.50063,usage_user=61.3118 9664000000000 +cpu,cpu=0 usage_idle=37.4879,usage_system=74.9206,usage_user=83.7965 9665000000000 +cpu,cpu=1 usage_idle=74.5906,usage_system=12.8072,usage_user=0.548471 9666000000000 +cpu,cpu=2 usage_idle=31.952,usage_system=58.3386,usage_user=92.895 9667000000000 +cpu,cpu=3 usage_idle=6.33933,usage_system=17.8922,usage_user=34.9403 9668000000000 +cpu,cpu=4 usage_idle=90.0332,usage_system=21.295,usage_user=62.5992 9669000000000 +cpu,cpu=0 usage_idle=74.6239,usage_system=82.3444,usage_user=31.3538 9670000000000 +cpu,cpu=1 usage_idle=30.7884,usage_system=75.9691,usage_user=37.9247 9671000000000 +cpu,cpu=2 usage_idle=72.5681,usage_system=60.0727,usage_user=32.7346 9672000000000 +cpu,cpu=3 usage_idle=82.6921,usage_system=17.9269,usage_user=85.1908 9673000000000 +cpu,cpu=4 usage_idle=32.5071,usage_system=95.4366,usage_user=88.6914 9674000000000 +cpu,cpu=0 usage_idle=93.819,usage_system=32.9245,usage_user=63.612 9675000000000 +cpu,cpu=1 usage_idle=77.6155,usage_system=7.51508,usage_user=76.4192 9676000000000 +cpu,cpu=2 usage_idle=78.164,usage_system=39.4671,usage_user=34.7578 9677000000000 +cpu,cpu=3 usage_idle=71.059,usage_system=45.8064,usage_user=52.6501 9678000000000 +cpu,cpu=4 usage_idle=5.9993,usage_system=35.8396,usage_user=73.9451 9679000000000 +cpu,cpu=0 usage_idle=68.5985,usage_system=10.4635,usage_user=56.2894 9680000000000 +cpu,cpu=1 usage_idle=99.9524,usage_system=41.2519,usage_user=32.2586 9681000000000 +cpu,cpu=2 usage_idle=37.8771,usage_system=13.82,usage_user=92.3312 9682000000000 +cpu,cpu=3 usage_idle=70.6116,usage_system=96.5121,usage_user=10.2581 9683000000000 +cpu,cpu=4 usage_idle=55.8024,usage_system=29.0192,usage_user=5.69474 9684000000000 +cpu,cpu=0 usage_idle=44.4939,usage_system=22.8382,usage_user=38.6192 9685000000000 +cpu,cpu=1 usage_idle=8.10587,usage_system=0.453663,usage_user=46.1343 9686000000000 +cpu,cpu=2 usage_idle=84.5251,usage_system=78.6176,usage_user=85.6014 9687000000000 +cpu,cpu=3 usage_idle=19.2829,usage_system=49.6766,usage_user=31.4078 9688000000000 +cpu,cpu=4 usage_idle=71.933,usage_system=55.6759,usage_user=67.2474 9689000000000 +cpu,cpu=0 usage_idle=45.8781,usage_system=24.2744,usage_user=77.7109 9690000000000 +cpu,cpu=1 usage_idle=2.1675,usage_system=24.2268,usage_user=18.9628 9691000000000 +cpu,cpu=2 usage_idle=34.4261,usage_system=62.1039,usage_user=32.7828 9692000000000 +cpu,cpu=3 usage_idle=26.7573,usage_system=32.7156,usage_user=29.2949 9693000000000 +cpu,cpu=4 usage_idle=37.0154,usage_system=88.518,usage_user=58.3141 9694000000000 +cpu,cpu=0 usage_idle=42.7102,usage_system=33.0119,usage_user=81.1522 9695000000000 +cpu,cpu=1 usage_idle=81.3294,usage_system=41.1177,usage_user=81.6059 9696000000000 +cpu,cpu=2 usage_idle=27.4637,usage_system=25.6428,usage_user=60.2235 9697000000000 +cpu,cpu=3 usage_idle=13.0651,usage_system=44.9257,usage_user=9.90017 9698000000000 +cpu,cpu=4 usage_idle=44.473,usage_system=16.8587,usage_user=65.5761 9699000000000 +cpu,cpu=0 usage_idle=11.7204,usage_system=62.7367,usage_user=89.8505 9700000000000 +cpu,cpu=1 usage_idle=89.4312,usage_system=64.9042,usage_user=14.0774 9701000000000 +cpu,cpu=2 usage_idle=8.39401,usage_system=99.3303,usage_user=76.1813 9702000000000 +cpu,cpu=3 usage_idle=41.1768,usage_system=26.0876,usage_user=8.89684 9703000000000 +cpu,cpu=4 usage_idle=70.4717,usage_system=63.103,usage_user=97.4148 9704000000000 +cpu,cpu=0 usage_idle=28.7858,usage_system=5.81316,usage_user=30.4267 9705000000000 +cpu,cpu=1 usage_idle=9.938,usage_system=87.1426,usage_user=71.5445 9706000000000 +cpu,cpu=2 usage_idle=91.5439,usage_system=14.6063,usage_user=97.1873 9707000000000 +cpu,cpu=3 usage_idle=51.7675,usage_system=27.6714,usage_user=42.113 9708000000000 +cpu,cpu=4 usage_idle=61.6676,usage_system=72.1443,usage_user=58.9716 9709000000000 +cpu,cpu=0 usage_idle=27.2437,usage_system=83.8647,usage_user=21.7083 9710000000000 +cpu,cpu=1 usage_idle=17.0943,usage_system=73.2959,usage_user=86.6126 9711000000000 +cpu,cpu=2 usage_idle=31.1716,usage_system=81.6899,usage_user=85.9428 9712000000000 +cpu,cpu=3 usage_idle=7.35291,usage_system=22.8667,usage_user=12.0304 9713000000000 +cpu,cpu=4 usage_idle=16.2497,usage_system=93.3384,usage_user=75.1334 9714000000000 +cpu,cpu=0 usage_idle=13.6646,usage_system=22.1241,usage_user=80.9466 9715000000000 +cpu,cpu=1 usage_idle=44.0913,usage_system=32.0621,usage_user=68.0891 9716000000000 +cpu,cpu=2 usage_idle=15.6357,usage_system=23.6061,usage_user=82.6954 9717000000000 +cpu,cpu=3 usage_idle=12.823,usage_system=75.3735,usage_user=10.3667 9718000000000 +cpu,cpu=4 usage_idle=54.936,usage_system=37.0412,usage_user=82.5111 9719000000000 +cpu,cpu=0 usage_idle=13.9076,usage_system=64.2849,usage_user=66.3758 9720000000000 +cpu,cpu=1 usage_idle=35.6159,usage_system=81.3791,usage_user=39.6717 9721000000000 +cpu,cpu=2 usage_idle=22.2285,usage_system=12.5508,usage_user=21.3616 9722000000000 +cpu,cpu=3 usage_idle=8.17134,usage_system=19.9037,usage_user=44.2284 9723000000000 +cpu,cpu=4 usage_idle=20.2017,usage_system=36.1534,usage_user=37.5668 9724000000000 +cpu,cpu=0 usage_idle=95.3352,usage_system=49.818,usage_user=59.6909 9725000000000 +cpu,cpu=1 usage_idle=76.2817,usage_system=93.9093,usage_user=91.7531 9726000000000 +cpu,cpu=2 usage_idle=44.3708,usage_system=9.54504,usage_user=15.3591 9727000000000 +cpu,cpu=3 usage_idle=27.0662,usage_system=22.368,usage_user=90.7326 9728000000000 +cpu,cpu=4 usage_idle=37.433,usage_system=77.304,usage_user=27.7738 9729000000000 +cpu,cpu=0 usage_idle=19.944,usage_system=91.2116,usage_user=92.0587 9730000000000 +cpu,cpu=1 usage_idle=86.3198,usage_system=26.8275,usage_user=73.4378 9731000000000 +cpu,cpu=2 usage_idle=25.9915,usage_system=49.056,usage_user=85.9886 9732000000000 +cpu,cpu=3 usage_idle=47.3531,usage_system=57.2274,usage_user=5.89225 9733000000000 +cpu,cpu=4 usage_idle=91.5815,usage_system=77.4291,usage_user=42.0457 9734000000000 +cpu,cpu=0 usage_idle=29.1483,usage_system=72.7643,usage_user=91.8637 9735000000000 +cpu,cpu=1 usage_idle=88.8392,usage_system=49.046,usage_user=85.773 9736000000000 +cpu,cpu=2 usage_idle=80.5923,usage_system=93.4168,usage_user=95.318 9737000000000 +cpu,cpu=3 usage_idle=95.9514,usage_system=20.4831,usage_user=17.6861 9738000000000 +cpu,cpu=4 usage_idle=86.684,usage_system=57.916,usage_user=94.9901 9739000000000 +cpu,cpu=0 usage_idle=14.4578,usage_system=77.8601,usage_user=86.2017 9740000000000 +cpu,cpu=1 usage_idle=6.51648,usage_system=64.1799,usage_user=13.0292 9741000000000 +cpu,cpu=2 usage_idle=79.9543,usage_system=90.1714,usage_user=62.0852 9742000000000 +cpu,cpu=3 usage_idle=65.9429,usage_system=37.5245,usage_user=19.3126 9743000000000 +cpu,cpu=4 usage_idle=71.8351,usage_system=29.106,usage_user=96.7417 9744000000000 +cpu,cpu=0 usage_idle=13.8808,usage_system=58.2543,usage_user=69.506 9745000000000 +cpu,cpu=1 usage_idle=5.74445,usage_system=47.0935,usage_user=18.552 9746000000000 +cpu,cpu=2 usage_idle=91.5174,usage_system=27.6858,usage_user=11.9688 9747000000000 +cpu,cpu=3 usage_idle=86.8354,usage_system=23.6372,usage_user=32.4519 9748000000000 +cpu,cpu=4 usage_idle=4.52147,usage_system=10.3212,usage_user=90.3679 9749000000000 +cpu,cpu=0 usage_idle=99.5115,usage_system=24.779,usage_user=68.228 9750000000000 +cpu,cpu=1 usage_idle=85.7132,usage_system=31.2955,usage_user=32.4079 9751000000000 +cpu,cpu=2 usage_idle=98.7424,usage_system=11.2498,usage_user=22.5792 9752000000000 +cpu,cpu=3 usage_idle=60.8276,usage_system=77.1926,usage_user=60.1038 9753000000000 +cpu,cpu=4 usage_idle=80.1402,usage_system=49.0277,usage_user=89.2098 9754000000000 +cpu,cpu=0 usage_idle=76.882,usage_system=62.9085,usage_user=47.4641 9755000000000 +cpu,cpu=1 usage_idle=46.388,usage_system=68.6529,usage_user=94.5577 9756000000000 +cpu,cpu=2 usage_idle=64.9399,usage_system=60.1704,usage_user=22.2435 9757000000000 +cpu,cpu=3 usage_idle=76.9087,usage_system=47.0058,usage_user=45.8806 9758000000000 +cpu,cpu=4 usage_idle=9.36061,usage_system=51.5273,usage_user=56.2018 9759000000000 +cpu,cpu=0 usage_idle=99.7285,usage_system=51.0388,usage_user=80.9808 9760000000000 +cpu,cpu=1 usage_idle=67.9565,usage_system=36.752,usage_user=12.2763 9761000000000 +cpu,cpu=2 usage_idle=0.364345,usage_system=35.4944,usage_user=23.526 9762000000000 +cpu,cpu=3 usage_idle=22.9436,usage_system=96.322,usage_user=0.71862 9763000000000 +cpu,cpu=4 usage_idle=83.0474,usage_system=76.4623,usage_user=49.7463 9764000000000 +cpu,cpu=0 usage_idle=72.2572,usage_system=53.3442,usage_user=12.6548 9765000000000 +cpu,cpu=1 usage_idle=19.7213,usage_system=99.7322,usage_user=81.3078 9766000000000 +cpu,cpu=2 usage_idle=14.279,usage_system=64.6721,usage_user=41.4781 9767000000000 +cpu,cpu=3 usage_idle=36.5225,usage_system=41.5809,usage_user=88.4839 9768000000000 +cpu,cpu=4 usage_idle=82.4031,usage_system=50.9415,usage_user=40.0112 9769000000000 +cpu,cpu=0 usage_idle=38.6049,usage_system=50.67,usage_user=91.0499 9770000000000 +cpu,cpu=1 usage_idle=19.5857,usage_system=18.6265,usage_user=27.8019 9771000000000 +cpu,cpu=2 usage_idle=31.8619,usage_system=18.9908,usage_user=63.2963 9772000000000 +cpu,cpu=3 usage_idle=55.3879,usage_system=41.9344,usage_user=59.6184 9773000000000 +cpu,cpu=4 usage_idle=56.1065,usage_system=24.9818,usage_user=36.0807 9774000000000 +cpu,cpu=0 usage_idle=5.85289,usage_system=97.2389,usage_user=89.4249 9775000000000 +cpu,cpu=1 usage_idle=18.5077,usage_system=16.9602,usage_user=89.1571 9776000000000 +cpu,cpu=2 usage_idle=99.8155,usage_system=31.2392,usage_user=53.8292 9777000000000 +cpu,cpu=3 usage_idle=41.2936,usage_system=67.7617,usage_user=95.4101 9778000000000 +cpu,cpu=4 usage_idle=29.7775,usage_system=50.1648,usage_user=46.3516 9779000000000 +cpu,cpu=0 usage_idle=69.7887,usage_system=88.7696,usage_user=97.0215 9780000000000 +cpu,cpu=1 usage_idle=60.8386,usage_system=8.35531,usage_user=15.648 9781000000000 +cpu,cpu=2 usage_idle=88.6406,usage_system=40.2172,usage_user=34.6388 9782000000000 +cpu,cpu=3 usage_idle=51.9369,usage_system=95.6052,usage_user=76.5732 9783000000000 +cpu,cpu=4 usage_idle=11.5553,usage_system=51.7117,usage_user=1.55501 9784000000000 +cpu,cpu=0 usage_idle=47.6359,usage_system=57.5646,usage_user=98.7939 9785000000000 +cpu,cpu=1 usage_idle=37.0608,usage_system=76.0723,usage_user=15.7542 9786000000000 +cpu,cpu=2 usage_idle=26.2179,usage_system=75.8878,usage_user=46.9934 9787000000000 +cpu,cpu=3 usage_idle=80.0472,usage_system=17.1814,usage_user=14.7551 9788000000000 +cpu,cpu=4 usage_idle=75.4572,usage_system=46.959,usage_user=64.9199 9789000000000 +cpu,cpu=0 usage_idle=21.8088,usage_system=16.7477,usage_user=53.6895 9790000000000 +cpu,cpu=1 usage_idle=18.8303,usage_system=77.5863,usage_user=62.0448 9791000000000 +cpu,cpu=2 usage_idle=34.4784,usage_system=66.2269,usage_user=2.26208 9792000000000 +cpu,cpu=3 usage_idle=69.1172,usage_system=18.1638,usage_user=97.8672 9793000000000 +cpu,cpu=4 usage_idle=45.6904,usage_system=29.7191,usage_user=49.579 9794000000000 +cpu,cpu=0 usage_idle=47.2454,usage_system=77.355,usage_user=7.14357 9795000000000 +cpu,cpu=1 usage_idle=46.0394,usage_system=14.4159,usage_user=83.2159 9796000000000 +cpu,cpu=2 usage_idle=61.7936,usage_system=40.6338,usage_user=59.1037 9797000000000 +cpu,cpu=3 usage_idle=8.78699,usage_system=20.6809,usage_user=76.2852 9798000000000 +cpu,cpu=4 usage_idle=23.5421,usage_system=96.1382,usage_user=23.2441 9799000000000 +cpu,cpu=0 usage_idle=88.462,usage_system=17.947,usage_user=39.9918 9800000000000 +cpu,cpu=1 usage_idle=42.1515,usage_system=36.7773,usage_user=17.5781 9801000000000 +cpu,cpu=2 usage_idle=4.19638,usage_system=71.2557,usage_user=83.805 9802000000000 +cpu,cpu=3 usage_idle=6.45846,usage_system=40.3729,usage_user=1.9688 9803000000000 +cpu,cpu=4 usage_idle=4.32571,usage_system=86.0633,usage_user=31.6879 9804000000000 +cpu,cpu=0 usage_idle=53.9047,usage_system=33.3088,usage_user=9.0429 9805000000000 +cpu,cpu=1 usage_idle=61.0482,usage_system=79.3481,usage_user=23.4588 9806000000000 +cpu,cpu=2 usage_idle=44.2641,usage_system=41.1417,usage_user=64.0925 9807000000000 +cpu,cpu=3 usage_idle=3.36784,usage_system=49.9287,usage_user=84.7735 9808000000000 +cpu,cpu=4 usage_idle=79.653,usage_system=73.4708,usage_user=80.9117 9809000000000 +cpu,cpu=0 usage_idle=2.89713,usage_system=61.9328,usage_user=98.8586 9810000000000 +cpu,cpu=1 usage_idle=42.8889,usage_system=4.08434,usage_user=35.6359 9811000000000 +cpu,cpu=2 usage_idle=60.467,usage_system=8.28072,usage_user=6.8916 9812000000000 +cpu,cpu=3 usage_idle=44.2721,usage_system=14.7392,usage_user=47.2645 9813000000000 +cpu,cpu=4 usage_idle=46.2409,usage_system=19.0649,usage_user=33.3278 9814000000000 +cpu,cpu=0 usage_idle=77.9287,usage_system=72.9696,usage_user=66.6365 9815000000000 +cpu,cpu=1 usage_idle=86.9716,usage_system=34.0178,usage_user=45.9847 9816000000000 +cpu,cpu=2 usage_idle=10.4304,usage_system=78.2819,usage_user=87.1264 9817000000000 +cpu,cpu=3 usage_idle=74.523,usage_system=81.6498,usage_user=37.0551 9818000000000 +cpu,cpu=4 usage_idle=59.2964,usage_system=61.3028,usage_user=10.5259 9819000000000 +cpu,cpu=0 usage_idle=40.2081,usage_system=64.1999,usage_user=72.4587 9820000000000 +cpu,cpu=1 usage_idle=39.0667,usage_system=7.08884,usage_user=76.543 9821000000000 +cpu,cpu=2 usage_idle=74.7027,usage_system=67.5559,usage_user=84.8237 9822000000000 +cpu,cpu=3 usage_idle=81.5943,usage_system=11.8279,usage_user=99.5629 9823000000000 +cpu,cpu=4 usage_idle=28.8587,usage_system=58.0688,usage_user=18.6278 9824000000000 +cpu,cpu=0 usage_idle=62.1865,usage_system=35.9975,usage_user=91.5974 9825000000000 +cpu,cpu=1 usage_idle=28.823,usage_system=22.9692,usage_user=25.6152 9826000000000 +cpu,cpu=2 usage_idle=74.8077,usage_system=33.3996,usage_user=3.89716 9827000000000 +cpu,cpu=3 usage_idle=61.9341,usage_system=7.92253,usage_user=85.5469 9828000000000 +cpu,cpu=4 usage_idle=98.9892,usage_system=67.219,usage_user=46.8497 9829000000000 +cpu,cpu=0 usage_idle=9.51504,usage_system=7.42707,usage_user=11.0496 9830000000000 +cpu,cpu=1 usage_idle=81.9737,usage_system=46.4938,usage_user=18.1385 9831000000000 +cpu,cpu=2 usage_idle=58.5167,usage_system=21.1965,usage_user=85.6944 9832000000000 +cpu,cpu=3 usage_idle=43.3405,usage_system=2.79075,usage_user=97.5223 9833000000000 +cpu,cpu=4 usage_idle=42.9034,usage_system=31.6495,usage_user=55.5911 9834000000000 +cpu,cpu=0 usage_idle=61.5312,usage_system=93.836,usage_user=91.5886 9835000000000 +cpu,cpu=1 usage_idle=53.1286,usage_system=22.6591,usage_user=14.5578 9836000000000 +cpu,cpu=2 usage_idle=78.7438,usage_system=97.4668,usage_user=47.9574 9837000000000 +cpu,cpu=3 usage_idle=82.641,usage_system=59.4009,usage_user=55.8799 9838000000000 +cpu,cpu=4 usage_idle=68.1879,usage_system=58.39,usage_user=23.0989 9839000000000 +cpu,cpu=0 usage_idle=15.0377,usage_system=67.9051,usage_user=30.5259 9840000000000 +cpu,cpu=1 usage_idle=26.0873,usage_system=49.8788,usage_user=77.0197 9841000000000 +cpu,cpu=2 usage_idle=44.2258,usage_system=8.39553,usage_user=98.2162 9842000000000 +cpu,cpu=3 usage_idle=29.9201,usage_system=51.736,usage_user=1.00696 9843000000000 +cpu,cpu=4 usage_idle=27.4424,usage_system=94.6394,usage_user=32.6565 9844000000000 +cpu,cpu=0 usage_idle=83.0335,usage_system=56.1707,usage_user=26.4925 9845000000000 +cpu,cpu=1 usage_idle=74.6221,usage_system=9.29928,usage_user=49.1515 9846000000000 +cpu,cpu=2 usage_idle=89.1799,usage_system=88.0431,usage_user=46.6183 9847000000000 +cpu,cpu=3 usage_idle=37.1372,usage_system=70.6841,usage_user=6.01917 9848000000000 +cpu,cpu=4 usage_idle=93.0171,usage_system=38.872,usage_user=64.4092 9849000000000 +cpu,cpu=0 usage_idle=16.116,usage_system=53.9097,usage_user=32.3143 9850000000000 +cpu,cpu=1 usage_idle=46.6419,usage_system=79.997,usage_user=82.193 9851000000000 +cpu,cpu=2 usage_idle=23.6616,usage_system=24.2227,usage_user=90.5886 9852000000000 +cpu,cpu=3 usage_idle=21.8778,usage_system=54.1429,usage_user=42.3246 9853000000000 +cpu,cpu=4 usage_idle=22.8848,usage_system=81.5852,usage_user=36.964 9854000000000 +cpu,cpu=0 usage_idle=55.5413,usage_system=64.6187,usage_user=93.1347 9855000000000 +cpu,cpu=1 usage_idle=82.0337,usage_system=39.2408,usage_user=2.43395 9856000000000 +cpu,cpu=2 usage_idle=31.1852,usage_system=28.4207,usage_user=90.4771 9857000000000 +cpu,cpu=3 usage_idle=77.8035,usage_system=65.5579,usage_user=61.1612 9858000000000 +cpu,cpu=4 usage_idle=83.8227,usage_system=58.575,usage_user=0.0332197 9859000000000 +cpu,cpu=0 usage_idle=48.2319,usage_system=74.691,usage_user=53.9429 9860000000000 +cpu,cpu=1 usage_idle=80.5462,usage_system=21.3329,usage_user=33.9399 9861000000000 +cpu,cpu=2 usage_idle=62.7392,usage_system=44.9945,usage_user=58.1627 9862000000000 +cpu,cpu=3 usage_idle=53.3278,usage_system=66.8724,usage_user=12.3055 9863000000000 +cpu,cpu=4 usage_idle=95.6524,usage_system=89.7572,usage_user=93.8908 9864000000000 +cpu,cpu=0 usage_idle=32.6164,usage_system=45.2984,usage_user=58.5095 9865000000000 +cpu,cpu=1 usage_idle=25.751,usage_system=27.3321,usage_user=97.7503 9866000000000 +cpu,cpu=2 usage_idle=28.185,usage_system=58.5174,usage_user=26.171 9867000000000 +cpu,cpu=3 usage_idle=18.662,usage_system=36.3209,usage_user=91.7288 9868000000000 +cpu,cpu=4 usage_idle=79.8232,usage_system=20.1437,usage_user=50.3039 9869000000000 +cpu,cpu=0 usage_idle=79.8564,usage_system=68.3756,usage_user=24.9948 9870000000000 +cpu,cpu=1 usage_idle=33.7994,usage_system=48.9217,usage_user=46.3277 9871000000000 +cpu,cpu=2 usage_idle=67.7393,usage_system=11.6609,usage_user=91.3222 9872000000000 +cpu,cpu=3 usage_idle=25.9019,usage_system=64.9887,usage_user=58.1946 9873000000000 +cpu,cpu=4 usage_idle=38.2075,usage_system=60.641,usage_user=47.9518 9874000000000 +cpu,cpu=0 usage_idle=32.0982,usage_system=93.2574,usage_user=93.2502 9875000000000 +cpu,cpu=1 usage_idle=90.6077,usage_system=19.0084,usage_user=20.5824 9876000000000 +cpu,cpu=2 usage_idle=88.358,usage_system=47.1934,usage_user=79.0998 9877000000000 +cpu,cpu=3 usage_idle=14.529,usage_system=65.8554,usage_user=15.4207 9878000000000 +cpu,cpu=4 usage_idle=6.25782,usage_system=45.6787,usage_user=35.5644 9879000000000 +cpu,cpu=0 usage_idle=56.5617,usage_system=25.5351,usage_user=3.93992 9880000000000 +cpu,cpu=1 usage_idle=81.5565,usage_system=59.3345,usage_user=52.8616 9881000000000 +cpu,cpu=2 usage_idle=27.8842,usage_system=27.0738,usage_user=64.5226 9882000000000 +cpu,cpu=3 usage_idle=19.2065,usage_system=52.9757,usage_user=29.5112 9883000000000 +cpu,cpu=4 usage_idle=77.4011,usage_system=91.1832,usage_user=90.1523 9884000000000 +cpu,cpu=0 usage_idle=25.3529,usage_system=23.2814,usage_user=83.4097 9885000000000 +cpu,cpu=1 usage_idle=18.6031,usage_system=13.8891,usage_user=2.41811 9886000000000 +cpu,cpu=2 usage_idle=39.1855,usage_system=2.24713,usage_user=49.6115 9887000000000 +cpu,cpu=3 usage_idle=18.2852,usage_system=16.7761,usage_user=15.467 9888000000000 +cpu,cpu=4 usage_idle=33.7059,usage_system=23.0339,usage_user=61.1456 9889000000000 +cpu,cpu=0 usage_idle=69.2703,usage_system=79.5956,usage_user=86.6807 9890000000000 +cpu,cpu=1 usage_idle=73.2102,usage_system=61.1521,usage_user=46.0152 9891000000000 +cpu,cpu=2 usage_idle=26.0719,usage_system=89.0363,usage_user=73.089 9892000000000 +cpu,cpu=3 usage_idle=90.5944,usage_system=8.24282,usage_user=26.0647 9893000000000 +cpu,cpu=4 usage_idle=20.1057,usage_system=85.6439,usage_user=17.2478 9894000000000 +cpu,cpu=0 usage_idle=10.258,usage_system=10.9968,usage_user=40.5292 9895000000000 +cpu,cpu=1 usage_idle=93.6676,usage_system=29.5999,usage_user=54.4183 9896000000000 +cpu,cpu=2 usage_idle=96.0857,usage_system=68.7854,usage_user=56.6654 9897000000000 +cpu,cpu=3 usage_idle=45.6973,usage_system=87.0706,usage_user=73.4415 9898000000000 +cpu,cpu=4 usage_idle=61.1642,usage_system=20.7766,usage_user=96.4755 9899000000000 +cpu,cpu=0 usage_idle=22.3098,usage_system=90.0469,usage_user=76.0711 9900000000000 +cpu,cpu=1 usage_idle=8.99058,usage_system=63.2571,usage_user=37.2232 9901000000000 +cpu,cpu=2 usage_idle=55.0058,usage_system=89.329,usage_user=26.2595 9902000000000 +cpu,cpu=3 usage_idle=28.0947,usage_system=79.9234,usage_user=34.5024 9903000000000 +cpu,cpu=4 usage_idle=54.1594,usage_system=0.0290834,usage_user=20.1463 9904000000000 +cpu,cpu=0 usage_idle=71.4072,usage_system=10.287,usage_user=31.1431 9905000000000 +cpu,cpu=1 usage_idle=11.9364,usage_system=3.95468,usage_user=60.743 9906000000000 +cpu,cpu=2 usage_idle=66.3547,usage_system=0.0404303,usage_user=29.5284 9907000000000 +cpu,cpu=3 usage_idle=23.0202,usage_system=45.7377,usage_user=16.599 9908000000000 +cpu,cpu=4 usage_idle=96.4617,usage_system=6.90191,usage_user=37.3755 9909000000000 +cpu,cpu=0 usage_idle=92.9372,usage_system=29.2118,usage_user=27.4224 9910000000000 +cpu,cpu=1 usage_idle=69.0083,usage_system=38.2023,usage_user=90.6795 9911000000000 +cpu,cpu=2 usage_idle=6.23146,usage_system=93.2081,usage_user=80.0085 9912000000000 +cpu,cpu=3 usage_idle=32.491,usage_system=21.3029,usage_user=59.9319 9913000000000 +cpu,cpu=4 usage_idle=66.9934,usage_system=75.4623,usage_user=59.961 9914000000000 +cpu,cpu=0 usage_idle=87.1396,usage_system=46.8695,usage_user=70.248 9915000000000 +cpu,cpu=1 usage_idle=18.2827,usage_system=58.8059,usage_user=74.2027 9916000000000 +cpu,cpu=2 usage_idle=79.0257,usage_system=25.1606,usage_user=74.2431 9917000000000 +cpu,cpu=3 usage_idle=8.55404,usage_system=48.1807,usage_user=19.9808 9918000000000 +cpu,cpu=4 usage_idle=25.153,usage_system=44.6425,usage_user=26.8827 9919000000000 +cpu,cpu=0 usage_idle=62.5285,usage_system=37.5796,usage_user=56.0945 9920000000000 +cpu,cpu=1 usage_idle=89.9509,usage_system=6.58792,usage_user=94.2968 9921000000000 +cpu,cpu=2 usage_idle=80.6305,usage_system=12.8194,usage_user=87.5049 9922000000000 +cpu,cpu=3 usage_idle=60.6389,usage_system=45.3104,usage_user=8.80779 9923000000000 +cpu,cpu=4 usage_idle=20.5708,usage_system=12.3037,usage_user=84.27 9924000000000 +cpu,cpu=0 usage_idle=80.5318,usage_system=99.4434,usage_user=31.1395 9925000000000 +cpu,cpu=1 usage_idle=50.7798,usage_system=17.7261,usage_user=89.9454 9926000000000 +cpu,cpu=2 usage_idle=24.9825,usage_system=96.7517,usage_user=15.1059 9927000000000 +cpu,cpu=3 usage_idle=99.2256,usage_system=5.30578,usage_user=63.2867 9928000000000 +cpu,cpu=4 usage_idle=19.2065,usage_system=30.4588,usage_user=7.92914 9929000000000 +cpu,cpu=0 usage_idle=46.0892,usage_system=92.9873,usage_user=45.5088 9930000000000 +cpu,cpu=1 usage_idle=2.18366,usage_system=82.9383,usage_user=52.0967 9931000000000 +cpu,cpu=2 usage_idle=96.4805,usage_system=63.5687,usage_user=64.9161 9932000000000 +cpu,cpu=3 usage_idle=83.9854,usage_system=24.2077,usage_user=10.2265 9933000000000 +cpu,cpu=4 usage_idle=92.7932,usage_system=44.7785,usage_user=22.5302 9934000000000 +cpu,cpu=0 usage_idle=77.0632,usage_system=25.3103,usage_user=21.9735 9935000000000 +cpu,cpu=1 usage_idle=8.20273,usage_system=76.0901,usage_user=39.6996 9936000000000 +cpu,cpu=2 usage_idle=98.1481,usage_system=1.07261,usage_user=36.4513 9937000000000 +cpu,cpu=3 usage_idle=13.254,usage_system=0.298247,usage_user=41.7571 9938000000000 +cpu,cpu=4 usage_idle=76.5407,usage_system=19.5047,usage_user=72.2159 9939000000000 +cpu,cpu=0 usage_idle=84.4699,usage_system=65.5939,usage_user=65.2032 9940000000000 +cpu,cpu=1 usage_idle=29.9786,usage_system=67.7776,usage_user=48.1415 9941000000000 +cpu,cpu=2 usage_idle=82.0754,usage_system=64.258,usage_user=11.7102 9942000000000 +cpu,cpu=3 usage_idle=46.9914,usage_system=48.2434,usage_user=35.9179 9943000000000 +cpu,cpu=4 usage_idle=57.2179,usage_system=41.0366,usage_user=80.6964 9944000000000 +cpu,cpu=0 usage_idle=79.7481,usage_system=18.0998,usage_user=6.00664 9945000000000 +cpu,cpu=1 usage_idle=1.72161,usage_system=26.3026,usage_user=82.0967 9946000000000 +cpu,cpu=2 usage_idle=41.4212,usage_system=24.4507,usage_user=83.1693 9947000000000 +cpu,cpu=3 usage_idle=77.8726,usage_system=37.7047,usage_user=83.4676 9948000000000 +cpu,cpu=4 usage_idle=19.6297,usage_system=14.2454,usage_user=2.97229 9949000000000 +cpu,cpu=0 usage_idle=91.8456,usage_system=98.7153,usage_user=68.5662 9950000000000 +cpu,cpu=1 usage_idle=57.0488,usage_system=28.6939,usage_user=36.3437 9951000000000 +cpu,cpu=2 usage_idle=5.19033,usage_system=10.7693,usage_user=0.601756 9952000000000 +cpu,cpu=3 usage_idle=16.9006,usage_system=57.7607,usage_user=48.8452 9953000000000 +cpu,cpu=4 usage_idle=52.8184,usage_system=14.9786,usage_user=89.8818 9954000000000 +cpu,cpu=0 usage_idle=33.5148,usage_system=94.7267,usage_user=7.98163 9955000000000 +cpu,cpu=1 usage_idle=39.5214,usage_system=96.4483,usage_user=34.2842 9956000000000 +cpu,cpu=2 usage_idle=21.6182,usage_system=37.8695,usage_user=58.7349 9957000000000 +cpu,cpu=3 usage_idle=4.7875,usage_system=15.7421,usage_user=96.4396 9958000000000 +cpu,cpu=4 usage_idle=88.2551,usage_system=35.3717,usage_user=10.685 9959000000000 +cpu,cpu=0 usage_idle=91.2274,usage_system=27.2173,usage_user=9.40028 9960000000000 +cpu,cpu=1 usage_idle=59.7936,usage_system=84.2662,usage_user=38.0942 9961000000000 +cpu,cpu=2 usage_idle=96.1373,usage_system=89.4565,usage_user=48.8635 9962000000000 +cpu,cpu=3 usage_idle=96.7391,usage_system=6.35705,usage_user=6.6242 9963000000000 +cpu,cpu=4 usage_idle=45.5842,usage_system=59.1755,usage_user=21.6028 9964000000000 +cpu,cpu=0 usage_idle=35.466,usage_system=92.6903,usage_user=16.3295 9965000000000 +cpu,cpu=1 usage_idle=43.4476,usage_system=32.2117,usage_user=12.7778 9966000000000 +cpu,cpu=2 usage_idle=77.7319,usage_system=53.8299,usage_user=50.6473 9967000000000 +cpu,cpu=3 usage_idle=36.4667,usage_system=58.6174,usage_user=66.3894 9968000000000 +cpu,cpu=4 usage_idle=32.9063,usage_system=46.8725,usage_user=1.76112 9969000000000 +cpu,cpu=0 usage_idle=43.5913,usage_system=38.0998,usage_user=28.9785 9970000000000 +cpu,cpu=1 usage_idle=52.9916,usage_system=97.8934,usage_user=13.2446 9971000000000 +cpu,cpu=2 usage_idle=91.0858,usage_system=94.0307,usage_user=2.70113 9972000000000 +cpu,cpu=3 usage_idle=39.9493,usage_system=90.7698,usage_user=9.05818 9973000000000 +cpu,cpu=4 usage_idle=46.5735,usage_system=36.354,usage_user=68.2337 9974000000000 +cpu,cpu=0 usage_idle=68.1763,usage_system=71.82,usage_user=60.9239 9975000000000 +cpu,cpu=1 usage_idle=84.5058,usage_system=15.2677,usage_user=93.1356 9976000000000 +cpu,cpu=2 usage_idle=97.2836,usage_system=92.9995,usage_user=46.9655 9977000000000 +cpu,cpu=3 usage_idle=47.931,usage_system=29.4663,usage_user=5.5829 9978000000000 +cpu,cpu=4 usage_idle=14.3203,usage_system=62.3726,usage_user=52.4554 9979000000000 +cpu,cpu=0 usage_idle=16.0814,usage_system=5.96395,usage_user=90.5552 9980000000000 +cpu,cpu=1 usage_idle=45.0599,usage_system=58.9556,usage_user=88.4486 9981000000000 +cpu,cpu=2 usage_idle=58.3045,usage_system=50.0414,usage_user=82.4793 9982000000000 +cpu,cpu=3 usage_idle=61.0057,usage_system=89.9907,usage_user=73.2491 9983000000000 +cpu,cpu=4 usage_idle=70.0638,usage_system=36.5643,usage_user=9.6031 9984000000000 +cpu,cpu=0 usage_idle=38.2975,usage_system=4.74059,usage_user=81.4231 9985000000000 +cpu,cpu=1 usage_idle=99.2214,usage_system=89.2464,usage_user=96.6908 9986000000000 +cpu,cpu=2 usage_idle=92.3571,usage_system=86.5301,usage_user=89.6903 9987000000000 +cpu,cpu=3 usage_idle=39.3226,usage_system=34.461,usage_user=19.1566 9988000000000 +cpu,cpu=4 usage_idle=44.9055,usage_system=48.7814,usage_user=81.5292 9989000000000 +cpu,cpu=0 usage_idle=97.3609,usage_system=64.8628,usage_user=87.4931 9990000000000 +cpu,cpu=1 usage_idle=87.9161,usage_system=9.92272,usage_user=46.4487 9991000000000 +cpu,cpu=2 usage_idle=76.3647,usage_system=68.2273,usage_user=96.4901 9992000000000 +cpu,cpu=3 usage_idle=58.8441,usage_system=29.2329,usage_user=86.4808 9993000000000 +cpu,cpu=4 usage_idle=32.0932,usage_system=99.2968,usage_user=23.0451 9994000000000 +cpu,cpu=0 usage_idle=41.6963,usage_system=37.5943,usage_user=27.7857 9995000000000 +cpu,cpu=1 usage_idle=23.1194,usage_system=36.8157,usage_user=17.0321 9996000000000 +cpu,cpu=2 usage_idle=19.8101,usage_system=29.1728,usage_user=3.56222 9997000000000 +cpu,cpu=3 usage_idle=9.50044,usage_system=68.4954,usage_user=38.0233 9998000000000 +cpu,cpu=4 usage_idle=28.657,usage_system=13.4009,usage_user=86.8046 9999000000000 diff --git a/influxdb_iox/tests/query_tests/setups.rs b/influxdb_iox/tests/query_tests/setups.rs index e9fdd79340..a80440929a 100644 --- a/influxdb_iox/tests/query_tests/setups.rs +++ b/influxdb_iox/tests/query_tests/setups.rs @@ -1392,6 +1392,20 @@ pub static SETUPS: Lazy> = Lazy::new(|| { }, ], ), + ( + // Used for percentile function tests for InfluxQL + "percentile", + vec![ + Step::RecordNumParquetFiles, + Step::WriteLineProtocol( + include_str!("data/percentile.lp").to_string() + ), + Step::Persist, + Step::WaitForPersisted { + expected_increase: 1, + }, + ], + ), ( "DuplicateDifferentDomains", (0..2) diff --git a/iox_query_influxql/src/aggregate.rs b/iox_query_influxql/src/aggregate.rs new file mode 100644 index 0000000000..badb2793b9 --- /dev/null +++ b/iox_query_influxql/src/aggregate.rs @@ -0,0 +1,24 @@ +//! User defined aggregate functions implementing influxQL features. + +use datafusion::logical_expr::{ + AccumulatorFactoryFunction, AggregateUDF, ReturnTypeFunction, StateTypeFunction, +}; +use once_cell::sync::Lazy; +use std::sync::Arc; + +mod percentile; + +/// Definition of the `PERCENTILE` user-defined aggregate function. +pub(crate) static PERCENTILE: Lazy> = Lazy::new(|| { + let return_type: ReturnTypeFunction = Arc::new(percentile::return_type); + let accumulator: AccumulatorFactoryFunction = Arc::new(percentile::accumulator); + let state_type: StateTypeFunction = Arc::new(percentile::state_type); + + Arc::new(AggregateUDF::new( + percentile::NAME, + &percentile::SIGNATURE, + &return_type, + &accumulator, + &state_type, + )) +}); diff --git a/iox_query_influxql/src/aggregate/percentile.rs b/iox_query_influxql/src/aggregate/percentile.rs new file mode 100644 index 0000000000..4e7f37b318 --- /dev/null +++ b/iox_query_influxql/src/aggregate/percentile.rs @@ -0,0 +1,156 @@ +use crate::error; +use arrow::array::{as_list_array, Array, ArrayRef, Float64Array, Int64Array}; +use arrow::datatypes::{DataType, Field}; +use datafusion::common::{downcast_value, DataFusionError, Result, ScalarValue}; +use datafusion::logical_expr::{Accumulator, Signature, TypeSignature, Volatility}; +use once_cell::sync::Lazy; +use std::sync::Arc; + +/// The name of the percentile aggregate function. +pub(super) const NAME: &str = "percentile"; + +/// Valid signatures for the percentile aggregate function. +pub(super) static SIGNATURE: Lazy = Lazy::new(|| { + Signature::one_of( + crate::NUMERICS + .iter() + .flat_map(|dt| { + [ + TypeSignature::Exact(vec![dt.clone(), DataType::Int64]), + TypeSignature::Exact(vec![dt.clone(), DataType::Float64]), + ] + }) + .collect(), + Volatility::Immutable, + ) +}); + +/// Calculate the return type given the function signature. Percentile +/// always returns the same type as the input column. +pub(super) fn return_type(signature: &[DataType]) -> Result> { + Ok(Arc::new(signature[0].clone())) +} + +/// Create a new accumulator for the data type. +pub(super) fn accumulator(dt: &DataType) -> Result> { + Ok(Box::new(PercentileAccumulator::new(dt.clone()))) +} + +/// Calculate the intermediate merge state for the aggregator. +pub(super) fn state_type(dt: &DataType) -> Result>> { + Ok(Arc::new(vec![ + DataType::List(Arc::new(Field::new("state", dt.clone(), false))), + DataType::Float64, + ])) +} + +#[derive(Debug)] +struct PercentileAccumulator { + data_type: DataType, + data: Vec, + percentile: Option, +} + +impl PercentileAccumulator { + fn new(data_type: DataType) -> Self { + Self { + data_type, + data: vec![], + percentile: None, + } + } + + fn update(&mut self, array: ArrayRef) -> Result<()> { + let array = Arc::clone(&array); + assert_eq!(array.data_type(), &self.data_type); + + let nulls = array.nulls(); + let null_len = nulls.map_or(0, |nb| nb.null_count()); + self.data.reserve(array.len() - null_len); + for idx in 0..array.len() { + if nulls.map_or(true, |nb| nb.is_valid(idx)) { + self.data.push(ScalarValue::try_from_array(&array, idx)?) + } + } + Ok(()) + } + + fn set_percentile(&mut self, array: ArrayRef) -> Result<()> { + if self.percentile.is_none() { + self.percentile = match array.data_type() { + DataType::Int64 => Some(downcast_value!(array, Int64Array).value(0) as f64), + DataType::Float64 => Some(downcast_value!(array, Float64Array).value(0)), + dt => { + return error::internal(format!( + "invalid data type ({dt}) for PERCENTILE n argument" + )) + } + }; + } + Ok(()) + } +} + +impl Accumulator for PercentileAccumulator { + fn update_batch(&mut self, values: &[ArrayRef]) -> Result<()> { + assert_eq!(values.len(), 2); + + self.set_percentile(Arc::clone(&values[1]))?; + self.update(Arc::clone(&values[0])) + } + + fn evaluate(&self) -> Result { + let idx = self + .percentile + .and_then(|n| percentile_idx(self.data.len(), n)); + if idx.is_none() { + return Ok(ScalarValue::Null); + } + + let array = ScalarValue::iter_to_array(self.data.clone())?; + let indices = arrow::compute::sort_to_indices(&array, None, None)?; + let array_idx = indices.value(idx.unwrap()); + ScalarValue::try_from_array(&array, array_idx as usize) + } + + fn size(&self) -> usize { + std::mem::size_of::>() + + std::mem::size_of::() + + ScalarValue::size_of_vec(&self.data) + } + + fn state(&self) -> Result> { + Ok(vec![ + ScalarValue::new_list(Some(self.data.clone()), self.data_type.clone()), + ScalarValue::Float64(self.percentile), + ]) + } + + fn merge_batch(&mut self, states: &[ArrayRef]) -> Result<()> { + assert_eq!(states.len(), 2); + + self.set_percentile(Arc::clone(&states[1]))?; + + let array = Arc::clone(&states[0]); + let list_array = as_list_array(&array); + for idx in 0..list_array.len() { + self.update(list_array.value(idx))?; + } + Ok(()) + } +} + +/// Calculate the location in an ordered list of len items where the +/// location of the item at the given percentile would be found. +/// +/// This uses the same algorithm as the original influxdb implementation +/// of percentile as can be found in +/// . +fn percentile_idx(len: usize, percentile: f64) -> Option { + match TryInto::::try_into( + (((len as f64) * percentile / 100.0 + 0.5).floor() as isize) - 1, + ) { + Ok(idx) if idx < len => Some(idx), + _ => None, + } +} diff --git a/iox_query_influxql/src/plan/error.rs b/iox_query_influxql/src/error.rs similarity index 97% rename from iox_query_influxql/src/plan/error.rs rename to iox_query_influxql/src/error.rs index c952521f9c..cc2dd6de9c 100644 --- a/iox_query_influxql/src/plan/error.rs +++ b/iox_query_influxql/src/error.rs @@ -58,7 +58,7 @@ pub(crate) mod map { #[cfg(test)] mod test { - use crate::plan::error::map::PlannerError; + use crate::error::map::PlannerError; #[test] fn test_planner_error_display() { diff --git a/iox_query_influxql/src/lib.rs b/iox_query_influxql/src/lib.rs index fd9b545106..e23695944f 100644 --- a/iox_query_influxql/src/lib.rs +++ b/iox_query_influxql/src/lib.rs @@ -12,8 +12,17 @@ unused_crate_dependencies )] +use arrow::datatypes::DataType; + // Workaround for "unused crate" lint false positives. use workspace_hack as _; +mod aggregate; +mod error; pub mod frontend; pub mod plan; +mod window; + +/// A list of the numeric types supported by InfluxQL that can be be used +/// as input to user-defined functions. +static NUMERICS: &[DataType] = &[DataType::Int64, DataType::UInt64, DataType::Float64]; diff --git a/iox_query_influxql/src/plan/expr_type_evaluator.rs b/iox_query_influxql/src/plan/expr_type_evaluator.rs index c9a08926f4..e10d2f8eb4 100644 --- a/iox_query_influxql/src/plan/expr_type_evaluator.rs +++ b/iox_query_influxql/src/plan/expr_type_evaluator.rs @@ -1,8 +1,9 @@ +use crate::error; use crate::plan::field::field_by_name; use crate::plan::field_mapper::map_type; use crate::plan::ir::DataSource; use crate::plan::var_ref::influx_type_to_var_ref_data_type; -use crate::plan::{error, SchemaProvider}; +use crate::plan::SchemaProvider; use datafusion::common::Result; use influxdb_influxql_parser::expression::{ Binary, BinaryOperator, Call, Expr, VarRef, VarRefDataType, diff --git a/iox_query_influxql/src/plan/ir.rs b/iox_query_influxql/src/plan/ir.rs index d5350b4ae9..ddc56c9516 100644 --- a/iox_query_influxql/src/plan/ir.rs +++ b/iox_query_influxql/src/plan/ir.rs @@ -1,6 +1,7 @@ //! Defines data structures which represent an InfluxQL //! statement after it has been processed +use crate::error; use crate::plan::rewriter::ProjectionType; use datafusion::common::Result; use influxdb_influxql_parser::common::{ @@ -17,7 +18,7 @@ use schema::{InfluxColumnType, Schema}; use std::collections::HashSet; use std::fmt::{Display, Formatter}; -use super::{error, SchemaProvider}; +use super::SchemaProvider; /// A set of tag keys. pub(super) type TagSet = HashSet; diff --git a/iox_query_influxql/src/plan/mod.rs b/iox_query_influxql/src/plan/mod.rs index 17bee0e7b5..15e6f5e957 100644 --- a/iox_query_influxql/src/plan/mod.rs +++ b/iox_query_influxql/src/plan/mod.rs @@ -1,4 +1,3 @@ -mod error; mod expr_type_evaluator; mod field; mod field_mapper; diff --git a/iox_query_influxql/src/plan/planner.rs b/iox_query_influxql/src/plan/planner.rs index ca67d73072..d7ed9e9920 100644 --- a/iox_query_influxql/src/plan/planner.rs +++ b/iox_query_influxql/src/plan/planner.rs @@ -1,8 +1,11 @@ mod select; +use crate::aggregate::PERCENTILE; +use crate::error; use crate::plan::ir::{DataSource, Field, Interval, Select, SelectQuery}; use crate::plan::planner::select::{ - fields_to_exprs_no_nulls, make_tag_key_column_meta, plan_with_sort, ProjectionInfo, + fields_to_exprs_no_nulls, make_tag_key_column_meta, plan_with_sort, ProjectionInfo, Selector, + SelectorWindowOrderBy, }; use crate::plan::planner_time_range_expression::time_range_to_df_expr; use crate::plan::rewriter::{find_table_names, rewrite_statement, ProjectionType}; @@ -16,7 +19,8 @@ use crate::plan::udf::{ }; use crate::plan::util::{binary_operator_to_df_operator, rebase_expr, Schemas}; use crate::plan::var_ref::var_ref_data_type_to_data_type; -use crate::plan::{error, planner_rewrite_expression, udf, util_copy}; +use crate::plan::{planner_rewrite_expression, udf, util_copy}; +use crate::window::PERCENT_ROW_NUMBER; use arrow::array::{StringBuilder, StringDictionaryBuilder}; use arrow::datatypes::{DataType, Field as ArrowField, Int32Type, Schema as ArrowSchema}; use arrow::record_batch::RecordBatch; @@ -47,6 +51,7 @@ use influxdb_influxql_parser::explain::{ExplainOption, ExplainStatement}; use influxdb_influxql_parser::expression::walk::{walk_expr, walk_expression, Expression}; use influxdb_influxql_parser::expression::{ Binary, Call, ConditionalBinary, ConditionalExpression, ConditionalOperator, VarRef, + VarRefDataType, }; use influxdb_influxql_parser::functions::{ is_aggregate_function, is_now_function, is_scalar_math_function, @@ -762,16 +767,19 @@ impl<'a> InfluxQLToLogicalPlan<'a> { group_by_tag_set: &[&str], ) -> Result { match ctx.projection_type { - ProjectionType::Raw => self.project_select_raw(input, fields), - ProjectionType::RawDistinct => self.project_select_raw_distinct(input, fields), - ProjectionType::Aggregate | ProjectionType::Selector{..} => self.project_select_aggregate(ctx, input, fields, group_by_tag_set), - ProjectionType::Window => self.project_select_window(ctx, input, fields, group_by_tag_set), - ProjectionType::WindowAggregate => self.project_select_window_aggregate(ctx, input, fields, group_by_tag_set), - ProjectionType::WindowAggregateMixed => error::not_implemented("mixed window-aggregate and aggregate columns, such as DIFFERENCE(MEAN(col)), MEAN(col)"), - ProjectionType::TopBottomSelector => self.project_select_top_bottom_selector(ctx, input, fields, group_by_tag_set), + ProjectionType::Raw => self.project_select_raw(input, fields), + ProjectionType::RawDistinct => self.project_select_raw_distinct(input, fields), + ProjectionType::Aggregate => self.project_select_aggregate(ctx, input, fields, group_by_tag_set), + ProjectionType::Window => self.project_select_window(ctx, input, fields, group_by_tag_set), + ProjectionType::WindowAggregate => self.project_select_window_aggregate(ctx, input, fields, group_by_tag_set), + ProjectionType::WindowAggregateMixed => error::not_implemented("mixed window-aggregate and aggregate columns, such as DIFFERENCE(MEAN(col)), MEAN(col)"), + ProjectionType::Selector{..} => self.project_select_selector(ctx, input, fields, group_by_tag_set), + ProjectionType::TopBottomSelector => self.project_select_top_bottom_selector(ctx, input, fields, group_by_tag_set), } } + /// Plan "Raw" SELECT queriers, These are queries that have no grouping + /// and call only scalar functions. fn project_select_raw(&self, input: LogicalPlan, fields: &[Field]) -> Result { let schemas = Schemas::new(input.schema())?; @@ -782,6 +790,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> { project(input, select_exprs) } + /// Plan "RawDistinct" SELECT queriers, These are queries that have no grouping + /// and call only scalar functions, but output only distinct rows. fn project_select_raw_distinct( &self, input: LogicalPlan, @@ -815,6 +825,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> { LogicalPlanBuilder::from(plan).distinct()?.build() } + /// Plan "Aggregate" SELECT queries. These are queries that use one or + /// more aggregate (but not window) functions. fn project_select_aggregate( &self, ctx: &Context<'_>, @@ -834,6 +846,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> { project(plan, select_exprs) } + /// Plan "Window" SELECT queries. These are queries that use one or + /// more window functions. fn project_select_window( &self, ctx: &Context<'_>, @@ -870,6 +884,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> { } } + /// Plan "WindowAggregate" SELECT queries. These are queries that use + /// a combination of window and nested aggregate functions. fn project_select_window_aggregate( &self, ctx: &Context<'_>, @@ -908,6 +924,102 @@ impl<'a> InfluxQLToLogicalPlan<'a> { } } + /// Plan the execution of SELECT queries that have the Selector projection + /// type. These a queries that include a single FIRST, LAST, MAX, MIN, + /// PERCENTILE, or SAMPLE function call, possibly requesting additional + /// tags or fields. + /// + /// N.B SAMPLE is not yet implemented. + fn project_select_selector( + &self, + ctx: &Context<'_>, + input: LogicalPlan, + fields: &[Field], + group_by_tag_set: &[&str], + ) -> Result { + let schemas = Schemas::new(input.schema())?; + + let (selector_index, field_key, plan) = match Selector::find_enumerated(fields)? { + (_, Selector::First { .. }) + | (_, Selector::Last { .. }) + | (_, Selector::Max { .. }) + | (_, Selector::Min { .. }) => { + // The FIRST, LAST, MAX & MIN selectors are implmented as specialised + // forms of the equivilent aggregate implementaiion. + return self.project_select_aggregate(ctx, input, fields, group_by_tag_set); + } + (idx, Selector::Percentile { field_key, n }) => { + let window_perc_row = Expr::WindowFunction(WindowFunction::new( + PERCENT_ROW_NUMBER.clone(), + vec![lit(n)], + window_partition_by(ctx, input.schema(), group_by_tag_set), + vec![field_key.as_expr().sort(true, false), ctx.time_sort_expr()], + WindowFrame { + units: WindowFrameUnits::Rows, + start_bound: WindowFrameBound::Preceding(ScalarValue::Null), + end_bound: WindowFrameBound::Following(ScalarValue::Null), + }, + )); + let perc_row_column_name = window_perc_row.display_name()?; + + let window_row = Expr::WindowFunction(WindowFunction::new( + window_function::WindowFunction::BuiltInWindowFunction( + window_function::BuiltInWindowFunction::RowNumber, + ), + vec![], + window_partition_by(ctx, input.schema(), group_by_tag_set), + vec![field_key.as_expr().sort(true, false), ctx.time_sort_expr()], + WindowFrame { + units: WindowFrameUnits::Rows, + start_bound: WindowFrameBound::Preceding(ScalarValue::Null), + end_bound: WindowFrameBound::Following(ScalarValue::Null), + }, + )); + let row_column_name = window_row.display_name()?; + + let filter_expr = binary_expr( + col(perc_row_column_name.clone()), + Operator::Eq, + col(row_column_name.clone()), + ); + let plan = LogicalPlanBuilder::from(input) + .filter(field_key.as_expr().is_not_null())? + .window(vec![ + window_perc_row.alias(perc_row_column_name), + window_row.alias(row_column_name), + ])? + .filter(filter_expr)? + .build()?; + + (idx, field_key, plan) + } + (_, Selector::Sample { field_key: _, n: _ }) => { + return error::not_implemented("sample selector function") + } + + (_, s) => { + return error::internal(format!( + "unsupported selector function for ProjectionSelector {s}" + )) + } + }; + + let mut fields_vec = fields.to_vec(); + fields_vec[selector_index].expr = IQLExpr::VarRef(VarRef { + name: field_key.clone(), + data_type: None, + }); + + // Transform InfluxQL AST field expressions to a list of DataFusion expressions. + let select_exprs = self.field_list_to_exprs(&plan, fields_vec.as_slice(), &schemas)?; + + // Wrap the plan in a `LogicalPlan::Projection` from the select expressions + project(plan, select_exprs) + } + + /// Plan the execution of "TopBottomSelector" SELECT queries. These are + /// queries that use the TOP or BOTTOM functions to select a number of + /// rows from the ends of a partition.. fn project_select_top_bottom_selector( &self, ctx: &Context<'_>, @@ -917,87 +1029,68 @@ impl<'a> InfluxQLToLogicalPlan<'a> { ) -> Result { let schemas = Schemas::new(input.schema())?; - let (selector_index, call) = fields - .iter() - .enumerate() - .find_map(|(idx, f)| match &f.expr { - IQLExpr::Call(c) if c.name == "top" || c.name == "bottom" => Some((idx, c.clone())), - _ => None, - }) - .ok_or(error::map::internal( - "ProjectionTopBottomSelector used without top or bottom field", - ))?; + let (selector_index, is_bottom, field_key, tag_keys, narg) = + match Selector::find_enumerated(fields)? { + ( + idx, + Selector::Bottom { + field_key, + tag_keys, + n, + }, + ) => (idx, true, field_key, tag_keys, n), + ( + idx, + Selector::Top { + field_key, + tag_keys, + n, + }, + ) => (idx, false, field_key, tag_keys, n), + (_, s) => { + return error::internal(format!( + "ProjectionTopBottomSelector used with unexpected selector function: {s}" + )) + } + }; - // Find the selector parameters. - let is_bottom = call.name == "bottom"; - let [field, tag_keys @ .., narg] = call.args.as_slice() else { - return error::internal(format!( - "invalid number of arguments for {}: expected 2 or more, got {}", - call.name, - call.args.len() - )); - }; - let field = if let IQLExpr::VarRef(v) = field { - Field { - expr: IQLExpr::VarRef(v.clone()), - name: v.name.clone().take(), - data_type: None, - } + let mut fields_vec = fields.to_vec(); + fields_vec[selector_index].expr = IQLExpr::VarRef(VarRef { + name: field_key.clone(), + data_type: None, + }); + let order_by = if is_bottom { + SelectorWindowOrderBy::FieldAsc(field_key) } else { - return error::internal(format!( - "invalid expression for {} field argument, {field}", - call.name, - )); - }; - let n = if let IQLExpr::Literal(Literal::Integer(v)) = narg { - *v - } else { - return error::internal(format!( - "invalid expression for {} n argument, {narg}", - call.name - )); + SelectorWindowOrderBy::FieldDesc(field_key) }; let mut internal_group_by = group_by_tag_set.to_vec(); - let mut fields_vec = fields.to_vec(); for (i, tag_key) in tag_keys.iter().enumerate() { - if let IQLExpr::VarRef(v) = &tag_key { - fields_vec.insert( - selector_index + i + 1, - Field { - expr: IQLExpr::VarRef(v.clone()), - name: v.name.clone().take(), - data_type: None, - }, - ); - internal_group_by.push(v.name.as_ref()); - } else { - return error::internal(format!( - "invalid expression for {} tag_keys argument, {}", - call.name, &tag_key - )); - } + fields_vec.insert( + selector_index + i + 1, + Field { + expr: IQLExpr::VarRef(VarRef { + name: (*tag_key).clone(), + data_type: Some(VarRefDataType::Tag), + }), + name: (*tag_key).clone().take(), + data_type: None, + }, + ); + internal_group_by.push(*tag_key); } // Transform InfluxQL AST field expressions to a list of DataFusion expressions. let select_exprs = self.field_list_to_exprs(&input, fields_vec.as_slice(), &schemas)?; let plan = if !tag_keys.is_empty() { - self.select_first( - ctx, - input, - &schemas, - &field, - is_bottom, - internal_group_by.as_slice(), - 1, - )? + self.select_first(ctx, input, order_by, internal_group_by.as_slice(), 1)? } else { input }; - let plan = - self.select_first(ctx, plan, &schemas, &field, is_bottom, group_by_tag_set, n)?; + let plan = self.select_first(ctx, plan, order_by, group_by_tag_set, narg)?; // Wrap the plan in a `LogicalPlan::Projection` from the select expressions project(plan, select_exprs) @@ -1281,42 +1374,32 @@ impl<'a> InfluxQLToLogicalPlan<'a> { Ok((plan, select_exprs)) } - /// Generate a plan to select the first n rows from each partition in the input data sorted by the requested field. - #[allow(clippy::too_many_arguments)] + /// Generate a plan to select the first n rows from each partition in + /// the input data, optionally sorted by the requested field. fn select_first( &self, ctx: &Context<'_>, input: LogicalPlan, - schemas: &Schemas, - field: &Field, - asc: bool, + order_by: SelectorWindowOrderBy<'_>, group_by_tags: &[&str], count: i64, ) -> Result { - let mut group_by = - fields_to_exprs_no_nulls(input.schema(), group_by_tags).collect::>(); - if let Some(i) = ctx.interval { - let stride = lit(ScalarValue::new_interval_mdn(0, 0, i.duration)); - let offset = i.offset.unwrap_or_default(); - - group_by.push(date_bin( - stride, - "time".as_expr(), - lit(ScalarValue::TimestampNanosecond(Some(offset), None)), - )); - } - - let field_sort_expr = self - .field_to_df_expr(field, &input, schemas)? - .sort(asc, false); + let order_by_exprs = match order_by { + SelectorWindowOrderBy::FieldAsc(id) => { + vec![id.as_expr().sort(true, false), ctx.time_sort_expr()] + } + SelectorWindowOrderBy::FieldDesc(id) => { + vec![id.as_expr().sort(false, false), ctx.time_sort_expr()] + } + }; let window_expr = Expr::WindowFunction(WindowFunction::new( window_function::WindowFunction::BuiltInWindowFunction( window_function::BuiltInWindowFunction::RowNumber, ), Vec::::new(), - group_by, - vec![field_sort_expr, ctx.time_sort_expr()], + window_partition_by(ctx, input.schema(), group_by_tags), + order_by_exprs, WindowFrame { units: WindowFrameUnits::Rows, start_bound: WindowFrameBound::Preceding(ScalarValue::Null), @@ -1855,6 +1938,21 @@ impl<'a> InfluxQLToLogicalPlan<'a> { None, ))) } + "percentile" => { + let expr = self.expr_to_df_expr(scope, &args[0], schemas)?; + if let Expr::Literal(ScalarValue::Null) = expr { + return Ok(expr); + } + + check_arg_count(name, args, 2)?; + let nexpr = self.expr_to_df_expr(scope, &args[1], schemas)?; + Ok(Expr::AggregateUDF(expr::AggregateUDF::new( + PERCENTILE.clone(), + vec![expr, nexpr], + None, + None, + ))) + } name @ ("first" | "last" | "min" | "max") => { let expr = self.expr_to_df_expr(scope, &args[0], schemas)?; if let Expr::Literal(ScalarValue::Null) = expr { @@ -3063,6 +3161,26 @@ fn find_var_refs(select: &Select) -> BTreeSet<&VarRef> { var_refs } +/// Calculate the partitioning for window functions. +fn window_partition_by( + ctx: &Context<'_>, + schema: &DFSchemaRef, + group_by_tags: &[&str], +) -> Vec { + let mut parition_by = fields_to_exprs_no_nulls(schema, group_by_tags).collect::>(); + if let Some(i) = ctx.interval { + let stride = lit(ScalarValue::new_interval_mdn(0, 0, i.duration)); + let offset = i.offset.unwrap_or_default(); + + parition_by.push(date_bin( + stride, + "time".as_expr(), + lit(ScalarValue::TimestampNanosecond(Some(offset), None)), + )); + } + parition_by +} + #[cfg(test)] mod test { use super::*; @@ -3689,10 +3807,10 @@ mod test { TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); - // aggregate with repeated table + // selector with repeated table // // ⚠️ Important - // The aggregate must be applied to the UNION of all instances of the cpu table + // The selector must be applied to the UNION of all instances of the cpu table assert_snapshot!(plan("SELECT last(usage_idle) FROM cpu, cpu"), @r###" Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, last:Float64;N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, (selector_last(usage_idle,time))[time] AS time, (selector_last(usage_idle,time))[value] AS last [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, last:Float64;N] @@ -3707,7 +3825,7 @@ mod test { // different tables for each subquery // // ⚠️ Important - // The aggregate must be applied independently for each unique table + // The selector must be applied independently for each unique table assert_snapshot!(plan("SELECT last(value) FROM (SELECT usage_idle AS value FROM cpu), (SELECT bytes_free AS value FROM disk)"), @r###" Sort: iox::measurement ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, last:Float64;N] Union [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, last:Float64;N] @@ -4062,39 +4180,91 @@ mod test { } } + #[test] + fn test_percentile() { + assert_snapshot!(plan("SELECT percentile(usage_idle,50),usage_system FROM cpu"), @r###" + Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), percentile:Float64;N, usage_system:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS percentile, cpu.usage_system AS usage_system [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), percentile:Float64;N, usage_system:Float64;N] + Filter: percent_row_number(Float64(50)) ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING = ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, percent_row_number(Float64(50)) ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N] + WindowAggr: windowExpr=[[percent_row_number(Float64(50)) ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING AS percent_row_number(Float64(50)) ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING, ROW_NUMBER() ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING AS ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, percent_row_number(Float64(50)) ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N] + Filter: cpu.usage_idle IS NOT NULL [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + + assert_snapshot!(plan("SELECT percentile(usage_idle,50),usage_system FROM cpu WHERE time >= 0 AND time < 60000000000 GROUP BY cpu"), @r###" + Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, usage_system:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.cpu AS cpu, cpu.usage_idle AS percentile, cpu.usage_system AS usage_system [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, usage_system:Float64;N] + Filter: percent_row_number(Float64(50)) PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING = ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, percent_row_number(Float64(50)) PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N] + WindowAggr: windowExpr=[[percent_row_number(Float64(50)) PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING AS percent_row_number(Float64(50)) PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING, ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, percent_row_number(Float64(50)) PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING:UInt64;N] + Filter: cpu.usage_idle IS NOT NULL [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + Filter: cpu.time >= TimestampNanosecond(0, None) AND cpu.time <= TimestampNanosecond(59999999999, None) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + + assert_snapshot!(plan("SELECT percentile(usage_idle,50), percentile(usage_idle,90) FROM cpu"), @r###" + Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), percentile:Float64;N, percentile_1:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, TimestampNanosecond(0, None) AS time, percentile(cpu.usage_idle,Int64(50)) AS percentile, percentile(cpu.usage_idle,Int64(90)) AS percentile_1 [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), percentile:Float64;N, percentile_1:Float64;N] + Aggregate: groupBy=[[]], aggr=[[percentile(cpu.usage_idle, Int64(50)), percentile(cpu.usage_idle, Int64(90))]] [percentile(cpu.usage_idle,Int64(50)):Float64;N, percentile(cpu.usage_idle,Int64(90)):Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + + assert_snapshot!(plan("SELECT percentile(usage_idle,50), percentile(usage_idle,90) FROM cpu GROUP BY cpu"), @r###" + Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, TimestampNanosecond(0, None) AS time, cpu.cpu AS cpu, percentile(cpu.usage_idle,Int64(50)) AS percentile, percentile(cpu.usage_idle,Int64(90)) AS percentile_1 [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + Aggregate: groupBy=[[cpu.cpu]], aggr=[[percentile(cpu.usage_idle, Int64(50)), percentile(cpu.usage_idle, Int64(90))]] [cpu:Dictionary(Int32, Utf8);N, percentile(cpu.usage_idle,Int64(50)):Float64;N, percentile(cpu.usage_idle,Int64(90)):Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + + assert_snapshot!(plan("SELECT percentile(usage_idle,50), percentile(usage_idle,90) FROM cpu GROUP BY cpu"), @r###" + Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, TimestampNanosecond(0, None) AS time, cpu.cpu AS cpu, percentile(cpu.usage_idle,Int64(50)) AS percentile, percentile(cpu.usage_idle,Int64(90)) AS percentile_1 [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + Aggregate: groupBy=[[cpu.cpu]], aggr=[[percentile(cpu.usage_idle, Int64(50)), percentile(cpu.usage_idle, Int64(90))]] [cpu:Dictionary(Int32, Utf8);N, percentile(cpu.usage_idle,Int64(50)):Float64;N, percentile(cpu.usage_idle,Int64(90)):Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + + assert_snapshot!(plan("SELECT percentile(usage_idle,50), percentile(usage_idle,90) FROM cpu WHERE time >= 0 AND time < 60000000000 GROUP BY time(10s), cpu"), @r###" + Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, time, cpu.cpu AS cpu, percentile(cpu.usage_idle,Int64(50)) AS percentile, percentile(cpu.usage_idle,Int64(90)) AS percentile_1 [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None);N, cpu:Dictionary(Int32, Utf8);N, percentile:Float64;N, percentile_1:Float64;N] + GapFill: groupBy=[time, cpu.cpu], aggr=[[percentile(cpu.usage_idle,Int64(50)), percentile(cpu.usage_idle,Int64(90))]], time_column=time, stride=IntervalMonthDayNano("10000000000"), range=Included(Literal(TimestampNanosecond(0, None)))..Included(Literal(TimestampNanosecond(59999999999, None))) [time:Timestamp(Nanosecond, None);N, cpu:Dictionary(Int32, Utf8);N, percentile(cpu.usage_idle,Int64(50)):Float64;N, percentile(cpu.usage_idle,Int64(90)):Float64;N] + Aggregate: groupBy=[[date_bin(IntervalMonthDayNano("10000000000"), cpu.time, TimestampNanosecond(0, None)) AS time, cpu.cpu]], aggr=[[percentile(cpu.usage_idle, Int64(50)), percentile(cpu.usage_idle, Int64(90))]] [time:Timestamp(Nanosecond, None);N, cpu:Dictionary(Int32, Utf8);N, percentile(cpu.usage_idle,Int64(50)):Float64;N, percentile(cpu.usage_idle,Int64(90)):Float64;N] + Filter: cpu.time >= TimestampNanosecond(0, None) AND cpu.time <= TimestampNanosecond(59999999999, None) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] + "###); + } + #[test] fn test_top() { assert_snapshot!(plan("SELECT top(usage_idle,10) FROM cpu"), @r###" Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS top [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT top(usage_idle,10),cpu FROM cpu"), @r###" Sort: time ASC NULLS LAST, cpu ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N, cpu:Dictionary(Int32, Utf8);N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS top, cpu.cpu AS cpu [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N, cpu:Dictionary(Int32, Utf8);N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT top(usage_idle,10) FROM cpu GROUP BY cpu"), @r###" Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, top:Float64;N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.cpu AS cpu, cpu.usage_idle AS top [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, top:Float64;N] - Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT top(usage_idle,cpu,10) FROM cpu"), @r###" Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N, cpu:Dictionary(Int32, Utf8);N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS top, cpu.cpu AS cpu [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), top:Float64;N, cpu:Dictionary(Int32, Utf8);N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(1) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(1) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle DESC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle DESC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); } @@ -4104,34 +4274,34 @@ mod test { assert_snapshot!(plan("SELECT bottom(usage_idle,10) FROM cpu"), @r###" Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS bottom [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT bottom(usage_idle,10),cpu FROM cpu"), @r###" Sort: time ASC NULLS LAST, cpu ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N, cpu:Dictionary(Int32, Utf8);N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS bottom, cpu.cpu AS cpu [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N, cpu:Dictionary(Int32, Utf8);N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT bottom(usage_idle,10) FROM cpu GROUP BY cpu"), @r###" Sort: cpu ASC NULLS LAST, time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, bottom:Float64;N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.cpu AS cpu, cpu.usage_idle AS bottom [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), cpu:Dictionary(Int32, Utf8);N, bottom:Float64;N] - Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); assert_snapshot!(plan("SELECT bottom(usage_idle,cpu,10) FROM cpu"), @r###" Sort: time ASC NULLS LAST [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N, cpu:Dictionary(Int32, Utf8);N] Projection: Dictionary(Int32, Utf8("cpu")) AS iox::measurement, cpu.time AS time, cpu.usage_idle AS bottom, cpu.cpu AS cpu [iox::measurement:Dictionary(Int32, Utf8), time:Timestamp(Nanosecond, None), bottom:Float64;N, cpu:Dictionary(Int32, Utf8);N] - Filter: ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(1) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] - WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [cpu.usage_idle AS usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(10) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N, ROW_NUMBER() ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + Filter: ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW <= Int64(1) [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] + WindowAggr: windowExpr=[[ROW_NUMBER() PARTITION BY [cpu.cpu] ORDER BY [cpu.usage_idle ASC NULLS LAST, cpu.time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW AS ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW]] [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N, ROW_NUMBER() PARTITION BY [cpu] ORDER BY [usage_idle ASC NULLS LAST, time ASC NULLS LAST] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW:UInt64;N] TableScan: cpu [cpu:Dictionary(Int32, Utf8);N, host:Dictionary(Int32, Utf8);N, region:Dictionary(Int32, Utf8);N, time:Timestamp(Nanosecond, None), usage_idle:Float64;N, usage_system:Float64;N, usage_user:Float64;N] "###); } diff --git a/iox_query_influxql/src/plan/planner/select.rs b/iox_query_influxql/src/plan/planner/select.rs index 5bc4d8314d..0db8df7c8c 100644 --- a/iox_query_influxql/src/plan/planner/select.rs +++ b/iox_query_influxql/src/plan/planner/select.rs @@ -1,13 +1,17 @@ +use crate::error; use crate::plan::ir::Field; use arrow::datatypes::DataType; use datafusion::common::{DFSchemaRef, Result}; use datafusion::logical_expr::{Expr, LogicalPlan, LogicalPlanBuilder}; use datafusion_util::AsExpr; use generated_types::influxdata::iox::querier::v1::influx_ql_metadata::TagKeyColumn; -use influxdb_influxql_parser::expression::{Expr as IQLExpr, VarRef, VarRefDataType}; +use influxdb_influxql_parser::expression::{Call, Expr as IQLExpr, VarRef, VarRefDataType}; +use influxdb_influxql_parser::identifier::Identifier; +use influxdb_influxql_parser::literal::Literal; use itertools::Itertools; use schema::{InfluxColumnType, INFLUXQL_MEASUREMENT_COLUMN_NAME}; use std::collections::{HashMap, HashSet}; +use std::fmt::{Display, Formatter}; pub(super) fn make_tag_key_column_meta( fields: &[Field], @@ -198,3 +202,236 @@ fn find_tag_and_unknown_columns(fields: &[Field]) -> impl Iterator _ => None, }) } + +/// The selector function that has been specified for use with a selector +/// projection type. +#[derive(Debug)] +pub(super) enum Selector<'a> { + Bottom { + field_key: &'a Identifier, + tag_keys: Vec<&'a Identifier>, + n: i64, + }, + First { + field_key: &'a Identifier, + }, + Last { + field_key: &'a Identifier, + }, + Max { + field_key: &'a Identifier, + }, + Min { + field_key: &'a Identifier, + }, + Percentile { + field_key: &'a Identifier, + n: f64, + }, + Sample { + field_key: &'a Identifier, + n: i64, + }, + Top { + field_key: &'a Identifier, + tag_keys: Vec<&'a Identifier>, + n: i64, + }, +} + +impl<'a> Selector<'a> { + /// Find the selector function, with its location, in the specified field list. + pub(super) fn find_enumerated(fields: &'a [Field]) -> Result<(usize, Self)> { + fields + .iter() + .enumerate() + .find_map(|(idx, f)| match &f.expr { + IQLExpr::Call(c) => Some((idx, c)), + _ => None, + }) + .map(|(idx, c)| { + Ok(( + idx, + match c.name.as_str() { + "bottom" => Self::bottom(c), + "first" => Self::first(c), + "last" => Self::last(c), + "max" => Self::max(c), + "min" => Self::min(c), + "percentile" => Self::percentile(c), + "sample" => Self::sample(c), + "top" => Self::top(c), + name => error::internal(format!("unexpected selector function: {name}")), + }?, + )) + }) + .ok_or_else(|| error::map::internal("expected Call expression"))? + } + + fn bottom(call: &'a Call) -> Result { + let [field_key, tag_keys @ .., narg] = call.args.as_slice() else { + return error::internal(format!( + "invalid number of arguments for bottom: expected 2 or more, got {}", + call.args.len() + )); + }; + let tag_keys: Result> = tag_keys.iter().map(Self::identifier).collect(); + Ok(Self::Bottom { + field_key: Self::identifier(field_key)?, + tag_keys: tag_keys?, + n: Self::literal_int(narg)?, + }) + } + + fn first(call: &'a Call) -> Result { + if call.args.len() != 1 { + return error::internal(format!( + "invalid number of arguments for first: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::First { + field_key: Self::identifier(call.args.get(0).unwrap())?, + }) + } + + fn last(call: &'a Call) -> Result { + if call.args.len() != 1 { + return error::internal(format!( + "invalid number of arguments for last: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::Last { + field_key: Self::identifier(call.args.get(0).unwrap())?, + }) + } + + fn max(call: &'a Call) -> Result { + if call.args.len() != 1 { + return error::internal(format!( + "invalid number of arguments for max: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::Max { + field_key: Self::identifier(call.args.get(0).unwrap())?, + }) + } + + fn min(call: &'a Call) -> Result { + if call.args.len() != 1 { + return error::internal(format!( + "invalid number of arguments for min: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::Min { + field_key: Self::identifier(call.args.get(0).unwrap())?, + }) + } + + fn percentile(call: &'a Call) -> Result { + if call.args.len() != 2 { + return error::internal(format!( + "invalid number of arguments for min: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::Percentile { + field_key: Self::identifier(call.args.get(0).unwrap())?, + n: Self::literal_num(call.args.get(1).unwrap())?, + }) + } + + fn sample(call: &'a Call) -> Result { + if call.args.len() != 2 { + return error::internal(format!( + "invalid number of arguments for min: expected 1, got {}", + call.args.len() + )); + } + Ok(Self::Sample { + field_key: Self::identifier(call.args.get(0).unwrap())?, + n: Self::literal_int(call.args.get(1).unwrap())?, + }) + } + + fn top(call: &'a Call) -> Result { + let [field_key, tag_keys @ .., narg] = call.args.as_slice() else { + return error::internal(format!( + "invalid number of arguments for top: expected 2 or more, got {}", + call.args.len() + )); + }; + let tag_keys: Result> = tag_keys.iter().map(Self::identifier).collect(); + Ok(Self::Top { + field_key: Self::identifier(field_key)?, + tag_keys: tag_keys?, + n: Self::literal_int(narg)?, + }) + } + + fn identifier(expr: &'a IQLExpr) -> Result<&'a Identifier> { + match expr { + IQLExpr::VarRef(v) => Ok(&v.name), + e => error::internal(format!("invalid column identifier: {}", e)), + } + } + + fn literal_int(expr: &'a IQLExpr) -> Result { + match expr { + IQLExpr::Literal(Literal::Integer(n)) => Ok(*n), + e => error::internal(format!("invalid integer literal: {}", e)), + } + } + + fn literal_num(expr: &'a IQLExpr) -> Result { + match expr { + IQLExpr::Literal(Literal::Integer(n)) => Ok(*n as f64), + IQLExpr::Literal(Literal::Float(n)) => Ok(*n), + e => error::internal(format!("invalid integer literal: {}", e)), + } + } +} + +impl<'a> Display for Selector<'a> { + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> { + match self { + Self::Bottom { + field_key, + tag_keys, + n, + } => { + write!(f, "bottom({field_key}")?; + for tag_key in tag_keys { + write!(f, ", {tag_key}")?; + } + write!(f, ", {n})") + } + Self::First { field_key } => write!(f, "first({field_key})"), + Self::Last { field_key } => write!(f, "last({field_key})"), + Self::Max { field_key } => write!(f, "max({field_key})"), + Self::Min { field_key } => write!(f, "min({field_key})"), + Self::Percentile { field_key, n } => write!(f, "percentile({field_key}, {n})"), + Self::Sample { field_key, n } => write!(f, "sample({field_key}, {n})"), + Self::Top { + field_key, + tag_keys, + n, + } => { + write!(f, "top({field_key}")?; + for tag_key in tag_keys { + write!(f, ", {tag_key}")?; + } + write!(f, ", {n})") + } + } + } +} + +#[derive(Clone, Copy, Debug)] +pub(super) enum SelectorWindowOrderBy<'a> { + FieldAsc(&'a Identifier), + FieldDesc(&'a Identifier), +} diff --git a/iox_query_influxql/src/plan/rewriter.rs b/iox_query_influxql/src/plan/rewriter.rs index 4f0eb6a642..47ff224458 100644 --- a/iox_query_influxql/src/plan/rewriter.rs +++ b/iox_query_influxql/src/plan/rewriter.rs @@ -1,9 +1,10 @@ +use crate::error; use crate::plan::expr_type_evaluator::TypeEvaluator; use crate::plan::field::{field_by_name, field_name}; use crate::plan::field_mapper::{field_and_dimensions, FieldTypeMap}; use crate::plan::ir::{DataSource, Field, Interval, Select, SelectQuery, TagSet}; use crate::plan::var_ref::{influx_type_to_var_ref_data_type, var_ref_data_type_to_influx_type}; -use crate::plan::{error, util, SchemaProvider}; +use crate::plan::{util, SchemaProvider}; use datafusion::common::{DataFusionError, Result}; use influxdb_influxql_parser::common::{MeasurementName, QualifiedMeasurementName, WhereClause}; use influxdb_influxql_parser::expression::walk::{ diff --git a/iox_query_influxql/src/plan/test_utils.rs b/iox_query_influxql/src/plan/test_utils.rs index 8c32866ce4..2abc03bb4a 100644 --- a/iox_query_influxql/src/plan/test_utils.rs +++ b/iox_query_influxql/src/plan/test_utils.rs @@ -1,7 +1,8 @@ //! APIs for testing. #![cfg(test)] -use crate::plan::{error, SchemaProvider}; +use crate::error; +use crate::plan::SchemaProvider; use chrono::{DateTime, NaiveDate, Utc}; use datafusion::common::Result as DataFusionResult; use datafusion::datasource::empty::EmptyTable; diff --git a/iox_query_influxql/src/plan/udaf.rs b/iox_query_influxql/src/plan/udaf.rs index 571c5f064b..8c75283ec5 100644 --- a/iox_query_influxql/src/plan/udaf.rs +++ b/iox_query_influxql/src/plan/udaf.rs @@ -1,4 +1,4 @@ -use crate::plan::error; +use crate::{error, NUMERICS}; use arrow::array::{Array, ArrayRef, Int64Array}; use arrow::datatypes::{DataType, TimeUnit}; use datafusion::common::{downcast_value, DataFusionError, Result, ScalarValue}; @@ -10,10 +10,6 @@ use once_cell::sync::Lazy; use std::mem::replace; use std::sync::Arc; -/// A list of the numeric types supported by InfluxQL that can be be used -/// as input to user-defined aggregate functions. -pub(crate) static NUMERICS: &[DataType] = &[DataType::Int64, DataType::UInt64, DataType::Float64]; - /// Name of the `MOVING_AVERAGE` user-defined aggregate function. pub(crate) const MOVING_AVERAGE_NAME: &str = "moving_average"; diff --git a/iox_query_influxql/src/plan/udf.rs b/iox_query_influxql/src/plan/udf.rs index 728aeffbc1..bab8f4bb0a 100644 --- a/iox_query_influxql/src/plan/udf.rs +++ b/iox_query_influxql/src/plan/udf.rs @@ -5,9 +5,8 @@ //! call information as the InfluxQL AST. These expressions are then //! rewritten at a later stage of planning, with more context available. -use crate::plan::error; -use crate::plan::udaf::NUMERICS; use crate::plan::util_copy::find_exprs_in_exprs; +use crate::{error, NUMERICS}; use arrow::datatypes::DataType; use datafusion::logical_expr::{ Expr, ReturnTypeFunction, ScalarFunctionImplementation, ScalarUDF, Signature, TypeSignature, diff --git a/iox_query_influxql/src/plan/util.rs b/iox_query_influxql/src/plan/util.rs index 72dac59207..4d8eece367 100644 --- a/iox_query_influxql/src/plan/util.rs +++ b/iox_query_influxql/src/plan/util.rs @@ -1,4 +1,5 @@ -use crate::plan::{error, util_copy}; +use crate::error; +use crate::plan::util_copy; use arrow::datatypes::{DataType, TimeUnit}; use datafusion::common::tree_node::{TreeNode, VisitRecursion}; use datafusion::common::{DFSchemaRef, Result}; diff --git a/iox_query_influxql/src/window.rs b/iox_query_influxql/src/window.rs new file mode 100644 index 0000000000..9cb989ea8a --- /dev/null +++ b/iox_query_influxql/src/window.rs @@ -0,0 +1,23 @@ +//! User defined window functions implementing influxQL features. + +use datafusion::logical_expr::{ + PartitionEvaluatorFactory, ReturnTypeFunction, WindowFunction, WindowUDF, +}; +use once_cell::sync::Lazy; +use std::sync::Arc; + +mod percent_row_number; + +/// Definition of the `PERCENT_ROW_NUMBER` user-defined window function. +pub(crate) static PERCENT_ROW_NUMBER: Lazy = Lazy::new(|| { + let return_type: ReturnTypeFunction = Arc::new(percent_row_number::return_type); + let partition_evaluator_factory: PartitionEvaluatorFactory = + Arc::new(percent_row_number::partition_evaluator_factory); + + WindowFunction::WindowUDF(Arc::new(WindowUDF::new( + percent_row_number::NAME, + &percent_row_number::SIGNATURE, + &return_type, + &partition_evaluator_factory, + ))) +}); diff --git a/iox_query_influxql/src/window/percent_row_number.rs b/iox_query_influxql/src/window/percent_row_number.rs new file mode 100644 index 0000000000..0435f336bb --- /dev/null +++ b/iox_query_influxql/src/window/percent_row_number.rs @@ -0,0 +1,96 @@ +use crate::error; +use arrow::array::{Array, ArrayRef, Float64Array, Int64Array, UInt64Array}; +use arrow::datatypes::DataType; +use datafusion::common::{downcast_value, DataFusionError, Result}; +use datafusion::logical_expr::{PartitionEvaluator, Signature, TypeSignature, Volatility}; +use once_cell::sync::Lazy; +use std::sync::Arc; + +/// The name of the percent_row_number aggregate function. +pub(super) const NAME: &str = "percent_row_number"; + +/// Valid signatures for the percent_row_number aggregate function. +pub(super) static SIGNATURE: Lazy = Lazy::new(|| { + Signature::one_of( + vec![ + TypeSignature::Exact(vec![DataType::Int64]), + TypeSignature::Exact(vec![DataType::Float64]), + ], + Volatility::Immutable, + ) +}); + +/// Calculate the return type given the function signature. Percent_row_number +/// always returns a UInt64. +pub(super) fn return_type(_: &[DataType]) -> Result> { + Ok(Arc::new(DataType::UInt64)) +} + +/// Create a new partition_evaluator_factory. +pub(super) fn partition_evaluator_factory() -> Result> { + Ok(Box::new(PercentRowNumberPartitionEvaluator {})) +} + +/// PartitionEvaluator which returns the row number at which the nth +/// percentile of the data will occur. +/// +/// This evaluator calculates the row_number accross the entire partition, +/// any data that should not be included must be filtered out before +/// evaluating the window function. +#[derive(Debug)] +struct PercentRowNumberPartitionEvaluator {} + +impl PartitionEvaluator for PercentRowNumberPartitionEvaluator { + fn evaluate_all(&mut self, values: &[ArrayRef], num_rows: usize) -> Result> { + assert_eq!(values.len(), 1); + + let array = Arc::clone(&values[0]); + let mut builder = UInt64Array::builder(array.len()); + match array.data_type() { + DataType::Int64 => builder.extend(downcast_value!(array, Int64Array).iter().map(|o| { + o.and_then(|v| percentile_idx(num_rows, v as f64).map(|v| v as u64)) + .or(Some(0)) + })), + DataType::Float64 => { + builder.extend(downcast_value!(array, Float64Array).iter().map(|o| { + o.and_then(|v| percentile_idx(num_rows, v).map(|v| v as u64)) + .or(Some(0)) + })) + } + dt => { + return error::internal(format!( + "invalid data type ({dt}) for PERCENTILE n argument" + )) + } + }; + Ok(Arc::new(builder.finish())) + } + + fn supports_bounded_execution(&self) -> bool { + false + } + + fn uses_window_frame(&self) -> bool { + false + } + + fn include_rank(&self) -> bool { + false + } +} + +/// Calculate the location in an ordered list of len items where the +/// location of the item at the given percentile would be found. +/// +/// Note that row numbers are 1-based so this returns values in the +/// range \[1,len\]. +/// +/// This uses the same algorithm as the original influxdb implementation +/// of percentile as can be found in +/// . +fn percentile_idx(len: usize, percentile: f64) -> Option { + match TryInto::::try_into(((len as f64) * percentile / 100.0 + 0.5).floor() as isize) { + Ok(idx) if 0 < idx && idx < len => Some(idx), + _ => None, + } +} From f3b6c8bf1587a52fc868a05c72c2ab106e7b7616 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 11 Jul 2023 09:21:38 +0000 Subject: [PATCH 23/37] chore(deps): Bump rustls from 0.21.3 to 0.21.5 (#8207) Bumps [rustls](https://github.com/rustls/rustls) from 0.21.3 to 0.21.5. - [Release notes](https://github.com/rustls/rustls/releases) - [Commits](https://github.com/rustls/rustls/compare/v/0.21.3...v/0.21.5) --- updated-dependencies: - dependency-name: rustls dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Dom --- Cargo.lock | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8fa9abeece..650749dac9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2277,7 +2277,7 @@ checksum = "0646026eb1b3eea4cd9ba47912ea5ce9cc07713d105b1a14698f4e6433d348b7" dependencies = [ "http", "hyper", - "rustls 0.21.3", + "rustls 0.21.5", "tokio", "tokio-rustls 0.24.1", ] @@ -4587,7 +4587,7 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls 0.21.3", + "rustls 0.21.5", "rustls-pemfile", "serde", "serde_json", @@ -4739,9 +4739,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.3" +version = "0.21.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b19faa85ecb5197342b54f987b142fb3e30d0c90da40f80ef4fa9a726e6676ed" +checksum = "79ea77c539259495ce8ca47f53e66ae0330a8819f67e23ac96ca02f50e7b7d36" dependencies = [ "log", "ring", @@ -5765,7 +5765,7 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ - "rustls 0.21.3", + "rustls 0.21.5", "tokio", ] @@ -6713,7 +6713,7 @@ dependencies = [ "reqwest", "ring", "rustix 0.38.3", - "rustls 0.21.3", + "rustls 0.21.5", "scopeguard", "serde", "serde_json", From 2d5decf1089189141006415a4c500c9059ba547f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 11 Jul 2023 09:27:00 +0000 Subject: [PATCH 24/37] chore(deps): Bump regex-syntax from 0.7.3 to 0.7.4 (#8206) Bumps [regex-syntax](https://github.com/rust-lang/regex) from 0.7.3 to 0.7.4. - [Release notes](https://github.com/rust-lang/regex/releases) - [Changelog](https://github.com/rust-lang/regex/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-lang/regex/compare/regex-syntax-0.7.3...regex-syntax-0.7.4) --- updated-dependencies: - dependency-name: regex-syntax dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- Cargo.lock | 16 ++++++++-------- query_functions/Cargo.toml | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 650749dac9..105d143d90 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -379,7 +379,7 @@ dependencies = [ "arrow-schema", "arrow-select", "regex", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", ] [[package]] @@ -1448,7 +1448,7 @@ dependencies = [ "hashbrown 0.14.0", "itertools 0.11.0", "log", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", ] [[package]] @@ -4395,7 +4395,7 @@ dependencies = [ "itertools 0.11.0", "once_cell", "regex", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", "schema", "snafu", "tokio", @@ -4529,7 +4529,7 @@ dependencies = [ "aho-corasick", "memchr", "regex-automata 0.3.2", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", ] [[package]] @@ -4549,7 +4549,7 @@ checksum = "83d3daa6976cffb758ec878f108ba0e062a45b2d6ca3a2cca965338855476caf" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", ] [[package]] @@ -4560,9 +4560,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.7.3" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ab07dc67230e4a4718e70fd5c20055a4334b121f1f9db8fe63ef39ce9b8c846" +checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2" [[package]] name = "reqwest" @@ -6709,7 +6709,7 @@ dependencies = [ "rand_core", "regex", "regex-automata 0.3.2", - "regex-syntax 0.7.3", + "regex-syntax 0.7.4", "reqwest", "ring", "rustix 0.38.3", diff --git a/query_functions/Cargo.toml b/query_functions/Cargo.toml index 52581c6748..115de7ac1e 100644 --- a/query_functions/Cargo.toml +++ b/query_functions/Cargo.toml @@ -11,7 +11,7 @@ chrono = { version = "0.4", default-features = false } datafusion = { workspace = true } once_cell = "1" regex = "1" -regex-syntax = "0.7.3" +regex-syntax = "0.7.4" schema = { path = "../schema" } snafu = "0.7" workspace-hack = { version = "0.1", path = "../workspace-hack" } From b24f9c81ba680ce828d72b14d17486646a0ff4d5 Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Tue, 11 Jul 2023 09:36:38 -0400 Subject: [PATCH 25/37] chore: Update DataFusion pin, updates for API changed (#8199) --- Cargo.lock | 104 +++++++++++------- Cargo.toml | 30 +---- compactor/src/components/df_planner/panic.rs | 14 ++- iox_query/src/exec/gapfill/mod.rs | 12 +- iox_query/src/exec/non_null_checker.rs | 22 ++-- iox_query/src/exec/query_tracing.rs | 4 +- iox_query/src/exec/schema_pivot.rs | 20 ++-- iox_query/src/exec/split.rs | 22 ++-- .../handle_gapfill/range_predicate.rs | 4 +- .../physical_optimizer/projection_pushdown.rs | 12 +- iox_query/src/provider/deduplicate.rs | 30 +++-- iox_query/src/provider/record_batch_exec.rs | 20 ++-- iox_query_influxql/src/frontend/planner.rs | 16 ++- iox_query_influxql/src/plan/planner.rs | 13 ++- iox_query_influxql/src/plan/util_copy.rs | 13 ++- predicate/src/lib.rs | 2 +- querier/src/system_tables/mod.rs | 16 ++- workspace-hack/Cargo.toml | 23 ++-- 18 files changed, 220 insertions(+), 157 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 105d143d90..660dd90e99 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -161,8 +161,9 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" [[package]] name = "arrow" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2feeebd77b34b0bc88f224e06d01c27da4733997cc4789a4e056196656cdc59a" dependencies = [ "ahash 0.8.3", "arrow-arith", @@ -182,8 +183,9 @@ dependencies = [ [[package]] name = "arrow-arith" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7173f5dc49c0ecb5135f52565af33afd3fdc9a12d13bd6f9973e8b96305e4b2e" dependencies = [ "arrow-array", "arrow-buffer", @@ -196,8 +198,9 @@ dependencies = [ [[package]] name = "arrow-array" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63d7ea725f7d1f8bb2cffc53ef538557e95fc802e217d5be25122d402e22f3d0" dependencies = [ "ahash 0.8.3", "arrow-buffer", @@ -212,8 +215,9 @@ dependencies = [ [[package]] name = "arrow-buffer" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdbe439e077f484e5000b9e1d47b5e4c0d15f2b311a8f5bcc682553d5d67a722" dependencies = [ "half 2.3.1", "num", @@ -221,8 +225,9 @@ dependencies = [ [[package]] name = "arrow-cast" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93913cc14875770aa1eef5e310765e855effa352c094cb1c7c00607d0f37b4e1" dependencies = [ "arrow-array", "arrow-buffer", @@ -238,8 +243,9 @@ dependencies = [ [[package]] name = "arrow-csv" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef55b67c55ed877e6fe7b923121c19dae5e31ca70249ea2779a17b58fb0fbd9a" dependencies = [ "arrow-array", "arrow-buffer", @@ -256,8 +262,9 @@ dependencies = [ [[package]] name = "arrow-data" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4f4f4a3c54614126a71ab91f6631c9743eb4643d6e9318b74191da9dc6e028b" dependencies = [ "arrow-buffer", "arrow-schema", @@ -267,8 +274,9 @@ dependencies = [ [[package]] name = "arrow-flight" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1128a9f099b4e8dc9a67aed274061f3cc95afd8b7aab98f2b44cb8b7b542b71" dependencies = [ "arrow-arith", "arrow-array", @@ -293,8 +301,9 @@ dependencies = [ [[package]] name = "arrow-ipc" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d41a3659f984a524ef1c2981d43747b24d8eec78e2425267fcd0ef34ce71cd18" dependencies = [ "arrow-array", "arrow-buffer", @@ -306,8 +315,9 @@ dependencies = [ [[package]] name = "arrow-json" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10b95faa95a378f56ef32d84cc0104ea998c39ef7cd1faaa6b4cebf8ea92846d" dependencies = [ "arrow-array", "arrow-buffer", @@ -316,7 +326,7 @@ dependencies = [ "arrow-schema", "chrono", "half 2.3.1", - "indexmap 1.9.3", + "indexmap 2.0.0", "lexical-core", "num", "serde", @@ -325,8 +335,9 @@ dependencies = [ [[package]] name = "arrow-ord" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c68549a4284d9f8b39586afb8d5ff8158b8f0286353a4844deb1d11cf1ba1f26" dependencies = [ "arrow-array", "arrow-buffer", @@ -339,8 +350,9 @@ dependencies = [ [[package]] name = "arrow-row" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a75a4a757afc301ce010adadff54d79d66140c4282ed3de565f6ccb716a5cf3" dependencies = [ "ahash 0.8.3", "arrow-array", @@ -353,13 +365,15 @@ dependencies = [ [[package]] name = "arrow-schema" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bebcb57eef570b15afbcf2d07d813eb476fde9f6dd69c81004d6476c197e87e" [[package]] name = "arrow-select" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6e2943fa433a48921e914417173816af64eef61c0a3d448280e6c40a62df221" dependencies = [ "arrow-array", "arrow-buffer", @@ -370,14 +384,16 @@ dependencies = [ [[package]] name = "arrow-string" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbc92ed638851774f6d7af1ad900b92bc1486746497511868b4298fcbcfa35af" dependencies = [ "arrow-array", "arrow-buffer", "arrow-data", "arrow-schema", "arrow-select", + "num", "regex", "regex-syntax 0.7.4", ] @@ -1344,7 +1360,7 @@ dependencies = [ [[package]] name = "datafusion" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "ahash 0.8.3", "arrow", @@ -1392,7 +1408,7 @@ dependencies = [ [[package]] name = "datafusion-common" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "arrow", "arrow-array", @@ -1406,7 +1422,7 @@ dependencies = [ [[package]] name = "datafusion-execution" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "dashmap", "datafusion-common", @@ -1423,7 +1439,7 @@ dependencies = [ [[package]] name = "datafusion-expr" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "ahash 0.8.3", "arrow", @@ -1437,7 +1453,7 @@ dependencies = [ [[package]] name = "datafusion-optimizer" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "arrow", "async-trait", @@ -1454,13 +1470,14 @@ dependencies = [ [[package]] name = "datafusion-physical-expr" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "ahash 0.8.3", "arrow", "arrow-array", "arrow-buffer", "arrow-schema", + "base64 0.21.2", "blake2", "blake3", "chrono", @@ -1469,6 +1486,7 @@ dependencies = [ "datafusion-row", "half 2.3.1", "hashbrown 0.14.0", + "hex", "indexmap 2.0.0", "itertools 0.11.0", "lazy_static", @@ -1486,7 +1504,7 @@ dependencies = [ [[package]] name = "datafusion-proto" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "arrow", "chrono", @@ -1500,7 +1518,7 @@ dependencies = [ [[package]] name = "datafusion-row" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "arrow", "datafusion-common", @@ -1511,7 +1529,7 @@ dependencies = [ [[package]] name = "datafusion-sql" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=46752163bd4f30f778850160513e8ca7f15fcf14#46752163bd4f30f778850160513e8ca7f15fcf14" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" dependencies = [ "arrow", "arrow-schema", @@ -3849,8 +3867,9 @@ dependencies = [ [[package]] name = "parquet" -version = "42.0.0" -source = "git+https://github.com/alamb/arrow-rs.git?branch=alamb/42.0.0_patched#20f6bd7ed730d937abe76ab859088094dee8a5d3" +version = "43.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec7267a9607c3f955d4d0ac41b88a67cecc0d8d009173ad3da390699a6cb3750" dependencies = [ "ahash 0.8.3", "arrow-array", @@ -6686,6 +6705,7 @@ dependencies = [ "hashbrown 0.14.0", "heck", "indexmap 1.9.3", + "indexmap 2.0.0", "itertools 0.10.5", "libc", "lock_api", diff --git a/Cargo.toml b/Cargo.toml index 1c6a8e3c82..b84d776fd6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -118,13 +118,14 @@ edition = "2021" license = "MIT OR Apache-2.0" [workspace.dependencies] -arrow = { version = "42.0.0" } -arrow-flight = { version = "42.0.0" } -datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "46752163bd4f30f778850160513e8ca7f15fcf14", default-features = false } -datafusion-proto = { git = "https://github.com/apache/arrow-datafusion.git", rev = "46752163bd4f30f778850160513e8ca7f15fcf14" } +arrow = { version = "43.0.0" } +arrow-flight = { version = "43.0.0" } +datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false } +datafusion-proto = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185" } + hashbrown = { version = "0.14.0" } object_store = { version = "0.6.0" } -parquet = { version = "42.0.0" } +parquet = { version = "43.0.0" } tonic = { version = "0.9.2", features = ["tls", "tls-webpki-roots"] } tonic-build = { version = "0.9.2" } tonic-health = { version = "0.9.2" } @@ -154,22 +155,3 @@ opt-level = 3 [profile.dev.package.similar] opt-level = 3 - -[patch.crates-io] -# TODO remove on upgrade to 43.0.0 -# Use https://github.com/apache/arrow-rs/pull/4467 to get the fix for -# https://github.com/apache/arrow-rs/issues/4459 -parquet = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-buffer = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-schema = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-data = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-array = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-select = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-cast = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-ipc = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-row = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-arith = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-ord = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-string = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } -arrow-flight = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched" } diff --git a/compactor/src/components/df_planner/panic.rs b/compactor/src/components/df_planner/panic.rs index 84fcdd6552..79956fdd0c 100644 --- a/compactor/src/components/df_planner/panic.rs +++ b/compactor/src/components/df_planner/panic.rs @@ -7,8 +7,8 @@ use datafusion::{ execution::context::TaskContext, physical_expr::PhysicalSortExpr, physical_plan::{ - stream::RecordBatchStreamAdapter, ExecutionPlan, Partitioning, SendableRecordBatchStream, - Statistics, + stream::RecordBatchStreamAdapter, DisplayAs, DisplayFormatType, ExecutionPlan, + Partitioning, SendableRecordBatchStream, Statistics, }, }; use schema::SchemaBuilder; @@ -93,6 +93,16 @@ impl ExecutionPlan for PanicPlan { } } +impl DisplayAs for PanicPlan { + fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + write!(f, "PanicPlan") + } + } + } +} + #[cfg(test)] mod tests { use data_types::CompactionLevel; diff --git a/iox_query/src/exec/gapfill/mod.rs b/iox_query/src/exec/gapfill/mod.rs index 95f806c74b..90b20254be 100644 --- a/iox_query/src/exec/gapfill/mod.rs +++ b/iox_query/src/exec/gapfill/mod.rs @@ -27,7 +27,7 @@ use datafusion::{ physical_plan::{ expressions::Column, metrics::{BaselineMetrics, ExecutionPlanMetricsSet}, - DisplayFormatType, Distribution, ExecutionPlan, Partitioning, PhysicalExpr, + DisplayAs, DisplayFormatType, Distribution, ExecutionPlan, Partitioning, PhysicalExpr, SendableRecordBatchStream, Statistics, }, prelude::Expr, @@ -534,6 +534,12 @@ impl ExecutionPlan for GapFillExec { )?)) } + fn statistics(&self) -> Statistics { + Statistics::default() + } +} + +impl DisplayAs for GapFillExec { fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { match t { DisplayFormatType::Default | DisplayFormatType::Verbose => { @@ -566,10 +572,6 @@ impl ExecutionPlan for GapFillExec { } } } - - fn statistics(&self) -> Statistics { - Statistics::default() - } } #[cfg(test)] diff --git a/iox_query/src/exec/non_null_checker.rs b/iox_query/src/exec/non_null_checker.rs index d5de5f34d3..1de84cc656 100644 --- a/iox_query/src/exec/non_null_checker.rs +++ b/iox_query/src/exec/non_null_checker.rs @@ -54,8 +54,8 @@ use datafusion::{ physical_plan::{ expressions::PhysicalSortExpr, metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet}, - DisplayFormatType, Distribution, ExecutionPlan, Partitioning, SendableRecordBatchStream, - Statistics, + DisplayAs, DisplayFormatType, Distribution, ExecutionPlan, Partitioning, + SendableRecordBatchStream, Statistics, }, }; @@ -272,14 +272,6 @@ impl ExecutionPlan for NonNullCheckerExec { Ok(AdapterStream::adapt(self.schema(), rx, handle)) } - fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match t { - DisplayFormatType::Default | DisplayFormatType::Verbose => { - write!(f, "NonNullCheckerExec") - } - } - } - fn metrics(&self) -> Option { Some(self.metrics.clone_inner()) } @@ -290,6 +282,16 @@ impl ExecutionPlan for NonNullCheckerExec { } } +impl DisplayAs for NonNullCheckerExec { + fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + write!(f, "NonNullCheckerExec") + } + } + } +} + async fn check_for_nulls( mut input_stream: SendableRecordBatchStream, schema: SchemaRef, diff --git a/iox_query/src/exec/query_tracing.rs b/iox_query/src/exec/query_tracing.rs index e5950dce49..b3d37b23b6 100644 --- a/iox_query/src/exec/query_tracing.rs +++ b/iox_query/src/exec/query_tracing.rs @@ -345,7 +345,7 @@ mod tests { physical_plan::{ expressions::PhysicalSortExpr, metrics::{Count, Time, Timestamp}, - Metric, + DisplayAs, Metric, }, }; use std::{collections::BTreeMap, str::FromStr, sync::Arc, time::Duration}; @@ -679,7 +679,9 @@ mod tests { fn metrics(&self) -> Option { self.metrics.clone() } + } + impl DisplayAs for TestExec { fn fmt_as(&self, _t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "TestExec - {}", self.name) } diff --git a/iox_query/src/exec/schema_pivot.rs b/iox_query/src/exec/schema_pivot.rs index 9670044849..b6192f61f1 100644 --- a/iox_query/src/exec/schema_pivot.rs +++ b/iox_query/src/exec/schema_pivot.rs @@ -30,7 +30,6 @@ use arrow::{ error::ArrowError, record_batch::RecordBatch, }; -use datafusion::error::DataFusionError; use datafusion::{ common::{DFSchemaRef, ToDFSchema}, error::{DataFusionError as Error, Result}, @@ -43,6 +42,7 @@ use datafusion::{ Statistics, }, }; +use datafusion::{error::DataFusionError, physical_plan::DisplayAs}; use datafusion_util::{watch::WatchedTask, AdapterStream}; use observability_deps::tracing::debug; @@ -247,14 +247,6 @@ impl ExecutionPlan for SchemaPivotExec { Ok(AdapterStream::adapt(self.schema(), rx, handle)) } - fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match t { - DisplayFormatType::Default | DisplayFormatType::Verbose => { - write!(f, "SchemaPivotExec") - } - } - } - fn metrics(&self) -> Option { Some(self.metrics.clone_inner()) } @@ -265,6 +257,16 @@ impl ExecutionPlan for SchemaPivotExec { } } +impl DisplayAs for SchemaPivotExec { + fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + write!(f, "SchemaPivotExec") + } + } + } +} + // Algorithm: for each column we haven't seen a value for yet, // check each input row; // diff --git a/iox_query/src/exec/split.rs b/iox_query/src/exec/split.rs index 23ddbd3498..c995dbe837 100644 --- a/iox_query/src/exec/split.rs +++ b/iox_query/src/exec/split.rs @@ -67,8 +67,8 @@ use datafusion::{ physical_plan::{ expressions::PhysicalSortExpr, metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet, RecordOutput}, - ColumnarValue, DisplayFormatType, Distribution, ExecutionPlan, Partitioning, PhysicalExpr, - SendableRecordBatchStream, Statistics, + ColumnarValue, DisplayAs, DisplayFormatType, Distribution, ExecutionPlan, Partitioning, + PhysicalExpr, SendableRecordBatchStream, Statistics, }, scalar::ScalarValue, }; @@ -267,14 +267,6 @@ impl ExecutionPlan for StreamSplitExec { } } - fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match t { - DisplayFormatType::Default | DisplayFormatType::Verbose => { - write!(f, "StreamSplitExec") - } - } - } - fn metrics(&self) -> Option { Some(self.metrics.clone_inner()) } @@ -286,6 +278,16 @@ impl ExecutionPlan for StreamSplitExec { } } +impl DisplayAs for StreamSplitExec { + fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + write!(f, "StreamSplitExec") + } + } + } +} + impl StreamSplitExec { /// if in State::New, sets up the output running and sets self.state --> `Running` fn start_if_needed(&self, context: Arc) -> Result<()> { diff --git a/iox_query/src/logical_optimizer/handle_gapfill/range_predicate.rs b/iox_query/src/logical_optimizer/handle_gapfill/range_predicate.rs index c89b7857cb..9965b86f0d 100644 --- a/iox_query/src/logical_optimizer/handle_gapfill/range_predicate.rs +++ b/iox_query/src/logical_optimizer/handle_gapfill/range_predicate.rs @@ -7,7 +7,7 @@ use datafusion::{ DFSchema, }, error::Result, - logical_expr::{Between, BinaryExpr, LogicalPlan, Operator}, + logical_expr::{expr::Alias, Between, BinaryExpr, LogicalPlan, Operator}, optimizer::utils::split_conjunction, prelude::{Column, Expr}, }; @@ -79,7 +79,7 @@ impl TreeNodeVisitor for TimeRangeVisitor { fn unwrap_alias(mut e: &Expr) -> &Expr { loop { match e { - Expr::Alias(inner, _) => e = inner.as_ref(), + Expr::Alias(Alias { expr, .. }) => e = expr.as_ref(), e => break e, } } diff --git a/iox_query/src/physical_optimizer/projection_pushdown.rs b/iox_query/src/physical_optimizer/projection_pushdown.rs index 2e8a97fb5f..d3c2c8879e 100644 --- a/iox_query/src/physical_optimizer/projection_pushdown.rs +++ b/iox_query/src/physical_optimizer/projection_pushdown.rs @@ -434,7 +434,7 @@ mod tests { logical_expr::Operator, physical_plan::{ expressions::{BinaryExpr, Literal}, - PhysicalExpr, Statistics, + DisplayAs, PhysicalExpr, Statistics, }, scalar::ScalarValue, }; @@ -1695,6 +1695,12 @@ mod tests { unimplemented!() } + fn statistics(&self) -> datafusion::physical_plan::Statistics { + unimplemented!() + } + } + + impl DisplayAs for TestExec { fn fmt_as( &self, _t: datafusion::physical_plan::DisplayFormatType, @@ -1702,9 +1708,5 @@ mod tests { ) -> std::fmt::Result { write!(f, "Test") } - - fn statistics(&self) -> datafusion::physical_plan::Statistics { - unimplemented!() - } } } diff --git a/iox_query/src/provider/deduplicate.rs b/iox_query/src/provider/deduplicate.rs index 02427b1257..e221c3fd87 100644 --- a/iox_query/src/provider/deduplicate.rs +++ b/iox_query/src/provider/deduplicate.rs @@ -20,8 +20,8 @@ use datafusion::{ metrics::{ self, BaselineMetrics, ExecutionPlanMetricsSet, MetricBuilder, MetricsSet, RecordOutput, }, - DisplayFormatType, Distribution, ExecutionPlan, Partitioning, SendableRecordBatchStream, - Statistics, + DisplayAs, DisplayFormatType, Distribution, ExecutionPlan, Partitioning, + SendableRecordBatchStream, Statistics, }, }; use futures::StreamExt; @@ -267,15 +267,6 @@ impl ExecutionPlan for DeduplicateExec { vec![Distribution::SinglePartition] } - fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match t { - DisplayFormatType::Default | DisplayFormatType::Verbose => { - let expr: Vec = self.sort_keys.iter().map(|e| e.to_string()).collect(); - write!(f, "DeduplicateExec: [{}]", expr.join(",")) - } - } - } - fn metrics(&self) -> Option { Some(self.metrics.clone_inner()) } @@ -289,6 +280,17 @@ impl ExecutionPlan for DeduplicateExec { } } +impl DisplayAs for DeduplicateExec { + fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + let expr: Vec = self.sort_keys.iter().map(|e| e.to_string()).collect(); + write!(f, "DeduplicateExec: [{}]", expr.join(",")) + } + } + } +} + async fn deduplicate( mut input_stream: SendableRecordBatchStream, sort_keys: Vec, @@ -1222,4 +1224,10 @@ mod test { Statistics::default() } } + + impl DisplayAs for DummyExec { + fn fmt_as(&self, _t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "DummyExec") + } + } } diff --git a/iox_query/src/provider/record_batch_exec.rs b/iox_query/src/provider/record_batch_exec.rs index ded30d8338..3959dca206 100644 --- a/iox_query/src/provider/record_batch_exec.rs +++ b/iox_query/src/provider/record_batch_exec.rs @@ -14,7 +14,7 @@ use datafusion::{ expressions::{Column, PhysicalSortExpr}, memory::MemoryStream, metrics::{BaselineMetrics, ExecutionPlanMetricsSet, MetricsSet}, - ColumnStatistics, DisplayFormatType, ExecutionPlan, Partitioning, + ColumnStatistics, DisplayAs, DisplayFormatType, ExecutionPlan, Partitioning, SendableRecordBatchStream, Statistics, }, scalar::ScalarValue, @@ -234,6 +234,16 @@ impl ExecutionPlan for RecordBatchesExec { Ok(adapter) } + fn metrics(&self) -> Option { + Some(self.metrics.clone_inner()) + } + + fn statistics(&self) -> Statistics { + self.statistics.clone() + } +} + +impl DisplayAs for RecordBatchesExec { fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { let total_groups = self.chunks.len(); @@ -258,12 +268,4 @@ impl ExecutionPlan for RecordBatchesExec { } } } - - fn metrics(&self) -> Option { - Some(self.metrics.clone_inner()) - } - - fn statistics(&self) -> Statistics { - self.statistics.clone() - } } diff --git a/iox_query_influxql/src/frontend/planner.rs b/iox_query_influxql/src/frontend/planner.rs index 998dfbd881..c0de1cdc31 100644 --- a/iox_query_influxql/src/frontend/planner.rs +++ b/iox_query_influxql/src/frontend/planner.rs @@ -17,7 +17,9 @@ use datafusion::datasource::provider_as_source; use datafusion::execution::context::{SessionState, TaskContext}; use datafusion::logical_expr::{AggregateUDF, LogicalPlan, ScalarUDF, TableSource}; use datafusion::physical_expr::PhysicalSortExpr; -use datafusion::physical_plan::{Partitioning, SendableRecordBatchStream}; +use datafusion::physical_plan::{ + DisplayAs, DisplayFormatType, Partitioning, SendableRecordBatchStream, +}; use datafusion::{ error::{DataFusionError, Result}, physical_plan::ExecutionPlan, @@ -78,7 +80,7 @@ struct SchemaExec { impl Debug for SchemaExec { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "SchemaExec") + self.fmt_as(DisplayFormatType::Default, f) } } @@ -123,6 +125,16 @@ impl ExecutionPlan for SchemaExec { } } +impl DisplayAs for SchemaExec { + fn fmt_as(&self, t: DisplayFormatType, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => { + write!(f, "SchemaExec") + } + } + } +} + /// Create plans for running InfluxQL queries against databases #[derive(Debug, Default)] pub struct InfluxQLQueryPlanner {} diff --git a/iox_query_influxql/src/plan/planner.rs b/iox_query_influxql/src/plan/planner.rs index d7ed9e9920..7201fa52a7 100644 --- a/iox_query_influxql/src/plan/planner.rs +++ b/iox_query_influxql/src/plan/planner.rs @@ -29,7 +29,7 @@ use datafusion::catalog::TableReference; use datafusion::common::tree_node::{TreeNode, VisitRecursion}; use datafusion::common::{DFSchema, DFSchemaRef, Result, ScalarValue, ToDFSchema}; use datafusion::datasource::{provider_as_source, MemTable}; -use datafusion::logical_expr::expr::ScalarFunction; +use datafusion::logical_expr::expr::{Alias, ScalarFunction}; use datafusion::logical_expr::expr_rewriter::normalize_col; use datafusion::logical_expr::logical_plan::builder::project; use datafusion::logical_expr::logical_plan::Analyze; @@ -813,7 +813,7 @@ impl<'a> InfluxQLToLogicalPlan<'a> { // Take ownership of the alias, so we don't reallocate, and temporarily place a literal // `NULL` in its place. - let Expr::Alias(_, alias) = std::mem::replace(&mut select_exprs[time_column_index], lit(ScalarValue::Null)) else { + let Expr::Alias(Alias{name: alias, ..}) = std::mem::replace(&mut select_exprs[time_column_index], lit(ScalarValue::Null)) else { return error::internal("time column is not an alias") }; @@ -1149,7 +1149,10 @@ impl<'a> InfluxQLToLogicalPlan<'a> { continue; } let (expr, out_name) = match expr.clone() { - Expr::Alias(expr, out_name) => (*expr, out_name), + Expr::Alias(Alias { + expr, + name: out_name, + }) => (*expr, out_name), _ => { return error::internal("other field is not aliased"); } @@ -1195,7 +1198,7 @@ impl<'a> InfluxQLToLogicalPlan<'a> { let time_column = { // Take ownership of the alias, so we don't reallocate, and temporarily place a literal // `NULL` in its place. - let Expr::Alias(_, alias) = std::mem::replace(&mut select_exprs[time_column_index], lit(ScalarValue::Null)) else { + let Expr::Alias(Alias{name: alias, ..}) = std::mem::replace(&mut select_exprs[time_column_index], lit(ScalarValue::Null)) else { return error::internal("time column is not an alias") }; @@ -2824,7 +2827,7 @@ fn build_gap_fill_node( fill_strategy: FillStrategy, ) -> Result { let (expr, alias) = match time_column { - Expr::Alias(expr, alias) => (expr.as_ref(), alias), + Expr::Alias(Alias { expr, name: alias }) => (expr.as_ref(), alias), _ => return error::internal("expected time column to have an alias function"), }; diff --git a/iox_query_influxql/src/plan/util_copy.rs b/iox_query_influxql/src/plan/util_copy.rs index 1ece258d5b..563b6e2a93 100644 --- a/iox_query_influxql/src/plan/util_copy.rs +++ b/iox_query_influxql/src/plan/util_copy.rs @@ -10,7 +10,7 @@ use datafusion::common::tree_node::{TreeNode, VisitRecursion}; use datafusion::common::Result; use datafusion::logical_expr::expr::{ - AggregateUDF, InList, InSubquery, Placeholder, ScalarFunction, ScalarUDF, + AggregateUDF, Alias, InList, InSubquery, Placeholder, ScalarFunction, ScalarUDF, }; use datafusion::logical_expr::{ expr::{ @@ -104,10 +104,13 @@ where filter: filter.clone(), order_by: order_by.clone(), })), - Expr::Alias(nested_expr, alias_name) => Ok(Expr::Alias( - Box::new(clone_with_replacement(nested_expr, replacement_fn)?), - alias_name.clone(), - )), + Expr::Alias(Alias { + expr: nested_expr, + name: alias_name, + }) => Ok(Expr::Alias(Alias { + expr: Box::new(clone_with_replacement(nested_expr, replacement_fn)?), + name: alias_name.clone(), + })), Expr::Between(Between { expr, negated, diff --git a/predicate/src/lib.rs b/predicate/src/lib.rs index f9ea842655..aa6c509574 100644 --- a/predicate/src/lib.rs +++ b/predicate/src/lib.rs @@ -488,7 +488,7 @@ impl TreeNodeVisitor for RowBasedVisitor { fn pre_visit(&mut self, expr: &Expr) -> Result { match expr { - Expr::Alias(_, _) + Expr::Alias(_) | Expr::Between { .. } | Expr::BinaryExpr { .. } | Expr::Case { .. } diff --git a/querier/src/system_tables/mod.rs b/querier/src/system_tables/mod.rs index c0d053c599..ee4d2a15a5 100644 --- a/querier/src/system_tables/mod.rs +++ b/querier/src/system_tables/mod.rs @@ -3,6 +3,7 @@ use arrow::{datatypes::SchemaRef, error::Result as ArrowResult, record_batch::Re use async_trait::async_trait; use data_types::NamespaceId; use datafusion::error::DataFusionError; +use datafusion::physical_plan::{DisplayAs, DisplayFormatType}; use datafusion::{ catalog::schema::SchemaProvider, datasource::TableProvider, @@ -140,9 +141,7 @@ struct SystemTableExecutionPlan { impl std::fmt::Debug for SystemTableExecutionPlan { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("SystemTableExecutionPlan") - .field("projection", &self.projection) - .finish() + self.fmt_as(DisplayFormatType::Default, f) } } @@ -192,6 +191,17 @@ impl ExecutionPlan for SystemTableExecutionPlan } } +impl DisplayAs for SystemTableExecutionPlan { + fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match t { + DisplayFormatType::Default | DisplayFormatType::Verbose => f + .debug_struct("SystemTableExecutionPlan") + .field("projection", &self.projection) + .finish(), + } + } +} + struct SystemTableStream { projected_schema: SchemaRef, projection: Option>, diff --git a/workspace-hack/Cargo.toml b/workspace-hack/Cargo.toml index 90bdcbb109..72d6c3a077 100644 --- a/workspace-hack/Cargo.toml +++ b/workspace-hack/Cargo.toml @@ -17,11 +17,11 @@ license.workspace = true ### BEGIN HAKARI SECTION [dependencies] ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] } -arrow = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", features = ["dyn_cmp_dict", "prettyprint"] } -arrow-array = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", default-features = false, features = ["chrono-tz"] } -arrow-flight = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", features = ["flight-sql-experimental"] } -arrow-ord = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", default-features = false, features = ["dyn_cmp_dict"] } -arrow-string = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", default-features = false, features = ["dyn_cmp_dict"] } +arrow = { version = "43", features = ["dyn_cmp_dict", "prettyprint"] } +arrow-array = { version = "43", default-features = false, features = ["chrono-tz"] } +arrow-flight = { version = "43", features = ["flight-sql-experimental"] } +arrow-ord = { version = "43", default-features = false, features = ["dyn_cmp_dict"] } +arrow-string = { version = "43", default-features = false, features = ["dyn_cmp_dict"] } base64-594e8ee84c453af0 = { package = "base64", version = "0.13" } base64-647d43efb71741da = { package = "base64", version = "0.21" } bitflags = { version = "1" } @@ -30,9 +30,9 @@ bytes = { version = "1" } chrono = { version = "0.4", default-features = false, features = ["alloc", "clock", "serde"] } crossbeam-utils = { version = "0.8" } crypto-common = { version = "0.1", default-features = false, features = ["std"] } -datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "46752163bd4f30f778850160513e8ca7f15fcf14" } -datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "46752163bd4f30f778850160513e8ca7f15fcf14", default-features = false, features = ["crypto_expressions", "regex_expressions", "unicode_expressions"] } -datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "46752163bd4f30f778850160513e8ca7f15fcf14", default-features = false, features = ["crypto_expressions", "regex_expressions", "unicode_expressions"] } +datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185" } +datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false, features = ["crypto_expressions", "regex_expressions", "unicode_expressions"] } +datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false, features = ["crypto_expressions", "encoding_expressions", "regex_expressions", "unicode_expressions"] } digest = { version = "0.10", features = ["mac", "std"] } either = { version = "1" } fixedbitset = { version = "0.4" } @@ -47,7 +47,8 @@ futures-task = { version = "0.3", default-features = false, features = ["std"] } futures-util = { version = "0.3", features = ["channel", "io", "sink"] } getrandom = { version = "0.2", default-features = false, features = ["std"] } hashbrown = { version = "0.14", features = ["raw"] } -indexmap = { version = "1", default-features = false, features = ["std"] } +indexmap-dff4ba8e3ae991db = { package = "indexmap", version = "1", default-features = false, features = ["std"] } +indexmap-f595c2ba2a3f28df = { package = "indexmap", version = "2" } itertools = { version = "0.10" } libc = { version = "0.2", features = ["extra_traits"] } lock_api = { version = "0.4", features = ["arc_lock"] } @@ -59,7 +60,7 @@ num-traits = { version = "0.2", features = ["i128", "libm"] } object_store = { version = "0.6", default-features = false, features = ["aws", "azure", "gcp"] } once_cell = { version = "1", features = ["parking_lot"] } parking_lot = { version = "0.12", features = ["arc_lock"] } -parquet = { git = "https://github.com/alamb/arrow-rs.git", branch = "alamb/42.0.0_patched", features = ["experimental", "object_store"] } +parquet = { version = "43", features = ["experimental", "object_store"] } petgraph = { version = "0.6" } phf_shared = { version = "0.11" } predicates = { version = "3" } @@ -122,7 +123,7 @@ futures-util = { version = "0.3", features = ["channel", "io", "sink"] } getrandom = { version = "0.2", default-features = false, features = ["std"] } hashbrown = { version = "0.14", features = ["raw"] } heck = { version = "0.4", features = ["unicode"] } -indexmap = { version = "1", default-features = false, features = ["std"] } +indexmap-dff4ba8e3ae991db = { package = "indexmap", version = "1", default-features = false, features = ["std"] } itertools = { version = "0.10" } libc = { version = "0.2", features = ["extra_traits"] } lock_api = { version = "0.4", features = ["arc_lock"] } From 3dabccd84bac95740c5e44be6defdc32e3937290 Mon Sep 17 00:00:00 2001 From: wiedld Date: Tue, 11 Jul 2023 08:41:12 -0700 Subject: [PATCH 26/37] feat(idpe-17789): scheduler job_status() (#8202) * feat(idpe-17789): scheduler job_status() (#8121) This block of work moves into the scheduler some of the specific downstream actions affiliated with compaction outcomes. Which responsibilities stay in the compactor, versus moved to the scheduler, roughly followed the heuristic of whether the action (a) had an impact on global catalog state (a.k.a. commits and partition skipping), (b) whether it's logging affiliated with compactor health (e.g. ParitionDoneSink logging outcomes) versus system health (e.g. logging commits), and (c) reporting to the scheduler on any errors encountered during compaction. This boundary is subject to change as we move forward. Also, a noted caveat (TODO) on this commit. We have a CompactionJob which is used to track work handed off to each compactor. Currently it still uses the partition_id for tracking, but the followup PR will start moving the compactor to have more CompactionJob uuid awareness. --- Cargo.lock | 4 + compactor/src/components/commit.rs | 55 +++ compactor/src/components/hardcoded.rs | 65 +-- compactor/src/components/mod.rs | 14 +- .../partition_done_sink/error_kind.rs | 50 +- .../components/partition_done_sink/logging.rs | 6 +- .../components/partition_done_sink/metrics.rs | 6 +- .../src/components/partition_done_sink/mod.rs | 32 +- .../components/partition_done_sink/outcome.rs | 49 ++ compactor/src/components/report.rs | 4 - compactor/src/config.rs | 7 +- compactor/src/error.rs | 12 + compactor/src/lib.rs | 8 +- compactor_scheduler/Cargo.toml | 4 + .../src}/commit/logging.rs | 6 +- .../src}/commit/metrics.rs | 6 +- .../src}/commit/mock.rs | 20 +- .../src}/commit/mod.rs | 7 +- compactor_scheduler/src/error.rs | 37 ++ compactor_scheduler/src/lib.rs | 29 +- compactor_scheduler/src/local_scheduler.rs | 438 +++++++++++++++++- .../src/local_scheduler/catalog_commit.rs | 6 +- .../src/local_scheduler}/combos/mod.rs | 4 +- .../src/local_scheduler}/combos/tests.rs | 10 +- .../combos/throttle_partition.rs | 19 +- .../combos/unique_partitions.rs | 15 +- .../partition_done_sink/catalog.rs | 8 +- .../partition_done_sink/mock.rs | 8 +- .../partition_done_sink/mod.rs | 32 ++ compactor_scheduler/src/scheduler.rs | 144 +++++- compactor_test_utils/src/commit_wrapper.rs | 2 +- compactor_test_utils/src/lib.rs | 3 +- ioxd_compactor/src/lib.rs | 1 - ioxd_compactor/src/scheduler_config.rs | 1 + 34 files changed, 906 insertions(+), 206 deletions(-) create mode 100644 compactor/src/components/commit.rs create mode 100644 compactor/src/components/partition_done_sink/outcome.rs rename {compactor/src/components => compactor_scheduler/src}/commit/logging.rs (97%) rename {compactor/src/components => compactor_scheduler/src}/commit/metrics.rs (98%) rename {compactor/src/components => compactor_scheduler/src}/commit/mock.rs (93%) rename {compactor/src/components => compactor_scheduler/src}/commit/mod.rs (95%) create mode 100644 compactor_scheduler/src/error.rs rename compactor/src/components/commit/catalog.rs => compactor_scheduler/src/local_scheduler/catalog_commit.rs (91%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/combos/mod.rs (59%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/combos/tests.rs (84%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/combos/throttle_partition.rs (96%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/combos/unique_partitions.rs (95%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/partition_done_sink/catalog.rs (88%) rename {compactor/src/components => compactor_scheduler/src/local_scheduler}/partition_done_sink/mock.rs (92%) create mode 100644 compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 660dd90e99..5d27b0f6e0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1001,11 +1001,15 @@ dependencies = [ "async-trait", "backoff", "data_types", + "futures", "iox_catalog", "iox_tests", "iox_time", + "itertools 0.11.0", + "metric", "observability_deps", "sharder", + "test_helpers", "tokio", "uuid", "workspace-hack", diff --git a/compactor/src/components/commit.rs b/compactor/src/components/commit.rs new file mode 100644 index 0000000000..67ad62d5f0 --- /dev/null +++ b/compactor/src/components/commit.rs @@ -0,0 +1,55 @@ +use std::sync::Arc; + +use async_trait::async_trait; +use compactor_scheduler::{ + Commit, CommitUpdate, CompactionJob, CompactionJobStatus, CompactionJobStatusResult, + CompactionJobStatusVariant, Scheduler, +}; +use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; + +#[derive(Debug)] +pub(crate) struct CommitToScheduler { + scheduler: Arc, +} + +impl CommitToScheduler { + pub(crate) fn new(scheduler: Arc) -> Self { + Self { scheduler } + } +} + +#[async_trait] +impl Commit for CommitToScheduler { + async fn commit( + &self, + partition_id: PartitionId, + delete: &[ParquetFile], + upgrade: &[ParquetFile], + create: &[ParquetFileParams], + target_level: CompactionLevel, + ) -> Vec { + match self + .scheduler + .job_status(CompactionJobStatus { + job: CompactionJob::new(partition_id), + status: CompactionJobStatusVariant::Update(CommitUpdate::new( + partition_id, + delete.into(), + upgrade.into(), + create.into(), + target_level, + )), + }) + .await + { + Ok(CompactionJobStatusResult::UpdatedParquetFiles(ids)) => ids, + _ => panic!("commit failed"), + } + } +} + +impl std::fmt::Display for CommitToScheduler { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "CommitToScheduler") + } +} diff --git a/compactor/src/components/hardcoded.rs b/compactor/src/components/hardcoded.rs index 672869940b..9554c3bd4f 100644 --- a/compactor/src/components/hardcoded.rs +++ b/compactor/src/components/hardcoded.rs @@ -4,7 +4,9 @@ use std::{sync::Arc, time::Duration}; -use compactor_scheduler::{create_scheduler, PartitionsSource, Scheduler}; +use compactor_scheduler::{ + create_scheduler, Commit, PartitionDoneSink, PartitionsSource, Scheduler, +}; use data_types::CompactionLevel; use object_store::memory::InMemory; @@ -12,11 +14,7 @@ use crate::{config::Config, error::ErrorKind, object_store::ignore_writes::Ignor use super::{ changed_files_filter::logging::LoggingChangedFiles, - combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, - commit::{ - catalog::CatalogCommit, logging::LoggingCommitWrapper, metrics::MetricsCommitWrapper, - mock::MockCommit, Commit, - }, + commit::CommitToScheduler, df_plan_exec::{ dedicated::DedicatedDataFusionPlanExec, noop::NoopDataFusionPlanExec, DataFusionPlanExec, }, @@ -39,9 +37,8 @@ use super::{ }, parquet_files_sink::{dispatch::DispatchParquetFilesSink, ParquetFilesSink}, partition_done_sink::{ - catalog::CatalogPartitionDoneSink, error_kind::ErrorKindPartitionDoneSinkWrapper, - logging::LoggingPartitionDoneSinkWrapper, metrics::MetricsPartitionDoneSinkWrapper, - mock::MockPartitionDoneSink, PartitionDoneSink, + error_kind::ErrorKindPartitionDoneSinkWrapper, logging::LoggingPartitionDoneSinkWrapper, + metrics::MetricsPartitionDoneSinkWrapper, outcome::PartitionDoneSinkToScheduler, }, partition_files_source::{ catalog::{CatalogPartitionFilesSource, QueryRateLimiter}, @@ -93,6 +90,8 @@ pub fn hardcoded_components(config: &Config) -> Arc { config.scheduler_config.clone(), Arc::clone(&config.catalog), Arc::clone(&config.time_provider), + Arc::clone(&config.metric_registry), + config.shadow_mode, ); let (partitions_source, commit, partition_done_sink) = make_partitions_source_commit_partition_sink(config, Arc::clone(&scheduler)); @@ -126,49 +125,14 @@ fn make_partitions_source_commit_partition_sink( Arc, Arc, ) { - let partitions_source = ScheduledPartitionsSource::new(scheduler); + let partitions_source = ScheduledPartitionsSource::new(Arc::clone(&scheduler)); - let partition_done_sink: Arc = if config.shadow_mode { - Arc::new(MockPartitionDoneSink::new()) - } else { - Arc::new(CatalogPartitionDoneSink::new( - config.backoff_config.clone(), - Arc::clone(&config.catalog), - )) - }; + let commit = CommitToScheduler::new(Arc::clone(&scheduler)); - let commit: Arc = if config.shadow_mode { - Arc::new(MockCommit::new()) - } else { - Arc::new(CatalogCommit::new( - config.backoff_config.clone(), - Arc::clone(&config.catalog), - )) - }; - - let commit = if let Some(commit_wrapper) = config.commit_wrapper.as_ref() { - commit_wrapper.wrap(commit) - } else { - commit - }; - - let (partitions_source, partition_done_sink) = - unique_partitions(partitions_source, partition_done_sink, 1); - - let (partitions_source, commit, partition_done_sink) = throttle_partition( - partitions_source, - commit, - partition_done_sink, - Arc::clone(&config.time_provider), - Duration::from_secs(60), - 1, - ); - - let commit = Arc::new(LoggingCommitWrapper::new(MetricsCommitWrapper::new( - commit, - &config.metric_registry, - ))); + let partition_done_sink = PartitionDoneSinkToScheduler::new(Arc::clone(&scheduler)); + // compactors are responsible for error classification + // and any future decisions regarding graceful shutdown let partition_done_sink: Arc = if config.all_errors_are_fatal { Arc::new(partition_done_sink) } else { @@ -185,6 +149,7 @@ fn make_partitions_source_commit_partition_sink( }) .copied() .collect(), + scheduler, )) }; let partition_done_sink = Arc::new(LoggingPartitionDoneSinkWrapper::new( @@ -210,7 +175,7 @@ fn make_partitions_source_commit_partition_sink( )) }; - (partitions_source, commit, partition_done_sink) + (partitions_source, Arc::new(commit), partition_done_sink) } fn make_partition_stream( diff --git a/compactor/src/components/mod.rs b/compactor/src/components/mod.rs index 1ce2eea844..2cf1dc9638 100644 --- a/compactor/src/components/mod.rs +++ b/compactor/src/components/mod.rs @@ -1,19 +1,19 @@ use std::sync::Arc; +use compactor_scheduler::{Commit, PartitionDoneSink}; + use self::{ - changed_files_filter::ChangedFilesFilter, commit::Commit, df_plan_exec::DataFusionPlanExec, + changed_files_filter::ChangedFilesFilter, df_plan_exec::DataFusionPlanExec, df_planner::DataFusionPlanner, divide_initial::DivideInitial, file_classifier::FileClassifier, ir_planner::IRPlanner, parquet_files_sink::ParquetFilesSink, - partition_done_sink::PartitionDoneSink, partition_files_source::PartitionFilesSource, - partition_filter::PartitionFilter, partition_info_source::PartitionInfoSource, - partition_stream::PartitionStream, + partition_files_source::PartitionFilesSource, partition_filter::PartitionFilter, + partition_info_source::PartitionInfoSource, partition_stream::PartitionStream, post_classification_partition_filter::PostClassificationPartitionFilter, round_info_source::RoundInfoSource, round_split::RoundSplit, scratchpad::ScratchpadGen, }; pub mod changed_files_filter; -pub mod combos; -pub mod commit; +pub(crate) mod commit; pub mod df_plan_exec; pub mod df_planner; pub mod divide_initial; @@ -61,7 +61,7 @@ pub struct Components { pub post_classification_partition_filter: Arc, /// Records "partition is done" status for given partition. pub partition_done_sink: Arc, - /// Commits changes (i.e. deletion and creation) to the catalog. + /// Commits changes (i.e. deletion and creation). pub commit: Arc, /// Creates `PlanIR` that describes what files should be compacted and updated pub ir_planner: Arc, diff --git a/compactor/src/components/partition_done_sink/error_kind.rs b/compactor/src/components/partition_done_sink/error_kind.rs index 0848906215..f06f141436 100644 --- a/compactor/src/components/partition_done_sink/error_kind.rs +++ b/compactor/src/components/partition_done_sink/error_kind.rs @@ -1,12 +1,14 @@ -use std::{collections::HashSet, fmt::Display}; +use std::{collections::HashSet, fmt::Display, sync::Arc}; use async_trait::async_trait; +use compactor_scheduler::{ + CompactionJob, CompactionJobStatus, CompactionJobStatusResult, CompactionJobStatusVariant, + ErrorKind as SchedulerErrorKind, PartitionDoneSink, Scheduler, +}; use data_types::PartitionId; use crate::error::{DynError, ErrorKind, ErrorKindExt}; -use super::PartitionDoneSink; - #[derive(Debug)] pub struct ErrorKindPartitionDoneSinkWrapper where @@ -14,14 +16,19 @@ where { kind: HashSet, inner: T, + scheduler: Arc, } impl ErrorKindPartitionDoneSinkWrapper where T: PartitionDoneSink, { - pub fn new(inner: T, kind: HashSet) -> Self { - Self { kind, inner } + pub fn new(inner: T, kind: HashSet, scheduler: Arc) -> Self { + Self { + kind, + inner, + scheduler, + } } } @@ -45,6 +52,24 @@ where match res { Ok(()) => self.inner.record(partition, Ok(())).await, Err(e) if self.kind.contains(&e.classify()) => { + let scheduler_error = match SchedulerErrorKind::from(e.classify()) { + SchedulerErrorKind::OutOfMemory => SchedulerErrorKind::OutOfMemory, + SchedulerErrorKind::ObjectStore => SchedulerErrorKind::ObjectStore, + SchedulerErrorKind::Timeout => SchedulerErrorKind::Timeout, + SchedulerErrorKind::Unknown(_) => SchedulerErrorKind::Unknown(e.to_string()), + }; + + match self + .scheduler + .job_status(CompactionJobStatus { + job: CompactionJob::new(partition), + status: CompactionJobStatusVariant::Error(scheduler_error), + }) + .await + { + Ok(CompactionJobStatusResult::Ack) => {} + _ => panic!("unexpected result from scheduler"), + } self.inner.record(partition, Err(e)).await; } _ => {} @@ -56,9 +81,10 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; - use crate::components::partition_done_sink::mock::MockPartitionDoneSink; - + use compactor_scheduler::{create_test_scheduler, MockPartitionDoneSink}; use datafusion::error::DataFusionError; + use iox_tests::TestCatalog; + use iox_time::{MockProvider, Time}; use object_store::Error as ObjectStoreError; use super::*; @@ -68,6 +94,11 @@ mod tests { let sink = ErrorKindPartitionDoneSinkWrapper::new( MockPartitionDoneSink::new(), HashSet::from([ErrorKind::ObjectStore, ErrorKind::OutOfMemory]), + create_test_scheduler( + TestCatalog::new().catalog(), + Arc::new(MockProvider::new(Time::MIN)), + None, + ), ); assert_eq!(sink.to_string(), "kind([ObjectStore, OutOfMemory], mock)"); } @@ -78,6 +109,11 @@ mod tests { let sink = ErrorKindPartitionDoneSinkWrapper::new( Arc::clone(&inner), HashSet::from([ErrorKind::ObjectStore, ErrorKind::OutOfMemory]), + create_test_scheduler( + TestCatalog::new().catalog(), + Arc::new(MockProvider::new(Time::MIN)), + None, + ), ); sink.record( diff --git a/compactor/src/components/partition_done_sink/logging.rs b/compactor/src/components/partition_done_sink/logging.rs index d4649567dc..a9fb53a327 100644 --- a/compactor/src/components/partition_done_sink/logging.rs +++ b/compactor/src/components/partition_done_sink/logging.rs @@ -1,13 +1,12 @@ use std::fmt::Display; use async_trait::async_trait; +use compactor_scheduler::PartitionDoneSink; use data_types::PartitionId; use observability_deps::tracing::{error, info}; use crate::error::{DynError, ErrorKindExt}; -use super::PartitionDoneSink; - #[derive(Debug)] pub struct LoggingPartitionDoneSinkWrapper where @@ -61,11 +60,10 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; + use compactor_scheduler::MockPartitionDoneSink; use object_store::Error as ObjectStoreError; use test_helpers::tracing::TracingCapture; - use crate::components::partition_done_sink::mock::MockPartitionDoneSink; - use super::*; #[test] diff --git a/compactor/src/components/partition_done_sink/metrics.rs b/compactor/src/components/partition_done_sink/metrics.rs index 1999e8e0f4..2a3c0163c4 100644 --- a/compactor/src/components/partition_done_sink/metrics.rs +++ b/compactor/src/components/partition_done_sink/metrics.rs @@ -1,13 +1,12 @@ use std::{collections::HashMap, fmt::Display}; use async_trait::async_trait; +use compactor_scheduler::PartitionDoneSink; use data_types::PartitionId; use metric::{Registry, U64Counter}; use crate::error::{DynError, ErrorKind, ErrorKindExt}; -use super::PartitionDoneSink; - const METRIC_NAME_PARTITION_COMPLETE_COUNT: &str = "iox_compactor_partition_complete_count"; #[derive(Debug)] @@ -83,11 +82,10 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; + use compactor_scheduler::MockPartitionDoneSink; use metric::{assert_counter, Attributes}; use object_store::Error as ObjectStoreError; - use crate::components::partition_done_sink::mock::MockPartitionDoneSink; - use super::*; #[test] diff --git a/compactor/src/components/partition_done_sink/mod.rs b/compactor/src/components/partition_done_sink/mod.rs index 40d1772222..32f5aa961c 100644 --- a/compactor/src/components/partition_done_sink/mod.rs +++ b/compactor/src/components/partition_done_sink/mod.rs @@ -1,34 +1,4 @@ -use std::{ - fmt::{Debug, Display}, - sync::Arc, -}; - -use async_trait::async_trait; -use data_types::PartitionId; - -use crate::error::DynError; - -pub mod catalog; pub mod error_kind; pub mod logging; pub mod metrics; -pub mod mock; - -/// Records "partition is done" status for given partition. -#[async_trait] -pub trait PartitionDoneSink: Debug + Display + Send + Sync { - /// Record "partition is done" status for given partition. - /// - /// This method should retry. - async fn record(&self, partition: PartitionId, res: Result<(), DynError>); -} - -#[async_trait] -impl PartitionDoneSink for Arc -where - T: PartitionDoneSink + ?Sized, -{ - async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { - self.as_ref().record(partition, res).await - } -} +pub mod outcome; diff --git a/compactor/src/components/partition_done_sink/outcome.rs b/compactor/src/components/partition_done_sink/outcome.rs new file mode 100644 index 0000000000..0f88f5c18c --- /dev/null +++ b/compactor/src/components/partition_done_sink/outcome.rs @@ -0,0 +1,49 @@ +use std::{fmt::Display, sync::Arc}; + +use async_trait::async_trait; +use compactor_scheduler::{ + CompactionJob, CompactionJobStatus, CompactionJobStatusResult, CompactionJobStatusVariant, + PartitionDoneSink, Scheduler, SkipReason, +}; +use data_types::PartitionId; + +use crate::DynError; + +#[derive(Debug)] +pub struct PartitionDoneSinkToScheduler { + scheduler: Arc, +} + +impl PartitionDoneSinkToScheduler { + pub fn new(scheduler: Arc) -> Self { + Self { scheduler } + } +} + +impl Display for PartitionDoneSinkToScheduler { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "PartitionDoneSinkToScheduler") + } +} + +#[async_trait] +impl PartitionDoneSink for PartitionDoneSinkToScheduler { + async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { + let mut job_status = CompactionJobStatus { + job: CompactionJob::new(partition), + status: CompactionJobStatusVariant::Complete, + }; + if let Err(e) = res { + job_status = CompactionJobStatus { + job: CompactionJob::new(partition), + status: CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError( + e.to_string(), + )), + }; + }; + match self.scheduler.job_status(job_status).await { + Ok(CompactionJobStatusResult::Ack) => {} + _ => panic!("unexpected result from scheduler"), + } + } +} diff --git a/compactor/src/components/report.rs b/compactor/src/components/report.rs index 0137447c45..d45b2664c1 100644 --- a/compactor/src/components/report.rs +++ b/compactor/src/components/report.rs @@ -32,7 +32,6 @@ pub fn log_config(config: &Config) { min_num_l1_files_to_compact, process_once, parquet_files_sink_override, - commit_wrapper, simulate_without_object_store, all_errors_are_fatal, max_num_columns_per_table, @@ -45,8 +44,6 @@ pub fn log_config(config: &Config) { .map(|_| "Some") .unwrap_or("None"); - let commit_wrapper = commit_wrapper.as_ref().map(|_| "Some").unwrap_or("None"); - info!( %catalog, %scheduler_config, @@ -69,7 +66,6 @@ pub fn log_config(config: &Config) { process_once, simulate_without_object_store, %parquet_files_sink_override, - %commit_wrapper, all_errors_are_fatal, max_num_columns_per_table, max_num_files_per_plan, diff --git a/compactor/src/config.rs b/compactor/src/config.rs index 63a2cf0abe..389ce7e9ac 100644 --- a/compactor/src/config.rs +++ b/compactor/src/config.rs @@ -8,7 +8,7 @@ use iox_query::exec::Executor; use iox_time::TimeProvider; use parquet_file::storage::ParquetStorage; -use crate::components::{commit::CommitWrapper, parquet_files_sink::ParquetFilesSink}; +use crate::components::parquet_files_sink::ParquetFilesSink; /// Multiple from `max_desired_file_size_bytes` to compute the minimum value for /// `max_compact_size_bytes`. Since `max_desired_file_size_bytes` is softly enforced, actual file @@ -119,11 +119,6 @@ pub struct Config { /// (used for testing) pub parquet_files_sink_override: Option>, - /// Optionally wrap the `Commit` instance - /// - /// This is mostly used for testing - pub commit_wrapper: Option>, - /// Ensure that ALL errors (including object store errors) result in "skipped" partitions. /// /// This is mostly useful for testing. diff --git a/compactor/src/error.rs b/compactor/src/error.rs index 3ae7be1b2b..a1d687165b 100644 --- a/compactor/src/error.rs +++ b/compactor/src/error.rs @@ -1,5 +1,6 @@ //! Error handling. +use compactor_scheduler::ErrorKind as SchedulerErrorKind; use datafusion::{arrow::error::ArrowError, error::DataFusionError, parquet::errors::ParquetError}; use object_store::Error as ObjectStoreError; use std::{error::Error, fmt::Display, sync::Arc}; @@ -51,6 +52,17 @@ impl ErrorKind { } } +impl From for SchedulerErrorKind { + fn from(e: ErrorKind) -> Self { + match e { + ErrorKind::ObjectStore => Self::ObjectStore, + ErrorKind::OutOfMemory => Self::OutOfMemory, + ErrorKind::Timeout => Self::Timeout, + ErrorKind::Unknown => Self::Unknown("".into()), + } + } +} + impl Display for ErrorKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.name()) diff --git a/compactor/src/lib.rs b/compactor/src/lib.rs index 711f6118b4..2e46324577 100644 --- a/compactor/src/lib.rs +++ b/compactor/src/lib.rs @@ -221,12 +221,8 @@ mod round_info; // publically expose items needed for testing pub use components::{ - commit::{Commit, CommitWrapper}, - df_planner::panic::PanicDataFusionPlanner, - hardcoded::hardcoded_components, - namespaces_source::mock::NamespaceWrapper, - parquet_files_sink::ParquetFilesSink, - Components, + df_planner::panic::PanicDataFusionPlanner, hardcoded::hardcoded_components, + namespaces_source::mock::NamespaceWrapper, parquet_files_sink::ParquetFilesSink, Components, }; pub use driver::compact; pub use error::DynError; diff --git a/compactor_scheduler/Cargo.toml b/compactor_scheduler/Cargo.toml index 426b5ab1ba..dae3b90adb 100644 --- a/compactor_scheduler/Cargo.toml +++ b/compactor_scheduler/Cargo.toml @@ -9,8 +9,11 @@ license.workspace = true async-trait = "0.1.71" backoff = { path = "../backoff" } data_types = { path = "../data_types" } +futures = "0.3" iox_catalog = { path = "../iox_catalog" } iox_time = { path = "../iox_time" } +itertools = "0.11.0" +metric = { path = "../metric" } observability_deps = { path = "../observability_deps" } sharder = { path = "../sharder" } uuid = { version = "1", features = ["v4"] } @@ -18,4 +21,5 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" } [dev-dependencies] iox_tests = { path = "../iox_tests" } +test_helpers = { path = "../test_helpers"} tokio = { version = "1.29", features = ["macros", "net", "parking_lot", "rt-multi-thread", "signal", "sync", "time"] } diff --git a/compactor/src/components/commit/logging.rs b/compactor_scheduler/src/commit/logging.rs similarity index 97% rename from compactor/src/components/commit/logging.rs rename to compactor_scheduler/src/commit/logging.rs index 0bd1789372..a2d97aed2a 100644 --- a/compactor/src/components/commit/logging.rs +++ b/compactor_scheduler/src/commit/logging.rs @@ -7,7 +7,7 @@ use observability_deps::tracing::info; use super::Commit; #[derive(Debug)] -pub struct LoggingCommitWrapper +pub(crate) struct LoggingCommitWrapper where T: Commit, { @@ -18,7 +18,7 @@ impl LoggingCommitWrapper where T: Commit, { - pub fn new(inner: T) -> Self { + pub(crate) fn new(inner: T) -> Self { Self { inner } } } @@ -83,7 +83,7 @@ mod tests { use test_helpers::tracing::TracingCapture; use super::*; - use crate::components::commit::mock::{CommitHistoryEntry, MockCommit}; + use crate::commit::mock::{CommitHistoryEntry, MockCommit}; use iox_tests::ParquetFileBuilder; #[test] diff --git a/compactor/src/components/commit/metrics.rs b/compactor_scheduler/src/commit/metrics.rs similarity index 98% rename from compactor/src/components/commit/metrics.rs rename to compactor_scheduler/src/commit/metrics.rs index 4a63cec426..37d141aa74 100644 --- a/compactor/src/components/commit/metrics.rs +++ b/compactor_scheduler/src/commit/metrics.rs @@ -102,7 +102,7 @@ impl Histogram { } #[derive(Debug)] -pub struct MetricsCommitWrapper +pub(crate) struct MetricsCommitWrapper where T: Commit, { @@ -124,7 +124,7 @@ impl MetricsCommitWrapper where T: Commit, { - pub fn new(inner: T, registry: &Registry) -> Self { + pub(crate) fn new(inner: T, registry: &Registry) -> Self { Self { file_bytes: Histogram::new( registry, @@ -307,7 +307,7 @@ mod tests { use metric::{assert_histogram, Attributes}; - use crate::components::commit::mock::{CommitHistoryEntry, MockCommit}; + use crate::commit::mock::{CommitHistoryEntry, MockCommit}; use iox_tests::ParquetFileBuilder; use super::*; diff --git a/compactor/src/components/commit/mock.rs b/compactor_scheduler/src/commit/mock.rs similarity index 93% rename from compactor/src/components/commit/mock.rs rename to compactor_scheduler/src/commit/mock.rs index 17a68c33b8..deee3592b3 100644 --- a/compactor/src/components/commit/mock.rs +++ b/compactor_scheduler/src/commit/mock.rs @@ -12,23 +12,23 @@ use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, use super::Commit; #[derive(Debug, PartialEq, Eq, Clone)] -pub struct CommitHistoryEntry { - pub partition_id: PartitionId, - pub delete: Vec, - pub upgrade: Vec, - pub created: Vec, - pub target_level: CompactionLevel, +pub(crate) struct CommitHistoryEntry { + pub(crate) partition_id: PartitionId, + pub(crate) delete: Vec, + pub(crate) upgrade: Vec, + pub(crate) created: Vec, + pub(crate) target_level: CompactionLevel, } -#[derive(Debug)] -pub struct MockCommit { +#[derive(Debug, Default)] +pub(crate) struct MockCommit { history: Mutex>, id_counter: AtomicI64, } impl MockCommit { #[allow(dead_code)] // not used anywhere - pub fn new() -> Self { + pub(crate) fn new() -> Self { Self { history: Default::default(), id_counter: AtomicI64::new(1000), @@ -36,7 +36,7 @@ impl MockCommit { } #[allow(dead_code)] // not used anywhere - pub fn history(&self) -> Vec { + pub(crate) fn history(&self) -> Vec { self.history.lock().expect("not poisoned").clone() } } diff --git a/compactor/src/components/commit/mod.rs b/compactor_scheduler/src/commit/mod.rs similarity index 95% rename from compactor/src/components/commit/mod.rs rename to compactor_scheduler/src/commit/mod.rs index de777ccefd..c1d90a7d1e 100644 --- a/compactor/src/components/commit/mod.rs +++ b/compactor_scheduler/src/commit/mod.rs @@ -6,10 +6,9 @@ use std::{ use async_trait::async_trait; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; -pub mod catalog; -pub mod logging; -pub mod metrics; -pub mod mock; +pub(crate) mod logging; +pub(crate) mod metrics; +pub(crate) mod mock; /// Ensures that the file change (i.e. deletion and creation) are committed to the catalog. #[async_trait] diff --git a/compactor_scheduler/src/error.rs b/compactor_scheduler/src/error.rs new file mode 100644 index 0000000000..7426de087d --- /dev/null +++ b/compactor_scheduler/src/error.rs @@ -0,0 +1,37 @@ +//! Error classification. + +/// What kind of error did we occur during compaction? +#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub enum ErrorKind { + /// Could not access the object store. + ObjectStore, + + /// We ran out of memory (OOM). + OutOfMemory, + + /// Partition took too long. + Timeout, + + /// Unknown/unexpected error. + /// + /// This will likely mark the affected partition as "skipped" and the compactor will no longer touch it. + Unknown(String), +} + +impl ErrorKind { + /// Return static name. + pub fn name(&self) -> &'static str { + match self { + Self::ObjectStore => "object_store", + Self::OutOfMemory => "out_of_memory", + Self::Timeout => "timeout", + Self::Unknown(_) => "unknown", + } + } +} + +impl std::fmt::Display for ErrorKind { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name()) + } +} diff --git a/compactor_scheduler/src/lib.rs b/compactor_scheduler/src/lib.rs index 7d7d35e7d4..1033364fe5 100644 --- a/compactor_scheduler/src/lib.rs +++ b/compactor_scheduler/src/lib.rs @@ -26,16 +26,26 @@ use iox_time::TimeProvider; // Workaround for "unused crate" lint false positives. use workspace_hack as _; +pub(crate) mod commit; +pub(crate) use commit::mock::MockCommit; +pub use commit::{Commit, CommitWrapper}; + +mod error; +pub use error::ErrorKind; + mod local_scheduler; pub(crate) use local_scheduler::{id_only_partition_filter::IdOnlyPartitionFilter, LocalScheduler}; -// configurations used externally during scheduler setup pub use local_scheduler::{ - partitions_source_config::PartitionsSourceConfig, shard_config::ShardConfig, + partition_done_sink::{mock::MockPartitionDoneSink, PartitionDoneSink}, + partitions_source_config::PartitionsSourceConfig, + shard_config::ShardConfig, LocalSchedulerConfig, }; + // partitions_source trait mod partitions_source; pub use partitions_source::*; + // scheduler trait and associated types mod scheduler; pub use scheduler::*; @@ -49,6 +59,8 @@ pub fn create_scheduler( config: SchedulerConfig, catalog: Arc, time_provider: Arc, + metrics: Arc, + shadow_mode: bool, ) -> Arc { match config { SchedulerConfig::Local(scheduler_config) => { @@ -57,6 +69,8 @@ pub fn create_scheduler( BackoffConfig::default(), catalog, time_provider, + metrics, + shadow_mode, ); Arc::new(scheduler) } @@ -75,13 +89,20 @@ pub fn create_test_scheduler( let scheduler_config = match mocked_partition_ids { None => SchedulerConfig::default(), Some(partition_ids) => SchedulerConfig::Local(LocalSchedulerConfig { + commit_wrapper: None, partitions_source_config: PartitionsSourceConfig::Fixed( partition_ids.into_iter().collect::>(), ), shard_config: None, }), }; - create_scheduler(scheduler_config, catalog, time_provider) + create_scheduler( + scheduler_config, + catalog, + time_provider, + Arc::new(metric::Registry::default()), + false, + ) } #[cfg(test)] @@ -111,7 +132,7 @@ mod tests { } #[tokio::test] - async fn test_test_scheduler_with_mocked_parition_ids() { + async fn test_test_scheduler_with_mocked_partition_ids() { let partitions = vec![PartitionId::new(0), PartitionId::new(1234242)]; let scheduler = create_test_scheduler( diff --git a/compactor_scheduler/src/local_scheduler.rs b/compactor_scheduler/src/local_scheduler.rs index 2aa917ef1f..f22d836100 100644 --- a/compactor_scheduler/src/local_scheduler.rs +++ b/compactor_scheduler/src/local_scheduler.rs @@ -1,26 +1,36 @@ //! Internals used by [`LocalScheduler`]. +pub(crate) mod catalog_commit; +pub(crate) mod combos; pub(crate) mod id_only_partition_filter; +pub(crate) mod partition_done_sink; pub(crate) mod partitions_source; pub(crate) mod partitions_source_config; pub(crate) mod shard_config; -use std::sync::Arc; +use std::{sync::Arc, time::Duration}; use async_trait::async_trait; use backoff::BackoffConfig; use iox_catalog::interface::Catalog; use iox_time::TimeProvider; -use observability_deps::tracing::info; +use observability_deps::tracing::{info, warn}; use crate::{ - CompactionJob, MockPartitionsSource, PartitionsSource, PartitionsSourceConfig, Scheduler, - ShardConfig, + commit::{logging::LoggingCommitWrapper, metrics::MetricsCommitWrapper}, + Commit, CommitUpdate, CommitWrapper, CompactionJob, CompactionJobStatus, + CompactionJobStatusResult, CompactionJobStatusVariant, MockCommit, MockPartitionsSource, + PartitionsSource, PartitionsSourceConfig, Scheduler, ShardConfig, SkipReason, }; use self::{ + catalog_commit::CatalogCommit, + combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, id_only_partition_filter::{ and::AndIdOnlyPartitionFilter, shard::ShardPartitionFilter, IdOnlyPartitionFilter, }, + partition_done_sink::{ + catalog::CatalogPartitionDoneSink, mock::MockPartitionDoneSink, PartitionDoneSink, + }, partitions_source::{ catalog_all::CatalogAllPartitionsSource, catalog_to_compact::CatalogToCompactPartitionsSource, @@ -31,6 +41,10 @@ use self::{ /// Configuration specific to the local scheduler. #[derive(Debug, Default, Clone)] pub struct LocalSchedulerConfig { + /// Optionally wrap the `Commit` instance + /// + /// This is mostly used for testing + pub commit_wrapper: Option>, /// The partitions source config used by the local sceduler. pub partitions_source_config: PartitionsSourceConfig, /// The shard config used by the local sceduler. @@ -40,8 +54,14 @@ pub struct LocalSchedulerConfig { /// Implementation of the scheduler for local (per compactor) scheduling. #[derive(Debug)] pub(crate) struct LocalScheduler { + /// Commits changes (i.e. deletion and creation) to the catalog + pub(crate) commit: Arc, /// The partitions source to use for scheduling. partitions_source: Arc, + /// The actions to take when a partition is done. + /// + /// Includes partition (PartitionId) tracking of uniqueness and throttling. + partition_done_sink: Arc, /// The shard config used for generating the PartitionsSource. shard_config: Option, } @@ -53,7 +73,47 @@ impl LocalScheduler { backoff_config: BackoffConfig, catalog: Arc, time_provider: Arc, + metrics: Arc, + shadow_mode: bool, ) -> Self { + let commit = Self::build_commit( + config.clone(), + backoff_config.clone(), + Arc::clone(&catalog), + metrics, + shadow_mode, + ); + + let partitions_source = Self::build_partitions_source( + config.clone(), + backoff_config.clone(), + Arc::clone(&catalog), + Arc::clone(&time_provider), + ); + + let (partitions_source, commit, partition_done_sink) = Self::build_partition_done_sink( + partitions_source, + commit, + backoff_config, + catalog, + time_provider, + shadow_mode, + ); + + Self { + commit, + partitions_source, + partition_done_sink, + shard_config: config.shard_config, + } + } + + fn build_partitions_source( + config: LocalSchedulerConfig, + backoff_config: BackoffConfig, + catalog: Arc, + time_provider: Arc, + ) -> Arc { let shard_config = config.shard_config; let partitions_source: Arc = match &config.partitions_source_config { PartitionsSourceConfig::CatalogRecentWrites { threshold } => { @@ -86,16 +146,75 @@ impl LocalScheduler { shard_config.shard_id, ))); } - let partitions_source: Arc = - Arc::new(FilterPartitionsSourceWrapper::new( - AndIdOnlyPartitionFilter::new(id_only_partition_filters), - partitions_source, - )); - - Self { + Arc::new(FilterPartitionsSourceWrapper::new( + AndIdOnlyPartitionFilter::new(id_only_partition_filters), partitions_source, - shard_config, - } + )) + } + + fn build_partition_done_sink( + partitions_source: Arc, + commit: Arc, + backoff_config: BackoffConfig, + catalog: Arc, + time_provider: Arc, + shadow_mode: bool, + ) -> ( + Arc, + Arc, + Arc, + ) { + let partition_done_sink: Arc = if shadow_mode { + Arc::new(MockPartitionDoneSink::new()) + } else { + Arc::new(CatalogPartitionDoneSink::new( + backoff_config, + Arc::clone(&catalog), + )) + }; + + let (partitions_source, partition_done_sink) = + unique_partitions(partitions_source, partition_done_sink, 1); + + let (partitions_source, commit, partition_done_sink) = throttle_partition( + partitions_source, + commit, + partition_done_sink, + Arc::clone(&time_provider), + Duration::from_secs(60), + 1, + ); + + ( + Arc::new(partitions_source), + Arc::new(commit), + Arc::new(partition_done_sink), + ) + } + + fn build_commit( + config: LocalSchedulerConfig, + backoff_config: BackoffConfig, + catalog: Arc, + metrics_registry: Arc, + shadow_mode: bool, + ) -> Arc { + let commit: Arc = if shadow_mode { + Arc::new(MockCommit::new()) + } else { + Arc::new(CatalogCommit::new(backoff_config, Arc::clone(&catalog))) + }; + + let commit = if let Some(commit_wrapper) = &config.commit_wrapper { + commit_wrapper.wrap(commit) + } else { + commit + }; + + Arc::new(LoggingCommitWrapper::new(MetricsCommitWrapper::new( + commit, + &metrics_registry, + ))) } } @@ -109,6 +228,48 @@ impl Scheduler for LocalScheduler { .map(CompactionJob::new) .collect() } + + async fn job_status( + &self, + job_status: CompactionJobStatus, + ) -> Result> { + match job_status.status { + CompactionJobStatusVariant::Update(commit_update) => { + let CommitUpdate { + partition_id, + delete, + upgrade, + target_level, + create, + } = commit_update; + + let result = self + .commit + .commit(partition_id, &delete, &upgrade, &create, target_level) + .await; + + // verify create commit counts + assert_eq!(result.len(), create.len()); + + Ok(CompactionJobStatusResult::UpdatedParquetFiles(result)) + } + CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError(msg)) => { + self.partition_done_sink + .record(job_status.job.partition_id, Err(msg.into())) + .await; + + Ok(CompactionJobStatusResult::Ack) + } + CompactionJobStatusVariant::Error(error_kind) => { + warn!("Error processing job: {:?}: {}", job_status.job, error_kind); + Ok(CompactionJobStatusResult::Ack) + } + CompactionJobStatusVariant::Complete => { + // TODO: once uuid is handled properly, we can track the job completion + Ok(CompactionJobStatusResult::Ack) + } + } + } } impl std::fmt::Display for LocalScheduler { @@ -122,7 +283,10 @@ impl std::fmt::Display for LocalScheduler { #[cfg(test)] mod tests { - use iox_tests::TestCatalog; + use std::collections::HashSet; + + use data_types::{ColumnType, PartitionId}; + use iox_tests::{ParquetFileBuilder, TestCatalog, TestParquetFile, TestParquetFileBuilder}; use iox_time::{MockProvider, Time}; use super::*; @@ -134,6 +298,8 @@ mod tests { BackoffConfig::default(), TestCatalog::new().catalog(), Arc::new(MockProvider::new(Time::MIN)), + Arc::new(metric::Registry::default()), + false, ); assert_eq!(scheduler.to_string(), "local_compaction_scheduler",); @@ -147,6 +313,7 @@ mod tests { }); let config = LocalSchedulerConfig { + commit_wrapper: None, partitions_source_config: PartitionsSourceConfig::default(), shard_config, }; @@ -156,6 +323,8 @@ mod tests { BackoffConfig::default(), TestCatalog::new().catalog(), Arc::new(MockProvider::new(Time::MIN)), + Arc::new(metric::Registry::default()), + false, ); assert_eq!( @@ -163,4 +332,245 @@ mod tests { "local_compaction_scheduler(shard_cfg(n_shards=2,shard_id=1))", ); } + + async fn create_scheduler_with_partitions() -> (LocalScheduler, TestParquetFile, TestParquetFile) + { + let catalog = TestCatalog::new(); + let ns = catalog.create_namespace_with_retention("ns", None).await; + let table = ns.create_table("table1").await; + table.create_column("time", ColumnType::Time).await; + table.create_column("load", ColumnType::F64).await; + + let partition1 = table.create_partition("k").await; + let partition2 = table.create_partition("k").await; + let partition_ids = vec![partition1.partition.id, partition2.partition.id]; + + // two files on partition1, to be replaced by one compacted file + let file_builder = TestParquetFileBuilder::default().with_line_protocol("table1 load=1 11"); + let file1_1 = partition1.create_parquet_file(file_builder.clone()).await; + let file1_2 = partition1.create_parquet_file(file_builder).await; + + let config = LocalSchedulerConfig { + commit_wrapper: None, + partitions_source_config: PartitionsSourceConfig::Fixed( + partition_ids.into_iter().collect::>(), + ), + shard_config: None, + }; + + let scheduler = LocalScheduler::new( + config, + BackoffConfig::default(), + catalog.catalog(), + Arc::new(MockProvider::new(Time::MIN)), + Arc::new(metric::Registry::default()), + false, + ); + + (scheduler, file1_1, file1_2) + } + + #[tokio::test] + #[should_panic] + async fn test_status_update_none_should_panic() { + test_helpers::maybe_start_logging(); + + let (scheduler, _, _) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + + for job in jobs { + let commit_update = CommitUpdate { + partition_id: job.partition_id, + delete: vec![], + upgrade: vec![], + target_level: data_types::CompactionLevel::Final, + create: vec![], + }; + + let _ = scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Update(commit_update), + }) + .await; + } + } + + #[tokio::test] + async fn test_status_update_replacement() { + test_helpers::maybe_start_logging(); + + let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + let job = jobs + .into_iter() + .find(|job| job.partition_id == existing_1.partition.partition.id) + .unwrap(); + + let created = ParquetFileBuilder::new(1002) + .with_partition(job.partition_id.get()) + .build(); + + let commit_update = CommitUpdate { + partition_id: job.partition_id, + delete: vec![existing_1.into(), existing_2.into()], + upgrade: vec![], + target_level: data_types::CompactionLevel::Final, + create: vec![created.into()], + }; + + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Update(commit_update), + }) + .await + .is_ok()); + } + + #[tokio::test] + #[should_panic] + async fn test_status_update_replacement_args_incomplete() { + test_helpers::maybe_start_logging(); + + let (scheduler, _, _) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + + for job in jobs { + let created_1 = ParquetFileBuilder::new(1002) + .with_partition(job.partition_id.get()) + .build(); + + let commit_update = CommitUpdate { + partition_id: job.partition_id, + delete: vec![], + upgrade: vec![], + target_level: data_types::CompactionLevel::Final, + create: vec![created_1.into()], + }; + + let _ = scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Update(commit_update), + }) + .await; + } + } + + #[tokio::test] + async fn test_status_update_upgrade() { + test_helpers::maybe_start_logging(); + + let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + let job = jobs + .into_iter() + .find(|job| job.partition_id == existing_1.partition.partition.id) + .unwrap(); + + let commit_update = CommitUpdate { + partition_id: job.partition_id, + delete: vec![], + upgrade: vec![existing_1.into(), existing_2.into()], + target_level: data_types::CompactionLevel::Final, + create: vec![], + }; + + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Update(commit_update), + }) + .await + .is_ok()); + } + + #[tokio::test] + async fn test_status_update_can_replace_and_upgrade_at_once() { + test_helpers::maybe_start_logging(); + + let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + let job = jobs + .into_iter() + .find(|job| job.partition_id == existing_1.partition.partition.id) + .unwrap(); + + let created = ParquetFileBuilder::new(1002) + .with_partition(job.partition_id.get()) + .build(); + + let commit_update = CommitUpdate { + partition_id: job.partition_id, + delete: vec![existing_1.into()], + upgrade: vec![existing_2.into()], + target_level: data_types::CompactionLevel::Final, + create: vec![created.into()], + }; + + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Update(commit_update), + }) + .await + .is_ok()); + } + + #[tokio::test] + async fn test_status_skip() { + test_helpers::maybe_start_logging(); + + let (scheduler, _, _) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + + for job in jobs { + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError( + "some error".into() + )), + }) + .await + .is_ok()); + } + } + + #[tokio::test] + async fn test_status_error() { + test_helpers::maybe_start_logging(); + + let (scheduler, _, _) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + + for job in jobs { + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Error(crate::ErrorKind::OutOfMemory), + }) + .await + .is_ok()); + } + } + + #[tokio::test] + async fn test_status_complete() { + test_helpers::maybe_start_logging(); + + let (scheduler, _, _) = create_scheduler_with_partitions().await; + let jobs = scheduler.get_jobs().await; + + for job in jobs { + assert!(scheduler + .job_status(CompactionJobStatus { + job, + status: CompactionJobStatusVariant::Complete, + }) + .await + .is_ok()); + } + } } diff --git a/compactor/src/components/commit/catalog.rs b/compactor_scheduler/src/local_scheduler/catalog_commit.rs similarity index 91% rename from compactor/src/components/commit/catalog.rs rename to compactor_scheduler/src/local_scheduler/catalog_commit.rs index 97d9eb1415..d71474610d 100644 --- a/compactor/src/components/commit/catalog.rs +++ b/compactor_scheduler/src/local_scheduler/catalog_commit.rs @@ -5,16 +5,16 @@ use backoff::{Backoff, BackoffConfig}; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use iox_catalog::interface::Catalog; -use super::Commit; +use crate::Commit; #[derive(Debug)] -pub struct CatalogCommit { +pub(crate) struct CatalogCommit { backoff_config: BackoffConfig, catalog: Arc, } impl CatalogCommit { - pub fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { + pub(crate) fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { Self { backoff_config, catalog, diff --git a/compactor/src/components/combos/mod.rs b/compactor_scheduler/src/local_scheduler/combos/mod.rs similarity index 59% rename from compactor/src/components/combos/mod.rs rename to compactor_scheduler/src/local_scheduler/combos/mod.rs index efaf6439ec..b52a36ef14 100644 --- a/compactor/src/components/combos/mod.rs +++ b/compactor_scheduler/src/local_scheduler/combos/mod.rs @@ -1,7 +1,7 @@ //! Combinations of multiple components that together can achieve one goal. -pub mod throttle_partition; -pub mod unique_partitions; +pub(crate) mod throttle_partition; +pub(crate) mod unique_partitions; #[cfg(test)] mod tests; diff --git a/compactor/src/components/combos/tests.rs b/compactor_scheduler/src/local_scheduler/combos/tests.rs similarity index 84% rename from compactor/src/components/combos/tests.rs rename to compactor_scheduler/src/local_scheduler/combos/tests.rs index bf5d3cafb1..4c52070997 100644 --- a/compactor/src/components/combos/tests.rs +++ b/compactor_scheduler/src/local_scheduler/combos/tests.rs @@ -1,15 +1,15 @@ use std::{sync::Arc, time::Duration}; -use compactor_scheduler::{MockPartitionsSource, PartitionsSource}; use data_types::{CompactionLevel, PartitionId}; use iox_time::{MockProvider, Time}; -use crate::components::{ - combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, - commit::{mock::MockCommit, Commit}, - partition_done_sink::{mock::MockPartitionDoneSink, PartitionDoneSink}, +use crate::{ + Commit, MockCommit, MockPartitionDoneSink, MockPartitionsSource, PartitionDoneSink, + PartitionsSource, }; +use super::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}; + #[tokio::test] async fn test_unique_and_throttle() { let inner_source = Arc::new(MockPartitionsSource::new(vec![ diff --git a/compactor/src/components/combos/throttle_partition.rs b/compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs similarity index 96% rename from compactor/src/components/combos/throttle_partition.rs rename to compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs index d108807a1e..624a1f5532 100644 --- a/compactor/src/components/combos/throttle_partition.rs +++ b/compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs @@ -8,12 +8,11 @@ use std::{ }; use async_trait::async_trait; -use compactor_scheduler::PartitionsSource; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use futures::StreamExt; use iox_time::{Time, TimeProvider}; -use crate::components::{commit::Commit, partition_done_sink::PartitionDoneSink}; +use crate::{Commit, PartitionDoneSink, PartitionsSource}; /// Ensures that partitions that do not receive any commits are throttled. /// @@ -54,8 +53,8 @@ use crate::components::{commit::Commit, partition_done_sink::PartitionDoneSink}; /// concurrency of this bypass can be controlled via `bypass_concurrency`. /// /// This setup relies on a fact that it does not process duplicate [`PartitionId`]. You may use -/// [`unique_partitions`](crate::components::combos::unique_partitions::unique_partitions) to achieve that. -pub fn throttle_partition( +/// [`unique_partitions`](super::unique_partitions::unique_partitions) to achieve that. +pub(crate) fn throttle_partition( source: T1, commit: T2, sink: T3, @@ -107,7 +106,7 @@ struct State { type SharedState = Arc>; #[derive(Debug)] -pub struct ThrottlePartitionsSourceWrapper +pub(crate) struct ThrottlePartitionsSourceWrapper where T1: PartitionsSource, T2: PartitionDoneSink, @@ -188,7 +187,7 @@ where } #[derive(Debug)] -pub struct ThrottleCommitWrapper +pub(crate) struct ThrottleCommitWrapper where T: Commit, { @@ -241,7 +240,7 @@ where } #[derive(Debug)] -pub struct ThrottlePartitionDoneSinkWrapper +pub(crate) struct ThrottlePartitionDoneSinkWrapper where T: PartitionDoneSink, { @@ -296,12 +295,10 @@ where #[cfg(test)] mod tests { - use compactor_scheduler::MockPartitionsSource; use iox_time::MockProvider; - use crate::components::{ - commit::mock::{CommitHistoryEntry, MockCommit}, - partition_done_sink::mock::MockPartitionDoneSink, + use crate::{ + commit::mock::CommitHistoryEntry, MockCommit, MockPartitionDoneSink, MockPartitionsSource, }; use super::*; diff --git a/compactor/src/components/combos/unique_partitions.rs b/compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs similarity index 95% rename from compactor/src/components/combos/unique_partitions.rs rename to compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs index 747fd3b512..3220645dfe 100644 --- a/compactor/src/components/combos/unique_partitions.rs +++ b/compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs @@ -7,11 +7,10 @@ use std::{ }; use async_trait::async_trait; -use compactor_scheduler::PartitionsSource; use data_types::PartitionId; use futures::StreamExt; -use crate::components::partition_done_sink::PartitionDoneSink; +use crate::{PartitionDoneSink, PartitionsSource}; /// Ensures that a unique set of partitions is flowing through the critical section of the compactor pipeline. /// @@ -32,7 +31,7 @@ use crate::components::partition_done_sink::PartitionDoneSink; /// /// | Step | Name | Type | Description | /// | ---- | --------------------- | ----------------------------------------------------------- | ----------- | -/// | 1 | **Actual source** | `inner_source`/`T1`/[`PartitionsSource`], wrapped | This is the actual source, e.g. a [schedule](crate::components::partitions_source::scheduled::ScheduledPartitionsSource) | +/// | 1 | **Actual source** | `inner_source`/`T1`/[`PartitionsSource`], wrapped | This is the actual source, e.g. a [schedule](crate::PartitionsSource) | /// | 2 | **Unique IDs source** | [`UniquePartionsSourceWrapper`], wraps `inner_source`/`T1` | Outputs that [`PartitionId`]s from the `inner_source` but filters out partitions that have not yet reached the uniqueness sink (step 4) | /// | 3 | **Critical section** | -- | Here it is always ensured that a single [`PartitionId`] does NOT occur more than once. | /// | 4 | **Unique IDs sink** | [`UniquePartitionDoneSinkWrapper`], wraps `inner_sink`/`T2` | Observes incoming IDs and removes them from the filter applied in step 2. | @@ -41,7 +40,7 @@ use crate::components::partition_done_sink::PartitionDoneSink; /// Note that partitions filtered out by [`UniquePartionsSourceWrapper`] will directly be forwarded to `inner_sink`. No /// partition is ever lost. This means that `inner_source` and `inner_sink` can perform proper accounting. The /// concurrency of this bypass can be controlled via `bypass_concurrency`. -pub fn unique_partitions( +pub(crate) fn unique_partitions( inner_source: T1, inner_sink: T2, bypass_concurrency: usize, @@ -71,7 +70,7 @@ where type InFlight = Arc>>; #[derive(Debug)] -pub struct UniquePartionsSourceWrapper +pub(crate) struct UniquePartionsSourceWrapper where T1: PartitionsSource, T2: PartitionDoneSink, @@ -128,7 +127,7 @@ where } #[derive(Debug)] -pub struct UniquePartitionDoneSinkWrapper +pub(crate) struct UniquePartitionDoneSinkWrapper where T: PartitionDoneSink, { @@ -180,9 +179,7 @@ where mod tests { use std::collections::HashMap; - use compactor_scheduler::MockPartitionsSource; - - use crate::components::partition_done_sink::mock::MockPartitionDoneSink; + use crate::{MockPartitionDoneSink, MockPartitionsSource}; use super::*; diff --git a/compactor/src/components/partition_done_sink/catalog.rs b/compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs similarity index 88% rename from compactor/src/components/partition_done_sink/catalog.rs rename to compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs index ab384d0ac0..4172391ec7 100644 --- a/compactor/src/components/partition_done_sink/catalog.rs +++ b/compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs @@ -5,18 +5,16 @@ use backoff::{Backoff, BackoffConfig}; use data_types::PartitionId; use iox_catalog::interface::Catalog; -use crate::error::DynError; - -use super::PartitionDoneSink; +use super::{DynError, PartitionDoneSink}; #[derive(Debug)] -pub struct CatalogPartitionDoneSink { +pub(crate) struct CatalogPartitionDoneSink { backoff_config: BackoffConfig, catalog: Arc, } impl CatalogPartitionDoneSink { - pub fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { + pub(crate) fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { Self { backoff_config, catalog, diff --git a/compactor/src/components/partition_done_sink/mock.rs b/compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs similarity index 92% rename from compactor/src/components/partition_done_sink/mock.rs rename to compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs index b906a8b520..29673f579e 100644 --- a/compactor/src/components/partition_done_sink/mock.rs +++ b/compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs @@ -3,21 +3,21 @@ use std::{collections::HashMap, fmt::Display, sync::Mutex}; use async_trait::async_trait; use data_types::PartitionId; -use crate::error::DynError; - -use super::PartitionDoneSink; +use super::{DynError, PartitionDoneSink}; +/// Mock for [`PartitionDoneSink`]. #[derive(Debug, Default)] pub struct MockPartitionDoneSink { last: Mutex>>, } impl MockPartitionDoneSink { + /// Create new mock. pub fn new() -> Self { Self::default() } - #[allow(dead_code)] // not used anywhere + /// Get the last recorded results. pub fn results(&self) -> HashMap> { self.last.lock().expect("not poisoned").clone() } diff --git a/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs b/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs new file mode 100644 index 0000000000..2bc87c4a0f --- /dev/null +++ b/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs @@ -0,0 +1,32 @@ +pub(crate) mod catalog; +pub(crate) mod mock; + +use std::{ + fmt::{Debug, Display}, + sync::Arc, +}; + +use async_trait::async_trait; +use data_types::PartitionId; + +/// Dynamic error type that is used throughout the stack. +pub(crate) type DynError = Box; + +/// Records "partition is done" status for given partition. +#[async_trait] +pub trait PartitionDoneSink: Debug + Display + Send + Sync { + /// Record "partition is done" status for given partition. + /// + /// This method should retry. + async fn record(&self, partition: PartitionId, res: Result<(), DynError>); +} + +#[async_trait] +impl PartitionDoneSink for Arc +where + T: PartitionDoneSink + ?Sized, +{ + async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { + self.as_ref().record(partition, res).await + } +} diff --git a/compactor_scheduler/src/scheduler.rs b/compactor_scheduler/src/scheduler.rs index 13f5b8355d..eaaa17b881 100644 --- a/compactor_scheduler/src/scheduler.rs +++ b/compactor_scheduler/src/scheduler.rs @@ -1,10 +1,13 @@ -use std::fmt::{Debug, Display}; +use std::{ + fmt::{Debug, Display}, + sync::Arc, +}; use async_trait::async_trait; -use data_types::PartitionId; +use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use uuid::Uuid; -use crate::LocalSchedulerConfig; +use crate::{CommitWrapper, ErrorKind, LocalSchedulerConfig, PartitionsSourceConfig}; /// Scheduler configuration. #[derive(Debug, Clone)] @@ -13,6 +16,19 @@ pub enum SchedulerConfig { Local(LocalSchedulerConfig), } +impl SchedulerConfig { + /// Create new [`LocalScheduler`](crate::LocalScheduler) config with a [`CommitWrapper`]. + /// + /// This is useful for testing. + pub fn new_local_with_wrapper(commit_wrapper: Arc) -> Self { + Self::Local(LocalSchedulerConfig { + shard_config: None, + partitions_source_config: PartitionsSourceConfig::default(), + commit_wrapper: Some(commit_wrapper), + }) + } +} + impl Default for SchedulerConfig { fn default() -> Self { Self::Local(LocalSchedulerConfig::default()) @@ -23,11 +39,21 @@ impl std::fmt::Display for SchedulerConfig { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { SchedulerConfig::Local(LocalSchedulerConfig { + commit_wrapper, shard_config, partitions_source_config: _, - }) => match &shard_config { - None => write!(f, "local_compaction_scheduler"), - Some(shard_config) => write!(f, "local_compaction_scheduler({shard_config})",), + }) => match (&shard_config, commit_wrapper) { + (None, None) => write!(f, "local_compaction_scheduler_cfg"), + (Some(shard_config), None) => { + write!(f, "local_compaction_scheduler_cfg({shard_config})",) + } + (Some(shard_config), Some(_)) => write!( + f, + "local_compaction_scheduler_cfg({shard_config},commit_wrapper=Some)", + ), + (None, Some(_)) => { + write!(f, "local_compaction_scheduler_cfg(commit_wrapper=Some)",) + } }, } } @@ -54,9 +80,115 @@ impl CompactionJob { } } +/// Commit update for a given partition. +#[derive(Debug)] +pub struct CommitUpdate { + /// Partition to be updated. + pub(crate) partition_id: PartitionId, + /// Files to be deleted. + pub(crate) delete: Vec, + /// Files to be upgraded. + pub(crate) upgrade: Vec, + /// Target level for upgraded files. + pub(crate) target_level: CompactionLevel, + /// Files to be created. + pub(crate) create: Vec, +} + +impl CommitUpdate { + /// Create new commit update. + pub fn new( + partition_id: PartitionId, + delete: Vec, + upgrade: Vec, + create: Vec, + target_level: CompactionLevel, + ) -> Self { + Self { + partition_id, + delete, + upgrade, + target_level, + create, + } + } +} + +/// Reason for skipping a partition. +#[derive(Debug)] +pub enum SkipReason { + /// Partition is not compactible, due to an encountered error. + CompactionError(String), +} + +/// Status. +#[derive(Debug)] +pub enum CompactionJobStatusVariant { + /// Updates associated with ongoing compaction job. + Update(CommitUpdate), + /// Request to skip partition. + RequestToSkip(SkipReason), + /// Compaction job is complete. + Complete, + /// Compaction job has failed. + Error(ErrorKind), +} + +/// Status ([`CompactionJobStatusVariant`]) associated with a [`CompactionJob`]. +#[derive(Debug)] +pub struct CompactionJobStatus { + /// Job. + pub job: CompactionJob, + /// Status. + pub status: CompactionJobStatusVariant, +} + +/// Status of a compaction job. +#[derive(Debug)] +pub enum CompactionJobStatusResult { + /// Ack only. + Ack, + /// Updates which were processed. + UpdatedParquetFiles(Vec), +} + /// Core trait used for all schedulers. #[async_trait] pub trait Scheduler: Send + Sync + Debug + Display { /// Get partitions to be compacted. async fn get_jobs(&self) -> Vec; + + /// Update job status. + async fn job_status( + &self, + job_status: CompactionJobStatus, + ) -> Result>; +} + +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use crate::Commit; + + use super::*; + + #[test] + fn test_cfg_display_new_local_with_wrapper() { + #[derive(Debug)] + struct MockCommitWrapper; + + impl CommitWrapper for MockCommitWrapper { + fn wrap(&self, commit: Arc) -> Arc { + commit + } + } + + let config = SchedulerConfig::new_local_with_wrapper(Arc::new(MockCommitWrapper)); + + assert_eq!( + config.to_string(), + "local_compaction_scheduler_cfg(commit_wrapper=Some)" + ); + } } diff --git a/compactor_test_utils/src/commit_wrapper.rs b/compactor_test_utils/src/commit_wrapper.rs index 388c62fb5c..9fd8b3d53c 100644 --- a/compactor_test_utils/src/commit_wrapper.rs +++ b/compactor_test_utils/src/commit_wrapper.rs @@ -1,7 +1,7 @@ //! Handles recording commit information to the test run log use async_trait::async_trait; -use compactor::{Commit, CommitWrapper}; +use compactor_scheduler::{Commit, CommitWrapper}; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use std::{ fmt::{Debug, Display}, diff --git a/compactor_test_utils/src/lib.rs b/compactor_test_utils/src/lib.rs index c0be0b889d..0001bc8e26 100644 --- a/compactor_test_utils/src/lib.rs +++ b/compactor_test_utils/src/lib.rs @@ -121,7 +121,7 @@ impl TestSetupBuilder { let config = Config { metric_registry: catalog.metric_registry(), catalog: catalog.catalog(), - scheduler_config: SchedulerConfig::default(), + scheduler_config: SchedulerConfig::new_local_with_wrapper(Arc::new(commit_wrapper)), parquet_store_real: catalog.parquet_store.clone(), parquet_store_scratchpad: ParquetStorage::new( Arc::new(object_store::memory::InMemory::new()), @@ -144,7 +144,6 @@ impl TestSetupBuilder { process_once: true, simulate_without_object_store: false, parquet_files_sink_override: None, - commit_wrapper: Some(Arc::new(commit_wrapper)), all_errors_are_fatal: true, max_num_columns_per_table: 200, max_num_files_per_plan: 200, diff --git a/ioxd_compactor/src/lib.rs b/ioxd_compactor/src/lib.rs index 1ed4cdfe3d..513e69c590 100644 --- a/ioxd_compactor/src/lib.rs +++ b/ioxd_compactor/src/lib.rs @@ -184,7 +184,6 @@ pub async fn create_compactor_server_type( process_once: compactor_config.process_once, simulate_without_object_store: false, parquet_files_sink_override: None, - commit_wrapper: None, all_errors_are_fatal: false, max_num_columns_per_table: compactor_config.max_num_columns_per_table, max_num_files_per_plan: compactor_config.max_num_files_per_plan, diff --git a/ioxd_compactor/src/scheduler_config.rs b/ioxd_compactor/src/scheduler_config.rs index ca3156d942..3be3eda2e3 100644 --- a/ioxd_compactor/src/scheduler_config.rs +++ b/ioxd_compactor/src/scheduler_config.rs @@ -66,6 +66,7 @@ fn convert_shard_config(config: ShardConfigForLocalScheduler) -> Option SchedulerConfig { match config.compactor_scheduler_type { CompactorSchedulerType::Local => SchedulerConfig::Local(LocalSchedulerConfig { + commit_wrapper: None, partitions_source_config: convert_partitions_source_config( config.partition_source_config, ), From d43300635ef8ca625a78cdbfde89fb8aa4e0d70b Mon Sep 17 00:00:00 2001 From: wiedld Date: Tue, 11 Jul 2023 10:33:56 -0700 Subject: [PATCH 27/37] Revert "feat(idpe-17789): scheduler job_status() (#8202)" (#8213) This reverts commit 3dabccd84bac95740c5e44be6defdc32e3937290. --- Cargo.lock | 4 - .../src/components}/combos/mod.rs | 4 +- .../src/components}/combos/tests.rs | 10 +- .../components}/combos/throttle_partition.rs | 19 +- .../components}/combos/unique_partitions.rs | 15 +- compactor/src/components/commit.rs | 55 --- .../src/components/commit/catalog.rs | 6 +- .../src/components}/commit/logging.rs | 6 +- .../src/components}/commit/metrics.rs | 6 +- .../src/components}/commit/mock.rs | 20 +- .../src/components}/commit/mod.rs | 7 +- compactor/src/components/hardcoded.rs | 65 ++- compactor/src/components/mod.rs | 14 +- .../partition_done_sink/catalog.rs | 8 +- .../partition_done_sink/error_kind.rs | 50 +- .../components/partition_done_sink/logging.rs | 6 +- .../components/partition_done_sink/metrics.rs | 6 +- .../components}/partition_done_sink/mock.rs | 8 +- .../src/components/partition_done_sink/mod.rs | 32 +- .../components/partition_done_sink/outcome.rs | 49 -- compactor/src/components/report.rs | 4 + compactor/src/config.rs | 7 +- compactor/src/error.rs | 12 - compactor/src/lib.rs | 8 +- compactor_scheduler/Cargo.toml | 4 - compactor_scheduler/src/error.rs | 37 -- compactor_scheduler/src/lib.rs | 29 +- compactor_scheduler/src/local_scheduler.rs | 438 +----------------- .../partition_done_sink/mod.rs | 32 -- compactor_scheduler/src/scheduler.rs | 144 +----- compactor_test_utils/src/commit_wrapper.rs | 2 +- compactor_test_utils/src/lib.rs | 3 +- ioxd_compactor/src/lib.rs | 1 + ioxd_compactor/src/scheduler_config.rs | 1 - 34 files changed, 206 insertions(+), 906 deletions(-) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/combos/mod.rs (59%) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/combos/tests.rs (84%) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/combos/throttle_partition.rs (96%) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/combos/unique_partitions.rs (95%) delete mode 100644 compactor/src/components/commit.rs rename compactor_scheduler/src/local_scheduler/catalog_commit.rs => compactor/src/components/commit/catalog.rs (91%) rename {compactor_scheduler/src => compactor/src/components}/commit/logging.rs (97%) rename {compactor_scheduler/src => compactor/src/components}/commit/metrics.rs (98%) rename {compactor_scheduler/src => compactor/src/components}/commit/mock.rs (93%) rename {compactor_scheduler/src => compactor/src/components}/commit/mod.rs (95%) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/partition_done_sink/catalog.rs (88%) rename {compactor_scheduler/src/local_scheduler => compactor/src/components}/partition_done_sink/mock.rs (92%) delete mode 100644 compactor/src/components/partition_done_sink/outcome.rs delete mode 100644 compactor_scheduler/src/error.rs delete mode 100644 compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 5d27b0f6e0..660dd90e99 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1001,15 +1001,11 @@ dependencies = [ "async-trait", "backoff", "data_types", - "futures", "iox_catalog", "iox_tests", "iox_time", - "itertools 0.11.0", - "metric", "observability_deps", "sharder", - "test_helpers", "tokio", "uuid", "workspace-hack", diff --git a/compactor_scheduler/src/local_scheduler/combos/mod.rs b/compactor/src/components/combos/mod.rs similarity index 59% rename from compactor_scheduler/src/local_scheduler/combos/mod.rs rename to compactor/src/components/combos/mod.rs index b52a36ef14..efaf6439ec 100644 --- a/compactor_scheduler/src/local_scheduler/combos/mod.rs +++ b/compactor/src/components/combos/mod.rs @@ -1,7 +1,7 @@ //! Combinations of multiple components that together can achieve one goal. -pub(crate) mod throttle_partition; -pub(crate) mod unique_partitions; +pub mod throttle_partition; +pub mod unique_partitions; #[cfg(test)] mod tests; diff --git a/compactor_scheduler/src/local_scheduler/combos/tests.rs b/compactor/src/components/combos/tests.rs similarity index 84% rename from compactor_scheduler/src/local_scheduler/combos/tests.rs rename to compactor/src/components/combos/tests.rs index 4c52070997..bf5d3cafb1 100644 --- a/compactor_scheduler/src/local_scheduler/combos/tests.rs +++ b/compactor/src/components/combos/tests.rs @@ -1,15 +1,15 @@ use std::{sync::Arc, time::Duration}; +use compactor_scheduler::{MockPartitionsSource, PartitionsSource}; use data_types::{CompactionLevel, PartitionId}; use iox_time::{MockProvider, Time}; -use crate::{ - Commit, MockCommit, MockPartitionDoneSink, MockPartitionsSource, PartitionDoneSink, - PartitionsSource, +use crate::components::{ + combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, + commit::{mock::MockCommit, Commit}, + partition_done_sink::{mock::MockPartitionDoneSink, PartitionDoneSink}, }; -use super::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}; - #[tokio::test] async fn test_unique_and_throttle() { let inner_source = Arc::new(MockPartitionsSource::new(vec![ diff --git a/compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs b/compactor/src/components/combos/throttle_partition.rs similarity index 96% rename from compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs rename to compactor/src/components/combos/throttle_partition.rs index 624a1f5532..d108807a1e 100644 --- a/compactor_scheduler/src/local_scheduler/combos/throttle_partition.rs +++ b/compactor/src/components/combos/throttle_partition.rs @@ -8,11 +8,12 @@ use std::{ }; use async_trait::async_trait; +use compactor_scheduler::PartitionsSource; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use futures::StreamExt; use iox_time::{Time, TimeProvider}; -use crate::{Commit, PartitionDoneSink, PartitionsSource}; +use crate::components::{commit::Commit, partition_done_sink::PartitionDoneSink}; /// Ensures that partitions that do not receive any commits are throttled. /// @@ -53,8 +54,8 @@ use crate::{Commit, PartitionDoneSink, PartitionsSource}; /// concurrency of this bypass can be controlled via `bypass_concurrency`. /// /// This setup relies on a fact that it does not process duplicate [`PartitionId`]. You may use -/// [`unique_partitions`](super::unique_partitions::unique_partitions) to achieve that. -pub(crate) fn throttle_partition( +/// [`unique_partitions`](crate::components::combos::unique_partitions::unique_partitions) to achieve that. +pub fn throttle_partition( source: T1, commit: T2, sink: T3, @@ -106,7 +107,7 @@ struct State { type SharedState = Arc>; #[derive(Debug)] -pub(crate) struct ThrottlePartitionsSourceWrapper +pub struct ThrottlePartitionsSourceWrapper where T1: PartitionsSource, T2: PartitionDoneSink, @@ -187,7 +188,7 @@ where } #[derive(Debug)] -pub(crate) struct ThrottleCommitWrapper +pub struct ThrottleCommitWrapper where T: Commit, { @@ -240,7 +241,7 @@ where } #[derive(Debug)] -pub(crate) struct ThrottlePartitionDoneSinkWrapper +pub struct ThrottlePartitionDoneSinkWrapper where T: PartitionDoneSink, { @@ -295,10 +296,12 @@ where #[cfg(test)] mod tests { + use compactor_scheduler::MockPartitionsSource; use iox_time::MockProvider; - use crate::{ - commit::mock::CommitHistoryEntry, MockCommit, MockPartitionDoneSink, MockPartitionsSource, + use crate::components::{ + commit::mock::{CommitHistoryEntry, MockCommit}, + partition_done_sink::mock::MockPartitionDoneSink, }; use super::*; diff --git a/compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs b/compactor/src/components/combos/unique_partitions.rs similarity index 95% rename from compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs rename to compactor/src/components/combos/unique_partitions.rs index 3220645dfe..747fd3b512 100644 --- a/compactor_scheduler/src/local_scheduler/combos/unique_partitions.rs +++ b/compactor/src/components/combos/unique_partitions.rs @@ -7,10 +7,11 @@ use std::{ }; use async_trait::async_trait; +use compactor_scheduler::PartitionsSource; use data_types::PartitionId; use futures::StreamExt; -use crate::{PartitionDoneSink, PartitionsSource}; +use crate::components::partition_done_sink::PartitionDoneSink; /// Ensures that a unique set of partitions is flowing through the critical section of the compactor pipeline. /// @@ -31,7 +32,7 @@ use crate::{PartitionDoneSink, PartitionsSource}; /// /// | Step | Name | Type | Description | /// | ---- | --------------------- | ----------------------------------------------------------- | ----------- | -/// | 1 | **Actual source** | `inner_source`/`T1`/[`PartitionsSource`], wrapped | This is the actual source, e.g. a [schedule](crate::PartitionsSource) | +/// | 1 | **Actual source** | `inner_source`/`T1`/[`PartitionsSource`], wrapped | This is the actual source, e.g. a [schedule](crate::components::partitions_source::scheduled::ScheduledPartitionsSource) | /// | 2 | **Unique IDs source** | [`UniquePartionsSourceWrapper`], wraps `inner_source`/`T1` | Outputs that [`PartitionId`]s from the `inner_source` but filters out partitions that have not yet reached the uniqueness sink (step 4) | /// | 3 | **Critical section** | -- | Here it is always ensured that a single [`PartitionId`] does NOT occur more than once. | /// | 4 | **Unique IDs sink** | [`UniquePartitionDoneSinkWrapper`], wraps `inner_sink`/`T2` | Observes incoming IDs and removes them from the filter applied in step 2. | @@ -40,7 +41,7 @@ use crate::{PartitionDoneSink, PartitionsSource}; /// Note that partitions filtered out by [`UniquePartionsSourceWrapper`] will directly be forwarded to `inner_sink`. No /// partition is ever lost. This means that `inner_source` and `inner_sink` can perform proper accounting. The /// concurrency of this bypass can be controlled via `bypass_concurrency`. -pub(crate) fn unique_partitions( +pub fn unique_partitions( inner_source: T1, inner_sink: T2, bypass_concurrency: usize, @@ -70,7 +71,7 @@ where type InFlight = Arc>>; #[derive(Debug)] -pub(crate) struct UniquePartionsSourceWrapper +pub struct UniquePartionsSourceWrapper where T1: PartitionsSource, T2: PartitionDoneSink, @@ -127,7 +128,7 @@ where } #[derive(Debug)] -pub(crate) struct UniquePartitionDoneSinkWrapper +pub struct UniquePartitionDoneSinkWrapper where T: PartitionDoneSink, { @@ -179,7 +180,9 @@ where mod tests { use std::collections::HashMap; - use crate::{MockPartitionDoneSink, MockPartitionsSource}; + use compactor_scheduler::MockPartitionsSource; + + use crate::components::partition_done_sink::mock::MockPartitionDoneSink; use super::*; diff --git a/compactor/src/components/commit.rs b/compactor/src/components/commit.rs deleted file mode 100644 index 67ad62d5f0..0000000000 --- a/compactor/src/components/commit.rs +++ /dev/null @@ -1,55 +0,0 @@ -use std::sync::Arc; - -use async_trait::async_trait; -use compactor_scheduler::{ - Commit, CommitUpdate, CompactionJob, CompactionJobStatus, CompactionJobStatusResult, - CompactionJobStatusVariant, Scheduler, -}; -use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; - -#[derive(Debug)] -pub(crate) struct CommitToScheduler { - scheduler: Arc, -} - -impl CommitToScheduler { - pub(crate) fn new(scheduler: Arc) -> Self { - Self { scheduler } - } -} - -#[async_trait] -impl Commit for CommitToScheduler { - async fn commit( - &self, - partition_id: PartitionId, - delete: &[ParquetFile], - upgrade: &[ParquetFile], - create: &[ParquetFileParams], - target_level: CompactionLevel, - ) -> Vec { - match self - .scheduler - .job_status(CompactionJobStatus { - job: CompactionJob::new(partition_id), - status: CompactionJobStatusVariant::Update(CommitUpdate::new( - partition_id, - delete.into(), - upgrade.into(), - create.into(), - target_level, - )), - }) - .await - { - Ok(CompactionJobStatusResult::UpdatedParquetFiles(ids)) => ids, - _ => panic!("commit failed"), - } - } -} - -impl std::fmt::Display for CommitToScheduler { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "CommitToScheduler") - } -} diff --git a/compactor_scheduler/src/local_scheduler/catalog_commit.rs b/compactor/src/components/commit/catalog.rs similarity index 91% rename from compactor_scheduler/src/local_scheduler/catalog_commit.rs rename to compactor/src/components/commit/catalog.rs index d71474610d..97d9eb1415 100644 --- a/compactor_scheduler/src/local_scheduler/catalog_commit.rs +++ b/compactor/src/components/commit/catalog.rs @@ -5,16 +5,16 @@ use backoff::{Backoff, BackoffConfig}; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use iox_catalog::interface::Catalog; -use crate::Commit; +use super::Commit; #[derive(Debug)] -pub(crate) struct CatalogCommit { +pub struct CatalogCommit { backoff_config: BackoffConfig, catalog: Arc, } impl CatalogCommit { - pub(crate) fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { + pub fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { Self { backoff_config, catalog, diff --git a/compactor_scheduler/src/commit/logging.rs b/compactor/src/components/commit/logging.rs similarity index 97% rename from compactor_scheduler/src/commit/logging.rs rename to compactor/src/components/commit/logging.rs index a2d97aed2a..0bd1789372 100644 --- a/compactor_scheduler/src/commit/logging.rs +++ b/compactor/src/components/commit/logging.rs @@ -7,7 +7,7 @@ use observability_deps::tracing::info; use super::Commit; #[derive(Debug)] -pub(crate) struct LoggingCommitWrapper +pub struct LoggingCommitWrapper where T: Commit, { @@ -18,7 +18,7 @@ impl LoggingCommitWrapper where T: Commit, { - pub(crate) fn new(inner: T) -> Self { + pub fn new(inner: T) -> Self { Self { inner } } } @@ -83,7 +83,7 @@ mod tests { use test_helpers::tracing::TracingCapture; use super::*; - use crate::commit::mock::{CommitHistoryEntry, MockCommit}; + use crate::components::commit::mock::{CommitHistoryEntry, MockCommit}; use iox_tests::ParquetFileBuilder; #[test] diff --git a/compactor_scheduler/src/commit/metrics.rs b/compactor/src/components/commit/metrics.rs similarity index 98% rename from compactor_scheduler/src/commit/metrics.rs rename to compactor/src/components/commit/metrics.rs index 37d141aa74..4a63cec426 100644 --- a/compactor_scheduler/src/commit/metrics.rs +++ b/compactor/src/components/commit/metrics.rs @@ -102,7 +102,7 @@ impl Histogram { } #[derive(Debug)] -pub(crate) struct MetricsCommitWrapper +pub struct MetricsCommitWrapper where T: Commit, { @@ -124,7 +124,7 @@ impl MetricsCommitWrapper where T: Commit, { - pub(crate) fn new(inner: T, registry: &Registry) -> Self { + pub fn new(inner: T, registry: &Registry) -> Self { Self { file_bytes: Histogram::new( registry, @@ -307,7 +307,7 @@ mod tests { use metric::{assert_histogram, Attributes}; - use crate::commit::mock::{CommitHistoryEntry, MockCommit}; + use crate::components::commit::mock::{CommitHistoryEntry, MockCommit}; use iox_tests::ParquetFileBuilder; use super::*; diff --git a/compactor_scheduler/src/commit/mock.rs b/compactor/src/components/commit/mock.rs similarity index 93% rename from compactor_scheduler/src/commit/mock.rs rename to compactor/src/components/commit/mock.rs index deee3592b3..17a68c33b8 100644 --- a/compactor_scheduler/src/commit/mock.rs +++ b/compactor/src/components/commit/mock.rs @@ -12,23 +12,23 @@ use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, use super::Commit; #[derive(Debug, PartialEq, Eq, Clone)] -pub(crate) struct CommitHistoryEntry { - pub(crate) partition_id: PartitionId, - pub(crate) delete: Vec, - pub(crate) upgrade: Vec, - pub(crate) created: Vec, - pub(crate) target_level: CompactionLevel, +pub struct CommitHistoryEntry { + pub partition_id: PartitionId, + pub delete: Vec, + pub upgrade: Vec, + pub created: Vec, + pub target_level: CompactionLevel, } -#[derive(Debug, Default)] -pub(crate) struct MockCommit { +#[derive(Debug)] +pub struct MockCommit { history: Mutex>, id_counter: AtomicI64, } impl MockCommit { #[allow(dead_code)] // not used anywhere - pub(crate) fn new() -> Self { + pub fn new() -> Self { Self { history: Default::default(), id_counter: AtomicI64::new(1000), @@ -36,7 +36,7 @@ impl MockCommit { } #[allow(dead_code)] // not used anywhere - pub(crate) fn history(&self) -> Vec { + pub fn history(&self) -> Vec { self.history.lock().expect("not poisoned").clone() } } diff --git a/compactor_scheduler/src/commit/mod.rs b/compactor/src/components/commit/mod.rs similarity index 95% rename from compactor_scheduler/src/commit/mod.rs rename to compactor/src/components/commit/mod.rs index c1d90a7d1e..de777ccefd 100644 --- a/compactor_scheduler/src/commit/mod.rs +++ b/compactor/src/components/commit/mod.rs @@ -6,9 +6,10 @@ use std::{ use async_trait::async_trait; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; -pub(crate) mod logging; -pub(crate) mod metrics; -pub(crate) mod mock; +pub mod catalog; +pub mod logging; +pub mod metrics; +pub mod mock; /// Ensures that the file change (i.e. deletion and creation) are committed to the catalog. #[async_trait] diff --git a/compactor/src/components/hardcoded.rs b/compactor/src/components/hardcoded.rs index 9554c3bd4f..672869940b 100644 --- a/compactor/src/components/hardcoded.rs +++ b/compactor/src/components/hardcoded.rs @@ -4,9 +4,7 @@ use std::{sync::Arc, time::Duration}; -use compactor_scheduler::{ - create_scheduler, Commit, PartitionDoneSink, PartitionsSource, Scheduler, -}; +use compactor_scheduler::{create_scheduler, PartitionsSource, Scheduler}; use data_types::CompactionLevel; use object_store::memory::InMemory; @@ -14,7 +12,11 @@ use crate::{config::Config, error::ErrorKind, object_store::ignore_writes::Ignor use super::{ changed_files_filter::logging::LoggingChangedFiles, - commit::CommitToScheduler, + combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, + commit::{ + catalog::CatalogCommit, logging::LoggingCommitWrapper, metrics::MetricsCommitWrapper, + mock::MockCommit, Commit, + }, df_plan_exec::{ dedicated::DedicatedDataFusionPlanExec, noop::NoopDataFusionPlanExec, DataFusionPlanExec, }, @@ -37,8 +39,9 @@ use super::{ }, parquet_files_sink::{dispatch::DispatchParquetFilesSink, ParquetFilesSink}, partition_done_sink::{ - error_kind::ErrorKindPartitionDoneSinkWrapper, logging::LoggingPartitionDoneSinkWrapper, - metrics::MetricsPartitionDoneSinkWrapper, outcome::PartitionDoneSinkToScheduler, + catalog::CatalogPartitionDoneSink, error_kind::ErrorKindPartitionDoneSinkWrapper, + logging::LoggingPartitionDoneSinkWrapper, metrics::MetricsPartitionDoneSinkWrapper, + mock::MockPartitionDoneSink, PartitionDoneSink, }, partition_files_source::{ catalog::{CatalogPartitionFilesSource, QueryRateLimiter}, @@ -90,8 +93,6 @@ pub fn hardcoded_components(config: &Config) -> Arc { config.scheduler_config.clone(), Arc::clone(&config.catalog), Arc::clone(&config.time_provider), - Arc::clone(&config.metric_registry), - config.shadow_mode, ); let (partitions_source, commit, partition_done_sink) = make_partitions_source_commit_partition_sink(config, Arc::clone(&scheduler)); @@ -125,14 +126,49 @@ fn make_partitions_source_commit_partition_sink( Arc, Arc, ) { - let partitions_source = ScheduledPartitionsSource::new(Arc::clone(&scheduler)); + let partitions_source = ScheduledPartitionsSource::new(scheduler); - let commit = CommitToScheduler::new(Arc::clone(&scheduler)); + let partition_done_sink: Arc = if config.shadow_mode { + Arc::new(MockPartitionDoneSink::new()) + } else { + Arc::new(CatalogPartitionDoneSink::new( + config.backoff_config.clone(), + Arc::clone(&config.catalog), + )) + }; - let partition_done_sink = PartitionDoneSinkToScheduler::new(Arc::clone(&scheduler)); + let commit: Arc = if config.shadow_mode { + Arc::new(MockCommit::new()) + } else { + Arc::new(CatalogCommit::new( + config.backoff_config.clone(), + Arc::clone(&config.catalog), + )) + }; + + let commit = if let Some(commit_wrapper) = config.commit_wrapper.as_ref() { + commit_wrapper.wrap(commit) + } else { + commit + }; + + let (partitions_source, partition_done_sink) = + unique_partitions(partitions_source, partition_done_sink, 1); + + let (partitions_source, commit, partition_done_sink) = throttle_partition( + partitions_source, + commit, + partition_done_sink, + Arc::clone(&config.time_provider), + Duration::from_secs(60), + 1, + ); + + let commit = Arc::new(LoggingCommitWrapper::new(MetricsCommitWrapper::new( + commit, + &config.metric_registry, + ))); - // compactors are responsible for error classification - // and any future decisions regarding graceful shutdown let partition_done_sink: Arc = if config.all_errors_are_fatal { Arc::new(partition_done_sink) } else { @@ -149,7 +185,6 @@ fn make_partitions_source_commit_partition_sink( }) .copied() .collect(), - scheduler, )) }; let partition_done_sink = Arc::new(LoggingPartitionDoneSinkWrapper::new( @@ -175,7 +210,7 @@ fn make_partitions_source_commit_partition_sink( )) }; - (partitions_source, Arc::new(commit), partition_done_sink) + (partitions_source, commit, partition_done_sink) } fn make_partition_stream( diff --git a/compactor/src/components/mod.rs b/compactor/src/components/mod.rs index 2cf1dc9638..1ce2eea844 100644 --- a/compactor/src/components/mod.rs +++ b/compactor/src/components/mod.rs @@ -1,19 +1,19 @@ use std::sync::Arc; -use compactor_scheduler::{Commit, PartitionDoneSink}; - use self::{ - changed_files_filter::ChangedFilesFilter, df_plan_exec::DataFusionPlanExec, + changed_files_filter::ChangedFilesFilter, commit::Commit, df_plan_exec::DataFusionPlanExec, df_planner::DataFusionPlanner, divide_initial::DivideInitial, file_classifier::FileClassifier, ir_planner::IRPlanner, parquet_files_sink::ParquetFilesSink, - partition_files_source::PartitionFilesSource, partition_filter::PartitionFilter, - partition_info_source::PartitionInfoSource, partition_stream::PartitionStream, + partition_done_sink::PartitionDoneSink, partition_files_source::PartitionFilesSource, + partition_filter::PartitionFilter, partition_info_source::PartitionInfoSource, + partition_stream::PartitionStream, post_classification_partition_filter::PostClassificationPartitionFilter, round_info_source::RoundInfoSource, round_split::RoundSplit, scratchpad::ScratchpadGen, }; pub mod changed_files_filter; -pub(crate) mod commit; +pub mod combos; +pub mod commit; pub mod df_plan_exec; pub mod df_planner; pub mod divide_initial; @@ -61,7 +61,7 @@ pub struct Components { pub post_classification_partition_filter: Arc, /// Records "partition is done" status for given partition. pub partition_done_sink: Arc, - /// Commits changes (i.e. deletion and creation). + /// Commits changes (i.e. deletion and creation) to the catalog. pub commit: Arc, /// Creates `PlanIR` that describes what files should be compacted and updated pub ir_planner: Arc, diff --git a/compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs b/compactor/src/components/partition_done_sink/catalog.rs similarity index 88% rename from compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs rename to compactor/src/components/partition_done_sink/catalog.rs index 4172391ec7..ab384d0ac0 100644 --- a/compactor_scheduler/src/local_scheduler/partition_done_sink/catalog.rs +++ b/compactor/src/components/partition_done_sink/catalog.rs @@ -5,16 +5,18 @@ use backoff::{Backoff, BackoffConfig}; use data_types::PartitionId; use iox_catalog::interface::Catalog; -use super::{DynError, PartitionDoneSink}; +use crate::error::DynError; + +use super::PartitionDoneSink; #[derive(Debug)] -pub(crate) struct CatalogPartitionDoneSink { +pub struct CatalogPartitionDoneSink { backoff_config: BackoffConfig, catalog: Arc, } impl CatalogPartitionDoneSink { - pub(crate) fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { + pub fn new(backoff_config: BackoffConfig, catalog: Arc) -> Self { Self { backoff_config, catalog, diff --git a/compactor/src/components/partition_done_sink/error_kind.rs b/compactor/src/components/partition_done_sink/error_kind.rs index f06f141436..0848906215 100644 --- a/compactor/src/components/partition_done_sink/error_kind.rs +++ b/compactor/src/components/partition_done_sink/error_kind.rs @@ -1,14 +1,12 @@ -use std::{collections::HashSet, fmt::Display, sync::Arc}; +use std::{collections::HashSet, fmt::Display}; use async_trait::async_trait; -use compactor_scheduler::{ - CompactionJob, CompactionJobStatus, CompactionJobStatusResult, CompactionJobStatusVariant, - ErrorKind as SchedulerErrorKind, PartitionDoneSink, Scheduler, -}; use data_types::PartitionId; use crate::error::{DynError, ErrorKind, ErrorKindExt}; +use super::PartitionDoneSink; + #[derive(Debug)] pub struct ErrorKindPartitionDoneSinkWrapper where @@ -16,19 +14,14 @@ where { kind: HashSet, inner: T, - scheduler: Arc, } impl ErrorKindPartitionDoneSinkWrapper where T: PartitionDoneSink, { - pub fn new(inner: T, kind: HashSet, scheduler: Arc) -> Self { - Self { - kind, - inner, - scheduler, - } + pub fn new(inner: T, kind: HashSet) -> Self { + Self { kind, inner } } } @@ -52,24 +45,6 @@ where match res { Ok(()) => self.inner.record(partition, Ok(())).await, Err(e) if self.kind.contains(&e.classify()) => { - let scheduler_error = match SchedulerErrorKind::from(e.classify()) { - SchedulerErrorKind::OutOfMemory => SchedulerErrorKind::OutOfMemory, - SchedulerErrorKind::ObjectStore => SchedulerErrorKind::ObjectStore, - SchedulerErrorKind::Timeout => SchedulerErrorKind::Timeout, - SchedulerErrorKind::Unknown(_) => SchedulerErrorKind::Unknown(e.to_string()), - }; - - match self - .scheduler - .job_status(CompactionJobStatus { - job: CompactionJob::new(partition), - status: CompactionJobStatusVariant::Error(scheduler_error), - }) - .await - { - Ok(CompactionJobStatusResult::Ack) => {} - _ => panic!("unexpected result from scheduler"), - } self.inner.record(partition, Err(e)).await; } _ => {} @@ -81,10 +56,9 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; - use compactor_scheduler::{create_test_scheduler, MockPartitionDoneSink}; + use crate::components::partition_done_sink::mock::MockPartitionDoneSink; + use datafusion::error::DataFusionError; - use iox_tests::TestCatalog; - use iox_time::{MockProvider, Time}; use object_store::Error as ObjectStoreError; use super::*; @@ -94,11 +68,6 @@ mod tests { let sink = ErrorKindPartitionDoneSinkWrapper::new( MockPartitionDoneSink::new(), HashSet::from([ErrorKind::ObjectStore, ErrorKind::OutOfMemory]), - create_test_scheduler( - TestCatalog::new().catalog(), - Arc::new(MockProvider::new(Time::MIN)), - None, - ), ); assert_eq!(sink.to_string(), "kind([ObjectStore, OutOfMemory], mock)"); } @@ -109,11 +78,6 @@ mod tests { let sink = ErrorKindPartitionDoneSinkWrapper::new( Arc::clone(&inner), HashSet::from([ErrorKind::ObjectStore, ErrorKind::OutOfMemory]), - create_test_scheduler( - TestCatalog::new().catalog(), - Arc::new(MockProvider::new(Time::MIN)), - None, - ), ); sink.record( diff --git a/compactor/src/components/partition_done_sink/logging.rs b/compactor/src/components/partition_done_sink/logging.rs index a9fb53a327..d4649567dc 100644 --- a/compactor/src/components/partition_done_sink/logging.rs +++ b/compactor/src/components/partition_done_sink/logging.rs @@ -1,12 +1,13 @@ use std::fmt::Display; use async_trait::async_trait; -use compactor_scheduler::PartitionDoneSink; use data_types::PartitionId; use observability_deps::tracing::{error, info}; use crate::error::{DynError, ErrorKindExt}; +use super::PartitionDoneSink; + #[derive(Debug)] pub struct LoggingPartitionDoneSinkWrapper where @@ -60,10 +61,11 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; - use compactor_scheduler::MockPartitionDoneSink; use object_store::Error as ObjectStoreError; use test_helpers::tracing::TracingCapture; + use crate::components::partition_done_sink::mock::MockPartitionDoneSink; + use super::*; #[test] diff --git a/compactor/src/components/partition_done_sink/metrics.rs b/compactor/src/components/partition_done_sink/metrics.rs index 2a3c0163c4..1999e8e0f4 100644 --- a/compactor/src/components/partition_done_sink/metrics.rs +++ b/compactor/src/components/partition_done_sink/metrics.rs @@ -1,12 +1,13 @@ use std::{collections::HashMap, fmt::Display}; use async_trait::async_trait; -use compactor_scheduler::PartitionDoneSink; use data_types::PartitionId; use metric::{Registry, U64Counter}; use crate::error::{DynError, ErrorKind, ErrorKindExt}; +use super::PartitionDoneSink; + const METRIC_NAME_PARTITION_COMPLETE_COUNT: &str = "iox_compactor_partition_complete_count"; #[derive(Debug)] @@ -82,10 +83,11 @@ where mod tests { use std::{collections::HashMap, sync::Arc}; - use compactor_scheduler::MockPartitionDoneSink; use metric::{assert_counter, Attributes}; use object_store::Error as ObjectStoreError; + use crate::components::partition_done_sink::mock::MockPartitionDoneSink; + use super::*; #[test] diff --git a/compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs b/compactor/src/components/partition_done_sink/mock.rs similarity index 92% rename from compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs rename to compactor/src/components/partition_done_sink/mock.rs index 29673f579e..b906a8b520 100644 --- a/compactor_scheduler/src/local_scheduler/partition_done_sink/mock.rs +++ b/compactor/src/components/partition_done_sink/mock.rs @@ -3,21 +3,21 @@ use std::{collections::HashMap, fmt::Display, sync::Mutex}; use async_trait::async_trait; use data_types::PartitionId; -use super::{DynError, PartitionDoneSink}; +use crate::error::DynError; + +use super::PartitionDoneSink; -/// Mock for [`PartitionDoneSink`]. #[derive(Debug, Default)] pub struct MockPartitionDoneSink { last: Mutex>>, } impl MockPartitionDoneSink { - /// Create new mock. pub fn new() -> Self { Self::default() } - /// Get the last recorded results. + #[allow(dead_code)] // not used anywhere pub fn results(&self) -> HashMap> { self.last.lock().expect("not poisoned").clone() } diff --git a/compactor/src/components/partition_done_sink/mod.rs b/compactor/src/components/partition_done_sink/mod.rs index 32f5aa961c..40d1772222 100644 --- a/compactor/src/components/partition_done_sink/mod.rs +++ b/compactor/src/components/partition_done_sink/mod.rs @@ -1,4 +1,34 @@ +use std::{ + fmt::{Debug, Display}, + sync::Arc, +}; + +use async_trait::async_trait; +use data_types::PartitionId; + +use crate::error::DynError; + +pub mod catalog; pub mod error_kind; pub mod logging; pub mod metrics; -pub mod outcome; +pub mod mock; + +/// Records "partition is done" status for given partition. +#[async_trait] +pub trait PartitionDoneSink: Debug + Display + Send + Sync { + /// Record "partition is done" status for given partition. + /// + /// This method should retry. + async fn record(&self, partition: PartitionId, res: Result<(), DynError>); +} + +#[async_trait] +impl PartitionDoneSink for Arc +where + T: PartitionDoneSink + ?Sized, +{ + async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { + self.as_ref().record(partition, res).await + } +} diff --git a/compactor/src/components/partition_done_sink/outcome.rs b/compactor/src/components/partition_done_sink/outcome.rs deleted file mode 100644 index 0f88f5c18c..0000000000 --- a/compactor/src/components/partition_done_sink/outcome.rs +++ /dev/null @@ -1,49 +0,0 @@ -use std::{fmt::Display, sync::Arc}; - -use async_trait::async_trait; -use compactor_scheduler::{ - CompactionJob, CompactionJobStatus, CompactionJobStatusResult, CompactionJobStatusVariant, - PartitionDoneSink, Scheduler, SkipReason, -}; -use data_types::PartitionId; - -use crate::DynError; - -#[derive(Debug)] -pub struct PartitionDoneSinkToScheduler { - scheduler: Arc, -} - -impl PartitionDoneSinkToScheduler { - pub fn new(scheduler: Arc) -> Self { - Self { scheduler } - } -} - -impl Display for PartitionDoneSinkToScheduler { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "PartitionDoneSinkToScheduler") - } -} - -#[async_trait] -impl PartitionDoneSink for PartitionDoneSinkToScheduler { - async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { - let mut job_status = CompactionJobStatus { - job: CompactionJob::new(partition), - status: CompactionJobStatusVariant::Complete, - }; - if let Err(e) = res { - job_status = CompactionJobStatus { - job: CompactionJob::new(partition), - status: CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError( - e.to_string(), - )), - }; - }; - match self.scheduler.job_status(job_status).await { - Ok(CompactionJobStatusResult::Ack) => {} - _ => panic!("unexpected result from scheduler"), - } - } -} diff --git a/compactor/src/components/report.rs b/compactor/src/components/report.rs index d45b2664c1..0137447c45 100644 --- a/compactor/src/components/report.rs +++ b/compactor/src/components/report.rs @@ -32,6 +32,7 @@ pub fn log_config(config: &Config) { min_num_l1_files_to_compact, process_once, parquet_files_sink_override, + commit_wrapper, simulate_without_object_store, all_errors_are_fatal, max_num_columns_per_table, @@ -44,6 +45,8 @@ pub fn log_config(config: &Config) { .map(|_| "Some") .unwrap_or("None"); + let commit_wrapper = commit_wrapper.as_ref().map(|_| "Some").unwrap_or("None"); + info!( %catalog, %scheduler_config, @@ -66,6 +69,7 @@ pub fn log_config(config: &Config) { process_once, simulate_without_object_store, %parquet_files_sink_override, + %commit_wrapper, all_errors_are_fatal, max_num_columns_per_table, max_num_files_per_plan, diff --git a/compactor/src/config.rs b/compactor/src/config.rs index 389ce7e9ac..63a2cf0abe 100644 --- a/compactor/src/config.rs +++ b/compactor/src/config.rs @@ -8,7 +8,7 @@ use iox_query::exec::Executor; use iox_time::TimeProvider; use parquet_file::storage::ParquetStorage; -use crate::components::parquet_files_sink::ParquetFilesSink; +use crate::components::{commit::CommitWrapper, parquet_files_sink::ParquetFilesSink}; /// Multiple from `max_desired_file_size_bytes` to compute the minimum value for /// `max_compact_size_bytes`. Since `max_desired_file_size_bytes` is softly enforced, actual file @@ -119,6 +119,11 @@ pub struct Config { /// (used for testing) pub parquet_files_sink_override: Option>, + /// Optionally wrap the `Commit` instance + /// + /// This is mostly used for testing + pub commit_wrapper: Option>, + /// Ensure that ALL errors (including object store errors) result in "skipped" partitions. /// /// This is mostly useful for testing. diff --git a/compactor/src/error.rs b/compactor/src/error.rs index a1d687165b..3ae7be1b2b 100644 --- a/compactor/src/error.rs +++ b/compactor/src/error.rs @@ -1,6 +1,5 @@ //! Error handling. -use compactor_scheduler::ErrorKind as SchedulerErrorKind; use datafusion::{arrow::error::ArrowError, error::DataFusionError, parquet::errors::ParquetError}; use object_store::Error as ObjectStoreError; use std::{error::Error, fmt::Display, sync::Arc}; @@ -52,17 +51,6 @@ impl ErrorKind { } } -impl From for SchedulerErrorKind { - fn from(e: ErrorKind) -> Self { - match e { - ErrorKind::ObjectStore => Self::ObjectStore, - ErrorKind::OutOfMemory => Self::OutOfMemory, - ErrorKind::Timeout => Self::Timeout, - ErrorKind::Unknown => Self::Unknown("".into()), - } - } -} - impl Display for ErrorKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.name()) diff --git a/compactor/src/lib.rs b/compactor/src/lib.rs index 2e46324577..711f6118b4 100644 --- a/compactor/src/lib.rs +++ b/compactor/src/lib.rs @@ -221,8 +221,12 @@ mod round_info; // publically expose items needed for testing pub use components::{ - df_planner::panic::PanicDataFusionPlanner, hardcoded::hardcoded_components, - namespaces_source::mock::NamespaceWrapper, parquet_files_sink::ParquetFilesSink, Components, + commit::{Commit, CommitWrapper}, + df_planner::panic::PanicDataFusionPlanner, + hardcoded::hardcoded_components, + namespaces_source::mock::NamespaceWrapper, + parquet_files_sink::ParquetFilesSink, + Components, }; pub use driver::compact; pub use error::DynError; diff --git a/compactor_scheduler/Cargo.toml b/compactor_scheduler/Cargo.toml index dae3b90adb..426b5ab1ba 100644 --- a/compactor_scheduler/Cargo.toml +++ b/compactor_scheduler/Cargo.toml @@ -9,11 +9,8 @@ license.workspace = true async-trait = "0.1.71" backoff = { path = "../backoff" } data_types = { path = "../data_types" } -futures = "0.3" iox_catalog = { path = "../iox_catalog" } iox_time = { path = "../iox_time" } -itertools = "0.11.0" -metric = { path = "../metric" } observability_deps = { path = "../observability_deps" } sharder = { path = "../sharder" } uuid = { version = "1", features = ["v4"] } @@ -21,5 +18,4 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" } [dev-dependencies] iox_tests = { path = "../iox_tests" } -test_helpers = { path = "../test_helpers"} tokio = { version = "1.29", features = ["macros", "net", "parking_lot", "rt-multi-thread", "signal", "sync", "time"] } diff --git a/compactor_scheduler/src/error.rs b/compactor_scheduler/src/error.rs deleted file mode 100644 index 7426de087d..0000000000 --- a/compactor_scheduler/src/error.rs +++ /dev/null @@ -1,37 +0,0 @@ -//! Error classification. - -/// What kind of error did we occur during compaction? -#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] -pub enum ErrorKind { - /// Could not access the object store. - ObjectStore, - - /// We ran out of memory (OOM). - OutOfMemory, - - /// Partition took too long. - Timeout, - - /// Unknown/unexpected error. - /// - /// This will likely mark the affected partition as "skipped" and the compactor will no longer touch it. - Unknown(String), -} - -impl ErrorKind { - /// Return static name. - pub fn name(&self) -> &'static str { - match self { - Self::ObjectStore => "object_store", - Self::OutOfMemory => "out_of_memory", - Self::Timeout => "timeout", - Self::Unknown(_) => "unknown", - } - } -} - -impl std::fmt::Display for ErrorKind { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}", self.name()) - } -} diff --git a/compactor_scheduler/src/lib.rs b/compactor_scheduler/src/lib.rs index 1033364fe5..7d7d35e7d4 100644 --- a/compactor_scheduler/src/lib.rs +++ b/compactor_scheduler/src/lib.rs @@ -26,26 +26,16 @@ use iox_time::TimeProvider; // Workaround for "unused crate" lint false positives. use workspace_hack as _; -pub(crate) mod commit; -pub(crate) use commit::mock::MockCommit; -pub use commit::{Commit, CommitWrapper}; - -mod error; -pub use error::ErrorKind; - mod local_scheduler; pub(crate) use local_scheduler::{id_only_partition_filter::IdOnlyPartitionFilter, LocalScheduler}; +// configurations used externally during scheduler setup pub use local_scheduler::{ - partition_done_sink::{mock::MockPartitionDoneSink, PartitionDoneSink}, - partitions_source_config::PartitionsSourceConfig, - shard_config::ShardConfig, + partitions_source_config::PartitionsSourceConfig, shard_config::ShardConfig, LocalSchedulerConfig, }; - // partitions_source trait mod partitions_source; pub use partitions_source::*; - // scheduler trait and associated types mod scheduler; pub use scheduler::*; @@ -59,8 +49,6 @@ pub fn create_scheduler( config: SchedulerConfig, catalog: Arc, time_provider: Arc, - metrics: Arc, - shadow_mode: bool, ) -> Arc { match config { SchedulerConfig::Local(scheduler_config) => { @@ -69,8 +57,6 @@ pub fn create_scheduler( BackoffConfig::default(), catalog, time_provider, - metrics, - shadow_mode, ); Arc::new(scheduler) } @@ -89,20 +75,13 @@ pub fn create_test_scheduler( let scheduler_config = match mocked_partition_ids { None => SchedulerConfig::default(), Some(partition_ids) => SchedulerConfig::Local(LocalSchedulerConfig { - commit_wrapper: None, partitions_source_config: PartitionsSourceConfig::Fixed( partition_ids.into_iter().collect::>(), ), shard_config: None, }), }; - create_scheduler( - scheduler_config, - catalog, - time_provider, - Arc::new(metric::Registry::default()), - false, - ) + create_scheduler(scheduler_config, catalog, time_provider) } #[cfg(test)] @@ -132,7 +111,7 @@ mod tests { } #[tokio::test] - async fn test_test_scheduler_with_mocked_partition_ids() { + async fn test_test_scheduler_with_mocked_parition_ids() { let partitions = vec![PartitionId::new(0), PartitionId::new(1234242)]; let scheduler = create_test_scheduler( diff --git a/compactor_scheduler/src/local_scheduler.rs b/compactor_scheduler/src/local_scheduler.rs index f22d836100..2aa917ef1f 100644 --- a/compactor_scheduler/src/local_scheduler.rs +++ b/compactor_scheduler/src/local_scheduler.rs @@ -1,36 +1,26 @@ //! Internals used by [`LocalScheduler`]. -pub(crate) mod catalog_commit; -pub(crate) mod combos; pub(crate) mod id_only_partition_filter; -pub(crate) mod partition_done_sink; pub(crate) mod partitions_source; pub(crate) mod partitions_source_config; pub(crate) mod shard_config; -use std::{sync::Arc, time::Duration}; +use std::sync::Arc; use async_trait::async_trait; use backoff::BackoffConfig; use iox_catalog::interface::Catalog; use iox_time::TimeProvider; -use observability_deps::tracing::{info, warn}; +use observability_deps::tracing::info; use crate::{ - commit::{logging::LoggingCommitWrapper, metrics::MetricsCommitWrapper}, - Commit, CommitUpdate, CommitWrapper, CompactionJob, CompactionJobStatus, - CompactionJobStatusResult, CompactionJobStatusVariant, MockCommit, MockPartitionsSource, - PartitionsSource, PartitionsSourceConfig, Scheduler, ShardConfig, SkipReason, + CompactionJob, MockPartitionsSource, PartitionsSource, PartitionsSourceConfig, Scheduler, + ShardConfig, }; use self::{ - catalog_commit::CatalogCommit, - combos::{throttle_partition::throttle_partition, unique_partitions::unique_partitions}, id_only_partition_filter::{ and::AndIdOnlyPartitionFilter, shard::ShardPartitionFilter, IdOnlyPartitionFilter, }, - partition_done_sink::{ - catalog::CatalogPartitionDoneSink, mock::MockPartitionDoneSink, PartitionDoneSink, - }, partitions_source::{ catalog_all::CatalogAllPartitionsSource, catalog_to_compact::CatalogToCompactPartitionsSource, @@ -41,10 +31,6 @@ use self::{ /// Configuration specific to the local scheduler. #[derive(Debug, Default, Clone)] pub struct LocalSchedulerConfig { - /// Optionally wrap the `Commit` instance - /// - /// This is mostly used for testing - pub commit_wrapper: Option>, /// The partitions source config used by the local sceduler. pub partitions_source_config: PartitionsSourceConfig, /// The shard config used by the local sceduler. @@ -54,14 +40,8 @@ pub struct LocalSchedulerConfig { /// Implementation of the scheduler for local (per compactor) scheduling. #[derive(Debug)] pub(crate) struct LocalScheduler { - /// Commits changes (i.e. deletion and creation) to the catalog - pub(crate) commit: Arc, /// The partitions source to use for scheduling. partitions_source: Arc, - /// The actions to take when a partition is done. - /// - /// Includes partition (PartitionId) tracking of uniqueness and throttling. - partition_done_sink: Arc, /// The shard config used for generating the PartitionsSource. shard_config: Option, } @@ -73,47 +53,7 @@ impl LocalScheduler { backoff_config: BackoffConfig, catalog: Arc, time_provider: Arc, - metrics: Arc, - shadow_mode: bool, ) -> Self { - let commit = Self::build_commit( - config.clone(), - backoff_config.clone(), - Arc::clone(&catalog), - metrics, - shadow_mode, - ); - - let partitions_source = Self::build_partitions_source( - config.clone(), - backoff_config.clone(), - Arc::clone(&catalog), - Arc::clone(&time_provider), - ); - - let (partitions_source, commit, partition_done_sink) = Self::build_partition_done_sink( - partitions_source, - commit, - backoff_config, - catalog, - time_provider, - shadow_mode, - ); - - Self { - commit, - partitions_source, - partition_done_sink, - shard_config: config.shard_config, - } - } - - fn build_partitions_source( - config: LocalSchedulerConfig, - backoff_config: BackoffConfig, - catalog: Arc, - time_provider: Arc, - ) -> Arc { let shard_config = config.shard_config; let partitions_source: Arc = match &config.partitions_source_config { PartitionsSourceConfig::CatalogRecentWrites { threshold } => { @@ -146,75 +86,16 @@ impl LocalScheduler { shard_config.shard_id, ))); } - Arc::new(FilterPartitionsSourceWrapper::new( - AndIdOnlyPartitionFilter::new(id_only_partition_filters), + let partitions_source: Arc = + Arc::new(FilterPartitionsSourceWrapper::new( + AndIdOnlyPartitionFilter::new(id_only_partition_filters), + partitions_source, + )); + + Self { partitions_source, - )) - } - - fn build_partition_done_sink( - partitions_source: Arc, - commit: Arc, - backoff_config: BackoffConfig, - catalog: Arc, - time_provider: Arc, - shadow_mode: bool, - ) -> ( - Arc, - Arc, - Arc, - ) { - let partition_done_sink: Arc = if shadow_mode { - Arc::new(MockPartitionDoneSink::new()) - } else { - Arc::new(CatalogPartitionDoneSink::new( - backoff_config, - Arc::clone(&catalog), - )) - }; - - let (partitions_source, partition_done_sink) = - unique_partitions(partitions_source, partition_done_sink, 1); - - let (partitions_source, commit, partition_done_sink) = throttle_partition( - partitions_source, - commit, - partition_done_sink, - Arc::clone(&time_provider), - Duration::from_secs(60), - 1, - ); - - ( - Arc::new(partitions_source), - Arc::new(commit), - Arc::new(partition_done_sink), - ) - } - - fn build_commit( - config: LocalSchedulerConfig, - backoff_config: BackoffConfig, - catalog: Arc, - metrics_registry: Arc, - shadow_mode: bool, - ) -> Arc { - let commit: Arc = if shadow_mode { - Arc::new(MockCommit::new()) - } else { - Arc::new(CatalogCommit::new(backoff_config, Arc::clone(&catalog))) - }; - - let commit = if let Some(commit_wrapper) = &config.commit_wrapper { - commit_wrapper.wrap(commit) - } else { - commit - }; - - Arc::new(LoggingCommitWrapper::new(MetricsCommitWrapper::new( - commit, - &metrics_registry, - ))) + shard_config, + } } } @@ -228,48 +109,6 @@ impl Scheduler for LocalScheduler { .map(CompactionJob::new) .collect() } - - async fn job_status( - &self, - job_status: CompactionJobStatus, - ) -> Result> { - match job_status.status { - CompactionJobStatusVariant::Update(commit_update) => { - let CommitUpdate { - partition_id, - delete, - upgrade, - target_level, - create, - } = commit_update; - - let result = self - .commit - .commit(partition_id, &delete, &upgrade, &create, target_level) - .await; - - // verify create commit counts - assert_eq!(result.len(), create.len()); - - Ok(CompactionJobStatusResult::UpdatedParquetFiles(result)) - } - CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError(msg)) => { - self.partition_done_sink - .record(job_status.job.partition_id, Err(msg.into())) - .await; - - Ok(CompactionJobStatusResult::Ack) - } - CompactionJobStatusVariant::Error(error_kind) => { - warn!("Error processing job: {:?}: {}", job_status.job, error_kind); - Ok(CompactionJobStatusResult::Ack) - } - CompactionJobStatusVariant::Complete => { - // TODO: once uuid is handled properly, we can track the job completion - Ok(CompactionJobStatusResult::Ack) - } - } - } } impl std::fmt::Display for LocalScheduler { @@ -283,10 +122,7 @@ impl std::fmt::Display for LocalScheduler { #[cfg(test)] mod tests { - use std::collections::HashSet; - - use data_types::{ColumnType, PartitionId}; - use iox_tests::{ParquetFileBuilder, TestCatalog, TestParquetFile, TestParquetFileBuilder}; + use iox_tests::TestCatalog; use iox_time::{MockProvider, Time}; use super::*; @@ -298,8 +134,6 @@ mod tests { BackoffConfig::default(), TestCatalog::new().catalog(), Arc::new(MockProvider::new(Time::MIN)), - Arc::new(metric::Registry::default()), - false, ); assert_eq!(scheduler.to_string(), "local_compaction_scheduler",); @@ -313,7 +147,6 @@ mod tests { }); let config = LocalSchedulerConfig { - commit_wrapper: None, partitions_source_config: PartitionsSourceConfig::default(), shard_config, }; @@ -323,8 +156,6 @@ mod tests { BackoffConfig::default(), TestCatalog::new().catalog(), Arc::new(MockProvider::new(Time::MIN)), - Arc::new(metric::Registry::default()), - false, ); assert_eq!( @@ -332,245 +163,4 @@ mod tests { "local_compaction_scheduler(shard_cfg(n_shards=2,shard_id=1))", ); } - - async fn create_scheduler_with_partitions() -> (LocalScheduler, TestParquetFile, TestParquetFile) - { - let catalog = TestCatalog::new(); - let ns = catalog.create_namespace_with_retention("ns", None).await; - let table = ns.create_table("table1").await; - table.create_column("time", ColumnType::Time).await; - table.create_column("load", ColumnType::F64).await; - - let partition1 = table.create_partition("k").await; - let partition2 = table.create_partition("k").await; - let partition_ids = vec![partition1.partition.id, partition2.partition.id]; - - // two files on partition1, to be replaced by one compacted file - let file_builder = TestParquetFileBuilder::default().with_line_protocol("table1 load=1 11"); - let file1_1 = partition1.create_parquet_file(file_builder.clone()).await; - let file1_2 = partition1.create_parquet_file(file_builder).await; - - let config = LocalSchedulerConfig { - commit_wrapper: None, - partitions_source_config: PartitionsSourceConfig::Fixed( - partition_ids.into_iter().collect::>(), - ), - shard_config: None, - }; - - let scheduler = LocalScheduler::new( - config, - BackoffConfig::default(), - catalog.catalog(), - Arc::new(MockProvider::new(Time::MIN)), - Arc::new(metric::Registry::default()), - false, - ); - - (scheduler, file1_1, file1_2) - } - - #[tokio::test] - #[should_panic] - async fn test_status_update_none_should_panic() { - test_helpers::maybe_start_logging(); - - let (scheduler, _, _) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - - for job in jobs { - let commit_update = CommitUpdate { - partition_id: job.partition_id, - delete: vec![], - upgrade: vec![], - target_level: data_types::CompactionLevel::Final, - create: vec![], - }; - - let _ = scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Update(commit_update), - }) - .await; - } - } - - #[tokio::test] - async fn test_status_update_replacement() { - test_helpers::maybe_start_logging(); - - let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - let job = jobs - .into_iter() - .find(|job| job.partition_id == existing_1.partition.partition.id) - .unwrap(); - - let created = ParquetFileBuilder::new(1002) - .with_partition(job.partition_id.get()) - .build(); - - let commit_update = CommitUpdate { - partition_id: job.partition_id, - delete: vec![existing_1.into(), existing_2.into()], - upgrade: vec![], - target_level: data_types::CompactionLevel::Final, - create: vec![created.into()], - }; - - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Update(commit_update), - }) - .await - .is_ok()); - } - - #[tokio::test] - #[should_panic] - async fn test_status_update_replacement_args_incomplete() { - test_helpers::maybe_start_logging(); - - let (scheduler, _, _) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - - for job in jobs { - let created_1 = ParquetFileBuilder::new(1002) - .with_partition(job.partition_id.get()) - .build(); - - let commit_update = CommitUpdate { - partition_id: job.partition_id, - delete: vec![], - upgrade: vec![], - target_level: data_types::CompactionLevel::Final, - create: vec![created_1.into()], - }; - - let _ = scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Update(commit_update), - }) - .await; - } - } - - #[tokio::test] - async fn test_status_update_upgrade() { - test_helpers::maybe_start_logging(); - - let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - let job = jobs - .into_iter() - .find(|job| job.partition_id == existing_1.partition.partition.id) - .unwrap(); - - let commit_update = CommitUpdate { - partition_id: job.partition_id, - delete: vec![], - upgrade: vec![existing_1.into(), existing_2.into()], - target_level: data_types::CompactionLevel::Final, - create: vec![], - }; - - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Update(commit_update), - }) - .await - .is_ok()); - } - - #[tokio::test] - async fn test_status_update_can_replace_and_upgrade_at_once() { - test_helpers::maybe_start_logging(); - - let (scheduler, existing_1, existing_2) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - let job = jobs - .into_iter() - .find(|job| job.partition_id == existing_1.partition.partition.id) - .unwrap(); - - let created = ParquetFileBuilder::new(1002) - .with_partition(job.partition_id.get()) - .build(); - - let commit_update = CommitUpdate { - partition_id: job.partition_id, - delete: vec![existing_1.into()], - upgrade: vec![existing_2.into()], - target_level: data_types::CompactionLevel::Final, - create: vec![created.into()], - }; - - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Update(commit_update), - }) - .await - .is_ok()); - } - - #[tokio::test] - async fn test_status_skip() { - test_helpers::maybe_start_logging(); - - let (scheduler, _, _) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - - for job in jobs { - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::RequestToSkip(SkipReason::CompactionError( - "some error".into() - )), - }) - .await - .is_ok()); - } - } - - #[tokio::test] - async fn test_status_error() { - test_helpers::maybe_start_logging(); - - let (scheduler, _, _) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - - for job in jobs { - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Error(crate::ErrorKind::OutOfMemory), - }) - .await - .is_ok()); - } - } - - #[tokio::test] - async fn test_status_complete() { - test_helpers::maybe_start_logging(); - - let (scheduler, _, _) = create_scheduler_with_partitions().await; - let jobs = scheduler.get_jobs().await; - - for job in jobs { - assert!(scheduler - .job_status(CompactionJobStatus { - job, - status: CompactionJobStatusVariant::Complete, - }) - .await - .is_ok()); - } - } } diff --git a/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs b/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs deleted file mode 100644 index 2bc87c4a0f..0000000000 --- a/compactor_scheduler/src/local_scheduler/partition_done_sink/mod.rs +++ /dev/null @@ -1,32 +0,0 @@ -pub(crate) mod catalog; -pub(crate) mod mock; - -use std::{ - fmt::{Debug, Display}, - sync::Arc, -}; - -use async_trait::async_trait; -use data_types::PartitionId; - -/// Dynamic error type that is used throughout the stack. -pub(crate) type DynError = Box; - -/// Records "partition is done" status for given partition. -#[async_trait] -pub trait PartitionDoneSink: Debug + Display + Send + Sync { - /// Record "partition is done" status for given partition. - /// - /// This method should retry. - async fn record(&self, partition: PartitionId, res: Result<(), DynError>); -} - -#[async_trait] -impl PartitionDoneSink for Arc -where - T: PartitionDoneSink + ?Sized, -{ - async fn record(&self, partition: PartitionId, res: Result<(), DynError>) { - self.as_ref().record(partition, res).await - } -} diff --git a/compactor_scheduler/src/scheduler.rs b/compactor_scheduler/src/scheduler.rs index eaaa17b881..13f5b8355d 100644 --- a/compactor_scheduler/src/scheduler.rs +++ b/compactor_scheduler/src/scheduler.rs @@ -1,13 +1,10 @@ -use std::{ - fmt::{Debug, Display}, - sync::Arc, -}; +use std::fmt::{Debug, Display}; use async_trait::async_trait; -use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; +use data_types::PartitionId; use uuid::Uuid; -use crate::{CommitWrapper, ErrorKind, LocalSchedulerConfig, PartitionsSourceConfig}; +use crate::LocalSchedulerConfig; /// Scheduler configuration. #[derive(Debug, Clone)] @@ -16,19 +13,6 @@ pub enum SchedulerConfig { Local(LocalSchedulerConfig), } -impl SchedulerConfig { - /// Create new [`LocalScheduler`](crate::LocalScheduler) config with a [`CommitWrapper`]. - /// - /// This is useful for testing. - pub fn new_local_with_wrapper(commit_wrapper: Arc) -> Self { - Self::Local(LocalSchedulerConfig { - shard_config: None, - partitions_source_config: PartitionsSourceConfig::default(), - commit_wrapper: Some(commit_wrapper), - }) - } -} - impl Default for SchedulerConfig { fn default() -> Self { Self::Local(LocalSchedulerConfig::default()) @@ -39,21 +23,11 @@ impl std::fmt::Display for SchedulerConfig { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { SchedulerConfig::Local(LocalSchedulerConfig { - commit_wrapper, shard_config, partitions_source_config: _, - }) => match (&shard_config, commit_wrapper) { - (None, None) => write!(f, "local_compaction_scheduler_cfg"), - (Some(shard_config), None) => { - write!(f, "local_compaction_scheduler_cfg({shard_config})",) - } - (Some(shard_config), Some(_)) => write!( - f, - "local_compaction_scheduler_cfg({shard_config},commit_wrapper=Some)", - ), - (None, Some(_)) => { - write!(f, "local_compaction_scheduler_cfg(commit_wrapper=Some)",) - } + }) => match &shard_config { + None => write!(f, "local_compaction_scheduler"), + Some(shard_config) => write!(f, "local_compaction_scheduler({shard_config})",), }, } } @@ -80,115 +54,9 @@ impl CompactionJob { } } -/// Commit update for a given partition. -#[derive(Debug)] -pub struct CommitUpdate { - /// Partition to be updated. - pub(crate) partition_id: PartitionId, - /// Files to be deleted. - pub(crate) delete: Vec, - /// Files to be upgraded. - pub(crate) upgrade: Vec, - /// Target level for upgraded files. - pub(crate) target_level: CompactionLevel, - /// Files to be created. - pub(crate) create: Vec, -} - -impl CommitUpdate { - /// Create new commit update. - pub fn new( - partition_id: PartitionId, - delete: Vec, - upgrade: Vec, - create: Vec, - target_level: CompactionLevel, - ) -> Self { - Self { - partition_id, - delete, - upgrade, - target_level, - create, - } - } -} - -/// Reason for skipping a partition. -#[derive(Debug)] -pub enum SkipReason { - /// Partition is not compactible, due to an encountered error. - CompactionError(String), -} - -/// Status. -#[derive(Debug)] -pub enum CompactionJobStatusVariant { - /// Updates associated with ongoing compaction job. - Update(CommitUpdate), - /// Request to skip partition. - RequestToSkip(SkipReason), - /// Compaction job is complete. - Complete, - /// Compaction job has failed. - Error(ErrorKind), -} - -/// Status ([`CompactionJobStatusVariant`]) associated with a [`CompactionJob`]. -#[derive(Debug)] -pub struct CompactionJobStatus { - /// Job. - pub job: CompactionJob, - /// Status. - pub status: CompactionJobStatusVariant, -} - -/// Status of a compaction job. -#[derive(Debug)] -pub enum CompactionJobStatusResult { - /// Ack only. - Ack, - /// Updates which were processed. - UpdatedParquetFiles(Vec), -} - /// Core trait used for all schedulers. #[async_trait] pub trait Scheduler: Send + Sync + Debug + Display { /// Get partitions to be compacted. async fn get_jobs(&self) -> Vec; - - /// Update job status. - async fn job_status( - &self, - job_status: CompactionJobStatus, - ) -> Result>; -} - -#[cfg(test)] -mod tests { - use std::sync::Arc; - - use crate::Commit; - - use super::*; - - #[test] - fn test_cfg_display_new_local_with_wrapper() { - #[derive(Debug)] - struct MockCommitWrapper; - - impl CommitWrapper for MockCommitWrapper { - fn wrap(&self, commit: Arc) -> Arc { - commit - } - } - - let config = SchedulerConfig::new_local_with_wrapper(Arc::new(MockCommitWrapper)); - - assert_eq!( - config.to_string(), - "local_compaction_scheduler_cfg(commit_wrapper=Some)" - ); - } } diff --git a/compactor_test_utils/src/commit_wrapper.rs b/compactor_test_utils/src/commit_wrapper.rs index 9fd8b3d53c..388c62fb5c 100644 --- a/compactor_test_utils/src/commit_wrapper.rs +++ b/compactor_test_utils/src/commit_wrapper.rs @@ -1,7 +1,7 @@ //! Handles recording commit information to the test run log use async_trait::async_trait; -use compactor_scheduler::{Commit, CommitWrapper}; +use compactor::{Commit, CommitWrapper}; use data_types::{CompactionLevel, ParquetFile, ParquetFileId, ParquetFileParams, PartitionId}; use std::{ fmt::{Debug, Display}, diff --git a/compactor_test_utils/src/lib.rs b/compactor_test_utils/src/lib.rs index 0001bc8e26..c0be0b889d 100644 --- a/compactor_test_utils/src/lib.rs +++ b/compactor_test_utils/src/lib.rs @@ -121,7 +121,7 @@ impl TestSetupBuilder { let config = Config { metric_registry: catalog.metric_registry(), catalog: catalog.catalog(), - scheduler_config: SchedulerConfig::new_local_with_wrapper(Arc::new(commit_wrapper)), + scheduler_config: SchedulerConfig::default(), parquet_store_real: catalog.parquet_store.clone(), parquet_store_scratchpad: ParquetStorage::new( Arc::new(object_store::memory::InMemory::new()), @@ -144,6 +144,7 @@ impl TestSetupBuilder { process_once: true, simulate_without_object_store: false, parquet_files_sink_override: None, + commit_wrapper: Some(Arc::new(commit_wrapper)), all_errors_are_fatal: true, max_num_columns_per_table: 200, max_num_files_per_plan: 200, diff --git a/ioxd_compactor/src/lib.rs b/ioxd_compactor/src/lib.rs index 513e69c590..1ed4cdfe3d 100644 --- a/ioxd_compactor/src/lib.rs +++ b/ioxd_compactor/src/lib.rs @@ -184,6 +184,7 @@ pub async fn create_compactor_server_type( process_once: compactor_config.process_once, simulate_without_object_store: false, parquet_files_sink_override: None, + commit_wrapper: None, all_errors_are_fatal: false, max_num_columns_per_table: compactor_config.max_num_columns_per_table, max_num_files_per_plan: compactor_config.max_num_files_per_plan, diff --git a/ioxd_compactor/src/scheduler_config.rs b/ioxd_compactor/src/scheduler_config.rs index 3be3eda2e3..ca3156d942 100644 --- a/ioxd_compactor/src/scheduler_config.rs +++ b/ioxd_compactor/src/scheduler_config.rs @@ -66,7 +66,6 @@ fn convert_shard_config(config: ShardConfigForLocalScheduler) -> Option SchedulerConfig { match config.compactor_scheduler_type { CompactorSchedulerType::Local => SchedulerConfig::Local(LocalSchedulerConfig { - commit_wrapper: None, partitions_source_config: convert_partitions_source_config( config.partition_source_config, ), From f33891b9fec115b0a21e6b62ec4ca5bcf97697c4 Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Tue, 11 Jul 2023 17:14:07 -0400 Subject: [PATCH 28/37] fix(all-in-one): Run compactor in all-in-one mode (#8214) Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- compactor/src/driver.rs | 2 +- influxdb_iox/src/commands/run/all_in_one.rs | 56 ++++++++++++--------- 2 files changed, 33 insertions(+), 25 deletions(-) diff --git a/compactor/src/driver.rs b/compactor/src/driver.rs index 7b3a6f8398..fca94d4192 100644 --- a/compactor/src/driver.rs +++ b/compactor/src/driver.rs @@ -52,7 +52,7 @@ async fn compact_partition( df_semaphore: Arc, components: Arc, ) { - info!(partition_id = partition_id.get(), "compact partition",); + info!(partition_id = partition_id.get(), timeout = ?partition_timeout, "compact partition",); let scratchpad = components.scratchpad_gen.pad(); let res = timeout_with_progress_checking(partition_timeout, |transmit_progress_signal| { diff --git a/influxdb_iox/src/commands/run/all_in_one.rs b/influxdb_iox/src/commands/run/all_in_one.rs index 7e1b07c608..af85a5ef60 100644 --- a/influxdb_iox/src/commands/run/all_in_one.rs +++ b/influxdb_iox/src/commands/run/all_in_one.rs @@ -33,7 +33,6 @@ use object_store::DynObjectStore; use observability_deps::tracing::*; use parquet_file::storage::{ParquetStorage, StorageId}; use std::{ - collections::HashMap, num::NonZeroUsize, path::{Path, PathBuf}, str::FromStr, @@ -436,6 +435,15 @@ impl Config { catalog_dsn.dsn = Some(dsn); }; + // TODO: make num_threads a parameter (other modes have it + // configured by a command line) + let num_threads = + NonZeroUsize::new(num_cpus::get()).unwrap_or_else(|| NonZeroUsize::new(1).unwrap()); + + // Target allowing the compactor to use as many as 1/2 the + // cores by default, but at least one. + let compactor_concurrency = NonZeroUsize::new((num_threads.get() / 2).max(1)).unwrap(); + let ingester_addresses = vec![IngesterAddress::from_str(&ingester_grpc_bind_address.to_string()).unwrap()]; @@ -487,15 +495,15 @@ impl Config { // parameters are redundant with ingester's let compactor_config = CompactorConfig { compactor_scheduler_config, - compaction_partition_concurrency: NonZeroUsize::new(1).unwrap(), - compaction_df_concurrency: NonZeroUsize::new(1).unwrap(), - compaction_partition_scratchpad_concurrency: NonZeroUsize::new(1).unwrap(), - query_exec_thread_count: Some(NonZeroUsize::new(1).unwrap()), + compaction_partition_concurrency: compactor_concurrency, + compaction_df_concurrency: compactor_concurrency, + compaction_partition_scratchpad_concurrency: compactor_concurrency, + query_exec_thread_count: Some(num_threads), exec_mem_pool_bytes, - max_desired_file_size_bytes: 30_000, + max_desired_file_size_bytes: 100 * 1024 * 1024, // 100 MB percentage_max_file_size: 30, split_percentage: 80, - partition_timeout_secs: 0, + partition_timeout_secs: 30 * 60, // 30 minutes shadow_mode: false, enable_scratchpad: true, ignore_partition_skip_marker: false, @@ -519,6 +527,8 @@ impl Config { }; SpecializedConfig { + num_threads, + router_run_config, querier_run_config, @@ -550,6 +560,8 @@ fn ensure_directory_exists(p: &Path) { /// Different run configs for the different services (needed as they /// listen on different ports) struct SpecializedConfig { + num_threads: NonZeroUsize, + router_run_config: RunConfig, querier_run_config: RunConfig, ingester_run_config: RunConfig, @@ -564,6 +576,7 @@ struct SpecializedConfig { pub async fn command(config: Config) -> Result<()> { let SpecializedConfig { + num_threads, router_run_config, querier_run_config, ingester_run_config, @@ -595,20 +608,23 @@ pub async fn command(config: Config) -> Result<()> { // create common state from the router and use it below let common_state = CommonServerState::from_config(router_run_config.clone())?; - // TODO: make num_threads a parameter (other modes have it - // configured by a command line) - let num_threads = NonZeroUsize::new(num_cpus::get()) - .unwrap_or_else(|| NonZeroUsize::new(1).expect("1 is valid")); info!(%num_threads, "Creating shared query executor"); - let parquet_store_real = ParquetStorage::new(Arc::clone(&object_store), StorageId::from("iox")); + let parquet_store_scratchpad = ParquetStorage::new( + Arc::new(MetricsStore::new( + Arc::new(object_store::memory::InMemory::new()), + &metrics, + "scratchpad", + )), + StorageId::from("iox_scratchpad"), + ); let exec = Arc::new(Executor::new_with_config(ExecutorConfig { num_threads, target_query_partitions: num_threads, - object_stores: HashMap::from([( - parquet_store_real.id(), - Arc::clone(parquet_store_real.object_store()), - )]), + object_stores: [&parquet_store_real, &parquet_store_scratchpad] + .into_iter() + .map(|store| (store.id(), Arc::clone(store.object_store()))) + .collect(), metric_registry: Arc::clone(&metrics), mem_pool_size: querier_config.exec_mem_pool_bytes, })); @@ -636,14 +652,6 @@ pub async fn command(config: Config) -> Result<()> { .expect("failed to start ingester"); info!("starting compactor"); - let parquet_store_scratchpad = ParquetStorage::new( - Arc::new(MetricsStore::new( - Arc::new(object_store::memory::InMemory::new()), - &metrics, - "scratchpad", - )), - StorageId::from("iox_scratchpad"), - ); let compactor = create_compactor_server_type( &common_state, From ebe1f4c91db03d5a464a80d4d7eb2e53c1cdc627 Mon Sep 17 00:00:00 2001 From: Marko Mikulicic Date: Wed, 12 Jul 2023 02:01:02 +0200 Subject: [PATCH 29/37] fix: Implement influxql ExecutionPlan::children (#8215) --- iox_query_influxql/src/frontend/planner.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/iox_query_influxql/src/frontend/planner.rs b/iox_query_influxql/src/frontend/planner.rs index c0de1cdc31..e8a311bdb6 100644 --- a/iox_query_influxql/src/frontend/planner.rs +++ b/iox_query_influxql/src/frontend/planner.rs @@ -102,7 +102,7 @@ impl ExecutionPlan for SchemaExec { } fn children(&self) -> Vec> { - unimplemented!() + vec![Arc::clone(&self.input)] } fn with_new_children( From d74f047b06cdd1f68a01b5cc5c7b5553e4c179a6 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 12 Jul 2023 02:00:42 +0000 Subject: [PATCH 30/37] chore(deps): Bump serde_json from 1.0.100 to 1.0.102 Bumps [serde_json](https://github.com/serde-rs/json) from 1.0.100 to 1.0.102. - [Release notes](https://github.com/serde-rs/json/releases) - [Commits](https://github.com/serde-rs/json/compare/v1.0.100...v1.0.102) --- updated-dependencies: - dependency-name: serde_json dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] --- Cargo.lock | 4 ++-- import_export/Cargo.toml | 2 +- influxdb2_client/Cargo.toml | 2 +- influxdb_iox/Cargo.toml | 2 +- influxdb_iox_client/Cargo.toml | 2 +- iox_data_generator/Cargo.toml | 2 +- iox_query_influxql/Cargo.toml | 2 +- ioxd_common/Cargo.toml | 2 +- service_grpc_flight/Cargo.toml | 2 +- service_grpc_influxrpc/Cargo.toml | 2 +- 10 files changed, 11 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 660dd90e99..6ba2133b2e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4901,9 +4901,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.100" +version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f1e14e89be7aa4c4b78bdbdc9eb5bf8517829a600ae8eaa39a6e1d960b5185c" +checksum = "b5062a995d481b2308b6064e9af76011f2921c35f97b0468811ed9f6cd91dfed" dependencies = [ "itoa", "ryu", diff --git a/import_export/Cargo.toml b/import_export/Cargo.toml index d181835bfa..106f2f11fc 100644 --- a/import_export/Cargo.toml +++ b/import_export/Cargo.toml @@ -16,7 +16,7 @@ parquet_file = { path = "../parquet_file" } object_store = { workspace=true } observability_deps = { path = "../observability_deps" } schema = { path = "../schema" } -serde_json = "1.0.100" +serde_json = "1.0.102" thiserror = "1.0.43" tokio = { version = "1.29" } tokio-util = { version = "0.7.8" } diff --git a/influxdb2_client/Cargo.toml b/influxdb2_client/Cargo.toml index 36c1075b0a..b1f5e9849b 100644 --- a/influxdb2_client/Cargo.toml +++ b/influxdb2_client/Cargo.toml @@ -10,7 +10,7 @@ bytes = "1.4" futures = { version = "0.3", default-features = false } reqwest = { version = "0.11", default-features = false, features = ["stream", "json", "rustls-tls"] } serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0.100" +serde_json = "1.0.102" snafu = "0.7" url = "2.4.0" uuid = { version = "1", features = ["v4"] } diff --git a/influxdb_iox/Cargo.toml b/influxdb_iox/Cargo.toml index f95b5bc146..e9997b8b95 100644 --- a/influxdb_iox/Cargo.toml +++ b/influxdb_iox/Cargo.toml @@ -67,7 +67,7 @@ libc = { version = "0.2" } num_cpus = "1.16.0" once_cell = { version = "1.18", features = ["parking_lot"] } rustyline = { version = "12.0", default-features = false, features = ["with-file-history"]} -serde_json = "1.0.100" +serde_json = "1.0.102" snafu = "0.7" tempfile = "3.6.0" thiserror = "1.0.43" diff --git a/influxdb_iox_client/Cargo.toml b/influxdb_iox_client/Cargo.toml index 08e9b23983..aff8d304f1 100644 --- a/influxdb_iox_client/Cargo.toml +++ b/influxdb_iox_client/Cargo.toml @@ -24,7 +24,7 @@ prost = "0.11" rand = "0.8.3" reqwest = { version = "0.11", default-features = false, features = ["stream", "rustls-tls"] } schema = { path = "../schema" } -serde_json = "1.0.100" +serde_json = "1.0.102" tokio = { version = "1.29", features = ["macros", "parking_lot", "rt-multi-thread"] } tokio-stream = "0.1.13" thiserror = "1.0.43" diff --git a/iox_data_generator/Cargo.toml b/iox_data_generator/Cargo.toml index 6d858a555e..fdfa316087 100644 --- a/iox_data_generator/Cargo.toml +++ b/iox_data_generator/Cargo.toml @@ -23,7 +23,7 @@ rand = { version = "0.8.3", features = ["small_rng"] } regex = "1.9" schema = { path = "../schema" } serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0.100" +serde_json = "1.0.102" snafu = "0.7" tokio = { version = "1.29", features = ["macros", "parking_lot", "rt-multi-thread", "sync", "time"] } toml = "0.7.6" diff --git a/iox_query_influxql/Cargo.toml b/iox_query_influxql/Cargo.toml index 25ed62d799..bfc3903ae2 100644 --- a/iox_query_influxql/Cargo.toml +++ b/iox_query_influxql/Cargo.toml @@ -20,7 +20,7 @@ predicate = { path = "../predicate" } query_functions = { path = "../query_functions" } regex = "1" schema = { path = "../schema" } -serde_json = "1.0.100" +serde_json = "1.0.102" thiserror = "1.0" workspace-hack = { version = "0.1", path = "../workspace-hack" } diff --git a/ioxd_common/Cargo.toml b/ioxd_common/Cargo.toml index 68227239e0..63d3c9c251 100644 --- a/ioxd_common/Cargo.toml +++ b/ioxd_common/Cargo.toml @@ -38,7 +38,7 @@ log = "0.4" parking_lot = "0.12" reqwest = { version = "0.11", default-features = false, features = ["json", "rustls-tls"] } serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0.100" +serde_json = "1.0.102" serde_urlencoded = "0.7.0" snafu = "0.7" tokio = { version = "1.29", features = ["macros", "net", "parking_lot", "rt-multi-thread", "signal", "sync", "time"] } diff --git a/service_grpc_flight/Cargo.toml b/service_grpc_flight/Cargo.toml index ef0d1c3a45..370344d49e 100644 --- a/service_grpc_flight/Cargo.toml +++ b/service_grpc_flight/Cargo.toml @@ -26,7 +26,7 @@ bytes = "1.4" futures = "0.3" prost = "0.11" serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0.100" +serde_json = "1.0.102" snafu = "0.7" tokio = { version = "1.29", features = ["macros", "net", "parking_lot", "rt-multi-thread", "signal", "sync", "time"] } tonic = { workspace = true } diff --git a/service_grpc_influxrpc/Cargo.toml b/service_grpc_influxrpc/Cargo.toml index 433efffaf1..e3bb678d3e 100644 --- a/service_grpc_influxrpc/Cargo.toml +++ b/service_grpc_influxrpc/Cargo.toml @@ -30,7 +30,7 @@ pin-project = "1.1" prost = "0.11" regex = "1.9.1" serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0.100" +serde_json = "1.0.102" snafu = "0.7" tokio-stream = { version = "0.1", features = ["net"] } tonic = { workspace = true } From b8f1c8f68abaca346a711c6a3e87d9f2afa98665 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 12 Jul 2023 09:28:30 +0000 Subject: [PATCH 31/37] chore(deps): Bump rustix from 0.38.3 to 0.38.4 (#8217) Bumps [rustix](https://github.com/bytecodealliance/rustix) from 0.38.3 to 0.38.4. - [Release notes](https://github.com/bytecodealliance/rustix/releases) - [Commits](https://github.com/bytecodealliance/rustix/compare/v0.38.3...v0.38.4) --- updated-dependencies: - dependency-name: rustix dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- Cargo.lock | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6ba2133b2e..db22951b90 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1731,7 +1731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5" dependencies = [ "cfg-if", - "rustix 0.38.3", + "rustix 0.38.4", "windows-sys 0.48.0", ] @@ -3130,7 +3130,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b" dependencies = [ "hermit-abi", - "rustix 0.38.3", + "rustix 0.38.4", "windows-sys 0.48.0", ] @@ -4733,9 +4733,9 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.3" +version = "0.38.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac5ffa1efe7548069688cd7028f32591853cd7b5b756d41bcffd2353e4fc75b4" +checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5" dependencies = [ "bitflags 2.3.3", "errno", @@ -6732,7 +6732,7 @@ dependencies = [ "regex-syntax 0.7.4", "reqwest", "ring", - "rustix 0.38.3", + "rustix 0.38.4", "rustls 0.21.5", "scopeguard", "serde", From af56985d70ce20c58a9d1e16a343e870afe3c2b1 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Wed, 12 Jul 2023 14:42:43 +0200 Subject: [PATCH 32/37] refactor(ingester): emit span for query handler Emit a span that covers the entire flight query handler. --- ingester/src/server/grpc/query.rs | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/ingester/src/server/grpc/query.rs b/ingester/src/server/grpc/query.rs index 763ad89688..b4dde8853c 100644 --- a/ingester/src/server/grpc/query.rs +++ b/ingester/src/server/grpc/query.rs @@ -19,7 +19,7 @@ use tokio::sync::{Semaphore, TryAcquireError}; use tonic::{Request, Response, Streaming}; use trace::{ ctx::SpanContext, - span::{Span, SpanExt}, + span::{Span, SpanExt, SpanRecorder}, }; mod instrumentation; @@ -175,7 +175,7 @@ where request: Request, ) -> Result, tonic::Status> { let span_ctx: Option = request.extensions().get().cloned(); - let span = span_ctx.child_span("ingester query"); + let mut query_recorder = SpanRecorder::new(span_ctx.child_span("ingester query")); // Acquire and hold a permit for the duration of this request, or return // an error if the existing requests have already exhausted the @@ -211,16 +211,23 @@ where let response = match self .query_handler - .query_exec(namespace_id, table_id, projection, span.clone(), predicate) + .query_exec( + namespace_id, + table_id, + projection, + query_recorder.child_span("query exec"), + predicate, + ) .await { Ok(v) => v, Err(e @ (QueryError::TableNotFound(_, _) | QueryError::NamespaceNotFound(_))) => { debug!( - error=%e, - %namespace_id, - %table_id, - "query error, no buffered data found"); + error=%e, + %namespace_id, + %table_id, + "no buffered data found for query" + ); return Err(e)?; } @@ -229,11 +236,12 @@ where let output = encode_response( response, self.ingester_id, - span, + query_recorder.child_span("serialise response"), Arc::clone(&self.query_request_frame_encoding_duration), ) .map_err(tonic::Status::from); + query_recorder.ok("query exec complete - streaming results"); Ok(Response::new(Box::pin(output) as Self::DoGetStream)) } From 7bd6e90830f423d9b49184ae12734e321d92e227 Mon Sep 17 00:00:00 2001 From: Dom Dwyer Date: Wed, 12 Jul 2023 18:38:43 +0200 Subject: [PATCH 33/37] perf: only send metadata for relevant partitions When partition pruning is possible, it skips sending the data for partitions that have no affect on the query outcome. This commit does the same for the partition metadata - these frames can form a significant portion of the query response when the row count is low, and for pruned partitions have no bearing on the query result. --- ingester/src/buffer_tree/root.rs | 102 ++++++++++++++++++++++++++++++ ingester/src/buffer_tree/table.rs | 27 +++++--- 2 files changed, 120 insertions(+), 9 deletions(-) diff --git a/ingester/src/buffer_tree/root.rs b/ingester/src/buffer_tree/root.rs index e153dbc1f8..2e3b7df7f7 100644 --- a/ingester/src/buffer_tree/root.rs +++ b/ingester/src/buffer_tree/root.rs @@ -745,6 +745,108 @@ mod tests { ] ); + /// Ensure partition pruning during query execution also prunes metadata + /// frames. + /// + /// Individual frames are fast to serialise, but large numbers of frames can + /// add significant query overhead, particularly for queries returning small + /// numbers of rows where the metadata becomes a significant portion of the + /// response. + #[tokio::test] + async fn test_partition_metadata_pruning() { + let partition_provider = Arc::new( + MockPartitionProvider::default() + .with_partition( + PartitionDataBuilder::new() + .with_partition_id(ARBITRARY_PARTITION_ID) + .with_partition_key("madrid".into()) + .build(), + ) + .with_partition( + PartitionDataBuilder::new() + .with_partition_id(PARTITION2_ID) + .with_partition_key("asturias".into()) + .build(), + ), + ); + + // Construct a partition template suitable for pruning on the "region" + // tag. + let table_provider = Arc::new(MockTableProvider::new(TableMetadata::new_for_testing( + ARBITRARY_TABLE_NAME.clone(), + test_table_partition_override(vec![TemplatePart::TagValue("region")]), + ))); + + // Init the buffer tree + let buf = BufferTree::new( + Arc::new(MockNamespaceNameProvider::new(&**ARBITRARY_NAMESPACE_NAME)), + table_provider, + partition_provider, + Arc::new(MockPostWriteObserver::default()), + Arc::new(metric::Registry::default()), + ); + + // Write to two regions + buf.apply(IngestOp::Write(make_write_op( + &PartitionKey::from("madrid"), + ARBITRARY_NAMESPACE_ID, + &ARBITRARY_TABLE_NAME, + ARBITRARY_TABLE_ID, + 0, + &format!( + r#"{},region=madrid temp=35 4242424242"#, + &*ARBITRARY_TABLE_NAME + ), + None, + ))) + .await + .expect("failed to perform write"); + + buf.apply(IngestOp::Write(make_write_op( + &PartitionKey::from("asturias"), + ARBITRARY_NAMESPACE_ID, + &ARBITRARY_TABLE_NAME, + ARBITRARY_TABLE_ID, + 0, + &format!( + r#"{},region=asturias temp=35 4242424242"#, + &*ARBITRARY_TABLE_NAME + ), + None, + ))) + .await + .expect("failed to perform write"); + + // Construct a predicate suitable for pruning partitions based on the + // region / partition template. + let predicate = Some(Predicate::new().with_expr(col("region").eq(lit( + ScalarValue::Dictionary( + Box::new(DataType::Int32), + Box::new(ScalarValue::from("asturias")), + ), + )))); + + // Execute the query and count the number of partitions that are + // returned (either data, or metadata). + let partition_count = buf + .query_exec( + ARBITRARY_NAMESPACE_ID, + ARBITRARY_TABLE_ID, + OwnedProjection::default(), + None, + predicate, + ) + .await + .expect("query should succeed") + .into_partition_stream() + .count() + .await; + + // Because the data in the "madrid" partition was pruned out, the + // metadata should not be sent either. + assert_eq!(partition_count, 1); + } + /// Assert that multiple writes to a single namespace/table results in a /// single namespace being created, and matching metrics. #[tokio::test] diff --git a/ingester/src/buffer_tree/table.rs b/ingester/src/buffer_tree/table.rs index 10fd6cb7a1..2307b1a423 100644 --- a/ingester/src/buffer_tree/table.rs +++ b/ingester/src/buffer_tree/table.rs @@ -270,7 +270,7 @@ where // Gather the partition data from all of the partitions in this table. let span = SpanRecorder::new(span); - let partitions = self.partitions().into_iter().map(move |p| { + let partitions = self.partitions().into_iter().filter_map(move |p| { let mut span = span.child("partition read"); let (id, hash_id, completed_persistence_count, data, partition_key) = { @@ -303,15 +303,24 @@ where }) .unwrap_or_default() { - return PartitionResponse::new( - vec![], - id, - hash_id, - completed_persistence_count, - ); + // This partition will never contain any data that would + // form part of the query response. + // + // Because this is true of buffered data, it is also + // true of the persisted data, and therefore sending the + // persisted file count metadata is useless because the + // querier would never utilise the persisted files as + // part of this query. + // + // This avoids sending O(n) metadata frames for queries + // that may only touch one or two actual frames. The N + // partition count grows over the lifetime of the + // ingester as more partitions are created, and while + // fast to serialise individually, the sequentially-sent + // N metadata frames add up. + return None; } - // Project the data if necessary PartitionResponse::new( data.into_record_batches(), id, @@ -323,7 +332,7 @@ where }; span.ok("read partition data"); - ret + Some(ret) }); Ok(PartitionStream::new(futures::stream::iter(partitions))) From c3788ee2b88c285511bedef4d5876d2d8a290e1d Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Wed, 12 Jul 2023 14:18:41 -0400 Subject: [PATCH 34/37] chore: Update datafusion pin (#8223) --- Cargo.lock | 18 +++++++++--------- Cargo.toml | 4 ++-- workspace-hack/Cargo.toml | 6 +++--- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f7e43980e6..715bda21a2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1360,7 +1360,7 @@ dependencies = [ [[package]] name = "datafusion" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "ahash 0.8.3", "arrow", @@ -1408,7 +1408,7 @@ dependencies = [ [[package]] name = "datafusion-common" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "arrow", "arrow-array", @@ -1422,7 +1422,7 @@ dependencies = [ [[package]] name = "datafusion-execution" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "dashmap", "datafusion-common", @@ -1439,7 +1439,7 @@ dependencies = [ [[package]] name = "datafusion-expr" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "ahash 0.8.3", "arrow", @@ -1453,7 +1453,7 @@ dependencies = [ [[package]] name = "datafusion-optimizer" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "arrow", "async-trait", @@ -1470,7 +1470,7 @@ dependencies = [ [[package]] name = "datafusion-physical-expr" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "ahash 0.8.3", "arrow", @@ -1504,7 +1504,7 @@ dependencies = [ [[package]] name = "datafusion-proto" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "arrow", "chrono", @@ -1518,7 +1518,7 @@ dependencies = [ [[package]] name = "datafusion-row" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "arrow", "datafusion-common", @@ -1529,7 +1529,7 @@ dependencies = [ [[package]] name = "datafusion-sql" version = "27.0.0" -source = "git+https://github.com/apache/arrow-datafusion.git?rev=311e8c7c7ab8c087f072eeac9335394c09ae8185#311e8c7c7ab8c087f072eeac9335394c09ae8185" +source = "git+https://github.com/apache/arrow-datafusion.git?rev=04ecaf7405dbbfd43f43acec972f2435ada5ee81#04ecaf7405dbbfd43f43acec972f2435ada5ee81" dependencies = [ "arrow", "arrow-schema", diff --git a/Cargo.toml b/Cargo.toml index b4aee42363..9d2418983c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -121,8 +121,8 @@ license = "MIT OR Apache-2.0" [workspace.dependencies] arrow = { version = "43.0.0" } arrow-flight = { version = "43.0.0" } -datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false } -datafusion-proto = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185" } +datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "04ecaf7405dbbfd43f43acec972f2435ada5ee81", default-features = false } +datafusion-proto = { git = "https://github.com/apache/arrow-datafusion.git", rev = "04ecaf7405dbbfd43f43acec972f2435ada5ee81" } hashbrown = { version = "0.14.0" } object_store = { version = "0.6.0" } diff --git a/workspace-hack/Cargo.toml b/workspace-hack/Cargo.toml index 72d6c3a077..17a2b27847 100644 --- a/workspace-hack/Cargo.toml +++ b/workspace-hack/Cargo.toml @@ -30,9 +30,9 @@ bytes = { version = "1" } chrono = { version = "0.4", default-features = false, features = ["alloc", "clock", "serde"] } crossbeam-utils = { version = "0.8" } crypto-common = { version = "0.1", default-features = false, features = ["std"] } -datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185" } -datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false, features = ["crypto_expressions", "regex_expressions", "unicode_expressions"] } -datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "311e8c7c7ab8c087f072eeac9335394c09ae8185", default-features = false, features = ["crypto_expressions", "encoding_expressions", "regex_expressions", "unicode_expressions"] } +datafusion = { git = "https://github.com/apache/arrow-datafusion.git", rev = "04ecaf7405dbbfd43f43acec972f2435ada5ee81" } +datafusion-optimizer = { git = "https://github.com/apache/arrow-datafusion.git", rev = "04ecaf7405dbbfd43f43acec972f2435ada5ee81", default-features = false, features = ["crypto_expressions", "regex_expressions", "unicode_expressions"] } +datafusion-physical-expr = { git = "https://github.com/apache/arrow-datafusion.git", rev = "04ecaf7405dbbfd43f43acec972f2435ada5ee81", default-features = false, features = ["crypto_expressions", "encoding_expressions", "regex_expressions", "unicode_expressions"] } digest = { version = "0.10", features = ["mac", "std"] } either = { version = "1" } fixedbitset = { version = "0.4" } From a9e40c1a90fe3f9fa866f2f072b44c4f06af8b67 Mon Sep 17 00:00:00 2001 From: wiedld Date: Wed, 12 Jul 2023 13:50:03 -0700 Subject: [PATCH 35/37] fix(8191): directory path resolve (#8205) --- Cargo.lock | 1 + tracker/Cargo.toml | 1 + tracker/src/disk_metric.rs | 23 +++++++++++++++++++---- 3 files changed, 21 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 715bda21a2..8111e7daa0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6135,6 +6135,7 @@ dependencies = [ "parking_lot 0.12.1", "pin-project", "sysinfo", + "tempfile", "tokio", "tokio-util", "trace", diff --git a/tracker/Cargo.toml b/tracker/Cargo.toml index 925e804cb1..7cf48e3f16 100644 --- a/tracker/Cargo.toml +++ b/tracker/Cargo.toml @@ -22,5 +22,6 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" } sysinfo = "0.29.4" [dev-dependencies] +tempfile = "3.6.0" # Need the multi-threaded executor for testing tokio = { version = "1.29", features = ["macros", "parking_lot", "rt-multi-thread", "time"] } diff --git a/tracker/src/disk_metric.rs b/tracker/src/disk_metric.rs index fe92597904..c2772a1237 100644 --- a/tracker/src/disk_metric.rs +++ b/tracker/src/disk_metric.rs @@ -27,8 +27,10 @@ pub struct DiskSpaceMetrics { impl DiskSpaceMetrics { /// Create a new [`DiskSpaceMetrics`], returning [`None`] if no disk can be /// found for the specified `directory`. - pub fn new(mut directory: PathBuf, registry: &metric::Registry) -> Option { + pub fn new(directory: PathBuf, registry: &metric::Registry) -> Option { let path: Cow<'static, str> = Cow::from(directory.display().to_string()); + let mut directory = directory.canonicalize().ok()?; + let attributes = Attributes::from([("path", path)]); let available_disk_space = registry @@ -49,6 +51,7 @@ impl DiskSpaceMetrics { let system = System::new_with_specifics(RefreshKind::new().with_disks_list()); // Resolve the mount point once. + // The directory path may be `/path/to/dir` and the mount point is `/`. let disk_idx = loop { if let Some((idx, _disk)) = system .disks() @@ -99,15 +102,27 @@ mod tests { use std::{sync::Arc, time::Instant}; use metric::Metric; + use tempfile::tempdir_in; use super::*; #[tokio::test] async fn test_metrics() { + let tmp_dir = tempdir_in(".").ok().unwrap(); + let path = tmp_dir.path().display().to_string(); + // TempDir creates a directory in current directory, so test the relative path (if possible). + let path = match path.find("/./") { + Some(index) => &path[index + 3..], + None => &path[..], + }; + + let pathbuf = PathBuf::from(path); + let metric_label: Cow<'static, str> = path.to_string().into(); + let registry = Arc::new(metric::Registry::new()); let _handle = tokio::spawn( - DiskSpaceMetrics::new(PathBuf::from("/"), ®istry) + DiskSpaceMetrics::new(pathbuf, ®istry) .expect("root always exists") .run(), ); @@ -124,14 +139,14 @@ mod tests { let recorded_free_metric = registry .get_instrument::>("disk_space_free") .expect("metric should exist") - .get_observer(&Attributes::from(&[("path", "/")])) + .get_observer(&Attributes::from([("path", metric_label.clone())])) .expect("metric should have labels") .fetch(); let recorded_total_metric = registry .get_instrument::>("disk_capacity_total") .expect("metric should exist") - .get_observer(&Attributes::from(&[("path", "/")])) + .get_observer(&Attributes::from([("path", metric_label.clone())])) .expect("metric should have labels") .fetch(); From 48a5c3e96636c3f9d4e025adcaf62e19ec2b9b1c Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Thu, 13 Jul 2023 06:14:59 -0400 Subject: [PATCH 36/37] chore: Add longer sleep in `end_to_end_cases::debug::build_catalog` and extra logging (#8224) * fix: Add longer sleep in end_to_end_cases::debug::build_catalog * chore: add debug logging when test fails --------- Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- influxdb_iox/tests/end_to_end_cases/debug.rs | 136 +++++++++++++------ 1 file changed, 98 insertions(+), 38 deletions(-) diff --git a/influxdb_iox/tests/end_to_end_cases/debug.rs b/influxdb_iox/tests/end_to_end_cases/debug.rs index da50bc0c87..937c91c430 100644 --- a/influxdb_iox/tests/end_to_end_cases/debug.rs +++ b/influxdb_iox/tests/end_to_end_cases/debug.rs @@ -1,5 +1,10 @@ //! Tests the `influxdb_iox debug` commands -use std::{path::Path, time::Duration}; +use std::{ + collections::VecDeque, + io::Write, + path::{Path, PathBuf}, + time::Duration, +}; use arrow::record_batch::RecordBatch; use arrow_util::assert_batches_sorted_eq; @@ -105,20 +110,18 @@ async fn build_catalog() { // We can build a catalog and start up the server and run a query let restarted = RestartedServer::build_catalog_and_start(&table_dir).await; - let batches = run_sql_until_non_empty(&restarted, sql, namespace.as_str()) - .with_timeout(Duration::from_secs(2)) - .await - .expect("timed out waiting for non-empty batches in result"); + let batches = restarted + .run_sql_until_non_empty(sql, namespace.as_str()) + .await; assert_batches_sorted_eq!(&expected, &batches); // We can also rebuild a catalog from just the parquet files let only_parquet_dir = copy_only_parquet_files(&table_dir); let restarted = RestartedServer::build_catalog_and_start(only_parquet_dir.path()).await; - let batches = run_sql_until_non_empty(&restarted, sql, namespace.as_str()) - .with_timeout(Duration::from_secs(2)) - .await - .expect("timed out waiting for non-empty batches in result"); + let batches = restarted + .run_sql_until_non_empty(sql, namespace.as_str()) + .await; assert_batches_sorted_eq!(&expected, &batches); } .boxed() @@ -129,23 +132,6 @@ async fn build_catalog() { .await } -/// Loops forever, running the SQL query against the [`RestartedServer`] given -/// until the result is non-empty. Callers are responsible for timing out the -/// function. -async fn run_sql_until_non_empty( - restarted: &RestartedServer, - sql: &str, - namespace: &str, -) -> Vec { - loop { - let batches = restarted.run_sql(sql, namespace).await; - if !batches.is_empty() { - return batches; - } - tokio::time::sleep(Duration::from_millis(100)).await; - } -} - /// An all in one instance, with data directory of `data_dir` struct RestartedServer { all_in_one: ServerFixture, @@ -183,27 +169,40 @@ impl RestartedServer { println!("target_directory: {data_dir:?}"); // call `influxdb_iox debug build-catalog ` - Command::cargo_bin("influxdb_iox") + let cmd = Command::cargo_bin("influxdb_iox") .unwrap() // use -v to enable logging so we can check the status messages - .arg("-v") + .arg("-vv") .arg("debug") .arg("build-catalog") .arg(exported_table_dir.as_os_str().to_str().unwrap()) .arg(data_dir.path().as_os_str().to_str().unwrap()) .assert() - .success() - .stdout( - predicate::str::contains("Beginning catalog / object_store build") - .and(predicate::str::contains( - "Begin importing files total_files=1", - )) - .and(predicate::str::contains( - "Completed importing files total_files=1", - )), - ); + .success(); + + // debug information to track down https://github.com/influxdata/influxdb_iox/issues/8203 + println!("***** Begin build-catalog STDOUT ****"); + std::io::stdout() + .write_all(&cmd.get_output().stdout) + .unwrap(); + println!("***** Begin build-catalog STDERR ****"); + std::io::stdout() + .write_all(&cmd.get_output().stderr) + .unwrap(); + println!("***** DONE ****"); + + cmd.stdout( + predicate::str::contains("Beginning catalog / object_store build") + .and(predicate::str::contains( + "Begin importing files total_files=1", + )) + .and(predicate::str::contains( + "Completed importing files total_files=1", + )), + ); println!("Completed rebuild in {data_dir:?}"); + RecursiveDirPrinter::new().print(data_dir.path()); // now, start up a new server in all-in-one mode // using the newly built data directory @@ -215,6 +214,27 @@ impl RestartedServer { data_dir, } } + + /// Runs the SQL query against this server, in a loop until + /// results are returned. Panics if the results are not produced + /// within a 5 seconds + async fn run_sql_until_non_empty(&self, sql: &str, namespace: &str) -> Vec { + let timeout = Duration::from_secs(5); + let loop_sleep = Duration::from_millis(500); + let fut = async { + loop { + let batches = self.run_sql(sql, namespace).await; + if !batches.is_empty() { + return batches; + } + tokio::time::sleep(loop_sleep).await; + } + }; + + fut.with_timeout(timeout) + .await + .expect("timed out waiting for non-empty batches in result") + } } /// Copies only parquet files from the source directory to a new @@ -240,3 +260,43 @@ fn copy_only_parquet_files(src: &Path) -> TempDir { } target_dir } + +/// Prints out the contents of the directory recursively +/// for debugging. +/// +/// ```text +/// RecursiveDirPrinter All files rooted at "/tmp/.tmpvf16r0" +/// "/tmp/.tmpvf16r0" +/// "/tmp/.tmpvf16r0/catalog.sqlite" +/// "/tmp/.tmpvf16r0/object_store" +/// "/tmp/.tmpvf16r0/object_store/1" +/// "/tmp/.tmpvf16r0/object_store/1/1" +/// "/tmp/.tmpvf16r0/object_store/1/1/b862a7e9b329ee6a418cde191198eaeb1512753f19b87a81def2ae6c3d0ed237" +/// "/tmp/.tmpvf16r0/object_store/1/1/b862a7e9b329ee6a418cde191198eaeb1512753f19b87a81def2ae6c3d0ed237/d78abef6-6859-48eb-aa62-3518097fbb9b.parquet" +/// +struct RecursiveDirPrinter { + paths: VecDeque, +} + +impl RecursiveDirPrinter { + fn new() -> Self { + Self { + paths: VecDeque::new(), + } + } + + // print root and all directories + fn print(mut self, root: &Path) { + println!("RecursiveDirPrinter All files rooted at {root:?}"); + self.paths.push_back(PathBuf::from(root)); + + while let Some(path) = self.paths.pop_front() { + println!("{path:?}"); + if path.is_dir() { + for entry in std::fs::read_dir(path).unwrap() { + self.paths.push_front(entry.unwrap().path()); + } + } + } + } +} From 9bfec2f77c1428cc985eab8da0fdceaf8dbe4b4c Mon Sep 17 00:00:00 2001 From: Andrew Lamb Date: Thu, 13 Jul 2023 06:27:13 -0400 Subject: [PATCH 37/37] fix: ignore flaky test while it is debugged (#8227) Co-authored-by: kodiakhq[bot] <49736102+kodiakhq[bot]@users.noreply.github.com> --- influxdb_iox/tests/end_to_end_cases/debug.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/influxdb_iox/tests/end_to_end_cases/debug.rs b/influxdb_iox/tests/end_to_end_cases/debug.rs index 937c91c430..40a43f9611 100644 --- a/influxdb_iox/tests/end_to_end_cases/debug.rs +++ b/influxdb_iox/tests/end_to_end_cases/debug.rs @@ -52,6 +52,8 @@ async fn test_print_cpu() { /// 3. Start a all-in-one instance from that rebuilt catalog /// 4. Can run a query successfully #[tokio::test] +// Ignore due to https://github.com/influxdata/influxdb_iox/issues/8203 +#[ignore] async fn build_catalog() { test_helpers::maybe_start_logging(); let database_url = maybe_skip_integration!();