//
        // TODO(allenl): There may be smarter ways to do this copy in some
        // cases, i.e. with a collective broadcast. We'll need to be careful
        // about things that are taken as inputs on the host or on their
        // existing device (for multi-device functions).
        std::unique_ptr<ParallelTensor> parallel_tensor(
            parallel_device.CopyToParallelDevice(

  };
  return tensorflow::unwrap(cancellation_manager)
      ->RegisterCallbackWithErrorLogging(token, callback, callback_name);
}

bool TFE_CancellationManagerDeregisterCallback(
    TFE_CancellationManager* cancellation_manager,
    TFE_CancellationToken token) {
  return tensorflow::unwrap(cancellation_manager)->DeregisterCallback(token);
}

bool TFE_CancellationManagerTryDeregisterCallback(

  };
  TFE_CancellationToken token2 = TFE_CancellationManagerGetToken(c_mgr);
  EXPECT_TRUE(TFE_CancellationManagerRegisterCallback(c_mgr, token2, &callback2,
                                                      "callback2"));

  TFE_CancellationToken token3 = TFE_CancellationManagerGetToken(c_mgr);
  EXPECT_TRUE(TFE_CancellationManagerRegisterCallback(c_mgr, token3, &callback1,

}

bool ModularFileSystem::FilesExist(const std::vector<std::string>& files,
                                   TransactionToken* token,
                                   std::vector<Status>* status) {
  if (ops_->paths_exist == nullptr)
    return FileSystem::FilesExist(files, token, status);

  std::vector<char*> translated_names;
  translated_names.reserve(files.size());
  for (int i = 0; i < files.size(); i++)