Crate memu

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 happends 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.

Modules

constants

Memory constants for conversion between units.

units

The core memory units.

Macros

bytes

Macro for creating a byte instance

giga_byte

Macro for creating a giga byte instance

kilo_bytes

Macro for creating a kilo byte instance

mega_bytes

Macro for creating a mega byte instance

peta_byte

Macro for creating a peta byte instance

tera_byte

Macro for creating a tera byte instance

Traits

MemoryUnit

Trait for converting between memory units.

Functions

best_fit

This functions finds the first memory unit without a leading 0 infront of the comma.