code: def test_pooling_branching_texture_params(
      remote, target, executor_type, dtype
  ):
      """
      Verification of the pooling and many branches having textures
                  layout_transform (NCHW->NCHW4c)
                           |                        <- buffer
                        conv2d (0)                  <- to get textures
                           |                        <- textures
                       pooling
                 /           \           \          <- textures
              conv2d (1)    conv2d (2)    conv2d (3)
                  \             /           |
                       add                  |       <- to have  the only one output, will be fused
                        \                  /
                              add                  <- to have  the only one output, will be fused
                               |                   <- buffer
                      layout_transform (NCHW4c->NCHW)
      """
      input_shape = (1, 32, 40, 40)
      filter_shape0 = (32, 32, 1, 1)
      filter_shape1 = (32, 32, 2, 2)
      filter_shape2 = (32, 32, 1, 1)
      filter_shape3 = (32, 32, 2, 2)
      bias_shape1 = (1, 32, 1, 1)
      # bias_shape2 = (1, 32, 1, 1)
      A = relay.var("data", shape=input_shape, dtype=dtype)
      W0 = relay.var("weight0", shape=filter_shape0, 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)
  
      conv0 = relay.nn.conv2d(
          A,
          W0,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 0, 0],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(1, 1),
      )
  
      pool = relay.nn.avg_pool2d(
          conv0, pool_size=(2, 2), strides=(2, 2)
      )
      conv1 = relay.nn.conv2d(
          pool,
          W1,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 0, 1, 1],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(2, 2),
      )
      conv1 = relay.op.add(conv1, B1)
      conv1 = relay.op.nn.relu(conv1)
  
      conv2 = relay.nn.conv2d(
          pool,
          W2,
          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(
          pool,
          W3,
          data_layout="NCHW",
          kernel_layout="OIHW",
          padding=[0, 1, 1, 0],
          strides=[1, 1],
          out_dtype=dtype,
          channels=32,
          kernel_size=(2, 2),
      )
      conv3 = relay.op.nn.relu(conv3)
      res = relay.op.add(conv1, conv2)
      res = relay.op.add(res, conv3)
  
      mod = relay.Function([A, W0, W1, B1, W2, W3], res)
      np.random.seed(0)
      initializer = relay.testing.init.Xavier()
      filter_data0 = np.zeros(filter_shape0).astype(dtype)
      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)
      initializer("weight", filter_data2)
      filter_data3 = np.zeros(filter_shape3).astype(dtype)
      initializer("weight", filter_data3)
      params1 = {
          "weight0": tvm.nd.array(filter_data0),
          "weight1": tvm.nd.array(filter_data1),
          "bias1": tvm.nd.array(bias_data1),
          "weight2": tvm.nd.array(filter_data2),
          "weight3": tvm.nd.array(filter_data3),
      }
  
      static_memory_scope = [
          "",
          "global.texture",
          "global.texture-weight",
          "global.texture",
          "global.texture",
          "global",
          "global.texture-weight",
          "global",
          "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 14 for calling a global function with example usage: test_pooling_branching_texture_params(remote, target, executor_type, dtype) without return types