Removing profiling code masquerading as a skipped test

Author: aldenks

tests/test_codecs/test_sharding.py

@@ -204,81 +204,6 @@ def test_sharding_partial_read(
     assert np.all(read_data == 1)
 
 
-@pytest.mark.skip("This is profiling rather than a test")
-@pytest.mark.slow_hypothesis
-@pytest.mark.parametrize("store", ["local"], indirect=["store"])
-def test_partial_shard_read_performance(store: Store) -> None:
-    import asyncio
-    import json
-    from functools import partial
-    from itertools import product
-    from timeit import timeit
-    from unittest.mock import AsyncMock
-
-    # The whole test array is a single shard to keep runtime manageable while
-    # using a realistic shard size (256 MiB uncompressed, ~115 MiB compressed).
-    # In practice, the array is likely to be much larger with many shards of this
-    # rough order of magnitude. There are 512 chunks per shard in this example.
-    array_shape = (512, 512, 512)
-    shard_shape = (512, 512, 512)  # 256 MiB uncompressed unit16s
-    chunk_shape = (64, 64, 64)  # 512 KiB uncompressed unit16s
-    dtype = np.uint16
-
-    a = zarr.create_array(
-        StorePath(store),
-        shape=array_shape,
-        chunks=chunk_shape,
-        shards=shard_shape,
-        compressors=BloscCodec(cname="zstd"),
-        dtype=dtype,
-        fill_value=np.iinfo(dtype).max,
-    )
-    # Narrow range of values lets zstd compress to about 1/2 of uncompressed size
-    a[:] = np.random.default_rng(123).integers(low=0, high=50, size=array_shape, dtype=dtype)
-
-    num_calls = 20
-    experiments = []
-    for concurrency, get_latency, coalesce_max_gap, statement in product(
-        [1, 10, 100],
-        [0.0, 0.01],
-        [-1, 2**20, 10 * 2**20],
-        ["a[0, :, :]", "a[:, 0, :]", "a[:, :, 0]"],
-    ):
-        zarr.config.set(
-            {
-                "async.concurrency": concurrency,
-                "sharding.read.coalesce_max_gap_bytes": coalesce_max_gap,
-            }
-        )
-
-        async def get_with_latency(*args: Any, get_latency: float, **kwargs: Any) -> Any:
-            await asyncio.sleep(get_latency)
-            return await store.get(*args, **kwargs)
-
-        store_mock = AsyncMock(wraps=store, spec=store.__class__)
-        store_mock.get.side_effect = partial(get_with_latency, get_latency=get_latency)
-
-        a = zarr.open_array(StorePath(store_mock))
-
-        store_mock.reset_mock()
-
-        # Each timeit call accesses a 512x512 slice covering 64 chunks
-        time = timeit(statement, number=num_calls, globals={"a": a}) / num_calls
-        experiments.append(
-            {
-                "concurrency": concurrency,
-                "coalesce_max_gap": coalesce_max_gap,
-                "get_latency": get_latency,
-                "statement": statement,
-                "time": time,
-                "store_get_calls": store_mock.get.call_count,
-            }
-        )
-
-    with open("zarr-python-partial-shard-read-performance-with-coalesce.json", "w") as f:
-        json.dump(experiments, f)
-
-
 @pytest.mark.parametrize("index_location", ["start", "end"])
 @pytest.mark.parametrize("store", ["local", "memory", "zip"], indirect=["store"])
 @pytest.mark.parametrize("coalesce_reads", [True, False])