params->emplace_back(handle);
  }
  return absl::OkStatus();
}

// Runs `model` maybe wrapped in a function.
Status RunModel(Model model, AbstractContext* ctx,
                absl::Span<AbstractTensorHandle* const> inputs,
                absl::Span<AbstractTensorHandle*> outputs, bool use_function) {
  if (use_function) {
    const char* fn_name = "test_fn";
    core::RefCountPtr<AbstractFunction> scoped_func;

  // XlaCompilationResult pointed to by `result`.
  virtual Status Compile(const XlaCompiler::CompileOptions& options,
                         const NameAttrList& function,
                         absl::Span<const XlaArgument> args,
                         XlaCompilationResult* result) = 0;

  // Compiles a Tensorflow single op to an HloModuleProto stored in the
  // XlaCompilationResult pointed to by `result`.

    <a class="badge" href="https://dpeuniversity.gradle.com/app/courses/ec69d0b8-9171-4969-ac3e-82dea16f87b0/" target="_blank">
        <span class="badge-type button--blue">LEARN</span>
        <span class="badge-text">Incremental Builds and Build Caching with Gradle&nbsp;&nbsp;&nbsp;&gt;</span>
    </a>
</div>
++++

Gradle uses two main features to reduce build time: *incremental builds* and *build caching*.

    <a class="badge" href="https://dpeuniversity.gradle.com/app/courses/ec69d0b8-9171-4969-ac3e-82dea16f87b0/" target="_blank">
        <span class="badge-type button--blue">LEARN</span>
        <span class="badge-text">Incremental Builds and Build Caching with Gradle&nbsp;&nbsp;&nbsp;&gt;</span>
    </a>
</div>
++++

Learn the basics of Gradle's incremental builds.

****
**In this section you will:**

			continue
		}
		obj, span, objIndex := findObject(ptr, 0, 0)
		if obj == 0 {
			continue
		}
		// TODO: Consider making two passes where the first
		// just prefetches the mark bits.
		mbits := span.markBitsForIndex(objIndex)
		if mbits.isMarked() {
			continue
		}
		mbits.setMarked()

		// Mark span.
		arena, pageIdx, pageMask := pageIndexOf(span.base())

 *
 * See LoggingBuildOperationProgressBroadcaster.
 *
 * @since 7.4
 */
public interface StyledTextBuildOperationProgressDetails {

    List<? extends Span> getSpans();

    String getCategory();

    LogEventLevel getLevel();

    interface Span {

        /**
         * Always a value name of {@code org.gradle.internal.logging.text.StyledTextOutput.Style}.
         */
        String getStyleName();

                 AbstractTensorHandle* const tensor_names,
                 AbstractTensorHandle* const shape_and_slices,
                 absl::Span<AbstractTensorHandle*> tensors,
                 absl::Span<DataType> dtypes, const char* name,
                 const char* raw_device_name) {
  AbstractOperationPtr op_ptr(ctx->CreateOperation());

                                     absl::Span<const XlaArgument> args,
                                     XlaCompilationResult* result) {
  return ADD_SOURCE_LOCATION(
      xla_compiler_.CompileFunction(options, function, args, result));
}

Status TfGraphToHloCompiler::CompileSingleOp(
    const XlaCompiler::CompileOptions& options, const OpKernelContext* ctx,
    absl::Span<const XlaArgument> args, XlaCompilationResult* result) {

#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/test.h"

namespace tensorflow {
namespace {

Status PickDeviceHelper(bool allow_mixing_unknown_and_cpu,
                        absl::Span<const absl::string_view> device_names,
                        string* result) {
  jit::DeviceInfoCache cache;
  jit::DeviceSet device_set;
  for (absl::string_view name : device_names) {

  // XlaCompilationResult pointed to by `result` by calling
  // XlaCompiler::CompileFunction.
  Status Compile(const XlaCompiler::CompileOptions& options,
                 const NameAttrList& function,
                 absl::Span<const XlaArgument> args,
                 XlaCompilationResult* result) override;

  // Compiles a Tensorflow single op into an HloModuleProto stored in the
  // XlaCompilationResult pointed to by `result` by calling