auto& tensor = tensors_[itensor];
  auto& operation = operations_[ioperation];

  const auto& size = tensor.size;

  const bool will_be_first_use =
      tensor.operations.empty() || ioperation < tensor.first_use();
  const bool will_be_last_use =
      tensor.operations.empty() || ioperation > tensor.last_use();

  if (will_be_first_use) {
    operation.alloc += size;

  r_.AddOperation(/*is_stateful=*/false);
  r_.AddUse(/*ioperation=*/1, /*itensor=*/0);
  r_.AddUse(/*ioperation=*/2, /*itensor=*/0);
  r_.AddUse(/*ioperation=*/2, /*itensor=*/1);
  r_.AddUse(/*ioperation=*/3, /*itensor=*/0);
  r_.AddUse(/*ioperation=*/3, /*itensor=*/1);
  r_.AddUse(/*ioperation=*/3, /*itensor=*/2);

  // /* before */
  // %0 = f1()
  // %1 = f2(%0)
  // %2 = f3(%0,%1)

  // that is needed when performing the i-th operation. This is the
  // sum of the sizes of
  //
  // (1) input tensors of that operation,
  // (2) output tensors of that operation,
  // (3) output tensors of preceding operations that are input tensors
  //     of subsequent operations.
  using MemProfile = std::vector<SizeT>;

  // Used for specifying memory consumption at a certain operation in the
  // computational graph.

	grm.(*nestedPendingOperations).lock.Lock()
	defer grm.(*nestedPendingOperations).lock.Unlock()
	for _, op := range grm.(*nestedPendingOperations).operations {
		if op.key.podName == podName2 {
			t.Errorf("NestedPendingOperations failed. Operation for pod2 should be removed")
		}
	}

        return new Comparator<Operation>() {
            @Override
            public int compare(Operation o1, Operation o2) {
                long byElapsedTime = o2.getElapsedTime() - o1.getElapsedTime();
                if (byElapsedTime > 0) {
                    return 1;
                } else if (byElapsedTime < 0) {
                    return -1;
                }

 * When a property is accessed, queries an existing operation, asserting that it exists. For example:
 *
 * <pre>
 *  when:
 *  // runs the given closure and defines operation 'doStuff'
 *  operation.doStuff {
 *      // do some test action
 *  }
 *
 *  then:
 *  // query
 *  operation.doStuff.end > operation.doStuff.start

func (op *PortAllocationOperation) AllocateNext() (int, error) {
	if op.dryRun {
		// Find the max element of the allocated ports array.
		// If no ports are already being allocated by this operation,
		// then choose a sensible guess for a dummy port number
		var lastPort int
		for _, allocatedPort := range op.allocated {
			if allocatedPort > lastPort {
				lastPort = allocatedPort
			}
		}

Vous devez vous assurer qu'il est unique pour chaque opération.

```Python hl_lines="6"
{!../../../docs_src/path_operation_advanced_configuration/tutorial001.py!}
```

### Utilisation du nom *path operation function* comme operationId

            id1 = operation.id
            assert operation.id != null
            assert operation.parentId == null
            assert operation.toString() == "<thread-1>"
        }
        1 * listener.start(_, _) >> { BuildOperationDescriptor descriptor, BuildOperationState operation ->
            id2 = operation.id
            assert operation.id != null

# Path Operation Configuration

There are several parameters that you can pass to your *path operation decorator* to configure it.

!!! warning
    Notice that these parameters are passed directly to the *path operation decorator*, not to your *path operation function*.

## Response Status Code

You can define the (HTTP) `status_code` to be used in the response of your *path operation*.

You can pass directly the `int` code, like `404`.