ui.PrintErr(fmt.Sprintf("Fetched %d base profiles out of %d", got, want))
	}

	return psrc, pbase, msrc, mbase, save, nil
}

// chunkedGrab fetches the profiles described in source and merges them into
// a single profile. It fetches a chunk of profiles concurrently, with a maximum
// chunk size to limit its memory usage.

	}
	if len(matchedPluginNames) > 1 {
		return nil, fmt.Errorf("multiple volume plugins matched: %s", strings.Join(matchedPluginNames, ","))
	}

	return match, nil
}

// FindPluginByName fetches a plugin by name. If no plugin is found, returns error.
func (pm *VolumePluginMgr) FindPluginByName(name string) (VolumePlugin, error) {
	pm.mutex.RLock()
	defer pm.mutex.RUnlock()

	var match VolumePlugin

// Appends `value` to the arguments of the `FetchOp` of `graph_op`.
void AppendValueToFetch(GraphOp graph_op, Value value) {
  FetchOp old_main_fetch = graph_op.GetFetch();
  auto fetches = llvm::to_vector(old_main_fetch.getFetches());
  fetches.emplace_back(value);

  auto builder = OpBuilder::atBlockTerminator(&graph_op.GetBody());
  builder.create<FetchOp>(old_main_fetch.getLoc(), std::move(fetches));
  old_main_fetch.erase();
}

		}
	}

	// Not all items are subject to timeout. Proceed only if the non-cancellable items have completed.
	mandatoryWg.Wait()

	// If log fetches have completed, cancel the timeout.
	go func() {
		optionalWg.Wait()
		cmdTimer.Reset(0)
	}()

	// Wait for log fetches, up to the timeout.
	<-cmdTimer.C

	// Find the timeout duration left for the analysis process.

  return wrapper_island_op;
}

// Adds a new fetch operand for the main function's GraphOp.
void AddFetchOperandToMain(GraphOp main_graph_op, const Value fetch_operand) {
  FetchOp old_fetch = main_graph_op.GetFetch();
  const absl::Cleanup erase_old_fetch = [old_fetch]() mutable {
    old_fetch.erase();
  };

  auto fetches = llvm::to_vector(old_fetch.getFetches());
  fetches.emplace_back(fetch_operand);

    graph and must match the return type of the graph.
  }];

  let arguments = (ins
    Variadic<AnyType>:$fetches
  );

  let builders = [
    OpBuilder<(ins),
    [{
      build($_builder, $_state, {});
    }]>
   ];

  let assemblyFormat = "($fetches^ `:` type($fetches))? attr-dict";

  let hasVerifier = 0;

      tf_executor::FetchOp fetch = graph_op.GetFetch();
      auto fetches = llvm::to_vector<8>(fetch.getOperands());
      fetches.append(unused_execute_controls.begin(),
                     unused_execute_controls.end());
      builder.setInsertionPoint(fetch);
      builder.create<tf_executor::FetchOp>(fetch.getLoc(), fetches);
      fetch.erase();
    }
  } else {

    tf_executor.fetch %1#0 : tensor<4x!tf_type.f32ref>
  }
  func.return %fetches : tensor<4x!tf_type.f32ref>
}

// -----

// Check that switchN data operand is broadcastable with all output types
func.func @invalid_switchN(%arg0: tensor<*xf32>, %arg1: tensor<i32>) -> tensor<*xf32> {
  %fetches = tf_executor.graph {

                     unused_replica_controls.end());
      builder.setInsertionPoint(fetch);
      builder.create<tf_executor::FetchOp>(fetch.getLoc(), fetches);
      fetch.erase();
    }
  } else {
    // Now, finally, we need to maintain the invariant expected to be maintained
    // throughout the graph export pipeline that all islands always perfectly

// control fetches.
// CHECK-LABEL: func @merge_independently_fetched_islands_control_and_control
func.func @merge_independently_fetched_islands_control_and_control(%arg0: tensor<i32>) {
 tf_executor.graph {
    %1 = tf_executor.island { tf_executor.yield }
    %2 = tf_executor.island { tf_executor.yield }
    tf_executor.fetch %1, %2 : !tf_executor.control, !tf_executor.control
  }