code: def test_concat(remote, target, executor_type, dtype):
      """
          layout_transform (NCHW->NCHW4c)
                    |                      <- buffer
                  conv2d (1)               <- to get textures as output
                 /         \
              conv2d (2)    conv2d (3)
                   \       /               <- concat does not support textures, there we should have buffers
                  concatenation
                       |                   <- buffer
                 layout_transform (NCHW4c->NCHW)
      """
      input_shape = (1, 32, 40, 40)
      filter_shape1 = (96, 32, 2, 2)
      filter_shape2 = (32, 96, 2, 2)
      filter_shape3 = (5, 96, 2, 2)
      bias_shape1 = (1, 96, 1, 1)
      bias_shape2 = (1, 32, 1, 1)
      A = relay.var("data", shape=input_shape, dtype=dtype)
      W1 = relay.var("weight1", shape=filter_shape1, dtype=dtype)
      B1 = relay.var("bias1", shape=bias_shape1, dtype=dtype)
      W2 = relay.var("weight2", shape=filter_shape2, dtype=dtype)
      W3 = relay.var("weight3", shape=filter_shape3, dtype=dtype)
      B2 = relay.var("bias2", shape=bias_shape2, dtype=dtype)
  
      # C = relay.nn.relu(A)
      conv1 = relay.nn.conv2d(
          A,
          W1,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[2, 2],
          out_dtype=dtype,
          channels=96,
          kernel_size=(2, 2),
      )
      D = relay.op.add(conv1, B1)
      D = relay.op.nn.relu(D)
  
      conv2 = relay.nn.conv2d(
          D,
          W2,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[2, 2],
          out_dtype=dtype,
          channels=32,
          kernel_size=(2, 2),
      )
      conv2 = relay.op.add(conv2, B2)
      conv2 = relay.op.nn.relu(conv2)
  
      conv3 = relay.nn.conv2d(
          D,
          W3,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[2, 2],
          out_dtype=dtype,
          channels=5,
          kernel_size=(2, 2),
      )
  
      t = relay.Tuple([conv2, conv3])
      c = relay.op.concatenate(t, axis=1)
  
      mod = relay.Function([A, W1, B1, W2, B2, W3], c)
      np.random.seed(0)
      initializer = relay.testing.init.Xavier()
      filter_data1 = np.zeros(filter_shape1).astype(dtype)
      bias_data1 = np.zeros(bias_shape1).astype(dtype)
      initializer("weight", filter_data1)
      initializer("bias", bias_data1)
      filter_data2 = np.zeros(filter_shape2).astype(dtype)
      bias_data2 = np.zeros(bias_shape2).astype(dtype)
      initializer("weight", filter_data2)
      initializer("bias", bias_data2)
      filter_data3 = np.zeros(filter_shape3).astype(dtype)
      initializer("weight", filter_data3)
      params1 = {
          "weight1": tvm.nd.array(filter_data1),
          "bias1": tvm.nd.array(bias_data1),
          "weight2": tvm.nd.array(filter_data2),
          "bias2": tvm.nd.array(bias_data2),
          "weight3": tvm.nd.array(filter_data3),
      }
  
      static_memory_scope = [
          "",
          "global.texture",
          "global",
          "global.texture-weight",
          "global",
          "global.texture-nhwc",
          "global",
          "global.texture-weight",
          "",
          "",
          "",
          "",
          "",
      ]
  
      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 13 for calling a global function with example usage: test_concat(remote, target, executor_type, dtype) without return types