Merge upstream/main into fork main (Apple Silicon MPS line)

Brings in 6 upstream commits (through bitsandbytes-foundation#2004). Conflict resolutions:

- csrc/mps_kernels.metal, csrc/mps_ops.mm: upstream bitsandbytes-foundation#2004 DELETED these as
  'unused metal build code' (they were stubs upstream); the fork built them into
  the real MPS port. Kept the fork's versions (rejected the deletion).
- CMakeLists.txt: bitsandbytes-foundation#2004 removed upstream's stub metal build. Restored the fork's
  full MPS build support that the auto-merge dropped: the COMPUTE_BACKEND=mps ->
  BUILD_MPS selection branch, set(MPS_FILES)/set(METAL_FILES), and the late
  if(BUILD_MPS) framework-linking + add_dependencies(metallib) block. Verified a
  clean MPS build produces the metallib + _mps.dylib.
- bitsandbytes/backends/default/ops.py: dropped the stale Lion NOTE (claimed CUDA
  and Triton still had the coupled-decay bug -- all three are now fixed on this
  fork); took upstream's cleaner version. The decoupled-decay code is unchanged.
- tests/test_optim.py: kept the fork's test_lion8bit_blockwise_weight_decay
  alongside upstream's test_lion32bit_weight_decay.
- csrc/pythonInterface.cpp: took upstream's removal of a commented-out dead
  #include (fork's MPS loads via dladdr, doesn't use it).

Verified on the merged tree: MPS builds, tests/test_mps_parity.py 329 passed
under BNB_MPS_REQUIRE_NATIVE=1 (bit-exact quant/dequant + native matmul intact).
Pre-existing paged_lion-on-mps test_optim failures are unchanged (paging is
CUDA-only; identical on fork main pre-merge).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: eaglstun

.github/workflows/python-package.yml

@@ -118,7 +118,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-22.04]
-        rocm_version: ["6.2.4", "6.3.4", "6.4.4", "7.0.2", "7.1.1", "7.2.3"]
+        rocm_version: ["6.2.4", "6.3.4", "6.4.4", "7.0.2", "7.1.1", "7.2.4"]
         include:
           - os: windows-2025
             rocm_version: "7.2.1"

CMakeLists.txt

@@ -3,7 +3,7 @@
 #   For  GCC: `cmake -B build . && cmake --build build`
 #   For MSVC: `cmake -B build . && cmake --build build --config Release`
 # You can also use the following options and variables
-#  - COMPUTE_BACKEND: Set to `cpu`, `cuda`, or `mps` to select the backend
+#  - COMPUTE_BACKEND: Set to `cpu`, `cuda`, `hip`, or `xpu` to select the backend
 #  - CUDA_VERSION: The expected CUDA version, for sanity checking. The actual version
 #                  is whatever CMake finds on your path.
 #  - COMPUTE_CAPABILITY: Which GPU Arch/Compute codes to provide to NVCC.
@@ -62,14 +62,14 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 # Define included source files
 set(CPP_FILES csrc/cpu_ops.cpp csrc/pythonInterface.cpp)
 set(GPU_FILES csrc/ops.cu csrc/kernels.cu)
+set(XPU_FILES csrc/xpu_ops.cpp csrc/xpu_kernels.cpp)
 set(MPS_FILES csrc/mps_ops.mm)
 set(METAL_FILES csrc/mps_kernels.metal)
-set(XPU_FILES csrc/xpu_ops.cpp csrc/xpu_kernels.cpp)
 # C++ sources are always included
 list(APPEND SRC_FILES ${CPP_FILES})
 
-set(COMPUTE_BACKEND "cpu" CACHE STRING "The compute backend to use (cpu, cuda, hip, mps, xpu)")
-set_property(CACHE COMPUTE_BACKEND PROPERTY STRINGS cpu cuda hip mps xpu)
+set(COMPUTE_BACKEND "cpu" CACHE STRING "The compute backend to use (cpu, cuda, hip, xpu, mps)")
+set_property(CACHE COMPUTE_BACKEND PROPERTY STRINGS cpu cuda hip xpu mps)
 option(PTXAS_VERBOSE "Pass through -v flag to PTX Assembler" OFF)
 
 if(APPLE)
@@ -86,34 +86,32 @@ if(${COMPUTE_BACKEND} STREQUAL "cuda")
     endif()
     set(BUILD_CUDA ON)
     set(BUILD_HIP OFF)
-    set(BUILD_MPS OFF)
 elseif(${COMPUTE_BACKEND} STREQUAL "hip")
     if(APPLE)
         message(FATAL_ERROR "HIP is not supported on macOS" )
     endif()
     set(BUILD_CUDA OFF)
     set(BUILD_HIP ON)
-    set(BUILD_MPS OFF)
-elseif(${COMPUTE_BACKEND} STREQUAL "mps")
-    if(NOT APPLE)
-        message(FATAL_ERROR "MPS is only supported on macOS" )
-    endif()
-    set(BUILD_CUDA OFF)
-    set(BUILD_HIP OFF)
-    set(BUILD_MPS ON)
 elseif(${COMPUTE_BACKEND} STREQUAL "xpu")
     if(APPLE)
         message(FATAL_ERROR "XPU is not supported on macOS" )
     endif()
     set(BUILD_CUDA OFF)
     set(BUILD_HIP OFF)
-    set(BUILD_MPS OFF)
     set(BUILD_XPU ON)
+elseif(${COMPUTE_BACKEND} STREQUAL "mps")
+    if(NOT APPLE)
+        message(FATAL_ERROR "MPS is only supported on macOS" )
+    endif()
+    set(BUILD_CUDA OFF)
+    set(BUILD_HIP OFF)
+    set(BUILD_XPU OFF)
+    set(BUILD_MPS ON)
 else()
     set(BUILD_CUDA OFF)
     set(BUILD_HIP OFF)
-    set(BUILD_MPS OFF)
     set(BUILD_XPU OFF)
+    set(BUILD_MPS OFF)
     set(BUILD_CPU ON)
 endif()
 

bitsandbytes/backends/cpu/ops.py

@@ -37,6 +37,7 @@ def _(A: torch.Tensor, B: torch.Tensor):
 
     @register_kernel("bitsandbytes::quantize_blockwise", "cpu")
     def _(A: torch.Tensor, code: torch.Tensor, blocksize: int) -> tuple[torch.Tensor, torch.Tensor]:
+        A = A.contiguous()
         n = A.numel()
         blocks = -(n // -blocksize)
 
@@ -94,6 +95,7 @@ def _(A: torch.Tensor, code: torch.Tensor, blocksize: int) -> tuple[torch.Tensor
     def _(
         A: torch.Tensor, absmax: torch.Tensor, code: torch.Tensor, blocksize: int, dtype: torch.dtype
     ) -> torch.Tensor:
+        A = A.contiguous()
         out = torch.empty_like(A, dtype=dtype)
         if dtype == torch.float32:
             lib.cdequantize_blockwise_cpu_fp32(

bitsandbytes/backends/default/ops.py

@@ -522,9 +522,6 @@ def _optimizer_update_32bit(
         # Lion uses decoupled weight decay: shrink the param directly (p *= 1 - lr*wd)
         # rather than folding wd into the gradient. Matches the cpu backend, the CUDA
         # 8-bit blockwise kernel, and the Lion paper (Chen et al. 2023).
-        # NOTE: the CUDA 32-bit kernel (csrc/kernels.cu::kOptimizer32bit1State) and the
-        # Triton 1-state kernel (backends/triton/kernels_optim.py) still apply *coupled*
-        # decay to Lion — the same bug this fixes — and need a separate upstream fix.
         if weight_decay > 0.0:
             p_vals = p_vals * (1.0 - lr * weight_decay)
 

bitsandbytes/functional.py

@@ -11,6 +11,7 @@
 import numpy as np
 import torch
 from torch import Tensor
+from typing_extensions import deprecated
 
 from bitsandbytes.utils import pack_dict_to_tensor, unpack_tensor_to_dict
 
@@ -1211,6 +1212,7 @@ def optimizer_update_8bit_blockwise(
     )
 
 
+@deprecated("This function is deprecated and will be removed in a future release.", category=FutureWarning)
 def check_matmul(A, B, out, transposed_A, transposed_B, expected_type=torch.int8):
     if not torch.cuda.is_initialized():
         torch.cuda.init()
@@ -1332,6 +1334,7 @@ def gemv_4bit(
     )
 
 
+@deprecated("This function is deprecated and will be removed in a future release.", category=FutureWarning)
 def igemm(
     A: Tensor,
     B: Tensor,
@@ -1433,6 +1436,7 @@ def igemm(
     return out
 
 
+@deprecated("This function is deprecated and will be removed in a future release.", category=FutureWarning)
 def batched_igemm(
     A: Tensor,
     B: Tensor,

csrc/pythonInterface.cpp

@@ -10,9 +10,6 @@
 #if BUILD_HIP
 #include <ops.cuh>
 #endif
-#if BUILD_MPS
-// #include <mps_ops.h>
-#endif
 #if BUILD_XPU
 #include <xpu_ops.h>
 #endif

docs/source/installation.mdx

@@ -248,7 +248,7 @@ The currently distributed `bitsandbytes` are built with the following configurat
 | **Linux x86-64**   | 6.4.4    | CDNA: gfx90a, gfx942 / RDNA: gfx1100, gfx1101, gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1200, gfx1201
 | **Linux x86-64**   | 7.0.2    | CDNA: gfx90a, gfx942, gfx950 / RDNA: gfx1100, gfx1101, gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1200, gfx1201
 | **Linux x86-64**   | 7.1.1    | CDNA: gfx90a, gfx942, gfx950 / RDNA: gfx1100, gfx1101, gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1200, gfx1201
-| **Linux x86-64**   | 7.2.3    | CDNA: gfx90a, gfx942, gfx950 / RDNA: gfx1100, gfx1101, gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1200, gfx1201
+| **Linux x86-64**   | 7.2.4    | CDNA: gfx90a, gfx942, gfx950 / RDNA: gfx1100, gfx1101, gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1200, gfx1201
 | **Windows x86-64** | 7.2.1    | RDNA: gfx1100, gfx1101, gfx1102, gfx1150, gfx1151, gfx1200, gfx1201
 
 Use `pip` or `uv` to install the latest release:
@@ -259,7 +259,7 @@ pip install bitsandbytes
 
 ### Compile from Source[[rocm-compile]]
 
-bitsandbytes can be compiled from ROCm 6.2 - ROCm 7.2.3. See the `CMakeLists.txt` for additional options.
+bitsandbytes can be compiled from ROCm 6.2 - ROCm 7.2.4. See the `CMakeLists.txt` for additional options.
 
 <hfoptions id="rocm-source">
 <hfoption id="Linux">

tests/test_ops.py

@@ -382,9 +382,6 @@ class TestNonContiguousInputs:
     @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16, torch.float32], ids=id_formatter("dtype"))
     @pytest.mark.parametrize("blocksize", [64, 128, 256])
     def test_quantize_blockwise_non_contiguous(self, device, dtype, blocksize):
-        if device == "cpu":
-            pytest.skip("Non-contiguous fix targets CUDA backend only")
-
         code = bitsandbytes.functional.create_dynamic_map().to(device)
 
         # Create non-contiguous tensor via slicing
@@ -404,9 +401,6 @@ def test_quantize_blockwise_non_contiguous(self, device, dtype, blocksize):
     @pytest.mark.parametrize("dtype", [torch.float16, torch.bfloat16, torch.float32], ids=id_formatter("dtype"))
     @pytest.mark.parametrize("blocksize", [64, 128, 256])
     def test_dequantize_blockwise_non_contiguous(self, device, dtype, blocksize):
-        if device == "cpu":
-            pytest.skip("Non-contiguous fix targets CUDA backend only")
-
         code = bitsandbytes.functional.create_dynamic_map().to(device, dtype=torch.float32)
 
         # Quantize a contiguous tensor, then create non-contiguous uint8 via transpose
@@ -435,8 +429,8 @@ def test_dequantize_blockwise_non_contiguous(self, device, dtype, blocksize):
     @pytest.mark.parametrize("quant_type", ["fp4", "nf4"])
     @pytest.mark.parametrize("blocksize", [64, 128, 256])
     def test_quantize_4bit_non_contiguous(self, device, dtype, quant_type, blocksize):
-        if device != "cuda":
-            pytest.skip("Non-contiguous fix targets CUDA backend only")
+        if device not in ("cuda", "mps"):
+            pytest.skip("Non-contiguous input handling not implemented for this backend")
 
         # Reproduce issue #1342: non-contiguous tensor from slicing
         A_full = torch.randn(3, 4, 6, 256, dtype=dtype, device=device)
@@ -458,8 +452,8 @@ def test_quantize_4bit_non_contiguous(self, device, dtype, quant_type, blocksize
     @pytest.mark.parametrize("blocksize", [64, 128, 256])
     def test_quantize_4bit_roundtrip_non_contiguous(self, device, dtype, quant_type, blocksize):
         """End-to-end test: quantize non-contiguous, dequantize, compare with contiguous path."""
-        if device != "cuda":
-            pytest.skip("Non-contiguous fix targets CUDA backend only")
+        if device not in ("cuda", "mps"):
+            pytest.skip("Non-contiguous input handling not implemented for this backend")
 
         A_full = torch.randn(3, 4, 6, 256, dtype=dtype, device=device)
         A_noncontig = A_full[:, ::2, :, :]