bsr_dense_mm(): better test coverage

test/test_sparse_csr.py

@@ -3365,8 +3365,9 @@ def test_triton_bsr_dense_bmm(self, device, dtype, index_dtype, block_size):
 
             bsr = bsr.to_sparse_bsr(block_size)
 
-            if bsr.dim() == 2:
-                # Test against linear to check dispatch.
+            if bsr.dim() == 2 and dtype != torch.float:
+                # Test against linear to check dispatch
+                # which takes place for torch.half and torch.bfloat16.
                 res_tri = torch.nn.functional.linear(dense, bsr)
                 res_dense = torch.nn.functional.linear(dense, bsr.to_dense())
 
@@ -3397,6 +3398,50 @@ def test_triton_bsr_dense_bmm(self, device, dtype, index_dtype, block_size):
                 )
                 self.assertEqual(res_tri, res_dense)
 
+    @onlyCUDA
+    @skipIfRocm
+    @dtypes(torch.half)
+    @unittest.skipIf(IS_FBCODE and IS_REMOTE_GPU, "Test requires Triton")
+    def test_triton_bsr_dense_bmm_error_messages(self, device, dtype):
+        from torch.sparse._triton_ops import bsr_dense_mm
+
+        rhs = torch.rand(32, 32, dtype=dtype, device=device)
+        lhs = rhs.to_sparse_bsr(16)
+        with self.assertRaisesRegex(ValueError, "only BSR sparse format is supported"):
+            bsr_dense_mm(lhs.to_sparse_bsc(16), rhs)
+        with self.assertRaisesRegex(ValueError, "on the same GPU device"):
+            bsr_dense_mm(lhs, rhs.cpu())
+        if torch.cuda.device_count() > 1:
+            with self.assertRaisesRegex(ValueError, "on the same GPU device"):
+                bsr_dense_mm(lhs.to("cuda:0"), rhs.to("cuda:1"))
+        with self.assertRaisesRegex(ValueError, "all inputs are expected to be of the same dtype"):
+            bsr_dense_mm(lhs, rhs.to(torch.float))
+        with self.assertRaisesRegex(ValueError, r"and one of \(half, bfloat16, float32\)"):
+            bsr_dense_mm(lhs.to(torch.double), rhs.to(torch.double))
+        with self.assertRaisesRegex(ValueError, "all inputs are expected to be at least 2D"):
+            bsr_dense_mm(lhs, torch.rand(1, dtype=dtype, device=device))
+        with self.assertRaisesRegex(ValueError, "sizes are not compatible for matrix multiplication"):
+            bsr_dense_mm(lhs, torch.rand(1, 1, dtype=dtype, device=device))
+        with self.assertRaisesRegex(ValueError,
+                                    r"dense.size\(-1\) == 15 should be divisible by blocksize\[0\] == 16"):
+            bsr_dense_mm(lhs, torch.rand(32, 15, dtype=dtype, device=device))
+        # Blocksizes check
+        for blocksize in (15, 30):
+            n = blocksize * 2
+            rhs = torch.rand(n, n, dtype=dtype, device=device)
+            lhs = rhs.to_sparse_bsr(blocksize)
+            with self.assertRaisesRegex(ValueError, "should be at least 16 and a power of 2"):
+                bsr_dense_mm(lhs, rhs)
+        # out check
+        rhs = torch.rand(2, 32, 32, dtype=dtype, device=device)
+        lhs = rhs.to_sparse_bsr(16)
+        with self.assertRaisesRegex(ValueError, r"`out` argument has wrong shape"):
+            out = torch.rand(2, 30, 30, dtype=dtype, device=device)
+            bsr_dense_mm(lhs, rhs, out=out)
+        with self.assertRaisesRegex(ValueError, r"only row-major/col-major `out`"):
+            out = torch.rand(32, 32, 2, dtype=dtype, device=device).transpose(0, -1)
+            bsr_dense_mm(lhs, rhs, out=out)
+
 
 # e.g., TestSparseCSRCPU and TestSparseCSRCUDA
 instantiate_device_type_tests(TestSparseCSR, globals())

torch/sparse/_triton_ops.py

@@ -431,9 +431,6 @@ def bsr_dense_mm(
         max_grid: Optional[Tuple[Optional[int], Optional[int], Optional[int]]] = None,
         out: Optional[torch.Tensor] = None,
     ):
-        m, kl = bsr.shape[-2:]
-        kr, n = dense.shape[-2:]
-
         def check(cond, msg):
             if not cond:
                 raise ValueError(msg)
@@ -463,19 +460,42 @@ def check(cond, msg):
                 f"but got bsr.dim() == {bsr.dim()} and dense.dim() == {dense.dim()}.",
             )
 
+            m, kl = bsr.shape[-2:]
+            kr, n = dense.shape[-2:]
+
             check(
                 kl == kr,
                 "bsr_dense_mm(): argument sizes are not compatible for matrix multiplication, "
                 f"got bsr.shape[-1] == {kl} which is not equal to dense.shape[-2] == {kr}.",
             )
 
-            row_block = bsr.values().shape[-2]
+            row_block, col_block = bsr.values().shape[-2:]
             check(
                 not n % row_block,
                 f"bsr_dense_mm(): dense.size(-1) == {n} should be divisible by "
                 f"blocksize[0] == {row_block}.",
             )
 
+            def is_power_of_two(v):
+                return not (v & (v - 1))
+
+            def is_compatible_blocksize(b):
+                assert len(b) == 2
+                res = True
+                for blocksize in b:
+                    # Triton loads only blocks which are at least 16 and powers of 2.
+                    res = (blocksize >= 16 and is_power_of_two(blocksize)) and res
+                return res
+
+            check(
+                is_compatible_blocksize((row_block, col_block)),
+                f"bsr_dense_mm(): sparse inputs' blocksize ({row_block}, {col_block}) "
+                "should be at least 16 and a power of 2 in each dimension.",
+            )
+        else:
+            m, kl = bsr.shape[-2:]
+            kr, n = dense.shape[-2:]
+
         original_batch_dims_broadcasted = broadcast_batch_dims(bsr, dense)
 
         if out is not None and not skip_checks: