Lines Matching defs:ownership

192   /// importantly the ownership map and list of memrefs to potentially be
195   /// point in the control-flow may be deallocated and the ownership map has to
196   /// be updated to reflect potential ownership changes caused by the dealloc
198   /// operation each, the second one should query the ownership map and use them
238   /// Make sure that for each forwarded MemRef value, an ownership indicator
255   ///   // replace ownership(r) with o element-wise
260   /// Add an ownership indicator for every forwarding MemRef operand and result.
261   /// Nested regions never take ownership of MemRefs owned by a parent region
292   /// If the private-function-dynamic-ownership pass option is enabled and the
294   /// result to pass the dynamic ownership indicator along. Otherwise, updates
295   /// the ownership map and list of memrefs to be deallocated according to the
296   /// function boundary ABI, i.e., assume ownership of all returned MemRefs.
298   /// Example (assume `private-function-dynamic-ownership` is enabled):
312   /// // set ownership(%ret_f) := true
316   /// // set ownership(%ret_g#0) := %ret_g#1
317   /// // remember to deallocate %ret_g if it comes with ownership
324   /// also updates the ownership map accordingly.
335   /// // set ownership(alloc) := true
336   /// // set ownership(alloca) := false
386   /// 'handleInterface' functions, this function sets the ownership of operation
390   /// assigns 'false' as ownership. This happens, e.g., for the
399   /// which has 'Unique' ownership where the ownership indicator is guaranteed
405   /// private visibility, and the private-function-dynamic-ownership pass option
411   /// materialized ownership indicator for 'memref'.  If the op does not
434   /// ownership of the memref to be transferred to the nested region, which does
441   /// When the 'private-function-dynamic-ownership' pass option is enabled,
467   // The interface can only materialize ownership indicators in the same block
476   // If the op implements the interface, query it for a materialized ownership
609   // Update the function signature if the function is private, dynamic ownership
617   // Compute liveness transfers of ownership to this block.
622     // taken, but ownership of memrefs in the same region (but different block)
642     // Adhere to function boundary ABI: no ownership of function argument
659   // and ownership of memrefs.
717   // No ownership is acquired for any MemRefs that are passed to the region from
738   // First, make sure we at least have 'Unique' ownership already.
744   // Avoid inserting additional IR if ownership is already guaranteed. In
745   // particular, this is already the case when we had 'Unknown' ownership
746   // initially and a clone was inserted to get to 'Unique' ownership.
750   // Insert a runtime check and only clone if we still don't have ownership at
802   // We want to replace the current ownership of the retained values with the
805   for (auto [retained, ownership] :
807     state.updateOwnership(retained, ownership, block);
832   // If the private-function-dynamic-ownership option is enabled and we are
834   // each MemRef result to dynamically pass the current ownership indicator
850   // According to the function boundary ABI we are guaranteed to get ownership
851   // of all MemRefs returned by the function. Thus we set ownership to constant
885       Ownership ownership = state.getOwnership(operand, block);
886       if (ownership.isUnique()) {
888             op.getLoc(), ownership.getIndicator(),
892             "expected that the block does not have ownership");
902         // Make sure that the ownership of auto-managed allocations is set to
906         // `memref.alloc`. If we wouldn't set the ownership of the result here,
907         // the default ownership population in `populateRemainingOwnerships`
915         // This allocation will be deallocated manually. Assign an ownership of
936   // dynamic function boundary ownership is disabled, we need to return memref
937   // values for which we have guaranteed ownership to pass on to adhere to the
964   // Add an additional operand for every MemRef for the ownership indicator.
988     // an ownership during `handleInterface`. Assume the result may alias with
999     // If the ownership value is still uninitialized (e.g., because the op has
1000     // no memref operands), assume that no ownership is taken. E.g., this is the