omnimalloc 0.3.0__tar.gz → 0.4.0__tar.gz

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.18...3.30)
 project(
   OmniMalloc
-  VERSION 0.3.0 # Also update pyproject.toml
+  VERSION 0.4.0 # Also update pyproject.toml
   LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -11,13 +11,11 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 option(ENABLE_CLANG_TIDY "Run clang-tidy with the compiler" OFF)
 if(ENABLE_CLANG_TIDY)
   find_program(CLANG_TIDY_PROGRAM NAMES clang-tidy REQUIRED)
-  set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PROGRAM}")
 endif()
 
 option(ENABLE_IWYU "Run include-what-you-use with the compiler" OFF)
 if(ENABLE_IWYU)
   find_program(IWYU_PROGRAM NAMES include-what-you-use iwyu REQUIRED)
-  set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "${IWYU_PROGRAM}")
 endif()
 
 find_package(Python 3.10 REQUIRED COMPONENTS Interpreter Development.Module)
@@ -33,6 +31,14 @@ nanobind_add_module(_cpp NB_STATIC src/cpp/allocators/greedy.cpp
 
 target_include_directories(_cpp PRIVATE src/cpp)
 
+if(ENABLE_CLANG_TIDY)
+  set_target_properties(_cpp PROPERTIES CXX_CLANG_TIDY "${CLANG_TIDY_PROGRAM}")
+endif()
+if(ENABLE_IWYU)
+  set_target_properties(_cpp PROPERTIES CXX_INCLUDE_WHAT_YOU_USE
+                                        "${IWYU_PROGRAM}")
+endif()
+
 nanobind_add_stub(
   _cpp_stub
   MODULE

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omnimalloc
-Version: 0.3.0
+Version: 0.4.0
 Summary: Your one-stop shop for static memory allocation.
 Keywords: memory,allocation,allocator,static-allocation
 Author-Email: Fabian Peddinghaus <fabianpedd@gmail.com>

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "omnimalloc"
-version = "0.3.0" # Also update CMakeLists.txt
+version = "0.4.0" # Also update CMakeLists.txt
 description = "Your one-stop shop for static memory allocation."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
@@ -117,6 +117,7 @@ ignore = [
   "PLC0415", # import outside top-level
   "PLR0913", # too many arguments
   "PLR2004", # magic value comparison
+  "PLW2901", # reassign for loop vars
   "PYI019",  # custom TypeVar
   "RET504",  # unnecessary variable before return
   "S101",    # assert
@@ -132,6 +133,10 @@ ignore = [
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = ["--import-mode=importlib"]
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)d)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
 
 [tool.ty]
 

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/allocators/__init__.py

@@ -5,11 +5,13 @@
 from .base import BaseAllocator as BaseAllocator
 from .genetic import GeneticAllocator as GeneticAllocator
 from .greedy import GreedyAllocator as GreedyAllocator
+from .greedy import GreedyByAllAllocator as GreedyByAllAllocator
 from .greedy import GreedyByAreaAllocator as GreedyByAreaAllocator
 from .greedy import GreedyByConflictAllocator as GreedyByConflictAllocator
 from .greedy import GreedyByDurationAllocator as GreedyByDurationAllocator
 from .greedy import GreedyBySizeAllocator as GreedyBySizeAllocator
 from .greedy_cpp import GreedyAllocatorCpp as GreedyAllocatorCpp
+from .greedy_cpp import GreedyByAllAllocatorCpp as GreedyByAllAllocatorCpp
 from .greedy_cpp import GreedyByAreaAllocatorCpp as GreedyByAreaAllocatorCpp
 from .greedy_cpp import GreedyByConflictAllocatorCpp as GreedyByConflictAllocatorCpp
 from .greedy_cpp import GreedyByDurationAllocatorCpp as GreedyByDurationAllocatorCpp

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/allocators/greedy.py

@@ -2,6 +2,8 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+import sys
+
 from omnimalloc.primitives import Allocation
 
 from .base import BaseAllocator
@@ -80,3 +82,40 @@ class GreedyBySizeAllocator(GreedyAllocator):
     def allocate(self, allocations: tuple[Allocation, ...]) -> tuple[Allocation, ...]:
         sorted_allocs = sorted(allocations, key=lambda a: a.size, reverse=True)
         return super().allocate(tuple(sorted_allocs))
+
+
+def allocate_best_of(
+    variants: tuple[BaseAllocator, ...], allocations: tuple[Allocation, ...]
+) -> tuple[Allocation, ...]:
+    """Run each variant and return the result with the smallest peak memory."""
+    if not allocations:
+        return allocations
+
+    best_allocation: tuple[Allocation, ...] | None = None
+    best_peak_memory = sys.maxsize
+
+    for variant in variants:
+        result = variant.allocate(allocations)
+        heights = [a.height for a in result if a.height is not None]
+        peak_memory = max(heights) if heights else 0
+
+        if peak_memory < best_peak_memory:
+            best_peak_memory = peak_memory
+            best_allocation = result
+
+    assert best_allocation is not None
+    return best_allocation
+
+
+class GreedyByAllAllocator(GreedyAllocator):
+    """Greedy allocator that runs every variant and keeps the best result."""
+
+    def allocate(self, allocations: tuple[Allocation, ...]) -> tuple[Allocation, ...]:
+        variants: tuple[BaseAllocator, ...] = (
+            GreedyAllocator(),
+            GreedyBySizeAllocator(),
+            GreedyByDurationAllocator(),
+            GreedyByAreaAllocator(),
+            GreedyByConflictAllocator(),
+        )
+        return allocate_best_of(variants, allocations)

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/allocators/greedy_cpp.py

@@ -6,6 +6,7 @@ from omnimalloc._cpp import GreedyAllocatorCpp as _GreedyAllocatorCpp
 from omnimalloc.primitives import Allocation
 
 from .base import BaseAllocator
+from .greedy import allocate_best_of
 
 
 class GreedyAllocatorCpp(BaseAllocator):
@@ -63,3 +64,17 @@ class GreedyBySizeAllocatorCpp(GreedyAllocatorCpp):
     def allocate(self, allocations: tuple[Allocation, ...]) -> tuple[Allocation, ...]:
         sorted_allocs = sorted(allocations, key=lambda a: a.size, reverse=True)
         return super().allocate(tuple(sorted_allocs))
+
+
+class GreedyByAllAllocatorCpp(GreedyAllocatorCpp):
+    """C++ greedy allocator that runs every variant and keeps the best result."""
+
+    def allocate(self, allocations: tuple[Allocation, ...]) -> tuple[Allocation, ...]:
+        variants: tuple[BaseAllocator, ...] = (
+            GreedyAllocatorCpp(),
+            GreedyBySizeAllocatorCpp(),
+            GreedyByDurationAllocatorCpp(),
+            GreedyByAreaAllocatorCpp(),
+            GreedyByConflictAllocatorCpp(),
+        )
+        return allocate_best_of(variants, allocations)

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/benchmark/__init__.py

@@ -13,6 +13,7 @@ from .sources import BaseSource as BaseSource
 from .sources import HighContentionSource as HighContentionSource
 from .sources import HuggingfaceSource as HuggingfaceSource
 from .sources import MinimallocSource as MinimallocSource
+from .sources import MinimallocSubset as MinimallocSubset
 from .sources import PowerOf2Source as PowerOf2Source
 from .sources import RandomSource as RandomSource
 from .sources import SequentialSource as SequentialSource

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/benchmark/sources/__init__.py

@@ -10,6 +10,7 @@ from .generator import SequentialSource as SequentialSource
 from .generator import UniformSource as UniformSource
 from .huggingface import HuggingfaceSource as HuggingfaceSource
 from .minimalloc import MinimallocSource as MinimallocSource
+from .minimalloc import MinimallocSubset as MinimallocSubset
 from .utils import AVAILABLE_SOURCES as AVAILABLE_SOURCES
 from .utils import DEFAULT_SOURCE as DEFAULT_SOURCE
 from .utils import get_available_sources as get_available_sources

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/src/python/omnimalloc/benchmark/sources/minimalloc.py

@@ -5,6 +5,7 @@
 import csv
 import logging
 from dataclasses import dataclass
+from enum import Enum
 from pathlib import Path
 
 from omnimalloc.common.directories import EXTERNAL_DIR
@@ -15,6 +16,14 @@ from .base import BaseSource
 logger = logging.getLogger(__name__)
 
 
+class MinimallocSubset(str, Enum):
+    """Bundled CSV subsets shipped under ``external/minimalloc/<value>``."""
+
+    EXAMPLES = "examples"
+    SMALL = "small"
+    CHALLENGING = "challenging"
+
+
 @dataclass(frozen=True)
 class _MinimallocBuffer:
     id: IdType
@@ -70,29 +79,20 @@ def _from_minimalloc_csv(file_path: str | Path) -> Pool:
     return pool
 
 
-def _get_minimalloc_pools() -> list[Pool]:
-    csv_dir = EXTERNAL_DIR / "minimalloc" / "challenging"
-    csv_files = list(csv_dir.glob("*.csv"))
-    pools = [_from_minimalloc_csv(file) for file in csv_files]
-    return pools
-
-
 class MinimallocSource(BaseSource):
-    """Load allocations from Minimalloc CSV format.
+    """Load allocations from a bundled Minimalloc CSV subset.
 
-    This is a fixed source with predetermined pools from Minimalloc benchmarks.
-    Can be initialized with either a specific CSV file or a directory of CSVs.
+    This is a fixed source with predetermined pools from the Minimalloc
+    benchmarks. Pick a bundled ``subset`` to select which pools to load.
     """
 
-    def __init__(self, file_path: str | Path | None = None) -> None:
-        self.file_path = Path(file_path) if file_path is not None else None
+    def __init__(
+        self,
+        subset: MinimallocSubset | str = MinimallocSubset.CHALLENGING,
+    ) -> None:
+        self.subset = MinimallocSubset(subset)
         self._cached_pools: list[Pool] | None = None
 
-        # Validate path exists if provided
-        if self.file_path is not None and not self.file_path.exists():
-            msg = f"Path does not exist: {self.file_path}"
-            raise FileNotFoundError(msg)
-
         # Load pools to get actual num_allocations
         pools = self._pools
         num_allocs = sum(len(p.allocations) for p in pools) if pools else 1
@@ -103,16 +103,10 @@ class MinimallocSource(BaseSource):
     @property
     def _pools(self) -> list[Pool]:
         if self._cached_pools is None:
-            if self.file_path is None:
-                self._cached_pools = _get_minimalloc_pools()
-            elif self.file_path.is_file():
-                self._cached_pools = [_from_minimalloc_csv(self.file_path)]
-            elif self.file_path.is_dir():
-                csv_files = list(self.file_path.glob("*.csv"))
-                self._cached_pools = [_from_minimalloc_csv(f) for f in csv_files]
-            else:
-                msg = f"Path does not exist: {self.file_path}"
-                raise FileNotFoundError(msg)
+            csv_dir = EXTERNAL_DIR / "minimalloc" / self.subset.value
+            self._cached_pools = [
+                _from_minimalloc_csv(f) for f in csv_dir.glob("*.csv")
+            ]
         return self._cached_pools
 
     def _all_allocations(self) -> tuple[Allocation, ...]:

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/tests/unit/allocators/test_greedy.py

@@ -4,6 +4,7 @@
 
 from omnimalloc.allocators.greedy import (
     GreedyAllocator,
+    GreedyByAllAllocator,
     GreedyByAreaAllocator,
     GreedyByConflictAllocator,
     GreedyByDurationAllocator,
@@ -254,3 +255,58 @@ def test_greedy_allocator_fits_in_gap() -> None:
     assert result[0].offset == 0
     assert result[1].offset == 50
     assert result[2].offset == 100
+
+
+def test_greedy_by_all_empty() -> None:
+    allocator = GreedyByAllAllocator()
+    result = allocator.allocate(())
+    assert len(result) == 0
+
+
+def test_greedy_by_all_preserves_allocations() -> None:
+    allocator = GreedyByAllAllocator()
+    allocs = (
+        Allocation(id=1, size=100, start=0, end=10),
+        Allocation(id=2, size=50, start=5, end=15),
+    )
+    result = allocator.allocate(allocs)
+    assert len(result) == len(allocs)
+    assert {a.id for a in result} == {1, 2}
+    assert all(a.offset is not None for a in result)
+
+
+def test_greedy_by_all_picks_best_peak() -> None:
+    allocator = GreedyByAllAllocator()
+    allocs = (
+        Allocation(id=1, size=100, start=0, end=5),
+        Allocation(id=2, size=100, start=3, end=8),
+        Allocation(id=3, size=100, start=6, end=10),
+        Allocation(id=4, size=50, start=0, end=10),
+        Allocation(id=5, size=300, start=2, end=4),
+    )
+    result = allocator.allocate(allocs)
+    peak = max(a.height for a in result if a.height is not None)
+
+    variants = (
+        GreedyAllocator(),
+        GreedyBySizeAllocator(),
+        GreedyByDurationAllocator(),
+        GreedyByAreaAllocator(),
+        GreedyByConflictAllocator(),
+    )
+    best_variant_peak = min(
+        max(a.height for a in v.allocate(allocs) if a.height is not None)
+        for v in variants
+    )
+    assert peak == best_variant_peak
+
+
+def test_greedy_by_all_deterministic() -> None:
+    allocator = GreedyByAllAllocator()
+    allocs = tuple(
+        Allocation(id=i, size=(i % 5 + 1) * 100, start=0, end=i % 7 + 1)
+        for i in range(20)
+    )
+    result1 = allocator.allocate(allocs)
+    result2 = allocator.allocate(allocs)
+    assert all(r1.offset == r2.offset for r1, r2 in zip(result1, result2, strict=True))

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/tests/unit/allocators/test_greedy_cpp.py

@@ -2,9 +2,10 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-from omnimalloc.allocators.greedy import GreedyAllocator
+from omnimalloc.allocators.greedy import GreedyAllocator, GreedyByAllAllocator
 from omnimalloc.allocators.greedy_cpp import (
     GreedyAllocatorCpp,
+    GreedyByAllAllocatorCpp,
     GreedyByAreaAllocatorCpp,
     GreedyByConflictAllocatorCpp,
     GreedyByDurationAllocatorCpp,
@@ -285,3 +286,60 @@ def test_greedy_cpp_matches_python() -> None:
         for cpp_alloc, py_alloc in zip(cpp_result, py_result, strict=True):
             assert cpp_alloc.offset == py_alloc.offset
             assert cpp_alloc.id == py_alloc.id
+
+
+def test_greedy_cpp_by_all_empty() -> None:
+    allocator = GreedyByAllAllocatorCpp()
+    result = allocator.allocate(())
+    assert len(result) == 0
+
+
+def test_greedy_cpp_by_all_preserves_allocations() -> None:
+    allocator = GreedyByAllAllocatorCpp()
+    allocs = (
+        Allocation(id=1, size=100, start=0, end=10),
+        Allocation(id=2, size=50, start=5, end=15),
+    )
+    result = allocator.allocate(allocs)
+    assert len(result) == len(allocs)
+    assert {a.id for a in result} == {1, 2}
+    assert all(a.offset is not None for a in result)
+
+
+def test_greedy_cpp_by_all_deterministic() -> None:
+    allocator = GreedyByAllAllocatorCpp()
+    allocs = tuple(
+        Allocation(id=i, size=(i % 5 + 1) * 100, start=0, end=i % 7 + 1)
+        for i in range(20)
+    )
+    result1 = allocator.allocate(allocs)
+    result2 = allocator.allocate(allocs)
+    assert all(r1.offset == r2.offset for r1, r2 in zip(result1, result2, strict=True))
+
+
+def test_greedy_cpp_by_all_matches_python() -> None:
+    """C++ greedy-by-all should match the Python greedy-by-all result."""
+    cpp_allocator = GreedyByAllAllocatorCpp()
+    py_allocator = GreedyByAllAllocator()
+
+    test_cases = [
+        tuple(Allocation(id=i, size=100, start=0, end=10) for i in range(5)),
+        (
+            Allocation(id=1, size=100, start=0, end=5),
+            Allocation(id=2, size=100, start=3, end=8),
+            Allocation(id=3, size=100, start=6, end=10),
+            Allocation(id=4, size=50, start=0, end=10),
+            Allocation(id=5, size=300, start=2, end=4),
+        ),
+        tuple(
+            Allocation(id=i, size=(i % 5 + 1) * 100, start=0, end=i % 7 + 1)
+            for i in range(20)
+        ),
+    ]
+
+    for allocs in test_cases:
+        cpp_result = cpp_allocator.allocate(allocs)
+        py_result = py_allocator.allocate(allocs)
+        cpp_peak = max(a.height for a in cpp_result if a.height is not None)
+        py_peak = max(a.height for a in py_result if a.height is not None)
+        assert cpp_peak == py_peak

omnimalloc-0.4.0/tests/unit/benchmark/sources/test_minimalloc.py

@@ -0,0 +1,107 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import pytest
+from omnimalloc.benchmark.sources.minimalloc import MinimallocSource, MinimallocSubset
+from omnimalloc.primitives import BufferKind
+
+
+def test_minimalloc_source_default_subset_is_challenging() -> None:
+    source = MinimallocSource()
+    assert source.subset is MinimallocSubset.CHALLENGING
+    assert source.num_allocations > 0
+
+
+def test_minimalloc_source_accepts_enum_member() -> None:
+    source = MinimallocSource(MinimallocSubset.SMALL)
+    assert source.subset is MinimallocSubset.SMALL
+
+
+def test_minimalloc_source_accepts_string_alias() -> None:
+    """Raw strings are coerced to the matching enum member."""
+    source = MinimallocSource("small")
+    assert source.subset is MinimallocSubset.SMALL
+    assert source.subset == "small"
+
+
+def test_minimalloc_source_examples_subset() -> None:
+    source = MinimallocSource(subset="examples")
+    assert source.subset == "examples"
+    variants = source.get_available_variants()
+    assert len(variants) == 1  # Only one example pool
+
+
+def test_minimalloc_source_small_subset() -> None:
+    source = MinimallocSource(subset="small")
+    assert source.subset == "small"
+    variants = source.get_available_variants()
+    assert len(variants) > 0
+    assert all(v[0].islower() for v in variants)
+
+
+def test_minimalloc_source_challenging_subset() -> None:
+    source = MinimallocSource(subset="challenging")
+    variants = source.get_available_variants()
+    assert len(variants) > 0
+
+
+def test_minimalloc_source_subsets_are_disjoint() -> None:
+    examples = set(MinimallocSource(subset="examples").get_available_variants())
+    small = set(MinimallocSource(subset="small").get_available_variants())
+    challenging = set(MinimallocSource(subset="challenging").get_available_variants())
+    assert examples
+    assert small
+    assert challenging
+    assert examples.isdisjoint(small)
+    assert examples.isdisjoint(challenging)
+    assert small.isdisjoint(challenging)
+
+
+def test_minimalloc_source_invalid_subset() -> None:
+    with pytest.raises(ValueError, match="not a valid MinimallocSubset"):
+        MinimallocSource(subset="bogus")  # type: ignore[arg-type]
+
+
+def test_minimalloc_source_get_allocations_skip_past_end() -> None:
+    source = MinimallocSource(subset="examples")
+    allocations = source.get_allocations(skip=10**9)
+    assert len(allocations) == 0
+
+
+def test_minimalloc_source_get_pools_with_skip_past_end() -> None:
+    source = MinimallocSource(subset="examples")
+    pools = source.get_pools(skip=10)
+    assert len(pools) == 0
+
+
+def test_minimalloc_source_get_pools_count_zero() -> None:
+    source = MinimallocSource(subset="examples")
+    pools = source.get_pools(num_pools=0)
+    assert len(pools) == 0
+
+
+def test_minimalloc_source_get_allocation_workspace_kind() -> None:
+    """All loaded allocations are tagged as WORKSPACE buffers."""
+    source = MinimallocSource(subset="examples")
+    allocation = source.get_allocation()
+    assert allocation.kind == BufferKind.WORKSPACE
+
+
+def test_minimalloc_source_get_variant_by_id() -> None:
+    source = MinimallocSource(subset="small")
+    variants = source.get_available_variants()
+    pool = source.get_variant(variants[0])
+    assert pool.id == variants[0]
+
+
+def test_minimalloc_source_get_variant_by_index() -> None:
+    source = MinimallocSource(subset="small")
+    pool = source.get_variant(0)
+    assert pool.id in source.get_available_variants()
+
+
+def test_minimalloc_source_get_variant_unknown_id() -> None:
+    source = MinimallocSource(subset="examples")
+    with pytest.raises(ValueError, match="not found"):
+        source.get_variant("does-not-exist")

{omnimalloc-0.3.0 → omnimalloc-0.4.0}/uv.lock

@@ -1551,7 +1551,7 @@ wheels = [
 
 [[package]]
 name = "omnimalloc"
-version = "0.2.0"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },

omnimalloc-0.3.0/tests/unit/benchmark/sources/test_minimalloc.py

@@ -1,121 +0,0 @@
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-import tempfile
-from pathlib import Path
-
-import pytest
-from omnimalloc.benchmark.sources.minimalloc import MinimallocSource
-from omnimalloc.primitives import BufferKind
-
-
-@pytest.fixture
-def sample_csv_path() -> Path:
-    """Create a temporary CSV file with sample minimalloc data."""
-    content = """id,lower,upper,size
-0,0,3,4
-1,3,9,4
-2,0,9,8
-3,9,21,4
-4,0,21,16
-"""
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
-        f.write(content)
-        return Path(f.name)
-
-
-def test_minimalloc_source_basic_creation(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    assert source.file_path == sample_csv_path
-    assert source.num_allocations == 5
-
-
-def test_minimalloc_source_get_allocations(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocations = source.get_allocations()
-    assert len(allocations) == 5
-    assert allocations[0].id == "0"
-    assert allocations[0].start == 0
-    assert allocations[0].end == 3
-    assert allocations[0].size == 4
-    assert allocations[0].kind == BufferKind.WORKSPACE
-
-
-def test_minimalloc_source_get_allocations_with_count(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocations = source.get_allocations(num_allocations=3)
-    assert len(allocations) == 3
-    assert allocations[0].id == "0"
-    assert allocations[2].id == "2"
-
-
-def test_minimalloc_source_get_allocations_with_skip(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocations = source.get_allocations(skip=2)
-    assert len(allocations) == 3
-    assert allocations[0].id == "2"
-    assert allocations[2].id == "4"
-
-
-def test_minimalloc_source_get_allocations_skip_and_count(
-    sample_csv_path: Path,
-) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocations = source.get_allocations(num_allocations=2, skip=1)
-    assert len(allocations) == 2
-    assert allocations[0].id == "1"
-    assert allocations[1].id == "2"
-
-
-def test_minimalloc_source_get_allocations_skip_past_end(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocations = source.get_allocations(skip=10)
-    assert len(allocations) == 0
-
-
-def test_minimalloc_source_get_pools(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    pools = source.get_pools()
-    assert len(pools) == 1
-    assert len(pools[0].allocations) == 5
-    assert pools[0].id == sample_csv_path.stem
-
-
-def test_minimalloc_source_get_pools_with_skip(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    pools = source.get_pools(skip=1)
-    assert len(pools) == 0
-
-
-def test_minimalloc_source_get_pools_count_zero(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    pools = source.get_pools(num_pools=0)
-    assert len(pools) == 0
-
-
-def test_minimalloc_source_get_pool(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    pool = source.get_pool()
-    assert len(pool.allocations) == 5
-
-
-def test_minimalloc_source_get_allocation(sample_csv_path: Path) -> None:
-    source = MinimallocSource(sample_csv_path)
-    allocation = source.get_allocation()
-    assert allocation.id == "0"
-    assert allocation.size == 4
-
-
-def test_minimalloc_source_file_not_found() -> None:
-    """Test that appropriate error is raised for missing file."""
-    with pytest.raises(FileNotFoundError):
-        MinimallocSource("/nonexistent/path.csv")
-
-
-def test_minimalloc_source_str_path(sample_csv_path: Path) -> None:
-    """Test that string paths are accepted."""
-    source = MinimallocSource(str(sample_csv_path))
-    assert source.file_path == sample_csv_path
-    allocations = source.get_allocations()
-    assert len(allocations) == 5