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:

    /**
     * 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 {

To add tags to your *path operations*, and group them in the docs UI, read the docs for [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.

## Documentation Summary and Description - OpenAPI

 * Offers ways to communicate both ways with a Gradle operation, be it building a model or running tasks.
 * <p>
 * Enables tracking progress via listeners that will receive events from the Gradle operation.
 * <p>
 * Allows providing standard output streams that will receive output if the Gradle operation writes to standard streams.
 * <p>
 * Allows providing standard input that can be consumed by the gradle operation (useful for interactive builds).
 * <p>

     * A structured object providing details about the operation that was performed.
     */
    Object getNotificationOperationDetails();

    /**
     * A structured object representing the outcome of the operation.
     * Null if the operation failed, or if no result details are produced for the type of operation.
     */
    Object getNotificationOperationResult();

    /**
     * The operation failure.