default:
                throw new AssertionError();
        }
    }

    /*
     * This operation is only used here temporarily. Should be replaced with a more stable operation in the long term.
     */
    public interface Operation extends BuildOperationType<Operation.Details, Operation.Result> {
        interface Details {
            Class<?> getWorkType();
            UnitOfWork.Identity getIdentity();

import org.gradle.internal.build.event.BuildEventSubscriptions;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.OperationFinishEvent;
import org.gradle.internal.operations.OperationIdentifier;
import org.gradle.internal.operations.OperationProgressEvent;
import org.gradle.internal.operations.OperationStartEvent;
import org.gradle.tooling.internal.protocol.events.InternalOperationDescriptor;

// identity ops, chain_src and chain_sink, per resource equivalence class.
// Using the resource to operations map, it adds (1) a control dependency
// from chain_src to all the operations that read/write to a resource of the
// equivalence class, and (2) a control dependency from all the operations that
// read/write to a resource of the class to the chain_sink operation.
void ChainResourceOps(
    func::FuncOp func, ResourceToOpsMapTy& chain_resource_to_ops_map,

        TemplateOperation operation1 = Mock(TemplateOperation)
        TemplateOperation operation2 = Mock(TemplateOperation)

        Mock(org.gradle.internal.Factory).create() >> true
        when:
        new ConditionalTemplateOperation({true} as org.gradle.internal.Factory, [operation1, operation2]).generate()
        then:
        1 * operation1.generate()
        1 * operation2.generate()

        when:

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits operation for each task action execution"() {
        when:
        buildScript """
            task t {
                doLast {}
                doLast {}
            }
        """
        succeeds "t"

        then:
        def actions = operations.all(ExecuteTaskActionBuildOperationType)

// Compute the set of all values which are inputs to `ops`, but not generated
// by an operation in `ops`, and all outputs which are used outside of `ops.
void computeInputsOutputs(std::vector<Operation*>& ops,
                          std::vector<Value>* inputs,
                          std::vector<Value>* outputs) {
  // All operations.
  llvm::DenseSet<Operation*> all_operations;

  // All results of all ops.

    /**
     * A unique, opaque, value identifying this operation.
     */
    Object getNotificationOperationId();

    /**
     * The ID of the parent of this notification.
     *
     * Note: this is the ID of the nearest parent operation that also resulted in a notification.
     * As notifications are not sent for all operations, this may be a different value to the
     * parent operation ID.
     *

    }
  });
}

// Move Transpose operations that permute `op` results before the `op`.
void MoveTransposeBefore(Operation* op, SmallVector<Operation*, 8>* work_list) {
  // TODO(ezhulenev): Move transpose across layout sensitive operations.
  if (!op->hasTrait<OpTrait::TF::LayoutAgnostic>()) return;

  // Transpose operations that use operation results.
  SmallVector<TransposeOp, 2> transpose_ops;

    // Clones the tf_device.remote_run operation to replace its callee args with
    // the results of the other tf_device.remote_run operations using the
    // `mapping` as appropriate.
    Operation *cloned_remote_run_op =
        builder.clone(*remote_run_op.getOperation(), mapping);
    remote_run_op.erase();

    // Replaces usages of the results of the original operations with the

package atomic

// LoadAcquire is a partially unsynchronized version
// of Load that relaxes ordering constraints. Other threads
// may observe operations that precede this operation to
// occur after it, but no operation that occurs after it
// on this thread can be observed to occur before it.
//
// WARNING: Use sparingly and with great care.
//
//go:nosplit
func (u *Uint64) LoadAcquire() uint64 {