Skip to content

refacto(json): convert for loops to iterators #87

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 31, 2021
Merged

refacto(json): convert for loops to iterators #87

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
117 changes: 53 additions & 64 deletions src/exporters/json.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
use crate::exporters::*;
use crate::sensors::{Record, Sensor, Topology};
use crate::sensors::{Sensor, Topology};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
Expand Down Expand Up @@ -139,83 +139,72 @@ impl JSONExporter {
}
}

fn get_domains_power(&self, socket_id: u16) -> Vec<Option<Record>> {
Copy link
Contributor Author

@jdrouet jdrouet Mar 10, 2021

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

this appears to be non necessary considering you already have the socket

let socket_present = self
.topology
.get_sockets_passive()
.iter()
.find(move |x| x.id == socket_id);

if let Some(socket) = socket_present {
let mut domains_power: Vec<Option<Record>> = vec![];
for d in socket.get_domains_passive() {
domains_power.push(d.get_records_diff_power_microwatts());
}
domains_power
} else {
vec![None, None, None]
}
}

fn iterate(&mut self, parameters: &ArgMatches) {
self.topology.refresh();
self.retrieve_metrics(&parameters);
}

fn retrieve_metrics(&mut self, parameters: &ArgMatches) {
let host_power = match self.topology.get_records_diff_power_microwatts() {
Some(record) => record.value.parse::<u64>().unwrap(),
None => 0,
let host_power = self
.topology
.get_records_diff_power_microwatts()
.map(|record| record.value.parse::<u64>().unwrap())
.unwrap_or(0);

let host_stat = match self.topology.get_stats_diff() {
Some(value) => value,
None => return,
};

let consumers = self.topology.proc_tracker.get_top_consumers(10);
let mut top_consumers = Vec::new();
for c in consumers.iter() {
if let Some(host_stat) = self.topology.get_stats_diff() {
let top_consumers = consumers
.iter()
.map(|(process, value)| {
let host_time = host_stat.total_time_jiffies();
let consumer = Consumer {
exe: c.0.exe().unwrap_or_default(),
pid: c.0.pid,
consumption: ((c.1 as f32
Consumer {
exe: process.exe().unwrap_or_default(),
pid: process.pid,
consumption: ((*value as f32
/ (host_time * procfs::ticks_per_second().unwrap() as f32))
* host_power as f32),
};
top_consumers.push(consumer)
}
}
}
})
.collect::<Vec<_>>();

let mut index = 0;
let names = ["core", "uncore", "dram"];
let mut all_sockets = Vec::new();
let sockets = self.topology.get_sockets_passive();
for s in sockets {
let socket_power = match s.get_records_diff_power_microwatts() {
Some(record) => record.value.parse::<u64>().unwrap(),
None => 0,
};

let v = (socket_power, self.get_domains_power(s.id));
let mut domains = Vec::new();

for d in v.1.iter() {
let domain_power = match d {
Some(record) => record.value.parse::<u64>().unwrap(),
None => 0,
};

domains.push(Domain {
name: names[index].to_string(),
consumption: domain_power as f32,
});
index += 1
}

all_sockets.push(Socket {
id: s.id,
consumption: (v.0 as f32),
domains,
});
}
let all_sockets = self
.topology
.get_sockets_passive()
.iter()
.map(|socket| {
let socket_power = socket
.get_records_diff_power_microwatts()
.map(|record| record.value.parse::<u64>().unwrap())
.unwrap_or(0);

let domains = socket
.get_domains_passive()
.iter()
.map(|d| d.get_records_diff_power_microwatts())
.map(|record| record.map(|d| d.value))
.enumerate()
.map(|(index, d)| {
let domain_power =
d.map(|value| value.parse::<u64>().unwrap()).unwrap_or(0);
Domain {
name: names[index].to_string(),
consumption: domain_power as f32,
}
})
.collect::<Vec<_>>();

Socket {
id: socket.id,
consumption: (socket_power as f32),
domains,
}
})
.collect::<Vec<_>>();

let report = Report {
host: host_power as f32,
Expand Down