initial commit

Author: fereidani

.github/workflows/pipeline.yaml

@@ -0,0 +1,62 @@
+name: pipeline
+
+on:
+  push:
+    branches:
+      - main
+      - feature/*
+  pull_request:
+    branches:
+      - main
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  cargo_fmt:
+    name: "Cargo Format"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install nightly toolchain
+        run: rustup toolchain install nightly --component rustfmt
+      - name: Check formatting
+        run: cargo +nightly fmt --all -- --check
+  cargo_clippy:
+    name: "Cargo Clippy"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Clippy
+        run: rustup component add clippy
+      - name: Run Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+  cargo_test:
+    name: "Cargo Test"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build
+        run: cargo build --verbose
+      - name: Test with Cargo
+        run: cargo test --verbose
+  cargo_test_release:
+    name: "Cargo Test (Release)"
+    runs-on: ubuntu-latest
+    needs: [cargo_test]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build
+        run: cargo build --release --verbose
+      - name: Test with Cargo (Release)
+        run: cargo test --release --verbose
+  cargo_test_no_default_features:
+    name: "Cargo Test (No Default Features)"
+    runs-on: ubuntu-latest
+    needs: [cargo_test_release]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build
+        run: cargo build --no-default-features --verbose
+      - name: Test with Cargo (No Default Features)
+        run: cargo test --no-default-features --verbose

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,21 @@
+[package]
+name = "stack-allocator"
+version = "0.1.0"
+edition = "2021"
+authors = ["Khashayar Fereidani"]
+description = "A stack-based memory allocator with optional fallback to a global/secondary allocator."
+license = "MIT"
+repository = "https://github.com/fereidani/stack-allocator"
+readme = "README.md"
+keywords = ["allocator", "stack", "alloc", "memory-management", "no-std"]
+categories = ["data-structures", "no-std"]
+
+[dependencies]
+allocator-api2 = "0"
+
+[build-dependencies]
+rustc_version = "0.4"
+
+[features]
+std = []
+alloc = []

Cargo.toml

@@ -0,0 +1,7 @@
+Copyright 2025 Khashayar Fereidani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE

@@ -0,0 +1,58 @@
+# Stack Allocator
+
+[![Crates.io](https://img.shields.io/crates/v/stack-allocator.svg)](https://crates.io/crates/stack-allocator)
+[![Documentation](https://docs.rs/stack-allocator/badge.svg)](https://docs.rs/stack-allocator)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+This crate provides two allocator types:
+
+- **`StackAllocator<N>`** - a bump‑allocator that uses a fixed‑size buffer stored on the stack (or in static memory). Allocations are fast and require no system calls. Individual blocks can be freed/shrinked/growed but only if they are the latest allocation.
+
+- **`HybridAllocator<N, F>`** - a hybrid allocator that first tries to allocate from a `StackAllocator<N>` and, if the stack buffer is exhausted, falls back to a user‑provided allocator `F` (e.g. `std::alloc::Global`). This gives the performance benefits of stack allocation while still supporting unbounded allocations via the fallback.
+
+## Features
+
+- **`allocator_api`** - uses the nightly `allocator_api` feature to implement `std::alloc::Allocator`.
+- **`allocator-api2`** – A stable fallback that mirrors the core allocation API, allowing this crate to be used on stable Rust with libraries like `hashbrown` that depend on `allocator-api2`.
+  **Note:** This crate is `#![no_std]` compatible.
+
+## Usage
+
+```rust:ignore
+#![feature(allocator_api)]
+use stack_allocator::{StackAllocator, HybridAllocator};
+use std::alloc::Global;
+
+// A pure stack allocator with a 1 KiB buffer.
+let mut stack = StackAllocator::<1024>::new();
+let mut v = Vec::new_in(stack);
+for i in 0..10 {
+    v.push(i);
+}
+assert_eq!(v.len(), 10);
+for (i, &val) in v.iter().enumerate() {
+    assert_eq!(i, val);
+}
+v.clear();
+assert_eq!(v.len(), 0);
+v.shrink_to_fit();
+assert_eq!(v.capacity(), 0);
+
+// A hybrid allocator that falls back to the global allocator(heap).
+let hybrid = HybridAllocator::<1024, Global>::new(Global);
+let mut v = Vec::new_in(hybrid);
+for i in 0..2048 {
+    v.push(i);
+}
+assert_eq!(v.len(), 2048);
+for (i, &val) in v.iter().enumerate() {
+    assert_eq!(i, val);
+}
+v.clear();
+assert_eq!(v.len(), 0);
+v.shrink_to_fit();
+assert_eq!(v.capacity(), 0);
+```
+
+The crate is `#![no_std]` compatible.
+It is usable in stable rust using `allocator-api2`.

README.md

@@ -0,0 +1,10 @@
+use rustc_version::{version_meta, Channel};
+
+fn main() {
+    if let Ok(meta) = version_meta() {
+        if meta.channel == Channel::Nightly {
+            println!("cargo:rustc-cfg=nightly");
+        }
+    }
+    println!("cargo::rustc-check-cfg=cfg(nightly)");
+}