#ifndef __cuda_api_object_h__
#define __cuda_api_object_h__

#include <list>
#include <map>
#include <set>
#include <string>

#include "builtin_types.h"

#include "../src/abstract_hardware_model.h"
#include "../src/cuda-sim/ptx_ir.h"
#include "../src/gpgpu-sim/gpu-sim.h"
#include "cuobjdump.h"

typedef std::list<gpgpu_ptx_sim_arg> gpgpu_ptx_sim_arg_list_t;

#ifndef OPENGL_SUPPORT
typedef unsigned long GLuint;
#endif

struct glbmap_entry {
  GLuint m_bufferObj;
  void *m_devPtr;
  size_t m_size;
  struct glbmap_entry *m_next;
};

typedef struct glbmap_entry glbmap_entry_t;

struct _cuda_device_id {
  _cuda_device_id(gpgpu_sim *gpu) {
    m_id = 0;
    m_next = NULL;
    m_gpgpu = gpu;
  }
  struct _cuda_device_id *next() {
    return m_next;
  }
  unsigned num_shader() const { return m_gpgpu->get_config().num_shader(); }
  int num_devices() const {
    if (m_next == NULL)
      return 1;
    else
      return 1 + m_next->num_devices();
  }
  struct _cuda_device_id *get_device(unsigned n) {
    assert(n < (unsigned)num_devices());
    struct _cuda_device_id *p = this;
    for (unsigned i = 0; i < n; i++) p = p->m_next;
    return p;
  }
  const struct cudaDeviceProp *get_prop() const { return m_gpgpu->get_prop(); }
  unsigned get_id() const { return m_id; }

  gpgpu_sim *get_gpgpu() { return m_gpgpu; }

 private:
  unsigned m_id;
  class gpgpu_sim *m_gpgpu;
  struct _cuda_device_id *m_next;
};

struct CUctx_st {
  CUctx_st(_cuda_device_id *gpu) {
    m_gpu = gpu;
    m_binary_info.cmem = 0;
    m_binary_info.gmem = 0;
    no_of_ptx = 0;
  }

  _cuda_device_id *get_device() { return m_gpu; }

  void add_binary(symbol_table *symtab, unsigned fat_cubin_handle) {
    m_code[fat_cubin_handle] = symtab;
    m_last_fat_cubin_handle = fat_cubin_handle;
  }

  void add_ptxinfo(const char *deviceFun,
                   const struct gpgpu_ptx_sim_info &info) {
    symbol *s = m_code[m_last_fat_cubin_handle]->lookup(deviceFun);
    assert(s != NULL);
    function_info *f = s->get_pc();
    assert(f != NULL);
    f->set_kernel_info(info);
  }

  void add_ptxinfo(const struct gpgpu_ptx_sim_info &info) {
    m_binary_info = info;
  }

  void register_function(unsigned fat_cubin_handle, const char *hostFun,
                         const char *deviceFun) {
    if (m_code.find(fat_cubin_handle) != m_code.end()) {
      symbol *s = m_code[fat_cubin_handle]->lookup(deviceFun);
      if (s != NULL) {
        function_info *f = s->get_pc();
        assert(f != NULL);
        m_kernel_lookup[hostFun] = f;
      } else {
        printf("Warning: cannot find deviceFun %s\n", deviceFun);
        m_kernel_lookup[hostFun] = NULL;
      }
      //		assert( s != NULL );
      //		function_info *f = s->get_pc();
      //		assert( f != NULL );
      //		m_kernel_lookup[hostFun] = f;
    } else {
      m_kernel_lookup[hostFun] = NULL;
    }
  }

  void register_hostFun_function(const char *hostFun, function_info *f) {
    m_kernel_lookup[hostFun] = f;
  }

  function_info *get_kernel(const char *hostFun) {
    std::map<const void *, function_info *>::iterator i =
        m_kernel_lookup.find(hostFun);
    assert(i != m_kernel_lookup.end());
    return i->second;
  }

  int no_of_ptx;

 private:
  _cuda_device_id *m_gpu;  // selected gpu
  std::map<unsigned, symbol_table *>
      m_code;  // fat binary handle => global symbol table
  unsigned m_last_fat_cubin_handle;
  std::map<const void *, function_info *>
      m_kernel_lookup;  // unique id (CUDA app function address) => kernel entry
                        // point
  struct gpgpu_ptx_sim_info m_binary_info;
};

class kernel_config {
 public:
  kernel_config(dim3 GridDim, dim3 BlockDim, size_t sharedMem,
                struct CUstream_st *stream) {
    m_GridDim = GridDim;
    m_BlockDim = BlockDim;
    m_sharedMem = sharedMem;
    m_stream = stream;
  }
  kernel_config() {
    m_GridDim = dim3(-1, -1, -1);
    m_BlockDim = dim3(-1, -1, -1);
    m_sharedMem = 0;
    m_stream = NULL;
  }
  void set_arg(const void *arg, size_t size, size_t offset) {
    m_args.push_front(gpgpu_ptx_sim_arg(arg, size, offset));
  }
  dim3 grid_dim() const { return m_GridDim; }
  dim3 block_dim() const { return m_BlockDim; }
  void set_grid_dim(dim3 *d) { m_GridDim = *d; }
  void set_block_dim(dim3 *d) { m_BlockDim = *d; }
  gpgpu_ptx_sim_arg_list_t get_args() { return m_args; }
  struct CUstream_st *get_stream() {
    return m_stream;
  }

 private:
  dim3 m_GridDim;
  dim3 m_BlockDim;
  size_t m_sharedMem;
  struct CUstream_st *m_stream;
  gpgpu_ptx_sim_arg_list_t m_args;
};

class cuda_runtime_api {
 public:
  cuda_runtime_api(gpgpu_context *ctx) {
    g_glbmap = NULL;
    g_active_device = 0;  // active gpu that runs the code
    gpgpu_ctx = ctx;
  }
  // global list
  std::list<cuobjdumpSection *> cuobjdumpSectionList;
  std::list<cuobjdumpSection *> libSectionList;
  std::list<kernel_config> g_cuda_launch_stack;
  std::map<int, bool> fatbin_registered;
  std::map<int, std::string> fatbinmap;
  std::map<std::string, symbol_table *> name_symtab;
  std::map<unsigned long long, size_t> g_mallocPtr_Size;
  // maps sm version number to set of filenames
  std::map<unsigned, std::set<std::string> > version_filename;
  std::map<void *, void **> pinned_memory;  // support for pinned memories added
  std::map<void *, size_t> pinned_memory_size;
  glbmap_entry_t *g_glbmap;
  int g_active_device;  // active gpu that runs the code
  // backward pointer
  class gpgpu_context *gpgpu_ctx;
  // member function list
  void cuobjdumpInit();
  void extract_code_using_cuobjdump();
  void extract_ptx_files_using_cuobjdump(CUctx_st *context);
  std::list<cuobjdumpSection *> pruneSectionList(CUctx_st *context);
  std::list<cuobjdumpSection *> mergeMatchingSections(std::string identifier);
  std::list<cuobjdumpSection *> mergeSections();
  cuobjdumpELFSection *findELFSection(const std::string identifier);
  cuobjdumpPTXSection *findPTXSection(const std::string identifier);
  cuobjdumpPTXSection *findPTXSectionInList(
      std::list<cuobjdumpSection *> &sectionlist, const std::string identifier);
  void cuobjdumpRegisterFatBinary(unsigned int handle, const char *filename,
                                  CUctx_st *context);
  kernel_info_t *gpgpu_cuda_ptx_sim_init_grid(const char *kernel_key,
                                              gpgpu_ptx_sim_arg_list_t args,
                                              struct dim3 gridDim,
                                              struct dim3 blockDim,
                                              struct CUctx_st *context);
  int load_static_globals(symbol_table *symtab, unsigned min_gaddr,
                          unsigned max_gaddr, gpgpu_t *gpu);
  int load_constants(symbol_table *symtab, addr_t min_gaddr, gpgpu_t *gpu);
};
#endif /* __cuda_api_object_h__ */