key := status.ResourceFromMetadata(m.Resource.Metadata)
			index[key] = append(index[key], m)
		}
		// if we previously had a message that has been removed, ensure it is removed
		// TODO: this creates a state destruction problem when istiod crashes
		// in that old messages may not be removed.  Not sure how to fix this
		// other than write every object's status every loop.
		for _, a := range res.ExecutedAnalyzers {

      cc_options, thread_name, [=]() { (*work_func)(param); }));
}

void TF_JoinThread(TF_Thread* thread) {
  // ::tensorflow::Thread joins on destruction
  delete reinterpret_cast<::tensorflow::Thread*>(thread);
}

void* TF_LoadSharedLibrary(const char* library_filename, TF_Status* status) {
  void* handle = nullptr;
  TF_SetStatus(status, TF_OK, "");

          absl::AbortedError("The input `histogram` must have int64 type."));
    }
  }

  ~CalibrationStatisticsSaverOp() override {
    // Save to file during destruction so we only save it once.
    // TODO - b/335044516 : Find a way to flush outside of the destructor.
    CalibrationStatisticsMap statistics_map;
    for (const auto& [id, collector] : id_to_collector_) {
      std::optional<CalibrationStatistics> statistics =

namespace {

// Returns ops that should use MLIR legalization.
// All other ops not in this list should use XlaOpKernel.
const llvm::DenseSet<mlir::TypeID>& MlirAlwaysOps() {
  // The static variable is a pointer in order to avoid destruction upon thread
  // termination.
  static const llvm::DenseSet<mlir::TypeID>* ops = new llvm::DenseSet<
      mlir::TypeID>{
      // Ops that should always use the MLIR legalization.

	// large enough to not use the tiny allocator.
	_ [24 - unsafe.Sizeof(splicePipeFields{})%24]byte
}

// splicePipePool caches pipes to avoid high-frequency construction and destruction of pipe buffers.
// The garbage collector will free all pipes in the sync.Pool periodically, thus we need to set up
// a finalizer for each pipe to close its file descriptors before the actual GC.

namespace tensorflow {

namespace {

// Managing context for the DLManagedTensor, will manage the lifetime of
// DLManagedTensor. When calling DLManagedTensor::deleter, it will notify the
// original framework of destruction, and this context will be deleted also.
struct TfDlManagedTensorCtx {
  TensorReference reference;
  std::vector<int64_t> shape;
  std::vector<int64_t> strides;
  DLManagedTensor tensor;

  typedef void (*MemoryReleaser)(void* data, size_t len, void* arg);

  // Create a tensor instance from the given data buffer and description.
  // `memory_releaser` will be called on destruction, and it's responsible for
  // cleaning up the underlying buffer.
  virtual AbstractTensorInterface* CreateTensor(
      DataType dtype, const int64_t* dims, int num_dims, void* data, size_t len,

	SetUpDevice() (stagingPath string, err error)

	// MapPodDevice maps the block device to a path and return the path.
	// Unique device path across kubelet node reboot is required to avoid
	// unexpected block volume destruction.
	// If empty string is returned, the path returned by attacher.Attach() and
	// attacher.WaitForAttach() will be used.
	MapPodDevice() (publishPath string, err error)

  // derived class method.
  device_ = device_mgr_->ListDevices().front();
  params_.device = device_;
  params_.resource_manager = device_->resource_manager();

  // Resources are cleared at the time of device manager destruction so pass
  // no-op cleanup function.
  auto cleanup = [](const std::string& name) {};
  // Use step_id zero as we only have a single context concurrently and

 *  to each suite using CU_add_test().  Test runs are then initiated 
 *  using one of the appropriate functions in TestRun.c via one of the 
 *  user interfaces.<br /><br />
 *
 *  Automatic creation and destruction of the internal registry and its 
 *  objects is available using CU_initialize_registry() and 
 *  CU_cleanup_registry(), respectively.  For internal and testing