U Jc3@sddlmZmZddlmZddlZddlmZddlm Z ddl m Z ddl m mZddlmZmZmZmZddlZdd gZeeZe d d eGd d d Ze d d Gd ddZdS)) dataclassfield) defaultdictN)Graph)Node) compatibility)DictListSetAnySubgraphMatcher InternalMatchF)Zis_backward_compatiblec@sheZdZUeeed<eedZe eefed<ee dZ eeed<ee dZ eeed<ddZ dS) r anchors)default_factory nodes_mapplaceholder_nodesreturning_nodescCs$t|j|j|j|jdS)N)rrrr)r rrcopyrrselfrG/tmp/pip-unpacked-wheel-gikjz4vx/torch/fx/passes/utils/matcher_utils.py__copy__szInternalMatch.__copy__N)__name__ __module__ __qualname__r r__annotations__rdictrrlistrrrrrrrr s  c@seZdZdeeeeddddZeeeddd Zeeefed d d Z e e e e d ddZ e e e edddZeee edddZee e dddZdS)r FTN)pattern match_outputmatch_placeholderremove_overlapping_matchesreturncCs||_||_||_||_t|jdkr.td|jD]$}|jdkr4t|jdks4t dq4dd|jD|_ t t t |j}|j|_g|_|r|g|_ndd|jD|_dS) al Args: pattern: the targeted matching pattern, represented in fx.Graph. match_output: If True, output node in the pattern graph will be treated as a part of the targeted pattern. If False, output node is ignored during match. match_placeholder: If True, placeholder node in the pattern graph will be treated as a part of the targeted pattern. If False, placeholder nodes will be used a wildcard. remove_overlapping_matches: If True, in the case of overlapping matches, only the first match will be returned. rz;SubgraphMatcher cannot be initialized with an empty patternoutputzDSubgraphMatcher cannot be initialized with an pattern with dead codecSsg|]}|jdkr|qS) placeholderop.0nrrr Bs z,SubgraphMatcher.__init__..cSsg|]}t|jdkr|qS))lenusersr(rrrr+MsN)rr r!r"r-nodes ValueErrorr'r.AssertionErrorpattern_placeholder_nodesnextiterreversedZall_input_nodespattern_returning_nodespattern_anchors)rrr r!r"nodeZ output_noderrr__init__$s$   zSubgraphMatcher.__init__)pngnr#cCsH|js|jdkrdS|j|jkrD|jdks4|jdkr8dS|j|jkSdS)Nr%Tr$F)r!r'target)rr:r;rrr_nodes_are_equalOs  z SubgraphMatcher._nodes_are_equal)rr#cCs\dd|D}|D]<\}}|jdkr.q||jkr:q|jD]}||kr@dSq@qdS)NcSsi|]\}}||qSrrr)r:r;rrr ]sz1SubgraphMatcher._is_contained..r%FT)itemsr'r6r.)rrlookupr;r:userrrr _is_containedZs    zSubgraphMatcher._is_contained)matchesr#cCst}t}|D]l}d}|jD]"\}}|jdkr"||kr"d}qFq"|s|||jD]\}}|jdkr^||q^q|S)NF>r$r%T)rsetrr@r'appendadd)rrDZnon_overlapping_matchesZ nodes_matchedmatchZ found_overlapr:r;rrr_remove_overlapping_matchesns  z+SubgraphMatcher._remove_overlapping_matches)r:r;rHr#cCst|trt|trtdt|trft|tsf|jdkr`||jkrR|j||kS||j|<dSdSn0t|ts~t|tr~dSt|t|ko||kSdS)Nzpn and gn cannot both be Noder%TF) isinstancerr1r'rtype)rr:r;rHrrr _match_argss   zSubgraphMatcher._match_argsc Cstd|d|t|tr*t|tsBttd|d|||jkrZ|j||kS||jkrldS|||s|dSt |}||j|<|j dkrdSd}t |j \}}t |j \}}|j|jkr |jD]$} ||j| ||j| qnd}|rt|t|krt||D]P\} } t| tr`t| tr`|| | |} n|| | |} | s0d}qq0nd}|st |}dSdS)Nz matching  to zpn and gn must be Node, pn: z, gn: Fr%T)loggerinforJrr1strrvaluesr=rr'pytreeZ tree_flattenargskwargskeysrFr-zip _match_nodesrL) rr:r;rH saved_match match_foundZpn_flatten_args_Zgn_flatten_argskeyZpn_Zgn_matchedrrrrWsB,       zSubgraphMatcher._match_nodes)graphr#c shddlm}tt}jD]*}|jD]}||r$|||q$qt|gfddt jd}d|t }fddDt }||krt d||d g} D]*}d d|j D} || r| |qt | t kr"t dt t | d jrdt | }| t }||krdt d||d S) a Returns: The matched subgraphs. Thre returned subgraph would be fully self-contained, meaning the nodes (except placeholder and nodes returned by output) can only be consumed by nodes within the matched subgraph. Subgraph pattern matcher is implemented with the backtracking style in the following steps: 1. We first identify all the anchor nodes in the pattern graph. The anchor nodes are the "sinks" (nodes with no user other than the output node) of the pattern graph. One pattern graph could have multiple anchors if it has multiple return values. 2. In the target graph, we identify the potential candidate nodes that can be matched with each anchor. These anchor-candidate pairs are the starting points for pairwise per-node matching. 3. For each anchor-candidate pair, we simultaneously traverse backwards (DFS) in both pattern and target graphs. For every pattern nodes along traversal path, we compare it against the target nodes. In case any comparison failed, the match for this anchor-candidate pair fails. A match is found when DFS completes traversing the graph. See `self._match_nodes` for more details. 4. In the case of multiple anchors, every anchor will need to find a match using step 3. In addition, the matches found between anchors need to have a common intersection node in order for the match to be valid. This is implemented with backtracking. See `backtracking` for more details. Notice: graph traversal must be done in the reverser order because a tensor can have multiple consumers, but can only have a single producer. Only with reverser order, we can we jointly traverse the pattern and target graph in a deterministic path. Warning: In theory, this backtracking algorithm have an **exponential** time complexity. However, in practice, it's unlikely to blow up. r)validate_partitioncs|tkrXfddjD_fddjD_tdddS|\}}t}|D]^}td|d| ||}|r|dntd |d|dt|qrdS) Ncsg|]}j|qSrrr)r:rHrrr+sz?SubgraphMatcher.match..backtracking..csg|]}j|qSrr_r`rarrr+szFound a match:  zTrying to match anchor rMr,zFailed to match anchor ) r-r2rr6rrFrNrOrrW)Z anchor_indexrHpattern_anchorZcandidate_nodesrXr8rY backtrackingZmatch_candidates_listrDrrarres    z+SubgraphMatcher.match..backtracking)rcsg|]}|jr|qSr)rCr)r)rHrrrr+s z)SubgraphMatcher.match..z Filtered out z- matches because they are not fully containedcSsg|]\}}|jdkr|qS)>r$r%r&r>rrrr+#s zW matches because matched subgraph would form a cycle if fusedz2 matches because matched subgraphs are overlapping)Z!torch.fx.passes.utils.fuser_utilsr^rrr7r/r=rFr@r r-rNrOrr"rI) rr]r^Zmatch_candidatesrcr8rHbeforeafterZ valid_matchesZmatched_compute_nodesrrdrrHs>$          zSubgraphMatcher.match)FFT)rrrrboolr9rr=rrCr r rIr rLrWrHrrrrr "s + :)Z dataclassesrr collectionsrrZtorch.fx.graphrZ torch.fx.noderZtorch.fx._compatibilityrZtorch.utils._pytreeutilsZ_pytreerRtypingrr r r logging__all__ getLoggerrrNr r rrrrs