1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
extern crate libc;
extern crate mcpat_sys as raw;
#[cfg(feature = "caching")]
extern crate hiredis;
use std::fmt::{self, Display, Formatter};
use std::marker::PhantomData;
use std::path::Path;
#[derive(Clone, Debug)]
pub struct Error {
pub kind: ErrorKind,
pub message: Option<String>,
}
#[derive(Clone, Copy, Debug)]
pub enum ErrorKind {
OutOfMemory,
NotFound,
Other,
}
pub type Result<T> = std::result::Result<T, Error>;
macro_rules! raise(
($message:expr) => (raise!(Other, $message));
($kind:ident, $message:expr) => (
return Err(::Error {
kind: ::ErrorKind::$kind,
message: Some($message.to_string()),
})
);
);
macro_rules! str_to_cstr(
($string:expr) => (match ::std::ffi::CString::new($string) {
Ok(string) => string,
Err(_) => raise!("failed to process a string"),
});
);
macro_rules! path_to_cstr(
($path:expr) => (match $path.to_str() {
Some(path) => str_to_cstr!(path),
None => raise!("failed to process a path"),
});
);
macro_rules! not_null(
($result:expr) => ({
let pointer = $result;
if pointer.is_null() {
raise!(OutOfMemory, "cannot allocate memory");
}
pointer
});
);
macro_rules! debug_not_null(
($result:expr) => ({
let pointer = $result;
debug_assert!(!pointer.is_null());
pointer
});
);
pub type Raw<T> = (*mut T, *mut raw::root_system);
type Phantom<'l, T> = PhantomData<(T, &'l raw::root_system)>;
mod cache;
mod component;
mod core;
mod processor;
mod system;
#[cfg(feature = "caching")]
pub mod caching;
pub use cache::{Cache, L3};
pub use component::Component;
pub use core::Core;
pub use processor::{Cores, L3s, Processor};
pub use system::System;
impl Display for Error {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
match self.message {
Some(ref message) => Display::fmt(message, formatter),
None => Display::fmt(&self.kind, formatter),
}
}
}
impl Display for ErrorKind {
fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
use ErrorKind::*;
match *self {
OutOfMemory => write!(formatter, "out of memory"),
NotFound => write!(formatter, "file not found"),
Other => write!(formatter, "other"),
}
}
}
#[inline]
pub fn open<T: AsRef<Path>>(path: T) -> Result<System> {
System::open(path)
}
#[inline]
pub fn optimize_for_clock_rate(value: bool) {
unsafe { raw::opt_for_clk_set(if value { 1 } else { 0 }) };
}