code: def test_conv2d_different_lowering_same_op(
      remote, target, executor_type, dtype
  ):
      """
      Use case for verification of caching compiled functions
      Three convolutions following by each other in this case should be
      compiled in three different entities and lowered differently because
      they are differ in input param memory scopes and in output memory scope
  
                  layout_transform (NCHW->NCHW4c)
                           |                      <- buffer
                        conv2d (1)                <- buffer as input tensor and texture as output
                           |                      <- texture
                        conv2d (2)                <- texture as input and texture as output
                           |                      <- texture
                        conv2d (3)                <- texture as input and buffer as output
                           |                      <- buffer
                      layout_transform (NCHW4c->NCHW)
      """
      input_shape = (1, 32, 40, 40)
      filter_shape1 = (32, 32, 1, 1)
      A = relay.var("data", shape=input_shape, dtype=dtype)
      W1 = relay.var("weight1", shape=filter_shape1, dtype=dtype)
  
      conv1 = relay.nn.conv2d(
          A,
          W1,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(1, 1),
      )
  
      conv2 = relay.nn.conv2d(
          conv1,
          W1,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(1, 1),
      )
  
      conv3 = relay.nn.conv2d(
          conv2,
          W1,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(1, 1),
      )
  
      mod = relay.Function([A, W1], conv3)
      np.random.seed(0)
      initializer = relay.testing.init.Xavier()
      filter_data1 = np.zeros(filter_shape1).astype(dtype)
      params1 = {
          "weight1": tvm.nd.array(filter_data1),
      }
  
      static_memory_scope = [
          "",
          "global.texture",
          "global.texture-weight",
          "global.texture",
          "global.texture",
          "",
          "",
      ]
  
      if executor_type == "ge":
          build_run_compare(
              remote,
              mod,
              params1,
              {"data": input_shape},
              {"data": dtype},
              target,
              static_memory_scope,
          )
      else:
          build_run_compare_vm(
              remote,
              mod,
              params1,
              {"data": input_shape},
              {"data": dtype},
              target,
          )
  
imports: import re
  import tvm
  import numpy
  from tvm import relay
  from tvm.relay import testing
  from tvm.contrib import utils
  from utils.adreno_utils import gpu_preprocess, build_run_compare, build_run_compare_vm
  import pytest
label_desc: Use image node_id 16 for calling a global function with example usage: test_conv2d_different_lowering_same_op(remote, target, executor_type, dtype) without return types