code: def run_convolution_operators_benchmarks(
      ctx=mx.cpu(),
      dtype="float32",
      profiler="native",
      int64_tensor="off",
      warmup=25,
      runs=100,
  ):
      """Runs benchmarks with the given context, precision (dtype), and input data size (int64_tensor) for all the convolution
      operators in MXNet.
  
      Parameters
      ----------
      ctx: mx.ctx
          Context to run benchmarks
      dtype: str, default 'float32'
          Precision to use for benchmarks
      profiler: str, default 'native'
          Type of Profiler to use (native/python)
      int64_tensor: str, default 'off'
          Input tensor size to use for tests (if on, dimensions >= 2**32)
      warmup: int, default 25
          Number of times to run for warmup
      runs: int, default 100
          Number of runs to capture benchmark results
  
      Returns
      -------
      Dictionary of results. Key -> Name of the operator, Value -> Benchmark results.
  
      """
  
      standard_data_list_conv1d = [(32, 3, 256), (32, 3, 64)]
      int64_tensor_data_list_conv1d = [(2**30, 1, 4)]
      standard_weight_conv1d = (1, 3, 3)
      int64_tensor_weight_conv1d = (1, 1, 1)
      standard_kernel_conv1d = (3,)
      int64_tensor_kernel_conv1d = (1,)
      standard_data_list_conv2d = [(32, 3, 256, 256), (32, 3, 64, 64)]
      int64_tensor_data_list_conv2d = [(2**28, 1, 4, 4)]
      standard_weight_conv2d = (1, 3, 3, 3)
      int64_tensor_weight_conv2d = (1, 1, 1, 1)
      standard_kernel_conv2d = (3, 3)
      int64_tensor_kernel_conv2d = (1, 1)
  
      if int64_tensor == "on":
          data_list_conv1d = int64_tensor_data_list_conv1d
          weight_conv1d = int64_tensor_weight_conv1d
          kernel_conv1d = int64_tensor_kernel_conv1d
          data_list_conv2d = int64_tensor_data_list_conv2d
          weight_conv2d = int64_tensor_weight_conv2d
          kernel_conv2d = int64_tensor_kernel_conv2d
      else:
          data_list_conv1d = standard_data_list_conv1d
          weight_conv1d = standard_weight_conv1d
          kernel_conv1d = standard_kernel_conv1d
          data_list_conv2d = standard_data_list_conv2d
          weight_conv2d = standard_weight_conv2d
          kernel_conv2d = standard_kernel_conv2d
  
      conv1d_benchmark_res = []
      conv2d_benchmark_res = []
      # Conv1D Benchmarks
      for conv_data in data_list_conv1d:
          conv1d_benchmark_res += run_performance_test(
              [getattr(MX_OP_MODULE, "Convolution")],
              run_backward=True,
              dtype=dtype,
              ctx=ctx,
              profiler=profiler,
              inputs=[
                  {
                      "data": conv_data,
                      "weight": weight_conv1d,
                      "bias": (1,),
                      "kernel": kernel_conv1d,
                      "stride": (1,),
                      "dilate": (1,),
                      "pad": (0,),
                      "num_filter": 1,
                      "layout": "NCW",
                  }
              ],
              warmup=warmup,
              runs=runs,
          )
      # Conv2D Benchmarks
      for conv_data in data_list_conv2d:
          conv2d_benchmark_res += run_performance_test(
              [getattr(MX_OP_MODULE, "Convolution")],
              run_backward=True,
              dtype=dtype,
              ctx=ctx,
              profiler=profiler,
              inputs=[
                  {
                      "data": conv_data,
                      "weight": weight_conv2d,
                      "bias": (1,),
                      "kernel": kernel_conv2d,
                      "stride": (1, 1),
                      "dilate": (1, 1),
                      "pad": (0, 0),
                      "num_filter": 1,
                      "layout": "NCHW",
                  }
              ],
              warmup=warmup,
              runs=runs,
          )
      # Prepare combined results
      mx_conv_op_results = merge_map_list(
          conv1d_benchmark_res + conv2d_benchmark_res
      )
      return mx_conv_op_results
  
imports: import mxnet
  from benchmark.opperf.utils.benchmark_utils import run_performance_test
  from benchmark.opperf.utils.common_utils import merge_map_list
  from benchmark.opperf.rules.default_params import MX_OP_MODULE
label_desc: Use image node_id 2 for calling a global function with example usage: run_convolution_operators_benchmarks(ctx, dtype, profiler, int64_tensor, warmup, runs) and returns: mx_conv_op_results