publish v0.4.5

Author: chyyuu-tsinghua-cs

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "arceos-msgqueue"
-version = "0.4.4"
+version = "0.4.5"
 edition = "2024"
 authors = ["Lei Shi <shi_lei@massclouds.com>", "Yu Chen <yuchen@tsinghua.edu.cn>"]
 description = "A message-queue crate (from crates.io) for ArceOS demonstrating cooperative multi-task scheduling with PFlash MMIO"
@@ -18,6 +18,7 @@ include = [
     "rust-toolchain.toml",
     "README.md",
     "LICENSE*",
+    "exercise/**",
 ]
 
 [features]

Cargo.toml

@@ -165,6 +165,21 @@ cross-compilation and QEMU execution:
 | `paging` feature | Enables page table management; maps MMIO regions listed in config |
 | `multitask` feature | Enables multi-task scheduler with cooperative scheduling support |
 
+## Exercise
+### Requirements
+Based on the `arceos-msgqueue` kernel component and the reference code under the `exercise` directory, implement a new kernel functional component for the memory allocator named `bump_allocator` (based on the `bump` memory allocation algorithm), as well as the corresponding kernel component `arceos-msgqueue-alt-alloc`. You are required to modify the implementation of the `exercise/modules/bump_allocator` component as much as possible to support the `bump` memory allocation algorithm, and modify other parts as little as possible.
+
+### Expectation
+```
+Running bump tests...
+Bump tests run OK!
+```
+
+### Tips
+1. You can refer to the existing page allocator and byte allocator to implement the corresponding Traits.
+2. This `bump_allocator` acts as both a byte allocator and a page allocator. Therefore, it must implement three Traits: `BaseAllocator`, `ByteAllocator`, and `PageAllocator` simultaneously. This is different from the existing references.
+
+
 ## ArceOS Tutorial Crates
 
 This crate is part of a series of tutorial crates for learning OS development with [ArceOS](https://github.com/arceos-org/arceos). The crates are organized by functionality and complexity progression:

README.md

@@ -0,0 +1,88 @@
+#![no_std]
+
+use allocator::{BaseAllocator, ByteAllocator, PageAllocator};
+
+/// Early memory allocator
+/// Use it before formal bytes-allocator and pages-allocator can work!
+/// This is a double-end memory range:
+/// - Alloc bytes forward
+/// - Alloc pages backward
+///
+/// [ bytes-used | avail-area | pages-used ]
+/// |            | -->    <-- |            |
+/// start       b_pos        p_pos       end
+///
+/// For bytes area, 'count' records number of allocations.
+/// When it goes down to ZERO, free bytes-used area.
+/// For pages area, it will never be freed!
+///
+pub struct EarlyAllocator<const SIZE: usize> {}
+
+impl<const SIZE: usize> EarlyAllocator<SIZE> {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<const SIZE: usize> BaseAllocator for EarlyAllocator<SIZE> {
+    fn init(&mut self, start: usize, size: usize) {
+        todo!()
+    }
+
+    fn add_memory(&mut self, start: usize, size: usize) -> allocator::AllocResult {
+        todo!()
+    }
+}
+
+impl<const SIZE: usize> ByteAllocator for EarlyAllocator<SIZE> {
+    fn alloc(
+        &mut self,
+        layout: core::alloc::Layout,
+    ) -> allocator::AllocResult<core::ptr::NonNull<u8>> {
+        todo!()
+    }
+
+    fn dealloc(&mut self, pos: core::ptr::NonNull<u8>, layout: core::alloc::Layout) {
+        todo!()
+    }
+
+    fn total_bytes(&self) -> usize {
+        todo!()
+    }
+
+    fn used_bytes(&self) -> usize {
+        todo!()
+    }
+
+    fn available_bytes(&self) -> usize {
+        todo!()
+    }
+}
+
+impl<const SIZE: usize> PageAllocator for EarlyAllocator<SIZE> {
+    const PAGE_SIZE: usize = SIZE;
+
+    fn alloc_pages(
+        &mut self,
+        num_pages: usize,
+        align_pow2: usize,
+    ) -> allocator::AllocResult<usize> {
+        todo!()
+    }
+
+    fn dealloc_pages(&mut self, pos: usize, num_pages: usize) {
+        todo!()
+    }
+
+    fn total_pages(&self) -> usize {
+        todo!()
+    }
+
+    fn used_pages(&self) -> usize {
+        todo!()
+    }
+
+    fn available_pages(&self) -> usize {
+        todo!()
+    }
+}

exercise/modules/bump_allocator/Cargo.toml.orig

@@ -0,0 +1,26 @@
+#![cfg_attr(feature = "axstd", no_std)]
+#![cfg_attr(feature = "axstd", no_main)]
+
+#[macro_use]
+#[cfg(feature = "axstd")]
+extern crate axstd as std;
+extern crate alloc;
+
+use alloc::vec::Vec;
+
+#[cfg_attr(feature = "axstd", no_mangle)]
+fn main() {
+    println!("Running bump tests...");
+
+    const N: usize = 3_000_000;
+    let mut v = Vec::with_capacity(N);
+    for i in 0..N {
+        v.push(i);
+    }
+    v.sort();
+    for i in 0..N - 1 {
+        assert!(v[i] <= v[i + 1]);
+    }
+
+    println!("Bump tests run OK!");
+}