From 01e0831222cf54040b02dea3b9f584e36ec54b46 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Mon, 14 Mar 2022 17:15:01 -0700 Subject: [PATCH 01/11] Collage RFC --- rfcs/xxxx-collage.md | 833 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 833 insertions(+) create mode 100644 rfcs/xxxx-collage.md diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md new file mode 100644 index 00000000..de799626 --- /dev/null +++ b/rfcs/xxxx-collage.md @@ -0,0 +1,833 @@ +# Design Doc: Collage [Draft 0.7] + +``` +Feature Name: Collage +Start Date: Mar 2022 +Authors: Mark Shields (mbs@octoml.ai) +RFC PR: +GitHub Issue: +``` + +This design doc (with accompanying +['v2' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-sketch)) +shows how to bring tuning to TVM's operator fusion and BYOC partitioning passes. The tuning search explores the choice +of sub-graphs (aka 'partitions') as well as choice of toolchain (TVM native or one of the available BYOC integrations, +aka 'backends') for each candidate kernel so as to minimize the expected model inference latency. We call the result +an 'optimal partitioning'. This new tuning layer complements the tuning traditionally done by TVM and other toolchains +during lowering. It can also complement any global tuning, for example to explore all possible global layouts. + +The approach is based on the [preprint](https://arxiv.org/pdf/2111.00655.pdf): + +> *Collage: Automated Integration of Deep Learning Backends* +> Byungsoo Jeon, Sunghyun Park, Peiyuan Liao, Sheng Xu, Tianqi Chen, Zhihao Jia + +This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to fusion and BYOC: + +- Greedy: Currently only the largest possible supported sub-graphs are used for kernels, irrespective of their execution + time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller sub-graphs to yield + better overall latency than one large sub-graph if they mix toolchains. +- Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding partitioning function + before the main TVM compilation flow proceeds. With Collage the choice of toolchain can be automated based on measured + latency. Collage will also explore mixing and matching between multiple BYOC toolchains as well as TVM's native + backend. + +The design (when Collage is enabled) subsumes TVM's fixed `FuseOps` and BYOC-provided `partition_for_` +operations (built using the `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes) with a +single new +`CollageFuseOps` pass. The pass is carefully engineered to build directly on the existing `"TOpPattern"` attributes +(provided for every Relay operator and used by `FuseOps`), BYOC `"target."` +operator predicates (provided for some operator/toolchain pairs by 'operator-based' BYOC integrations) and BYOC operator +pattern/predicates (registered in the pattern table by 'pattern-based' BYOC integrations). In this way only the more +boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage. The +`partition_for_` operations are retained for users who wish to retain manual control. + +> NOTE: We'd like to coordinate these changes with the UMA project. Our aim in this design is to make the smallest +> changes to BYOC as possible. We think the changes described here can be easily reworked to follow any BYOC API +> proposals settled on by UMA. See also "Related Work." + +Collage offers four advantages: + +- **Latency**: Overall model latency may be reduced compared to TVM native, TVM with a specific BYOC toolchain, or a + non-TVM compiler such as TensorRT. +- **Automation**: The choice of which BYOC toolchains to enable can be automated. +- **Economy of implementation**: Five standalone passes using three separate mechanisms for expressing fusion + rules/algorithms and implementing partitioning can be replaced with one, which itself is built from compositional + primitives. +- **Decoupling**: It is ok for a candidate kernel found during search to actually not be valid for a toolchain (even + TVM's). Such candidates could be given 'infinite' cost and thus ignored during search. In this way we can avoid tight + coupling between backends and fusion rules. + +## FAQ + +Pending. + +## Success Metrics + +1. Collage offers at least a 10% latency improvement for a selection of standard ONNX models and NVIDIA hardware using + targets which include the CuDNN and CuBlas libraries, the CUTLASS library (with tuning, via BYOC), the TensorRT + compiler (via BYOC), and (obviously!) TVM native. +2. Collage does not require new per-target or per-model patterns or rules to be implemented independently of the BYOC + integrations. +3. Collage with just the native TWM and a single BYOC toolchain enabled is never worse than using the + existing `partition_for_` class and can go into main independently. +- Some basic `Expr` improvements can go into main independently. +- The design allows for multiple `Target`s for the same `DLDeviceType`. That requires the various + `build` interfaces which currently accept `Union[Target,Dict]` to also accept a list of `Target`s, and can be + backwards compat. +- The new Collage code can go in bottom-up as we develop unit tests: + - Support utils, including `NameSupply`, `IndexSet`, `PriorityQueue`, `Cost`, `CostEstimator`. + - The core `SubGraph` datatype. + - `CandidateKernel`. + - The `FusionRule` class hierachy (which itself can be broken into sub-PRs). + - `FusionSpec`. + - `GatherFusionSpecs` helper for bridging the existing BYOC world with the Collage 'FusionRule' world. + - The `CollageFuseOps` driver pass itself. + +## Related Work + +- The [Cascading Scheduler](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0037-arm-ethosu-cascading-scheduler.md) combines i) dynamic-programming + to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to guide the search, + and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By contrast + Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) + uses measurement to guide the search and iii) assuming the toolchain will 'do its best' with the + sub-graph offered to it. +- The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal + adds a layer on top of the existing and separate TVM BYOC, operator strategy, operator scheduling, + target-specific passes and target-specific code generation extension points. Collage currently relies + only on the global pattern registry and global `relay.ext.` function to integrate with BYOC + integrations, but this is trivial to change should this project change the source of truth. + +## Example + +We start with `mod` bound to [MNIST](https://github.com/onnx/models/tree/main/vision/classification/mnist): + +``` +fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { + %0 = nn.pad(%x, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]); + %1 = nn.conv2d(%0, meta[relay.Constant][0] /*Tensor[(8, 1, 5, 5), float32]*/, + padding=[0, 0, 0, 0], channels=8, kernel_size=[5, 5]); + %2 = add(%1, meta[relay.Constant][1] /*Tensor[(8, 1, 1), float32]*/); + %3 = nn.relu(%2); + %4 = nn.max_pool2d(%3, pool_size=[2, 2], strides=[2, 2], padding=[0, 0, 0, 0]); + %5 = nn.pad(%4, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]); + %6 = nn.conv2d(%5, meta[relay.Constant][2] /*Tensor[(16, 8, 5, 5), float32]*/, + padding=[0, 0, 0, 0], channels=16, kernel_size=[5, 5]); + %7 = add(%6, meta[relay.Constant][3] /*Tensor[(16, 1, 1), float32]*/); + %8 = nn.relu(%7); + %9 = nn.max_pool2d(%8, pool_size=[3, 3], strides=[3, 3], padding=[0, 0, 0, 0]); + %10 = reshape(%9, newshape=[1, 256]); + %11 = nn.dense(%10, meta[relay.Constant][4] /*Tensor[(10, 256), float32]*/, units=None, out_dtype="float32"); + add(%11, meta[relay.Constant][5] /*Tensor[(1, 10), float32]*/) +} +``` + +We can compile this with Collage enabled for a variety of NVIDIA toolchains/libraries as follows: + +``` +with tvm.transform.PassContext(config={"relay.fallback_device_type": 2, "relay.collage.enable_collage": True}): + host_target = tvm.target.Target("llvm") + generic_target = tvm.target.Target("cuda", host_target) + cutlass_target = tvm.target.Target("cuda -compiler=cutlass", host_target) + tensorrt_target = tvm.target.Target("cuda -compiler=tensorrt", host_target) + cudnn_target = tvm.target.Target("cuda -libs=cudnn", host_target) + cublas_target = tvm.target.Target("cuda -libs=cublas", host_target) + targets = [generic_target, cutlass_target, tensorrt_target, cudnn_target, cublas_target] + exe = tvm.relay.vm.compile(mod, target=targets) +``` + +(Note that `cudnn` and `cublas` are not yet supported in the 'v2' prototype.) + +After the `CollageFuseOps` pass, the intermediate `"main"` global function could resemble the following (though we've +modified this "optimal" partitioning by hand to illustrate all the varieties of kernels so don't take it as +representative of actual performance): + +``` +fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { + # Use TVM native + %3 = fn (%FunctionVar_08: Tensor[(1, 1, 28, 28), float32], + Primitive=1) -> Tensor[(1, 1, 32, 32), float32] { + nn.pad(%FunctionVar_08, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]) + }; + %4 = %3(%x); + # Use TVM native, but indicate we wish to link to CuDNN + %6 = fn (%FunctionVar_07: Tensor[(1, 1, 32, 32), float32], + Primitive=1) -> Tensor[(1, 8, 28, 28), float32] { + %5 = fn (%FunctionVar_5: Tensor[(1, 1, 32, 32), float32], + Composite="cudnn.conv2d") -> Tensor[(1, 8, 28, 28), float32] { + nn.conv2d(%FunctionVar_5, meta[relay.Constant][0] /*Tensor[(8, 1, 5, 5), float32]*/, + padding=[0, 0, 0, 0], channels=8, kernel_size=[5, 5]) + }; + %5(%FunctionVar_07) + }; + %7 = %6(%4); + # Use TVM native, with fusion + %8 = fn (%FunctionVar_06: Tensor[(1, 8, 28, 28), float32], + %FunctionVar_12: Tensor[(8, 1, 1), float32], + Primitive=1) -> Tensor[(1, 8, 28, 28), float32] { + %3 = add(%FunctionVar_06, %FunctionVar_12); + nn.relu(%3) + }; + %9 = %8(%7, meta[relay.Constant][1] /*Tensor[(8, 1, 1), float32]*/); + # Use TVM native + %10 = fn (%FunctionVar_05: Tensor[(1, 8, 28, 28), float32], + Primitive=1) -> Tensor[(1, 8, 14, 14), float32] { + nn.max_pool2d(%FunctionVar_05, pool_size=[2, 2], strides=[2, 2], padding=[0, 0, 0, 0]) + }; + %11 = %10(%9); + # Use TVM native + %12 = fn (%FunctionVar_04: Tensor[(1, 8, 14, 14), float32], + Primitive=1) -> Tensor[(1, 8, 18, 18), float32] { + nn.pad(%FunctionVar_04, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]) + }; + %13 = %12(%11); + # Use TensorRT, with fusion + %14 = fn (%FunctionVar_03: Tensor[(1, 8, 18, 18), float32], + %FunctionVar_11: Tensor[(16, 1, 1), float32], + Primitive=1, + Compiler="tensorrt", + global_symbol="collage_nn_conv2d_add_nn_relu_1") -> Tensor[(1, 16, 14, 14), float32] { + %1 = nn.conv2d(%FunctionVar_03, meta[relay.Constant][2] /*Tensor[(16, 8, 5, 5), float32]*/, + padding=[0, 0, 0, 0], channels=16, kernel_size=[5, 5]); + %2 = add(%1, %FunctionVar_11); + nn.relu(%2) + }; + %15 = %14(%13, meta[relay.Constant][3] /*Tensor[(16, 1, 1), float32]*/); + # Use TVM native + %16 = fn (%FunctionVar_02: Tensor[(1, 16, 14, 14), float32], + Primitive=1) -> Tensor[(1, 16, 4, 4), float32] { + nn.max_pool2d(%FunctionVar_02, pool_size=[3, 3], strides=[3, 3], padding=[0, 0, 0, 0]) + }; + %17 = %16(%15); + # Use TVM native + %18 = fn (%FunctionVar_01: Tensor[(1, 16, 4, 4), float32], + Primitive=1) -> Tensor[(1, 256), float32] { + reshape(%FunctionVar_01, newshape=[1, 256]) + }; + %19 = %18(%17); + # Use CUTLASS, with fusion + %20 = fn (%FunctionVar_0: Tensor[(1, 256), float32], + %FunctionVar_1: Tensor[(10, 256), float32], + %FunctionVar_2: Tensor[(1, 10), float32], + Primitive=1, + Compiler="cutlass", + global_symbol="collage_cutlass_dense_bias_nn_dense_add") -> Tensor[(1, 10), float32] { + %1 = fn (%FunctionVar_01: Tensor[(1, 256), float32], + %FunctionVar_11: Tensor[(10, 256), float32], + %FunctionVar_21: Tensor[(1, 10), float32], + Composite="cutlass.dense_bias") -> Tensor[(1, 10), float32] { + %0 = nn.dense(%FunctionVar_01, %FunctionVar_11, units=None, out_dtype="float32"); + add(%0, %FunctionVar_21) + }; + %1(%FunctionVar_0, %FunctionVar_1, %FunctionVar_2) + }; + %20(%19, meta[relay.Constant][4] /*Tensor[(10, 256), float32]*/, meta[relay.Constant][5] /*Tensor[(1, 10), float32]*/) +} +``` + +## Design + +The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with some helper Python +under `python/tvm/relay/collage`. + +If the `relay.collage.enable_collage` `PassConfig` attribute is true then a new `CollageFuseOps` pass is inserted before +the existing `FuseOps` pass. The new pass effects the invariant: + +> All Relay sub-graphs in all global functions which are to be lowered to a kernel are replaced by calls to an inline +> `"Primitive"` `Function`. Functions which are to be lowered by a BYOC-provided toolchain are given +> `"Compiler"` and `"global_symbol"` attributes. The bodies of those function may contain calls to inlined +> `"Composite"` annotated functions to further direct lowering within the kernel. + +The `CollageFuseOps` pass proceeds in four phases: + +- **Phase 1**: The available `Target`s are scanned to build a list of `FusionSpec`s. Each `FusionSpec` is built from + (a tree of) `FusionRule`s. How the rules are constructed depends on `Target` itself. The remaining phases execute on + each global function separately. +- **Phase 2**: A `DataflowGraph` is constructed for the global function. The available `FusionRule`s are evaluated on + the dataflow graph to yield a (possibly overlapping) set of `CandidateKernels` for each target. Each candidate is + described by a `SubGraph` which efficiently denotes a sub-graph of the global function's body without the need to + construct any new expressions. The candidates are placed in a `CandidateKernelIndex` for use below. +- **Phase 3**: A shortest path is found in the following (implicit) search graph: + - Search Nodes: An `IndexSet` describing which dataflow nodes are been assigned to a candidate kernel so far. + - Search Edge X->Y: A `CandidateKernel` can be applied to node X to give node Y. The candidate is disjoint from all + dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate must also + include the next yet-to-be-assigned dataflow node in X. + - Edge cost: Estimated latency of the candidate kernel, plus a kernel launch penalty. Note that though we need to be + able to extract the candidate's sub-graph in order to build the kernel, we do not yet need to partition the + overall function body expression. + Other search algorithms are certainly possible, eg the Paper uses an evolutionary search to refine + the partitioning found by the dynamic-programming search. We can easily abstract away the search + interface to support multiple implementations in the future. +- **Phase 4**: The function body is partitioned according to the candidate kernels on the shortest path. + +In the following we introduce the new datatypes, then expand on the phases. + +### Util Datatypes + +- `PostDfsIndex`: The integer index of a Relay sub-expression in a post-dfs traversal of the overall Relay expression. + If index i is less than index j then we know the sub-expression for j cannot influence the value of the sub-expression + for i. +- `DataflowGraph`: As alias for the existing `IndexedGraph` from the `DFPatternMatcher` suite (which in turn is a + reworked copy of the `IndexedGraph` private to `fuse_ops.cc`). It is used throughout to manage the three-way bijection + from Relay `ExprNode`s to `PostDfsIndex`s to + `DataflowGraph::Node`s. Each `DataflowGraph::Node` describes the sub-expression's dataflow inputs, outputs, dominator + and inverse-dominators. +- `IndexSet`: A bit vector indexed by `PostDfsIndex`s. These are used as a compact representation for an arbitrary set + of dataflow nodes in a dataflow graph. +- `Cost`: A `double` representing a candidate kernel's 'cost', which currently is just mean execution latency in + seconds. Collage only cares that costs are additive and a total order, so in the future we could support cost + functions which balance execution time against high memory watermark or other measures. Costs may be `Unknown` + (ie NaN) to signal some other heuristic should be used to compare kernel costs. Costs may be `Invalid` (ie +inf) + to signal the toolchain could not compile and run a candidate kernel. + +### SubGraph + +A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary sub-graph of the +overall dataflow graph. This and `FusionRule` below are the core Collage datatypes. + +Sub-graphs can be used to represent 'composite'' and 'fused' functions without having to pay the cost of constructing +either the function or the rewritten overall 'partitioned' expression which calls that function. We also allow functions +to be extracted independently of partitioning, since we'll need to estimate the latency of many more kernel functions +than will ultimately be used in the final Relay expression. We expect O(thousands) of sub-graphs to be in flight while +processing a given model. + +A sub-graph classifies every dataflow node of the overall expression as either 'inside' or 'outside' the sub-graph. +Obviously not all such divisions make sense, for example it is not valid for an inside node to feed into another inside +node via outside nodes. We provide the `IsValid` method to check for validity, and `SubGraphConfig` to control which +rules apply (such as maximum depth). + +As well as 'inside' and 'outside' we have four other flavors of dataflow nodes (all uniquely determined from the +'inside' nodes): + +- 'entry' nodes are those inside with at least one dataflow input outside. +- 'exit' nodes are those inside with at least one dataflow output outside, or which are considered 'external' in the + underlying dataflow graph (eg because they represent the result of the overall function). +- 'input' nodes are those outside with at least one dataflow output inside. +- 'output' nodes are those outside with at least one dataflow input inside. + +It is valid to have multiple entry nodes (we'll bind a parameter for each). It may be valid to have multiple exit +nodes (we'll build a tuple of all such). It may be valid to have exit nodes which also contribute to other inside +nodes (ie represent a 'top' on an intermediate result). + +Sub-graphs are closed under: + +- Disjoint union. +- Wrapping by a label, which indicates the wrapped sub-graph should be extracted as a sub-function with a "Composite" + label. +- Substitution, which allows a sub-graph w.r.t. one dataflow graph to be transformed to match some other (typically + smaller) dataflow graph. + +To support some of the `OpPatternKind`-based fusion rules (see below) we give sub-graphs a kind, which is generally the +maximum of the kinds of all the operator calls appearing inside it. We also given sub-graphs a label to help debugging. + +Note that the Relay `PatternPartitoner` goes directly from `Expr` to partitioned `Expr` without stopping at any +intermediate representation. It may be worth 'promoting' `SubGraph` out of Collage andy into the standard `DFPattern` +suite. + +Note that to support closure on both disjoint union and wrapping by a label `SubGraph`s are actually recursive -- see +the 'v2' prototype `sub_graph.cc` for details. + +### CandidateKernel + +A `CandidateKernel` pairs a `SubGraph` with a `FusionSpec` (from which the intended `Target` for the candidate kernel +can be extracted). All Collage search and measurement is in units of candidate kernels. + +### FusionRule + +A `FusionRule` describes how to find a set of `CandidateKernel`s for a `DataflowGraph`. This and `SubGraph` above are +the core Collage datatypes. All fusion rules implement the method: + +``` +virtual Array AllCandidateKernels(const DataflowGraph& dataflow_graph, + const FusionSpec& spec) const; +``` + +The candidates are allowed to overlap, and ultimately it is the job of the Collage fusion searcher to find a selection +of candidates which covers the whole Relay expression without overlap. + +We provide a set of 'base' fusion rules which produce candidates from the dataflow graph directly. We also provide a set +of 'combinator' rules which can produce new candidates from the results of arbitrary sub-rule or sub-rules. In this way +it is possible to combine the fusion rules to express a wide variety of fusion strategies, akin to the way we can +combine TVM passes. + +There may be many thousands of candidates in flight during the fusion search. We take care to defer rewriting any Relay +expressions (eg to extract the fused function, or partition the model) until absolutely necessary. + +The base rules implemented so far: + +- `DFPatternFusionRule`: Given a `DFPattern` and expression predicate, produces a candidate for every sub-graph matched + by the pattern and predicate. Unlike the Relay `PatternRewriter`, candidates are free to overlap. This is the + foundation for pattern-based BYOC integrations, and can be used to write targeted fusion rules as well as find + examples of 'composite' operators. +- `OpPredicateFusionRule`: Given an attribute name, produces a candidate for every call to a primitive Relay operator + where the operator has predicate bound to that attribute which returns true given the call sub-expression. Generally + this will result in a singleton sub-graph containing only the call, but it may pull in constant arguments to the call + should they be required. This is the foundation for operator-based BYOC integrations, though we should consider + retiring this mechanism in favor of pattern-based alone. +- `OpCallByKindFusionRule`: Uses the `"TOpPattern"` attribute provided for every Relay operator to produce a candidate + for every call to a 'fusable Relay operator'. This can be used as the foundation for generic fusion patterns which + work over all Relay operators with particular properties (elementwise, broadcast, injective, reductive, anchor). + +The combinator rules implemented so far: + +- `CompositeFusionRule`: 'Tags' the candidates matched by an arbitrary sub-rule with the rule name. Tagged sub-graphs + are turned into "Primitive" Function with the "Composite" + attribute bound to the tag. This can be used to indicate Relay operators (or groups of Relay operators) are to be + rewritten to specific target-specific operators. This combinator wraps the `DFPatternFusionRules` for the + pattern-based BYOC integrations. However it could also be used with the default TVM backend, eg to indicate Relay + operators should be replaced with particular external library implementations. +- `CombineByPrimitivesFusionRule`: Given a sub-rule and a list of 'primitive' rules, finds all possible ways of + combining the sub-rule candidates to yield even larger candidates. Note that the sub-rule's candidates may also be + included in the results -- that is every combination of candidates is considered optional. The 'primitive' rules allow + combining by + `OpPatternKinds`, and combining the arguments to tuples which themselves are arguments to Relay operator calls. This + rule is intended to mimic the existing TVM `FuseOps` pass, though: i) all combinations are found, ii) the starting set + of candidates can be provided by any other rule (ie not just `OpCallByKindFusionRule`), and iii) we rely on `SubGraph` + validity checking to weed out infeasible candidates. + +Though not yet implemented, we'd like to allow a combinator rule which will union candidate based on their 'anchor' +operators. This can be used to implement 'vertical' and 'horizontal' fusion on more primitive candidates. Note that the +`SubGraph` machinery supports multiple-input and -output sub-graphs and their validation, so horizontal fusion is easy +implement. + +We also have `MaxCoalesceFusionRule`, which eagerly combines 'touching' candidates (ie candidates where the output of +one sub-graph can be directly connected to the input of the other sub-graph) +to form the largest possible candidate. The idea is once the search has been completed this rule can be used to collapse +adjacent kernels intended for the same target. + +Here's some typical `FusionRule` combinations for different fusion strategies (please excuse the crudity of the diagram, +I didn't have time to build it to scale or paint it): + +- Classic TVM `FuseOps`: + +``` + OpCallByKindFusionRule + | + v + CombineByPrimitivesFusionRule (with default TVM primitive rules) +``` + +- Classic operator-based BYOC with `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes: + +``` + OpPredicateFusionRule + | + v + CombineByPrimitivesFusionRule (with join anything primitive rule) +``` + +- Classic pattern-based BYOC with `MergeComposite`/`AnnotateTarget`/`PartitionGraph` passes: + +``` + DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) + | | + v v + CompositeFusionRule(label1) ... CompositeFusionRule(labeln) + \ / + v v + UnionFusionRule + | + v + CombineByPrimitivesFusionRule (with join anything primitive rule) +``` + +- "Just fuse what I tell you to fuse", using `DFPatterns` to directly select candidates: + +``` + DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) + \ / + v v + UnionFusionRule +``` + +- "Consider this library implementation for these sub-expressions", using `DFPatterns` to pick out which Relay operators + are supported (note that TVM lowering does not currently support this): + +``` + OpCallByKindFusionRule DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) + \ | | + \ v v + \ CompositeFusionRule(label1) ... CompositeFusionRule(labeln) + \ | / + v v v + UnionFusionRule + | + v + CombineByPrimitivesFusionRule (with default TVM primitive rules) +``` + +### FusionSpec + +A `FusionSpec` pairs a a `FusionRule` with a `Target`. + +### Phase 1 + +We build on the existing TVM support for heterogeneous devices and targets. The available `Targets` are extracted from +the compilation configuration (eg using the existing `CompilationConfig` helper class). Each target is inspected to +decide on how to construct a `FusionSpec`, which will guide Collage in the selection of candidate kernels to explore for +that target. + +- If the `Target` has a `"fusion_spec"` attribute, use that directly (not currently in the 'v2' prototype). This would + allow users to directly control fusion for the target's they care about. +- If the `Target` has a `"compiler"` attribute (eg `"cutlass"`), and the global pattern table has an entry for that + attribute value, assume the `Target` denotes a pattern-based BYOC integration to explore. The `FusionSpec` + will import all the BYOC patterns and predicates automatically. +- As above, but if global pattern has no matching entry, assume the `Target` denotes a predicate-based BYOC integration + to explore (eg `"tensorrt"`). The `FusionSpec` will look for and evaluate predicates with the + `"target."` attribute on all Relay operators. +- Otherwise, assume the `Target` denotes a TVM-native target. The `FusionSpec` mimics the existing `FuseOps`, but now + generalized to explore multiple candidates so as to leave room for possible BYOC candidates. + +Note that to make this approach work we need to allow for multiple `Target`s with the same `DLDeviceKind`. For the VM +simply switching the `target` argument from dictionary to list and removing some redundant Python preprocessing code was +all that was required to support this. + +The user can use `on_device` annotations to constrain sub-graphs to particular devices. When Collage is considering +candidate kernels, it should be sure to choose a candidate `Target` which 'refines' the `Target` for every +sub-expression discovered by the `PlanDevicesPass`. Given targets T and U we say 'T refines U' if T has a +'"compiler"' and/or '"fusion_spec"' attributes, U has no such attributes, and T and U otherwise agree on all other +fields. (This is not currently in the 'v2' prototype). + +### Phase 2 + +Most of the hard work for this phase is carried by the `AllCandidateKernels` implementations of the `FusionRule`s. The +main driver simply needs to index all the found `CandidateKernels` by their minimum 'inside' `PostDfsIndex` +for rapid retrieval during the shortest path search. + +### Phase 3 + +We find it most natural to use Dijkstra to find the optimal partitioning. A `SearchState` is: + +- An `IndexSet` of the dataflow nodes already 'covered' by candidates on the best path to this state. This is the + identifying key for the state. +- The predecessor `SearchState` in the best path to this state. +- The `Cost` of the best path to this state. This is the order for the Dijkstra priority queue. +- The `CandidateKernel` for the transition from the best predecessor to this state. + +The starting state has no covered nodes. The final state has all nodes covered. + +When expanding a state we could choose any `CandidateKernel` collected from phase 2 provided it doesn't overlap with the +state's covered set. However, a search path applying candidates C then D is equivalent to one applying D then C, so we +only consider candidates which intersect the next yet-to-be-covered dataflow node. For each such candidate we use +the `CostEstimator` (with it's assumed cache) to get the candidate's cost, build the successor state, and 'relax' the +successor state in the usual way. + +Not all Relay expression nodes need to be assigned to a kernel since the VM or other execution provider can happily +evaluate most Relay expressions except for calls to primitive operators. Thus the search must allow for the possibility +of a expression node being 'left behind'. + +### Phase 4 + +The overall Relay expression is partitioned over all the `CandidateKernel`s on the shortest path 'in parallel'. Since +all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful not to +invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. + +Note that all the extracted functions in the result will be marked as `"Primitive"`, and thus will be left alone by most +other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run (repeatably) after +`CollageFuseOps`. + +## Known Limitations + +- **Some BYOC boilerplate changes required**: TVM's current BYOC integration API only requires the 'lowering/codegen' + function to be registered to a well-known global function name. Everything else is up to the BYOC author. + - Collage requires pattern-based BYOC integrations to register their patterns in the global pattern table. + - Collage requires the BYOC lowering function to yield a valid `runtime::Module` without requiring any additional + BYOC-specific passes to be run. + - Collage requires the BYOC integration to either correctly test for which operators are supported in the + pattern/operator predicate, or gracefully propagate failure rather than CHECK-fail if an unsupported operator is + included in a candidate kernel. Thus a BYOC integration will need to be 'robustified' to become 'Collage + compatible'. Overall we've tried to make as few changes as possible. Collage will happily follow along with any + improvements to the BYOC integration API (eg via the UMA project). +- **Higher tuning cost**: Obviously Collage needs to estimate the latency of many more candidate kernels, and each + candidate may itself trigger tuning during lowering. For TVM this can require O(thousands) of trials and take O(hours) + , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. + Currently Collage will measure more candidates even if TVM native is the only available target. +- **Task extraction vs Tuning**: Traditionally TVM has had three phases: i) Task extraction (find the fused sub-graphs + to tune), ii) Tuning (find a good schedule for those sub-graphs), and iii) Compilation (re-compile the model, now + retrieving schedules for all the anticipated sub-graphs from the cache.) However the Collage 'v2' prototype collapses + all these phases. This lets us lazily explore the implied search graph (nodes = partially rewritten models, edges = + selected of sub-graph and toolchain as a candidate kernel, cost = estimated sum of kernel costs plus launch penalties) + , and thus only pay the cost of tuning candidate kernels which could possibly influence the final partitioning. +- **No non-local optimization**: Though Collage can explore the choice of sub-graph and toolchain, it cannot explore any + choices which require the arguments and/or result of the sub-graph to be rewritten. Thus Collage **cannot** be used to + search over: + - choice of layout for arguments/results (may require insertion of layout transforms), + - choice of memory scope for arguments/results (may require insertion of device copies), + - choice of device on which to host the kernel (ditto) + since all those choices can require changes beyond the candidates sub-graph. +- the choice of layout for a kernel since any choice other than the model's default must be + 'corrected' for by the inserted layout transformations. To support this efficiently we'd need to abandon the + simple-minded but fast `SubGraph` representation we describe below in favor of something like an EGraph + representation, which seems like a very large change for TVM. +- **Dependency management**: Currently BYOC integrations tend to assume they are the only non-TVM toolchain in use. So + it's possible two toolchains introduce runtime dependencies which can't be satisfied. Collage has no notion of + dependencies or incompatibilities and may attemt to mix candidate kernels we can't support in prod. It's also possible + for two BYOC integrations to have incompatible runtimes. +- **Additive kernel cost assumption**: Collage as per this design assumes the cost of running candidate kernels is + additive, plus a small launch penalty. However cache effects can dominate measured latency, particularly for 'light' + kernels. Thus there may be a **additive error** in the final result: + + > additive_error = measured_latency(collage_partitioning) - sum_{kernel} (estimated_latency(kernel) + penalty) + + The evolutionary search explored by the Collage paper can help here since it uses measured end-to-end model latency as + its cost function, but we're deferring that to future work. + +- **Limited search space**: Naively exploring all sub-graphs is O(n!), so we need to constrain the search. The easiest + approach is just to limit candidate kernels to sub-graphs of just a few operators. This can mean significatly faster + candidates are not explored, yielding a partitioning with high **optimality loss**: + + > optimality_loss = measured_latency(collage_partitioning) - measured_latency(true_optimal_partitioning) + + Though the 'true' optimal partitioning may be infeasible to find, the user may easily discover a high + **apparent loss**, eg by comparing the Collage result with a traditional BYOC partitioning result: + + > apparent_loss = measured_latency(collage_partitioning) - measured_latency(users_own_partitioning) + +- **Fragile toolchains**: Some BYOC toolchains are intended to be stand-alone compilers in their own right, and have + been tuned against common models and include global flags to guide optimizations such as reducing precision. However + Collage will only feed these toolchains smaller sub-graphs, thus making the limited search space problem more severe. +- **High variance in lightweight kernels**: Small kernels can have high variance, thus the choice of which toolchain to + use can be arbitrary. We probably want to i) validate our variance estimator is accurate, ii) choose a percentile + slightly above 50% for the estimated candidate kernel latency, and iii) fall back to hard-coded priorities when the + measured variance is too high. +- **Non-compositional BYOC toolchains**: BYOC partitioning functions often run global passes to get the Relay graph into + a state better aligned with the toolchain on the assumption they are the exclusive partitioning pass. Most obvious is + the choice of layout, and if two BYOC integrations have a different choice of layout then there's currently no way for + them to be used concurrently. All of those passes must either be i) pushed up to global configuration (which could be + explored by a search layer outside of TVM), ii) pushed into the BYOC lowering/codegen function (to prepare the + sub-graph for further compilation) or iii) moved into the standard Relay optimization passes run before + `CollageFuseOps`. +- **Repeated FuseOps**: Some passes (eg `ManifestAlloc`) introduce new calls to primitive function which must be fused + and lowered, even though the main work of fusion and lowering has already occurred. We'll need to either + retain `FuseOps`, or ensure `CollageFuseOps` retains the efficiency and handling of `FuseOps` when there's no + toolchain ambiguity. +- **Explainability**: It's easy to show the user the final partitioning and estimated times for each kernel, but harder + to show why that partitioning won out over all others during search. +- **Does not subsume `partition_for_`**: We don't have any plan to deprecate the existing patterns of each + BYOC integration supplying a `partiion_for_` function. If the user has a specific toolchain in mind then + making the partition explicit enjoys both faster compilation and can incorporate global optimization passes which + Collage cannot currently account for (eg enforcing a particular layout). + +## Sub-projects + +These items need more design and can be run as 'sub-projects'. + +### Robust candidate kernel latency measurement + +Collage requires an implementation of a `CostEstimator`: + +``` +class CostEstimator { + public: + /*! + * \brief Return the estimated cost (possibly after many many minutes of training time) of + * running function using target. + */ + virtual Cost Estimate(const Function& function, const Target& target) const; +} +``` + +The 'v2' prototype has implemented this with an in-memory cache and a small Python driver which defers to +TVM's `tvm.runtime.vm.VirtualMachine`s `benchmark` helper. The following needs to be designed and implemented: + +- Compilation should be in units of `IRModule` rather than `Function` so that, in the future, additional global + definitions (such as for weights) can be conveyed to the toolchain. +- The recent MetaSchedule work has provided `BuilderInput` (`include/tvm/meta_schedule/builder.h`), + `RunnerInput` (`include/tvm/meta_schedule/runner.h`) and `Database` (`include/tvm/meta_schedule/database.h`) + interfaces. The latter is for `TuningRecord`s of `Workload`s. It looks like these interfaces can support the + measurement of Collage `CandidateKernel`s with minor changes. +- (Internal to OctoML) We need an implementation connecting to the internal OctoML kernel tuning workflow and production + cache. Ideally this would be the same implementation as for the MetaSchedule system. +- Collage converts measured 50th %ile latencies to costs in seconds. We may need to consider taking a slightly higher + %ile to be more robust against variance on small kernels. We need to validate the estimated variance reflects true + variance. +- For TVM-native targets, we would like the `Estimate` call to perform any TVM tuning required for a novel candidate + kernel. + +### Easier Library Integration + +TVM has two very different ways to make external library implementations available for use by kernels: The pattern-based +BYOC approach and the TVM `te.extern` approach. + +The pattern-based approach allows library implementations to match with more than one Relay operator, such as for biased +convolution with an activation function. For example, for +[DNNL](https://oneapi-src.github.io/oneDNN/v1.3/index.html) the global pattern table is extended +in `python/tvm/relay/op/contrib/dnnl.py`, and the pattern labels indicate the intended corresponding DNNL functions. The +user is responsible for partitioning using the usual `MergeComposite`/`AnnotateTarget`/`PartitionGraph` +sequence. The `relay.ext.dnnl` BYOC function in `src/relay/backend/contrib/dnnl/codegen.cc` looks for calls to +`"Composite"` functions in the overall `"Primitive"` function, and dispatches based on the `"Composite"` label. C code +is emitted to target the DNNL library, and the standard C compiler helper is invoked to produce a +`runtime::Module`. + +Note that it is not possible for a TVM-generated kernel to call a library function integrated this way. In effect every +library function must go into a library-specific kernel (though kernels may group calls to multiple library function). + +The `te.extern` approach only allows library implementations which are 1:1 with Relay operators. However the library may +be used as part of a larger TVM-generated kernel, and the usual TVM tuning machinery may choose to use the library based +on overall kernel performance measured during TVM tuning. For example, `batch_matmul` +can be implemented using [CuBLAS](https://developer.nvidia.com/cublas) via the strategy `batch_matmul` in +`python/tvm/contrib/cublas.py`, which is made available to the operator's `OpStrategy` using +`batch_matmul_stategy_cuda` in `python/tvm/relay/op/strategy/cuda.py` when `cublas` appears in the `Target`s `libs` +attribute. That strategy simply calls the `PackedFunc` registered as `tvm.contrib.cublas.batch_matmul` and implemented +in `src/runtime/contrib/cublas/cublas.cc` as part of the TVM runtime. + +Collage as presented can work with either approach. For the pattern-based BYOC approach Collage doesn't need to know +what's going on under the BYOC integration hood, it only needs to see a `Target` with the appropriate +`compiler` attribute. For the `te.extern` approach Collage can choose a candidate TVM sub-graph, then rely on TVM tuning +to redirect some operators to their library implementations should the `Target` have the appropritae `libs` +attribute. + +However, better would be something which: + +- Supports the many-to-one mapping of the pattern-based approach since it is so common in library implementations. +- Always allows calls to extern functions from within TVM-generated kernels. +- Requires less boilerplate than the pattern-based approach, and less ceremony than the `te.extern` approach. + +Our strawman: + +- Allow calls to `"Composite"` Functions to be transliterated to extern calls in the normal TVM lowering flow, where + the `"Composite"` attribute gives us the 'external function label'. +- The transliteration uses a global TVM registry of external function labels. Each entry describes how to generate a + library shim and how to emit a `tir.call_packed' to that shim. +- The usual Collage fusion rules can be used to include labelled sub-graphs with the appropriate external function + labels as alternatives. Those sub-graphs are ultimately combined into candidate kernels. Collage will then naturally + search between candidates with different choices of native vs library implementations. + +### Robust BYOC integrations for targets of interest + +Overall any BYOC toolchain which could be supported by Collage needs to be brought to a high standard: + +- It should support the latest toolchain/library versions. +- It should support as much of Relay (both operators and dtypes) as feasible. In particular, Collage will only find + interesting mixes when BYOC toolchains have overlapping operator and dtype support. +- It should correctly report which operators/patterns are supported. +- It should have good unit test coverage in CI. +- Dependencies should be documented and installation scripted (hopefully this is an easy consequence of the above). +- The translation scheme should give the BYOC toolchain the best chance to do well. In particular, if Collage reports + toolchain X 'is better' than toolchain Y for a candidate sub-graph we want to have confidence that's not just because + toolchain Y has been hobbled by a poor translation, API misuse, or other 'holding it wrong' issue. +- Where feasible, partitioning for the BYOC toolchain (not using Collage) should not be worse than using the toolchain + directly. + +Our current focus is on TensorRT, CUTLASS, CuDnn and CuBlas. + +### Visualization + +A [netron](https://netron.app/) style visualization for Relay which clearly shows the partitioning and cost for all the +kernels would be very valuable. The paper prototype produces such a visualization but we've lost that functionality in +the transition to 'v2'. + +## Highlights from the 'v1' prototype + +The results of the preprint were derived in a [branch](https://github.com/cmu-catalyst/collage) from +[TVM](https://github.com/apache/tvm) at `461d06eb5cfc7954f1983779acd05c47cea269f1`. We ported/rebased that code onto +main, and refer to it as the +['v1' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-port). + +The 'v1' prototype has five main parts: + +- A + new [backend](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/include/tvm/ir/expr.h#L208) + field on every Relay `Expr` to capture the pattern name and backend name chosen by Collage to force compilation to + match its choices. +- An [intercept](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1392) + in `fuse_ops.cc` which redirects to the main Collage fuser/searcher before TVM’s fusion rules kick in. + +- The main + fuser/searcher [implementation](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/comp_graph_optimizer.py#L221) + (for the simpler DP algorithm). This implementation: + - Uses both Relay `Pattern` s and it’s own path-based fusion algorithm to find candidate sub-graphs. + - Uses the DP algorithm to find the best assignment of fused sub-graphs and targets to cover the whole Relay graph. + - Applies the assignment to the IRModule using the new `backend` field + + The evolutionary search algorithm runs after the above and attempts to replace ‘op’ kernels (use a library) with + ‘graph’ kernels (if there’s a unique graph backend). +- An + intercept ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1402) + and + [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/_optimizer.py#L48)) + in `fuse_ops.cc` to actually effect the fusion for BYOC backends depending on the new `backend` field +- An + intercept ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/backend/te_compiler_cache.cc#L284) + and + [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/backend/collage_strategies.py#L18)) + in `te_compiler.cc` to take over the selection of `OpStrategy` based on the `backend` field. + +Note that the 'v1' prototype only supports `IRModules` with a single `"main"` whose body is in the ‘pure dataflow’ Relay +subset. Ie only calls, tuples, tuple projections, function variables and constants are supported. + +## Differences between the Paper's prototype and this Design + +In comparison to the 'v1' prototype, this design: + +- Avoids the need to add any new 'Collage specific' fusion patterns and predicates. We want to make sure Collage can + work even for out-of-tree BYOC toolchains (modulo some of the BYOC API changes we discuss below). +- Builds on the existing support for heterogeneous `Target`s to represent the menu of available toolchains to use during + search. In particular, we want to allow users to blend `on_device` annotations (to express preferences for which + devices should execute which sub-graphs) with Collage (to find the best kernels and toolchains respecting those device + preferences). +- Uses the existing convention for `"Primitive"`, `"Composite"` and `"Compiler"` attributes on Relay `Function`s to + express the assignment of sub-graph to toolchain. +- Implements support for 3rd party libraries (eg cudnn) so as to allow an N-to-1 mapping from Relay operators to library + call (this is not yet implemented in the 'v2' prototype, see below for the sketch). +- Is implemented mostly in C++. + +However: + +- The 'v2' prototype only implements the 'op-level' dynamic-programming based search strategy from the paper. Though the + paper reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future work. + +## TODO in the 'v2' prototype + +- Implement extern-for-TVM support and bring in `cudnn` and `cublas`. +- Cross-check against one of the 'v1' models. +- Bring up on `GPT2`. +- Explore `float16` performance mixing `CUTLASS` and `TensorRT`. +- Implement TVM-tuning during Collage search. +- Connect estimator to production tuner & cache. +- Estimator works on `IRModule` not `Function`. Resolve `params` binding question. +- Find model+target combination that shows compelling speedup from mixing w.r.t. all other options, including stand + alone `TensorRT`. +- Implement Target refinement so that device planning can be used to constrain the available Collage targets to consider + for arbitrary sub-graphs. Allow multiple targets per `FusionSpec` so that we don't waste time finding the same + candidates for different TVM targets. +- 'Lookahead' from the current search state to find the 'next' dataflow node(s) which have candidates crossing multiple + `FusionSpec`s. That defines a sub-graph. There's no need to search over all possible candidates within that sub-graph + since almost certainly the maximal candidates will be best. Somehow prune the candidates to implement that. +- Cleanup after search to merge adjacent kernels for the same target when supported by toolchain. +- How much of the existing `DFPattern` machinery should be refactored to go via `SubGraph`? +- Post fusion passes introduce new Relay primitives which then need to be fused and lowered, so `FuseOps` still in pass + list. Consider replacing with `CollageFuseOps` in lightweight mode? Need to avoid all search when toolchain is already + uniquely determined. +- `Target`s can have a `"fusion_spec"` attribute to directly control fusion. +- Indexing in `CombineByKindFusionRule` to avoid O(n^2) iteration over candidates. +- Need to be dominator aware in `CombineByPrimitivesFusionRule` or is current naive approach of + using `SubGraph::IsValid` + good enough to eliminate taps? +- What's with the use of `OpPatternKinds` on dataflow edges in `FuseOps` and the special rule relabelling + `kBroadcast` as `kElemwise` if input/output shapes match? Need to find examples. +- Horizontal/Vertical prims for `CombineByKindFusionRule` to finally cover those uses. Check we subsume + `Combine` \ No newline at end of file From 98d9ba51b01dd080314b20e105970f45eaec82a0 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Tue, 15 Mar 2022 12:08:03 -0700 Subject: [PATCH 02/11] - Add some FAQ entries. Make the partition_for_x preamble issue more explict. --- rfcs/xxxx-collage.md | 69 ++++++++++++++++++++++++++++---------------- 1 file changed, 44 insertions(+), 25 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index de799626..db7bd688 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -31,15 +31,16 @@ This tuning approach contrasts with TVM's existing "greedy" and "manual" approac latency. Collage will also explore mixing and matching between multiple BYOC toolchains as well as TVM's native backend. -The design (when Collage is enabled) subsumes TVM's fixed `FuseOps` and BYOC-provided `partition_for_` +When Collage is enabled it subsumes TVM's fixed `FuseOps` and (some) BYOC-provided `partition_for_` operations (built using the `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes) with a single new `CollageFuseOps` pass. The pass is carefully engineered to build directly on the existing `"TOpPattern"` attributes (provided for every Relay operator and used by `FuseOps`), BYOC `"target."` operator predicates (provided for some operator/toolchain pairs by 'operator-based' BYOC integrations) and BYOC operator pattern/predicates (registered in the pattern table by 'pattern-based' BYOC integrations). In this way only the more -boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage. The -`partition_for_` operations are retained for users who wish to retain manual control. +boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage. Note however the +`partition_for_` operations are retained for users who wish to retain manual control, and to support +global rewrites in preparation for partitioning. > NOTE: We'd like to coordinate these changes with the UMA project. Our aim in this design is to make the smallest > changes to BYOC as possible. We think the changes described here can be easily reworked to follow any BYOC API @@ -59,7 +60,19 @@ Collage offers four advantages: ## FAQ -Pending. +- **Are you deprecating `FuseOps`?** No. On the VM compilation path `FuseOps` is run multiple times to prepare for +lowering newly inserted primitives. `FuseOps` is also much more efficient when sub-graph search is not required. +Finally, `FuseOps` has some special cases we're not yet handling in `CollageFuseOps`. +- **Are you deprecating the BYOC `partition_for_` methods?** No. Collage does not yet have a way to handle +any global passes invoked before partitioning in those functions. +- **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores +partitionings, and cannot currently explore rewrites. So, for example, Collage cannot explore the choice of device +for a sub-graph since that choice must be captured in the overall `IRModule` by new `device_copy` calls or some other +`IRModule` rewrite. +- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate kernels, and for the +TVM backend those kernels may themselves be subject to schedule tuning. +- **Does this clash with the UMA proposal?** No. Though Collage takes over fusion and partitioning, it only needs +access to the pattern table for the active BYOC toolchains. Collage can track any changes to that registry. ## Success Metrics @@ -90,9 +103,8 @@ TVM. A rough PR progression is: - TensorRT and CUTLASS BYOC changes are backwards compat. The existing `partition_for_X` functions remain. The CUTLASS-specific tuning and codegen functions will either continue to be supported or we'll work with users to account - for them being folded into the function-at-a-time `relay.ext.cutlass` - codegen function. -- The the `DFPattern` and friends changes are all mostly just for improving the robustness of the + for them being folded into the function-at-a-time `relay.ext.cutlass` codegen function. +- The `DFPattern` and friends changes are all mostly just for improving the robustness of the `IndexedGraph` class and can go into main independently. - Some basic `Expr` improvements can go into main independently. - The design allows for multiple `Target`s for the same `DLDeviceType`. That requires the various @@ -553,14 +565,25 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run - **Some BYOC boilerplate changes required**: TVM's current BYOC integration API only requires the 'lowering/codegen' function to be registered to a well-known global function name. Everything else is up to the BYOC author. - - Collage requires pattern-based BYOC integrations to register their patterns in the global pattern table. + - Collage requires pattern-based BYOC integrations to register their patterns in the global pattern table. Some + BYOC integrations use the table but many do not, but it's an easy fix. - Collage requires the BYOC lowering function to yield a valid `runtime::Module` without requiring any additional - BYOC-specific passes to be run. + BYOC-specific passes to be run. Some BYOC integrations require the user to run separate passes to tune and/or + compile the partitioned, those need to be moved into the lowering function itself. - Collage requires the BYOC integration to either correctly test for which operators are supported in the pattern/operator predicate, or gracefully propagate failure rather than CHECK-fail if an unsupported operator is included in a candidate kernel. Thus a BYOC integration will need to be 'robustified' to become 'Collage - compatible'. Overall we've tried to make as few changes as possible. Collage will happily follow along with any - improvements to the BYOC integration API (eg via the UMA project). + compatible'. + + Overall we've tried to make as few changes as possible. Collage will happily follow along with any + improvements to the BYOC integration API (eg via the UMA project). +- **Non-compositional BYOC toolchains**: BYOC partitioning functions often run global passes to get the Relay graph into + a state better aligned with the toolchain on the assumption they are the exclusive partitioning pass. Most obvious is + the choice of layout, and if two BYOC integrations have a different choice of layout then there's currently no way for + them to be used concurrently. All of those passes must either be i) pushed up to global configuration (which could be + explored by a search layer outside of TVM), ii) pushed into the BYOC lowering/codegen function (to prepare the + sub-graph for further compilation) or iii) moved into the standard Relay optimization passes run before + `CollageFuseOps`. - **Higher tuning cost**: Obviously Collage needs to estimate the latency of many more candidate kernels, and each candidate may itself trigger tuning during lowering. For TVM this can require O(thousands) of trials and take O(hours) , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. @@ -572,15 +595,15 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run selected of sub-graph and toolchain as a candidate kernel, cost = estimated sum of kernel costs plus launch penalties) , and thus only pay the cost of tuning candidate kernels which could possibly influence the final partitioning. - **No non-local optimization**: Though Collage can explore the choice of sub-graph and toolchain, it cannot explore any - choices which require the arguments and/or result of the sub-graph to be rewritten. Thus Collage **cannot** be used to - search over: + choices which require the arguments and/or result of the sub-graph to be rewritten, or the overall `IRModule` to be + changed. Thus Collage **cannot** be used to search over: - choice of layout for arguments/results (may require insertion of layout transforms), - choice of memory scope for arguments/results (may require insertion of device copies), - - choice of device on which to host the kernel (ditto) - since all those choices can require changes beyond the candidates sub-graph. -- the choice of layout for a kernel since any choice other than the model's default must be - 'corrected' for by the inserted layout transformations. To support this efficiently we'd need to abandon the - simple-minded but fast `SubGraph` representation we describe below in favor of something like an EGraph + - choice of device on which to host the kernel (ditto), + - choice of quantization scheme, + + since all those choices can require changes beyond the candidate's sub-graph. To support this efficiently we'd need + to abandon the simple-minded but fast `SubGraph` representation we describe here in favor of something like an EGraph representation, which seems like a very large change for TVM. - **Dependency management**: Currently BYOC integrations tend to assume they are the only non-TVM toolchain in use. So it's possible two toolchains introduce runtime dependencies which can't be satisfied. Collage has no notion of @@ -613,13 +636,6 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run use can be arbitrary. We probably want to i) validate our variance estimator is accurate, ii) choose a percentile slightly above 50% for the estimated candidate kernel latency, and iii) fall back to hard-coded priorities when the measured variance is too high. -- **Non-compositional BYOC toolchains**: BYOC partitioning functions often run global passes to get the Relay graph into - a state better aligned with the toolchain on the assumption they are the exclusive partitioning pass. Most obvious is - the choice of layout, and if two BYOC integrations have a different choice of layout then there's currently no way for - them to be used concurrently. All of those passes must either be i) pushed up to global configuration (which could be - explored by a search layer outside of TVM), ii) pushed into the BYOC lowering/codegen function (to prepare the - sub-graph for further compilation) or iii) moved into the standard Relay optimization passes run before - `CollageFuseOps`. - **Repeated FuseOps**: Some passes (eg `ManifestAlloc`) introduce new calls to primitive function which must be fused and lowered, even though the main work of fusion and lowering has already occurred. We'll need to either retain `FuseOps`, or ensure `CollageFuseOps` retains the efficiency and handling of `FuseOps` when there's no @@ -802,6 +818,9 @@ However: ## TODO in the 'v2' prototype +- Can me move `CollageFuseOps` earlier in the pipeline? Are there passes in `partiton_for_x` preambles which are + always safe to run in the standard Relay flow (eg inline constants). +- Dig into quantization. - Implement extern-for-TVM support and bring in `cudnn` and `cublas`. - Cross-check against one of the 'v1' models. - Bring up on `GPT2`. From 384198fc7a1cca1f403208d08e985924ce5adb21 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Tue, 15 Mar 2022 16:50:21 -0700 Subject: [PATCH 03/11] - Clarify pass ordering issue. --- rfcs/xxxx-collage.md | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index db7bd688..5efa6fb4 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -73,6 +73,10 @@ for a sub-graph since that choice must be captured in the overall `IRModule` by TVM backend those kernels may themselves be subject to schedule tuning. - **Does this clash with the UMA proposal?** No. Though Collage takes over fusion and partitioning, it only needs access to the pattern table for the active BYOC toolchains. Collage can track any changes to that registry. +- **Won't this mean the BYOC-specific fusion patterns and lowering will be after standard + Relay passes?** Yes. At the moment `CollageFuseOps` runs just before `FuseOps`, which is + after quite a few passes such as `qnn.transform.Legalize`. We think we need to move `CollageFuseOps` to be + much earlier in the pipeline but are not yet sure of the consequences. ## Success Metrics @@ -81,7 +85,7 @@ access to the pattern table for the active BYOC toolchains. Collage can track an compiler (via BYOC), and (obviously!) TVM native. 2. Collage does not require new per-target or per-model patterns or rules to be implemented independently of the BYOC integrations. -3. Collage with just the native TWM and a single BYOC toolchain enabled is never worse than using the +3. Collage with just the native TVM and a single BYOC toolchain enabled is never worse than using the existing `partition_for_` + functions run before any other Relay passes, and thus the Relay model is seen in it's 'clean' state. We need to + figure out how to move `CollageFuseOps` earlier in the pipeline to be before any target-specific rewrites or any + passes which may make BYOC patterns and lowering more difficult, but without interfering with TVM's fusion. This + needs more thought. - **Higher tuning cost**: Obviously Collage needs to estimate the latency of many more candidate kernels, and each candidate may itself trigger tuning during lowering. For TVM this can require O(thousands) of trials and take O(hours) , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. From 107ed169f78cbc5a66f78a9a811dfa87c2906db5 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Wed, 16 Mar 2022 17:31:20 -0700 Subject: [PATCH 04/11] - Strawman for moving CollageFuseOps early. --- rfcs/xxxx-collage.md | 186 +++++++++++++++++++++++++++++++------------ 1 file changed, 135 insertions(+), 51 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 5efa6fb4..3173c65c 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -39,8 +39,8 @@ single new operator predicates (provided for some operator/toolchain pairs by 'operator-based' BYOC integrations) and BYOC operator pattern/predicates (registered in the pattern table by 'pattern-based' BYOC integrations). In this way only the more boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage. Note however the -`partition_for_` operations are retained for users who wish to retain manual control, and to support -global rewrites in preparation for partitioning. +`partition_for_` operations are retained for users who wish to retain manual control, and to support global +rewrites in preparation for partitioning. > NOTE: We'd like to coordinate these changes with the UMA project. Our aim in this design is to make the smallest > changes to BYOC as possible. We think the changes described here can be easily reworked to follow any BYOC API @@ -61,22 +61,22 @@ Collage offers four advantages: ## FAQ - **Are you deprecating `FuseOps`?** No. On the VM compilation path `FuseOps` is run multiple times to prepare for -lowering newly inserted primitives. `FuseOps` is also much more efficient when sub-graph search is not required. -Finally, `FuseOps` has some special cases we're not yet handling in `CollageFuseOps`. + lowering newly inserted primitives. `FuseOps` is also much more efficient when sub-graph search is not required. + Finally, `FuseOps` has some special cases we're not yet handling in `CollageFuseOps`. - **Are you deprecating the BYOC `partition_for_` methods?** No. Collage does not yet have a way to handle -any global passes invoked before partitioning in those functions. + any global passes invoked before partitioning in those functions. - **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores -partitionings, and cannot currently explore rewrites. So, for example, Collage cannot explore the choice of device -for a sub-graph since that choice must be captured in the overall `IRModule` by new `device_copy` calls or some other -`IRModule` rewrite. -- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate kernels, and for the -TVM backend those kernels may themselves be subject to schedule tuning. -- **Does this clash with the UMA proposal?** No. Though Collage takes over fusion and partitioning, it only needs -access to the pattern table for the active BYOC toolchains. Collage can track any changes to that registry. -- **Won't this mean the BYOC-specific fusion patterns and lowering will be after standard - Relay passes?** Yes. At the moment `CollageFuseOps` runs just before `FuseOps`, which is - after quite a few passes such as `qnn.transform.Legalize`. We think we need to move `CollageFuseOps` to be - much earlier in the pipeline but are not yet sure of the consequences. + partitionings, and cannot currently explore rewrites. So, for example, Collage cannot explore the choice of device for + a sub-graph since that choice must be captured in the overall `IRModule` by new `device_copy` calls or some other + `IRModule` rewrite. +- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate kernels, and for the TVM + backend those kernels may themselves be subject to schedule tuning. +- **Does this clash with the UMA proposal?** No. Though Collage takes over fusion and partitioning, it only needs access + to the pattern table for the active BYOC toolchains. Collage can track any changes to that registry. +- **Won't this mean the BYOC-specific fusion patterns and lowering will be after standard Relay passes?** Yes. At the + moment `CollageFuseOps` runs just before `FuseOps`, which is after quite a few passes such as `qnn.transform.Legalize` + . We think we need to move `CollageFuseOps` to be much earlier in the pipeline but are not yet sure of the + consequences. ## Success Metrics @@ -86,7 +86,7 @@ access to the pattern table for the active BYOC toolchains. Collage can track an 2. Collage does not require new per-target or per-model patterns or rules to be implemented independently of the BYOC integrations. 3. Collage with just the native TVM and a single BYOC toolchain enabled is never worse than using the - existing `partition_for_` method in TVM today. ## Project Milestones @@ -105,7 +105,7 @@ Though the 'v2' prototype is in a personal branch we'd like to transition to mai separation, maintaining backwards compat, and a new `PassConfig` flag to isolate all Collage changes from the rest of TVM. A rough PR progression is: -- TensorRT and CUTLASS BYOC changes are backwards compat. The existing `partition_for_X` functions remain. The +- TensorRT and CUTLASS BYOC changes are backwards compat. The existing `partition_for_` functions remain. The CUTLASS-specific tuning and codegen functions will either continue to be supported or we'll work with users to account for them being folded into the function-at-a-time `relay.ext.cutlass` codegen function. - The `DFPattern` and friends changes are all mostly just for improving the robustness of the @@ -125,17 +125,17 @@ TVM. A rough PR progression is: ## Related Work -- The [Cascading Scheduler](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0037-arm-ethosu-cascading-scheduler.md) combines i) dynamic-programming - to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to guide the search, - and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By contrast - Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) - uses measurement to guide the search and iii) assuming the toolchain will 'do its best' with the - sub-graph offered to it. -- The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal - adds a layer on top of the existing and separate TVM BYOC, operator strategy, operator scheduling, - target-specific passes and target-specific code generation extension points. Collage currently relies - only on the global pattern registry and global `relay.ext.` function to integrate with BYOC - integrations, but this is trivial to change should this project change the source of truth. +- The [Cascading Scheduler](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0037-arm-ethosu-cascading-scheduler.md) + combines i) dynamic-programming to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to + guide the search, and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By + contrast Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) + uses measurement to guide the search and iii) assuming the toolchain will 'do its best' with the sub-graph offered to + it. +- The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal adds a layer on top + of the existing and separate TVM BYOC, operator strategy, operator scheduling, target-specific passes and + target-specific code generation extension points. Collage currently relies only on the global pattern registry and + global `relay.ext.` function to integrate with BYOC integrations, but this is trivial to change should this + project change the source of truth. ## Example @@ -264,6 +264,90 @@ fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { } ``` +## Pass Ordering +> CAUTION: Under construction. + +The current TVM convention is for BYOC integrations to supply a `partition_for_` function which can be called +by the user on the original input model, ie before **any** Relay passes are run. + +Many `partition_for_` functions then run their own 'preamble' passes before the op patterns and op predicates +are used for partitioning. Those passes are sometimes just generic Relay passes such as `FoldConstant`. But some may +impose specific global rewrites, such as for layout. All the BYOC op patterns and op predicates are thus written +w.r.t. 'vanilla' Relay models after just those passes. There's also no reason to expect those global rewrites are +compositional in any sensible way between different BYOC integrations. + +Some BYOC integrations also supply additional passes which are expected to be run after partitioning and lowering, for +example to finish tuning or compilation. + +Finally, the standard Relay pass prefix includes many passes which are target dependent (for example to 'legalize' +quantized version of ops depending on the intended target), or which prepare the model for Relay fusion and subsequent +lowering. These are all run before `FuseOps`. + +For `CollageFuseOps`: + +- We want to run before any TVM-specific passes so that both the BYOC patterns and toolchains see models in their + 'vanilla' form. +- But we also want to run after all TVM-specific passes so that candidates intended for TVM are ready for lowering. + +Clearly we can't have it both ways! + +For Collage we'll need to lightly refactor where passes are run. + +- **BYOC specific**: + - **BYOC global** (eg `ConvertLayout`): Currently run in the preamble of the `partition_for_` function to + apply a global rewrite to improve efficiency for the intended target (possibly at the expense of TVM's native + lowering). + - Under Collage, these passes need to be refactored out of `partition_for_` and into (eg) + `optimize_for_`. The user (or some top-level search outside of TVM) can apply this function in the + same way the currently apply `partition_for_`. Ideally this would be a well-known UMA extension + point. + - **BYOC partitioning** (`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` or a subset + thereof): Currently run after the premable of the `partition_for_runtime::Module` function registered as `relay.ext.`). Actually + invokes the BYOC compilation toolchain. + - Under Collage, the standard `TELower` pass will continue to invoke these functions depending on partitioning + annotations. + - **BYOC post-lowering** (eg `tune_cutlass_kernels`): A follow-on pass supplied by the BYOC integration to further + prepare the `runtime::Module`. + - Under Collage, these passes need to be folded back into BYOC lowering. +- **Safe global** (eg `FoldConstant`): Currently within the Relay pass prefix, and may be included in a BYOC preamble. + However the pass is universally applicable to all BYOC and TVM toolchains. + - Under Collage a 'safe' prefix of passes will be run before `CollageFuseOps`. If any BYOC predicates/patterns are + not invariant to these safe passes then we'll need to generalize them. +- **TVM specific**: + - **Target specific** (eg `qnn::transform::Legalize`): Applies per-operator or other rewrites which may be overriden + per target. Clearly the target must be known. Currently within the Relay pass prefix. Techncially should be run + after `PlanDevices` to support heterogenous execution but currently before `PlanDevices` and (sometimes) disabled + in heterogeneous mode. + - Under Collage these passes are run after `PlanDevices` (which may use `on_device` annotations to enforce some + target constraints) and `CollageFuseOps` (which will choose targets for all partitions subject to any existing + constraints). But they are only run on non-BYOC partitions, ie on everything other than `"Primitive"` + functions with a `"Compiler"` attribute. + - **Lowering specific** (eg `CanonicalizeOps`): Optimizations preparing for `FuseOps` and subsequent TVM lowering. + Currently within the Relay pass prefix. + - Under Collage, as for target specific passes above. + +In pictures, we are moving from: + +``` +partition_for_ --> {Safe global, TVM-specific} --> PlanDevices --> FuseOps --> LowerTE +(opt, by user) | + v + BYOC lowering +``` + +to: + +``` +optimize_for_ --> Safe Global --> PlanDevices --> CollageFuseOps --> TVM-specific --> LowerTE +(opt, by user) (TVM partitions only) | + v + BYOC lowering +``` + ## Design The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with some helper Python @@ -293,10 +377,9 @@ The `CollageFuseOps` pass proceeds in four phases: include the next yet-to-be-assigned dataflow node in X. - Edge cost: Estimated latency of the candidate kernel, plus a kernel launch penalty. Note that though we need to be able to extract the candidate's sub-graph in order to build the kernel, we do not yet need to partition the - overall function body expression. - Other search algorithms are certainly possible, eg the Paper uses an evolutionary search to refine - the partitioning found by the dynamic-programming search. We can easily abstract away the search - interface to support multiple implementations in the future. + overall function body expression. Other search algorithms are certainly possible, eg the Paper uses an + evolutionary search to refine the partitioning found by the dynamic-programming search. We can easily abstract + away the search interface to support multiple implementations in the future. - **Phase 4**: The function body is partitioned according to the candidate kernels on the shortest path. In the following we introduce the new datatypes, then expand on the phases. @@ -569,8 +652,8 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run - **Some BYOC boilerplate changes required**: TVM's current BYOC integration API only requires the 'lowering/codegen' function to be registered to a well-known global function name. Everything else is up to the BYOC author. - - Collage requires pattern-based BYOC integrations to register their patterns in the global pattern table. Some - BYOC integrations use the table but many do not, but it's an easy fix. + - Collage requires pattern-based BYOC integrations to register their patterns in the global pattern table. Some BYOC + integrations use the table but many do not, but it's an easy fix. - Collage requires the BYOC lowering function to yield a valid `runtime::Module` without requiring any additional BYOC-specific passes to be run. Some BYOC integrations require the user to run separate passes to tune and/or compile the partitioned, those need to be moved into the lowering function itself. @@ -578,9 +661,9 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run pattern/operator predicate, or gracefully propagate failure rather than CHECK-fail if an unsupported operator is included in a candidate kernel. Thus a BYOC integration will need to be 'robustified' to become 'Collage compatible'. - - Overall we've tried to make as few changes as possible. Collage will happily follow along with any - improvements to the BYOC integration API (eg via the UMA project). + + Overall we've tried to make as few changes as possible. Collage will happily follow along with any improvements to the + BYOC integration API (eg via the UMA project). - **Non-compositional BYOC toolchains**: BYOC partitioning functions often run global passes to get the Relay graph into a state better aligned with the toolchain on the assumption they are the exclusive partitioning pass. Most obvious is the choice of layout, and if two BYOC integrations have a different choice of layout then there's currently no way for @@ -591,14 +674,14 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run - **BYOC-specific patterns must match after standard Relay passes**: We currently run `CollageFuseOps` just before `FuseOps`, which means it runs after quite a number of standard Relay passes which themselves may invoke some target-specific rewrites (eg for quantization legalization). However, currently BYOC `partition_for_` - functions run before any other Relay passes, and thus the Relay model is seen in it's 'clean' state. We need to - figure out how to move `CollageFuseOps` earlier in the pipeline to be before any target-specific rewrites or any - passes which may make BYOC patterns and lowering more difficult, but without interfering with TVM's fusion. This - needs more thought. + functions run before any other Relay passes, and thus the Relay model is seen in it's 'clean' state. We need to figure + out how to move `CollageFuseOps` earlier in the pipeline to be before any target-specific rewrites or any passes which + may make BYOC patterns and lowering more difficult, but without interfering with TVM's fusion. This needs more + thought. - **Higher tuning cost**: Obviously Collage needs to estimate the latency of many more candidate kernels, and each candidate may itself trigger tuning during lowering. For TVM this can require O(thousands) of trials and take O(hours) - , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. - Currently Collage will measure more candidates even if TVM native is the only available target. + , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. Currently + Collage will measure more candidates even if TVM native is the only available target. - **Task extraction vs Tuning**: Traditionally TVM has had three phases: i) Task extraction (find the fused sub-graphs to tune), ii) Tuning (find a good schedule for those sub-graphs), and iii) Compilation (re-compile the model, now retrieving schedules for all the anticipated sub-graphs from the cache.) However the Collage 'v2' prototype collapses @@ -612,9 +695,9 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run - choice of memory scope for arguments/results (may require insertion of device copies), - choice of device on which to host the kernel (ditto), - choice of quantization scheme, - - since all those choices can require changes beyond the candidate's sub-graph. To support this efficiently we'd need - to abandon the simple-minded but fast `SubGraph` representation we describe here in favor of something like an EGraph + + since all those choices can require changes beyond the candidate's sub-graph. To support this efficiently we'd need to + abandon the simple-minded but fast `SubGraph` representation we describe here in favor of something like an EGraph representation, which seems like a very large change for TVM. - **Dependency management**: Currently BYOC integrations tend to assume they are the only non-TVM toolchain in use. So it's possible two toolchains introduce runtime dependencies which can't be satisfied. Collage has no notion of @@ -780,8 +863,9 @@ The 'v1' prototype has five main parts: new [backend](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/include/tvm/ir/expr.h#L208) field on every Relay `Expr` to capture the pattern name and backend name chosen by Collage to force compilation to match its choices. -- An [intercept](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1392) - in `fuse_ops.cc` which redirects to the main Collage fuser/searcher before TVM’s fusion rules kick in. +- +An [intercept](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1392) +in `fuse_ops.cc` which redirects to the main Collage fuser/searcher before TVM’s fusion rules kick in. - The main fuser/searcher [implementation](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/comp_graph_optimizer.py#L221) @@ -829,8 +913,8 @@ However: ## TODO in the 'v2' prototype -- Can me move `CollageFuseOps` earlier in the pipeline? Are there passes in `partiton_for_x` preambles which are - always safe to run in the standard Relay flow (eg inline constants). +- Can me move `CollageFuseOps` earlier in the pipeline? Are there passes in `partiton_for_x` preambles which are always + safe to run in the standard Relay flow (eg inline constants). - Dig into quantization. - Implement extern-for-TVM support and bring in `cudnn` and `cublas`. - Cross-check against one of the 'v1' models. From a54ff7a7e09e0531c3a6ffa575940f658ff3b044 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Tue, 22 Mar 2022 17:35:56 -0700 Subject: [PATCH 05/11] - Switch from 'fusion' to 'partition' focus, matched prototype again. --- rfcs/xxxx-collage.md | 1176 +++++++++++++++++++++--------------------- 1 file changed, 577 insertions(+), 599 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 3173c65c..765d8d87 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -1,4 +1,4 @@ -# Design Doc: Collage [Draft 0.7] +# Design Doc: Collage [Draft 0.8] ``` Feature Name: Collage @@ -6,77 +6,67 @@ Start Date: Mar 2022 Authors: Mark Shields (mbs@octoml.ai) RFC PR: GitHub Issue: + +History: +- v0.7: First draft. +- v0.8: Rework to emphasise 'partitioning' (quite early in pipeline) instead of 'fusion' (quite late in pipeline). ``` This design doc (with accompanying ['v2' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-sketch)) -shows how to bring tuning to TVM's operator fusion and BYOC partitioning passes. The tuning search explores the choice -of sub-graphs (aka 'partitions') as well as choice of toolchain (TVM native or one of the available BYOC integrations, -aka 'backends') for each candidate kernel so as to minimize the expected model inference latency. We call the result -an 'optimal partitioning'. This new tuning layer complements the tuning traditionally done by TVM and other toolchains -during lowering. It can also complement any global tuning, for example to explore all possible global layouts. +shows how to bring tuning to TVM's BYOC partitioning passes. The tuning search explores the choice +of sub-graphs (aka 'partitions') and toolchains (aka 'backends') so as to minimize the expected model +inference latency. Both 'graph style' (eg TensorRT) and 'library style' (eg DNNL) BYOC integrations +are supported. We call the result an 'optimal partitioning'. This new tuning layer complements the tuning +traditionally done by TVM and other toolchains during lowering. It can also complement any global tuning, for +example to explore the choice of layout convention or device assignment. The approach is based on the [preprint](https://arxiv.org/pdf/2111.00655.pdf): > *Collage: Automated Integration of Deep Learning Backends* > Byungsoo Jeon, Sunghyun Park, Peiyuan Liao, Sheng Xu, Tianqi Chen, Zhihao Jia -This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to fusion and BYOC: - -- Greedy: Currently only the largest possible supported sub-graphs are used for kernels, irrespective of their execution - time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller sub-graphs to yield - better overall latency than one large sub-graph if they mix toolchains. -- Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding partitioning function - before the main TVM compilation flow proceeds. With Collage the choice of toolchain can be automated based on measured - latency. Collage will also explore mixing and matching between multiple BYOC toolchains as well as TVM's native - backend. - -When Collage is enabled it subsumes TVM's fixed `FuseOps` and (some) BYOC-provided `partition_for_` -operations (built using the `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes) with a -single new -`CollageFuseOps` pass. The pass is carefully engineered to build directly on the existing `"TOpPattern"` attributes -(provided for every Relay operator and used by `FuseOps`), BYOC `"target."` -operator predicates (provided for some operator/toolchain pairs by 'operator-based' BYOC integrations) and BYOC operator -pattern/predicates (registered in the pattern table by 'pattern-based' BYOC integrations). In this way only the more -boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage. Note however the -`partition_for_` operations are retained for users who wish to retain manual control, and to support global -rewrites in preparation for partitioning. - -> NOTE: We'd like to coordinate these changes with the UMA project. Our aim in this design is to make the smallest -> changes to BYOC as possible. We think the changes described here can be easily reworked to follow any BYOC API -> proposals settled on by UMA. See also "Related Work." +(See Appendix A for a comparison of this proposal and the paper's implementation. See Appendix D for +TODO items in the 'v2' prototype.) + +This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to partitioning: + +- Greedy: Currently only the largest possible supported sub-graphs are used for partitions, irrespective of their + execution time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller + sub-graphs to yield better overall latency than one large sub-graph if they mix toolchains. +- Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding + `partition_for_` function before the main TVM compilation flow begins. With Collage the choice of + toolchain can be automated based on measured latency. Collage will also explore mixing and matching between + multiple BYOC toolchains as well as TVM's native backend. + +When Collage is enabled it subsumes the existing `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/ +`PartitionGraph` passes embedded within each `partition_for_` function with a single new +`CollagePartitioner` pass. The pass is guided by the list of available `Target`s and three existing sources: +1. The `"TOpPattern"` attributes provided for every Relay operator and used by TVM's built-in `FuseOps`. +2. The BYOC `"target."` operator predicates provided for some operator/toolchain pairs by + 'operator-based' BYOC integrations. +3. The BYOC operator pattern/predicates (usually) registered in the pattern table by 'pattern-based' BYOC integrations. + +Only some boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage (and we will +make these changes either as part of or in coordination with the UMA project). However Collage may require more +robustness from the BYOC integrations, see Appendix F. + +Note however that we are **not** proposing to deprecate the existing `partition_for_` operations (or their +UMA equivalent). This is mostly because Collage is inherently a tuning-based system which is not practical for +users who need a stand-alone compiler. But it is also because of challenges with establishing a common pass +ordering which will work for both TVM and all BYOC toolchains (see Appendix C for more details). Collage offers four advantages: -- **Latency**: Overall model latency may be reduced compared to TVM native, TVM with a specific BYOC toolchain, or a - non-TVM compiler such as TensorRT. +- **Latency**: Overall model latency may be reduced compared to TVM native, TVM with a single + `partition_for_` call, or a non-TVM stand-alone compiler such as TensorRT. - **Automation**: The choice of which BYOC toolchains to enable can be automated. -- **Economy of implementation**: Five standalone passes using three separate mechanisms for expressing fusion - rules/algorithms and implementing partitioning can be replaced with one, which itself is built from compositional - primitives. -- **Decoupling**: It is ok for a candidate kernel found during search to actually not be valid for a toolchain (even - TVM's). Such candidates could be given 'infinite' cost and thus ignored during search. In this way we can avoid tight - coupling between backends and fusion rules. - -## FAQ - -- **Are you deprecating `FuseOps`?** No. On the VM compilation path `FuseOps` is run multiple times to prepare for - lowering newly inserted primitives. `FuseOps` is also much more efficient when sub-graph search is not required. - Finally, `FuseOps` has some special cases we're not yet handling in `CollageFuseOps`. -- **Are you deprecating the BYOC `partition_for_` methods?** No. Collage does not yet have a way to handle - any global passes invoked before partitioning in those functions. -- **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores - partitionings, and cannot currently explore rewrites. So, for example, Collage cannot explore the choice of device for - a sub-graph since that choice must be captured in the overall `IRModule` by new `device_copy` calls or some other - `IRModule` rewrite. -- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate kernels, and for the TVM - backend those kernels may themselves be subject to schedule tuning. -- **Does this clash with the UMA proposal?** No. Though Collage takes over fusion and partitioning, it only needs access - to the pattern table for the active BYOC toolchains. Collage can track any changes to that registry. -- **Won't this mean the BYOC-specific fusion patterns and lowering will be after standard Relay passes?** Yes. At the - moment `CollageFuseOps` runs just before `FuseOps`, which is after quite a few passes such as `qnn.transform.Legalize` - . We think we need to move `CollageFuseOps` to be much earlier in the pipeline but are not yet sure of the - consequences. +- **Economy and modularity of implementation**: Four standalone passes using two separate mechanisms for expressing + partitioning rules/algorithms can be replaced with one, which itself is built from compositional primitives. (The + machinery is also reusable for the very similar problem of choosing TVM fusion kernels, which we'll tackle in the + future). + +See Appendix H for some frequently asked questions. ## Success Metrics @@ -85,8 +75,8 @@ Collage offers four advantages: compiler (via BYOC), and (obviously!) TVM native. 2. Collage does not require new per-target or per-model patterns or rules to be implemented independently of the BYOC integrations. -3. Collage with just the native TVM and a single BYOC toolchain enabled is never worse than using the - existing `partition_for_` method in TVM today. +3. Collage with a `Target` list enabling just one BYOC toolchain is never worse than using the the existing + `partition_for_` function directly. ## Project Milestones @@ -117,11 +107,10 @@ TVM. A rough PR progression is: - The new Collage code can go in bottom-up as we develop unit tests: - Support utils, including `NameSupply`, `IndexSet`, `PriorityQueue`, `Cost`, `CostEstimator`. - The core `SubGraph` datatype. - - `CandidateKernel`. - - The `FusionRule` class hierachy (which itself can be broken into sub-PRs). - - `FusionSpec`. - - `GatherFusionSpecs` helper for bridging the existing BYOC world with the Collage 'FusionRule' world. - - The `CollageFuseOps` driver pass itself. + - `CandidatePartition`. + - The `PartitionRule` class hierarchy, as a series of PRs, ending with `PartitionSpec`. + - `GatherPartitionSpecs` helper for bridging the existing BYOC world with the Collage `PartitionRule` world. + - The `CollagePartitioner` driver pass itself. ## Related Work @@ -129,13 +118,13 @@ TVM. A rough PR progression is: combines i) dynamic-programming to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to guide the search, and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By contrast Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) - uses measurement to guide the search and iii) assuming the toolchain will 'do its best' with the sub-graph offered to - it. + uses (very much slower!) measurement to guide the search and iii) has no influence over how either TVM or BYOC + toolchains actually lower the sub-graphs given to them. - The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal adds a layer on top of the existing and separate TVM BYOC, operator strategy, operator scheduling, target-specific passes and target-specific code generation extension points. Collage currently relies only on the global pattern registry and - global `relay.ext.` function to integrate with BYOC integrations, but this is trivial to change should this - project change the source of truth. + global `relay.ext.` function to integrate with BYOC integrations, but this is easy to rework should UMA + change the source of truth. ## Example @@ -169,58 +158,39 @@ with tvm.transform.PassContext(config={"relay.fallback_device_type": 2, "relay.c generic_target = tvm.target.Target("cuda", host_target) cutlass_target = tvm.target.Target("cuda -compiler=cutlass", host_target) tensorrt_target = tvm.target.Target("cuda -compiler=tensorrt", host_target) - cudnn_target = tvm.target.Target("cuda -libs=cudnn", host_target) - cublas_target = tvm.target.Target("cuda -libs=cublas", host_target) + cudnn_target = tvm.target.Target("cuda -compiler=cudnn", host_target) + cublas_target = tvm.target.Target("cuda -compiler=cublas", host_target) targets = [generic_target, cutlass_target, tensorrt_target, cudnn_target, cublas_target] exe = tvm.relay.vm.compile(mod, target=targets) ``` -(Note that `cudnn` and `cublas` are not yet supported in the 'v2' prototype.) +(Note that `cudnn` and `cublas` are not yet supported in the 'v2' prototype, see Appendix B.) -After the `CollageFuseOps` pass, the intermediate `"main"` global function could resemble the following (though we've -modified this "optimal" partitioning by hand to illustrate all the varieties of kernels so don't take it as +After the `CollagePartitioner` pass, the intermediate `"main"` global function could resemble the following +(though we've modified this "optimal" partitioning by hand for illustration so don't take it as representative of actual performance): ``` fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { - # Use TVM native - %3 = fn (%FunctionVar_08: Tensor[(1, 1, 28, 28), float32], - Primitive=1) -> Tensor[(1, 1, 32, 32), float32] { - nn.pad(%FunctionVar_08, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]) - }; - %4 = %3(%x); - # Use TVM native, but indicate we wish to link to CuDNN - %6 = fn (%FunctionVar_07: Tensor[(1, 1, 32, 32), float32], - Primitive=1) -> Tensor[(1, 8, 28, 28), float32] { - %5 = fn (%FunctionVar_5: Tensor[(1, 1, 32, 32), float32], - Composite="cudnn.conv2d") -> Tensor[(1, 8, 28, 28), float32] { - nn.conv2d(%FunctionVar_5, meta[relay.Constant][0] /*Tensor[(8, 1, 5, 5), float32]*/, - padding=[0, 0, 0, 0], channels=8, kernel_size=[5, 5]) - }; - %5(%FunctionVar_07) + # Operators left behind in the function body are intended for TVM. + # The usual Relay passes may rewrite them, then FuseOps will push them + # into "Primitive" functions (without any "Compiler" attribute) ready + # for TVM lowering. + %4 = nn.pad(%x, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]); + # This conv2d will be offloaded to cudnn. However the main TVM compilation + # flow is responsible for emitting the call. + %6 = fn (%FunctionVar_5: Tensor[(1, 1, 32, 32), float32], + Composite="cudnn.conv2d") -> Tensor[(1, 8, 28, 28), float32] { + nn.conv2d(%FunctionVar_5, meta[relay.Constant][0] /*Tensor[(8, 1, 5, 5), float32]*/, + padding=[0, 0, 0, 0], channels=8, kernel_size=[5, 5]) }; + # Back to vanilla TVM. %7 = %6(%4); - # Use TVM native, with fusion - %8 = fn (%FunctionVar_06: Tensor[(1, 8, 28, 28), float32], - %FunctionVar_12: Tensor[(8, 1, 1), float32], - Primitive=1) -> Tensor[(1, 8, 28, 28), float32] { - %3 = add(%FunctionVar_06, %FunctionVar_12); - nn.relu(%3) - }; - %9 = %8(%7, meta[relay.Constant][1] /*Tensor[(8, 1, 1), float32]*/); - # Use TVM native - %10 = fn (%FunctionVar_05: Tensor[(1, 8, 28, 28), float32], - Primitive=1) -> Tensor[(1, 8, 14, 14), float32] { - nn.max_pool2d(%FunctionVar_05, pool_size=[2, 2], strides=[2, 2], padding=[0, 0, 0, 0]) - }; - %11 = %10(%9); - # Use TVM native - %12 = fn (%FunctionVar_04: Tensor[(1, 8, 14, 14), float32], - Primitive=1) -> Tensor[(1, 8, 18, 18), float32] { - nn.pad(%FunctionVar_04, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]) - }; - %13 = %12(%11); - # Use TensorRT, with fusion + %3 = add(%7, meta[relay.Constant][1] /*Tensor[(8, 1, 1), float32]*/); + %9 = nn.relu(%3); + %11 = nn.max_pool2d(%9, pool_size=[2, 2], strides=[2, 2], padding=[0, 0, 0, 0]); + %13 = nn.pad(%11, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]); + # Use TensorRT. The "Primitive" function deleniates the partition. %14 = fn (%FunctionVar_03: Tensor[(1, 8, 18, 18), float32], %FunctionVar_11: Tensor[(16, 1, 1), float32], Primitive=1, @@ -232,19 +202,13 @@ fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { nn.relu(%2) }; %15 = %14(%13, meta[relay.Constant][3] /*Tensor[(16, 1, 1), float32]*/); - # Use TVM native - %16 = fn (%FunctionVar_02: Tensor[(1, 16, 14, 14), float32], - Primitive=1) -> Tensor[(1, 16, 4, 4), float32] { - nn.max_pool2d(%FunctionVar_02, pool_size=[3, 3], strides=[3, 3], padding=[0, 0, 0, 0]) - }; - %17 = %16(%15); - # Use TVM native - %18 = fn (%FunctionVar_01: Tensor[(1, 16, 4, 4), float32], - Primitive=1) -> Tensor[(1, 256), float32] { - reshape(%FunctionVar_01, newshape=[1, 256]) - }; - %19 = %18(%17); - # Use CUTLASS, with fusion + # Back to vanilla TVM. + %17 = nn.max_pool2d(%15, pool_size=[3, 3], strides=[3, 3], padding=[0, 0, 0, 0]); + %19 = reshape(%17, newshape=[1, 256]); + # Use CUTLASS. Note the double function nesting: the outer "Primitive" function + # deleniates the partition and the inner "Composite" function maps the original + # Relay operators to a tag to be used during compilation/build/lowering with the + # CUTLASS BYOC integration. %20 = fn (%FunctionVar_0: Tensor[(1, 256), float32], %FunctionVar_1: Tensor[(10, 256), float32], %FunctionVar_2: Tensor[(1, 10), float32], @@ -260,126 +224,51 @@ fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { }; %1(%FunctionVar_0, %FunctionVar_1, %FunctionVar_2) }; - %20(%19, meta[relay.Constant][4] /*Tensor[(10, 256), float32]*/, meta[relay.Constant][5] /*Tensor[(1, 10), float32]*/) + %20(%19, meta[relay.Constant][4] /*Tensor[(10, 256), float32]*/, + meta[relay.Constant][5] /*Tensor[(1, 10), float32]*/) } ``` -## Pass Ordering -> CAUTION: Under construction. - -The current TVM convention is for BYOC integrations to supply a `partition_for_` function which can be called -by the user on the original input model, ie before **any** Relay passes are run. - -Many `partition_for_` functions then run their own 'preamble' passes before the op patterns and op predicates -are used for partitioning. Those passes are sometimes just generic Relay passes such as `FoldConstant`. But some may -impose specific global rewrites, such as for layout. All the BYOC op patterns and op predicates are thus written -w.r.t. 'vanilla' Relay models after just those passes. There's also no reason to expect those global rewrites are -compositional in any sensible way between different BYOC integrations. - -Some BYOC integrations also supply additional passes which are expected to be run after partitioning and lowering, for -example to finish tuning or compilation. - -Finally, the standard Relay pass prefix includes many passes which are target dependent (for example to 'legalize' -quantized version of ops depending on the intended target), or which prepare the model for Relay fusion and subsequent -lowering. These are all run before `FuseOps`. - -For `CollageFuseOps`: - -- We want to run before any TVM-specific passes so that both the BYOC patterns and toolchains see models in their - 'vanilla' form. -- But we also want to run after all TVM-specific passes so that candidates intended for TVM are ready for lowering. - -Clearly we can't have it both ways! - -For Collage we'll need to lightly refactor where passes are run. - -- **BYOC specific**: - - **BYOC global** (eg `ConvertLayout`): Currently run in the preamble of the `partition_for_` function to - apply a global rewrite to improve efficiency for the intended target (possibly at the expense of TVM's native - lowering). - - Under Collage, these passes need to be refactored out of `partition_for_` and into (eg) - `optimize_for_`. The user (or some top-level search outside of TVM) can apply this function in the - same way the currently apply `partition_for_`. Ideally this would be a well-known UMA extension - point. - - **BYOC partitioning** (`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` or a subset - thereof): Currently run after the premable of the `partition_for_runtime::Module` function registered as `relay.ext.`). Actually - invokes the BYOC compilation toolchain. - - Under Collage, the standard `TELower` pass will continue to invoke these functions depending on partitioning - annotations. - - **BYOC post-lowering** (eg `tune_cutlass_kernels`): A follow-on pass supplied by the BYOC integration to further - prepare the `runtime::Module`. - - Under Collage, these passes need to be folded back into BYOC lowering. -- **Safe global** (eg `FoldConstant`): Currently within the Relay pass prefix, and may be included in a BYOC preamble. - However the pass is universally applicable to all BYOC and TVM toolchains. - - Under Collage a 'safe' prefix of passes will be run before `CollageFuseOps`. If any BYOC predicates/patterns are - not invariant to these safe passes then we'll need to generalize them. -- **TVM specific**: - - **Target specific** (eg `qnn::transform::Legalize`): Applies per-operator or other rewrites which may be overriden - per target. Clearly the target must be known. Currently within the Relay pass prefix. Techncially should be run - after `PlanDevices` to support heterogenous execution but currently before `PlanDevices` and (sometimes) disabled - in heterogeneous mode. - - Under Collage these passes are run after `PlanDevices` (which may use `on_device` annotations to enforce some - target constraints) and `CollageFuseOps` (which will choose targets for all partitions subject to any existing - constraints). But they are only run on non-BYOC partitions, ie on everything other than `"Primitive"` - functions with a `"Compiler"` attribute. - - **Lowering specific** (eg `CanonicalizeOps`): Optimizations preparing for `FuseOps` and subsequent TVM lowering. - Currently within the Relay pass prefix. - - Under Collage, as for target specific passes above. - -In pictures, we are moving from: - -``` -partition_for_ --> {Safe global, TVM-specific} --> PlanDevices --> FuseOps --> LowerTE -(opt, by user) | - v - BYOC lowering -``` - -to: - -``` -optimize_for_ --> Safe Global --> PlanDevices --> CollageFuseOps --> TVM-specific --> LowerTE -(opt, by user) (TVM partitions only) | - v - BYOC lowering -``` +Ideally this optimal partitioning would be understandable to the user, see Appendix G. ## Design -The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with some helper Python -under `python/tvm/relay/collage`. - -If the `relay.collage.enable_collage` `PassConfig` attribute is true then a new `CollageFuseOps` pass is inserted before -the existing `FuseOps` pass. The new pass effects the invariant: - -> All Relay sub-graphs in all global functions which are to be lowered to a kernel are replaced by calls to an inline -> `"Primitive"` `Function`. Functions which are to be lowered by a BYOC-provided toolchain are given -> `"Compiler"` and `"global_symbol"` attributes. The bodies of those function may contain calls to inlined -> `"Composite"` annotated functions to further direct lowering within the kernel. - -The `CollageFuseOps` pass proceeds in four phases: - -- **Phase 1**: The available `Target`s are scanned to build a list of `FusionSpec`s. Each `FusionSpec` is built from - (a tree of) `FusionRule`s. How the rules are constructed depends on `Target` itself. The remaining phases execute on - each global function separately. -- **Phase 2**: A `DataflowGraph` is constructed for the global function. The available `FusionRule`s are evaluated on - the dataflow graph to yield a (possibly overlapping) set of `CandidateKernels` for each target. Each candidate is - described by a `SubGraph` which efficiently denotes a sub-graph of the global function's body without the need to - construct any new expressions. The candidates are placed in a `CandidateKernelIndex` for use below. -- **Phase 3**: A shortest path is found in the following (implicit) search graph: - - Search Nodes: An `IndexSet` describing which dataflow nodes are been assigned to a candidate kernel so far. - - Search Edge X->Y: A `CandidateKernel` can be applied to node X to give node Y. The candidate is disjoint from all - dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate must also - include the next yet-to-be-assigned dataflow node in X. - - Edge cost: Estimated latency of the candidate kernel, plus a kernel launch penalty. Note that though we need to be - able to extract the candidate's sub-graph in order to build the kernel, we do not yet need to partition the - overall function body expression. Other search algorithms are certainly possible, eg the Paper uses an - evolutionary search to refine the partitioning found by the dynamic-programming search. We can easily abstract - away the search interface to support multiple implementations in the future. +The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with just a few Python +helper functions under `python/tvm/relay/collage`. + +If the `relay.collage.enable_collage` `PassConfig` attribute is true then a new `CollagePartitioner` pass is +inserted before all other Relay passes. The result of the pass is: +- All Relay sub-graphs in all global functions which are to be handed off to a BYOC toolchain are replaced by + calls to an inline `"Primitive"` function with `"Compiler"` and `"global_symbol"` attributes. +- Relay operators, or groups of operators, which are to be translated to particular library or BYOC-supplied + function are replaced by calls to an inline `"Composite"` function. (This encoding is supported for both + BYOC and external libraries.) + +Note that no `"Primitive"` functions denoting TVM kernels are produced -- the existing `FuseOps` pass is still +required. + +The `CollagePartitioner` pass has four phases: + +- **Phase 1**: The available `Target`s are scanned to build a list of rules describing how to find possible + partitions (see `PartitionSpec` and `PartitionRule` below). Depending on the `Target` the rules may incorporate + entries from the BYOC pattern table. (The remaining phases execute on each global function separately.) +- **Phase 2**: A dataflow graph is constructed for the global function (which is just an `IndexedGraph`). + The available rules from phase 1 are evaluated on the dataflow graph to yield a (possibly overlapping) set of + candidate partitions for each target (see `CandidatePartition` below). Each candidate efficiently describes a + sub-graph of the global function's body without the need to construct any new expressions (see `SubGraph` below). +- **Phase 3**: A shortest path is found in the following (implicit and lazily constructed) search graph: + - Search Nodes: The set of dataflow nodes which have already been assigned to a candidate partition in all paths + to the node. + - Search Edge X->Y: A candidate partition can be applied to node X to give node Y. The candidate is disjoint + from all dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate + must also include the next yet-to-be-assigned dataflow node in X. + - Edge cost: The estimated latency of the candidate partition, plus a partition transition penalty. Note that + though we need to be able to extract the candidate's sub-graph in order to build a function representing the + candidate, we do not yet need to partition the overall function body expression. + + Other search algorithms are certainly possible, eg the paper uses an evolutionary search to refine the partitioning + found by the dynamic-programming search. We can easily abstract away the search interface to support multiple + implementations in the future. - **Phase 4**: The function body is partitioned according to the candidate kernels on the shortest path. In the following we introduce the new datatypes, then expand on the phases. @@ -396,208 +285,215 @@ In the following we introduce the new datatypes, then expand on the phases. and inverse-dominators. - `IndexSet`: A bit vector indexed by `PostDfsIndex`s. These are used as a compact representation for an arbitrary set of dataflow nodes in a dataflow graph. -- `Cost`: A `double` representing a candidate kernel's 'cost', which currently is just mean execution latency in - seconds. Collage only cares that costs are additive and a total order, so in the future we could support cost - functions which balance execution time against high memory watermark or other measures. Costs may be `Unknown` +- `Cost`: A `double` representing a candidate partition (or kernel) 'cost', which currently is just mean execution + latency in seconds. Collage only cares that costs are additive and a total order, so in the future we could support + cost functions which balance execution time against high memory watermark or other measures. Costs may be `Unknown` (ie NaN) to signal some other heuristic should be used to compare kernel costs. Costs may be `Invalid` (ie +inf) to signal the toolchain could not compile and run a candidate kernel. ### SubGraph -A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary sub-graph of the -overall dataflow graph. This and `FusionRule` below are the core Collage datatypes. +A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary +sub-graph of the overall dataflow graph. This and `PartitionRule` below are the core Collage datatypes. + +Sub-graphs can be used to represent partitions/kernels/composite functions without having to +pay the cost of constructing or rewriting any expressions. We also allow 'extracting' a +function to use for measuring a partition/kernel's latency independently from 'rewriting' +the overall Relay expression since only a tiny subset of candidate partitions will end up being +needed after Collage has completed its search. -Sub-graphs can be used to represent 'composite'' and 'fused' functions without having to pay the cost of constructing -either the function or the rewritten overall 'partitioned' expression which calls that function. We also allow functions -to be extracted independently of partitioning, since we'll need to estimate the latency of many more kernel functions -than will ultimately be used in the final Relay expression. We expect O(thousands) of sub-graphs to be in flight while -processing a given model. +We expect O(thousands) of sub-graphs to be in flight while processing a given model, so are +mindful of space overhead. -A sub-graph classifies every dataflow node of the overall expression as either 'inside' or 'outside' the sub-graph. -Obviously not all such divisions make sense, for example it is not valid for an inside node to feed into another inside -node via outside nodes. We provide the `IsValid` method to check for validity, and `SubGraphConfig` to control which -rules apply (such as maximum depth). +A sub-graph classifies every dataflow node of the overall expression as either 'inside' or +'outside' the sub-graph. Obviously not all such divisions make sense, for example it is not +valid for an inside node to feed into another inside node via outside nodes. We provide an +`IsValid` method to check for validity, and `SubGraphConfig` to control which validity rules +apply (such as maximum depth). -As well as 'inside' and 'outside' we have four other flavors of dataflow nodes (all uniquely determined from the -'inside' nodes): +We generally work with the `DataflowGraph` representation of the overall Relay expression +rather than the expression itself. We use the post-dfs visit index to uniquely refer to +expression nodes. +As well as 'inside' and 'outside' we have four other flavors of dataflow nodes, all uniquely +determined from the 'inside' nodes: - 'entry' nodes are those inside with at least one dataflow input outside. -- 'exit' nodes are those inside with at least one dataflow output outside, or which are considered 'external' in the - underlying dataflow graph (eg because they represent the result of the overall function). +- 'exit' nodes are those inside with at least one dataflow output outside, or which + are considered 'external' in the underlying dataflow graph (eg because they represent + the result of the overall function). - 'input' nodes are those outside with at least one dataflow output inside. - 'output' nodes are those outside with at least one dataflow input inside. -It is valid to have multiple entry nodes (we'll bind a parameter for each). It may be valid to have multiple exit -nodes (we'll build a tuple of all such). It may be valid to have exit nodes which also contribute to other inside -nodes (ie represent a 'top' on an intermediate result). +Index sets for these are cached with the sub-graph for performance. +It is valid to have multiple entry nodes (we can bind a parameter for each). It may be valid to +have multiple exit nodes (we can build a tuple of all such). It may be valid to have exit nodes +which also contribute to other inside nodes (ie represent a 'tap' on an intermediate result). + Sub-graphs are closed under: - - Disjoint union. -- Wrapping by a label, which indicates the wrapped sub-graph should be extracted as a sub-function with a "Composite" - label. -- Substitution, which allows a sub-graph w.r.t. one dataflow graph to be transformed to match some other (typically - smaller) dataflow graph. - -To support some of the `OpPatternKind`-based fusion rules (see below) we give sub-graphs a kind, which is generally the -maximum of the kinds of all the operator calls appearing inside it. We also given sub-graphs a label to help debugging. - -Note that the Relay `PatternPartitoner` goes directly from `Expr` to partitioned `Expr` without stopping at any -intermediate representation. It may be worth 'promoting' `SubGraph` out of Collage andy into the standard `DFPattern` -suite. - -Note that to support closure on both disjoint union and wrapping by a label `SubGraph`s are actually recursive -- see -the 'v2' prototype `sub_graph.cc` for details. +- Wrapping by a function with given attributes. This can be used to encode "Composite" functions, + or to represent a candidate kernel within a "Primitive" function. (By combining 'wrapping' with + 'union' we can encode, eg, 'this sub-graph should be placed inside a primitive function which + itself may have calls to composite functions). +- Substitution, which allows a sub-graph w.r.t. one dataflow graph to be transformed to + match some other (typically smaller) dataflow graph. + +Note that the Relay `PatternPartitoner` goes directly from `Expr` to partitioned `Expr` without stopping +at any intermediate representation. It may be worth 'promoting' `SubGraph` out of Collage and into the +standard `DFPattern` suite, we leave that to future work. -### CandidateKernel +### CandidatePartition -A `CandidateKernel` pairs a `SubGraph` with a `FusionSpec` (from which the intended `Target` for the candidate kernel -can be extracted). All Collage search and measurement is in units of candidate kernels. +A `CandidatePartition` pairs a `SubGraph` with a `Target`. All Collage search and measurement is in terms of +candidate partitions. -### FusionRule +### PartitionRule -A `FusionRule` describes how to find a set of `CandidateKernel`s for a `DataflowGraph`. This and `SubGraph` above are -the core Collage datatypes. All fusion rules implement the method: +A `PartitionRule` describes how to find a set of `CandidatePartitions`s for a `DataflowGraph`. This and `SubGraph` +above are the core Collage datatypes. All partition rules implement the method: ``` -virtual Array AllCandidateKernels(const DataflowGraph& dataflow_graph, - const FusionSpec& spec) const; +virtual std::vector AllCandidates(const DataflowGraph& dataflow_graph, + const PartitionSpec& spec) const; ``` -The candidates are allowed to overlap, and ultimately it is the job of the Collage fusion searcher to find a selection +The candidates are allowed to overlap, and ultimately it is the job of the Collage searcher to find a selection of candidates which covers the whole Relay expression without overlap. -We provide a set of 'base' fusion rules which produce candidates from the dataflow graph directly. We also provide a set -of 'combinator' rules which can produce new candidates from the results of arbitrary sub-rule or sub-rules. In this way -it is possible to combine the fusion rules to express a wide variety of fusion strategies, akin to the way we can -combine TVM passes. +We provide a set of 'base' partition rules which produce candidates from the dataflow graph +directly. We also provide a set of 'combinator' partition rules which can produce new candidates +from the results of an arbitrary sub-rule or sub-rules. By mixing these base and combinator +rules we can express a wide variety of partition strategies and encoding conventions. -There may be many thousands of candidates in flight during the fusion search. We take care to defer rewriting any Relay -expressions (eg to extract the fused function, or partition the model) until absolutely necessary. +There may be many thousands of candidates in flight during the Collage search. We take care to +defer constructing or rewriting Relay expressions until absolutely necessary. We only pay for +extracting a function to represent a candidate when we need to measure it's cost. And we only +pay for rewriting the overall Relay expression to commit to a partitioning when the Collage +search has completed. The base rules implemented so far: - -- `DFPatternFusionRule`: Given a `DFPattern` and expression predicate, produces a candidate for every sub-graph matched - by the pattern and predicate. Unlike the Relay `PatternRewriter`, candidates are free to overlap. This is the - foundation for pattern-based BYOC integrations, and can be used to write targeted fusion rules as well as find - examples of 'composite' operators. -- `OpPredicateFusionRule`: Given an attribute name, produces a candidate for every call to a primitive Relay operator - where the operator has predicate bound to that attribute which returns true given the call sub-expression. Generally - this will result in a singleton sub-graph containing only the call, but it may pull in constant arguments to the call - should they be required. This is the foundation for operator-based BYOC integrations, though we should consider - retiring this mechanism in favor of pattern-based alone. -- `OpCallByKindFusionRule`: Uses the `"TOpPattern"` attribute provided for every Relay operator to produce a candidate - for every call to a 'fusable Relay operator'. This can be used as the foundation for generic fusion patterns which - work over all Relay operators with particular properties (elementwise, broadcast, injective, reductive, anchor). +- `DFPatternPartitionRule`: Given a `DFPattern` and expression predicate, produces a candidate + for every sub-graph matched by the pattern and predicate. Unlike the `PatternRewriter`, + candidates are free to overlap. Used to bring BYOC patterns into the Collage framework. +- `OpPredicatePartitionRule`: Given an attribute name, produces a candidate for every call + to a primitive Relay operator where the operator i) has predicate bound to that attribute + which ii) returns true given the call sub-expression. Generally this will result in a + singleton sub-graph containing only the call, but it may also pull in constant arguments to + the call should they be required. Used to bring BYOC operator predicates into the Collage + framework. +- `OpCallByKindPartitionRule`: Uses the `"TOpPattern"` attribute provided for every Relay + operator to produce a candidate for every call to a 'fusable Relay operator'. Used to + look ahead to how TVM will fuse sub-graphs. The combinator rules implemented so far: - -- `CompositeFusionRule`: 'Tags' the candidates matched by an arbitrary sub-rule with the rule name. Tagged sub-graphs - are turned into "Primitive" Function with the "Composite" - attribute bound to the tag. This can be used to indicate Relay operators (or groups of Relay operators) are to be - rewritten to specific target-specific operators. This combinator wraps the `DFPatternFusionRules` for the - pattern-based BYOC integrations. However it could also be used with the default TVM backend, eg to indicate Relay - operators should be replaced with particular external library implementations. -- `CombineByPrimitivesFusionRule`: Given a sub-rule and a list of 'primitive' rules, finds all possible ways of - combining the sub-rule candidates to yield even larger candidates. Note that the sub-rule's candidates may also be - included in the results -- that is every combination of candidates is considered optional. The 'primitive' rules allow - combining by - `OpPatternKinds`, and combining the arguments to tuples which themselves are arguments to Relay operator calls. This - rule is intended to mimic the existing TVM `FuseOps` pass, though: i) all combinations are found, ii) the starting set - of candidates can be provided by any other rule (ie not just `OpCallByKindFusionRule`), and iii) we rely on `SubGraph` - validity checking to weed out infeasible candidates. - -Though not yet implemented, we'd like to allow a combinator rule which will union candidate based on their 'anchor' -operators. This can be used to implement 'vertical' and 'horizontal' fusion on more primitive candidates. Note that the -`SubGraph` machinery supports multiple-input and -output sub-graphs and their validation, so horizontal fusion is easy -implement. - -We also have `MaxCoalesceFusionRule`, which eagerly combines 'touching' candidates (ie candidates where the output of -one sub-graph can be directly connected to the input of the other sub-graph) -to form the largest possible candidate. The idea is once the search has been completed this rule can be used to collapse -adjacent kernels intended for the same target. - -Here's some typical `FusionRule` combinations for different fusion strategies (please excuse the crudity of the diagram, -I didn't have time to build it to scale or paint it): - -- Classic TVM `FuseOps`: - -``` - OpCallByKindFusionRule - | - v - CombineByPrimitivesFusionRule (with default TVM primitive rules) -``` - -- Classic operator-based BYOC with `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes: - -``` - OpPredicateFusionRule - | - v - CombineByPrimitivesFusionRule (with join anything primitive rule) -``` +- `CompositePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped + by a `"Composite"` function. The `"Composite"` name is taken from the rule name. Used to indicate + Relay operators (or groups of Relay operators) should be mapped to target-specific operators, + both for BYOC and TVM external library integrations. +- `PrimitivePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped + by a `"Primitive"` function, possibly with an additional `"Compiler"` attribute. Used to + delineate a partition (or kernel). +- `UnionPartitionRule`: Simply unions all the candidates from all sub-rules together. Used to + combine individual `DFPatternPartitionRules`. +- `CombinePartitionRule`: Given a sub-rule and a list of 'combiner' rules, finds + all possible ways of combining the sub-rule's candidates to yield even larger candidates. + Note that the sub-rule's candidates may also be directly included in the results. The + 'combiner' rules allow combining by \p OpPatternKinds, combining the arguments to tuples + which themselves are arguments to Relay operator calls, and so on. This rule is intended to + mimic the existing TVM `FuseOps` pass, though: + i) all candidates are found rather than just the largest, ii) the starting set of candidates + can be provided by any other rule, and iii) we rely on `SubGraph` validity checking to weed + out infeasible candidates. +- `OnlyValidPartitionRule`: Given a `SubGraphConfig`, ignores candidates with 'invalid' + sub-graphs. Used to limit the maximum candidate depth, the number of independent outputs, + and whether intermediate 'taps' are allowed. +- `HostPartitionRule`: Produces candidates for all Relay expressions which could be + 'left behind' for execution by the host (eg on the VM). This rule lets us simplify the + overall Collage search algorithm. + +(Though not yet implemented, we'd like to allow a combinator rule which will union candidate +based on their 'anchor' operators. This can be used to implement 'vertical' and 'horizontal' +partition on more primitive candidates. Note that the \p SubGraph machinery supports +multiple-input and -output sub-graphs and their validation, so horizontal partition is easy +implement.) + +Here are some typical ways to combine `PartitionRules` for different partition/fusion +strategies: +- Classic operator-predicate based BYOC with + `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes: + ``` + PrimitivePartitionRule + OnlyValidPartitionRule + CombinePartitionRule (with a join-anything combiner rule) + OpPredicatePartitionRule + ``` - Classic pattern-based BYOC with `MergeComposite`/`AnnotateTarget`/`PartitionGraph` passes: + ``` + PrimitivePartitionRule + OnlyValidPartitionRule + CombinePartitionRule (with join-anything combiner rule) + UnionPartitionRule + CompositePartitionRule(label1) + DFPatternPartitionRule(pattern1) + : + CompositePartitionRule(labeln) + DFPatternPartitionRule(patternn) + ``` + +- "Consider this library implementation for these sub-expressions", using `DFPatterns` to + pick out which Relay operators are supported: + ``` + OnlyValidPartitionRule + CombinePartitionRule (with default TVM combiner rules) + UnionPartitionRule + OpCallByKindPartitionRule + CompositePartitionRule(lable1) + DFPatternPartitionRule(pattern1) + : + CompositePartitionRule(lablen) + DFPatternPartitionRule(patternn) + ``` -``` - DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) - | | - v v - CompositeFusionRule(label1) ... CompositeFusionRule(labeln) - \ / - v v - UnionFusionRule - | - v - CombineByPrimitivesFusionRule (with join anything primitive rule) -``` +- Classic TVM `FuseOps`: + ``` + PrimitivePartitionRule + OnlyValidPartitionRule + CombinePartitionRule (with default TVM combiner rules) + OpCallByKindPartitionRule + ``` - "Just fuse what I tell you to fuse", using `DFPatterns` to directly select candidates: + ``` + PrimitivePartitionRule + OnlyValidPartitionRule + UnionPartitionRule + DFPatternPartitionRule(pattern1) + : + DFPatternPartitionRule(patternn) + ``` -``` - DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) - \ / - v v - UnionFusionRule -``` - -- "Consider this library implementation for these sub-expressions", using `DFPatterns` to pick out which Relay operators - are supported (note that TVM lowering does not currently support this): - -``` - OpCallByKindFusionRule DFPatternFusionRule(pattern1) ... DFPatternFusionRule(patternn) - \ | | - \ v v - \ CompositeFusionRule(label1) ... CompositeFusionRule(labeln) - \ | / - v v v - UnionFusionRule - | - v - CombineByPrimitivesFusionRule (with default TVM primitive rules) -``` - -### FusionSpec +### PartitionSpec -A `FusionSpec` pairs a a `FusionRule` with a `Target`. +A `PartitionSpec` pairs a a `PartitionRule` with one or more `Target`s. ### Phase 1 We build on the existing TVM support for heterogeneous devices and targets. The available `Targets` are extracted from the compilation configuration (eg using the existing `CompilationConfig` helper class). Each target is inspected to -decide on how to construct a `FusionSpec`, which will guide Collage in the selection of candidate kernels to explore for +decide on how to construct a `PartitionRule`, which will guide Collage in the selection of candidate kernels to explore for that target. -- If the `Target` has a `"fusion_spec"` attribute, use that directly (not currently in the 'v2' prototype). This would - allow users to directly control fusion for the target's they care about. +- If the `Target` has a `"partition_rule"` attribute, use that directly. This would allow users to directly control + partitioning/fusion for the target's they care about. - If the `Target` has a `"compiler"` attribute (eg `"cutlass"`), and the global pattern table has an entry for that - attribute value, assume the `Target` denotes a pattern-based BYOC integration to explore. The `FusionSpec` + attribute value, assume the `Target` denotes a pattern-based BYOC integration to explore. The `PartitionRule` will import all the BYOC patterns and predicates automatically. - As above, but if global pattern has no matching entry, assume the `Target` denotes a predicate-based BYOC integration - to explore (eg `"tensorrt"`). The `FusionSpec` will look for and evaluate predicates with the + to explore (eg `"tensorrt"`). The `PartitonRule` will look for and evaluate predicates with the `"target."` attribute on all Relay operators. -- Otherwise, assume the `Target` denotes a TVM-native target. The `FusionSpec` mimics the existing `FuseOps`, but now +- Otherwise, assume the `Target` denotes a TVM-native target. The `PartitionRule` mimics `FuseOps`, but now generalized to explore multiple candidates so as to leave room for possible BYOC candidates. Note that to make this approach work we need to allow for multiple `Target`s with the same `DLDeviceKind`. For the VM @@ -605,15 +501,15 @@ simply switching the `target` argument from dictionary to list and removing some all that was required to support this. The user can use `on_device` annotations to constrain sub-graphs to particular devices. When Collage is considering -candidate kernels, it should be sure to choose a candidate `Target` which 'refines' the `Target` for every +candidate partitions, it should be sure to choose a candidate `Target` which 'refines' the `Target` for every sub-expression discovered by the `PlanDevicesPass`. Given targets T and U we say 'T refines U' if T has a -'"compiler"' and/or '"fusion_spec"' attributes, U has no such attributes, and T and U otherwise agree on all other -fields. (This is not currently in the 'v2' prototype). +'"compiler"' and/or '"partition_rule"' attributes, U has no such attributes, and T and U otherwise agree on all other +fields. ### Phase 2 -Most of the hard work for this phase is carried by the `AllCandidateKernels` implementations of the `FusionRule`s. The -main driver simply needs to index all the found `CandidateKernels` by their minimum 'inside' `PostDfsIndex` +Most of the hard work for this phase is carried by the `AllCandidates` implementations of the `PartitionRule`s. The +main driver simply needs to index all the found `CandidatePartitions` by their minimum 'inside' `PostDfsIndex` for rapid retrieval during the shortest path search. ### Phase 3 @@ -624,29 +520,23 @@ We find it most natural to use Dijkstra to find the optimal partitioning. A `Sea identifying key for the state. - The predecessor `SearchState` in the best path to this state. - The `Cost` of the best path to this state. This is the order for the Dijkstra priority queue. -- The `CandidateKernel` for the transition from the best predecessor to this state. +- The `CandidatePartition` for the transition from the best predecessor to this state. The starting state has no covered nodes. The final state has all nodes covered. -When expanding a state we could choose any `CandidateKernel` collected from phase 2 provided it doesn't overlap with the -state's covered set. However, a search path applying candidates C then D is equivalent to one applying D then C, so we -only consider candidates which intersect the next yet-to-be-covered dataflow node. For each such candidate we use -the `CostEstimator` (with it's assumed cache) to get the candidate's cost, build the successor state, and 'relax' the -successor state in the usual way. +When expanding a state we could choose any `CandidatePartition` collected from phase 2 provided it doesn't overlap +with the state's covered set. However, a search path applying candidates C then D is equivalent to one applying +D then C, so we only consider candidates which intersect the next yet-to-be-covered dataflow node. For each such +candidate we use the `CostEstimator` (with it's assumed cache) to get the candidate's cost, build the successor +state, and 'relax' the successor state in the usual way. (See Appendix E for more details on `CostEstimator`.) -Not all Relay expression nodes need to be assigned to a kernel since the VM or other execution provider can happily -evaluate most Relay expressions except for calls to primitive operators. Thus the search must allow for the possibility -of a expression node being 'left behind'. +The `HostPartitionRule` is used to allow some dataflow nodes to be 'left behind' for execution by the host. ### Phase 4 -The overall Relay expression is partitioned over all the `CandidateKernel`s on the shortest path 'in parallel'. Since -all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful not to -invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. - -Note that all the extracted functions in the result will be marked as `"Primitive"`, and thus will be left alone by most -other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run (repeatably) after -`CollageFuseOps`. +The overall Relay expression is partitioned over all the `CandidatePartition`s on the shortest path 'in parallel'. +Since all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful +not to invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. ## Known Limitations @@ -664,56 +554,54 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run Overall we've tried to make as few changes as possible. Collage will happily follow along with any improvements to the BYOC integration API (eg via the UMA project). + - **Non-compositional BYOC toolchains**: BYOC partitioning functions often run global passes to get the Relay graph into a state better aligned with the toolchain on the assumption they are the exclusive partitioning pass. Most obvious is the choice of layout, and if two BYOC integrations have a different choice of layout then there's currently no way for them to be used concurrently. All of those passes must either be i) pushed up to global configuration (which could be explored by a search layer outside of TVM), ii) pushed into the BYOC lowering/codegen function (to prepare the sub-graph for further compilation) or iii) moved into the standard Relay optimization passes run before - `CollageFuseOps`. -- **BYOC-specific patterns must match after standard Relay passes**: We currently run `CollageFuseOps` just before - `FuseOps`, which means it runs after quite a number of standard Relay passes which themselves may invoke some - target-specific rewrites (eg for quantization legalization). However, currently BYOC `partition_for_` - functions run before any other Relay passes, and thus the Relay model is seen in it's 'clean' state. We need to figure - out how to move `CollageFuseOps` earlier in the pipeline to be before any target-specific rewrites or any passes which - may make BYOC patterns and lowering more difficult, but without interfering with TVM's fusion. This needs more - thought. -- **Higher tuning cost**: Obviously Collage needs to estimate the latency of many more candidate kernels, and each - candidate may itself trigger tuning during lowering. For TVM this can require O(thousands) of trials and take O(hours) - , so we'll be very dependent on cached tuning logs to amortize this cost between models for the same target. Currently - Collage will measure more candidates even if TVM native is the only available target. + `CollagePartitioner`. + +- **Higher tuning cost**: Obviously Collage needs to estimate the latency of partitions. For TVM this can trigger + turning of schedules for novel kernels, which can require O(thousands) of trials and take O(hours), so we'll be + very dependent on cached tuning logs to amortize this cost between models for the same target. + - **Task extraction vs Tuning**: Traditionally TVM has had three phases: i) Task extraction (find the fused sub-graphs to tune), ii) Tuning (find a good schedule for those sub-graphs), and iii) Compilation (re-compile the model, now retrieving schedules for all the anticipated sub-graphs from the cache.) However the Collage 'v2' prototype collapses all these phases. This lets us lazily explore the implied search graph (nodes = partially rewritten models, edges = - selected of sub-graph and toolchain as a candidate kernel, cost = estimated sum of kernel costs plus launch penalties) - , and thus only pay the cost of tuning candidate kernels which could possibly influence the final partitioning. + selected of sub-graph and toolchain as a candidate partition, cost = estimated sum of partition costs plus transition + penalties), and thus only pay the cost of measuring (and tuning) candidates which could possibly influence the + final partitioning. + - **No non-local optimization**: Though Collage can explore the choice of sub-graph and toolchain, it cannot explore any choices which require the arguments and/or result of the sub-graph to be rewritten, or the overall `IRModule` to be changed. Thus Collage **cannot** be used to search over: - - choice of layout for arguments/results (may require insertion of layout transforms), - - choice of memory scope for arguments/results (may require insertion of device copies), - - choice of device on which to host the kernel (ditto), - - choice of quantization scheme, - - since all those choices can require changes beyond the candidate's sub-graph. To support this efficiently we'd need to - abandon the simple-minded but fast `SubGraph` representation we describe here in favor of something like an EGraph - representation, which seems like a very large change for TVM. + - Choice of layout for arguments/results (may require insertion of layout transforms), + - Choice of memory scope for arguments/results (may require insertion of device copies), + - Choice of device on which to host the kernel (ditto), + - Choice of quantization scheme, + + To support this efficiently we'd need to abandon the simple-minded but fast `SubGraph` representation we describe + here in favor of something like an EGraph representation, which seems like a very large change for TVM. + - **Dependency management**: Currently BYOC integrations tend to assume they are the only non-TVM toolchain in use. So it's possible two toolchains introduce runtime dependencies which can't be satisfied. Collage has no notion of dependencies or incompatibilities and may attemt to mix candidate kernels we can't support in prod. It's also possible for two BYOC integrations to have incompatible runtimes. -- **Additive kernel cost assumption**: Collage as per this design assumes the cost of running candidate kernels is - additive, plus a small launch penalty. However cache effects can dominate measured latency, particularly for 'light' - kernels. Thus there may be a **additive error** in the final result: - > additive_error = measured_latency(collage_partitioning) - sum_{kernel} (estimated_latency(kernel) + penalty) +- **Additive cost assumption**: Collage as per this design assumes the cost of running candidate partitions is + additive, plus a small transition penalty. However cache effects can dominate measured latency, particularly for + 'lightweight' kernels. Thus there may be a **additive error** in the final result: + + > additive_error = measured_latency(collage_partitioning) - sum_{partition} (estimated_latency(partition) + penalty) - The evolutionary search explored by the Collage paper can help here since it uses measured end-to-end model latency as + The evolutionary search explored by the paper can help here since it uses measured end-to-end model latency as its cost function, but we're deferring that to future work. - **Limited search space**: Naively exploring all sub-graphs is O(n!), so we need to constrain the search. The easiest - approach is just to limit candidate kernels to sub-graphs of just a few operators. This can mean significatly faster + approach is just to limit candidates to sub-graphs of just a few operators. This can mean significantly faster candidates are not explored, yielding a partitioning with high **optimality loss**: > optimality_loss = measured_latency(collage_partitioning) - measured_latency(true_optimal_partitioning) @@ -726,26 +614,237 @@ other Relay passes except `LowerTEPass`. Thus it's fine for `FuseOps` to be run - **Fragile toolchains**: Some BYOC toolchains are intended to be stand-alone compilers in their own right, and have been tuned against common models and include global flags to guide optimizations such as reducing precision. However Collage will only feed these toolchains smaller sub-graphs, thus making the limited search space problem more severe. + - **High variance in lightweight kernels**: Small kernels can have high variance, thus the choice of which toolchain to use can be arbitrary. We probably want to i) validate our variance estimator is accurate, ii) choose a percentile slightly above 50% for the estimated candidate kernel latency, and iii) fall back to hard-coded priorities when the measured variance is too high. -- **Repeated FuseOps**: Some passes (eg `ManifestAlloc`) introduce new calls to primitive function which must be fused - and lowered, even though the main work of fusion and lowering has already occurred. We'll need to either - retain `FuseOps`, or ensure `CollageFuseOps` retains the efficiency and handling of `FuseOps` when there's no - toolchain ambiguity. + - **Explainability**: It's easy to show the user the final partitioning and estimated times for each kernel, but harder to show why that partitioning won out over all others during search. + - **Does not subsume `partition_for_`**: We don't have any plan to deprecate the existing patterns of each BYOC integration supplying a `partiion_for_` function. If the user has a specific toolchain in mind then making the partition explicit enjoys both faster compilation and can incorporate global optimization passes which Collage cannot currently account for (eg enforcing a particular layout). -## Sub-projects +## Appendix A: Differences between the paper's implementation and this proposal + +The results of the paper were derived in a [branch](https://github.com/cmu-catalyst/collage) from +[TVM](https://github.com/apache/tvm) at `461d06eb5cfc7954f1983779acd05c47cea269f1`. We ported/rebased that code onto +main, and refer to it as the +['v1' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-port). + +The 'v1' prototype has nine main parts: + +1. A new + [backend](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/include/tvm/ir/expr.h#L208) + field on every Relay `Expr` to capture the pattern name and backend name chosen during search. Downstream compilation + must be forced to respect that choice. +2. An + [intercept](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1392) + in `fuse_ops.cc` which redirects to the main Collage fuser/searcher before TVM’s fusion rules kick in. +3. The main fuser/searcher + [implementation](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/comp_graph_optimizer.py#L221) + (for the simpler DP algorithm). This implementation: +4. Uses both Relay `Pattern` s and its own path-based fusion algorithm to find candidate sub-graphs. +5. Uses the DP algorithm to find the best assignment of fused sub-graphs and backends to cover the whole Relay graph. +6. Applies the resulting assignment to the `IRModule` using the new `backend` field on every expression. +7. An evolutionary search algorithm may optionally run after the above, and will attempt to replace ‘op’ kernels + (which use a library) with ‘graph’ kernels (arbtrary sub-graph), but only if there’s a unique graph backend enabled. +8. An intercept + ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1402) + and + [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/_optimizer.py#L48)) + in `fuse_ops.cc` to actually effect the fusion for BYOC backends depending on the new `backend` field. +9. An intercept + ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/backend/te_compiler_cache.cc#L284) + and + [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/backend/collage_strategies.py#L18)) + in `te_compiler.cc` to take over the selection of `OpStrategy` based on the `backend` field. -These items need more design and can be run as 'sub-projects'. +Note that the 'v1' prototype only supports `IRModules` with a single `"main"` whose body is in the ‘pure dataflow’ Relay +subset. Ie only calls, tuples, tuple projections, function variables and constants are supported. + +In comparison to the 'v1' prototype, this design: + +1. Shifts the search to occur at the very start of the compilation flow rather than just before `FuseOps` so that + Collage sees the same input model as would an existing `partition_for_` BYOC function. This change allows + us to use the existing BYOC patterns/predicates to guide the selection of candidate partitions instead of requiring + new patterns to be added to support the combination of models and BYOC toolchains. It also ensures the existing BYOC + lowering functions see partitions before any TVM-lowering specific passes have been applied, such as + `qnn::transform::Legalize` and `transform::CombineParallelConv2D`. +2. Builds on the existing support for heterogeneous `Target`s to represent the menu of available toolchains to use + during search. In particular, we want to allow users to blend `on_device` annotations (to express preferences for + which devices should execute which sub-graphs) with Collage (to find the best partitions respecting those device + preferences). +3. Uses the existing convention for `"Primitive"`, `"Composite"` and `"Compiler"` attributes on Relay `Function`s to + encode partitioning choices. +4. Does not treat library integrations (eg for `CuDnn`) differently from toolchain integrations (eg for `TensorRT`). + See Appendix B for a sketch of the issues. +5. Supports all of Relay. +6. Is implemented almost entirely in C++. + +However: + +6. We have only re-implemented the 'op-level' dynamic-programming based search strategy from the paper. Though the + paper reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future + work. + +## Appendix B: Easier Library Integration -### Robust candidate kernel latency measurement +TVM has two very different ways to make external library implementations available for use as (or in) kernels: +The pattern-based BYOC approach and the TVM `te.extern` approach. + +The pattern-based approach allows library implementations to match with more than one Relay operator, such as for +biased convolution with an activation function. For example, for +[DNNL](https://oneapi-src.github.io/oneDNN/v1.3/index.html) the global pattern table is extended +in `python/tvm/relay/op/contrib/dnnl.py`, and the pattern labels encode the intended corresponding DNNL functions. The +user is responsible for partitioning using the usual `MergeComposite`/`AnnotateTarget`/`PartitionGraph` +sequence (surprisingly there's no `partition_for_dnnl` convenience function). The `relay.ext.dnnl` BYOC function +in `src/relay/backend/contrib/dnnl/codegen.cc` looks for calls to `"Composite"` functions in the overall `"Primitive"` +function, and dispatches based on the `"Composite"` label. C code is emitted to target the DNNL library, and the +standard C compiler helper is invoked to produce a `runtime::Module`. + +Note that it is not possible for a TVM-generated kernel to call a library function integrated this way. In effect every +library function must go into a library-specific kernel (though kernels may group calls to multiple library function). + +The `te.extern` approach only allows library implementations which are 1:1 with Relay operators. However the library may +be used as part of a larger TVM-generated kernel, and the usual TVM tuning machinery may choose to use the library based +on overall kernel performance measured during TVM tuning. For example, `batch_matmul` can be implemented using +[CuBLAS](https://developer.nvidia.com/cublas) via the strategy `batch_matmul` in `python/tvm/contrib/cublas.py`, +which is made available to the operator's `OpStrategy` using `batch_matmul_stategy_cuda` in +`python/tvm/relay/op/strategy/cuda.py` when `cublas` appears in the `Target`s `libs` attribute. That strategy simply +calls the `PackedFunc` registered as `tvm.contrib.cublas.batch_matmul` and implemented in +`src/runtime/contrib/cublas/cublas.cc` as part of the TVM runtime. + +The `te.extern` approach also supports integrating 'micro-kernels' which may be invoked as part of the TVM schedule +for some larger Relay operator. + +Collage as presented can work with either approach. For the pattern-based BYOC approach Collage doesn't need to know +what's going on under the BYOC integration hood, it only needs to see a `Target` with the appropriate +`compiler` attribute. For the `te.extern` approach Collage similarly doesn't need to know that the TVM partition +may result in a kernel who's schedule includes a call to the linked library provided the `Target` has the appropriate +`libs` attribute. + +However, we'd to make library integration with Collage as seamless as possible since we expect it to be the common +case. The requirements are roughly: +- Support library functions which match sub-graphs as well as single Relay operators. +- Allow library calls from within TVM-generated kernels. +- Avoid the boilerplate needed for full BYOC integrations, but retain the familiar BYOC pattern-based mechanism. +- Express the choice of external library in the same way we express other partitioning choices. + +One possibility is: +- Like the `te.extern` approach, libraries can be made available to the TVM runtime via registered `PackedFunc`s. +- Like the pattern-based BYOC approach, labelled patterns can be supplied which indicate how Relay operators could + be mapped to registered `PackedFunc`s. +- Like the BYOC custom lowering approach, a distinguished compiler name controls when the library is available + and causes lowering to go via a different path. +- But unlike the BYOC custom lowering approach, the rewrite to an external library call is made available in TE + or TIR form so that it can be incorporated into larger TVM kernels. + +We'll follow up on this separately, but mention it here since it motivates why we've tried to handle "Composite" +patterns fairly generally. + +## Appendix C: When to run Collage? + +The current TVM convention is for BYOC integrations to supply a `partition_for_` function which can +be called by the user on the original input model, ie before **any** Relay passes are run. + +Many `partition_for_` functions run their own 'preamble' passes before the standard +`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes. The preamble passes are sometimes +just generic Relay passes such as `FoldConstant`. But some partitioning functions impose specific global rewrites, +such as for layout. All the BYOC op patterns and op predicates are thus written expecting the Relay model in 'vanilla' +form with only those preamble passes applied. + +There's no reason to expect the preamble passes are compositional in any sensible way between different BYOC +integrations. + +Some BYOC integrations also supply additional passes which are expected to be run after partitioning and lowering, +for example to finish tuning or compilation. + +The standard Relay pass prefix includes many passes which are either target dependent (for example to +'legalize' quantized version of ops depending on the intended target), or which prepare the model for Relay fusion +and subsequent lowering. These passes are all run before `FuseOps`. Those passes are not universally applicable to +all BYOC integrations, and BYOC patterns are not guaranteed to be invariant over them. + +Finally, Relay's default `FuseOps` is currently hard-coded to greedily find the largest possible kernels using fixed +`OpPatternKind` based rules. Those rules are intended to predict exactly what TVM's scheduling can support. There's +strong pressure to bring both customization (eg target-dependent restrictions, custom horizontal fusion, custom vertical +fusion) and search to `FuseOps`. That all looks so similar to partitioning that it's tempting to simply collapse +TVM kernal search with Collage-style partition search. (And indeed, this is exactly what we tried in this RFC's first +draft). + +This puts us in a bit of a pickle since there's no obvious point in the compilation flow to insert the Collage search: + +1. We could run before any Relay passes at all, just as `partition_for_` functions are run today. + However there's no opportunity to apply any BYOC preamble passes which may be needed before patterns are used. +2. We could run just after the BYOC preamble passes. However that's prematurely committing to a particular BYOC + integration, and there's no way to detect when two BYOC integrations have incompatible preambles. +3. We could run just before (or instead of) `FuseOps` to bring search and customization to TVM fusion. However, + by that stage too many TVM-specific optimizations have been applied for the BYOC integrations to work. + +Our compromise is to i) run Collage at the very beginning of compilation (ie option 1), ii) require the user +manually apply global passes which may assist particular BYOC integrations (such as to choose a particularly favorable +layout), and iii) leave `FuseOps` unchanged. + +In more detail, here's a taxonomy of pass instances and how we can handle them in Collage: + +- **BYOC global** (eg `ConvertLayout`): These passes are currently run in the preamble of some of the + `partition_for_` functions to apply a global rewrite to improve efficiency for the intended target. + - Under Collage, these passes should be made available as a new `optimize_for_` function. The user + (or some top-level search outside of TVM) can apply this function in the same way they currently apply + `partition_for_`. + - Ideally this would also be a well-known UMA extension point. +- **BYOC partitioning** (`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` or a subset + thereof): These passes are currently run after the premable of the `partition_for_` function to + effect the desired partitioning and composite function labelling. + - Under Collage, these passes are subsumed by `CollagePartitioner`. + - They will also be called automatically by the UMA 'partitioner'. +- **BYOC lowering** (eg `Function->runtime::Module` function registered as `relay.ext.`). These passes + invoke the BYOC-specific compilation toolchain. + - Under Collage, the standard `TELower` pass will continue to invoke these functions depending on partitioning + annotations. Collage will also need to support the other per-target compilation overrides. +- **BYOC post-lowering** (eg `tune_cutlass_kernels`): These follow-on passes are supplied by some BYOC integrations + to further prepare the `runtime::Module` after lowering. + - Under Collage, these passes need to be folded back into the generic BYOC lowering extension point. +- **Safe global** (eg `FoldConstant`): These passes are run within the standard Relay pass prefix, but may also be + included in the BYOC preamble. However the pass is universally applicable to all BYOC and TVM toolchains. + - Under Collage this 'safe' prefix of passes can be run before `CollagePartitioner`. If any BYOC + predicates/patterns are not invariant to these safe passes then we'll need to generalize them. Note that + currently this pass set is empty. +- **Target specific** (eg `qnn::transform::Legalize`): These passes are also within the standard Relay pass prefix. + They apply per-operator or other rewrites which may be target-dependent. Clearly the target must already be known. + Technically they should be run after `PlanDevices` to support heterogeneous execution this is not currently the case + (and a few are disabled in the heterogeneous case). + - Under Collage these passes are run after `PlanDevices` (which may use `on_device` annotations to enforce some + target constraints) and `CollagePartitioner` (which will choose targets for all partitions subject to any existing + constraints). But they are only run on non-BYOC partitions, ie on everything other than `"Primitive"` + functions with a `"Compiler"` attribute. +- **Lowering specific** (eg `CanonicalizeOps`): These passes apply optimizations preparing for `FuseOps` and + subsequent TVM lowering. They are also within the standard Relay pass prefix. + - Under Collage, same as for the target specific passes above. + +## Appendix D: TODO items in the 'v2' prototype before proceeding + +- Implement the penalty for transitioning execution between partitions. +- Bring in `cudnn` and `cublas` to support measurement (ideally as Appendix B, but probably as heavyweight BYOC + integration pending better support). +- Implement TVM-tuning during Collage search. +- Cross-check measurements against some of the 'v1' models. +- Bring up on `GPT2` and other 'larger' models. +- Measure additive error. +- Measure apparent loss with `partition_for_tensorrt`. +- Explore `float16` performance mixing `CUTLASS` and `TensorRT`. +- Find model+target combination that shows compelling speedup from mixing w.r.t. all other options, including stand + alone `TensorRT`. +- If needed, implement 'lookahead' from the current search state to find the 'next' dataflow node(s) which have + candidates crossing multiple `PartitionSpec`s. That defines a sub-graph. There's no need to search over all possible + candidates within that sub-graph since almost certainly the maximal candidates will be best. Somehow prune the + candidates to implement that. +- If needed, build indexes in `CombinePartitionRule` to avoid O(n^2) iteration over candidates. + +## Appendix E: Robust candidate kernel latency measurement Collage requires an implementation of a `CostEstimator`: @@ -753,80 +852,31 @@ Collage requires an implementation of a `CostEstimator`: class CostEstimator { public: /*! - * \brief Return the estimated cost (possibly after many many minutes of training time) of - * running function using target. + * \brief Returns the estimated cost (possibly after many many minutes of training time) of + * running "main" in mod using target, which represents a possible partitioning of some overall + * Relay expression. */ - virtual Cost Estimate(const Function& function, const Target& target) const; + virtual Cost Estimate(const IRModule& mod, const Target& target) const; } ``` The 'v2' prototype has implemented this with an in-memory cache and a small Python driver which defers to TVM's `tvm.runtime.vm.VirtualMachine`s `benchmark` helper. The following needs to be designed and implemented: -- Compilation should be in units of `IRModule` rather than `Function` so that, in the future, additional global - definitions (such as for weights) can be conveyed to the toolchain. - The recent MetaSchedule work has provided `BuilderInput` (`include/tvm/meta_schedule/builder.h`), `RunnerInput` (`include/tvm/meta_schedule/runner.h`) and `Database` (`include/tvm/meta_schedule/database.h`) interfaces. The latter is for `TuningRecord`s of `Workload`s. It looks like these interfaces can support the - measurement of Collage `CandidateKernel`s with minor changes. -- (Internal to OctoML) We need an implementation connecting to the internal OctoML kernel tuning workflow and production - cache. Ideally this would be the same implementation as for the MetaSchedule system. + measurement of Collage `CandidatePartitions`s with no or minor changes. - Collage converts measured 50th %ile latencies to costs in seconds. We may need to consider taking a slightly higher %ile to be more robust against variance on small kernels. We need to validate the estimated variance reflects true variance. - For TVM-native targets, we would like the `Estimate` call to perform any TVM tuning required for a novel candidate kernel. +- Collage needs an estimate of the cost of transitioning between partitions (or kernels). Ideally that estimate would + be based on measurement rather than hard coded. -### Easier Library Integration - -TVM has two very different ways to make external library implementations available for use by kernels: The pattern-based -BYOC approach and the TVM `te.extern` approach. - -The pattern-based approach allows library implementations to match with more than one Relay operator, such as for biased -convolution with an activation function. For example, for -[DNNL](https://oneapi-src.github.io/oneDNN/v1.3/index.html) the global pattern table is extended -in `python/tvm/relay/op/contrib/dnnl.py`, and the pattern labels indicate the intended corresponding DNNL functions. The -user is responsible for partitioning using the usual `MergeComposite`/`AnnotateTarget`/`PartitionGraph` -sequence. The `relay.ext.dnnl` BYOC function in `src/relay/backend/contrib/dnnl/codegen.cc` looks for calls to -`"Composite"` functions in the overall `"Primitive"` function, and dispatches based on the `"Composite"` label. C code -is emitted to target the DNNL library, and the standard C compiler helper is invoked to produce a -`runtime::Module`. - -Note that it is not possible for a TVM-generated kernel to call a library function integrated this way. In effect every -library function must go into a library-specific kernel (though kernels may group calls to multiple library function). - -The `te.extern` approach only allows library implementations which are 1:1 with Relay operators. However the library may -be used as part of a larger TVM-generated kernel, and the usual TVM tuning machinery may choose to use the library based -on overall kernel performance measured during TVM tuning. For example, `batch_matmul` -can be implemented using [CuBLAS](https://developer.nvidia.com/cublas) via the strategy `batch_matmul` in -`python/tvm/contrib/cublas.py`, which is made available to the operator's `OpStrategy` using -`batch_matmul_stategy_cuda` in `python/tvm/relay/op/strategy/cuda.py` when `cublas` appears in the `Target`s `libs` -attribute. That strategy simply calls the `PackedFunc` registered as `tvm.contrib.cublas.batch_matmul` and implemented -in `src/runtime/contrib/cublas/cublas.cc` as part of the TVM runtime. - -Collage as presented can work with either approach. For the pattern-based BYOC approach Collage doesn't need to know -what's going on under the BYOC integration hood, it only needs to see a `Target` with the appropriate -`compiler` attribute. For the `te.extern` approach Collage can choose a candidate TVM sub-graph, then rely on TVM tuning -to redirect some operators to their library implementations should the `Target` have the appropritae `libs` -attribute. - -However, better would be something which: - -- Supports the many-to-one mapping of the pattern-based approach since it is so common in library implementations. -- Always allows calls to extern functions from within TVM-generated kernels. -- Requires less boilerplate than the pattern-based approach, and less ceremony than the `te.extern` approach. -Our strawman: - -- Allow calls to `"Composite"` Functions to be transliterated to extern calls in the normal TVM lowering flow, where - the `"Composite"` attribute gives us the 'external function label'. -- The transliteration uses a global TVM registry of external function labels. Each entry describes how to generate a - library shim and how to emit a `tir.call_packed' to that shim. -- The usual Collage fusion rules can be used to include labelled sub-graphs with the appropriate external function - labels as alternatives. Those sub-graphs are ultimately combined into candidate kernels. Collage will then naturally - search between candidates with different choices of native vs library implementations. - -### Robust BYOC integrations for targets of interest +## Appendix F: Robust BYOC integrations for targets of interest Overall any BYOC toolchain which could be supported by Collage needs to be brought to a high standard: @@ -839,109 +889,37 @@ Overall any BYOC toolchain which could be supported by Collage needs to be broug - The translation scheme should give the BYOC toolchain the best chance to do well. In particular, if Collage reports toolchain X 'is better' than toolchain Y for a candidate sub-graph we want to have confidence that's not just because toolchain Y has been hobbled by a poor translation, API misuse, or other 'holding it wrong' issue. -- Where feasible, partitioning for the BYOC toolchain (not using Collage) should not be worse than using the toolchain - directly. +- Where feasible, using `partition_for_` (ie using TVM but not Collage) should not be worse than using + the toolchain directly (ie not using TVM at all). Our current focus is on TensorRT, CUTLASS, CuDnn and CuBlas. -### Visualization +## Appendix G: Visualization A [netron](https://netron.app/) style visualization for Relay which clearly shows the partitioning and cost for all the kernels would be very valuable. The paper prototype produces such a visualization but we've lost that functionality in the transition to 'v2'. -## Highlights from the 'v1' prototype - -The results of the preprint were derived in a [branch](https://github.com/cmu-catalyst/collage) from -[TVM](https://github.com/apache/tvm) at `461d06eb5cfc7954f1983779acd05c47cea269f1`. We ported/rebased that code onto -main, and refer to it as the -['v1' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-port). -The 'v1' prototype has five main parts: - -- A - new [backend](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/include/tvm/ir/expr.h#L208) - field on every Relay `Expr` to capture the pattern name and backend name chosen by Collage to force compilation to - match its choices. -- -An [intercept](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1392) -in `fuse_ops.cc` which redirects to the main Collage fuser/searcher before TVM’s fusion rules kick in. - -- The main - fuser/searcher [implementation](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/comp_graph_optimizer.py#L221) - (for the simpler DP algorithm). This implementation: - - Uses both Relay `Pattern` s and it’s own path-based fusion algorithm to find candidate sub-graphs. - - Uses the DP algorithm to find the best assignment of fused sub-graphs and targets to cover the whole Relay graph. - - Applies the assignment to the IRModule using the new `backend` field - - The evolutionary search algorithm runs after the above and attempts to replace ‘op’ kernels (use a library) with - ‘graph’ kernels (if there’s a unique graph backend). -- An - intercept ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/transforms/fuse_ops.cc#L1402) - and - [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/_optimizer.py#L48)) - in `fuse_ops.cc` to actually effect the fusion for BYOC backends depending on the new `backend` field -- An - intercept ([here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/src/relay/backend/te_compiler_cache.cc#L284) - and - [here](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/backend/collage_strategies.py#L18)) - in `te_compiler.cc` to take over the selection of `OpStrategy` based on the `backend` field. +## Appendix H: FAQ -Note that the 'v1' prototype only supports `IRModules` with a single `"main"` whose body is in the ‘pure dataflow’ Relay -subset. Ie only calls, tuples, tuple projections, function variables and constants are supported. - -## Differences between the Paper's prototype and this Design - -In comparison to the 'v1' prototype, this design: - -- Avoids the need to add any new 'Collage specific' fusion patterns and predicates. We want to make sure Collage can - work even for out-of-tree BYOC toolchains (modulo some of the BYOC API changes we discuss below). -- Builds on the existing support for heterogeneous `Target`s to represent the menu of available toolchains to use during - search. In particular, we want to allow users to blend `on_device` annotations (to express preferences for which - devices should execute which sub-graphs) with Collage (to find the best kernels and toolchains respecting those device - preferences). -- Uses the existing convention for `"Primitive"`, `"Composite"` and `"Compiler"` attributes on Relay `Function`s to - express the assignment of sub-graph to toolchain. -- Implements support for 3rd party libraries (eg cudnn) so as to allow an N-to-1 mapping from Relay operators to library - call (this is not yet implemented in the 'v2' prototype, see below for the sketch). -- Is implemented mostly in C++. - -However: - -- The 'v2' prototype only implements the 'op-level' dynamic-programming based search strategy from the paper. Though the - paper reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future work. - -## TODO in the 'v2' prototype - -- Can me move `CollageFuseOps` earlier in the pipeline? Are there passes in `partiton_for_x` preambles which are always - safe to run in the standard Relay flow (eg inline constants). -- Dig into quantization. -- Implement extern-for-TVM support and bring in `cudnn` and `cublas`. -- Cross-check against one of the 'v1' models. -- Bring up on `GPT2`. -- Explore `float16` performance mixing `CUTLASS` and `TensorRT`. -- Implement TVM-tuning during Collage search. -- Connect estimator to production tuner & cache. -- Estimator works on `IRModule` not `Function`. Resolve `params` binding question. -- Find model+target combination that shows compelling speedup from mixing w.r.t. all other options, including stand - alone `TensorRT`. -- Implement Target refinement so that device planning can be used to constrain the available Collage targets to consider - for arbitrary sub-graphs. Allow multiple targets per `FusionSpec` so that we don't waste time finding the same - candidates for different TVM targets. -- 'Lookahead' from the current search state to find the 'next' dataflow node(s) which have candidates crossing multiple - `FusionSpec`s. That defines a sub-graph. There's no need to search over all possible candidates within that sub-graph - since almost certainly the maximal candidates will be best. Somehow prune the candidates to implement that. -- Cleanup after search to merge adjacent kernels for the same target when supported by toolchain. -- How much of the existing `DFPattern` machinery should be refactored to go via `SubGraph`? -- Post fusion passes introduce new Relay primitives which then need to be fused and lowered, so `FuseOps` still in pass - list. Consider replacing with `CollageFuseOps` in lightweight mode? Need to avoid all search when toolchain is already - uniquely determined. -- `Target`s can have a `"fusion_spec"` attribute to directly control fusion. -- Indexing in `CombineByKindFusionRule` to avoid O(n^2) iteration over candidates. -- Need to be dominator aware in `CombineByPrimitivesFusionRule` or is current naive approach of - using `SubGraph::IsValid` - good enough to eliminate taps? -- What's with the use of `OpPatternKinds` on dataflow edges in `FuseOps` and the special rule relabelling - `kBroadcast` as `kElemwise` if input/output shapes match? Need to find examples. -- Horizontal/Vertical prims for `CombineByKindFusionRule` to finally cover those uses. Check we subsume - `Combine` \ No newline at end of file +- **Are you deprecating `FuseOps`?** No. `FuseOps` will be run along with all the other Relay passes on the + TVM partitions (ie all Relay expressions not partitioned onto a BYOC backend). +- **Are you deprecating the BYOC `partition_for_` methods?** No. Collage does not yet have a way to handle + any global passes invoked before partitioning in those functions. +- **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores + partitionings, and cannot currently explore rewrites. Though Collage could allow sub-graphs to be rewritten as + part of a partitioning choice (eg to insert `device_copy` nodes on inputs and outputs), there's little utility to + doing so since Collage won't be able to measure the effect of those rewrites on the overall model latency after + further downstream passes (eg to collapse unnecessary `device_copy` nodes). These sorts of global optimization + problems can be tackled by additional analysis passes before `CollagePartitioner`. +- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate partitions, and for + the TVM backend the resulting kernels will themselves require schedule tuning. +- **Does this clash with the UMA proposal?** No. Though Collage takes over partitioning, it can still greatly + benefit from the UMA proposal to better organize all the BYOC extension points. Any changes made by the UMA + project should be easy to account for in Collage. +- **Why replace the existing `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/ + `PartitionGraph` passes?** Those passes don't allow us to represent the search space over all partitionings. +- **Why not just build on `DFPattern`s instead of introducing the PartitionRule family?** We actually started in + that direction but found the complexity overwhelming. We believe it's best to keep `DFPattern`s focussed on the + simple and common case of deterministically matching specific sub-expressions. From 26d0828a7a757b3cea05a87aee12778b31e42f12 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Tue, 22 Mar 2022 17:39:02 -0700 Subject: [PATCH 06/11] - Err, three advantages, not four. --- rfcs/xxxx-collage.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 765d8d87..372e2e27 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -56,7 +56,7 @@ UMA equivalent). This is mostly because Collage is inherently a tuning-based sys users who need a stand-alone compiler. But it is also because of challenges with establishing a common pass ordering which will work for both TVM and all BYOC toolchains (see Appendix C for more details). -Collage offers four advantages: +Collage offers three advantages: - **Latency**: Overall model latency may be reduced compared to TVM native, TVM with a single `partition_for_` call, or a non-TVM stand-alone compiler such as TensorRT. From 1640639a5c1d1e754796dc4647ff55cfc9fbd480 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Tue, 22 Mar 2022 17:43:31 -0700 Subject: [PATCH 07/11] - minor clarrification --- rfcs/xxxx-collage.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 372e2e27..8c1378a5 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -905,8 +905,9 @@ the transition to 'v2'. - **Are you deprecating `FuseOps`?** No. `FuseOps` will be run along with all the other Relay passes on the TVM partitions (ie all Relay expressions not partitioned onto a BYOC backend). -- **Are you deprecating the BYOC `partition_for_` methods?** No. Collage does not yet have a way to handle - any global passes invoked before partitioning in those functions. +- **Are you deprecating the BYOC `partition_for_` functions?** No. Collage does not yet have a way to handle + any global passes invoked before partitioning in those functions. Those functions are still the best approach + for users who cannot tolerate long search/tuning times. - **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores partitionings, and cannot currently explore rewrites. Though Collage could allow sub-graphs to be rewritten as part of a partitioning choice (eg to insert `device_copy` nodes on inputs and outputs), there's little utility to From 775c6172d92eeac1dae385b15166de656e93adef Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Wed, 23 Mar 2022 12:42:29 -0700 Subject: [PATCH 08/11] - some more clarifications based on github comments --- rfcs/xxxx-collage.md | 560 ++++++++++++++++++++++--------------------- 1 file changed, 286 insertions(+), 274 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 8c1378a5..fc0db219 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -14,47 +14,48 @@ History: This design doc (with accompanying ['v2' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-sketch)) -shows how to bring tuning to TVM's BYOC partitioning passes. The tuning search explores the choice -of sub-graphs (aka 'partitions') and toolchains (aka 'backends') so as to minimize the expected model -inference latency. Both 'graph style' (eg TensorRT) and 'library style' (eg DNNL) BYOC integrations -are supported. We call the result an 'optimal partitioning'. This new tuning layer complements the tuning -traditionally done by TVM and other toolchains during lowering. It can also complement any global tuning, for -example to explore the choice of layout convention or device assignment. +shows how to bring tuning to TVM's BYOC partitioning passes. The tuning search explores the choice of sub-graphs (aka ' +partitions') and toolchains (aka 'backends') so as to minimize the expected model inference latency. Both 'graph +style' (eg TensorRT) and 'library style' (eg DNNL) BYOC integrations are supported. We call the result an 'optimal +partitioning'. This new tuning layer complements the tuning traditionally done by TVM and other toolchains during +lowering. It can also complement any global tuning, for example to explore the choice of layout convention or device +assignment. The approach is based on the [preprint](https://arxiv.org/pdf/2111.00655.pdf): > *Collage: Automated Integration of Deep Learning Backends* > Byungsoo Jeon, Sunghyun Park, Peiyuan Liao, Sheng Xu, Tianqi Chen, Zhihao Jia -(See Appendix A for a comparison of this proposal and the paper's implementation. See Appendix D for -TODO items in the 'v2' prototype.) +(See Appendix A for a comparison of this proposal and the paper's implementation. See Appendix D for TODO items in the ' +v2' prototype.) This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to partitioning: - Greedy: Currently only the largest possible supported sub-graphs are used for partitions, irrespective of their - execution time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller + execution time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller sub-graphs to yield better overall latency than one large sub-graph if they mix toolchains. - Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding - `partition_for_` function before the main TVM compilation flow begins. With Collage the choice of - toolchain can be automated based on measured latency. Collage will also explore mixing and matching between - multiple BYOC toolchains as well as TVM's native backend. + `partition_for_` function before the main TVM compilation flow begins. With Collage the choice of toolchain + can be automated based on measured latency. Collage will also explore mixing and matching between multiple BYOC + toolchains as well as TVM's native backend. When Collage is enabled it subsumes the existing `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/ `PartitionGraph` passes embedded within each `partition_for_` function with a single new `CollagePartitioner` pass. The pass is guided by the list of available `Target`s and three existing sources: + 1. The `"TOpPattern"` attributes provided for every Relay operator and used by TVM's built-in `FuseOps`. 2. The BYOC `"target."` operator predicates provided for some operator/toolchain pairs by 'operator-based' BYOC integrations. 3. The BYOC operator pattern/predicates (usually) registered in the pattern table by 'pattern-based' BYOC integrations. -Only some boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage (and we will -make these changes either as part of or in coordination with the UMA project). However Collage may require more -robustness from the BYOC integrations, see Appendix F. +Only some boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage (and we will make +these changes either as part of or in coordination with the UMA project). However Collage may require more robustness +from the BYOC integrations, see Appendix F. Note however that we are **not** proposing to deprecate the existing `partition_for_` operations (or their -UMA equivalent). This is mostly because Collage is inherently a tuning-based system which is not practical for -users who need a stand-alone compiler. But it is also because of challenges with establishing a common pass -ordering which will work for both TVM and all BYOC toolchains (see Appendix C for more details). +UMA equivalent). This is mostly because Collage is inherently a tuning-based system which is not practical for users who +need a stand-alone compiler. But it is also because of challenges with establishing a common pass ordering which will +work for both TVM and all BYOC toolchains (see Appendix C for more details). Collage offers three advantages: @@ -66,7 +67,7 @@ Collage offers three advantages: machinery is also reusable for the very similar problem of choosing TVM fusion kernels, which we'll tackle in the future). -See Appendix H for some frequently asked questions. +See Appendix H for some frequently asked questions. ## Success Metrics @@ -167,8 +168,8 @@ with tvm.transform.PassContext(config={"relay.fallback_device_type": 2, "relay.c (Note that `cudnn` and `cublas` are not yet supported in the 'v2' prototype, see Appendix B.) After the `CollagePartitioner` pass, the intermediate `"main"` global function could resemble the following -(though we've modified this "optimal" partitioning by hand for illustration so don't take it as -representative of actual performance): +(though we've modified this "optimal" partitioning by hand for illustration so don't take it as representative of actual +performance): ``` fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { @@ -236,36 +237,36 @@ Ideally this optimal partitioning would be understandable to the user, see Appen The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with just a few Python helper functions under `python/tvm/relay/collage`. -If the `relay.collage.enable_collage` `PassConfig` attribute is true then a new `CollagePartitioner` pass is -inserted before all other Relay passes. The result of the pass is: -- All Relay sub-graphs in all global functions which are to be handed off to a BYOC toolchain are replaced by - calls to an inline `"Primitive"` function with `"Compiler"` and `"global_symbol"` attributes. -- Relay operators, or groups of operators, which are to be translated to particular library or BYOC-supplied - function are replaced by calls to an inline `"Composite"` function. (This encoding is supported for both - BYOC and external libraries.) +If the `relay.collage.enable_collage` `PassConfig` attribute is true then a new `CollagePartitioner` pass is inserted +before all other Relay passes. The result of the pass is: + +- All Relay sub-graphs in all global functions which are to be handed off to a BYOC toolchain are replaced by calls to + an inline `"Primitive"` function with `"Compiler"` and `"global_symbol"` attributes. +- Relay operators, or groups of operators, which are to be translated to particular library or BYOC-supplied function + are replaced by calls to an inline `"Composite"` function. (This encoding is supported for both BYOC and external + libraries.) -Note that no `"Primitive"` functions denoting TVM kernels are produced -- the existing `FuseOps` pass is still -required. +Note that no `"Primitive"` functions denoting TVM kernels are produced -- the existing `FuseOps` pass is still required. The `CollagePartitioner` pass has four phases: -- **Phase 1**: The available `Target`s are scanned to build a list of rules describing how to find possible - partitions (see `PartitionSpec` and `PartitionRule` below). Depending on the `Target` the rules may incorporate - entries from the BYOC pattern table. (The remaining phases execute on each global function separately.) -- **Phase 2**: A dataflow graph is constructed for the global function (which is just an `IndexedGraph`). - The available rules from phase 1 are evaluated on the dataflow graph to yield a (possibly overlapping) set of - candidate partitions for each target (see `CandidatePartition` below). Each candidate efficiently describes a - sub-graph of the global function's body without the need to construct any new expressions (see `SubGraph` below). +- **Phase 1**: The available `Target`s are scanned to build a list of rules describing how to find possible partitions ( + see `PartitionSpec` and `PartitionRule` below). Depending on the `Target` the rules may incorporate entries from the + BYOC pattern table. (The remaining phases execute on each global function separately.) +- **Phase 2**: A dataflow graph is constructed for the global function (which is just an `IndexedGraph`). The + available rules from phase 1 are evaluated on the dataflow graph to yield a (possibly overlapping) set of candidate + partitions for each target (see `CandidatePartition` below). Each candidate efficiently describes a sub-graph of the + global function's body without the need to construct any new expressions (see `SubGraph` below). - **Phase 3**: A shortest path is found in the following (implicit and lazily constructed) search graph: - - Search Nodes: The set of dataflow nodes which have already been assigned to a candidate partition in all paths - to the node. - - Search Edge X->Y: A candidate partition can be applied to node X to give node Y. The candidate is disjoint - from all dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate - must also include the next yet-to-be-assigned dataflow node in X. - - Edge cost: The estimated latency of the candidate partition, plus a partition transition penalty. Note that - though we need to be able to extract the candidate's sub-graph in order to build a function representing the - candidate, we do not yet need to partition the overall function body expression. - + - Search Nodes: The set of dataflow nodes which have already been assigned to a candidate partition in all paths to + the node. + - Search Edge X->Y: A candidate partition can be applied to node X to give node Y. The candidate is disjoint from + all dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate must also + include the next yet-to-be-assigned dataflow node in X. + - Edge cost: The estimated latency of the candidate partition, plus a partition transition penalty. Note that though + we need to be able to extract the candidate's sub-graph in order to build a function representing the candidate, + we do not yet need to partition the overall function body expression. + Other search algorithms are certainly possible, eg the paper uses an evolutionary search to refine the partitioning found by the dynamic-programming search. We can easily abstract away the search interface to support multiple implementations in the future. @@ -293,60 +294,58 @@ In the following we introduce the new datatypes, then expand on the phases. ### SubGraph -A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary -sub-graph of the overall dataflow graph. This and `PartitionRule` below are the core Collage datatypes. +A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary sub-graph of the +overall dataflow graph. This and `PartitionRule` below are the core Collage datatypes. -Sub-graphs can be used to represent partitions/kernels/composite functions without having to -pay the cost of constructing or rewriting any expressions. We also allow 'extracting' a -function to use for measuring a partition/kernel's latency independently from 'rewriting' -the overall Relay expression since only a tiny subset of candidate partitions will end up being -needed after Collage has completed its search. +Sub-graphs can be used to represent partitions/kernels/composite functions without having to pay the cost of +constructing or rewriting any expressions. We also allow 'extracting' a function to use for measuring a +partition/kernel's latency independently from 'rewriting' the overall Relay expression since only a tiny subset of +candidate partitions will end up being needed after Collage has completed its search. -We expect O(thousands) of sub-graphs to be in flight while processing a given model, so are -mindful of space overhead. +We expect O(thousands) of sub-graphs to be in flight while processing a given model, so are mindful of space overhead. A sub-graph classifies every dataflow node of the overall expression as either 'inside' or -'outside' the sub-graph. Obviously not all such divisions make sense, for example it is not -valid for an inside node to feed into another inside node via outside nodes. We provide an -`IsValid` method to check for validity, and `SubGraphConfig` to control which validity rules -apply (such as maximum depth). +'outside' the sub-graph. Obviously not all such divisions make sense, for example it is not valid for an inside node to +feed into another inside node via outside nodes. We provide an +`IsValid` method to check for validity, and `SubGraphConfig` to control which validity rules apply (such as maximum +depth). -We generally work with the `DataflowGraph` representation of the overall Relay expression -rather than the expression itself. We use the post-dfs visit index to uniquely refer to -expression nodes. +We generally work with the `DataflowGraph` representation of the overall Relay expression rather than the expression +itself. We use the post-dfs visit index to uniquely refer to expression nodes. + +As well as 'inside' and 'outside' we have four other flavors of dataflow nodes, all uniquely determined from the ' +inside' nodes: -As well as 'inside' and 'outside' we have four other flavors of dataflow nodes, all uniquely -determined from the 'inside' nodes: - 'entry' nodes are those inside with at least one dataflow input outside. -- 'exit' nodes are those inside with at least one dataflow output outside, or which - are considered 'external' in the underlying dataflow graph (eg because they represent - the result of the overall function). +- 'exit' nodes are those inside with at least one dataflow output outside, or which are considered 'external' in the + underlying dataflow graph (eg because they represent the result of the overall function). - 'input' nodes are those outside with at least one dataflow output inside. - 'output' nodes are those outside with at least one dataflow input inside. Index sets for these are cached with the sub-graph for performance. -It is valid to have multiple entry nodes (we can bind a parameter for each). It may be valid to -have multiple exit nodes (we can build a tuple of all such). It may be valid to have exit nodes -which also contribute to other inside nodes (ie represent a 'tap' on an intermediate result). - +It is valid to have multiple entry nodes (we can bind a parameter for each). It may be valid to have multiple exit +nodes (we can build a tuple of all such). It may be valid to have exit nodes which also contribute to other inside +nodes (ie represent a 'tap' on an intermediate result). + Sub-graphs are closed under: + - Disjoint union. -- Wrapping by a function with given attributes. This can be used to encode "Composite" functions, - or to represent a candidate kernel within a "Primitive" function. (By combining 'wrapping' with - 'union' we can encode, eg, 'this sub-graph should be placed inside a primitive function which - itself may have calls to composite functions). -- Substitution, which allows a sub-graph w.r.t. one dataflow graph to be transformed to - match some other (typically smaller) dataflow graph. - -Note that the Relay `PatternPartitoner` goes directly from `Expr` to partitioned `Expr` without stopping -at any intermediate representation. It may be worth 'promoting' `SubGraph` out of Collage and into the -standard `DFPattern` suite, we leave that to future work. +- Wrapping by a function with given attributes. This can be used to encode "Composite" functions, or to represent a + candidate kernel within a "Primitive" function. (By combining 'wrapping' with + 'union' we can encode, eg, 'this sub-graph should be placed inside a primitive function which itself may have calls to + composite functions). +- Substitution, which allows a sub-graph w.r.t. one dataflow graph to be transformed to match some other (typically + smaller) dataflow graph. + +Note that the Relay `PatternPartitoner` goes directly from `Expr` to partitioned `Expr` without stopping at any +intermediate representation. It may be worth 'promoting' `SubGraph` out of Collage and into the standard `DFPattern` +suite, we leave that to future work. ### CandidatePartition -A `CandidatePartition` pairs a `SubGraph` with a `Target`. All Collage search and measurement is in terms of -candidate partitions. +A `CandidatePartition` pairs a `SubGraph` with a `Target`. All Collage search and measurement is in terms of candidate +partitions. ### PartitionRule @@ -358,70 +357,62 @@ virtual std::vector AllCandidates(const DataflowGraph& dataf const PartitionSpec& spec) const; ``` -The candidates are allowed to overlap, and ultimately it is the job of the Collage searcher to find a selection -of candidates which covers the whole Relay expression without overlap. +The candidates are allowed to overlap, and ultimately it is the job of the Collage searcher to find a selection of +candidates which covers the whole Relay expression without overlap. -We provide a set of 'base' partition rules which produce candidates from the dataflow graph -directly. We also provide a set of 'combinator' partition rules which can produce new candidates -from the results of an arbitrary sub-rule or sub-rules. By mixing these base and combinator -rules we can express a wide variety of partition strategies and encoding conventions. +We provide a set of 'base' partition rules which produce candidates from the dataflow graph directly. We also provide a +set of 'combinator' partition rules which can produce new candidates from the results of an arbitrary sub-rule or +sub-rules. By mixing these base and combinator rules we can express a wide variety of partition strategies and encoding +conventions. -There may be many thousands of candidates in flight during the Collage search. We take care to -defer constructing or rewriting Relay expressions until absolutely necessary. We only pay for -extracting a function to represent a candidate when we need to measure it's cost. And we only -pay for rewriting the overall Relay expression to commit to a partitioning when the Collage -search has completed. +There may be many thousands of candidates in flight during the Collage search. We take care to defer constructing or +rewriting Relay expressions until absolutely necessary. We only pay for extracting a function to represent a candidate +when we need to measure it's cost. And we only pay for rewriting the overall Relay expression to commit to a +partitioning when the Collage search has completed. The base rules implemented so far: -- `DFPatternPartitionRule`: Given a `DFPattern` and expression predicate, produces a candidate - for every sub-graph matched by the pattern and predicate. Unlike the `PatternRewriter`, - candidates are free to overlap. Used to bring BYOC patterns into the Collage framework. -- `OpPredicatePartitionRule`: Given an attribute name, produces a candidate for every call - to a primitive Relay operator where the operator i) has predicate bound to that attribute - which ii) returns true given the call sub-expression. Generally this will result in a - singleton sub-graph containing only the call, but it may also pull in constant arguments to - the call should they be required. Used to bring BYOC operator predicates into the Collage - framework. -- `OpCallByKindPartitionRule`: Uses the `"TOpPattern"` attribute provided for every Relay - operator to produce a candidate for every call to a 'fusable Relay operator'. Used to - look ahead to how TVM will fuse sub-graphs. + +- `DFPatternPartitionRule`: Given a `DFPattern` and expression predicate, produces a candidate for every sub-graph + matched by the pattern and predicate. Unlike the `PatternRewriter`, candidates are free to overlap. Used to bring BYOC + patterns into the Collage framework. +- `OpPredicatePartitionRule`: Given an attribute name, produces a candidate for every call to a primitive Relay operator + where the operator i) has predicate bound to that attribute which ii) returns true given the call sub-expression. + Generally this will result in a singleton sub-graph containing only the call, but it may also pull in constant + arguments to the call should they be required. Used to bring BYOC operator predicates into the Collage framework. +- `OpCallByKindPartitionRule`: Uses the `"TOpPattern"` attribute provided for every Relay operator to produce a + candidate for every call to a 'fusable Relay operator'. Used to look ahead to how TVM will fuse sub-graphs. The combinator rules implemented so far: -- `CompositePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped - by a `"Composite"` function. The `"Composite"` name is taken from the rule name. Used to indicate - Relay operators (or groups of Relay operators) should be mapped to target-specific operators, - both for BYOC and TVM external library integrations. -- `PrimitivePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped - by a `"Primitive"` function, possibly with an additional `"Compiler"` attribute. Used to - delineate a partition (or kernel). -- `UnionPartitionRule`: Simply unions all the candidates from all sub-rules together. Used to - combine individual `DFPatternPartitionRules`. -- `CombinePartitionRule`: Given a sub-rule and a list of 'combiner' rules, finds - all possible ways of combining the sub-rule's candidates to yield even larger candidates. - Note that the sub-rule's candidates may also be directly included in the results. The - 'combiner' rules allow combining by \p OpPatternKinds, combining the arguments to tuples - which themselves are arguments to Relay operator calls, and so on. This rule is intended to - mimic the existing TVM `FuseOps` pass, though: - i) all candidates are found rather than just the largest, ii) the starting set of candidates - can be provided by any other rule, and iii) we rely on `SubGraph` validity checking to weed - out infeasible candidates. -- `OnlyValidPartitionRule`: Given a `SubGraphConfig`, ignores candidates with 'invalid' - sub-graphs. Used to limit the maximum candidate depth, the number of independent outputs, - and whether intermediate 'taps' are allowed. + +- `CompositePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped by a `"Composite"` + function. The `"Composite"` name is taken from the rule name. Used to indicate Relay operators (or groups of Relay + operators) should be mapped to target-specific operators, both for BYOC and TVM external library integrations. +- `PrimitivePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped by a `"Primitive"` + function, possibly with an additional `"Compiler"` attribute. Used to delineate a partition (or kernel). +- `UnionPartitionRule`: Simply unions all the candidates from all sub-rules together. Used to combine + individual `DFPatternPartitionRules`. +- `CombinePartitionRule`: Given a sub-rule and a list of 'combiner' rules, finds all possible ways of combining the + sub-rule's candidates to yield even larger candidates. Note that the sub-rule's candidates may also be directly + included in the results. The + 'combiner' rules allow combining by \p OpPatternKinds, combining the arguments to tuples which themselves are + arguments to Relay operator calls, and so on. This rule is intended to mimic the existing TVM `FuseOps` pass, though: + i) all candidates are found rather than just the largest, ii) the starting set of candidates can be provided by any + other rule, and iii) we rely on `SubGraph` validity checking to weed out infeasible candidates. +- `OnlyValidPartitionRule`: Given a `SubGraphConfig`, ignores candidates with 'invalid' sub-graphs. Used to limit the + maximum candidate depth, the number of independent outputs, and whether intermediate 'taps' are allowed. - `HostPartitionRule`: Produces candidates for all Relay expressions which could be - 'left behind' for execution by the host (eg on the VM). This rule lets us simplify the - overall Collage search algorithm. + 'left behind' for execution by the host (eg on the VM). This rule lets us simplify the overall Collage search + algorithm. -(Though not yet implemented, we'd like to allow a combinator rule which will union candidate -based on their 'anchor' operators. This can be used to implement 'vertical' and 'horizontal' -partition on more primitive candidates. Note that the \p SubGraph machinery supports -multiple-input and -output sub-graphs and their validation, so horizontal partition is easy -implement.) +(Though not yet implemented, we'd like to allow a combinator rule which will union candidate based on their 'anchor' +operators. This can be used to implement 'vertical' and 'horizontal' partition on more primitive candidates. Note that +the \p SubGraph machinery supports multiple-input and -output sub-graphs and their validation, so horizontal partition +is easy implement.) + +Here are some typical ways to combine `PartitionRules` for different partition/fusion strategies: -Here are some typical ways to combine `PartitionRules` for different partition/fusion -strategies: - Classic operator-predicate based BYOC with - `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes: + `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes (eg see `tensorrt.py`): ``` PrimitivePartitionRule OnlyValidPartitionRule @@ -429,7 +420,8 @@ strategies: OpPredicatePartitionRule ``` -- Classic pattern-based BYOC with `MergeComposite`/`AnnotateTarget`/`PartitionGraph` passes: +- Classic pattern-based BYOC with `MergeComposite`/`AnnotateTarget`/`PartitionGraph` passes + (eg see `cutlass.py`)`: ``` PrimitivePartitionRule OnlyValidPartitionRule @@ -442,8 +434,8 @@ strategies: DFPatternPartitionRule(patternn) ``` -- "Consider this library implementation for these sub-expressions", using `DFPatterns` to - pick out which Relay operators are supported: +- "Consider this library implementation for these sub-expressions", using `DFPatterns` to pick out which Relay operators + are supported (a new scheme): ``` OnlyValidPartitionRule CombinePartitionRule (with default TVM combiner rules) @@ -464,7 +456,7 @@ strategies: OpCallByKindPartitionRule ``` -- "Just fuse what I tell you to fuse", using `DFPatterns` to directly select candidates: +- "Just fuse what I tell you to fuse", using `DFPatterns` to directly select candidates (a new scheme): ``` PrimitivePartitionRule OnlyValidPartitionRule @@ -482,8 +474,8 @@ A `PartitionSpec` pairs a a `PartitionRule` with one or more `Target`s. We build on the existing TVM support for heterogeneous devices and targets. The available `Targets` are extracted from the compilation configuration (eg using the existing `CompilationConfig` helper class). Each target is inspected to -decide on how to construct a `PartitionRule`, which will guide Collage in the selection of candidate kernels to explore for -that target. +decide on how to construct a `PartitionRule`, which will guide Collage in the selection of candidate kernels to explore +for that target. (See Appendix G for the requirements which motivated this part of the design.) - If the `Target` has a `"partition_rule"` attribute, use that directly. This would allow users to directly control partitioning/fusion for the target's they care about. @@ -493,8 +485,8 @@ that target. - As above, but if global pattern has no matching entry, assume the `Target` denotes a predicate-based BYOC integration to explore (eg `"tensorrt"`). The `PartitonRule` will look for and evaluate predicates with the `"target."` attribute on all Relay operators. -- Otherwise, assume the `Target` denotes a TVM-native target. The `PartitionRule` mimics `FuseOps`, but now - generalized to explore multiple candidates so as to leave room for possible BYOC candidates. +- Otherwise, assume the `Target` denotes a TVM-native target. The `PartitionRule` mimics `FuseOps`, but now generalized + to explore multiple candidates so as to leave room for possible BYOC candidates. Note that to make this approach work we need to allow for multiple `Target`s with the same `DLDeviceKind`. For the VM simply switching the `target` argument from dictionary to list and removing some redundant Python preprocessing code was @@ -508,8 +500,8 @@ fields. ### Phase 2 -Most of the hard work for this phase is carried by the `AllCandidates` implementations of the `PartitionRule`s. The -main driver simply needs to index all the found `CandidatePartitions` by their minimum 'inside' `PostDfsIndex` +Most of the hard work for this phase is carried by the `AllCandidates` implementations of the `PartitionRule`s. The main +driver simply needs to index all the found `CandidatePartitions` by their minimum 'inside' `PostDfsIndex` for rapid retrieval during the shortest path search. ### Phase 3 @@ -524,19 +516,19 @@ We find it most natural to use Dijkstra to find the optimal partitioning. A `Sea The starting state has no covered nodes. The final state has all nodes covered. -When expanding a state we could choose any `CandidatePartition` collected from phase 2 provided it doesn't overlap -with the state's covered set. However, a search path applying candidates C then D is equivalent to one applying -D then C, so we only consider candidates which intersect the next yet-to-be-covered dataflow node. For each such -candidate we use the `CostEstimator` (with it's assumed cache) to get the candidate's cost, build the successor -state, and 'relax' the successor state in the usual way. (See Appendix E for more details on `CostEstimator`.) +When expanding a state we could choose any `CandidatePartition` collected from phase 2 provided it doesn't overlap with +the state's covered set. However, a search path applying candidates C then D is equivalent to one applying D then C, so +we only consider candidates which intersect the next yet-to-be-covered dataflow node. For each such candidate we use +the `CostEstimator` (with it's assumed cache) to get the candidate's cost, build the successor state, and 'relax' the +successor state in the usual way. (See Appendix E for more details on `CostEstimator`.) The `HostPartitionRule` is used to allow some dataflow nodes to be 'left behind' for execution by the host. ### Phase 4 -The overall Relay expression is partitioned over all the `CandidatePartition`s on the shortest path 'in parallel'. -Since all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful -not to invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. +The overall Relay expression is partitioned over all the `CandidatePartition`s on the shortest path 'in parallel'. Since +all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful not to +invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. ## Known Limitations @@ -564,16 +556,16 @@ not to invalidate yet-to-be-partitioned candidates as we go. Working backwards i `CollagePartitioner`. - **Higher tuning cost**: Obviously Collage needs to estimate the latency of partitions. For TVM this can trigger - turning of schedules for novel kernels, which can require O(thousands) of trials and take O(hours), so we'll be - very dependent on cached tuning logs to amortize this cost between models for the same target. + turning of schedules for novel kernels, which can require O(thousands) of trials and take O(hours), so we'll be very + dependent on cached tuning logs to amortize this cost between models for the same target. - **Task extraction vs Tuning**: Traditionally TVM has had three phases: i) Task extraction (find the fused sub-graphs to tune), ii) Tuning (find a good schedule for those sub-graphs), and iii) Compilation (re-compile the model, now retrieving schedules for all the anticipated sub-graphs from the cache.) However the Collage 'v2' prototype collapses all these phases. This lets us lazily explore the implied search graph (nodes = partially rewritten models, edges = selected of sub-graph and toolchain as a candidate partition, cost = estimated sum of partition costs plus transition - penalties), and thus only pay the cost of measuring (and tuning) candidates which could possibly influence the - final partitioning. + penalties), and thus only pay the cost of measuring (and tuning) candidates which could possibly influence the final + partitioning. - **No non-local optimization**: Though Collage can explore the choice of sub-graph and toolchain, it cannot explore any choices which require the arguments and/or result of the sub-graph to be rewritten, or the overall `IRModule` to be @@ -583,22 +575,22 @@ not to invalidate yet-to-be-partitioned candidates as we go. Working backwards i - Choice of device on which to host the kernel (ditto), - Choice of quantization scheme, - To support this efficiently we'd need to abandon the simple-minded but fast `SubGraph` representation we describe - here in favor of something like an EGraph representation, which seems like a very large change for TVM. + To support this efficiently we'd need to abandon the simple-minded but fast `SubGraph` representation we describe here + in favor of something like an EGraph representation, which seems like a very large change for TVM. - **Dependency management**: Currently BYOC integrations tend to assume they are the only non-TVM toolchain in use. So it's possible two toolchains introduce runtime dependencies which can't be satisfied. Collage has no notion of dependencies or incompatibilities and may attemt to mix candidate kernels we can't support in prod. It's also possible for two BYOC integrations to have incompatible runtimes. -- **Additive cost assumption**: Collage as per this design assumes the cost of running candidate partitions is - additive, plus a small transition penalty. However cache effects can dominate measured latency, particularly for +- **Additive cost assumption**: Collage as per this design assumes the cost of running candidate partitions is additive, + plus a small transition penalty. However cache effects can dominate measured latency, particularly for 'lightweight' kernels. Thus there may be a **additive error** in the final result: > additive_error = measured_latency(collage_partitioning) - sum_{partition} (estimated_latency(partition) + penalty) - The evolutionary search explored by the paper can help here since it uses measured end-to-end model latency as - its cost function, but we're deferring that to future work. + The evolutionary search explored by the paper can help here since it uses measured end-to-end model latency as its + cost function, but we're deferring that to future work. - **Limited search space**: Naively exploring all sub-graphs is O(n!), so we need to constrain the search. The easiest approach is just to limit candidates to sub-graphs of just a few operators. This can mean significantly faster @@ -647,7 +639,7 @@ The 'v1' prototype has nine main parts: 3. The main fuser/searcher [implementation](https://github.com/mbs-octoml/mbs-tvm/blob/52d8780e879a9115b8a93e505bcd3a6c2646c61f/python/collage/optimizer/comp_graph_optimizer.py#L221) (for the simpler DP algorithm). This implementation: -4. Uses both Relay `Pattern` s and its own path-based fusion algorithm to find candidate sub-graphs. +4. Uses both Relay `Pattern` s and its own path-based fusion algorithm to find candidate sub-graphs. 5. Uses the DP algorithm to find the best assignment of fused sub-graphs and backends to cover the whole Relay graph. 6. Applies the resulting assignment to the `IRModule` using the new `backend` field on every expression. 7. An evolutionary search algorithm may optionally run after the above, and will attempt to replace ‘op’ kernels @@ -680,24 +672,23 @@ In comparison to the 'v1' prototype, this design: preferences). 3. Uses the existing convention for `"Primitive"`, `"Composite"` and `"Compiler"` attributes on Relay `Function`s to encode partitioning choices. -4. Does not treat library integrations (eg for `CuDnn`) differently from toolchain integrations (eg for `TensorRT`). - See Appendix B for a sketch of the issues. +4. Does not treat library integrations (eg for `CuDnn`) differently from toolchain integrations (eg for `TensorRT`). See + Appendix B for a sketch of the issues. 5. Supports all of Relay. 6. Is implemented almost entirely in C++. However: -6. We have only re-implemented the 'op-level' dynamic-programming based search strategy from the paper. Though the - paper reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future - work. +6. We have only re-implemented the 'op-level' dynamic-programming based search strategy from the paper. Though the paper + reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future work. ## Appendix B: Easier Library Integration TVM has two very different ways to make external library implementations available for use as (or in) kernels: The pattern-based BYOC approach and the TVM `te.extern` approach. -The pattern-based approach allows library implementations to match with more than one Relay operator, such as for -biased convolution with an activation function. For example, for +The pattern-based approach allows library implementations to match with more than one Relay operator, such as for biased +convolution with an activation function. For example, for [DNNL](https://oneapi-src.github.io/oneDNN/v1.3/index.html) the global pattern table is extended in `python/tvm/relay/op/contrib/dnnl.py`, and the pattern labels encode the intended corresponding DNNL functions. The user is responsible for partitioning using the usual `MergeComposite`/`AnnotateTarget`/`PartitionGraph` @@ -712,118 +703,121 @@ library function must go into a library-specific kernel (though kernels may grou The `te.extern` approach only allows library implementations which are 1:1 with Relay operators. However the library may be used as part of a larger TVM-generated kernel, and the usual TVM tuning machinery may choose to use the library based on overall kernel performance measured during TVM tuning. For example, `batch_matmul` can be implemented using -[CuBLAS](https://developer.nvidia.com/cublas) via the strategy `batch_matmul` in `python/tvm/contrib/cublas.py`, -which is made available to the operator's `OpStrategy` using `batch_matmul_stategy_cuda` in +[CuBLAS](https://developer.nvidia.com/cublas) via the strategy `batch_matmul` in `python/tvm/contrib/cublas.py`, which +is made available to the operator's `OpStrategy` using `batch_matmul_stategy_cuda` in `python/tvm/relay/op/strategy/cuda.py` when `cublas` appears in the `Target`s `libs` attribute. That strategy simply calls the `PackedFunc` registered as `tvm.contrib.cublas.batch_matmul` and implemented in `src/runtime/contrib/cublas/cublas.cc` as part of the TVM runtime. -The `te.extern` approach also supports integrating 'micro-kernels' which may be invoked as part of the TVM schedule -for some larger Relay operator. +The `te.extern` approach also supports integrating 'micro-kernels' which may be invoked as part of the TVM schedule for +some larger Relay operator. Collage as presented can work with either approach. For the pattern-based BYOC approach Collage doesn't need to know what's going on under the BYOC integration hood, it only needs to see a `Target` with the appropriate -`compiler` attribute. For the `te.extern` approach Collage similarly doesn't need to know that the TVM partition -may result in a kernel who's schedule includes a call to the linked library provided the `Target` has the appropriate +`compiler` attribute. For the `te.extern` approach Collage similarly doesn't need to know that the TVM partition may +result in a kernel who's schedule includes a call to the linked library provided the `Target` has the appropriate `libs` attribute. -However, we'd to make library integration with Collage as seamless as possible since we expect it to be the common -case. The requirements are roughly: +However, we'd to make library integration with Collage as seamless as possible since we expect it to be the common case. +The requirements are roughly: + - Support library functions which match sub-graphs as well as single Relay operators. - Allow library calls from within TVM-generated kernels. - Avoid the boilerplate needed for full BYOC integrations, but retain the familiar BYOC pattern-based mechanism. - Express the choice of external library in the same way we express other partitioning choices. One possibility is: + - Like the `te.extern` approach, libraries can be made available to the TVM runtime via registered `PackedFunc`s. -- Like the pattern-based BYOC approach, labelled patterns can be supplied which indicate how Relay operators could - be mapped to registered `PackedFunc`s. -- Like the BYOC custom lowering approach, a distinguished compiler name controls when the library is available - and causes lowering to go via a different path. -- But unlike the BYOC custom lowering approach, the rewrite to an external library call is made available in TE - or TIR form so that it can be incorporated into larger TVM kernels. +- Like the pattern-based BYOC approach, labelled patterns can be supplied which indicate how Relay operators could be + mapped to registered `PackedFunc`s. +- Like the BYOC custom lowering approach, a distinguished compiler name controls when the library is available and + causes lowering to go via a different path. +- But unlike the BYOC custom lowering approach, the rewrite to an external library call is made available in TE or TIR + form so that it can be incorporated into larger TVM kernels. We'll follow up on this separately, but mention it here since it motivates why we've tried to handle "Composite" patterns fairly generally. ## Appendix C: When to run Collage? -The current TVM convention is for BYOC integrations to supply a `partition_for_` function which can -be called by the user on the original input model, ie before **any** Relay passes are run. - -Many `partition_for_` functions run their own 'preamble' passes before the standard -`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes. The preamble passes are sometimes -just generic Relay passes such as `FoldConstant`. But some partitioning functions impose specific global rewrites, -such as for layout. All the BYOC op patterns and op predicates are thus written expecting the Relay model in 'vanilla' -form with only those preamble passes applied. - -There's no reason to expect the preamble passes are compositional in any sensible way between different BYOC -integrations. - -Some BYOC integrations also supply additional passes which are expected to be run after partitioning and lowering, -for example to finish tuning or compilation. - -The standard Relay pass prefix includes many passes which are either target dependent (for example to -'legalize' quantized version of ops depending on the intended target), or which prepare the model for Relay fusion -and subsequent lowering. These passes are all run before `FuseOps`. Those passes are not universally applicable to -all BYOC integrations, and BYOC patterns are not guaranteed to be invariant over them. - -Finally, Relay's default `FuseOps` is currently hard-coded to greedily find the largest possible kernels using fixed -`OpPatternKind` based rules. Those rules are intended to predict exactly what TVM's scheduling can support. There's -strong pressure to bring both customization (eg target-dependent restrictions, custom horizontal fusion, custom vertical -fusion) and search to `FuseOps`. That all looks so similar to partitioning that it's tempting to simply collapse -TVM kernal search with Collage-style partition search. (And indeed, this is exactly what we tried in this RFC's first -draft). - -This puts us in a bit of a pickle since there's no obvious point in the compilation flow to insert the Collage search: - -1. We could run before any Relay passes at all, just as `partition_for_` functions are run today. - However there's no opportunity to apply any BYOC preamble passes which may be needed before patterns are used. +There's a few cross-cutting issues when it comes to when Collage should run in the compilation flow: + +- The current TVM convention is for BYOC integrations to supply a `partition_for_` function which can be + called by the user on the original input model, ie before **any** Relay passes are run. +- Many `partition_for_` functions run their own 'preamble' passes before the standard + `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes. The preamble passes are sometimes + just generic Relay passes such as `FoldConstant`. But some partitioning functions impose specific global rewrites, + such as for layout. All the BYOC op patterns and op predicates are thus written expecting the Relay model in 'vanilla' + form with only those preamble passes applied. +- There's no reason to expect the preamble passes are compositional in any sensible way between different BYOC + integrations. +- Some BYOC integrations also supply additional passes which are expected to be run after partitioning and lowering, for + example to finish tuning or compilation. +- The standard Relay pass prefix includes many passes which are either target dependent (for example to + 'legalize' quantized version of ops depending on the intended target), or which prepare the model for Relay fusion and + subsequent lowering. These passes are all run before `FuseOps`. Those passes are not universally applicable to all + BYOC integrations, and BYOC patterns are not guaranteed to be invariant over them. +- Relay's default `FuseOps` is currently hard-coded to greedily find the largest possible kernels using fixed + `OpPatternKind` based rules. Those rules are intended to predict exactly what TVM's scheduling can support. There's + interest in bringing customization (eg limiting fusion patterns to directly match hardware supported primitives, + supporting custom 'horizontal' and 'vertical' fusion) and search (to reduce the strong coupling of fusion with + lowering) to `FuseOps`, which all looks very similar to customization and search Collage brings to partitioning. +- Finally(!), Collage should obviously explore candidate partitions which both TVM and the BYOC toolchains can do well + on. That encourages large partitions with fusion opportunities. But a naive search over all O(n!) possibilities is + also obviously not feasible. This means Collage should limit its search to candidates which more or less correspond to + the kernels each backend would choose using their own fusion rules. This in turn requires Collage's partitioning rules + to roughly match the backend fusion rules. + +This puts us in a bit of a pickle since there's no obvious single point in the compilation flow for Collage: + +1. We could run before any Relay passes at all, just as `partition_for_` functions are run today. However + there's no opportunity to apply any BYOC preamble passes which may be needed before patterns are used. 2. We could run just after the BYOC preamble passes. However that's prematurely committing to a particular BYOC integration, and there's no way to detect when two BYOC integrations have incompatible preambles. -3. We could run just before (or instead of) `FuseOps` to bring search and customization to TVM fusion. However, - by that stage too many TVM-specific optimizations have been applied for the BYOC integrations to work. +3. We could run instead of `FuseOps` to collapse partitioning with fusion. However, by that stage too many + TVM-specific optimizations have been applied for the BYOC integrations to work. -Our compromise is to i) run Collage at the very beginning of compilation (ie option 1), ii) require the user -manually apply global passes which may assist particular BYOC integrations (such as to choose a particularly favorable -layout), and iii) leave `FuseOps` unchanged. +Our compromise is to i) run Collage at the very beginning of compilation (ie option 1), ii) require the user manually +apply global passes which may assist particular BYOC integrations (such as to choose a particularly favorable layout), +and iii) leave `FuseOps` unchanged. (Note the first draft of the RFC instead chose option 3.) In more detail, here's a taxonomy of pass instances and how we can handle them in Collage: - **BYOC global** (eg `ConvertLayout`): These passes are currently run in the preamble of some of the `partition_for_` functions to apply a global rewrite to improve efficiency for the intended target. - - Under Collage, these passes should be made available as a new `optimize_for_` function. The user - (or some top-level search outside of TVM) can apply this function in the same way they currently apply - `partition_for_`. - - Ideally this would also be a well-known UMA extension point. -- **BYOC partitioning** (`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` or a subset - thereof): These passes are currently run after the premable of the `partition_for_` function to - effect the desired partitioning and composite function labelling. - - Under Collage, these passes are subsumed by `CollagePartitioner`. - - They will also be called automatically by the UMA 'partitioner'. -- **BYOC lowering** (eg `Function->runtime::Module` function registered as `relay.ext.`). These passes - invoke the BYOC-specific compilation toolchain. - - Under Collage, the standard `TELower` pass will continue to invoke these functions depending on partitioning - annotations. Collage will also need to support the other per-target compilation overrides. -- **BYOC post-lowering** (eg `tune_cutlass_kernels`): These follow-on passes are supplied by some BYOC integrations - to further prepare the `runtime::Module` after lowering. - - Under Collage, these passes need to be folded back into the generic BYOC lowering extension point. + - Under Collage, these passes should be made available as a new `optimize_for_` function. The user + (or some top-level search outside of TVM) can apply this function in the same way they currently apply + `partition_for_`. + - Ideally this would also be a well-known UMA extension point. +- **BYOC partitioning** (`MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` or a subset thereof): + These passes are currently run after the premable of the `partition_for_` function to effect the desired + partitioning and composite function labelling. + - Under Collage, these passes are subsumed by `CollagePartitioner`. + - They will also be called automatically by the UMA 'partitioner'. +- **BYOC lowering** (eg `Function->runtime::Module` function registered as `relay.ext.`). These passes invoke + the BYOC-specific compilation toolchain. + - Under Collage, the standard `TELower` pass will continue to invoke these functions depending on partitioning + annotations. Collage will also need to support the other per-target compilation overrides. +- **BYOC post-lowering** (eg `tune_cutlass_kernels`): These follow-on passes are supplied by some BYOC integrations to + further prepare the `runtime::Module` after lowering. + - Under Collage, these passes need to be folded back into the generic BYOC lowering extension point. - **Safe global** (eg `FoldConstant`): These passes are run within the standard Relay pass prefix, but may also be included in the BYOC preamble. However the pass is universally applicable to all BYOC and TVM toolchains. - - Under Collage this 'safe' prefix of passes can be run before `CollagePartitioner`. If any BYOC - predicates/patterns are not invariant to these safe passes then we'll need to generalize them. Note that - currently this pass set is empty. -- **Target specific** (eg `qnn::transform::Legalize`): These passes are also within the standard Relay pass prefix. - They apply per-operator or other rewrites which may be target-dependent. Clearly the target must already be known. + - Under Collage this 'safe' prefix of passes can be run before `CollagePartitioner`. If any BYOC predicates/patterns + are not invariant to these safe passes then we'll need to generalize them. Note that currently this pass set is + empty. +- **Target specific** (eg `qnn::transform::Legalize`): These passes are also within the standard Relay pass prefix. They + apply per-operator or other rewrites which may be target-dependent. Clearly the target must already be known. Technically they should be run after `PlanDevices` to support heterogeneous execution this is not currently the case (and a few are disabled in the heterogeneous case). - - Under Collage these passes are run after `PlanDevices` (which may use `on_device` annotations to enforce some - target constraints) and `CollagePartitioner` (which will choose targets for all partitions subject to any existing - constraints). But they are only run on non-BYOC partitions, ie on everything other than `"Primitive"` - functions with a `"Compiler"` attribute. -- **Lowering specific** (eg `CanonicalizeOps`): These passes apply optimizations preparing for `FuseOps` and - subsequent TVM lowering. They are also within the standard Relay pass prefix. - - Under Collage, same as for the target specific passes above. + - Under Collage these passes are run after `PlanDevices` (which may use `on_device` annotations to enforce some + target constraints) and `CollagePartitioner` (which will choose targets for all partitions subject to any existing + constraints). But they are only run on non-BYOC partitions, ie on everything other than `"Primitive"` + functions with a `"Compiler"` attribute. +- **Lowering specific** (eg `CanonicalizeOps`): These passes apply optimizations preparing for `FuseOps` and subsequent + TVM lowering. They are also within the standard Relay pass prefix. + - Under Collage, same as for the target specific passes above. ## Appendix D: TODO items in the 'v2' prototype before proceeding @@ -843,6 +837,8 @@ In more detail, here's a taxonomy of pass instances and how we can handle them i candidates within that sub-graph since almost certainly the maximal candidates will be best. Somehow prune the candidates to implement that. - If needed, build indexes in `CombinePartitionRule` to avoid O(n^2) iteration over candidates. +- Reconcile with the 'RFC10' style BYOC extension methods -- we should support them all but for simplicity have just + focussed on the traditional "Compiler" annotation. ## Appendix E: Robust candidate kernel latency measurement @@ -872,9 +868,8 @@ TVM's `tvm.runtime.vm.VirtualMachine`s `benchmark` helper. The following needs t variance. - For TVM-native targets, we would like the `Estimate` call to perform any TVM tuning required for a novel candidate kernel. -- Collage needs an estimate of the cost of transitioning between partitions (or kernels). Ideally that estimate would - be based on measurement rather than hard coded. - +- Collage needs an estimate of the cost of transitioning between partitions (or kernels). Ideally that estimate would be + based on measurement rather than hard coded. ## Appendix F: Robust BYOC integrations for targets of interest @@ -889,8 +884,8 @@ Overall any BYOC toolchain which could be supported by Collage needs to be broug - The translation scheme should give the BYOC toolchain the best chance to do well. In particular, if Collage reports toolchain X 'is better' than toolchain Y for a candidate sub-graph we want to have confidence that's not just because toolchain Y has been hobbled by a poor translation, API misuse, or other 'holding it wrong' issue. -- Where feasible, using `partition_for_` (ie using TVM but not Collage) should not be worse than using - the toolchain directly (ie not using TVM at all). +- Where feasible, using `partition_for_` (ie using TVM but not Collage) should not be worse than using the + toolchain directly (ie not using TVM at all). Our current focus is on TensorRT, CUTLASS, CuDnn and CuBlas. @@ -900,27 +895,44 @@ A [netron](https://netron.app/) style visualization for Relay which clearly show kernels would be very valuable. The paper prototype produces such a visualization but we've lost that functionality in the transition to 'v2'. - ## Appendix H: FAQ -- **Are you deprecating `FuseOps`?** No. `FuseOps` will be run along with all the other Relay passes on the - TVM partitions (ie all Relay expressions not partitioned onto a BYOC backend). +- **Are you deprecating `FuseOps`?** No. `FuseOps` will be run along with all the other Relay passes on the TVM + partitions (ie all Relay expressions not partitioned onto a BYOC backend). - **Are you deprecating the BYOC `partition_for_` functions?** No. Collage does not yet have a way to handle - any global passes invoked before partitioning in those functions. Those functions are still the best approach - for users who cannot tolerate long search/tuning times. + any global passes invoked before partitioning in those functions. Those functions are still the best approach for + users who cannot tolerate long search/tuning times. - **Can I use Collage for optimizing layout? Device placement? Quantization strategy?** No. Collage only explores - partitionings, and cannot currently explore rewrites. Though Collage could allow sub-graphs to be rewritten as - part of a partitioning choice (eg to insert `device_copy` nodes on inputs and outputs), there's little utility to - doing so since Collage won't be able to measure the effect of those rewrites on the overall model latency after - further downstream passes (eg to collapse unnecessary `device_copy` nodes). These sorts of global optimization - problems can be tackled by additional analysis passes before `CollagePartitioner`. -- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate partitions, and for - the TVM backend the resulting kernels will themselves require schedule tuning. -- **Does this clash with the UMA proposal?** No. Though Collage takes over partitioning, it can still greatly - benefit from the UMA proposal to better organize all the BYOC extension points. Any changes made by the UMA - project should be easy to account for in Collage. + partitionings, and cannot currently explore rewrites. Though Collage could allow sub-graphs to be rewritten as part of + a partitioning choice (eg to insert `device_copy` nodes on inputs and outputs), there's little utility to doing so + since Collage won't be able to measure the effect of those rewrites on the overall model latency after further + downstream passes (eg to collapse unnecessary `device_copy` nodes). These sorts of global optimization problems can be + tackled by additional analysis passes before `CollagePartitioner`. +- **Won't this increase tuning time?** Yes. Collage will explore significantly more candidate partitions, and for the + TVM backend the resulting kernels will themselves require schedule tuning. +- **Does this clash with the UMA proposal?** No. Though Collage takes over partitioning, it can still greatly benefit + from the UMA proposal to better organize all the BYOC extension points. Any changes made by the UMA project should be + easy to account for in Collage. - **Why replace the existing `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/ `PartitionGraph` passes?** Those passes don't allow us to represent the search space over all partitionings. -- **Why not just build on `DFPattern`s instead of introducing the PartitionRule family?** We actually started in - that direction but found the complexity overwhelming. We believe it's best to keep `DFPattern`s focussed on the - simple and common case of deterministically matching specific sub-expressions. +- **Why not just build on `DFPattern`s instead of introducing the PartitionRule family?** We actually started in that + direction but found the complexity overwhelming. We believe it's best to keep `DFPattern`s focussed on the simple and + common case of deterministically matching specific sub-expressions. +- **Why should partitioning have anything to do with fusion?** For efficiency Collage should only explore candidate + partitions which roughly match kernel boundaries. This means Collage's partitioning rules need to roughly predict + the fusion rules of each backend, TVM included. + +## Appendix G: Representing Collage 'backends' + +The paper introduced an explicit representation for 'backends'. In this design we've chosen to merge this notion +back into the existing `Target` machinery: +- All the backends we know of are dependent on a family of `Target`s. For example, `TensorRT` obviously only applies + to CUDA targets, `DNNL` only applies to CPU targets, and so on. +- So it seems most natural to just extend `TargetKind`s with the ability to specify a particular BYOC toolchain, and + allow the user to supply as many `Target`s as needed to cover all the BYOC toolchains they'd like to include in + the Collage search. +- There's then two subtleties which are easy to handle: + - A `Target` which is specific about it's BYOC toolchain should be considered a refinement of the same `Target` + without any such detail. + - The user may supply multiple `Target`s for the same `DLDeviceType`. There's a few places in device planning where + the `DLDeviceType` to `Target` mapping needs to choose the least-refined `Target`. From 8184b8da3ef158d6820ef3d00d12b240fa0527aa Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Wed, 23 Mar 2022 14:21:04 -0700 Subject: [PATCH 09/11] - expand on PartitionRule --- rfcs/xxxx-collage.md | 151 ++++++++++++++++++++++++++++--------------- 1 file changed, 100 insertions(+), 51 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index fc0db219..3aba5dea 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -358,58 +358,87 @@ virtual std::vector AllCandidates(const DataflowGraph& dataf ``` The candidates are allowed to overlap, and ultimately it is the job of the Collage searcher to find a selection of -candidates which covers the whole Relay expression without overlap. - -We provide a set of 'base' partition rules which produce candidates from the dataflow graph directly. We also provide a -set of 'combinator' partition rules which can produce new candidates from the results of an arbitrary sub-rule or -sub-rules. By mixing these base and combinator rules we can express a wide variety of partition strategies and encoding -conventions. - -There may be many thousands of candidates in flight during the Collage search. We take care to defer constructing or -rewriting Relay expressions until absolutely necessary. We only pay for extracting a function to represent a candidate -when we need to measure it's cost. And we only pay for rewriting the overall Relay expression to commit to a -partitioning when the Collage search has completed. - -The base rules implemented so far: +candidates which cover the whole Relay expression without overlap. There may be many thousands of candidates in flight +during the Collage search. + +We currently have three distinct flavors of partitions: + +- For pattern-based BYOC integrations, individual `DFPattern`s are used to select the `"Composite"` functions to + offload, and those are grouped into a `"Primitive"` Relay function with a `"Compiler"` attribute. +- For operator-based BYOC integrations, per-operator predicates indicate operators to offload, and again those are + grouped into a `"Primitive"` Relay function with a `"Compiler"` attribute. +- For TVM, obviously all of Relay can go into a single partition, however for search efficiency the partitions should + roughly mimic the Relay `FuseOps`. That pass uses the `"TOpPattern"` (of type `OPPatternKind`) attribute on all Relay + operators, and rules for when operators of one kind can be folded into another (typically by moving scalar ops from + elementwise operators into the output position of an earlier operator). This is implemented as a + stand-alone analysis which encodes its result using `"Primitive"` functions. + +Two new flavors are also showing up: + +- For easy external library integration we would like to borrow the `DFPattern`-with-composite-functions approach from + pattern-based BYOC integrations. But we'd like to leave those composite functions outside of any `"Primitive"` + function so that the library calls could end up within larger TVM kernels. +- `FuseOps` is generally considered too inflexible, and we've sought a more flexible way to express target-dependent + fusion rules. + +So in the same way `DFPattern`s provide a small library of 'base' and 'combinator' pattern rules supporting a wide +variety of examples, we seek the same economy and flexibility from `PartitionRule`s. + +An obvious question is whether all partition rules should be expressed with `DFPattern`s, possibly by extending +the `DFPattern` library itself. Indeed, though it does not appear to be used in prod, the `DominatorPattern` is +an attempt to use `DFPattern`s to subsume the existing `FuseOps` machinery. We actually went down this path but +decided to back out: +- Since we are interested in searching over possibly overlapping candidate partitions we'd need the `DFPattern` + machinery to all enumeration over all matching sub-expressions. That would require a rewrite of the + `DFPatternMatcher`. +- Some of the more subtle fusion rules are difficult to express as patterns. +- `DFPattern`s are widely used outside of just partitioning, so any change would need to ensure no efficiency + or cognitive overhead for those common cases. + +That pushed us to the present design, which builds on `DFPatterns`, but introduces new 'base' and 'combinator' +partition rules which can be combined to match the desired partition flavors. The 'base' rules produce candidates +from the dataflow graph directly (eg all sub-graphs matching a given `DFPattern`). The 'combinator' rules +combine the candidates found by one or more sub-rules into a new set of candidates (eg by indicating the +sub-candidates should be wrapped by a `"Composite"` function, or touching sub-candidates should be unioned +together). + +The base rules are: - `DFPatternPartitionRule`: Given a `DFPattern` and expression predicate, produces a candidate for every sub-graph - matched by the pattern and predicate. Unlike the `PatternRewriter`, candidates are free to overlap. Used to bring BYOC - patterns into the Collage framework. -- `OpPredicatePartitionRule`: Given an attribute name, produces a candidate for every call to a primitive Relay operator - where the operator i) has predicate bound to that attribute which ii) returns true given the call sub-expression. - Generally this will result in a singleton sub-graph containing only the call, but it may also pull in constant - arguments to the call should they be required. Used to bring BYOC operator predicates into the Collage framework. + matched by the pattern and predicate. Unlike the `PatternRewriter`, candidates are free to overlap. Mainly used + to bring BYOC patterns into the Collage framework. +- `OpPredicatePartitionRule`: Given an attribute name, produces a candidate for every call to a primitive Relay + operator where the operator i) has predicate bound to that attribute which ii) returns true given the + call sub-expression. Generally this will result in a singleton sub-graph containing only the call, but it may also + pull in constant arguments to the call should they be required. Used to bring BYOC operator predicates into the + Collage framework. - `OpCallByKindPartitionRule`: Uses the `"TOpPattern"` attribute provided for every Relay operator to produce a - candidate for every call to a 'fusable Relay operator'. Used to look ahead to how TVM will fuse sub-graphs. + candidate for every call to a 'fusable Relay operator'. Used to select the operators which `FuseOps` will consider + parts of kernels. -The combinator rules implemented so far: +The combinator rules are: -- `CompositePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped by a `"Composite"` +- `CompositePartitionRule`: Indicates all sub-candidates matched by the sub-rule should be wrapped by a `"Composite"` function. The `"Composite"` name is taken from the rule name. Used to indicate Relay operators (or groups of Relay operators) should be mapped to target-specific operators, both for BYOC and TVM external library integrations. -- `PrimitivePartitionRule`: Indicates all candidates matched by the sub-rule should be wrapped by a `"Primitive"` +- `PrimitivePartitionRule`: Indicates all sub-candidates matched by the sub-rule should be wrapped by a `"Primitive"` function, possibly with an additional `"Compiler"` attribute. Used to delineate a partition (or kernel). -- `UnionPartitionRule`: Simply unions all the candidates from all sub-rules together. Used to combine +- `UnionPartitionRule`: Simply unions all the sub-candidates from all sub-rules together. Used to combine individual `DFPatternPartitionRules`. -- `CombinePartitionRule`: Given a sub-rule and a list of 'combiner' rules, finds all possible ways of combining the - sub-rule's candidates to yield even larger candidates. Note that the sub-rule's candidates may also be directly - included in the results. The - 'combiner' rules allow combining by \p OpPatternKinds, combining the arguments to tuples which themselves are - arguments to Relay operator calls, and so on. This rule is intended to mimic the existing TVM `FuseOps` pass, though: - i) all candidates are found rather than just the largest, ii) the starting set of candidates can be provided by any - other rule, and iii) we rely on `SubGraph` validity checking to weed out infeasible candidates. +- `CombinePartitionRule`: Given a sub-rule and a list of 'combiner' rules (see below), finds all possible ways of + combining the sub-candidates to yield even larger candidates. Note that the sub-candidates may also be directly + included in the results. The 'combiner' rules allow combining by `OpPatternKinds`, combining the arguments to + tuples which themselves are arguments to Relay operator calls, and so on. This rule is intended to mimic the + existing TVM `FuseOps` pass, though: i) all candidates are found rather than just the largest, ii) the starting + set of candidates can be provided by any other rule, and iii) we rely on `SubGraph` validity checking to weed out + infeasible candidates. - `OnlyValidPartitionRule`: Given a `SubGraphConfig`, ignores candidates with 'invalid' sub-graphs. Used to limit the maximum candidate depth, the number of independent outputs, and whether intermediate 'taps' are allowed. - `HostPartitionRule`: Produces candidates for all Relay expressions which could be 'left behind' for execution by the host (eg on the VM). This rule lets us simplify the overall Collage search algorithm. -(Though not yet implemented, we'd like to allow a combinator rule which will union candidate based on their 'anchor' -operators. This can be used to implement 'vertical' and 'horizontal' partition on more primitive candidates. Note that -the \p SubGraph machinery supports multiple-input and -output sub-graphs and their validation, so horizontal partition -is easy implement.) - -Here are some typical ways to combine `PartitionRules` for different partition/fusion strategies: +Here are some typical ways to combine `PartitionRules` for different partition flavors: - Classic operator-predicate based BYOC with `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes (eg see `tensorrt.py`): @@ -434,6 +463,25 @@ Here are some typical ways to combine `PartitionRules` for different partition/f DFPatternPartitionRule(patternn) ``` + The `CompositePartitionRule`/`DFPatternPartitionRule` combination is repeated for each entry in the pattern table for + the BYOC toolchain name, eg: + ``` + CompositePartitionRule( + rule_name="cutlass.conv2d_bias_residual_multiply_relu" + sub_rule=DFPatternPartitionRule( + pattern=CallPatternNode(Op(nn.relu), + [AltPattern(CallPatternNode(Op(multiply), + [CallPatternNode(AltPattern(Op(add) | Op(nn.bias_add)), + [CallPatternNode(Op(nn.conv2d), [*, *]), *]), + *]) | + CallPatternNode(Op(multiply), + [*, + CallPatternNode(AltPattern(Op(add) | Op(nn.bias_add)), + [CallPatternNode(Op(nn.conv2d), [*, *]), *]) + ])) + ]))) + ``` + - "Consider this library implementation for these sub-expressions", using `DFPatterns` to pick out which Relay operators are supported (a new scheme): ``` @@ -775,8 +823,8 @@ This puts us in a bit of a pickle since there's no obvious single point in the c there's no opportunity to apply any BYOC preamble passes which may be needed before patterns are used. 2. We could run just after the BYOC preamble passes. However that's prematurely committing to a particular BYOC integration, and there's no way to detect when two BYOC integrations have incompatible preambles. -3. We could run instead of `FuseOps` to collapse partitioning with fusion. However, by that stage too many - TVM-specific optimizations have been applied for the BYOC integrations to work. +3. We could run instead of `FuseOps` to collapse partitioning with fusion. However, by that stage too many TVM-specific + optimizations have been applied for the BYOC integrations to work. Our compromise is to i) run Collage at the very beginning of compilation (ie option 1), ii) require the user manually apply global passes which may assist particular BYOC integrations (such as to choose a particularly favorable layout), @@ -919,20 +967,21 @@ the transition to 'v2'. direction but found the complexity overwhelming. We believe it's best to keep `DFPattern`s focussed on the simple and common case of deterministically matching specific sub-expressions. - **Why should partitioning have anything to do with fusion?** For efficiency Collage should only explore candidate - partitions which roughly match kernel boundaries. This means Collage's partitioning rules need to roughly predict - the fusion rules of each backend, TVM included. + partitions which roughly match kernel boundaries. This means Collage's partitioning rules need to roughly predict the + fusion rules of each backend, TVM included. ## Appendix G: Representing Collage 'backends' -The paper introduced an explicit representation for 'backends'. In this design we've chosen to merge this notion -back into the existing `Target` machinery: -- All the backends we know of are dependent on a family of `Target`s. For example, `TensorRT` obviously only applies - to CUDA targets, `DNNL` only applies to CPU targets, and so on. +The paper introduced an explicit representation for 'backends'. In this design we've chosen to merge this notion back +into the existing `Target` machinery: + +- All the backends we know of are dependent on a family of `Target`s. For example, `TensorRT` obviously only applies to + CUDA targets, `DNNL` only applies to CPU targets, and so on. - So it seems most natural to just extend `TargetKind`s with the ability to specify a particular BYOC toolchain, and - allow the user to supply as many `Target`s as needed to cover all the BYOC toolchains they'd like to include in - the Collage search. + allow the user to supply as many `Target`s as needed to cover all the BYOC toolchains they'd like to include in the + Collage search. - There's then two subtleties which are easy to handle: - - A `Target` which is specific about it's BYOC toolchain should be considered a refinement of the same `Target` - without any such detail. - - The user may supply multiple `Target`s for the same `DLDeviceType`. There's a few places in device planning where - the `DLDeviceType` to `Target` mapping needs to choose the least-refined `Target`. + - A `Target` which is specific about it's BYOC toolchain should be considered a refinement of the same `Target` + without any such detail. + - The user may supply multiple `Target`s for the same `DLDeviceType`. There's a few places in device planning where + the `DLDeviceType` to `Target` mapping needs to choose the least-refined `Target`. From 1a803e5f346ecd1eecb159c663b502188b3634f9 Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Fri, 25 Mar 2022 16:34:27 -0700 Subject: [PATCH 10/11] - Manupa's comments --- rfcs/xxxx-collage.md | 140 ++++++++++++++++++++++++++----------------- 1 file changed, 84 insertions(+), 56 deletions(-) diff --git a/rfcs/xxxx-collage.md b/rfcs/xxxx-collage.md index 3aba5dea..a53a8355 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/xxxx-collage.md @@ -1,17 +1,16 @@ -# Design Doc: Collage [Draft 0.8] - ``` -Feature Name: Collage +Feature Name: Collage [Draft 0.81] Start Date: Mar 2022 Authors: Mark Shields (mbs@octoml.ai) -RFC PR: -GitHub Issue: +RFC PR: https://github.com/apache/tvm-rfcs/pull/62 History: - v0.7: First draft. - v0.8: Rework to emphasise 'partitioning' (quite early in pipeline) instead of 'fusion' (quite late in pipeline). ``` +# Summary + This design doc (with accompanying ['v2' prototype implementation](https://github.com/mbs-octoml/mbs-tvm/tree/mbs-collage-sketch)) shows how to bring tuning to TVM's BYOC partitioning passes. The tuning search explores the choice of sub-graphs (aka ' @@ -29,16 +28,6 @@ The approach is based on the [preprint](https://arxiv.org/pdf/2111.00655.pdf): (See Appendix A for a comparison of this proposal and the paper's implementation. See Appendix D for TODO items in the ' v2' prototype.) -This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to partitioning: - -- Greedy: Currently only the largest possible supported sub-graphs are used for partitions, irrespective of their - execution time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller - sub-graphs to yield better overall latency than one large sub-graph if they mix toolchains. -- Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding - `partition_for_` function before the main TVM compilation flow begins. With Collage the choice of toolchain - can be automated based on measured latency. Collage will also explore mixing and matching between multiple BYOC - toolchains as well as TVM's native backend. - When Collage is enabled it subsumes the existing `MergeComposite`/`AnnotateTarget`/`MergeCompilerRegions`/ `PartitionGraph` passes embedded within each `partition_for_` function with a single new `CollagePartitioner` pass. The pass is guided by the list of available `Target`s and three existing sources: @@ -46,17 +35,36 @@ When Collage is enabled it subsumes the existing `MergeComposite`/`AnnotateTarge 1. The `"TOpPattern"` attributes provided for every Relay operator and used by TVM's built-in `FuseOps`. 2. The BYOC `"target."` operator predicates provided for some operator/toolchain pairs by 'operator-based' BYOC integrations. + TODO(mbs): Consider removing predicate based BYOC integrations once TensorRT has been transitioned to be + predicate based. 3. The BYOC operator pattern/predicates (usually) registered in the pattern table by 'pattern-based' BYOC integrations. -Only some boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage (and we will make -these changes either as part of or in coordination with the UMA project). However Collage may require more robustness -from the BYOC integrations, see Appendix F. +The pass is run as early in the compilation flow as possible (see Appendix C). + +Only some boilerplate aspects of existing BYOC integrations need to be adjusted to support Collage (patterns must +be registered in the standard pattern table, 'preamble' passes need to be split out as per Appendix C, and any +mandatory post lowering helpers must be folded into the custom lowering function. We'll make sure these changes are +part of or coordinated with the UMA project). However Collage may require more robustness from the BYOC integrations, +see Appendix F. Note however that we are **not** proposing to deprecate the existing `partition_for_` operations (or their UMA equivalent). This is mostly because Collage is inherently a tuning-based system which is not practical for users who need a stand-alone compiler. But it is also because of challenges with establishing a common pass ordering which will work for both TVM and all BYOC toolchains (see Appendix C for more details). +# Motivation + +This tuning approach contrasts with TVM's existing "greedy" and "manual" approaches to partitioning: + +- Greedy: Currently only the largest possible supported sub-graphs are used for partitions, irrespective of their + execution time. With Collage many more candidate sub-graphs are explored, and it is possible for two smaller + sub-graphs to yield better overall latency than one large sub-graph if they mix toolchains. +- Manual: Currently the TVM user must commit to a BYOC toolchain and invoke the corresponding + `partition_for_` function before the main TVM compilation flow begins. With Collage the choice of toolchain + can be automated based on measured latency. Collage will also explore mixing and matching between multiple BYOC + toolchains as well as TVM's native backend. + + Collage offers three advantages: - **Latency**: Overall model latency may be reduced compared to TVM native, TVM with a single @@ -69,7 +77,7 @@ Collage offers three advantages: See Appendix H for some frequently asked questions. -## Success Metrics +# Success Metrics 1. Collage offers at least a 10% latency improvement for a selection of standard ONNX models and NVIDIA hardware using targets which include the CuDNN and CuBlas libraries, the CUTLASS library (with tuning, via BYOC), the TensorRT @@ -79,7 +87,7 @@ See Appendix H for some frequently asked questions. 3. Collage with a `Target` list enabling just one BYOC toolchain is never worse than using the the existing `partition_for_` function directly. -## Project Milestones +# Project Milestones - [Done] M0: Port paper prototype to recent TVM main and validate paper results. - [Done] M1: Internal design doc. @@ -90,7 +98,7 @@ See Appendix H for some frequently asked questions. - [OctoML internal] M6: Estimator integrated into OctoML platform, validation against OctoML test suite. - [OctoML internal] M7: Productionization for OctoML. -## Check-in plan +# Check-in plan Though the 'v2' prototype is in a personal branch we'd like to transition to main ASAP and rely on directory/namespace separation, maintaining backwards compat, and a new `PassConfig` flag to isolate all Collage changes from the rest of @@ -113,26 +121,19 @@ TVM. A rough PR progression is: - `GatherPartitionSpecs` helper for bridging the existing BYOC world with the Collage `PartitionRule` world. - The `CollagePartitioner` driver pass itself. -## Related Work +# Guide-level explanation -- The [Cascading Scheduler](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0037-arm-ethosu-cascading-scheduler.md) - combines i) dynamic-programming to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to - guide the search, and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By - contrast Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) - uses (very much slower!) measurement to guide the search and iii) has no influence over how either TVM or BYOC - toolchains actually lower the sub-graphs given to them. -- The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal adds a layer on top - of the existing and separate TVM BYOC, operator strategy, operator scheduling, target-specific passes and - target-specific code generation extension points. Collage currently relies only on the global pattern registry and - global `relay.ext.` function to integrate with BYOC integrations, but this is easy to rework should UMA - change the source of truth. +Collage allows the choice and partitioning for BYOC toolchains to be determined automatically +so as to minimize overall (expected) model execution latency. -## Example +To compile with Collage it's necessary to set a `PassContext` flag, and include +'Collage aware' `Targets` in the build's `target` argument. -We start with `mod` bound to [MNIST](https://github.com/onnx/models/tree/main/vision/classification/mnist): + +For example, assume `mod` is bound to [MNIST](https://github.com/onnx/models/tree/main/vision/classification/mnist): ``` -fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { +def @main(%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { %0 = nn.pad(%x, 0f, pad_width=[[0, 0], [0, 0], [2, 2], [2, 2]]); %1 = nn.conv2d(%0, meta[relay.Constant][0] /*Tensor[(8, 1, 5, 5), float32]*/, padding=[0, 0, 0, 0], channels=8, kernel_size=[5, 5]); @@ -151,7 +152,8 @@ fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { } ``` -We can compile this with Collage enabled for a variety of NVIDIA toolchains/libraries as follows: +We can compile this with Collage enabled for a variety of NVIDIA toolchains/libraries with +the following fragment: ``` with tvm.transform.PassContext(config={"relay.fallback_device_type": 2, "relay.collage.enable_collage": True}): @@ -172,7 +174,7 @@ After the `CollagePartitioner` pass, the intermediate `"main"` global function c performance): ``` -fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { +def @main(%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { # Operators left behind in the function body are intended for TVM. # The usual Relay passes may rewrite them, then FuseOps will push them # into "Primitive" functions (without any "Compiler" attribute) ready @@ -230,9 +232,10 @@ fn (%x: Tensor[(1, 1, 28, 28), float32]) -> Tensor[(1, 10), float32] { } ``` -Ideally this optimal partitioning would be understandable to the user, see Appendix G. +The remainder of the compilation will respect the partitioning found by Collage without +any further user involvement. -## Design +# Reference-level explanation The implementation is mostly under `src/relay/collage/...` (namespace `tvm::relay::collage`), with just a few Python helper functions under `python/tvm/relay/collage`. @@ -246,6 +249,9 @@ before all other Relay passes. The result of the pass is: are replaced by calls to an inline `"Composite"` function. (This encoding is supported for both BYOC and external libraries.) +TODO(mbs): We need to also support +[RFC10](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0010-target-registered-compiler-flow-customisation.md) style BYOC extensions in the partitioning encoding. + Note that no `"Primitive"` functions denoting TVM kernels are produced -- the existing `FuseOps` pass is still required. The `CollagePartitioner` pass has four phases: @@ -367,6 +373,8 @@ We currently have three distinct flavors of partitions: offload, and those are grouped into a `"Primitive"` Relay function with a `"Compiler"` attribute. - For operator-based BYOC integrations, per-operator predicates indicate operators to offload, and again those are grouped into a `"Primitive"` Relay function with a `"Compiler"` attribute. + TODO(mbs): Consider removing predicate based BYOC integrations once TensorRT has been transitioned to be + predicate based. - For TVM, obviously all of Relay can go into a single partition, however for search efficiency the partitions should roughly mimic the Relay `FuseOps`. That pass uses the `"TOpPattern"` (of type `OPPatternKind`) attribute on all Relay operators, and rules for when operators of one kind can be folded into another (typically by moving scalar ops from @@ -412,6 +420,8 @@ The base rules are: call sub-expression. Generally this will result in a singleton sub-graph containing only the call, but it may also pull in constant arguments to the call should they be required. Used to bring BYOC operator predicates into the Collage framework. + TODO(mbs): Consider removing predicate based BYOC integrations once TensorRT has been transitioned to be + predicate based. - `OpCallByKindPartitionRule`: Uses the `"TOpPattern"` attribute provided for every Relay operator to produce a candidate for every call to a 'fusable Relay operator'. Used to select the operators which `FuseOps` will consider parts of kernels. @@ -435,8 +445,8 @@ The combinator rules are: - `OnlyValidPartitionRule`: Given a `SubGraphConfig`, ignores candidates with 'invalid' sub-graphs. Used to limit the maximum candidate depth, the number of independent outputs, and whether intermediate 'taps' are allowed. - `HostPartitionRule`: Produces candidates for all Relay expressions which could be - 'left behind' for execution by the host (eg on the VM). This rule lets us simplify the overall Collage search - algorithm. + 'left behind' for execution by the host (eg on the VM). This rule lets us move special case handling out of the + core search algorithm and into a simple rule. Here are some typical ways to combine `PartitionRules` for different partition flavors: @@ -448,6 +458,8 @@ Here are some typical ways to combine `PartitionRules` for different partition f CombinePartitionRule (with a join-anything combiner rule) OpPredicatePartitionRule ``` + TODO(mbs): Consider removing predicate based BYOC integrations once TensorRT has been transitioned to be + predicate based. - Classic pattern-based BYOC with `MergeComposite`/`AnnotateTarget`/`PartitionGraph` passes (eg see `cutlass.py`)`: @@ -554,9 +566,10 @@ for rapid retrieval during the shortest path search. ### Phase 3 -We find it most natural to use Dijkstra to find the optimal partitioning. A `SearchState` is: +We find it most natural to use Dijkstra to find the optimal partitioning. A `SearchState` is a node in the search +graph, and contains: -- An `IndexSet` of the dataflow nodes already 'covered' by candidates on the best path to this state. This is the +- An `IndexSet` of the dataflow nodes already 'covered' by candidates on every path to this state. This is the identifying key for the state. - The predecessor `SearchState` in the best path to this state. - The `Cost` of the best path to this state. This is the order for the Dijkstra priority queue. @@ -574,11 +587,11 @@ The `HostPartitionRule` is used to allow some dataflow nodes to be 'left behind' ### Phase 4 -The overall Relay expression is partitioned over all the `CandidatePartition`s on the shortest path 'in parallel'. Since -all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful not to +The overall Relay expression is partitioned over all the `CandidatePartition`s on the lowest cost path 'in parallel'. +Since all the candidates are expressed using `SubGraph`s w.r.t. the original dataflow graph, we must be careful not to invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataflow order avoids this problem. -## Known Limitations +# Drawbacks - **Some BYOC boilerplate changes required**: TVM's current BYOC integration API only requires the 'lowering/codegen' function to be registered to a well-known global function name. Everything else is up to the BYOC author. @@ -668,7 +681,21 @@ invalidate yet-to-be-partitioned candidates as we go. Working backwards in dataf making the partition explicit enjoys both faster compilation and can incorporate global optimization passes which Collage cannot currently account for (eg enforcing a particular layout). -## Appendix A: Differences between the paper's implementation and this proposal +# Prior art + +- The [Cascading Scheduler](https://github.com/apache/tvm-rfcs/blob/main/rfcs/0037-arm-ethosu-cascading-scheduler.md) + combines i) dynamic-programming to find an optimal grouping of TE sub-expressions, ii) an analytic model of cost to + guide the search, and iii) cascading scheduling of the TE sub-expressions so as to reduce memory high-watermark. By + contrast Collage i) also uses dynamic-programming, but to find an optimal grouping of Relay sub-expressions, ii) + uses (very much slower!) measurement to guide the search and iii) has no influence over how either TVM or BYOC + toolchains actually lower the sub-graphs given to them. +- The [Universal modular Accelerator Interface](https://github.com/apache/tvm-rfcs/pull/60) proposal adds a layer on top + of the existing and separate TVM BYOC, operator strategy, operator scheduling, target-specific passes and + target-specific code generation extension points. Collage currently relies only on the global pattern registry and + global `relay.ext.` function to integrate with BYOC integrations, but this is easy to rework should UMA + change the source of truth. + +# Appendix A: Differences between the paper's implementation and this proposal The results of the paper were derived in a [branch](https://github.com/cmu-catalyst/collage) from [TVM](https://github.com/apache/tvm) at `461d06eb5cfc7954f1983779acd05c47cea269f1`. We ported/rebased that code onto @@ -730,7 +757,7 @@ However: 6. We have only re-implemented the 'op-level' dynamic-programming based search strategy from the paper. Though the paper reports encouraging results with the 'graph-level' evolutionary-search strategy we leave that to future work. -## Appendix B: Easier Library Integration +# Appendix B: Easier Library Integration TVM has two very different ways to make external library implementations available for use as (or in) kernels: The pattern-based BYOC approach and the TVM `te.extern` approach. @@ -787,7 +814,7 @@ One possibility is: We'll follow up on this separately, but mention it here since it motivates why we've tried to handle "Composite" patterns fairly generally. -## Appendix C: When to run Collage? +# Appendix C: When to run Collage? There's a few cross-cutting issues when it comes to when Collage should run in the compilation flow: @@ -867,11 +894,12 @@ In more detail, here's a taxonomy of pass instances and how we can handle them i TVM lowering. They are also within the standard Relay pass prefix. - Under Collage, same as for the target specific passes above. -## Appendix D: TODO items in the 'v2' prototype before proceeding +# Appendix D: TODO items in the 'v2' prototype before proceeding - Implement the penalty for transitioning execution between partitions. - Bring in `cudnn` and `cublas` to support measurement (ideally as Appendix B, but probably as heavyweight BYOC integration pending better support). +- Support RFC10-style integrations in the partitioning rules / sub-graph realization. - Implement TVM-tuning during Collage search. - Cross-check measurements against some of the 'v1' models. - Bring up on `GPT2` and other 'larger' models. @@ -888,7 +916,7 @@ In more detail, here's a taxonomy of pass instances and how we can handle them i - Reconcile with the 'RFC10' style BYOC extension methods -- we should support them all but for simplicity have just focussed on the traditional "Compiler" annotation. -## Appendix E: Robust candidate kernel latency measurement +# Appendix E: Robust candidate kernel latency measurement Collage requires an implementation of a `CostEstimator`: @@ -919,7 +947,7 @@ TVM's `tvm.runtime.vm.VirtualMachine`s `benchmark` helper. The following needs t - Collage needs an estimate of the cost of transitioning between partitions (or kernels). Ideally that estimate would be based on measurement rather than hard coded. -## Appendix F: Robust BYOC integrations for targets of interest +# Appendix F: Robust BYOC integrations for targets of interest Overall any BYOC toolchain which could be supported by Collage needs to be brought to a high standard: @@ -937,13 +965,13 @@ Overall any BYOC toolchain which could be supported by Collage needs to be broug Our current focus is on TensorRT, CUTLASS, CuDnn and CuBlas. -## Appendix G: Visualization +# Appendix G: Visualization A [netron](https://netron.app/) style visualization for Relay which clearly shows the partitioning and cost for all the kernels would be very valuable. The paper prototype produces such a visualization but we've lost that functionality in the transition to 'v2'. -## Appendix H: FAQ +# Appendix H: FAQ - **Are you deprecating `FuseOps`?** No. `FuseOps` will be run along with all the other Relay passes on the TVM partitions (ie all Relay expressions not partitioned onto a BYOC backend). @@ -970,7 +998,7 @@ the transition to 'v2'. partitions which roughly match kernel boundaries. This means Collage's partitioning rules need to roughly predict the fusion rules of each backend, TVM included. -## Appendix G: Representing Collage 'backends' +# Appendix G: Representing Collage 'backends' The paper introduced an explicit representation for 'backends'. In this design we've chosen to merge this notion back into the existing `Target` machinery: From ae796b0bc18ad62efb4af0c6e632eed92f67b21a Mon Sep 17 00:00:00 2001 From: Mark Shields Date: Mon, 28 Mar 2022 13:44:45 -0700 Subject: [PATCH 11/11] - Remainder of Manupa's comments (oops) - Add some pictures --- rfcs/{xxxx-collage.md => 0062-collage.md} | 64 ++++++++++++------ .../0062/dataflow_graphs_and_sub_graphs.png | Bin 0 -> 99128 bytes rfcs/assets/0062/optimal_placement.png | Bin 0 -> 125042 bytes rfcs/assets/0062/partition_rules.png | Bin 0 -> 188360 bytes rfcs/assets/0062/search_graph.png | Bin 0 -> 191885 bytes 5 files changed, 45 insertions(+), 19 deletions(-) rename rfcs/{xxxx-collage.md => 0062-collage.md} (95%) create mode 100644 rfcs/assets/0062/dataflow_graphs_and_sub_graphs.png create mode 100644 rfcs/assets/0062/optimal_placement.png create mode 100644 rfcs/assets/0062/partition_rules.png create mode 100644 rfcs/assets/0062/search_graph.png diff --git a/rfcs/xxxx-collage.md b/rfcs/0062-collage.md similarity index 95% rename from rfcs/xxxx-collage.md rename to rfcs/0062-collage.md index a53a8355..0e7a5c47 100644 --- a/rfcs/xxxx-collage.md +++ b/rfcs/0062-collage.md @@ -85,7 +85,9 @@ See Appendix H for some frequently asked questions. 2. Collage does not require new per-target or per-model patterns or rules to be implemented independently of the BYOC integrations. 3. Collage with a `Target` list enabling just one BYOC toolchain is never worse than using the the existing - `partition_for_` function directly. + `partition_for_` function directly. (Since partitioning for multiple toolchains in sequence should never + improve the result for any single toolchain we consider just the single BYOC case.) + # Project Milestones @@ -263,20 +265,25 @@ The `CollagePartitioner` pass has four phases: available rules from phase 1 are evaluated on the dataflow graph to yield a (possibly overlapping) set of candidate partitions for each target (see `CandidatePartition` below). Each candidate efficiently describes a sub-graph of the global function's body without the need to construct any new expressions (see `SubGraph` below). -- **Phase 3**: A shortest path is found in the following (implicit and lazily constructed) search graph: - - Search Nodes: The set of dataflow nodes which have already been assigned to a candidate partition in all paths to - the node. - - Search Edge X->Y: A candidate partition can be applied to node X to give node Y. The candidate is disjoint from - all dataflow nodes already assigned in X. To avoid an unnecessary search space explosion the candidate must also - include the next yet-to-be-assigned dataflow node in X. - - Edge cost: The estimated latency of the candidate partition, plus a partition transition penalty. Note that though - we need to be able to extract the candidate's sub-graph in order to build a function representing the candidate, - we do not yet need to partition the overall function body expression. +- **Phase 3**: A least cost path is found in the following (implicit and lazily constructed) search graph: + - Search Node: Each node represents the set of 'covered' dataflow nodes which have been assigned to a + candidate partition on every path to the node from the starting node. + - Starting node: The search node with empty 'covered' set. + - Ending node: The search node with every dataflow node in the 'covered' set. + - Search Edge X->Y: A candidate partition P does not overlap X's 'covered' nodes. Y's 'covered' nodes are + those of X union P. To avoid an unnecessary search space explosion the candidate must also include the + next yet-to-be-covered dataflow node in X. + - Edge cost: The estimated latency of the candidate partition, plus a partition transition penalty. Note + that though we need to be able to extract the candidate's sub-graph in order to build a function + representing the candidate to measure with, we do not yet need to partition the overall function body + expression. Other search algorithms are certainly possible, eg the paper uses an evolutionary search to refine the partitioning found by the dynamic-programming search. We can easily abstract away the search interface to support multiple implementations in the future. -- **Phase 4**: The function body is partitioned according to the candidate kernels on the shortest path. +- **Phase 4**: The function body is partitioned according to the candidate kernels on the shortest path. This phase + can be run independently of the first three so that additional inspection or optimization may be applied to + the intmediate optimal partitioning. In the following we introduce the new datatypes, then expand on the phases. @@ -301,7 +308,10 @@ In the following we introduce the new datatypes, then expand on the phases. ### SubGraph A `SubGraph` is an `IndexSet` of the `PostDfsIndex`s of all dataflow nodes 'inside' an arbitrary sub-graph of the -overall dataflow graph. This and `PartitionRule` below are the core Collage datatypes. +overall dataflow graph. This and `PartitionRule` below are the core Collage datatypes. The following illustrates +the dataflow graph, indexes and one sub-graph for 'mini' MNIST (MNIST with the second layer removed): + +![dataflow graphs and sub-graphs](assets/0062/dataflow_graphs_and_sub_graphs.png) Sub-graphs can be used to represent partitions/kernels/composite functions without having to pay the cost of constructing or rewriting any expressions. We also allow 'extracting' a function to use for measuring a @@ -396,6 +406,7 @@ An obvious question is whether all partition rules should be expressed with `DFP the `DFPattern` library itself. Indeed, though it does not appear to be used in prod, the `DominatorPattern` is an attempt to use `DFPattern`s to subsume the existing `FuseOps` machinery. We actually went down this path but decided to back out: +- We'd need a new pattern combinator to associate predicates with sub-patterns. - Since we are interested in searching over possibly overlapping candidate partitions we'd need the `DFPattern` machinery to all enumeration over all matching sub-expressions. That would require a rewrite of the `DFPatternMatcher`. @@ -404,11 +415,17 @@ decided to back out: or cognitive overhead for those common cases. That pushed us to the present design, which builds on `DFPatterns`, but introduces new 'base' and 'combinator' -partition rules which can be combined to match the desired partition flavors. The 'base' rules produce candidates -from the dataflow graph directly (eg all sub-graphs matching a given `DFPattern`). The 'combinator' rules -combine the candidates found by one or more sub-rules into a new set of candidates (eg by indicating the -sub-candidates should be wrapped by a `"Composite"` function, or touching sub-candidates should be unioned -together). +partition rules which can be combined to match the desired partition flavors: +- The 'base' rules produce candidates from the dataflow graph directly. Eg we have a base rule to produce + all sub-graphs matching a given `DFPattern`. +- The 'combinator' rules combine the candidates found by one or more sub-rules into a new set of + candidates. The sub-rule(s) can be 'base' or 'candidate' rules. We call the candidates produced by + a sub-rule 'sub-candidates'. Eg we have a combinator rule which wraps all sub-candidates in a + `"Composite"` function (when the overall expression is rewritten). + +The following illustrates some base and combinator patterns on the earlier mini MNIST dataflow graph: + +![partition rules](assets/0062/partition_rules.png) The base rules are: @@ -448,7 +465,8 @@ The combinator rules are: 'left behind' for execution by the host (eg on the VM). This rule lets us move special case handling out of the core search algorithm and into a simple rule. -Here are some typical ways to combine `PartitionRules` for different partition flavors: +Here are some typical ways to combine `PartitionRules` for different partition flavors. (These combinations +may be generated during phase 1 by inspection of the `Target` and BYOC registration -- see 'Phase 1' below.) - Classic operator-predicate based BYOC with `AnnotateTarget`/`MergeCompilerRegions`/`PartitionGraph` passes (eg see `tensorrt.py`): @@ -575,7 +593,10 @@ graph, and contains: - The `Cost` of the best path to this state. This is the order for the Dijkstra priority queue. - The `CandidatePartition` for the transition from the best predecessor to this state. -The starting state has no covered nodes. The final state has all nodes covered. +The starting state has no covered nodes. The final state has all nodes covered. The following is an example search +graph fragment for the mini MNIST example: + +![search graph](assets/0062/search_graph.png) When expanding a state we could choose any `CandidatePartition` collected from phase 2 provided it doesn't overlap with the state's covered set. However, a search path applying candidates C then D is equivalent to one applying D then C, so @@ -585,6 +606,11 @@ successor state in the usual way. (See Appendix E for more details on `CostEstim The `HostPartitionRule` is used to allow some dataflow nodes to be 'left behind' for execution by the host. +The result at this stage is an `Array`, which can be materialized and restored using the standard +TVM object graph machinery if desired. An example least-cost path for the mini MNIST example could be the following: + +![optimal placement](assets/0062/optimal_placement.png) + ### Phase 4 The overall Relay expression is partitioned over all the `CandidatePartition`s on the lowest cost path 'in parallel'. diff --git a/rfcs/assets/0062/dataflow_graphs_and_sub_graphs.png b/rfcs/assets/0062/dataflow_graphs_and_sub_graphs.png new file mode 100644 index 0000000000000000000000000000000000000000..4af6497e58957f5b17141c1cc9e9317445710762 GIT binary patch literal 99128 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

VF$)R>7is1{dXjyp#7piiQapdC{h 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

9S5$R&KK}9J&!aO9uV?y3S}EOC6(`VoLNUJ| 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�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%0AI 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 z zqd9f&-$&Jos+(4=yRNXH+DHe!zwKlzua+t78=>B{on^YKJnjv#&KVin&HZmTMd1hD z_T$pGo2SI1x!3aVdWgBt^*m>jm{*2)SJ+;*d&P{*mkjvS0>W~Qv*Xvxm62%7pKr0Y zLqbi~@y(aef!-7Xe-q_iTpQD?*5@^h83_p*@m^(0u=3(SngP$XS_O~0+Yh~B$Jz)t zcZ@$cBmnUqVC4u0M8Ds}Z2B@0Bjgpx-f3OZM3-h` zmAjGK;906-3ttGE7`S1^3n3d5kue>?xRnecNwQeGeM4-QRv^Tar5rfYN-sp4dQ6{e zqWlp+ZGDCa(t@9t&L-_JVIlqi-x|P*{$BNl**E?ShG*`V#Y4pxs zS}o@cKRSb$aT)zaDx>~)H~NA$9XN{fCiTvlZ7KO;|ZzcDmDa&ebx z31ZK3eLC|_gZB<@)9`Ak`1hYJ*+wPbmF%IgXLg{R>Jo8wu2w65^lUd_V7UGCn)1a@ z&X5!Pe5}ib>US^%egDl;Su@N91>^8LOm|b*OuVbgZ14d5VO~VFoawS7C?h@n>kn?& z8@FVs@nc_2nnp{|T=tYPFS-FW_wc*Pwn-NTYn@d2%|P>Yx>XyLnwO^mKr9NjMrRIg z`aQn)>2GNTtO+XhvH<77oJ9TjYr0u>@-`MiuRy8?bjOp;e~6&3sre?KLe);xNol;I zSwLbt+qH>s^zX~m|N3{@=vsa0#!^i4xHi{55v{)4`Ltz7WTf5ntQ1g;&5PLg27s58 zPeBI2FcU<7P{+mw+nO>PtCp7EyLl;)eklari9$Vp(<>1jL@Qv{^#6OYo(~;Ra~zI9 zWXVvUTcOkEzXQ7&X=L=Rqz%UR+1#?{PDVck+djN&7>>GHSJ~-Kqo`?aw}Cyp4SIUh z-ZuRA!R`P4^M#y5eS)j^@4t#1X{oELJFv-diTmkO-TwA?W&5O<-ce*ozESks8TEB^ zxFLFxC8JH1LcZ45Xbvq~Og$e34opB|>_{eco5-pDx(+CK$S*36O1a2HS%&8(s%{KV ziqIrm)mTa3X8?zp2+>v(rTUY38}t?SgDz;~IMp48gi#n&|Dm(3h-t1q%<0QiL5FmU*bI9MAgS5`^1xFm zq}-Y9Rj2dj21=Oxv+ViBR_fT^S~wMu$((R&A9T}TNWh+?`EYv@VaH5(6G4c4miY(S z3SvxjX1^TKA2>*5IMG+s?>B9ue}7+U+611;ZhLocK}1Z{0orQc`vAvD5!u`6CK>z1 zcIyR^&3QV|=J{a@*cFZiJ#hNvnI_PJ2ieHvoS z{{4II|EL3ZKTaDs6Su6a**lG|2428#x77g=9$M7!pd3n~H;1~DHq;ATr^0dSN=i4e z9$a7GD1kK)mNg#wK@8qR*g$TCPKlK!0vYg}J{WkVPCWW?4$g$X2tKVAlTIW$`whUI z3_-!P%`tQStu_&Oa-SUlpCm(5b(EHZ0^=qbcxYtEGlPy4V3qC-kl$SR^!RVzzP<33 zk(M@rZcLl&^o=gJR%)k78Oh0?H^2QRHZ~jDH=rbJS*vE(%k*bYc2rmB51q{;G}9;e&@fUITz8UX-+M!f5$Ko_A; zrz0A;&M=-2%_VWi%1VDmUe*K&wCe;!(S(hwsZ_^J7mm-y&Jg#U~awl zs7vX5i>CfNB4I`cTU4&MZp}~dd~AvV)I8ff&@3=YI*}wH^-|en39ElwZrPORP-28E zOF1IZ6PanelYSt+ISqOPn3Mjpqiy)xw@E;D6ucX5?WD7#%P$f-sLSdF$20Fym4S1} z(IN(&zZA}Z{$SP!5HlAT{#i1f}nd18~9 z5>C-Kq#o?j1PKpe7lLc~9yjFsSB2@%A`RqOSy_){67F3H0T&ecN+=WHP(kA%8tMNI z=NTWGp@`3HY7p;g_apBXZPqkffgxQF7LTp1@2w`qRm3I$Se38?bA>7;iE+g0tfaJEr!?fCatq{&>yWo3u;S9I^w}Y@Iz7bbw68+OW zx)P$QU#0*ZreXNrVUTIp-IdIu0hPxZkYg~(U=;wq!L?W^x15M7LQg^3nS(0aMo8f5 z_CFr9=x5$__0}|KIgIBXo%1a$IwZ&hs-7rltySnvI7Z^`fkwISeJ#B zl@Czx4ZJct`NJD6fW!?`XI0Hiw#(l9z`*XaI=5#42{!F3pv!bt5R)cC;ULLcIT%*o zfw(J*JFwILQHy0zPcD#`b)`HAg6F0E@l)jz*WXh0l>;u>Pmlx)qvZ9 zU7mMOgK?gpPXXBijTS(uq}vi+SK*#7dzBdr1syqeN=p!7V^O-M*SU>;F*xbW2D8nm z3@^`hAh=_leBK&U@i-Ov z69EsS6A*v~m8il!pH8g9@rlssMAVQ|4v*w)ps^2Xn4H219cIi+5IOvroA%DAvYR5- zVn{chCq%iI=?-QT^H&!Y0F@&7c^EP!y1ycLWlxUi0}LG$aw;O5&#?#KuONz)gaJbHPDHL zfgwL&Q%w6>HjK<2&L%jO-6`mKxd?5n8p3HK{~>!nm1>89X3R}aMvj%DprZ_{&!_w4 z1F*8Wixfb_?8bi2yH#@n9Skzl!pf=}9Sr)kY+!clR7zo?PFk#M6wZxMHAH@$I1UGp zJYwFy)i#fZ0a%;TXY;heH23kx1S-2jN&?6SxOf@b+dUUACUs=0SLf9^J#Z2Ob!|v! z%{9Y4J$AmZcLX3r_)DVB@0iJUi}zN}JT(zZ?)0pbwX@77m;P#~o>+P}T=Sb%;Qci5 z61${xhi8xoMtisumZ8L@vSN@~H+wy(@B_6o(m+|LkqYTu&4VB9asPU68ZJr8EoPL=@X za&nQUdA{-BA97D|xq~C_M*M-0f+$l7dp>Nt^y7o&dUx}cclyNt9f`@{RCS$J&86n= z6*p^b_W+5Z15Vqw$aCVLrlCt|$K*OfFG+B=(j7KJH@&T>e?gUi(qzko<`}tv^8rD> z!_!-u+QUpP+xM9yVzl@i)pOp53+bdec=4ce!fbBk-Y?p|fzxpf#-&ek>~V>=E>jdE z?YD0(xQ|!PHdri@$Tqn#Y2dEW?6d^mYht4F<+rh>=+TAcmz|EC8KG@$wtH)RpZ*ru zX@g(9y&SkCemGHnFwVH?p@mcJQHFkp^V%fj>1Tfp)Hw*9CT*$wtVOoI1a0EFXIHfZ zhxTzLDC*oVQfi-QT+jJ(cgJds84CLfvIo?b48QtESMqI%K3+yC;}SLonLmHV#cv9CFTP6!C7X!Y#> z1+%k<(XKnqQ+G_1Bwe6vY4>O?Hx`03`bp9W?!57dZYjkQ{X6n}Uc8W>KN!&$g^05^ zhpeb_2DH`p#K|SPw!?V4UPnh8&D|fLeL{Su8aQ5=I}=|O)`vfZ81L4JwDt$S zrx27Gevo@?^2=Ie%x~K_mU#zmZp;;cj%gv%EVY&=k$WfLyfYxm-YsMjlYJ6ny>rpK z9pUpRnt#p^l@78PbSG6gF!(mmWk(_~2n0bvW&*Gu91x+o$5&6%X~Y{`XI|(HSK#P2 zsA%N(OoFD{#4dxA1;8#}rl7Y>>Sm^NyB|$1p5kR&Of2ccD^NXt1}?VRNJN*yPb>?R z%_xKk@E=E=j${XqVa=+&`OoaFk7{Xf7C`RM5Tt+pFhl^<(zKCGE6_~r?hg@??COQ= z9@E=6){G9LIMAL9sH>NCZdRuhDz*D2z0$Tl8<+s%Tue7i1I+OOWC?+yhabtwO?T&p z*Za(tI1a(#?OWF!Okcm|5ET~h$&g|1IScnCV1MBwsJDw92fkI$SNdEqFdFn@505?`UoFnv= zeQ%zEe`u##D70{=?_m}QHh?*wn#wODGic4sFf~3Td@1$QKh@~P z*<6%*Wlo_4Uf|W93%?FauYNPaBUEJSEq!L*;pDt4-63+!?__++*vF?o;U711--0Tc=@6D?SADf;w6f)(ss#b zIN`k?Y1@ha_;)u{^*fXp7P&Tdo^5g#(6p(+4HXKw1th=6E>0c0xb!cot&L~bl*@)6 z<=7b%KObKgr6}`Loc208e74e}q+mbdU__m!kNqV$4iNBbej9So#|84vMhaD5Az7)bgu*9gk? zM_jQhPT2$YJg9BkWR|^5FUGhG_5OO}Q;}UyHck_kL8~XJO{L{XQ+SK6sQ@grrjbOp zHdIeILphxF=lD8~A2njP)|h40s|FsG_u7&*>WXvtNVoI5L|X&hr> z+Uy``x^yj;fCybN9$H<|zOAd?)sU6=ADUpMdRBTxncwKUcTKM@BHwN`8ND<2Or|MdC5%kv}a#Ufk|iBuc%>?300B$c=sWpRV|D&@%7s&7oUKW z*D!_VD`B?HI~Y|$;>X``*VdixnnrAAIc-|8v|I>un-}9~1FH!Mm*TgiHv!UR;holh z>M?y(d(Mbr(p@ zT$DW%XO`dLP4Rt1!udSN_nf>^DM9)VLU#33OW@f)+SW{rne;W?4^f{3_gh(gw3TgD zpxDH)#Ka@6*uIAsF@7E2k4?ly3x{&Y#@&C8Bh47q#AdKPnA3%$2aN?*;j>kfZ7(YE zjceq(TD0}APE7LpR>rB88Ya%At>TvlrOOOU(EiYCShWPineX;nw6g_?22|@8vD=U~ zza9)NB8G)`v+LHESq>lo*!xVe>xZdOG%;B`WUaNR1{$X%Rf!rdt)s z((5l~tMSTSZ^aeIV}9tzmXov^^=x{JE&L=LjUkwooHO7tJ#3W4KYg zZ0;daOI8>F)@BlEi&$0-6Gz%4=SF(Bndgn+<%=4Un^!c1lT&KY3_4|{59@R}g`Oj)HD}N*;BBcL=IuiK# zyq8XA9g)LgGS}imLb%h~Z9p3B$u$Z1jvI|jJK;pw8;hHK+IL#<_aK!gKE!QWKv(&K z>ykh+CrKx#ra}w_E&|8U;uUfsXQi)!izST2AP{K_@|Fz{;gG*@?R3AyvF)ENNzxE= z&&T_@nRNvZeGli36?ctcJa+N(Jw@GZ|6D`=&avYTwVy*s^EdQ<^*9)YfFX%QxH14mhOZ^Xgwu z?8Q>?f|Vt0K;LHo&I2_K!S|sOIUN$6#wCn@bEM!bu0|%=+J>k+6!cG48C7J zRDYn-LgXuv#S1DDw29Vd!5)}A=({znl}UF$oLbA{Nhg2%lwW58(v6Mr9+vne`E=K$L;{8+n3XmQqVC1On$KU-xNA1K6ici zIJJ*qD&<4D_C>pc^?0>*h(=v6fuZ_tr_C(kKM0%K01Xs8lmPz;UK6y)aMdtRhhiZw zcdd4HYFB=eRrv*~`;Ua&|NBA{3}T7W9*YqUk18ix&-}>J3NChSw`XwaddG@nW8@yt zb;?OTe*Uvn-yn^x0ikACmM<909ZkaCe@V~0@rFM-u;TyU{kL9lSbGW{(<2e?hM#QB z2v6%ztX&w?hbT(B{kuq`D(73Z&A0U3VsND+yOGq8@0ZW?5j~dULQt`f;Ew}vGe8EP z?cI8_0l-K@Vq@X(Gi*(W_JEh23g()!{hL$zjfF4FJF#}9X6@2!Q!=ei!PZkeQSql8 z-Et(djrdT8tDTVB0(p-9Ri74m*b%FZxKU#471xkl3J9N@=tvLPnqrOsdy6!~hCE$J z$!Yx_S%2o+ie?lym#M+?Gx+v}4%)DhyX!Kf z*Oyl|+MuhUU1f7=wTzy9ME}0#ww3=2qn$!0T)Pbs!K?};-pI%p{yVrS9wH*r5#=Jya0>FM2$&;?L?nC$YMuYo zG`TBNK88Yi#_Yj7l#0V28LUcCRn&P9jC)aHWLr@e^BIS~?S9Xyysdu^`BH(UrR~R0 z+nmzMTvpiK_|Mmwrgk#hoCMm-F$TMPy5{L#$|eag>JH<#JX1g-de9bY3A#K~ejnGX!@KG~$sc~=@j#Ay_PF@! z!u425-5WPf$t*;!YAIDuEVs_rg&ZZ1ztWQ5%b%rZ2M+tUscxgb_?fSDL}E$L-RrFzvL0?6th#G( za8$geY7f`1s?;*eS)(WmL)$At@d?fW@;lA4V*M5)jDn=|}c^*e-X7W{umG)$&MFYr5nyA9khTg!q9qI=+i3%1c|G9Z7D!#1q>~K1 z*Wg`nIcG0zVA}wbVNZM_^Y-mGUvS91`BCjt4PylI?|-zJ)b;%*uMZCxI_D&x0s`gB zSI}q@0&7*9H{A}R--L`tLE-7UBmeyK56ixNH(@j>idU~b;odaLat_kIxBM9bT*}eV z6&XeYKORQe|(-N*HJ*;z(nnq)jIJ zxf5U@%WGMrVHk-A+1X>)tY{SApiMOVO;}j!($d2ubB&g*BFCs}{h^co_}TtjF9w^N zgE1Vw$D!?e{MtCQZaN%+#2a~!&?Z~@FXV!K&urG8mC^|q4#*?I;Okp6%F4<@@EP_I zZzZ(t5PnWwqkF70ZkzuA*>5EP;>Y{|I8}g&{Ci;^9QS3B_SF*nyLq0|sPB6Ki^aYO z4nF^v30TTYldU#iyodJUn0o=06KiX0tSl^dkmc|5Uz^~;UiM>TJcY;u<-N4~)=!Fy zcM2{hLe$u|RVaiwJUq-ug{=I)chslj$ zAdc@R`pevBHCmV$8Tq-mK1>{D_^|op@pqd~%E89|P%AV@rJAoDZFh2!e+0@v(;Q%3 zg*pZX=$s(4(hLTQmFE3~EIr8B(pYFS z4jmVedBE)H3&~rAkgFfs|DAjei9^`upRQ~YlD7zve$CCz@BkN|-DVk|f8gf+)<7z6 z;jKSqVfs~8&2h9(3(-IQTWA{`j9}=m_s7Uwy43%Zy6ft%(O&IB{V1T97lfBvQQw^K zhfWuEH=rLtuU1u60sVZTY?LZEX-p-D#Xv(l1W)H&#Pw6uc|jX3rOkrBggkdPc9*c|`XFvYF zcj1^q0QK<%-XC`*t|=(6MSX-usnE=isz#XRT^rC>c3{6aK8IbxUQjPz)Yx@i5=ko2 zq#8rWiP`suq_=I#_>@DNJ3K)rujlSl!Zk;U=$=5T4)@i1MWyzyEl_Ei#dL#|}|3#4LuPF>lH)-~CPOi^zpH;o;%1 zZIGYuQ5xHa7(k!_QZi@7`~m`)Ac#-BdYArWBRomV;xHJ$qz(2&S&b<%E-sEXUf*Lh zcI3fG&0OO=cI*t`d?uMwzr%2z&PMkEux0m9Aky>=df+^@+`K#+Kzrw}(ngj_z#XTL zFPgTwLU;Qf}`D)DQD6Lc@TNH*Y}T(rlU!p)_K%*xA_F{1umX&PKj` zwP_Lc)9ir+gFt9U0*3p$Bc7g~(8TgC2u$Rsaf!AsUSxy3puJZvpHAFj_~gr1T+r5o z{z+Dv;$Tsch*s6h?3_5f6F5T>37&(-P@t_?Ee7Pv%E}5vgATKAat+H#8hLM@h9oMI z39Gw_02;&ZHO=txy?q)X+jdaNI?%uXmP~%2yC`@n%r4pfXvtCb+I#Yx-dZk=;%y~n z-fq{%Pa7O4_#VINb^NrSfXm&kYjCB3)SPQ4QA(7Nr(7B)%9we{kTBh_T2tSTdZas) zDHs;49tuamz^+H&as=FI6n?iI~#;tS+v*Rlct9 zXL!#x-1>5NT&H+=)0L9#v#_q0-?) zp7+Hn?}e0neVsNHt;(k^q>0yxVxt9)Vh+RrHmUWEoC!%-A{KU9u#4p=gsYUHa7L05 z_RV{*^^aF?j2v*@I9aK)7Bv-q$!)yLgfg2MIn|X@P9YxyaO*5W>NkxQg%WFGprg&? z>gcr)wrWDJ(FFPHw{IPPwlq(5zDXjj%vSCc=FE{K*-jf@&l>v{lk4FynPMO9%F<97 z@ap09uzi7JYo!_idpU$c5T*g-;7x12_A&U|NKi@?xcZElSy&n)S8ZHiXV&C{-@~`M zex@;+F0Mv9;uD%yx+iN;g!<$4ahBcK^md4(4;#);d!C95{8|=aaBbb|eGB279pzZI z@qEE!c|TH38==st@pjXidzkl{R}ik>Jrj});d^#0ubV%>5$>Gs8K#RsXlXGSHh2xw&|Vx zJUqIbRpO@X(Jq=v{7s$tJ@#n3j`H_BJ$EF=D+|lH@ju?H1k0W^wx4#>sA*8`tZEfR zyMEn8d9ZOjZJc>>;R&)$hTQO->t0M^GjE1%wR8R0bZv5^q=+s3oCklq=Q?}fQdOgJ z;!30wQpJs?DH(ztWftcv=fBxWq9+XEx_dBpDbD?ea0T+r;@CkgRlDM@%2+~sA*wyp zLB0C-xY1JkZODRQ<99MNqtevk^adDRSiHuvq6)3EdR^>HT1nR| zmOq7}3%hR?W%QZu;TP8o_!3K8%?o$=-JIlZ`u5EmY?EpeC?-iM zVfL=x*Fg6FTyvh{)A8{>XVe2Lh`|Ouv?z@d0~3h^EB3`x%n;hn)CI3)AE-NN;@TWI zK)xr8y5SR!dXDmUqS^twH+AX@Ch zf#yBB3tdfx_9L#OYPW<}oK2NXE|+r!(*N^|Z%>}n4uQ!xn#6XddI@A3&KEEa%Ie@g zuTP&#Yig@;BX{?PPU~#o(71B4NrrJsV%RsMqqnc(Koe1G0aD{iWD@pN-~G1MQ&GW< z>XRU7#Lup=?q|!YQ{1gb9(0@f8m~y2|D$Pm!6SbmCRjQ*KesAv!Y9#1B|N&bk{p|1 zoc(@mEl;kpTqap|@#=5fDIp0pvdeVRjuDw~@xhFof%5dVrt`e~^MzlkC~=IkOG`X~ zl%Qz|6|E}r8_u;~Mv@+5Syhz#iH1e?@5VWNQ1!*XJu4M&pUBXPg7u>^*_4gg^w(p8!wPQWTmbIK|h1Ckp@_?OTV;z6G$f8Cst(#ri z`MSBOyOAYxLF&5LjqKi{Z!!`-T~{iXes2(ez1?WfuvZ!7{JBA}I%nlo96S`4FsCh} zk(R?=5ZsxgtwN}fQ5*7{%f^v$=jztHhl=zC!dJ5tRCC+ET^nj>>=Rh|LFqgyw)C-% zG`V6n5jc6k$(Y==G1&QTYe45*aWt{Mo3jC|6RobZi+-HPQdOr*tf#`;#V4LCKJfbT z^5wUgUj?LV@dT$6i?iLIdIH6rI@%HOdq`0>%|mJ^H&WZm1{8z-s*JzINA*B4JIY<% z97B}$_;t-9HeDWz&_5$X%Q^>S50#mWZ z{#l{hpoaX*E42QQ+PbMQvybkAUUS3!>c{Jsd?aUgK|_gxnojByWp0iR;(hRi?B`uf4m;NaaZ)carjk?eLe$HE4 z`=uTx+i9yOShzd8uc&RVtPkH+TEY0wE-&YFK3*+CFVm=n$3!P?_auORr+T|CmDG#Jw5$k$=($ zg^4P*jzKQ%jqSCY&EO<;)j5tmlpdS8C>U9NeQTB{y^Rvts_&pi1ad4Ke4D@Exf5QoU(4-Txv44$u+ZLZt9 z!Gp5xEWY-tyRxE^`0+Ej@b<#(POSdQPMLhs!Hw!*Zd4_u-zZ(6P|Uv708>alKR$%S zB@g>;TG~Im5c4#0vSRxgerWW2y)~)jLi8sgvwQ#-m-#+5KRti)Ho+UE1@h8~J+nJ6 z2Xt(#X$hTw>Ys4~kXIx2{FUzrMTSeb^?8m}-WYk%f^g#3m zGjr&UU7?fv8`q`U|4=9wIZj!3W!O~Z2%j0hecMIkm%97Ih}iXk$R&jY0*;Yw!V(B-_@oupFGDerrdXX20Vg{vvSge_M)?%xrC|hrAJg9(=W@u)jbC@Lh zYd;5{wgVFrg>Mk{^ z_MPwAgWmtkH2VGFC4rH$f^lM-c2dlkNUWLn2EqKaQx-Ru1>Q;+^=^Z2Bd}nX59jb` z&4T!V*Dyhd|sM_4UmnK!}&LFqp%4 z%L3?VfOO~d_V!Lm&4P;c`_X*pg2;hi8j>avscNdKF6h-O*cG$&E$hm8r))n87wG2R z8o1KvCd$lQz%kKn#7vydeju9PTj32oYYcN)1NA2R>W8N9I=_^mI2kW4Z`rbrN&Y_I z&}!BGWqif^P($;RjWd;IG0X8AamEk7{!%uHh-=RDZALeT93$WJx68@KigH!~+P9DD ziuZ~z1FpHR0VgJm~z#oowFrQGdZGVT**3H#UX zF*lz``tM8E!3WdW|Hp{xhVq^QxeT>yCr+M3`p5L#{oa_5IU&)twD!Qu%PTTb5vwP0 z$xe2oooe}5qc-H$8j~XFGGEwke#@d!3G=;{ zWnk+yX-5w^FqO6ZlvQJ7F5EBr)DWhL#}$P{Mq*tuyT&DF?_F>+r8m1q6PV~5Db(S%lJ9izIw3LYM%=Ul^2Jyiu zB06{>GwBC@G4s0<-;v29=){foUUDBNj{K;c)EYiA-!GY%_c`YIo8%K-2+uQw(_G_P z1C-$O0C>kkLuSwk3W9VyYo|u5t>>TQio1W(55GhJOAm#y^paJq3+8C{UIT}5&>io! z?RP%sir*R`JU2I3PiXyytgzABksm`ou`TUe6*J75FH`Kt3Hr;Z_t&GvOg4_r;ViGO ziFW5F1-#KJhlU#Rtx9T!TgExBw>=21P7eht-R<%aJtqjM1&(IFb|o zv^rzy$I`JnFrvb~nF*n6JCfhEPYdW_dHJTT<|f{mUwj23iC0h%pK(sP?GUFI76K)i zHi2K*7KW|mi`9B6%>g`zVj1*ebr4AW_2}loDBtLE3`!P+Ec^+qJpq4we7f<=Mja4K z1B6-UxAn>3m8XLy(S7H%Z4GDX2R`rv zWBoE)o}lG>g{GcUtkSInn>z#Ib?UU&~g)Z%`DShqYzb7x-wx&j^IPG<}%_oz_40nAxilK7t&X<28WEitpV&@m<~EZexhE&I{*Kn&>sg5>)F;zM&pDfL zY}*J$BzQxbnF?nA0SwU~{`CB%l5TnF4*aZ;zDsq*-M&&2WY-<^pI?W?+!hg%29l)`}P0{6htk_JRVBS0w1KyuurY6`-4J zql#ucRM}*27 z4UBd_zA`)7p-i)&Dn6;wV_oCD;EmCSfa#CxWV?xTez9tE(brFT5l1gHtyg7_eTzub zRnZqXDJ>tGq1TacnrR|Gjgj|)*bj?~W)IDiZ94%c(#J3v6cXP@+t8BWVB4;YcUBwZ zLdu>=0W-7sOSu~pjrS2FrMJ*K5D6zh&*=;eYz11TqlPDw#b6{G!o_d6*(Dz?VKM~^ z9o$Gp3>O|qPI1D&7*tis!24|8^&`Q~ZRTL^>`jt~zcMhyKzlc&nmz##2_X(<8elO}d<**axAM|a{)y*zfe6bJQ* zdp9sm^{y3PDQ6bSHZKr*@#1CM`=DJeO-15?GgXdNVtPY9(%QlmqFP%6NY#mUh|KX? zT)#>x-EgQpckB8v;~B;8Eh^4KkdC&R8-p%Hi}{EHf-6L zK%x>9L6VB(pb|usEJ$nw6a@j19Gb?2NK{Zzk)R~W0+OSFpyZ4|gCv_KN^GFht+g7@ zIb;0y>Au{T-?7IQn_hFxS+iz^uWDAc&OV6X0}U{QmDET2*T?yGPDsP(tIQ1E6#NSm zdw=xue=tJ?VU2#v#~mpkeL?9G8Np)A1xdYS1ZKn+96rnZ?aKoUVR)f(^=96P^=Q}V zy|OE1jv|SpFz8REKXZPWv1@tP^$G|(K%4ftGy6v2YK@}=8X`bCP+J2K4N9%8UYBoa zebH$$lt9M2h70vfG z@5)RI%^N^nBj1@%flA9wUvKRc*_Teha17^Ng2~+B+F0SEfvilpuV`dq^7`$e#v7*q z72P>@&#$7uy-SvwcQ>|@x*)gA(cY6hr!?_x6Z_H_Q*`CA>}Eg@Tzs(}IdbME?N0dO z%l1ZDEhINENZ4h@RDs?TS>fu!A1}RcI0;C8wc91Qb#%=YtvBiKQWwS*iFXuRBC{EH z+uGPntj>?ZJv^}mAIyoCc{Mjb=>Q1U3bjEw+9WKlQFe_wD zY{X&w^{Q{X0y)6Rc2PBNrIQ9zwd1>?TRDXJfnDGkxbl7CBdKaHxVV2}A-sRg+wb)e zw2|G9u5`m4T|sE_mON+t?|=QF+!Cb|I{3Sxcd0Iz9z`{EVZ(qWug^r%d`3$uI~Q8! z3Bl+4Vie88<2UFIk}mb7LYs@-ZXwcH9C@HBR? z$F3`TT%ZLb?~&&B@{HzoKAM5u#n(bc8A<)K6PZV}nImxiRUP)*c27l*PDx?dH8sSD zb5&Y5K^xe2l#0l@$eNt}bT(Z-r*NGat0LuADN$FV&djA>?H}I-UGS%y z+|2LZ4NB3bS!6_Icjtbov(d~uepp<&V6wA)hUD7yfI1r)U1W4`0R&>g(niot>N;F5 z4SSlJff#tNd?0TiWkUBvtUODyBA!g_{MNDa@7=A-P1*Wpx62WAI}_t!SKskqX__8) zM)pP_z%1+%t1@6p5rUd|7Qgo+SS%cBg!0u1OkjoSAedBFgI`-n&CvI|ZC~XV3WuXZ z*;nd2E?&M2ed-M#T^v8)BdQhC?bMdCYi>c2eLUWLdNuZ=L-=Ca~UNHBtHKV{RBNG$cj1;P8S(FgbLwQ}8>plrdecoD(f z%VPTMC`LR&^?L<1O!BR=;<%;tB5SpE5z`Iqz<}$Q3I(RV&R-D0eAGKtwWbR_RfJ5l zGn?aNe7;TjndhJFNNv=)`AP>XX&=FEfx$!|hUoAXb-OQO9LvKm!?*}in1498a=NS!{F)dXK3&x%YRtGjhrDJa5?5vb_nu!X5Ea*p*y=&Hg#xWX1$Kd*E(=?!Jj>Nn9fDb0{6U&aD3JDU_n8c4C!Mk--tWQ&) zEG#c}eVtRhGA{H&)Cb?GF{BX@=d=6@c@FH#rP+rP3rh=~)2|kvzkGW2=8qhM`;xk& zLsSEg0nc!DBm1{UB~8-EO$y6v+aql>zgO)2UO7ZVq#c6l0&MtJOlj?6QBjp?kCDUM zZa1gS`nO_}jbN#qq}@fLI9u)C*>$F8Yp3`=RXF4bepg0I1^aS$LqwAH5d9ozi|Zs2 zJ3!>4_z?&8N>xhf9yLnZ`R#k;6g7|Q&!%9Z87bcfx`al@kpkl0LMm@>aCqE3DK~NC@;dEQR$r;Xj8o-sUJvBj+fCIv zfU`Y$x5uF*ELz0KP^9m4v_eyMQ}=O!PH3xf=vu;p1V8rXZ>uoEV$W!&U|+Igoep!+b121 zV)7xDJKQT(HNkcJxLAKf1pnbMA#a(GvulsDAHJ0(oLFSte|lw9YS+3h&_?GwBckpf z12q8D)CE73e_w}Ys9W@}@7TFh&(iYexc1h8)<-*LT0iKd)@2xEoB*H(HbwUq) z&|4$1wlWg}mWQ=-g!>)ldxxuRwDU8->5wt}yZ9<~YVx99Tx7fIb%>@C;g_9&otxxd z&mDXvu7+SA8HJ*{9S1`X8FQ3LZD$0Z}G;Uy|LH%xqcR(p?5ve1E?bw4%Z-yK#moO|46-Gk-j z8z=iJg86R&vY=(O{XNcHL8F~wyvuFEayI@5_+kFl{$@EnayUF-p$+WuK4k|n7@kz- zbI3{b`lAO7-t1ZrHaF{5S5+;k*-HbkSXx-WFod57k}9>XqrE*ZnyAQuC1xEPXaWVw zuQ4uUBhuhUnQ$(6k2e&tE9x?e*KU$EtQ=T#(dLMdm>Q%{5U$%J5nqnE(1@ZUj}-|z z6RtvfT}GoFmHaAuHZn!PwT?Oc{^->zfZ@}^6nXsH`w*LH*9yOvtg zG?iKxzSh6pnYYyr!rzmfc^QMA*Fq5QCP`(~C;+T3<@t>a56AaO&zD$xXWRvjvR6I+ zSY!39s;a6@!hf@UUtX?!g}mED^|hJ1dGzJRTlsnPH@8pG-oB(1Kkeyh(T;%Rk2E;< zdo!P0ysYtpf9)?DF3pRL6$BsMAGz04!4L2H;QVD8J1Ewjq-y<_@#gDbf($E#kIBxC z&m^aa#Ef}Y_&!>Q;J1IXoPNr}j9V^dx7ZF^?>^|9#eL<~2OY=^kR>mRdf*5b(7>DKdzuH9-sOV3I-D~R}&NjV!^>TaNC zg$7B&N!W`bQy=w*xVONe{LJao3w8ig^dG}dPysLLvzIRwnsh^2rjY;`y55SO09B+x zJ^*awbIZ$}uR3g(KscTr#g(R}AE(h|cls{=3sW zLo<{J61c^#r4eTVEu=~PQgs-t(!x-sb+-g8cN9P>0)#FRhp@DuYo;%Mie%P<$WcZ5 z%0360b*$pc)of(apT7s(>aU&gp8rNq^XS=rz-7hk2-XBv`~38VD%U&mpM10IKF!2< zqp6iF*Of+N6et0Hma-Vqh{sCn=2TLH&YjCIbp5b(`=K|daiW)e`y=vF#&SvuQ})FD z$arA8V%M7w?dCKH;fG|n;v(MgYAnbp&CiA8ICbl-G#j4!{rk7z8%x$5c@(n8-0hR) z#SQiKoe^FQ{2E0=9g=mq0ihfS$`z!*n(>dl)c6`VSmky@xv>_$qcS2EO4_^pUS*|- zunVu4WyVb_o%=?h$I*qQPha&I^eL+iqbp^R9bO#8(qDa#63&2-@U!1JK~sg2i7+Hn~n6YOo$B zj;9HArL%EKVuY?_2@>1MO>`H(q4iynlWM;gTZ9OaV)H}9U4P}^{3ZJB4ImB~2Ul~8 zQm0niM!`R)955#gugz`Q3K*kIW#wTJk;@TdGc)6_Km7HmB1U`us`{v^tk1M9A>u0nRxokJk?96daAi^|HzJdq&L^EYqa9c{|-F!@lL&n}tK z0A;dtpQY|+@u1 z8#>Yo*Z<@K^lSdZA=wI%azMx&?C_N@Iu-+%Jq=I3T56womTr)&7q)})GGF3{=`pkE zM&hZ6q^Boq9eDD7re-G33L9l5EgW!B^0zGNFYq8KQp=}V1^Oe#33I6+ObQ(bQXtB- zY)L1_R^|Y7I@wuen3_oYMw1H(l1~N;T(Ev`5@bD1FO}L)bw$B9APeTe8cCze{^mf- zF(69N_6?`;{I_o<(HGP{d3t-FR1Mz?X>=3)VpSao1RI~(?N>nYC1U*4L&_RuvLJC4v43=j8MS+9$TM+I>wBoGZ* zSdDJxYTi(mOd9TOBO313@&e}cuNOsE06Z+1^E{u8Bk&V*`0AjMxsb+AIUJH-dgu7` zMj~q)q`;4jUmwV8^cQ}0>1Y-vAB9?YLJsAGgj~`vP96h2*acqQl}alaJn6!mW@XF& zVC8G2bPxR-2y|26IorM&7od4)RRyQfer(P!9WS?HQ^gIIR2;`j9^lLC|9JJ@(ls&o z-0(QVo+SDm1V@ZmC=zcVUj@_EscI#TpZM$(*5(WcDWizYLrk`lOrL}>Qh*{wWyPkL z9|1e!*jF?8iLas`69j)dmF4I2-=aX%hp+SX(>;P@;D-k)YG^5m z8H<=kTn1>|*`!s|m>xHPCyQ#dzmqZ6C%H{xGP-9>zYX8HIq^l?t|fbju`iHS_gX7f zJ`46wcAy=~u>y>Oq+&!Kd$-h?$On<%7o(-1)4KA{W1jLOP&7m^&DXsUIdyWQwytBn zBV-i5Rr$TJpm!nAS@YzUN5hYL;=7#WR&Gvybt! zDZ=xo{3t71!Ph)oXI~e_8Oe_o|24{~nXE+b%TG5iisDbZ)o|2%q~tB)BzXT^d3+_6 zRdiG@)6b`_ zuuErFy*-5W^mPu*|-NQMYen$>s^;LIRWj%k$UIEg99|Ng|;qp(a7M|L5M z;$=`&SZa=Vv5@+z6(^kr+yWYWqKSm@@EWWN<1*^unEk%E8WF!p!UI*C20DvYxSYfgTTM7(u!%OP0cHj;AzLYm*| z>eT13vWAeQ$Nz1wRom)uo}0aVUjPF0Mi!H9kdxlpY8e|E)&_1JV51l9QC)<~REq!~fxVIXX2gCjWN5r>g^UL{q8cJ@s)njJnvbxOvQ# zbwXUm%ZsDxq#B&|CX+Mg^%bcmNM?&Y)@D!olfw)^!e6yT0g- z0_T|XZWHdA4nEmr%k;= ztmy#lf-T~4KgQnnU7zAW5`C5TZbX>+HMF&>C>q6?peJ{tfFsjS_YG)GAPj8Y`wt$V zcqGi^>8?LvsoWp8!DU+6yyXWgTTP3ToL`U27mM$-QV2bGPp)0tc2o%JRR0e+yDbII zG?Rb%AFccbJS|8VsfWbchK7a->FNVdfL zWaU$)dULH2r>#zqrM$cxP*1_BXJQOmIJxd-^56C9GIzRpVI`VN&c7i@1V1rg1pqvc zPa(5m@;BW`%a(!*U{ku?h~*2>;Eg*Ujt}ow-ud%kB4gtI9B-4v*jb~OA<7ScPh#eF z^bytjjMSQe3*O$PZ7dfLKtcI3d^Qw5{LY}L4*v#4lew=m?gR)5F>KDCYDg_Y7FZpc z4SwzKKTq^-JRxHyIB|UH&y1)3%p(`^S?kq|wT+Q%NPv#vVi5B8#uVD0Q4Gjz zhyNBxBq`a0$nTj112ztEXmJNW6{p*6n`@Hw9H{{Y_+K^ScL~oMoQPV+@sIM*F`4#n zWxxo;-h zh{^0=m*7;snc!4KdAUKQuh+&`4m0j0G3i`@-+}`MtgpARHyRrcpMkAxW7+xFf5+Xp z1L5C)L0el&_S{>croX5)8xs-4Z!G!p^G*$KX>|t4l!+UjUh>sjnEQiVI*fPdly1NR z9LQyjf#~~#aMQc{@uNrIkQ903>JB7XZ_aN+IfzLBr{rxW1AE<(s?D+TlaZ@0Xtq&& z{5+%J6CknHFY#j}o!J!;6fcyoo_? zCP#mGy}?HVN!iUo^-wu*KMTtdjn@*^0iSLm-+O*=!~SrrMwH~HZSNAc2U)17sJNdU z%D2^i(1CnO@bX59C8?)S3)yum+gG@OA!*-zT6UYxtv+J-D7DpaDhs#HA4^-@iS85tk551`!3IZkxnK5des3r?*7$yWR`;Xe#HLZWS!JQuy`Oqn3U70V9sSaa)Q$ZS zBtjiAA%pjpuDcTqg2TeV(?P!Ac#p9L@t1f5=)vGT-)JzOjOb9U6Rm-@1;jdRed1O8t?Pm?0T#i1+y#=ef0DW{EO54 zM|QAkNR|5s`u{6CeDtjPr;md5Xa8-rVPoO4<#fIK>x~!lo(HlI5-!{~3y}Q#{pokB zLf;Q3m3+VQuTbDq|ADk^5lpcUXOjk%)?F_@UQ)PHKwenOd@(-Tr>#IP${^hpSvRdB zY`UOhYHG^cbD)(q+@CuD%A<0C%HefIE(3jepamrJ-})oG633S|g{uuYq^8#(}5VEFJ^4G|Bey?;;KbLcwI zs{S{8)qfbR*-`z0FJb%6w`4sM(N%WX4jE?$GSJ@6!NEA!9bcf*wctY#l1kl3sj}V2 z4rm}nbHtw|N~dkiR_R@EWF`J8Qml`SRr*Mlkc=Lul`H{tL&bxP7f# z9zhX~MRMB|!k__YY29kJNGQ!AdQEt z@v+n%3y;)NuHNC{tMWo3c!JE4U8^767qG%P{h9ccu3%-2%s+UJLq zDW@u`yZmC~sWlf^-;=wrY1{Z;GypkR;YV>p`Q=W1jcDPtap{e; zt}^rPZ^|o-=RvO}umj`1WiSUEUb!vnP`UUhi2ZYtr%#WC>!)=Z5*ogLN6Ti0{EhHG zQ;?Q2^X&{^udgA8PVv4YV2P}vW^7$uUCE*lgR^X9kf;?E^iSZ#Jz5yV63ZShqjyTx z(6$K5J3_jiS|~H`Z}%Z3&zY>yCKAKLfFJoU!ZBm}7?gwr^VoLPT3x`Hn{&Cjxq&(f z;hp=3ST=#EGqt^_8WLzlML)9eplb_b-*Ov7%Wlv2-T!Ns71VXU_#SLa|4)piRbK^B zl9mRuQC%E#T(=HaIP(@cKLMz?Q~uQ1)ujr0wEa3$V(&nS%VOPQZtt6oZ)8q=LKO5i z1{rNoGV1Jw`RJOP$HHk8?5T(xv_Q7^f&pWD6Y*Dj!~ZL?tJ!p50r|EqVZcZ=j%71Z zt}-y-15~+K#{4~T?PlJO+aEuER8jc~>d*%+fnR%ELs?t&QNRs)5teY&3ER z(ITb?v$C?N&H0}5BNtLT6yi*CtyBlR2(i>==zaX|=FOWE^JdUWWxOGpB&QCn9B;m~ zr6L|m;IDXRmz0#W3~5H68_mtv9kphASF+uJEz)>?wl%L z!sEAPqhSZ;^W*WobH&8`l@L5;&Pz2+%EBr1($S7N&axR@9MCDHwQWX1d&tc9 zFkUYD<)+<>@)@*+K7YF(Wa{JEJspERqb0U+Ue}dfI%iJv9qpR!o>KT{$!~rAQk>6l zR|H_(nHPD%%r3|4KP40G!-Aej3Y5je|5dBv7k0?~3Wq#7 zs67s5ZCiW$Ud?FH8MjA>LGxP=irq)MA~ix1e=N2r@j(4s?b49@dt1N!tXNz5;3IWh_~v_y4AFONoVI&_s81BjQ9}Nczby4%t@>ce*IvDxa%0ZCS;r0rQTz3*Y@|}oFAkTLmZqTt3P3<73KcGivHsk( zDVL7!BfN3Zl3y4DOD`aH@>_xP@8P;SB4*9qPxbLPeY?HcJDHejx1onfb){2ZTfqGD z88B{s!aAklQQmi_b}LYYhqQ`$C-9|`Su8BMF6OfAH^MZFL0qs=8T!ofv^^-o(uWR) z#>R(0>uQwlX48!l!^9~$_Rh6#6}|_Ng!Zb6Bdjgg<*W?*;&*RiN_dIdJvu5}TwEH_ zA1;F)_XNA-R6BkM!ZUR~s+B-Nj@w9yGRN(6j zZc#kcLh-upcLfsV5!I#x%z^L%$?h`I1)SXJPA=f zmM<@YayDyMh3|%_WfZe(z9qj$ug2CofLcFnB$IQVj z2$4lin;;csW)PeTC1>2<3kAEDo+RqQkOo4Ur7#>*kh(H(Hj{WcV{Z48$|i(`g{`4* z6=TlV)X;UaWI~~lT>D*U4Jn2ytQO==fc<4+8)R_XR*e%L7~s)UHyQ)Mb&9}nOgxAB zN6Q$C(4KCGu!=z?F(M*n*a8?kqci!mGB58Wcrp6z_M1(ihQX7lsHpdGX2MCfUrmZq zpxpX=s^>Uy0Xi@FwU5JYz2`$2>b_pU5=?IA@x^*`=OHeo@Ib`$P-a2AKc=9B#Kc7Y zo>$V&R-jn&`Fl1`EGz`K)XYDgE9sh&!qZZFZ>?u;6%vZmXXV zTTbq65bV-3hOxIbc>=NczkH%3Dsu13C=3n^d~zkSP@41;>!Gq(5M5) z%G|#`jre1VexGkSFR5z@)-TUhkqcLqF!XcfE8l~iC+=I14vCSCtL6?}f-;mCwtSBn z%DK-9!hZXvx+`^`LSc6QTusy=*t}!n-tdSpeRYPrj1XMsGR$begppd0gHd8&ui z!4U@DdxAcz1RCp@mi#F#rKu?iXDhxuWh5=6bdi__^!sw!U_jmt zB|AI0ma4&ZyEgkEwo12u)KA@L30+f9eOFj2&p6QxA#zn+{n}?4WDgv!(zR4nLU@!a zTbxIaT?z~gEG#Svw$T6jJIh}BH7M@s0;BWOG8G#FVdL>5h`g-68Qn0>%gcKpjbcAD zGpFXb_$#Y6%E&;)%j*^`q)Q(m=_7t*)7fs^Xne_X<;oQheB%83GLFK^1D2=AoJG#( z32W&Z{R9kodVYIdx{_@nJ9&PeRxpn8EAQ(hSfGMQc?=8ma$!L*n5iMI1$2)VQulNN zHmsp?z5U>5utRY-r1FI*pn`1YO{@~vYb;ooiJzwN1T~efE*UgVFc0+7;-W)wE3Xi$ zXZxHU!<5a^eLSxskLp}N9}U<91TpdbnXm@Cjqpn6cXc1m{9jEyqu(0&fEPcV4`b_a z1NmW%_HRh=-&QsNra>~m70<3WMAbw`z1eGIu}ad2j(B;fY?|F?X7N*CU@;tTZ%&t) z7pyhEF2`8e;g?pc&xTr;W)I)QzwW-esAdnU9ueXGx*Dj9p!{G5@jv3#vU6=JhgS9M zV)957#*9^IwTOPmVXpiD3(H((nM5`{e69v(L33hZadx?KBJocyK(|p#@WMj-Os%xp z6uaZe@PPxYvGgv)o`?{I1*;|Jk}({xJ*wiZi0vP8gNM>O?7X7%hG(ek=alpEf>T|A zk;Q&}yY^gU`S?%{Ufz*>%xanRN^#^i1=1+4SgBcN)Y`PX@EX=sMP zh>+aQ}UL2#_z^x>Y=9{b?SD$uhK%nw^O!SPtrGC z=vE~2aFVBScg_+9NLwC%or~}LaM@*lB6=e87|t7`xM3>_UL3}{wQU$2#-9<#f{87R zan|yniWN5oqHbUkt9`S1szMq^W@Ys{N`#JX4p{$)Se1CiHKzX%|!0@T@%-C1GW{krq08YVKH-|bU$0( z%(0%@Y5ZiOov#q%bpMYDu&qUj?u#hoKX}_+|A!y5`}sj{_Pd{ijr8r<)LD7vTU73k< zrt^znKfm=Fc~-WNp^O+n{v#-g!LtiS6@a7=3kKlH zB>o!wJ5_ys{qm*eJ-N9G(XKM$f~RiG91_d)YmdH+n9AU~G~+}-(lPD7I#t>PGJORG zJo_ro-1t(qS$<77L_Ut)m9a1j{b>GvRm#*0Q@i!W|cfafC_ zy>NnTnm-1;ERR*H5~n2Vv6NlT2y}jt#*i>AI05ukZDjZC5Uyixv>m^|hQ3(L-rH9k zWPr%|^bATG#C|V+ibLRKCV@MIIi7G$vGr&$x;XwJbFpvd@$+pLkWf>YuQ#6`$=3!E zs}XO`S=Je)e*MuN;0M72j8N@!Wg}K9xGbpoMV?*t0{1X<@_2!6#reyAW?%dkt!m$t zC^XN1o;=34_?T8UpV|_~;ZuRL$RXg!`3>6*79T4)-^d}9Zm+<~to|NN^uFs5PPpi$ z)D>w@rdX*QpG(ada#p!EOQ`I33UaeISyaj~C3{!aib@s`-;07`7oI)~ypfFRASS_k z0-8}O;Bq5=I;1j#XZ2x@J4sE2)AfS&bTQT|+(o`Co3{K?n@o)Fk0m z*QZGET%Y%`TJ8`g$J!2KBx}Za2U}iCnQT8@_Xa-|?57l73F-cJKU^Hox6Kj0)y;-U zI(=O6R*cnBx3;#f>H(Fp6U8my#6Vx8aNrYlKnK7%6gJ8Z>F(}EVipn|9w)-_Q{J@5 zrm`~a;IekAhr*n6T4s+7uk4mST2cp5k?^v_MRw4l-{xQNB?Zgqhc44`%GU=2H zVPvQ!I6t*^bj$nelY45a;$x>$)UK~ZY4-N?^r!=)0(gPg$W=YCsX<>Dn+rec@LorQ z8pvKVSu+|k`a48@vnjk<$OED$4n6uzy*H!=JrhwxmWgrvZ%0CxJ(Z)8PhJQc9W@6h zw)(>{lu0dP20TYYSy)gZvWan2#BGEPGwa1%oRF(H{xrszYIl zuz{9srWGhEGZBLd4ga&y9~eCTysoL0WH<-^`PkmkadzGfIjqVZL72RC4k2&jP0WlpZ95V94HiIjL92@=cx-%{nIpO`%6Jd7RsyQ{Z!!jS zr^T#C`bP*UDJh6FR16%#lJJRXX}5wU z7*jGJzNHD8dSU^Akr6jwD1I*0v?=KJrM_=2@fnp0xOLl7u z<1B3@=d95E*x2ICs$vE!r2v{|$-S-<-*n?IBtEae*v8gG zaK2z(L_>0ux{9AMIk5RoWdlHDfd5MHx^^IIWr$S=TYzCYOsMt=F1cw>?Q$N_RIz(Mo4L)aeaNAl8Z2(<N>ch4fPVoCy^ zT$Bj#CrtAdfGa03mGTI%;VSx|ih&efC$OK-ipISE3#=W$~j7g8mR(da zj94qn*d>9EzCL!A*oHyVb=VKK;EnfO($v&c>5V}?D*N+li0g}az#YzbH1hk6!J0aI z&EbHuAOTn;KJ=7xW7unG8}5yNv|`i9K)Qz+uwxe(t+)N(fe;A`Y!>x~CYK-qUonpS zyYK&vB3o~Wfp?QTC-~4wFqRgS{y%}^2-MPLO1KHZ+`vHKT>-=psQ%61Y4|t_iQG!y zXcWfV<2K#{lK&ZWp8afrXj^l}68G0Ej5qMT%MV5ZjA&RoV57s{U(xVgkXjE#VITdW zp&G(h`^{WjTxeHW5q`s=7(0`W4g}FnOiXysAtu{z3&wz#9lA)6#n%RxH?=U?n^h2L5MTW2_PV9Bh#LFMt*y+#8R6ygU9quoa1M z>s&|!Gz@B5-s9BH1kr@PnPZLxaZ-5{F*A4hTgf23| zhK-K=2=O}DKIG3IK>$Dge;795p<~H-)P-a{#4~O@)pDuyjRdihJljCu6Q)F4O=>vQ zedc!WQ+lR5Xwakv#JgrRVc6|cMHv@cJUgsI2P9Sii@3pzLyF8vj}cUdU{&v})Yy?z z@oS9)%RA_rs{`{Oy!F+iaxoS{hVaypTm&da|7@rlwtU5IciS;IY&q z-&&deF`uT574jpM4ITIhLHU*9^~sFU;?b~RD5_rP-tWK)q08LSFuB_8N~@n%`+6!5 zYAaD)s}{?tEB(&Hk63GU)wvGH&6T?V!lRgS>D6AJnF1rqGKTIZ|GRq2mUMy`ZcUTY zp+wc^^qzPt0g+fXDMvGdD_3eVjq?%N53J7@-LSk)+pP~&8U*=Ma+N^wx>GIk9ZvWI2V!?! z&NeL)1>((p-L#$a--3by2|vo}OBt6NZ(Q3ooas~&^Ter%%WvcJ0|ViBLYUR!^qDhi zun8d?Qldw-<2Ze0OKjixtrMN6vWoV+FQl*M(1XClc&Ui>M%L-xcPmwTB#>_;JtI4) zDMpHUQgIHZakbpjxiMBw3N-8Em*UsXU5Zy!2$T8svUqhQc)KeGQGH{`9tM=eI91B9 zvXlhYbGf#j{VRqP$QM?xs*+t^E)R&;UHWP`{biMwHeK=eJ?1em;bOT75D#t;x%wfY zg@haB7^scJMPhi!XXTm6_ihBsW{k$IFZCFHp>p z6ShfLSC>Uwan0t0Y2gXlIEDso5U0=dU_b9T24_hg%Ed4KY6{lZk`Y+xwGI~)77mWa z_{ku0p%~sZg7+8-6~huW=POASV#r2|{3?c#t%g58%5@&CMZO=Yttg|o_D#DMTIh~K z+sGi`tYgUbc&?2@`Jo1}aE~FZRCeY1WR~69j1!InF|^G@Ss~%Tc`_}vR-%q`A8cXp zKOASieqmPPWX1S8m%|Z77_$~6{pf4^>>qY<^P_bT9ff2AGnXdG`QKld>!1(INWz0X zLGb6Ltec(RbjszJkwhNq%>lO_bATUVp0yx=4wlVT`jo>?R`pJh=W#6S!i$`d!}Byg<1Yz5HLLn zO6s7=BqL~1$gxz$1$AlQ8YSw+2zcNv7sx9xaRlO{FA3)#I@k>SBQ?-E$_dt#l*jA{6~iIVNyo|YLhNTY>}oSc^M3g9Q7%v7aE-p$?F<}n#rSu;g(;9A1T z#4n6y7moyqG($ybLW*{LoD#0l$)?lBUQ!o zklr$5-`7DYc5y>St(3#OfGdu)Yl?;D;$?jnqhs1_EM48yD-NY}mXOhabtaVFmD z*DD409jSV0tAnJdL(q*URJQ zd(ln$3R+ozFtT`QyJ4r?itgjoW^<}BDMxDd)q#4-h(2rhz z-8ol|F!H6B;&1C*py4M1P14sYG`l^RW5YorTI5Jv|NdMW1ROalSJcv1SF*K-Rfc4#(mnI7Hbj$<(o^bFv`%9vn=EA;=z4G6Ko0wB8mzQrPbptj>cy z?LOdKXF(v+)+#_2V=WdR?$Zhc0m9v)054e+W8?Jvc~8Q=I}<|v%3!O@oh#7NbK^9)UKg59__N}>%uwla;&pT!d@u*8IhV&_pSuriwI zl*dYxBRI47gn}uVpb5GM1di@8`yR$+LT;gdZYE*56*V%_h#jey7Y3H=nz-EC-jOXwp3U;Zx3m=2%qzvUkND|GiSm|4>5%Xg~bVB*U zcVX(bc`W3ZY2^^&uq!_(^N>Uq;2SDh;Wq6-oFOS1oX0i~!m@pj;h;%05-A_DZ+a~$ z>_;aLseg^iV0BfRooU!*zV2-i4~mmAzeb4XA;bg7DCtHtaRm6VmKSxH7)grFz?b)1 z`uhiGsb1unqQyFMu37A%`gSr^1~Dbqmx%M@VmKMvQYysg2o}qT<~O_hO#rb19`pEl zzJWQ;=Z0f%2a~{nbd1TS4w97CClcqMX#4US=2%o*UUcv2vF)U;2WIoVkvJG zZOt)TpG;7E!FH{hBhqBt=>yvq8&{UgCM-HE9j08s^WkGS{gxcAbMD+1Qr$=j_@bK6 zk9HwAnlo50b&%e_zi80go&sDP0`dq_W>5_e76UtO*$8)_2ZO^Zw$5^2)P5;`1ksnw zlcg?%<|dvT^RhDsAtf)TeBmNUgCQDNSR#8AmRcccyzk((1w;l)15a;v4P97R*c93i z5+%Wo=UeIHg)K7^bBftTaDB!I(_&Auz4a|ZV4kRr^Hz3K{hDBO2mFpU2H5uDpHdGO zW}B9UbMF6wY<>xvtuaPQ425k5K$1ICmwW2O{N{rpmv$ab*~w~(c%{B)=^Jx9=7`nK%bQ*D>$T@{ml5B)Q@!yDKJIXab(P>)pRXJQT^FT9 zTkokFBrGiANfAQ_^KUeL=gBcCNI&cnwiWS$7MtZDnE>pl!d~V|DZEnrtWSe>tgIxC z0*1_zj5?-eD!XjnkD%GH<4skVm$_*fS<(6D;u4Rh^Ixut zd!Lr{5gY~PdKg%&bBYs0TnHk&6sbh*I&Iu~he)$q{32qJxP=9aRZ7Rx6&K~dqQ9^Wh9y$wUl>^&VusUVXbs_u5tn$f86?9W!K8xG31nhH&ZHT3xeFWc z4pBt3U0e1Yy%dP70XK^{$pFNQ@XE@i(P?w^%DPg>JRb=;)f@;8&j~*;F1{lBSF<*Y zU!42rcbOTEy6ik#LQn(6O)HqaN3~4WOGD1)q7rU+7pC`JVpRhOg6BE6>bN{YM#Gi- z>U%gv5!)8=J5^jACGXT6Fj|s^A>x9aV0YHys}^45fbsOwI_$}}$Ya2rh}RMgGR@Eh z)*($Aa2W;ucw!*bWq%n%oitjk1B;2($9#nbNJelDjyg4uC=(iWh^`5FlgT14r^W?>z@{BWQ0o_ucv<^UuP4_14(qnV7cgXsDbu;P(SFs0Nw=z5|dR zIr)e?nFti*#!==`7Xh(gPnegUMg;T`%vAYeb8upqtk4;!LC#}u?tG>X4dNgDTBUE| zq&J@N`Tb%0t-Vk5Y@Q!)+jIM&0JG}dv9z}Dc`vp++VX_&QD|q-`xjAL@=rW}{`le1 zC!Bw0a7iETyr{yRJ@l!{uuADy-5iPhi$1rU&NYDVSuV+*^1-N+$dz+7fHfm2d=icW z#cYbco=YTB9lp$C6zbN^Lx3SL@Fu{tEPQIa8|$GH86Y7@Fw1xK_mMqZvilVj6u@rc zi9DtqCgn8vHBmkMT~?OE;Zm*Fr;oeO4N_BGjEfx2-$*+{whG*N+j~A>H-d?)LCHaR zuLXX{zZ->jKq4_0Wc4Dq76Jn&W@p2)v$J19iWuCd5LsC8n-xjVGA-KUd-EskC1UJB zj0E`$x{En4Pj*dAPjjyR{Pc`Z-3nU6Ru%rNdIrVLrQN5mBHpVaj>Z`yClFlkva@G1WT0zl$V`8c`d8e@I=Bi}0C4K+>FtHU zrSoKGTCvySjobZ&BFK3F`V7gZ!gp!`4N5F4ld~xIM6zt!dVARrR0YW6xiW2RR_-Z* zus-zV1kVyjr@epwewEb-LUw*GkO9C{?UW7A1_xGAdwP3UQ%k_d<@TH%tnhgd_a(d# zOI>$6V_h3^HoOWZKmF;!_ATK(IT*U;lruOhnIAsRaT)}(TO47_24}yir zW7kguHn$IfA0(`6RbbL%q z+8K`lS_$u^3Ahg(49$KKaRzA%HB>Swv7lhN zEC;KlrS-9>NZr=f_JnaBKjh2t0x{t)y_x8P-KIi u1fnqx_~~gNinRaV5C1Pg{(oWy%BEJ;gDD?nl9BSYOd6_MD%s~O@BcqmWtBq! literal 0 HcmV?d00001 diff --git a/rfcs/assets/0062/partition_rules.png b/rfcs/assets/0062/partition_rules.png new file mode 100644 index 0000000000000000000000000000000000000000..2efd15c00c7bb900ffbebb2bf67663a7508785a5 GIT binary patch literal 188360 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

E7=Q#lvif#B40f5&F21` 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 V0Gb^8WVG&OI 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 NM=?k{{Bd>{^MHtOKs{mBv* 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�AF3$tM=U0fiNi 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 literal 0 HcmV?d00001 diff --git a/rfcs/assets/0062/search_graph.png b/rfcs/assets/0062/search_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..50ac85c11296ef09c144276446dbb4d7a1d0af64 GIT binary patch literal 191885 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 AUjP6A literal 0 HcmV?d00001