memu

The memu crate provides rust implementations of digital storage (or memory) units. The maximum amount of storage is 18446.744073709553 Petabyte, conversion between units always happens with a factor of 1024.

The create also provides conversions between units and information about the units such as, unit suffixes and scale factors. As well as optional serde compatibility.

Licensed under MIT.

Example

In the following example we first crate a KiloByte with 913 Kilobytes. We then print it as Gigabytes.

use memu::units::MegaByte;

let kilo_byte = MegaByte::from(913);

println!("{}", kilo_byte.as_giga_byte().as_string_with_unit());

In the next example we first fetch some system info using the sysinfo crate and then print the memory usage for every process. We use the KiloByte::new() method here, since process.memory() returns bytes and the new method constructs the unit from an amount of bytes.

use memu::units::KiloByte;
use sysinfo::{ProcessExt, System, SystemExt};

fn main() {
    let mut sys = System::new_all();
    sys.refresh_all();

    for (pid, process) in sys.processes() {
        let memory = KiloByte::new(process.memory());
        println!("{}: {}", pid, memory.as_string_with_unit())
    }
}

Now we use normal addition with the units to sum all of the processes memory.

use memu::units::Byte;
use sysinfo::{ProcessExt, System, SystemExt};

fn main() {
    let mut sys = System::new_all();
    sys.refresh_all();

    let mut total = Byte::default();

    for (pid, process) in sys.processes() {
        total += process.memory();
    }

    println!("Total: {}", total.as_gigabyte().as_string_with_unit())

    let average = total / sys.processes().len();

    println!("Average: {}", average.as_gigabyte().as_string_with_unit())
}

Features

The crate contains the following features:

• serde, serialize and deserialize data with the serde crate.
• macro, use macros to create the storage structs. Enabled by default.
• units, include text units such as "KB" and "TB". Enabled by default.