Skip to content

New buddy allocator tests + bug fixes #26

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Akshay-Srivatsan merged 16 commits into from
Apr 20, 2026
Merged

New buddy allocator tests + bug fixes #26

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
e2f5f4b
Added basic testing for arca types and kernel types based on code. Pe…
Feb 2, 2026
a0f61f4
Added a ton of tests for buddy allocator. Most pass, but a couple fai…
Feb 9, 2026
a9caf17
fixed formatting and recommitted
Feb 9, 2026
f01ede0
removed the piece causing the error in serde
Feb 9, 2026
30cc5fb
Fixed 4 bugs – two where sizes too small for allocator or indexes too…
Feb 17, 2026
af2f21b
rebased with rust 1.95 changes and fixed warnings
Apr 10, 2026
de4db72
upgrading to rust 1.96
Apr 10, 2026
5bac46f
added test harness
Apr 11, 2026
b78a22c
testing 1
Apr 16, 2026
786bb6b
fix 2
Apr 16, 2026
df18a55
moved tests to inside inidividual files, removed all unnecessary comm…
Apr 16, 2026
6ce6ccd
fixing rust version differences for package support
Apr 16, 2026
737a1d4
allowing unused features
Apr 16, 2026
e6ccbd7
different modules based on rust versions
Apr 16, 2026
0200d7e
build: merge Fix Shell
Akshay-Srivatsan Apr 20, 2026
9f6bf95
refactor: move buddy allocator tests to separate file
Akshay-Srivatsan Apr 20, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion arca/src/serde.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -333,7 +333,7 @@ impl<'de, R: Runtime> Visitor<'de> for TableVisitor<R> {
where
A: serde::de::MapAccess<'de>,
{
let (first_key, first_value): (alloc::string::String, usize) =
let (first_key, first_value): (&str, usize) =
map.next_entry()?.expect("at least one element needed");
assert_eq!(first_key, "len");
let mut table = Table::new(first_value);
Expand Down
181 changes: 17 additions & 164 deletions common/src/buddy.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -413,6 +413,13 @@ impl AllocatorInner {
size: 1 << size_log2,
});
}
// Check if index is within valid range for this level
if index >= self.size_of_level_bits(size_log2) {
return Err(AllocationError::InvalidReservation {
index,
size: 1 << size_log2,
});
}
self.with_level(base, size_log2, |level: &mut AllocatorLevel<'_>| {
if level.reserve(index) {
Ok(index)
Expand Down Expand Up @@ -553,12 +560,15 @@ impl BuddyAllocatorImpl {

// prevent physical zero page from being allocated
assert_eq!(temp.to_offset(temp.reserve_raw(0, 4096)), 0);
// reserve kernel pages
// reserve kernel pages (only if within range)
let mut pages = alloc::vec![];
for i in 0..8 {
let p = temp.reserve_raw(0x100000 * (i + 1), 0x100000);
assert!(!p.is_null());
pages.push(p);
let addr = 0x100000 * (i + 1);
if addr + 0x100000 <= size {
let p = temp.reserve_raw(addr, 0x100000);
assert!(!p.is_null());
pages.push(p);
}
}

let new_inner = AllocatorInner::new_in(slice, &temp);
Expand Down Expand Up @@ -681,6 +691,7 @@ impl BuddyAllocatorImpl {
for (i, item) in ptrs.iter_mut().enumerate() {
let result = self.allocate_raw_unchecked(size);
if result.is_null() {
self.inner.unlock();
return Some(i);
}
*item = result;
Expand All @@ -696,6 +707,7 @@ impl BuddyAllocatorImpl {
for (i, item) in ptrs.iter_mut().enumerate() {
let result = self.allocate_raw_unchecked(size);
if result.is_null() {
self.inner.unlock();
return i;
}
*item = result;
Expand Down Expand Up @@ -1139,163 +1151,4 @@ unsafe impl Allocator for BuddyAllocator {
}

#[cfg(test)]
mod tests {
extern crate test;

use super::*;
use test::Bencher;

#[test]
fn test_bitref() {
let mut word = 10;

let mut r0 = BitRef::new(&mut word, 0);
r0.set();

let mut r1 = BitRef::new(&mut word, 1);
r1.clear();

let mut r2 = BitRef::new(&mut word, 2);
r2.write(false);

let mut r3 = BitRef::new(&mut word, 3);
r3.write(true);

assert_eq!(word, 9);
}

#[test]
fn test_bitslice() {
let mut words = [0; 2];
let mut slice = BitSlice::new(128, &mut words);
let mut r0 = slice.bit(0);
r0.set();

let mut r1 = slice.bit(1);
r1.set();

let mut r127 = slice.bit(127);
r127.set();

assert_eq!(words[0], 3);
assert_eq!(
words[127 / (core::mem::size_of::<u64>() * 8)],
1 << (127 % (core::mem::size_of::<u64>() * 8))
);
}

#[test]
fn test_buddy_allocator() {
let allocator = BuddyAllocatorImpl::new(0x10000000);

let test = Box::new_in(10, allocator.clone());
assert_eq!(*test, 10);

let mut v = Vec::new_in(allocator.clone());
for i in 0..10000 {
v.push(i);
}
}

#[bench]
fn bench_allocate_free(b: &mut Bencher) {
let allocator = BuddyAllocatorImpl::new(0x100000000);
b.iter(|| {
let x: Box<[MaybeUninit<u8>], BuddyAllocatorImpl> =
Box::new_uninit_slice_in(128, allocator.clone());
core::mem::drop(x);
});
}

#[bench]
fn bench_allocate_free_no_cache(b: &mut Bencher) {
let allocator = BuddyAllocatorImpl::new(0x100000000);
allocator.set_caching(false);
b.iter(|| {
let x: Box<[MaybeUninit<u8>], BuddyAllocatorImpl> =
Box::new_uninit_slice_in(128, allocator.clone());
core::mem::drop(x);
});
}

#[bench]
fn bench_contended_allocate_free(b: &mut Bencher) {
let allocator = BuddyAllocatorImpl::new(0x100000000);
let f = || {
let x: Box<[MaybeUninit<u8>], BuddyAllocatorImpl> =
Box::new_uninit_slice_in(128, allocator.clone());
core::mem::drop(x);
};
use core::sync::atomic::AtomicBool;
use std::sync::Arc;
std::thread::scope(|s| {
let flag = Arc::new(AtomicBool::new(true));
for _ in 0..16 {
let flag = flag.clone();
s.spawn(move || {
while flag.load(Ordering::SeqCst) {
f();
}
});
}
b.iter(f);
flag.store(false, Ordering::SeqCst);
});
}

#[bench]
#[ignore]
fn bench_contended_allocate_free_no_cache(b: &mut Bencher) {
let allocator = BuddyAllocatorImpl::new(0x100000000);
allocator.set_caching(false);
let f = || {
let x: Box<[MaybeUninit<u8>], BuddyAllocatorImpl> =
Box::new_uninit_slice_in(128, allocator.clone());
core::mem::drop(x);
};
use core::sync::atomic::AtomicBool;
use std::sync::Arc;
std::thread::scope(|s| {
let flag = Arc::new(AtomicBool::new(true));
for _ in 0..16 {
let flag = flag.clone();
s.spawn(move || {
while flag.load(Ordering::SeqCst) {
f();
}
});
}
b.iter(f);
flag.store(false, Ordering::SeqCst);
});
}

#[test]
fn stress_test() {
use std::hash::{BuildHasher, Hasher, RandomState};
let allocator = BuddyAllocatorImpl::new(0x10000000);
allocator.set_caching(false);
let mut v = vec![];
let random = |limit: usize| {
let x: u64 = RandomState::new().build_hasher().finish();
x as usize % limit
};
for _ in 0..100000 {
let used_before = allocator.used_size();
let remaining = allocator.total_size() - used_before;
let size = random(core::cmp::min(1 << 21, remaining / 2));
let alloc =
Box::<[u8], BuddyAllocatorImpl>::new_uninit_slice_in(size, allocator.clone());
let used_after = allocator.used_size();
assert!(used_after >= used_before + size);
if !v.is_empty() && size % 3 == 0 {
let number = random(v.len());
for _ in 0..number {
let index = random(v.len());
v.remove(index);
}
}
v.push(alloc);
}
}
}
mod tests;
Loading
Loading