#include "caffe2/core/common_gpu.h"
#include "caffe2/core/operator.h"

#include <stdlib.h>
#include <string.h>

#include <cuda_profiler_api.h>

namespace caffe2 {
namespace {

static std::vector<std::string> kCudaProfileConfiguration = {
    "gpustarttimestamp",
    "gpuendtimestamp",
    "gridsize3d",
    "threadblocksize",
    "dynsmemperblock",
    "stasmemperblock",
    "regperthread",
    "memtransfersize",
    "memtransferdir",
    "memtransferhostmemtype",
    "streamid",
    "cacheconfigrequested",
    "cacheconfigexecuted",
    "countermodeaggregate",
    "enableonstart 0",
    "active_warps",
    "active_cycles",
};

class CudaProfileInitializeOp : public OperatorBase {
 public:
  CudaProfileInitializeOp(const OperatorDef& operator_def, Workspace* ws)
      : OperatorBase(operator_def, ws),
        output_(GetSingleArgument<std::string>("output", "/tmp/output")) {
    std::array<char, 128> buf;
    std::string tmpl = "/tmp/cuda_profile_config.XXXXXX";
    CAFFE_ENFORCE_LT(tmpl.size(), buf.size());
    memcpy(buf.data(), tmpl.data(), tmpl.size());
    auto result = mktemp(buf.data());
    CAFFE_ENFORCE_NE(strlen(result), 0, "mktemp: ", strerror(errno));
    config_ = result;

    // Write configuration to temporary file
    {
      std::ofstream ofs(config_, std::ios::out | std::ios::trunc);
      CAFFE_ENFORCE(ofs.is_open(), "ofstream: ", ofs.rdstate());
      for (const auto& line : kCudaProfileConfiguration) {
        ofs << line << std::endl;
      }
    }
  }

  ~CudaProfileInitializeOp() {
    unlink(config_.c_str());
  }

  virtual bool Run(int /* unused */ stream_id = 0) {
    // If this fails, check the contents of "output" for hints.
    CUDA_CHECK(
        cudaProfilerInitialize(config_.c_str(), output_.c_str(), cudaCSV));
    return true;
  }

 protected:
  std::string config_;
  std::string output_;
};

class CudaProfileStartOp : public OperatorBase {
 public:
  CudaProfileStartOp(const OperatorDef& operator_def, Workspace* ws)
      : OperatorBase(operator_def, ws) {}

  virtual bool Run(int /* unused */ stream_id = 0) {
    CUDA_ENFORCE(cudaProfilerStart());
    return true;
  }
};

class CudaProfileStopOp : public OperatorBase {
 public:
  CudaProfileStopOp(const OperatorDef& operator_def, Workspace* ws)
      : OperatorBase(operator_def, ws) {}

  virtual bool Run(int /* unused */ stream_id = 0) {
    CUDA_ENFORCE(cudaProfilerStop());
    return true;
  }
};

REGISTER_CPU_OPERATOR(CudaProfileInitialize, CudaProfileInitializeOp);
REGISTER_CPU_OPERATOR(CudaProfileStart, CudaProfileStartOp);
REGISTER_CPU_OPERATOR(CudaProfileStop, CudaProfileStopOp);

REGISTER_CUDA_OPERATOR(CudaProfileInitialize, CudaProfileInitializeOp);
REGISTER_CUDA_OPERATOR(CudaProfileStart, CudaProfileStartOp);
REGISTER_CUDA_OPERATOR(CudaProfileStop, CudaProfileStopOp);

} // namespace
} // namespace caffe2
