code: def verify_conv2d_common(
      expr_nchw,  # can be dynamic batch
      expr_ref,  # always static batch
      input_names,
      inputs,
      params,
      sm=80,
      split_k_slices=[1],
      atol=1e-5,
      rtol=1e-5,
      use_cudnn_ref=False,
      run_benchmark=False,
      use_fast_math=False,
      ref_target="cuda",
      use_vm=False,
  ):
      assert has_cutlass()
      if sm < 80 and inputs[0].dtype == "float32":
          return
  
      mod_nchw = tvm.IRModule.from_expr(expr_nchw)
      mod_ref = tvm.IRModule.from_expr(expr_ref)
  
      if use_vm:
          profile_and_build_func = profile_and_build_vm
          get_output_func = get_output_vm
          ref_build_func = get_ref_vm
      else:
          profile_and_build_func = profile_and_build
          get_output_func = get_output
          ref_build_func = get_ref_rt_mod
  
      mod_weight_ohwi = convert_conv2d_layout(
          mod_nchw,
          {
              "nn.conv2d": ["NHWC", "OHWI"],
              "nn.conv2d_transpose": ["NHWC", "IHWO"],
              "nn.conv2d_backward_weight": ["NHWC", "OHWI"],
          },
      )
  
      rt_mod, _, num_cutlass_partition = profile_and_build_func(
          mod_weight_ohwi,
          params,
          sm,
          split_k_slices,
          use_fast_math=use_fast_math,
      )
      out = get_output_func(rt_mod, input_names, inputs)
  
      assert num_cutlass_partition > 0
  
      if use_cudnn_ref:
          rt_mod_ref, dev = ref_build_func(
              convert_conv2d_layout(
                  mod_ref, {"nn.conv2d": ["NHWC", "OHWI"]}
              ),
              params,
              target="cuda -libs=cudnn",
          )
      else:
          rt_mod_ref, dev = ref_build_func(
              convert_conv2d_layout(
                  mod_ref, {"nn.conv2d": ["NHWC", "HWIO"]}
              ),
              params,
              target=ref_target,
          )
  
      ref_out = get_output_func(rt_mod_ref, input_names, inputs)
  
      if run_benchmark:
          print("CUTLASS:", rt_mod.benchmark(dev, number=1, repeat=600))
          print(
              "TVM Tensorcore (no tuning):",
              rt_mod_ref.benchmark(dev, number=1, repeat=600),
          )
  
      np.testing.assert_allclose(out, ref_out, atol=atol, rtol=rtol)
  
imports: import logging
  import tempfile
  import math
  import tvm
  from tvm import relay
  from tvm.contrib.cudnn import conv_output_shape
  import numpy
  from tvm.relay import op
  from tvm.runtime.vm import VirtualMachine
  from tvm.relay.op.contrib.cutlass import partition_for_cutlass
  from tvm import auto_scheduler
  from tvm.relay.transform import FirstOrderGradient, ToMixedPrecision, InferType
  from tvm.contrib.cutlass import has_cutlass, num_cutlass_partitions, finalize_modules, finalize_modules_vm
  import tvm.testing
label_desc: Use image node_id 37 for calling a global function with example usage: verify_conv2d_common(expr_nchw, expr_ref, input_names, inputs, params, sm, split_k_slices, atol, rtol, use_cudnn_ref, run_benchmark, use_fast_math, ref_target, use_vm) without return types