omnimalloc 0.5.0__tar.gz → 0.6.0__tar.gz

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/.gitignore

@@ -53,6 +53,10 @@ htmlcov/
 *.gcov.json.gz
 **/artifacts/
 
+# Benchmark script outputs (scripts/*.py --out)
+benchmark_results_*/
+stress_results_*/
+
 # OS
 .DS_Store
 Thumbs.db

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/CMakeLists.txt

@@ -42,18 +42,18 @@ nanobind_add_module(
   NOMINSIZE
   src/cpp/allocators/best_fit.cpp
   src/cpp/allocators/first_fit.cpp
-  src/cpp/allocators/greedy.cpp
   src/cpp/allocators/local_search.cpp
   src/cpp/allocators/omni.cpp
   src/cpp/allocators/simulated_annealing.cpp
-  src/cpp/allocators/supermalloc/partition.cpp
+  src/cpp/allocators/supermalloc.cpp
   src/cpp/allocators/tabu_search.cpp
   src/cpp/allocators/telamalloc.cpp
+  src/cpp/analysis/antichain.cpp
+  src/cpp/analysis/closure.cpp
+  src/cpp/analysis/conflicts.cpp
+  src/cpp/analysis/linearize.cpp
+  src/cpp/analysis/placement.cpp
   src/cpp/primitives/allocation.cpp
-  src/cpp/primitives/antichain.cpp
-  src/cpp/primitives/closure.cpp
-  src/cpp/primitives/linearize.cpp
-  src/cpp/primitives/placement.cpp
   src/cpp/bindings.cpp)
 
 target_include_directories(_cpp PRIVATE src/cpp)

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omnimalloc
-Version: 0.5.0
+Version: 0.6.0
 Summary: Your one-stop shop for static memory allocation.
 Keywords: memory,allocation,allocator,static-allocation
 Author-Email: Fabian Peddinghaus <fabianpedd@gmail.com>
@@ -274,15 +274,15 @@ pip install git+https://github.com/fpedd/omnimalloc.git
 ## Usage
 
 ```python
-from omnimalloc import Allocation, Pool, run_allocation
+import omnimalloc as om
 
-pool = Pool(id="pool", allocations=(
-    Allocation(id=0, size=64, start=0, end=10),
-    Allocation(id=1, size=64, start=12, end=20),
-    Allocation(id=2, size=32, start=5, end=15),
+pool = om.Pool(id="pool", allocations=(
+    om.Allocation(id=0, size=64, start=0, end=10),
+    om.Allocation(id=1, size=64, start=12, end=20),
+    om.Allocation(id=2, size=32, start=5, end=15),
 ))
 
-pool = run_allocation(pool, allocator="supermalloc_allocator", validate=True)
+pool = om.allocate(pool, allocator="supermalloc", validate=True)
 
 print(pool.size)                                     # 96
 print([alloc.offset for alloc in pool.allocations])  # [0, 0, 64]
@@ -335,4 +335,4 @@ uv run pre-commit run --all-files
 
 ## License
 
-Copyright 2025 Fabian Peddinghaus. Licensed under Apache 2.0 License. See [LICENSE](LICENSE) for details.
+Copyright 2025-2026 Fabian Peddinghaus. Licensed under Apache 2.0 License. See [LICENSE](LICENSE) for details.

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/README.md

@@ -38,15 +38,15 @@ pip install git+https://github.com/fpedd/omnimalloc.git
 ## Usage
 
 ```python
-from omnimalloc import Allocation, Pool, run_allocation
+import omnimalloc as om
 
-pool = Pool(id="pool", allocations=(
-    Allocation(id=0, size=64, start=0, end=10),
-    Allocation(id=1, size=64, start=12, end=20),
-    Allocation(id=2, size=32, start=5, end=15),
+pool = om.Pool(id="pool", allocations=(
+    om.Allocation(id=0, size=64, start=0, end=10),
+    om.Allocation(id=1, size=64, start=12, end=20),
+    om.Allocation(id=2, size=32, start=5, end=15),
 ))
 
-pool = run_allocation(pool, allocator="supermalloc_allocator", validate=True)
+pool = om.allocate(pool, allocator="supermalloc", validate=True)
 
 print(pool.size)                                     # 96
 print([alloc.offset for alloc in pool.allocations])  # [0, 0, 64]
@@ -99,4 +99,4 @@ uv run pre-commit run --all-files
 
 ## License
 
-Copyright 2025 Fabian Peddinghaus. Licensed under Apache 2.0 License. See [LICENSE](LICENSE) for details.
+Copyright 2025-2026 Fabian Peddinghaus. Licensed under Apache 2.0 License. See [LICENSE](LICENSE) for details.

omnimalloc-0.6.0/examples/01_basic.py

@@ -0,0 +1,26 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import omnimalloc as om
+
+
+def main() -> None:
+    # Define allocations with temporal bounds
+    alloc_0 = om.Allocation(id="alloc_0", size=5, start=0, end=10)
+    alloc_1 = om.Allocation(id="alloc_1", size=5, start=12, end=20)
+    alloc_2 = om.Allocation(id="alloc_2", size=4, start=5, end=15)
+    alloc_3 = om.Allocation(id="alloc_3", size=5, start=15, end=23)
+
+    # Create pool and allocate
+    pool = om.Pool(id="pool_0", allocations=(alloc_0, alloc_1, alloc_2, alloc_3))
+    pool = om.allocate(pool, validate=True)
+
+    # View results
+    print(f"Pool {pool.id!r} size: {pool.size}")
+    for alloc in pool.allocations:
+        print(f"  {alloc.id!r} offset: {alloc.offset}")
+
+
+if __name__ == "__main__":
+    main()

omnimalloc-0.6.0/examples/02_plotting.py

@@ -0,0 +1,29 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import omnimalloc as om
+
+
+def main() -> None:
+    # Define allocations with temporal bounds
+    alloc_0 = om.Allocation(id="alloc_0", size=5, start=0, end=10)
+    alloc_1 = om.Allocation(id="alloc_1", size=5, start=12, end=20)
+    alloc_2 = om.Allocation(id="alloc_2", size=4, start=5, end=15)
+    alloc_3 = om.Allocation(id="alloc_3", size=5, start=15, end=23)
+
+    # Create pool and allocate
+    pool = om.Pool(id="pool_0", allocations=(alloc_0, alloc_1, alloc_2, alloc_3))
+    pool = om.allocate(pool, validate=True)
+
+    # View results
+    print(f"Pool {pool.id!r} size: {pool.size}")
+    for alloc in pool.allocations:
+        print(f"  {alloc.id!r} offset: {alloc.offset}")
+
+    # Visualize (requires matplotlib)
+    om.plot_allocation(pool, "allocation.pdf")
+
+
+if __name__ == "__main__":
+    main()

omnimalloc-0.6.0/examples/03_allocators.py

@@ -0,0 +1,43 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from pathlib import Path
+
+import omnimalloc as om
+from omnimalloc.allocators import DEFAULT_ALLOCATOR, available_allocators
+from omnimalloc.allocators.minimalloc import HAS_MINIMALLOC
+
+
+def main() -> None:
+    example_dir = Path("03_example_output")
+
+    # Define allocations with temporal bounds
+    alloc_0 = om.Allocation(id="alloc_0", size=5, start=0, end=10)
+    alloc_1 = om.Allocation(id="alloc_1", size=5, start=12, end=20)
+    alloc_2 = om.Allocation(id="alloc_2", size=4, start=5, end=15)
+    alloc_3 = om.Allocation(id="alloc_3", size=5, start=15, end=23)
+
+    # Create pool and allocate
+    pool = om.Pool(id="pool_0", allocations=(alloc_0, alloc_1, alloc_2, alloc_3))
+
+    # Get and run the default allocator
+    print(f"Running allocation with default allocator: {DEFAULT_ALLOCATOR}")
+    pool = om.allocate(pool, allocator=DEFAULT_ALLOCATOR, validate=True)
+    print(f"Pool {pool.id!r} size: {pool.size}")
+    om.plot_allocation(pool, example_dir / f"{DEFAULT_ALLOCATOR}_default.pdf")
+
+    # Run allocation with all available allocators
+    for allocator_name in available_allocators():
+        # minimalloc is an optional dependency that only builds on some platforms
+        if "minimalloc" in allocator_name and not HAS_MINIMALLOC:
+            print(f"Skipping unavailable allocator: {allocator_name}")
+            continue
+        print(f"Running allocation with allocator: {allocator_name}")
+        pool = om.allocate(pool, allocator_name, validate=True)
+        print(f"Pool {pool.id!r} size: {pool.size}")
+        om.plot_allocation(pool, example_dir / f"{allocator_name}.pdf")
+
+
+if __name__ == "__main__":
+    main()

omnimalloc-0.6.0/examples/04_sources.py

@@ -0,0 +1,39 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from pathlib import Path
+
+import omnimalloc as om
+from omnimalloc.benchmark.sources import (
+    DEFAULT_SOURCE,
+    BaseSource,
+    available_sources,
+)
+
+
+def allocate_and_plot(source: BaseSource, output: Path) -> None:
+    pool = source.get_pool()
+    pool = om.allocate(pool, validate=True)
+    print(f"Pool {pool.id!r} size: {pool.size}")
+    om.plot_allocation(pool, output)
+
+
+def main() -> None:
+    example_dir = Path("04_example_output")
+
+    # Get and use the default source
+    default_source = BaseSource.get(DEFAULT_SOURCE)()
+    print(f"Using default source: {DEFAULT_SOURCE}")
+    allocate_and_plot(
+        default_source, example_dir / f"source_{DEFAULT_SOURCE}_default.pdf"
+    )
+
+    for source_name in available_sources():
+        source = BaseSource.get(source_name)()
+        print(f"Using source: {source_name}")
+        allocate_and_plot(source, example_dir / f"source_{source_name}.pdf")
+
+
+if __name__ == "__main__":
+    main()

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/examples/05_benchmark.py

@@ -17,25 +17,25 @@ def main() -> None:
 
     # Define allocators, sources, and variants to benchmark
     allocators = (
-        "greedy_by_size_allocator",
-        "greedy_by_size_allocator_cpp",
-        "greedy_by_all_allocator_cpp",
-        "best_fit_allocator",
-        "telamalloc_allocator",
+        "greedy_by_size",
+        "greedy_by_all",
+        "omni",
+        "best_fit",
+        "telamalloc",
     )
     # minimalloc is an optional dependency that only builds on some platforms
     if HAS_MINIMALLOC:
-        allocators += ("minimalloc_allocator",)
+        allocators += ("minimalloc",)
     sources = (
-        "random_source",
-        "minimalloc_source",
-        "huggingface_source",
+        "random",
+        "minimalloc",
+        "huggingface",
     )
     # Counts for the parameterizable source, "first 5" for the fixed ones
     variants = {
-        "random_source": (10, 50, 100, 250, 500),
-        "minimalloc_source": 5,
-        "huggingface_source": 5,
+        "random": (10, 50, 100, 250, 500),
+        "minimalloc": 5,
+        "huggingface": 5,
     }
 
     # Run benchmark campaign

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/pyproject.toml

@@ -54,13 +54,14 @@ dev = [
   "pre-commit>=4.0.0",
   "pytest>=8.0",
   "pytest-cov>=7.0.0",
+  "pytest-xdist>=3.6.0",
   "ruff>=0.14.0",
   "ty>=0.0.1a26",
 ]
 
 [tool.scikit-build]
 wheel.packages = ["src/python/omnimalloc"]
-cmake.build-type = "Release"                         # TODO(fpedd): Cross-check with CMakeLists.txt
+cmake.build-type = "Release"                                            # TODO(fpedd): Cross-check with CMakeLists.txt
 build-dir = "build/{wheel_tag}"
 sdist.include = ["src/cpp/**"]
 sdist.exclude = [".github", "notebooks", "external"]
@@ -137,7 +138,8 @@ ignore = [
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = ["--import-mode=importlib"]
+addopts = ["--import-mode=importlib", "-m", "not slow"]
+markers = ["slow: exhaustive stress grids (deselected by default)"]
 log_cli = true
 log_cli_level = "INFO"
 log_cli_format = "%(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)d)"

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/scripts/benchmark_allocation.py

@@ -48,10 +48,11 @@ NUM_SYNCS = (0, 64, 1_024)
 # fall back to peak-bound sanity checks on larger instances
 VALIDATE_LIMIT = 2_000
 ALLOCATORS = (
-    "greedy_by_all_allocator_cpp",
-    "greedy_allocator_cpp",
-    "best_fit_allocator",
-    "naive_allocator",
+    "omni",
+    "greedy_by_all",
+    "greedy",
+    "best_fit",
+    "naive",
 )
 
 SURFACE = "#fcfcfb"

{omnimalloc-0.5.0 → omnimalloc-0.6.0}/scripts/benchmark_pressure.py

@@ -3,34 +3,34 @@
 #
 """Benchmark exact pressure lower bounds on vector-clock workloads.
 
-Compares the shipping ``get_pressure`` (linearize then sweep, else the exact
-antichain) against the two exact C++ methods:
+Compares the shipping ``pressure`` (linearize then sweep, else the exact
+antichain, under the default work budget) against the two exact C++ methods:
 
-- ``get_antichain_pressure``: max-weight antichain (weighted Dilworth via
-  min flow), the tightest sound lower bound on any placement's peak and the
-  reference every ratio is measured against
-- ``get_closure_pressure``: realizable peak via join-closure enumeration;
+- ``pressure(work_budget=None)``: unbudgeted max-weight antichain
+  (weighted Dilworth via min flow), the tightest sound lower bound on any
+  placement's peak and the reference every ratio is measured against
+- ``closure_pressure``: realizable peak via join-closure enumeration;
   instances whose closure exceeds ``--closure-cap`` are reported as capped
-  and excluded from the means
+  and excluded from the means. Instances where ``pressure`` exceeds its
+  default work budget are reported the same way
 
 and their per-allocation counterparts (dashed in the figures; ratios are
 means over the per-allocation pinned antichain):
 
-- ``get_per_allocation_pressure``: pinned antichain per distinct lifetime
-- ``get_per_allocation_closure_pressure``: realizable peak per allocation
-- ``get_per_allocation_placement_pressure``: placement-certified bound read
-  off an untimed ``OmniAllocator`` placement, plain and ``clique_cap`` forms
+- ``pressure_per_allocation``: pinned antichain per distinct lifetime
+- ``closure_pressure_per_allocation``: realizable peak per allocation
+- ``placement_pressure_per_allocation``: placement-certified bound read
+  off an untimed ``OmniAllocator`` placement
 
 Each sample also places the workload with ``OmniAllocator`` and reports its
 peak over the antichain bound, so a ratio of 1.000 certifies the placement
-optimal. Every sample cross-checks the bound order — globally ``get_pressure``
+optimal. Every sample cross-checks the bound order — globally ``pressure``
 equal to the antichain, closure at or below it, omni peak at or above it,
 antichain at or below the tiling optimum; per allocation closure <= pinned
-antichain <= clique-capped <= plain placement, with each per-allocation max
-matching its global counterpart and the plain placement max matching the
-placement's peak — so the sweep doubles as a torture pass for the exact
-primitives. Any method whose single run exceeds ``--budget`` seconds is
-dropped for the rest of the sweep.
+antichain <= placement, with each per-allocation max matching its global
+counterpart and the placement max matching the placement's peak — so the
+sweep doubles as a torture pass for the exact primitives. Any method whose
+single run exceeds ``--budget`` seconds is dropped for the rest of the sweep.
 
     uv run python scripts/benchmark_pressure.py --out benchmark_results_pressure
 """
@@ -45,17 +45,17 @@ from typing import TYPE_CHECKING, Any
 
 import matplotlib.pyplot as plt
 from omnimalloc import OmniAllocator
+from omnimalloc.analysis import (
+    closure_pressure,
+    closure_pressure_per_allocation,
+    placement_pressure,
+    placement_pressure_per_allocation,
+    pressure,
+    pressure_per_allocation,
+)
 from omnimalloc.benchmark.sources.concurrent_tiling import ConcurrentTilingSource
 from omnimalloc.benchmark.sources.sync_patterns import SYNC_PATTERNS, SyncPatternSource
 from omnimalloc.benchmark.timer import Timer
-from omnimalloc.primitives import (
-    get_antichain_pressure,
-    get_closure_pressure,
-    get_per_allocation_closure_pressure,
-    get_per_allocation_placement_pressure,
-    get_per_allocation_pressure,
-)
-from omnimalloc.primitives.pressure import get_pressure
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -69,17 +69,16 @@ if TYPE_CHECKING:
 
 SIZES = (100, 300, 1_000, 3_000, 10_000)
 NUM_SYNCS = (0, 64, 1_024)
-REFERENCE = "get_antichain_pressure"
-PER_ALLOCATION_REFERENCE = "get_per_allocation_pressure"
+REFERENCE = "pressure(work_budget=None)"
+PER_ALLOCATION_REFERENCE = "pressure_per_allocation"
 METHODS = (
-    "get_pressure",
+    "pressure",
     REFERENCE,
-    "get_closure_pressure",
-    "omni_allocator",
+    "closure_pressure",
+    "omni",
     PER_ALLOCATION_REFERENCE,
-    "get_per_allocation_closure_pressure",
-    "get_per_allocation_placement_pressure",
-    "placement_clique_cap",
+    "closure_pressure_per_allocation",
+    "placement_pressure_per_allocation",
 )
 DEFAULT_CLOSURE_CAP = 1 << 16
 
@@ -90,31 +89,24 @@ INK_MUTED = "#898781"
 GRID = "#e1e0d9"
 AXIS = "#c3c2b7"
 COLORS = {
-    "get_pressure": "#2a78d6",
-    "get_antichain_pressure": "#1baf7a",
-    "get_closure_pressure": "#eda100",
-    "omni_allocator": "#4a3aa7",
-    "get_per_allocation_pressure": "#1baf7a",
-    "get_per_allocation_closure_pressure": "#eda100",
-    "get_per_allocation_placement_pressure": "#4a3aa7",
-    "placement_clique_cap": "#4a3aa7",
+    "pressure": "#2a78d6",
+    REFERENCE: "#1baf7a",
+    "closure_pressure": "#eda100",
+    "omni": "#4a3aa7",
+    "pressure_per_allocation": "#1baf7a",
+    "closure_pressure_per_allocation": "#eda100",
+    "placement_pressure_per_allocation": "#4a3aa7",
 }
 # Per-allocation variants share their global counterpart's color, dashed
 LINESTYLES = {
-    "get_per_allocation_pressure": "--",
-    "get_per_allocation_closure_pressure": "--",
-    "get_per_allocation_placement_pressure": "--",
-    "placement_clique_cap": ":",
+    "pressure_per_allocation": "--",
+    "closure_pressure_per_allocation": "--",
+    "placement_pressure_per_allocation": "--",
 }
 
 Sample = dict[str, Any]
 
 
-def _peak(placed: tuple[Allocation, ...]) -> int:
-    heights = [alloc.height for alloc in placed if alloc.height is not None]
-    return max(heights, default=0)
-
-
 def _capped(
     query: Callable[..., Any], allocations: tuple[Allocation, ...], cap: int
 ) -> Value:
@@ -125,6 +117,14 @@ def _capped(
         return None
 
 
+def _budgeted(allocations: tuple[Allocation, ...]) -> Value:
+    """None instead of raising when pressure exceeds its work budget."""
+    try:
+        return pressure(allocations)
+    except RuntimeError:
+        return None
+
+
 def _sample_runners(
     allocations: tuple[Allocation, ...],
     placed: tuple[Allocation, ...],
@@ -132,21 +132,18 @@ def _sample_runners(
     args: argparse.Namespace,
 ) -> dict[str, Runner]:
     return {
-        "get_pressure": lambda: get_pressure(allocations),
-        REFERENCE: lambda: get_antichain_pressure(allocations),
-        "get_closure_pressure": lambda: _capped(
-            get_closure_pressure, allocations, args.closure_cap
-        ),
-        "omni_allocator": lambda: _peak(allocator.allocate(allocations)),
-        PER_ALLOCATION_REFERENCE: lambda: get_per_allocation_pressure(allocations),
-        "get_per_allocation_closure_pressure": lambda: _capped(
-            get_per_allocation_closure_pressure, allocations, args.closure_cap
+        "pressure": lambda: _budgeted(allocations),
+        REFERENCE: lambda: pressure(allocations, work_budget=None),
+        "closure_pressure": lambda: _capped(
+            closure_pressure, allocations, args.closure_cap
         ),
-        "get_per_allocation_placement_pressure": lambda: (
-            get_per_allocation_placement_pressure(placed)
+        "omni": lambda: placement_pressure(allocator.allocate(allocations)),
+        PER_ALLOCATION_REFERENCE: lambda: pressure_per_allocation(allocations),
+        "closure_pressure_per_allocation": lambda: _capped(
+            closure_pressure_per_allocation, allocations, args.closure_cap
         ),
-        "placement_clique_cap": lambda: (
-            get_per_allocation_placement_pressure(placed, clique_cap=True)
+        "placement_pressure_per_allocation": lambda: (
+            placement_pressure_per_allocation(placed)
         ),
     }
 
@@ -199,9 +196,9 @@ def _finish_sample(
     reference = values.get(REFERENCE)
     if not reference:
         return sample
-    assert values.get("get_pressure", reference) == reference
-    assert values.get("get_closure_pressure", 0) <= reference
-    assert values.get("omni_allocator", reference) >= reference
+    assert values.get("pressure", reference) == reference
+    assert values.get("closure_pressure", 0) <= reference
+    assert values.get("omni", reference) >= reference
     assert optimum is None or reference <= optimum
     _check_per_allocation(values, reference, placed)
     sample["ratios"] = _ratios(values, reference)
@@ -213,20 +210,18 @@ def _check_per_allocation(
 ) -> None:
     """Per-allocation identities: maxima match globals, bounds are ordered."""
     per_alloc = values.get(PER_ALLOCATION_REFERENCE)
-    closure = values.get("get_per_allocation_closure_pressure")
-    placement = values.get("get_per_allocation_placement_pressure")
-    clique = values.get("placement_clique_cap")
+    closure = values.get("closure_pressure_per_allocation")
+    placement = values.get("placement_pressure_per_allocation")
     if per_alloc:
         assert max(per_alloc.values()) == reference
         for i, pinned in per_alloc.items():
             low = closure[i] if closure else pinned
-            mid = clique[i] if clique else pinned
-            high = placement[i] if placement else mid
-            assert low <= pinned <= mid <= high
-    if closure and values.get("get_closure_pressure") is not None:
-        assert max(closure.values()) == values["get_closure_pressure"]
+            high = placement[i] if placement else pinned
+            assert low <= pinned <= high
+    if closure and values.get("closure_pressure") is not None:
+        assert max(closure.values()) == values["closure_pressure"]
     if placement:
-        assert max(placement.values()) == _peak(placed)
+        assert max(placement.values()) == placement_pressure(placed)
 
 
 def _ratios(values: dict[str, Any], reference: int) -> dict[str, float]: