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

//! # `interloc`
//! This crate defines an interface for creating allocator middleware,
//! i.e. code that runs when your allocator is run.
//!
//! # Examples
//! ```rust
//! use interloc::{AllocMonitor, AllocAction, InterAlloc, StatsMonitor, ThreadMonitor};
//! use std::alloc::System;
//! use core::alloc::Layout;
//!
//! struct MyMonitor {
//!     pub global: StatsMonitor,
//!     pub local: ThreadMonitor
//! }
//!
//! impl MyMonitor {
//!
//!     // This needs to be const to be usable in static variable declarations.
//!     pub const fn new() -> Self {
//!         Self {
//!             global: StatsMonitor::new(),
//!             local: ThreadMonitor::new(),
//!         }
//!     }
//! }
//!
//! impl AllocMonitor for MyMonitor {
//!     fn monitor(&self, layout: Layout, action: AllocAction) {
//!         self.global.monitor(layout, action);
//!         self.local.monitor(layout, action);
//!     }
//! }
//!
//! static MONITOR: MyMonitor = MyMonitor::new();
//!
//! // This needs to be done at the project root, i.e. `lib.rs` or `main.rs`
//! #[global_allocator]
//! static GLOBAL: InterAlloc<System, MyMonitor> = InterAlloc {
//!     inner: System,
//!     monitor: &MONITOR,
//! };
//!
//! fn use_monitor_in_thread() {
//!     let alloc_info = MONITOR.local.info();
//!     let _allocation_test = Vec::<u8>::with_capacity(100);
//!     println!("{:#?}", MONITOR.local.info().relative_to(&alloc_info));
//! }
//! ```
extern crate lock_api;
extern crate parking_lot;

mod alloc;
mod monitor;

pub use alloc::*;
pub use monitor::*;