@@ -0,0 +1,17 @@
+Made the `fill_value` check on the write path substantially cheaper.
+`NDBuffer.all_equal` runs on every chunk write when `write_empty_chunks` is
+false, which is the default, and it dominated the cost of writing chunks.
+
+Two changes. The bit-pattern comparison used for a zero `fill_value`, which
+keeps `-0.0` distinct from `0.0`, now views the buffer as an unsigned integer
+of the same width instead of as a void dtype; NumPy has vectorised integer
+comparison loops but no void one, so the void form fell back to a generic
+elementwise path. Separately, the scan now walks slices of the leading axis,
+doubling in length, and returns on the first slice that differs, so a buffer
+that is not uniformly `fill_value` no longer has to be read in full. The
+leading axis is used rather than a flattened view because a chunk is normally
+a strided view into a larger array and cannot be flattened without a copy. A
+buffer that really is uniform is still covered in the same number of element
+comparisons.
+
+Results are unchanged, including for `-0.0`, NaN, and non-contiguous buffers.
@@ -28,6 +28,15 @@
 __all__: list[str] = []
 
 
+# Integer dtypes used to compare raw bytes when `fill_value` is zero, keyed by
+# itemsize. A view to a dtype of the same width is always permitted by numpy.
+_BITWISE_DTYPE = {1: "u1", 2: "u2", 4: "u4", 8: "u8"}
+
+# Elements in the first slice examined by `NDBuffer.all_equal`. Large enough to
+# amortise one numpy call, small enough that a mismatch in it is nearly free.
+_ALL_EQUAL_BLOCK = 1 << 14
+
+
 @runtime_checkable
 class ArrayLike(Protocol):
     """Protocol for the array-like type that underlie Buffer"""
@@ -531,32 +540,66 @@ def __len__(self) -> int:
     def __repr__(self) -> str:
         return f"<NDBuffer shape={self.shape} dtype={self.dtype} {self._data!r}>"
 
-    def all_equal(self, other: Any, equal_nan: bool = True) -> bool:
-        """Compare to `other` using np.array_equal."""
-        if other is None:
-            # Handle None fill_value for Zarr V2
-            return False
+    @staticmethod
+    def _compare_all(data: NDArrayLike, other: Any, equal_nan: bool) -> bool:
+        """Whether every element of `data` equals `other`, inspecting all of it."""
         # Handle positive and negative zero by comparing bit patterns:
         if (
             np.asarray(other).dtype.kind == "f"
             and other == 0.0
-            and self._data.dtype.kind not in ("U", "S", "T", "O", "V")
+            and data.dtype.kind not in ("U", "S", "T", "O", "V")
         ):
-            _data, other = np.broadcast_arrays(self._data, np.asarray(other, self._data.dtype))
-            void_dtype = f"V{_data.dtype.itemsize}"
-            return np.array_equal(_data.view(void_dtype), other.view(void_dtype))
+            _data, other = np.broadcast_arrays(data, np.asarray(other, data.dtype))
+            # Read the bytes as unsigned integers rather than as a void dtype.
+            # Both compare bit patterns, so both keep -0.0 distinct from 0.0,
+            # but numpy has vectorised integer comparison loops and no void
+            # one: the void form falls back to a generic elementwise path that
+            # is more than an order of magnitude slower. Widths with no integer
+            # of the same size (longdouble, complex128) keep the void form.
+            bitwise_dtype = _BITWISE_DTYPE.get(_data.dtype.itemsize, f"V{_data.dtype.itemsize}")
+            return bool(np.array_equal(_data.view(bitwise_dtype), other.view(bitwise_dtype)))
         # use array_equal to obtain equal_nan=True functionality
-        # Since fill-value is a scalar, isn't there a faster path than allocating a new array for fill value
-        # every single time we have to write data?
-        _data, other = np.broadcast_arrays(self._data, other)
-        return np.array_equal(
-            _data,
-            other,
-            equal_nan=equal_nan
-            if self._data.dtype.kind not in ("U", "S", "T", "O", "V")
-            else False,
+        _data, other = np.broadcast_arrays(data, other)
+        return bool(
+            np.array_equal(
+                _data,
+                other,
+                equal_nan=equal_nan if data.dtype.kind not in ("U", "S", "T", "O", "V") else False,
+            )
         )
 
+    def all_equal(self, other: Any, equal_nan: bool = True) -> bool:
+        """Compare to `other` using np.array_equal."""
+        if other is None:
+            # Handle None fill_value for Zarr V2
+            return False
+        data = self._data
+        # A buffer that is not uniformly `other` still has to be read in full
+        # before a whole-buffer comparison can report the first mismatch, and
+        # on the write path that is the common case. Walking it in slices of
+        # the leading axis returns as soon as one slice differs. Slices double
+        # in length, so a buffer that really is uniform is covered in O(log n)
+        # comparisons and costs the same as the single scan this replaces.
+        #
+        # The leading axis is used rather than a flattened view because a chunk
+        # is usually a strided view into a larger array, which cannot be
+        # flattened without copying it. Slicing axis 0 is a view whatever the
+        # layout.
+        if data.ndim > 0 and np.ndim(other) == 0 and data.size > _ALL_EQUAL_BLOCK:
+            leading = data.shape[0]
+            per_index = data.size // leading if leading else 0
+            if leading > 1 and per_index:
+                step = max(1, _ALL_EQUAL_BLOCK // per_index)
+                start = 0
+                while start < leading:
+                    stop = min(start + step, leading)
+                    if not self._compare_all(data[start:stop], other, equal_nan):
+                        return False
+                    start = stop
+                    step *= 2
+                return True
+        return self._compare_all(data, other, equal_nan)
+
     def fill(self, value: Any) -> None:
         self._data.fill(value)
 
 
@@ -238,3 +238,92 @@ def test_empty(
         assert result.flags.c_contiguous  # type: ignore[attr-defined]
     else:
         assert result.flags.f_contiguous  # type: ignore[attr-defined]
+
+
+@pytest.mark.parametrize("dtype", ["float16", "float32", "float64", "complex64", "int32"])
+@pytest.mark.parametrize("order", ["C", "F"])
+def test_all_equal_matches_full_scan(dtype: str, order: str) -> None:
+    """The blocked scan must agree with a whole-buffer comparison.
+
+    Buffers are deliberately larger than one block and not a whole number of
+    blocks, and the mismatching element is placed at the very end so an
+    early-exit bug cannot pass by luck.
+    """
+    n = (1 << 14) * 3 + 7
+    side = int(np.sqrt(n))
+    for base in (np.zeros(n, dtype=dtype), np.zeros((side, side), dtype=dtype)):
+        arr = np.asfortranarray(base) if order == "F" and base.ndim > 1 else base
+        uniform = cpu.NDBuffer.from_numpy_array(arr)
+        differs = arr.copy()
+        differs.reshape(-1)[-1] = 1
+        mixed = cpu.NDBuffer.from_numpy_array(differs)
+        for fill in (0, 0.0, 1):
+            assert uniform.all_equal(fill) == cpu.NDBuffer._compare_all(arr, fill, True)
+            assert mixed.all_equal(fill) == cpu.NDBuffer._compare_all(differs, fill, True)
+
+
+@pytest.mark.parametrize("dtype", ["float16", "float32", "float64"])
+def test_all_equal_distinguishes_negative_zero(dtype: str) -> None:
+    """Regression test for #3144: -0.0 is not the same chunk as 0.0."""
+    n = (1 << 14) * 2 + 3
+    negative = cpu.NDBuffer.from_numpy_array(np.full(n, -0.0, dtype=dtype))
+    positive = cpu.NDBuffer.from_numpy_array(np.zeros(n, dtype=dtype))
+    assert positive.all_equal(0.0)
+    assert not negative.all_equal(0.0)
+    assert negative.all_equal(-0.0)
+    assert not positive.all_equal(-0.0)
+    # a single -0.0 in an otherwise +0.0 buffer, past the first block
+    mixed_data = np.zeros(n, dtype=dtype)
+    mixed_data[-1] = np.array(-0.0, dtype=dtype)
+    assert not cpu.NDBuffer.from_numpy_array(mixed_data).all_equal(0.0)
+
+
+def test_all_equal_non_contiguous() -> None:
+    """A strided buffer cannot be flattened without copying; it must still be correct."""
+    n = (1 << 14) * 4
+    base = np.zeros(n * 2, dtype="float32")
+    strided = base[::2]
+    assert not strided.flags.c_contiguous
+    assert cpu.NDBuffer.from_numpy_array(strided).all_equal(0.0)
+    strided2 = base[::2].copy()
+    strided2[-1] = 1
+    assert not cpu.NDBuffer.from_numpy_array(strided2).all_equal(0.0)
+
+
+@pytest.mark.parametrize("fill", [0.0, np.nan, 1.0])
+def test_all_equal_strided_chunk_view(fill: float) -> None:
+    """A chunk carved out of a larger array is strided, which is the shape the
+    write path actually hands this method. Slicing the leading axis has to work
+    for those, not just for contiguous buffers."""
+    whole = np.full((512, 512), fill, dtype="float32")
+    chunk = whole[64:192, 64:192]
+    assert not chunk.flags.c_contiguous
+    assert not chunk.flags.f_contiguous
+    assert cpu.NDBuffer.from_numpy_array(chunk).all_equal(fill)
+    # a single differing element, placed last so an early exit cannot pass by luck
+    whole2 = whole.copy()
+    whole2[191, 191] = 12345.0
+    chunk2 = whole2[64:192, 64:192]
+    assert not cpu.NDBuffer.from_numpy_array(chunk2).all_equal(fill)
+    # and placed first
+    whole3 = whole.copy()
+    whole3[64, 64] = 12345.0
+    assert not cpu.NDBuffer.from_numpy_array(whole3[64:192, 64:192]).all_equal(fill)
+
+
+def test_all_equal_single_leading_row() -> None:
+    """shape[0] == 1 has no leading axis to slice; it must fall back, not break."""
+    row = np.zeros((1, (1 << 14) * 2), dtype="float32")
+    assert cpu.NDBuffer.from_numpy_array(row).all_equal(0.0)
+    row2 = row.copy(); row2[0, -1] = 1
+    assert not cpu.NDBuffer.from_numpy_array(row2).all_equal(0.0)
+
+
+def test_all_equal_nan() -> None:
+    n = (1 << 14) * 2 + 1
+    nans = cpu.NDBuffer.from_numpy_array(np.full(n, np.nan, dtype="float64"))
+    assert nans.all_equal(np.nan)
+    assert not nans.all_equal(0.0)
+    one_nan = np.zeros(n, dtype="float64")
+    one_nan[-1] = np.nan
+    assert not cpu.NDBuffer.from_numpy_array(one_nan).all_equal(0.0)