code: def schedule_pool(outs, layout):
      """Schedule for pool
  
      Parameters
      ----------
      outs: Array of Tensor
            The computation graph description of pool
            in the format of an array of tensors.
  
      layout: str
          Data layout.
  
      Returns
      -------
      sch: Schedule
          The computation schedule for the op.
      """
      outs = [outs] if isinstance(outs, te.tensor.Tensor) else outs
      s = te.create_schedule([x.op for x in outs])
      scheduled_ops = []
  
      def _schedule(PaddedInput, Pool):
          if isinstance(PaddedInput.op, te.tensor.ComputeOp):
              s[PaddedInput].compute_inline()
          do_vectorize = layout[-1] not in "DHWdhw"
          _parallel_sch(s[Pool], outs[0].shape, do_vectorize)
  
      def traverse(OP):
          """Internal traverse function"""
          # inline all one-to-one-mapping operators except the last stage (output)
          if tag.is_injective(OP.tag):
              if OP not in s.outputs:
                  s[OP].compute_inline()
              for tensor in OP.input_tensors:
                  if (
                      isinstance(tensor.op, te.tensor.ComputeOp)
                      and tensor.op not in scheduled_ops
                  ):
                      traverse(tensor.op)
          # schedule pool
          elif OP.tag.startswith("pool"):
              # Average pool accumulation and division happens in different for loops (#3607).
              # To ensure good parallel support, apply multi-threading on the second loop.
              if OP != outs[0].op:
                  output = outs[0]
                  output_fused = s[output].fuse(
                      output.op.axis[0], output.op.axis[1]
                  )
                  s[output].parallel(output_fused)
  
              PaddedInput = OP.input_tensors[0]
              Pool = OP.output(0)
              _schedule(PaddedInput, Pool)
          else:
              raise RuntimeError(f"Unsupported operator: {OP.tag}")
  
          scheduled_ops.append(OP)
  
      traverse(outs[0].op)
      return s
  
imports: from tvm import te
  from ..None import tag
label_desc: Use image node_id 2 for calling a global function with example usage: schedule_pool(outs, layout) and returns: s