在定义pass时，通常会设置相应的优化等级，例如：

1 FunctionPass

  1. Pass FoldConstant() {
  2.   runtime::TypedPackedFunc<Function(Function, Module, PassContext)> pass_func =
  3.     [=](Function f, Module m, PassContext pc) {
  4.       return Downcast<Function>(FoldConstant(f, m));
  5.   };
  6.   return CreateFunctionPass(pass_func, 2, "FoldConstant", {});
  7. }
  9. TVM_REGISTER_API("relay._transform.FoldConstant")
  10. .set_body_typed(FoldConstant);

说明：CreateFunctionPass(pass_func, 2, “FoldConstant”, {});中的第2个参数2，表示该Pass的优化等级是2。
那么，这个优化等级有什么用呢？在用户提供的优化级别下运行时，帮助Pass基础结构识别是否需要执行某个Pass。假设用户指定的优化级别是2，那么所有优化级别小于或等于2的Pass都执行，大于2的Pass都不执行。

  1.     #  only the passes that have optimization level less or equal to 2 will be executed
  2.     with _transform.PassContext(opt_level=2,
  3.                                 required_pass=["QuantizeAnnotate",
  4.                                                "QuantizeCalibrate",
  5.                                                "QuantizeRealize"]):
  6.         with quantize_context():
  7.             mod = quantize_seq(mod)

上面的例子是执行连续的Pass，所有优化级别小于或等于2的都执行，大于2的不执行。

  1. opt_level = 3
  2. target = tvm.target.cuda()
  3. with relay.build_config(opt_level=opt_level):
  4.     graph, lib, params = relay.build_module.build(
  5.         mod, target, params=params)

上面的例子是在relay.build时，表示所有优化级别小于或等于3的都执行，大于3的不执行。

build_config其实也是调用了PassContext，代码如下：

  2. @register_relay_node
  3. class PassContext(RelayNode):
  4.     """The basis where a Relay optimization/analysis runs on.
  5.     Each pass context contains a number of auxiliary information that is used
  6.     to help an optimization pass. Such information includes the error reporter
  7.     to record the errors of during the optimization, etc.
  9.     opt_level : Optional[int]
  10.         The optimization level of this pass.
  12.     fallback_device : Optional[Union[int, str, TVMContext]]
  13.         The fallback device type. It is also used as the default device for
  14.         operators that are not annotated during heterogeneous execution.
  16.     required_pass : Optional[Union[List[str], Set[str], Tuple[str]]]
  17.         The list of passes that are required by a certain pass.
  19.     disabled_pass : Optional[Union[List[str], Set[str], Tuple[str]]]
  20.         The list of passes that are disabled.
  22.     force_transform_avgpool2d : Optional[Bool]
  23.         The flag indicated whether force transform avgpool2d to conv2d in VaccTransformAvgPool pass.
  25.     ksize_global_avgpool2d_transform : Optional[int]
  26.         The kernel type we used to decompose large global avgpool2d.
  28.     svd_topn_percent : Optional[int]
  29.         svd_topn_percent = sum(TopN singular values) / sum(All singular values).
  30.     """
  31.     def __init__(self,
  32.                  opt_level=2,
  33.                  fallback_device=_nd.cpu(),
  34.                  required_pass=None,
  35.                  disabled_pass=None,
  36.                  force_transform_avgpool2d=True,
  37.                  ksize_global_avgpool2d_transform=0,
  38.                  svd_topn_percent = 100):
  39.         if isinstance(fallback_device, str):
  40.             fallback_device = _nd.context(fallback_device).device_type
  41.         elif isinstance(fallback_device, TVMContext):
  42.             fallback_device = fallback_device.device_type
  43.         if not isinstance(fallback_device, int):
  44.             raise TypeError("required_pass is expected to be the type of " +
  45.                             "int/str/TVMContext.")
  47.         required = list(required_pass) if required_pass else []
  48.         if not isinstance(required, (list, tuple)):
  49.             raise TypeError("required_pass is expected to be the type of " +
  50.                             "list/tuple/set.")
  52.         disabled = list(disabled_pass) if disabled_pass else []
  53.         if not isinstance(disabled, (list, tuple)):
  54.             raise TypeError("disabled_pass is expected to be the type of " +
  55.                             "list/tuple/set.")
  57.         if not (svd_topn_percent <= 100 and svd_topn_percent > 0):
  58.             raise TypeError("svd_top_n_weight is expected to be in (0, 100].")
  60.         self.__init_handle_by_constructor__(_transform.PassContext, opt_level,
  61.                                             fallback_device, required,
  62.                                             disabled, force_transform_avgpool2d,
  63.                                             ksize_global_avgpool2d_transform,
  64.                                             svd_topn_percent)
  66.     def __enter__(self):
  67.         _transform.EnterPassContext(self)
  68.         return self
  70.     def __exit__(self, ptype, value, trace):
  71.         _transform.ExitPassContext(self)
  73.     @staticmethod
  74.     def current():
  75.         """Return the current pass context."""
  76.         return _transform.GetCurrentPassContext()
  79. def build_config(opt_level=2,
  80.                  fallback_device=_nd.cpu(),
  81.                  required_pass=None,
  82.                  disabled_pass=None,
  83.                  force_transform_avgpool2d=True,
  84.                  ksize_global_avgpool2d_transform=0,
  85.                  svd_topn_percent = 100):
  86.     """Configure the build behavior by setting config variables.
  88.     Parameters
  89.     ----------
  90.     opt_level: int, optional
  91.         Optimization level. The optimization pass name and level are as the
  92.         following:
  94.         .. code-block:: python
  96.             OPT_PASS_LEVEL = {
  97.                 "SimplifyInference": 0,
  98.                 "OpFusion": 1,
  99.                 "FoldConstant": 2,
  100.                 "FoldScaleAxis": 3,
  101.                 "AlterOpLayout": 3,
  102.                 "CanonicalizeOps": 3,
  103.                 "CanonicalizeCast": 3,
  104.                 "EliminateCommonSubexpr": 3,
  105.                 "CombineParallelConv2D": 4,
  106.                 "CombineParallelDense": 4
  107.             }
  109.     fallback_device : int, str, or tvm.TVMContext, optional
  110.         The fallback device. It is also used as the default device for
  111.         operators without specified device during heterogeneous execution.
  113.     required_pass: set of str, optional
  114.         Optimization passes that are required regardless of optimization level.
  116.     disabled_pass: set of str, optional
  117.         Optimization passes to be disabled during optimization.
  119.     force_transform_avgpool2d : bool, optional
  120.         The flag indicated whether force transform avgpool2d to conv2d in VaccTransformAvgPool pass.
  121.         The initial purpose of adding this flag is to support transform avgpool2d in inception_v3 model in Keras and ONNX.
  122.         If enabled, VaccTransformAvgPool pass will ignore the count_include_pad check and treat count_include_pad false
  123.             as true. The accuracy loss caused by this approximate convert is little through Table 60 in spec.
  124.         If disabled, VaccTransformAvgPool pass will do count_include_pad check and reject when check failed.
  126.     ksize_global_avgpool2d_transform : int, optional
  127.         The kernel type we used to decompose large global avgpool2d.
  128.         We provide 2 options to choose: 0 represents 3x3 s2; 1 represents 5x5 s4.
  129.         As our hardware do better support for 3x3 kernel, so we choose 3x3 s2 as default.
  131.     svd_topn_percent : int, optional
  132.         svd_topn_percent% = sum(TopN singular values) / sum(All singular values).
  134.     Returns
  135.     -------
  136.     pass_context: PassContext
  137.         The pass context for optimizations.
  138.     """
  139.     return PassContext(opt_level, fallback_device, required_pass,
  140.                        disabled_pass, force_transform_avgpool2d, 
  141.                        ksize_global_avgpool2d_transform, svd_topn_percent)