code: def test_matmullt(
      dim1,
      dim2,
      dim3,
      dim4,
      funcs,
      dtype,
      req_grad,
      transpose,
      decomp,
      has_fp16_weights,
      has_bias,
  ):
      if not torch.cuda.is_available():
          pytest.skip("No GPU found.")
      dimA = (dim2, dim3) if not transpose[0] else (dim3, dim2)
      dimB = (dim3, dim4) if not transpose[1] else (dim4, dim3)
      outlier_dim = torch.randint(
          0, dimA[1], size=(dimA[1] // 8,), device="cuda"
      )
      if has_bias == False:
          req_grad = list(req_grad)
          req_grad[2] = False
  
      for i in range(k):
          # normal multiply
          if funcs[0] in [torch.mm, torch.matmul]:
              A = torch.randn(
                  size=dimA,
                  device="cuda",
                  requires_grad=req_grad[0],
                  dtype=dtype,
              )
              if decomp == 6.0:
                  with torch.no_grad():
                      A[:, outlier_dim] = 6.0
              B = torch.randn(
                  size=dimB,
                  device="cuda",
                  requires_grad=req_grad[1],
                  dtype=dtype,
              )
              target = torch.randn(
                  size=(dim2, dim4),
                  device="cuda",
                  requires_grad=req_grad[1],
                  dtype=dtype,
              )
              bias = None
              bias2 = None
              if has_bias:
                  bias = torch.randn(
                      dim4,
                      device="cuda",
                      dtype=dtype,
                      requires_grad=req_grad[2],
                  )
                  bias2 = bias.clone()
              torch.nn.init.xavier_uniform_(B)
              B2 = B.clone()
  
              state = bnb.MatmulLtState()
              state.threshold = decomp
              state.has_fp16_weights = has_fp16_weights
              if not has_fp16_weights:
                  if not transpose[0] and not transpose[1]:
                      B2 = B2.t().contiguous()
                  (
                      state.CB,
                      CBt,
                      state.SCB,
                      SCBt,
                      coo_tensorB,
                  ) = bnb.functional.double_quant(B2.to(torch.float16))
                  B2 = state.CB
  
              if not transpose[0] and transpose[1]:
                  out_torch = funcs[0](A, B.t())
                  out_bnb = funcs[1](A, B2, state=state, bias=bias2)
              elif not transpose[0] and not transpose[1]:
                  out_torch = funcs[0](A, B)
                  out_bnb = funcs[1](A, B2.t(), state=state, bias=bias2)
  
              if has_bias:
                  out_torch += bias
  
              assert (
                  out_bnb.dtype == A.dtype
              ), f"bnb matmullt received {A.dtype} but returned {out_bnb.dtype}"
  
              n = out_bnb.numel()
              err = torch.abs(out_bnb - out_torch).mean().item()
              # print(f'abs error {err:.4f}')
  
              idx = torch.isclose(
                  out_bnb, out_torch, atol=0.01, rtol=0.1
              )
              assert (idx == 0).sum().item() <= n * (
                  0.0175 if dtype == torch.float16 else 0.021
              )
              idx = torch.isclose(
                  out_bnb, out_torch, atol=0.035, rtol=0.2
              )
              assert (idx == 0).sum().item() <= n * 0.001
  
              if has_fp16_weights:
                  if any(req_grad):
                      out_bnb.data.copy_(out_torch)
                      torch.cuda.synchronize()
                      loss_bnb = torch.nn.functional.mse_loss(
                          out_bnb, target
                      ).mean()
                      loss_bnb.backward()
                      gradA1 = A.grad
                      gradB1 = B.grad
                      A.grad = None
                      B.grad = None
                      if has_bias:
                          gradBias1 = bias.grad
                          bias.grad = None
  
                      loss_torch = torch.nn.functional.mse_loss(
                          out_torch, target
                      ).mean()
                      loss_torch.backward()
                      gradA2 = A.grad
                      gradB2 = B.grad
                      A.grad = None
                      B.grad = None
                      if has_bias:
                          gradBias2 = bias.grad
                          bias.grad = None
  
                  if req_grad[0]:
                      torch.testing.assert_close(
                          gradA1, gradA2, atol=0.015, rtol=0.1
                      )
                  if req_grad[1]:
                      n = gradB1.numel()
                      if dim2 > 0:
                          assert torch.abs(gradB1).sum() > 0.0
                          assert torch.abs(gradB2).sum() > 0.0
                      else:
                          assert torch.abs(gradB1).sum() == 0.0
                          assert torch.abs(gradB2).sum() == 0.0
                      idx = torch.isclose(
                          gradB1, gradB2, atol=0.06, rtol=0.3
                      )
  
                      assert (idx == 0).sum().item() <= n * 0.1
                      idx = torch.isclose(
                          gradB1, gradB2, atol=0.10, rtol=0.3
                      )
                      assert (idx == 0).sum().item() <= n * 0.02
                      torch.testing.assert_close(
                          gradB1, gradB2, atol=0.18, rtol=0.3
                      )
  
                  if req_grad[2]:
                      torch.testing.assert_close(gradBias1, gradBias2)
  
file_path: bitsandbytes/tests/test_autograd.py
imports: from itertools import permutations, product
  import pytest
  import torch
  import bitsandbytes
label_desc: Use image node_id 2 for calling a global function with example usage: test_matmullt(dim1, dim2, dim3, dim4, funcs, dtype, req_grad, transpose, decomp, has_fp16_weights, has_bias) without return types