// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "paddle/phi/backends/device_base.h"

#include "glog/logging.h"
#include "paddle/common/flags.h"
#include "paddle/phi/core/enforce.h"

PD_DECLARE_double(fraction_of_gpu_memory_to_use);
PD_DECLARE_uint64(initial_gpu_memory_in_mb);
PD_DECLARE_uint64(reallocate_gpu_memory_in_mb);

constexpr static float fraction_reserve_gpu_memory = 0.05f;

namespace phi {

#define INTERFACE_UNIMPLEMENT                 \
  PADDLE_THROW(common::errors::Unimplemented( \
      "%s is not implemented on %s device.", __func__, Type()));

// info
size_t DeviceInterface::GetComputeCapability(size_t dev_id) {
  VLOG(10) << Type() << " get compute capability " << 0;
  return 0;
}

DeviceProp& DeviceInterface::GetDeviceProperties(size_t dev_id) {
  static DeviceProp prop;
  VLOG(10) << Type() << " get device properties " << 0;
  return prop;
}

size_t DeviceInterface::GetRuntimeVersion(size_t dev_id) {
  VLOG(10) << Type() << " get runtime version " << 0;
  return 0;
}

size_t DeviceInterface::GetDriverVersion(size_t dev_id) {
  VLOG(10) << Type() << " get driver version " << 0;
  return 0;
}

size_t DeviceInterface::GetMultiProcessors(size_t dev_id) {
  VLOG(10) << Type() << " get multiprocessors " << 0;
  return 0;
}

size_t DeviceInterface::GetMaxThreadsPerMultiProcessor(size_t dev_id) {
  VLOG(10) << Type() << " get max threads per multiprocessor " << 0;
  return 0;
}

size_t DeviceInterface::GetMaxThreadsPerBlock(size_t dev_id) {
  VLOG(10) << Type() << " get max threads per block " << 0;
  return 0;
}

size_t DeviceInterface::GetMaxSharedMemPerBlock(size_t dev_id) {
  VLOG(10) << Type() << " get max shared mem per block " << 0;
  return 0;
}

size_t DeviceInterface::GetMaxBlocksPerMultiProcessor(size_t dev_id) {
  VLOG(10) << Type() << " get max blocks per multiprocessor " << 0;
  return 0;
}

size_t DeviceInterface::GetWarpSize(size_t dev_id) {
  VLOG(10) << Type() << " get warp size " << 0;
  return 0;
}

size_t DeviceInterface::GetMaxRegistersPerMultiProcessor(size_t dev_id) {
  VLOG(10) << Type() << " get max registers per multiprocessor " << 0;
  return 0;
}

size_t DeviceInterface::GetPreferredVectorWidth(size_t dev_id) {
  VLOG(10) << Type() << " get preferred vector width " << 0;
  return 0;
}

std::array<unsigned int, 3> DeviceInterface::GetMaxGridDimSize(size_t dev_id) {
  VLOG(10) << Type() << " get max grid dim size [" << 0 << ", " << 0 << ", "
           << 0 << "]";
  return {0, 0, 0};
}

std::array<unsigned int, 3> DeviceInterface::GetMaxBlockDimSize(size_t dev_id) {
  VLOG(10) << Type() << " get max block dim size [" << 0 << ", " << 0 << ", "
           << 0 << "]";
  return {0, 0, 0};
}

bool DeviceInterface::IsFloat16Supported(size_t dev_id) {
  VLOG(10) << Type() << " is float16 supported: " << false;
  return false;
}

bool DeviceInterface::IsBFloat16Supported(size_t dev_id) {
  VLOG(10) << Type() << " is bfloat16 supported: " << false;
  return false;
}

bool DeviceInterface::IsDnnAvailable(size_t dev_id) {
  VLOG(10) << Type() << " is dnn available: " << false;
  return false;
}

void* DeviceInterface::InitEigenDevice(const Place& place,
                                       stream::stream_t stream,
                                       phi::Allocator* allocator) {
  VLOG(10) << Type() << " init eigen device ";
  return 0;
}

void DeviceInterface::DestroyEigenDevice(size_t dev_id, void* eigen_device) {
  VLOG(10) << Type() << " destroy eigen device ";
}

// device manage
void DeviceInterface::Initialize() { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::Finalize() { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::SynchronizeDevice(size_t dev_id) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::InitDevice(size_t dev_id) { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::DeInitDevice(size_t dev_id) { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::SetDevice(size_t dev_id) { INTERFACE_UNIMPLEMENT; }

int DeviceInterface::GetDevice() { INTERFACE_UNIMPLEMENT; }

// stream manage
void DeviceInterface::CreateStream(size_t dev_id,
                                   stream::Stream* stream,
                                   const stream::Stream::Priority& priority,
                                   const stream::Stream::Flag& flag) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::DestroyStream(size_t dev_id, stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::SynchronizeStream(size_t dev_id,
                                        stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
}

bool DeviceInterface::QueryStream(size_t dev_id, stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
  return true;
}

void DeviceInterface::AddCallback(size_t dev_id,
                                  stream::Stream* stream,
                                  stream::Stream::Callback* callback) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::StreamWaitEvent(size_t dev_id,
                                      const stream::Stream* stream,
                                      const event::Event* event) {
  INTERFACE_UNIMPLEMENT;
}

// event manage
void DeviceInterface::CreateEvent(size_t dev_id,
                                  event::Event* event,
                                  event::Event::Flag flags) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::DestroyEvent(size_t dev_id, event::Event* event) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::RecordEvent(size_t dev_id,
                                  const event::Event* event,
                                  const stream::Stream* stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::SynchronizeEvent(size_t dev_id,
                                       const event::Event* event) {
  INTERFACE_UNIMPLEMENT;
}

bool DeviceInterface::QueryEvent(size_t dev_id, const event::Event* event) {
  INTERFACE_UNIMPLEMENT;
  return true;
}

// memory manage
void DeviceInterface::MemoryCopyH2D(size_t dev_id,
                                    void* dst,
                                    const void* src,
                                    size_t size,
                                    const stream::Stream* stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::MemoryCopyD2H(size_t dev_id,
                                    void* dst,
                                    const void* src,
                                    size_t size,
                                    const stream::Stream* stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::MemoryCopyD2D(size_t dev_id,
                                    void* dst,
                                    const void* src,
                                    size_t size,
                                    const stream::Stream* stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::MemoryCopyP2P(const Place& dst_place,
                                    void* dst,
                                    size_t src_id,
                                    const void* src,
                                    size_t size,
                                    const stream::Stream* stream) {
  INTERFACE_UNIMPLEMENT;
}

void* DeviceInterface::MemoryAllocate(size_t dev_id, size_t size) {
  INTERFACE_UNIMPLEMENT;
  return nullptr;
}

void DeviceInterface::MemoryDeallocate(size_t dev_id, void* ptr, size_t size) {
  INTERFACE_UNIMPLEMENT;
}

void* DeviceInterface::MemoryAllocateHost(size_t dev_id, size_t size) {
  INTERFACE_UNIMPLEMENT;
  return nullptr;
}

void DeviceInterface::MemoryDeallocateHost(size_t dev_id,
                                           void* ptr,
                                           size_t size) {
  INTERFACE_UNIMPLEMENT;
}

void* DeviceInterface::MemoryAllocateUnified(size_t dev_id, size_t size) {
  INTERFACE_UNIMPLEMENT;
  return nullptr;
}

void DeviceInterface::MemoryDeallocateUnified(size_t dev_id,
                                              void* ptr,
                                              size_t size) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::MemorySet(size_t dev_id,
                                void* ptr,
                                uint8_t value,
                                size_t size) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::MemoryStats(size_t dev_id, size_t* total, size_t* free) {
  INTERFACE_UNIMPLEMENT;
}

size_t DeviceInterface::GetMinChunkSize(size_t dev_id) {
  INTERFACE_UNIMPLEMENT;
}

size_t DeviceInterface::AllocSize(size_t dev_id, bool realloc) {
  size_t available_to_alloc = AvailableAllocSize(dev_id);
  PADDLE_ENFORCE_GT(available_to_alloc,
                    0,
                    common::errors::ResourceExhausted(
                        "Not enough available %s memory.", Type()));
  // If FLAGS_initial_gpu_memory_in_mb is 0, then initial memory will be
  // allocated by fraction
  size_t flag_mb = realloc ? FLAGS_reallocate_gpu_memory_in_mb
                           : FLAGS_initial_gpu_memory_in_mb;
  size_t alloc_bytes =
      (flag_mb > 0ul ? flag_mb << 20
                     : available_to_alloc *
                           FLAGS_fraction_of_gpu_memory_to_use);  // NOLINT
  PADDLE_ENFORCE_GE(available_to_alloc,
                    alloc_bytes,
                    common::errors::ResourceExhausted(
                        "Not enough available %s memory.", Type()));
  return alloc_bytes;
}

size_t DeviceInterface::AvailableAllocSize(size_t dev_id) {
  size_t total = 0;
  size_t available = 0;
  MemoryStats(dev_id, &total, &available);
  // If available size is less than minimum chunk size, no usable memory exists
  size_t min_chunk_size = GetMinChunkSize(dev_id);
  if (available < min_chunk_size) {
    available = 0;
  }
  return available;
}

size_t DeviceInterface::GetInitAllocSize(size_t dev_id) {
  size_t init_alloc_size = AllocSize(dev_id, false);
  VLOG(10) << Type() << " init alloc size " << (init_alloc_size >> 20) << "M";
  return init_alloc_size;
}

size_t DeviceInterface::GetReallocSize(size_t dev_id) {
  size_t realloc_size = AllocSize(dev_id, true);
  VLOG(10) << Type() << " realloc size " << (realloc_size >> 20) << "M";
  return realloc_size;
}

size_t DeviceInterface::GetMaxAllocSize(size_t dev_id) {
  size_t max_alloc_size =
      std::max(GetInitAllocSize(dev_id), GetReallocSize(dev_id));
  VLOG(10) << Type() << " max alloc size " << (max_alloc_size >> 20) << "M";
  return max_alloc_size;
}

size_t DeviceInterface::GetMaxChunkSize(size_t dev_id) {
  size_t max_chunk_size = GetMaxAllocSize(dev_id);
  VLOG(10) << Type() << " max chunk size " << (max_chunk_size >> 20) << "M";
  return max_chunk_size;
}

size_t DeviceInterface::GetExtraPaddingSize(size_t dev_id) {
  VLOG(10) << Type() << " extra padding size " << 0;
  return 0;
}

void DeviceInterface::CCLCommName(ccl::CCLComm ccl_comm, char* comm_name) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLDestroyComm(ccl::CCLComm ccl_comm) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLCommInitRank(size_t num_ranks,
                                      ccl::CCLRootId* root_id,
                                      size_t rank_id,
                                      ccl::CCLComm* ccl_comm) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLGetUniqueId(ccl::CCLRootId* root_id) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLBroadcast(void* data,
                                   size_t num,
                                   DataType data_type,
                                   size_t root,
                                   const ccl::CCLComm& ccl_comm,
                                   const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLAllReduce(void* in_data,
                                   void* out_data,
                                   size_t num,
                                   DataType data_type,
                                   ccl::CCLReduceOp reduce_op,
                                   const ccl::CCLComm& ccl_comm,
                                   const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLReduce(void* in_data,
                                void* out_data,
                                size_t num,
                                DataType data_type,
                                ccl::CCLReduceOp reduce_op,
                                size_t root_id,
                                const ccl::CCLComm& ccl_comm,
                                const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLAllGather(void* in_data,
                                   void* out_data,
                                   size_t num,
                                   DataType data_type,
                                   const ccl::CCLComm& ccl_comm,
                                   const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLReduceScatter(void* in_data,
                                       void* out_data,
                                       size_t num,
                                       DataType data_type,
                                       ccl::CCLReduceOp op,
                                       const ccl::CCLComm& ccl_comm,
                                       const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLGroupStart() { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::CCLGroupEnd() { INTERFACE_UNIMPLEMENT; }

void DeviceInterface::CCLSend(void* sendbuf,
                              size_t num,
                              DataType data_type,
                              size_t dst_rank,
                              const ccl::CCLComm& ccl_comm,
                              const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLRecv(void* recvbuf,
                              size_t num,
                              DataType data_type,
                              size_t src_rank,
                              const ccl::CCLComm& ccl_comm,
                              const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CCLAllToAll(const void** send_buf,
                                  const size_t* send_count,
                                  const DataType* send_dtype,
                                  void** recv_buf,
                                  const size_t* recv_count,
                                  const DataType* recv_dtype,
                                  size_t rank,
                                  size_t nranks,
                                  const ccl::CCLComm& comm,
                                  const stream::stream_t& stream) {
  INTERFACE_UNIMPLEMENT;
}

// blas
void DeviceInterface::BlasAXPBY(size_t dev_id,
                                const stream::stream_t& stream,
                                DataType dtype,
                                size_t numel,
                                float alpha,
                                void* x,
                                float beta,
                                void* y) {
  INTERFACE_UNIMPLEMENT;
}

// profiler
void DeviceInterface::ProfilerInitialize(phi::TraceEventCollector* collector,
                                         void** user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::ProfilerFinalize(phi::TraceEventCollector* collector,
                                       void* user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::ProfilerPrepareTracing(
    phi::TraceEventCollector* collector, void* user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::ProfilerStartTracing(phi::TraceEventCollector* collector,
                                           void* user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::ProfilerStopTracing(phi::TraceEventCollector* collector,
                                          void* user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::ProfilerCollectTraceData(
    phi::TraceEventCollector* collector, uint64_t start_ns, void* user_data) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::InitBlasHandle(size_t dev_id,
                                     void** blas_handle,
                                     stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::BlasSetMathMode(size_t dev_id,
                                      void* blas_handle,
                                      int math_mode) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::InitBlasLtHandle(size_t dev_id, void** blaslt_handle) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::DestroyBlasHandle(size_t dev_id, void* blas_handle) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::DestroyBlasLtHandle(size_t dev_id, void* blaslt_handle) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::InitDnnHandle(size_t dev_id,
                                    void** dnn_handle,
                                    phi::stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::DestroyDnnHandle(size_t dev_id, void* dnn_handle) {
  INTERFACE_UNIMPLEMENT;
}

// CudaGraph
void DeviceInterface::CUDAStreamBeginCapture(size_t dev_id,
                                             stream::stream_t stream,
                                             graph::streamCaptureMode mode) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaStreamEndCapture(size_t dev_id,
                                           stream::stream_t stream,
                                           graph::CUDAGraph_t* pGraph) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphLaunch(size_t dev_id,
                                      graph::CUDAGraphExec_t exec,
                                      stream::stream_t stream) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphDestroy(graph::CUDAGraph_t graph) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphExecDestroy(graph::CUDAGraphExec_t graphExec) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphInstantiate(graph::CUDAGraphExec_t* pGraphExec,
                                           graph::CUDAGraph_t* pGraph,
                                           void** pErrorNode,
                                           char* pLogBuffer,
                                           size_t bufferSize) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphGetNodes(graph::CUDAGraph_t graph,
                                        graph::CUDAGraphNode_t* pNodes,
                                        size_t* numNodes) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaStreamGetCaptureInfo(
    size_t dev_id,
    stream::stream_t stream,
    graph::streamCaptureStatus* captureStatus_out,
    unsigned long long* id_out,  // NOLINT
    graph::CUDAGraph_t* graph_out,
    graph::CUDAGraphNode_t* dependencies_out,
    void** edgeData_out,
    size_t* numDependencies_out) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::GetParameterSetterForExecGraph(
    graph::CUDAGraph_t graph, graph::GraphHookManager* hook) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaGraphDebugDotPrint(graph::CUDAGraph_t graph,
                                             const char* path,
                                             unsigned flags) {
  INTERFACE_UNIMPLEMENT;
}

void DeviceInterface::CudaThreadExchangeStreamCaptureMode(
    graph::streamCaptureMode* mode) {
  INTERFACE_UNIMPLEMENT;
}

#undef INTERFACE_UNIMPLEMENT

}  // namespace phi