code: def _schedule_conv3d_ncdhw(
      s,
      cfg,
      data,
      data_pad,
      data_vec,
      kernel_vec,
      conv_out,
      output,
      last,
  ):
      # fetch schedule
      ic_bn, oc_bn, reg_n, unroll_kw = (
          cfg["tile_ic"].size[-1],
          cfg["tile_oc"].size[-1],
          cfg["tile_ow"].size[-1],
          cfg["unroll_kw"].val,
      )
  
      # get padding size
      padding = infer_pad3d(data, data_pad, "NCDHW")
      DPAD, HPAD, WPAD = padding
      DOPAD = DPAD != 0 or HPAD != 0 or WPAD != 0
  
      A, W = data, kernel_vec
      A0, A1 = data_pad, data_vec
  
      # schedule data
      if DOPAD:
          s[A0].compute_inline()
      batch, ic_chunk, idd, ih, ic_block, iw = s[A1].op.axis
      parallel_axis = s[A1].fuse(batch, ic_chunk, idd, ih)
      s[A1].parallel(parallel_axis)
  
      # schedule kernel pack
      oc_chunk, ic_chunk, od, oh, ow, ic_block, oc_block = s[W].op.axis
      s[W].reorder(oc_chunk, od, oh, ic_chunk, ow, ic_block, oc_block)
      if oc_bn > 1:
          s[W].vectorize(oc_block)
      parallel_axis = s[W].fuse(oc_chunk, od, oh)
      s[W].parallel(parallel_axis)
  
      # schedule conv
      C, O0, O = conv_out, output, last
      CC = s.cache_write(C, "global")
  
      _, oc_chunk, od, oh, ow, oc_block = s[C].op.axis
      ow_chunk, ow_block = s[C].split(ow, factor=reg_n)
      s[C].reorder(oc_chunk, od, oh, ow_chunk, ow_block, oc_block)
      s[C].fuse(oc_chunk, od, oh)
      s[C].vectorize(oc_block)
  
      s[CC].compute_at(s[C], ow_chunk)
      _, oc_chunk, od, oh, ow, oc_block = s[CC].op.axis
      ic, kd, kh, kw = s[CC].op.reduce_axis
  
      ow_chunk, ow_block = s[CC].split(ow, factor=reg_n)
      ic_chunk, ic_block = s[CC].split(ic, factor=ic_bn)
  
      if unroll_kw:
          s[CC].reorder(
              oc_chunk,
              oh,
              ow_chunk,
              ic_chunk,
              kd,
              kh,
              ic_block,
              kw,
              ow_block,
              oc_block,
          )
          s[CC].unroll(kw)
      else:
          s[CC].reorder(
              oc_chunk,
              oh,
              ow_chunk,
              ic_chunk,
              kd,
              kh,
              kw,
              ic_block,
              ow_block,
              oc_block,
          )
  
      s[CC].fuse(oc_chunk, od, oh)
      s[CC].vectorize(oc_block)
      s[CC].unroll(ow_block)
  
      if O0 != O:
          s[O0].compute_inline()
  
      # unpacking
      batch, oc, od, oh, ow = s[O].op.axis
      ow_chunk, ow_block = s[O].split(ow, factor=reg_n)
      oc_chunk, oc_block = s[O].split(oc, factor=oc_bn)
      s[O].reorder(oc_chunk, od, oh, ow_chunk, ow_block, oc_block)
      parallel_axis = s[O].fuse(batch, oc_chunk, od, oh)
      s[C].compute_at(s[O], parallel_axis)
      s[O].vectorize(oc_block)
      s[O].parallel(parallel_axis)
  
      return s
  
file_path: tvm/python/tvm/topi/x86/conv3d.py
imports: from collections import namedtuple
  import tvm
  from tvm import autotvm, te
  from tvm.autotvm.task.space import OtherOptionEntity, SplitEntity
  from tvm.target.x86 import get_simd_32bit_lanes
  from ..nn.pad import pad
  from ..nn.utils import get_pad_tuple3d, infer_pad3d
  from ..utils import get_const_int, get_const_tuple, simplify, traverse_inline
label_desc: Use image node_id 12 for calling a global function with example usage: _schedule_conv3d_ncdhw(s, cfg, data, data_pad, data_vec, kernel_vec, conv_out, output, last) and returns: s