}
  start_execute_.notify_one();
}

void DeviceThread::AsyncWait(TF_Status* status) {
  tensorflow::mutex_lock l(execution_mutex_);
  TFE_ExecutorWaitForAllPendingNodes(executor_.get(), status);
  TFE_ExecutorClearError(executor_.get());
}

void DeviceThread::Run() {
  while (true) {
    {
      tensorflow::mutex_lock l(execution_mutex_);
      while (execution_state_ == ExecutionState::kIdle ||

                    // on Windows, need a short path or we hit 256 character limit for paths
                    // using EXECUTOR_NUMBER guarantees that concurrent builds on same agent
                    // will not trample each other plus workaround for JENKINS-52657
                    dir(isUnix() ? 'test' : "c:\\mvn-it-${EXECUTOR_NUMBER}.tmp") {
                        def WORK_DIR=pwd()
                        try {

        return getComponent(EXTRACTOR_FACTORY);
    }

    public static JobExecutor getJobExecutor(final String name) {
        if (name.endsWith(JOB_EXECUTOR_SUFFIX)) {
            return getComponent(name);
        }
        return getComponent("script" + JOB_EXECUTOR_SUFFIX);
    }

    public static FileTypeHelper getFileTypeHelper() {
        return getComponent(FILE_TYPE_HELPER);
    }

                    // on Windows, need a short path or we hit 256 character limit for paths
                    // using EXECUTOR_NUMBER guarantees that concurrent builds on same agent
                    // will not trample each other plus workaround for JENKINS-52657
                    dir(isUnix() ? 'test' : "c:\\mvn-it-${EXECUTOR_NUMBER}.tmp") {
                        def WORK_DIR=pwd()

  EXPECT_EQ(7, product[0]);
  EXPECT_EQ(10, product[1]);
  EXPECT_EQ(15, product[2]);
  EXPECT_EQ(22, product[3]);
  TF_DeleteStatus(status);
}
TEST(CAPI, Executor_MatMul_CPU) { Executor_MatMul_CPU(false); }
TEST(CAPI, Executor_MatMul_CPUAsync) { Executor_MatMul_CPU(true); }

void Deleter(void* data, size_t unused, void* tensor_handle) {
  TFE_DeleteTensorHandle(static_cast<TFE_TensorHandle*>(tensor_handle));
}

                                                  TF_Status* status) {
  tensorflow::EagerContext* context =
      tensorflow::ContextFromInterface(tensorflow::unwrap(ctx));
  auto collective_executor_handle = context->GetCollectiveExecutorHandle();
  collective_executor_handle->get()->StartAbort(status->status);
}

TF_CAPI_EXPORT extern void TFE_CollectiveOpsCheckPeerHealth(
    TFE_Context* ctx, const char* task, int64_t timeout_in_ms,

        "//tensorflow/c:conversion_macros",
        "//tensorflow/core:framework",
    ],
)

cc_library(
    name = "tfe_executor_internal",
    hdrs = ["tfe_executor_internal.h"],
    visibility = ["//visibility:private"],
    deps = [
        "//tensorflow/core/common_runtime/eager:eager_executor",
    ],
)

cc_library(
    name = "tfe_monitoring_internal",
    hdrs = ["tfe_monitoring_internal.h"],

                // Test distribution annotation-class filters
                // See: https://docs.gradle.com/enterprise/test-distribution/#gradle_executor_restrictions_class_matcher
                localOnly {
                    includeAnnotationClasses.addAll("com.gradle.enterprise.testing.annotations.LocalOnly")
                }
                remoteOnly {

            "//tensorflow/c/experimental/stream_executor:stream_executor_hdrs",
            "//tensorflow/core:portable_tensorflow_lib_lite",
        ],
        "//conditions:default": [
            ":tf_tensor",
            "//tensorflow/c/experimental/stream_executor",
            "//tensorflow/c/experimental/stream_executor:stream_executor_internal",
            "//tensorflow/core:framework",

                "//tensorflow/core/util:determinism",  # Must be linked and exported to libtensorflow_framework.so.
                "//tensorflow/lite/kernels/shim:tf_kernel_shim",
                "@local_xla//xla/stream_executor:stream_executor_impl",
                "@local_tsl//tsl/framework:bfc_allocator",
                "@local_tsl//tsl/framework:metrics",
            ] + tf_additional_binary_deps() +