collam

A naive and thread safe general-purpose allocator written in Rust built with #[no_std]. This project started as an experiment to get comfortable with #[no_std] environments and unsafe Rust. This library is currently NOT stable and I'm sure there are plenty of bugs, be warned!

A note on its state

Collam implements the GlobalAlloc trait and can be used within Rust. The sub-crate posix exposes malloc, calloc, realloc, free, malloc_usable_size, mallopt and can be used for arbitrary programs, in its current state its working with almost all tested programs using LD_PRELOAD.

Tested platforms

[x] Linux x86_64

Implementation details

Bookkeeping is currently done with an intrusive doubly linked list. The overhead for each use allocated block is 16 bytes whereas only 12 bytes of them are used.

Performance

In regards of memory usage/overhead it is comparable to dlmalloc with tested applications, however the performance is not there yet.

Usage within Rust

use collam::alloc::Collam;

#[global_allocator]
static ALLOC: Collam = Collam::new();

fn main() {
    let mut vec = Vec::new();
    vec.push(42);
    assert_eq!(vec.pop().unwrap(), 42);
}

Testing collam in C/POSIX environment

Make sure you have Rust nightly. Manually overwrite default allocator:

$ cargo build --manifest-path posix/Cargo.toml --release
$ LD_PRELOAD="$(pwd)/posix/target/release/libcollam.so" kwrite

Or use the test script in the root folder:

$ ./scripts/test.sh kwrite

There are some more helper scripts for debugging, profiling, etc. See scripts/ folder.

Execute tests

Tests are not thread safe, make sure to force 1 thread only!

$ cargo test --all-features -- --test-threads 1

TODO:

• Proper Page handling
• mmap support
• Thread-local allocation
• Logarithmic-time complexity allocation
• Support for different architectures
• Proper logging