code: def schedule_alu_packed(cfg, outs):
      """alu packed schedule"""
      assert len(outs) == 1
  
      def is_cast_op(op):
          return op.name == "T_cast"
  
      outs = [outs] if isinstance(outs, te.tensor.Tensor) else outs
      output = outs[0]
      s = te.create_schedule([x.op for x in outs])
      te.schedule.AutoInlineInjective(s)
  
      # other target does not support alu-only ops
      if not (ENV.TARGET in ["sim", "tsim", "intelfocl"]):
          return s
  
      # only put the int-related ops to vta
      if "int" in output.dtype and len(output.shape) == 6:
          ewise_inputs = []
          ewise_ops = []
          const_ops = []
  
          def _traverse(op):
              if topi.tag.is_broadcast(op.tag):
                  if not op.same_as(output.op):
                      if not op.axis:
                          const_ops.append(op)
                      elif not is_cast_op(op):
                          ewise_ops.append(op)
  
                  for tensor in op.input_tensors:
                      if isinstance(tensor.op, tvm.te.PlaceholderOp):
                          ewise_inputs.append((op, tensor))
                      elif is_cast_op(tensor.op) and not op.same_as(
                          output.op
                      ):
                          ewise_inputs.append((op, tensor))
                      else:
                          _traverse(tensor.op)
              else:
                  for tensor in op.input_tensors:
                      if (
                          not isinstance(
                              tensor.op, tvm.te.PlaceholderOp
                          )
                      ) and (not is_cast_op(tensor.op)):
                          _traverse(tensor.op)
  
          op = output.op
          _traverse(op)
          for _, t in ewise_inputs:
              if t.dtype == "float32":
                  return s
  
          x_bo, x_co, x_i, x_j, x_bi, x_ci = s[output].op.axis
  
          cfg.define_split("tile_co", x_co, num_outputs=2)
          cfg.define_split("tile_h", x_i, num_outputs=2)
          cfg.define_split("tile_w", x_j, num_outputs=2)
  
          x_co0, x_co1 = cfg["tile_co"].apply(s, output, x_co)
          x_i0, x_i1 = cfg["tile_h"].apply(s, output, x_i)
          x_j0, x_j1 = cfg["tile_w"].apply(s, output, x_j)
          s[output].reorder(
              x_bo, x_i0, x_co0, x_j0, x_co1, x_i1, x_j1, x_bi, x_ci
          )
          store_pt = x_j0
  
          for e_o in ewise_ops:
              s[e_o].set_scope(ENV.acc_scope)
              s[e_o].pragma(s[e_o].op.axis[0], ENV.alu)
              s[e_o].compute_at(s[output], store_pt)
  
          # cache read input
          cache_read_ewise = []
          for consumer, tensor in ewise_inputs:
              cache_read_ewise.append(
                  s.cache_read(tensor, ENV.acc_scope, [consumer])
              )
  
          for tensor in cache_read_ewise:
              if s[tensor].op.axis:
                  s[tensor].pragma(s[tensor].op.axis[0], ENV.dma_copy)
              s[tensor].compute_at(s[output], store_pt)
  
          for op in const_ops:
              s[op].compute_inline()
  
          s[output].pragma(x_co1, ENV.dma_copy)
  
      return s
  
imports: from __future__ import absolute_import
  import tvm
  from tvm import te
  from tvm import autotvm
  from tvm import topi
  from tvm.relay.op import op
  from tvm.relay.op import strategy
  from tvm.relay.op.op import OpPattern, OpStrategy
  from .utils import is_packed_layout
  from .vta_conv2d import conv2d_packed, schedule_conv2d_packed
  from .vta_conv2d_transpose import conv2d_transpose_packed, schedule_conv2d_transpose_packed
  from .vta_group_conv2d import group_conv2d_packed, schedule_group_conv2d_packed
  from .vta_dense import dense_packed, schedule_dense_packed
  from ..environment import get_env
label_desc: Use image node_id 5 for calling a global function with example usage: schedule_alu_packed(cfg, outs) and returns: s, unknown, s, s