// The copy can be non-consectutive copy. This is just fake data.
constexpr float kGPUCopyUnitCost = 0.2;

// Default values.
constexpr float kGPUDefaultFixedValuedCost = 10000.0;

std::unique_ptr<TargetHardware> CreateGpuHardware() {
  return std::make_unique<GpuHardware>();
}

TargetHardwareRegistration<GpuHardware> gpu_hardware("Target device for GPU",

// and maps to the SignatureDefFunction node in the SavedObjectGraph.
struct PartiallyRevivedObjects {
  gtl::FlatMap<int, std::unique_ptr<Variable>> variables;
  gtl::FlatMap<int, std::unique_ptr<Asset>> assets;
  gtl::FlatMap<int, std::unique_ptr<Constant>> constants;
  gtl::FlatMap<int, TFConcreteFunctionRevivalState> concrete_functions;
  gtl::FlatMap<int, TFSignatureDefFunctionRevivalState> signature_def_functions;

#include "tensorflow/core/platform/thread_annotations.h"

namespace tensorflow {
namespace {
// The list of all registered `XlaActivityListener`s.
struct XlaActivityListenerList {
  absl::Mutex mutex;
  std::vector<std::unique_ptr<XlaActivityListener>> listeners
      TF_GUARDED_BY(mutex);
};

void FlushAllListeners();

XlaActivityListenerList* GetXlaActivityListenerList() {

};

// Struct that wraps TF_Tensor and TF_Status to delete once out of scope
using Safe_TF_TensorPtr = std::unique_ptr<TF_Tensor, TFTensorDeleter>;
using Safe_TF_StatusPtr = std::unique_ptr<TF_Status, TFStatusDeleter>;

// dummy functions used for kernel registration
void* MergeSummaryOp_Create(TF_OpKernelConstruction* ctx) { return nullptr; }

void MergeSummaryOp_Delete(void* kernel) {}

#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir::odml {

std::unique_ptr<OperationPass<func::FuncOp>> CreateOutlineCompositesPass();

std::unique_ptr<OperationPass<ModuleOp>> CreateSHLOSimplifyPass();

#define GEN_PASS_REGISTRATION
#include "tensorflow/compiler/mlir/lite/stablehlo/odml_converter/passes.h.inc"

    std::vector<ImmediateExecutionTensorHandle*> captures,
    FunctionMetadata metadata, ImmediateExecutionContext* ctx,
    std::unique_ptr<TFConcreteFunction>* out) {
  std::unique_ptr<FlatTensorFunction> func;
  TF_RETURN_IF_ERROR(FlatTensorFunction::Create(
      function_def, std::move(captures), ctx, &func));

  out->reset(new TFConcreteFunction(std::move(func), std::move(metadata)));
  return Status();
}

    SignatureDefFunctionMetadata metadata, ImmediateExecutionContext* ctx,
    std::unique_ptr<TFSignatureDefFunction>* out) {
  std::unique_ptr<FlatTensorFunction> func;
  TF_RETURN_IF_ERROR(FlatTensorFunction::Create(
      function_def, std::move(captures), ctx, &func));

  out->reset(new TFSignatureDefFunction(std::move(func), std::move(metadata)));
  return Status();
}

    if (op->getDialect() == nullptr) return false;
    if (op->getDialect()->getNamespace() != "tfl") return false;
    return true;
  }
};

constexpr char CpuHardware::kId[];  // Define kId.

std::unique_ptr<TargetHardware> CreateCpuHardware() {
  return std::make_unique<CpuHardware>();
}

TargetHardwareRegistration<CpuHardware> cpu_hardware("Target device for CPU",

  mlir::RewritePatternSet patterns(context);

  patterns.add<SquaredDifference, LowerPackIntoConcatReshape,
               ReduceMeanToAvgPool, InsertRequantForReduceMean>(context);
  return patterns;
}

std::unique_ptr<TargetHardware> CreateNNAPIHardware() {
  return std::make_unique<NNAPIHardware>();
}

TargetHardwareRegistration<NNAPIHardware> nnapi_hardware(
    "Target device for NNAPI", CreateNNAPIHardware);

  });
}

}  // namespace

TEST(TfTextUtilsTest, TestTfTextRegistered) {
  std::unique_ptr<OpRegistry> registry(new OpRegistry);
  Register("WhitespaceTokenizeWithOffsets", registry.get());
  EXPECT_TRUE(IsTFTextRegistered(registry.get()));
}

TEST(TfTextUtilsTest, TestTfTextNotRegistered) {
  std::unique_ptr<OpRegistry> registry(new OpRegistry);
  Register("Test", registry.get());