if (it == id_to_resource_values_.end()) {
      return {};  // return empty set
    }
    return it->getSecond();
  }

  // Returns true iff given resource is allocated by op with
  // `UniqueResourceAllocation` trait. This can be utilized for while-loop
  // parallelization.
  bool IsUniqueResourceAllocationId(int64_t resource_id) const {
    return unique_resource_allocation_ids_.contains(resource_id);
  }

 private:

    return detail::foldInvolution(op);
  }
};

// Indicates that any returned resource is unique.
template <typename ConcreteType>
class UniqueResourceAllocation
    : public TraitBase<ConcreteType, UniqueResourceAllocation> {
 public:
  // Implements method required for `ResourceHandleAllocatorInterface`.
  llvm::SmallVector<mlir::TF::ResourceHandleValueAndId>
  GetResourceHandleValueAndIdList(

        // Keep track of IDs of resources that are allocated by ops with
        // `UniqueResourceAllocation` trait, this can be utilized for while-loop
        // parallelization (every iteration creates a new unique resource).
        if (op->hasTrait<OpTrait::TF::UniqueResourceAllocation>()) {
          unique_resource_allocation_ids_.insert(resource_handle.id);
        }
      }

  const llvm::SmallVector<std::pair<ResourceId, bool>>& GetResourceIds(
      Operation* op) const;

  // Returns true iff given resource is allocated by op with
  // `UniqueResourceAllocation` trait. This can be utilized for while-loop
  // parallelization.
  bool IsUniqueResourceAllocationId(ResourceId resource_id) const {
    return alias_analysis_.IsUniqueResourceAllocationId(resource_id);
  }

      } else {
        resource_and_device = std::make_pair(resource_id, kAnyDevice);
      }

      // If the resource was allocated by an op with `UniqueResourceAllocation`
      // trait, then we don't need to chain resource ops accessing this resource
      // between iterations: Every iteration will create a new independent

// Example op where the invariant is not true: `TF_VarHandleOp`.
def TF_UniqueResourceAllocation: TraitList<[
    TF_ResourceHandleAllocatorInterface,
    NativeOpTrait<"TF::UniqueResourceAllocation">
]>;

//===----------------------------------------------------------------------===//
// Rank/Shape helpers.
//===----------------------------------------------------------------------===//

// Tests two side-effecting ops operating on resources that are allocated in the
// same function. The expectation is that the ops are treated as independent
// (as the involved resource allocators have the `UniqueResourceAllocation`
// trait).
func.func @side_effecting_ops_with_different_resources_and_allocations(
  // expected-remark@above {{ID: 9}}
  %arg0: tensor<i32>,
  %arg1: tensor<f32>) {
  tf_executor.graph {