//
// Created by ubuntu on 11/3/21.
//
#include <debug.hpp>
void DEBUG_INFO(std::string info){
    std::cout << "\x1b[34m" << info << "\x1b[0m" << std::endl;
}

void COMPARE_MATRICES(float* data_d2h, float* data, int h, int w, std::string message){
  for(int j=0;j<h;j++)
    for(int k=0;k<w;k++)
      if(abs(data_d2h[j*w+k]-data[j*w+k])>=0.01){
        std::cout << message << "    ";
        printf("Error at (%d, %d): %.10f, %.10f\n", j, k, data_d2h[j*w+k], data[j*w+k]);
        //exit(0);
      }
}

void COMPARE_MATRICES(double* data_d2h, double* data, int h, int w, std::string message){
  for(int j=0;j<h;j++)
    for(int k=0;k<w;k++)
      if(abs(data_d2h[j*w+k]-data[j*w+k])>=0.01){
        std::cout << message << "    ";;
        printf("Error at (%d, %d): %.10f, %.10f\n", j, k, data_d2h[j*w+k], data[j*w+k]);
        exit(0);
      }
}



void MEM_USAGE(){
    // extremely non-portable
    std::cout << "\x1b[36m";
    unsigned int pid = static_cast<unsigned>(getpid());
    char statFileName[STRLEN];
    memset(statFileName, 0, STRLEN*sizeof(char));
    sprintf(statFileName, "/proc/%u/status", pid);

    std::ifstream statFile(statFileName, std::ios::in);
    if (!statFile.is_open()) {
        std::cerr << "ERROR: DDgrp::MEM_USAGE: "
             << " couldn't open file " << statFileName << "for read" << std::endl;
        return;
    }

    double vmRss  = -1.;
    double vmSize = -1.;
    double vmPeak = -1.;

    std::string buffer;
    unsigned int pos = 0;

    while (!statFile.eof()) {
        pos = statFile.tellg();
        getline(statFile, buffer);
        if (buffer.find("VmPeak:") != std::string::npos) {
            statFile.seekg(pos);
            statFile >> buffer >> vmPeak >> buffer;
        } else if (buffer.find("VmSize:") != std::string::npos) {
            statFile.seekg(pos);
            statFile >> buffer >> vmSize >> buffer;
        } else if (buffer.find("VmRSS:") != std::string::npos) {
            statFile.seekg(pos);
            statFile >> buffer >> vmRss >> buffer;
        }
    }
    statFile.close();

    vmPeak /= 1024.;
    vmSize /= 1024.;
    vmRss  /= 1024.;

    std::cout.setf(std::ios::fixed, std::ios::floatfield);
    std::cout.precision(3);
    std::cout << "Memory Usage: VmRSS = " << vmRss << "; VmSize = " << vmSize;
    if (vmPeak > 0.) {
        std::cout << "; VmPeak = " << vmPeak;
    }
    std::cout << " (MB)" << std::endl;
    std::cout << "\x1b[0m";
}


void SYSTEM_MEM_USAGE(){
  int a;
  a = system("free -m");
}
void SYSTEM_VIDEO_MEM_USAGE(){
  int a ;
  a = system("glxinfo | egrep -i 'Total available memory'");
  a = system("glxinfo | egrep -i 'Currently available dedicated video memory'");
}


#if defined (DGTD_USE_CUDA) || defined(DGTD_USE_CUDA_OPENCL)
void CUDA_MEM_USAGE(){
  size_t free;
  size_t total;
  CUDA_SAFE_CALL(cudaMemGetInfo(&free,&total));
  size_t used = total - free;
  std::cout << "\x1b[34m" << "Used Global Memory (GHz): " << used/1e9 << "\x1b[0m" << std::endl;
}
#endif

#if defined(DGTD_USE_OPENCL) || defined(DGTD_USE_CUDA_OPENCL)
#include <CL/opencl.h>

std::string getErrorString(cl_int error)
{
  switch(error){
    // run-time and JIT compiler errors
    case 0: return "CL_SUCCESS";
    case -1: return "CL_DEVICE_NOT_FOUND";
    case -2: return "CL_DEVICE_NOT_AVAILABLE";
    case -3: return "CL_COMPILER_NOT_AVAILABLE";
    case -4: return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
    case -5: return "CL_OUT_OF_RESOURCES";
    case -6: return "CL_OUT_OF_HOST_MEMORY";
    case -7: return "CL_PROFILING_INFO_NOT_AVAILABLE";
    case -8: return "CL_MEM_COPY_OVERLAP";
    case -9: return "CL_IMAGE_FORMAT_MISMATCH";
    case -10: return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
    case -11: return "CL_BUILD_PROGRAM_FAILURE";
    case -12: return "CL_MAP_FAILURE";
    case -13: return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
    case -14: return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
    case -15: return "CL_COMPILE_PROGRAM_FAILURE";
    case -16: return "CL_LINKER_NOT_AVAILABLE";
    case -17: return "CL_LINK_PROGRAM_FAILURE";
    case -18: return "CL_DEVICE_PARTITION_FAILED";
    case -19: return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE";

      // compile-time errors
    case -30: return "CL_INVALID_VALUE";
    case -31: return "CL_INVALID_DEVICE_TYPE";
    case -32: return "CL_INVALID_PLATFORM";
    case -33: return "CL_INVALID_DEVICE";
    case -34: return "CL_INVALID_CONTEXT";
    case -35: return "CL_INVALID_QUEUE_PROPERTIES";
    case -36: return "CL_INVALID_COMMAND_QUEUE";
    case -37: return "CL_INVALID_HOST_PTR";
    case -38: return "CL_INVALID_MEM_OBJECT";
    case -39: return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
    case -40: return "CL_INVALID_IMAGE_SIZE";
    case -41: return "CL_INVALID_SAMPLER";
    case -42: return "CL_INVALID_BINARY";
    case -43: return "CL_INVALID_BUILD_OPTIONS";
    case -44: return "CL_INVALID_PROGRAM";
    case -45: return "CL_INVALID_PROGRAM_EXECUTABLE";
    case -46: return "CL_INVALID_KERNEL_NAME";
    case -47: return "CL_INVALID_KERNEL_DEFINITION";
    case -48: return "CL_INVALID_KERNEL";
    case -49: return "CL_INVALID_ARG_INDEX";
    case -50: return "CL_INVALID_ARG_VALUE";
    case -51: return "CL_INVALID_ARG_SIZE";
    case -52: return "CL_INVALID_KERNEL_ARGS";
    case -53: return "CL_INVALID_WORK_DIMENSION";
    case -54: return "CL_INVALID_WORK_GROUP_SIZE";
    case -55: return "CL_INVALID_WORK_ITEM_SIZE";
    case -56: return "CL_INVALID_GLOBAL_OFFSET";
    case -57: return "CL_INVALID_EVENT_WAIT_LIST";
    case -58: return "CL_INVALID_EVENT";
    case -59: return "CL_INVALID_OPERATION";
    case -60: return "CL_INVALID_GL_OBJECT";
    case -61: return "CL_INVALID_BUFFER_SIZE";
    case -62: return "CL_INVALID_MIP_LEVEL";
    case -63: return "CL_INVALID_GLOBAL_WORK_SIZE";
    case -64: return "CL_INVALID_PROPERTY";
    case -65: return "CL_INVALID_IMAGE_DESCRIPTOR";
    case -66: return "CL_INVALID_COMPILER_OPTIONS";
    case -67: return "CL_INVALID_LINKER_OPTIONS";
    case -68: return "CL_INVALID_DEVICE_PARTITION_COUNT";

      // extension errors
    case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
    case -1001: return "CL_PLATFORM_NOT_FOUND_KHR";
    case -1002: return "CL_INVALID_D3D10_DEVICE_KHR";
    case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR";
    case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR";
    case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR";
    default: return "Unknown OpenCL error";
  }
}

#endif