// Copyright (c) 2009-2011, Tor M. Aamodt, Inderpreet Singh
// The University of British Columbia
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution. Neither the name of
// The University of British Columbia nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

#include "scoreboard.h"
#include "../cuda-sim/ptx_sim.h"
#include "gpu-sim.h"
#include "shader.h"
#include "shader_trace.h"

// Constructor
Scoreboard::Scoreboard(unsigned sid, unsigned n_warps, class gpgpu_t* gpu)
    : longopregs() {
  m_sid = sid;
  // Initialize size of table
  reg_table.resize(n_warps);
  longopregs.resize(n_warps);
  sec_reg_table.resize(n_warps);

  m_gpu = gpu;

  m_primary_reserve_calls = 0;
  m_primary_release_calls = 0;
  m_sec_reserve_calls = 0;
  m_sec_release_calls = 0;
  m_sec_clear_calls = 0;
  m_sec_clear_regs_dropped = 0;
  m_primary_total_duration_cycles = 0;
  m_primary_completed_reservations = 0;
  m_primary_max_duration_cycles = 0;
  m_sec_total_duration_cycles = 0;
  m_sec_completed_reservations = 0;
  m_sec_max_duration_cycles = 0;
}

// Print scoreboard contents
void Scoreboard::printContents() const {
  printf("scoreboard contents (sid=%d): \n", m_sid);
  for (unsigned i = 0; i < reg_table.size(); i++) {
    if (reg_table[i].size() == 0) continue;
    printf("  wid = %2d: ", i);
    std::set<unsigned>::const_iterator it;
    for (it = reg_table[i].begin(); it != reg_table[i].end(); it++)
      printf("%u ", *it);
    printf("\n");
  }
}

void Scoreboard::reserveRegister(unsigned wid, unsigned regnum) {
  if (!(reg_table[wid].find(regnum) == reg_table[wid].end())) {
    printf(
        "Error: trying to reserve an already reserved register (sid=%d, "
        "wid=%d, regnum=%d).",
        m_sid, wid, regnum);
    abort();
  }
  SHADER_DPRINTF(SCOREBOARD, "Reserved Register - warp:%d, reg: %d\n", wid,
                 regnum);
  reg_table[wid].insert(regnum);
  m_primary_reserve_calls++;
  m_primary_resv_cycle[std::make_pair(wid, regnum)] =
      m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle;
}

// Unmark register as write-pending
void Scoreboard::releaseRegister(unsigned wid, unsigned regnum) {
  if (!(reg_table[wid].find(regnum) != reg_table[wid].end())) return;
  SHADER_DPRINTF(SCOREBOARD, "Release register - warp:%d, reg: %d\n", wid,
                 regnum);
  reg_table[wid].erase(regnum);
  m_primary_release_calls++;
  auto key = std::make_pair(wid, regnum);
  auto it = m_primary_resv_cycle.find(key);
  if (it != m_primary_resv_cycle.end()) {
    unsigned long long now = m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle;
    unsigned long long dur = now - it->second;
    m_primary_total_duration_cycles += dur;
    m_primary_completed_reservations++;
    if (dur > m_primary_max_duration_cycles)
      m_primary_max_duration_cycles = dur;
    m_primary_resv_cycle.erase(it);
  }
}

const bool Scoreboard::islongop(unsigned warp_id, unsigned regnum) {
  return longopregs[warp_id].find(regnum) != longopregs[warp_id].end();
}

void Scoreboard::reserveRegisters(const class warp_inst_t* inst) {
  for (unsigned r = 0; r < MAX_OUTPUT_VALUES; r++) {
    if (inst->out[r] > 0) {
      reserveRegister(inst->warp_id(), inst->out[r]);
      SHADER_DPRINTF(SCOREBOARD, "Reserved register - warp:%d, reg: %d\n",
                     inst->warp_id(), inst->out[r]);
    }
  }

  // Keep track of long operations
  if (inst->is_load() && (inst->space.get_type() == global_space ||
                          inst->space.get_type() == local_space ||
                          inst->space.get_type() == param_space_kernel ||
                          inst->space.get_type() == param_space_local ||
                          inst->space.get_type() == param_space_unclassified ||
                          inst->space.get_type() == tex_space)) {
    for (unsigned r = 0; r < MAX_OUTPUT_VALUES; r++) {
      if (inst->out[r] > 0) {
        SHADER_DPRINTF(SCOREBOARD, "New longopreg marked - warp:%d, reg: %d\n",
                       inst->warp_id(), inst->out[r]);
        longopregs[inst->warp_id()].insert(inst->out[r]);
      }
    }
  }
}

// Release registers for an instruction
void Scoreboard::releaseRegisters(const class warp_inst_t* inst) {
  for (unsigned r = 0; r < MAX_OUTPUT_VALUES; r++) {
    if (inst->out[r] > 0) {
      SHADER_DPRINTF(SCOREBOARD, "Register Released - warp:%d, reg: %d\n",
                     inst->warp_id(), inst->out[r]);
      releaseRegister(inst->warp_id(), inst->out[r]);
      longopregs[inst->warp_id()].erase(inst->out[r]);
    }
  }
}

/**
 * Checks to see if registers used by an instruction are reserved in the
 *scoreboard
 *
 * @return
 * true if WAW or RAW hazard (no WAR since in-order issue)
 **/
bool Scoreboard::checkCollision(unsigned wid, const class inst_t* inst) const {
  // Get list of all input and output registers
  std::set<int> inst_regs;

  for (unsigned iii = 0; iii < inst->outcount; iii++)
    inst_regs.insert(inst->out[iii]);

  for (unsigned jjj = 0; jjj < inst->incount; jjj++)
    inst_regs.insert(inst->in[jjj]);

  if (inst->pred > 0) inst_regs.insert(inst->pred);
  if (inst->ar1 > 0) inst_regs.insert(inst->ar1);
  if (inst->ar2 > 0) inst_regs.insert(inst->ar2);

  // Check for collision, get the intersection of reserved registers and
  // instruction registers
  std::set<int>::const_iterator it2;
  for (it2 = inst_regs.begin(); it2 != inst_regs.end(); it2++)
    if (reg_table[wid].find(*it2) != reg_table[wid].end()) {
      return true;
    }
  return false;
}

bool Scoreboard::pendingWrites(unsigned wid) const {
  return !reg_table[wid].empty();
}

// Secondary scoreboard methods for intra-warp co-issue

void Scoreboard::reserveRegisterSecondary(unsigned wid, unsigned regnum) {
  // No abort on duplicate — secondary may share register names with primary
  bool inserted = sec_reg_table[wid].insert(regnum).second;
  if (inserted) {
    m_sec_reserve_calls++;
    m_sec_resv_cycle[std::make_pair(wid, regnum)] =
        m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle;
  }
}

void Scoreboard::releaseRegisterSecondary(unsigned wid, unsigned regnum) {
  size_t n = sec_reg_table[wid].erase(regnum);
  if (n == 0) return;
  m_sec_release_calls++;
  auto key = std::make_pair(wid, regnum);
  auto it = m_sec_resv_cycle.find(key);
  if (it != m_sec_resv_cycle.end()) {
    unsigned long long now = m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle;
    unsigned long long dur = now - it->second;
    m_sec_total_duration_cycles += dur;
    m_sec_completed_reservations++;
    if (dur > m_sec_max_duration_cycles) m_sec_max_duration_cycles = dur;
    m_sec_resv_cycle.erase(it);
  }
}

bool Scoreboard::checkCollisionSecondary(unsigned wid,
                                          const inst_t *inst) const {
  std::set<int> inst_regs;
  for (unsigned i = 0; i < inst->outcount; i++) inst_regs.insert(inst->out[i]);
  for (unsigned j = 0; j < inst->incount; j++) inst_regs.insert(inst->in[j]);
  if (inst->pred > 0) inst_regs.insert(inst->pred);
  if (inst->ar1 > 0) inst_regs.insert(inst->ar1);
  if (inst->ar2 > 0) inst_regs.insert(inst->ar2);

  for (auto it = inst_regs.begin(); it != inst_regs.end(); it++)
    if (sec_reg_table[wid].find(*it) != sec_reg_table[wid].end())
      return true;
  return false;
}

void Scoreboard::clearSecondary(unsigned wid) {
  m_sec_clear_calls++;
  m_sec_clear_regs_dropped += sec_reg_table[wid].size();
  // Drop in-flight duration timestamps for any regs we are dropping —
  // these are abandoned reservations (e.g. warp completed, pipeline flush)
  // and counting their duration would skew the histogram.
  for (auto reg : sec_reg_table[wid])
    m_sec_resv_cycle.erase(std::make_pair(wid, reg));
  sec_reg_table[wid].clear();
}

// End-of-run accounting dump.
void Scoreboard::dumpAccounting(FILE* out) const {
  unsigned long long primary_remaining = 0;
  unsigned long long sec_remaining = 0;
  for (unsigned w = 0; w < reg_table.size(); w++)
    primary_remaining += reg_table[w].size();
  for (unsigned w = 0; w < sec_reg_table.size(); w++)
    sec_remaining += sec_reg_table[w].size();
  double primary_avg_dur =
      m_primary_completed_reservations
          ? (double)m_primary_total_duration_cycles /
                (double)m_primary_completed_reservations
          : 0.0;
  double sec_avg_dur =
      m_sec_completed_reservations
          ? (double)m_sec_total_duration_cycles /
                (double)m_sec_completed_reservations
          : 0.0;
  fprintf(out,
          "scoreboard_accounting sid=%u "
          "primary: reserves=%llu releases=%llu remaining=%llu "
          "completed=%llu avg_cycles=%.2f max_cycles=%llu "
          "| secondary: reserves=%llu releases=%llu remaining=%llu "
          "completed=%llu avg_cycles=%.2f max_cycles=%llu "
          "clearSecondary=%llu regs_dropped_by_clear=%llu\n",
          m_sid, m_primary_reserve_calls, m_primary_release_calls,
          primary_remaining, m_primary_completed_reservations, primary_avg_dur,
          m_primary_max_duration_cycles, m_sec_reserve_calls,
          m_sec_release_calls, sec_remaining, m_sec_completed_reservations,
          sec_avg_dur, m_sec_max_duration_cycles, m_sec_clear_calls,
          m_sec_clear_regs_dropped);
}

// Read-only diagnostic. Prints the primary and secondary scoreboard
// register sets for one warp. Called from deadlock_check() under
// MEMCO_DBG_DEADLOCK to help localize a stuck warp.
void Scoreboard::dump_warp_state(FILE *out, unsigned wid) const {
  if (wid >= reg_table.size()) return;
  fprintf(out, "    primary_reg_table[%u] (size=%zu):", wid,
          reg_table[wid].size());
  for (auto r : reg_table[wid]) fprintf(out, " r%u", r);
  fprintf(out, "\n");
  fprintf(out, "    sec_reg_table[%u] (size=%zu):", wid,
          sec_reg_table[wid].size());
  for (auto r : sec_reg_table[wid]) fprintf(out, " r%u", r);
  fprintf(out, "\n");
  // Long-op registers — relevant for stuck loads
  if (wid < longopregs.size() && !longopregs[wid].empty()) {
    fprintf(out, "    longopregs[%u] (size=%zu):", wid,
            longopregs[wid].size());
    for (auto r : longopregs[wid]) fprintf(out, " r%u", r);
    fprintf(out, "\n");
  }
}