To avoid cratio differences between CPUs, better use fixed budgets instead of CPU cache sizes

Author: FrancescAlted

src/blosc2/batch_array.py

@@ -177,13 +177,13 @@ class BatchArray:
         Maximum number of items stored in each internal variable-length block.
         The last block in a batch may contain fewer items than this cap. If not
         provided, a value is inferred from the first batch using the serialized
-        item sizes and the compression level. For ``clevel`` 1 through 5, the
-        heuristic targets the L1 data-cache size for faster scans and item
-        lookups. For ``clevel`` 6 through 8, it targets the L2 cache size for
-        larger blocks and better compression. At ``clevel`` 9, the whole batch
-        is kept as one block. Smaller blocks generally improve random access
-        and cache behavior, while larger blocks generally improve compression
-        ratio.
+        item sizes and the compression level. The heuristic uses fixed byte
+        budgets so that the layout (and hence the compression ratio) does not
+        depend on the CPU it was created on: 1 MiB for ``clevel`` 1 through 3,
+        8 MiB for ``clevel`` 4 through 6, and 16 MiB for ``clevel`` 7 and 8.
+        At ``clevel`` 9, the whole batch is kept as one block. Smaller blocks
+        generally improve random access, while larger blocks generally improve
+        compression ratio.
     serializer : {"msgpack", "arrow"}, optional
         Serializer used for batch payloads. ``"msgpack"`` is the default and is
         the general-purpose choice for Python items, including nested Blosc2
@@ -609,14 +609,19 @@ def _guess_blocksize(self, payload_sizes: list[int]) -> int:
         # too small for codecs like Zstd to exploit cross-row redundancy.  Use larger
         # cache-budget tiers as clevel increases, while avoiding full L2 blocks at the
         # default clevel to keep random access reasonably granular.
+        # UPDATE: to avoid cratio differences between CPUs, better use fixed budgets instead
+        # of CPU cache sizes.
         if clevel == 9:
             return len(payload_sizes)
         if 0 < clevel <= 3:
-            budget = blosc2.cpu_info.get("l1_data_cache_size")
+            # budget = blosc2.cpu_info.get("l1_data_cache_size")
+            budget = 2**20  #  1 MB
         elif 3 < clevel <= 6:
-            budget = blosc2.cpu_info.get("l2_cache_size") // 2
+            # budget = blosc2.cpu_info.get("l2_cache_size") // 2
+            budget = 2**23  #  8 MB
         elif 6 < clevel < 9:
-            budget = blosc2.cpu_info.get("l2_cache_size")
+            # budget = blosc2.cpu_info.get("l2_cache_size")
+            budget = 2**24  # 16 MB
         else:
             return len(payload_sizes)
         if not isinstance(budget, int) or budget <= 0:

tests/test_batch_array.py

@@ -380,25 +380,29 @@ def test_batcharray_respects_explicit_use_dict_and_non_zstd():
     assert barray.cparams.use_dict is False
 
 
-def test_batcharray_guess_items_per_block_uses_l1_for_low_clevel(monkeypatch):
+def test_batcharray_guess_items_per_block_uses_1mib_budget_for_low_clevel(monkeypatch):
+    # Budgets are fixed; detected cache sizes must not influence the layout.
     monkeypatch.setitem(blosc2.cpu_info, "l1_data_cache_size", 100)
     monkeypatch.setitem(blosc2.cpu_info, "l2_cache_size", 1000)
     barray = blosc2.BatchArray(cparams={"clevel": 3})
-    assert barray._guess_blocksize([30, 30, 30, 30]) == 3
+    # 1 MiB budget: three 300 KiB payloads fit, a fourth would exceed it
+    assert barray._guess_blocksize([300 * 1024] * 4) == 3
 
 
-def test_batcharray_guess_items_per_block_uses_half_l2_for_default_clevel(monkeypatch):
+def test_batcharray_guess_items_per_block_uses_8mib_budget_for_default_clevel(monkeypatch):
     monkeypatch.setitem(blosc2.cpu_info, "l1_data_cache_size", 100)
     monkeypatch.setitem(blosc2.cpu_info, "l2_cache_size", 150)
     barray = blosc2.BatchArray(cparams={"clevel": 5})
-    assert barray._guess_blocksize([60, 60, 60, 60]) == 1
+    # 8 MiB budget: a single 5 MiB payload fits, a second would exceed it
+    assert barray._guess_blocksize([5 * 2**20] * 4) == 1
 
 
-def test_batcharray_guess_items_per_block_uses_l2_for_high_clevel(monkeypatch):
+def test_batcharray_guess_items_per_block_uses_16mib_budget_for_high_clevel(monkeypatch):
     monkeypatch.setitem(blosc2.cpu_info, "l1_data_cache_size", 100)
     monkeypatch.setitem(blosc2.cpu_info, "l2_cache_size", 150)
     barray = blosc2.BatchArray(cparams={"clevel": 7})
-    assert barray._guess_blocksize([60, 60, 60, 60]) == 2
+    # 16 MiB budget: two 6 MiB payloads fit, a third would exceed it
+    assert barray._guess_blocksize([6 * 2**20] * 4) == 2
 
 
 def test_batcharray_guess_items_per_block_uses_full_batch_for_clevel_9(monkeypatch):