def "generates build phase events for task #taskName and expects #expectedReportedTasksCount run tasks"() {
        setupProject()

        when:
        def events = ProgressEvents.create()
        withConnection {
            it.newBuild().forTasks(taskName)
                .addProgressListener(events, OperationType.BUILD_PHASE)
                .run()
        }

    llvm::cl::desc(
        "Comma-separated list of exported model signatures to convert"),
    llvm::cl::Optional, llvm::cl::init("serving_default"));

// NOLINTNEXTLINE
opt<std::string> tag_names(
    "tags",
    llvm::cl::desc("Comma-separated list of tags for loading SavedModel. "
                   "Ignored for MLIR input"),
    llvm::cl::Optional, llvm::cl::init("serve"));

// NOLINTNEXTLINE

import jetbrains.buildServer.configs.kotlin.buildFeatures.parallelTests
import jetbrains.buildServer.configs.kotlin.buildFeatures.pullRequests
import model.CIBuildModel
import model.StageName

fun checkCleanDirUnixLike(dir: String, exitOnFailure: Boolean = true) = """
    REPO=$dir
    if [ -e ${'$'}REPO ] ; then
        tree ${'$'}REPO
        rm -rf ${'$'}REPO

        }
    }

    private void executeTaskViaGradleProjectLaunchable(String taskName) {
        withConnection { connection ->
            def gradleProjects = connection.action(new LoadCompositeModel(GradleProject)).run()
            def launchables = findLaunchables(gradleProjects, taskName)
            assert launchables.size == 1
            def build = connection.newBuild()

        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(
                "deserialize",
                Task::class,

          <type>String</type>
          <description></description>
        </field>
        <field xml.tagName="role-hint">
          <name>roleHint</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description></description>
        </field>
        <field xml.tagName="field-name">
          <name>fieldName</name>
          <required>true</required>
          <version>1.0.0+</version>

        someTaskOutput.assertExists()
    }

    private void assertTaskOutputCached(String taskName) {
        assert listCacheFiles().any { it.name == cacheOperations.getCacheKeyForTask(taskName) }
    }

    private void assertTaskOutputNotCached(String taskName) {
        def cacheKey = cacheOperations.getCacheKeyForTaskOrNull(taskName)
        assert cacheKey == null
    }

    @Override

  tensorflow::AddTypeConstraint(kernel_builder, attr_name, dtype, status);
}

void TF_KernelBuilder_HostMemory(TF_KernelBuilder* kernel_builder,
                                 const char* arg_name) {
  kernel_builder->cc_builder->HostMemory(arg_name);
}

void TF_KernelBuilder_Priority(TF_KernelBuilder* kernel_builder,
                               int32_t priority_number) {
  kernel_builder->cc_builder->Priority(priority_number);

    const std::unordered_set<std::string>* constant_inputs =
        XlaOpRegistry::CompileTimeConstantInputArgNames(def->op());

    for (const std::string& arg_name : *constant_inputs) {
      def->add_host_memory_arg(arg_name);
    }

    def->set_device_type(device);
    registrations->op_kernel_registrars.emplace_back(
        new kernel_factory::OpKernelRegistrar(def, kernel_class_name, factory));
  }

      /*use_multiple_streams=*/platform_info.UseMultipleStreams());
  return launch_context;
}

Status GetTaskName(const std::string_view device_name, std::string* task_name) {
  string ignored;
  if (!DeviceNameUtils::SplitDeviceName(device_name, task_name, &ignored)) {
    return errors::InvalidArgument("Unable to parse device name: ",
                                   device_name);
  }

  return absl::OkStatus();
}