// 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 #include #include #include #include #include #include "assert.h" #ifndef SCOREBOARD_H_ #define SCOREBOARD_H_ #include "../abstract_hardware_model.h" class Scoreboard { public: // mode: 0 = legacy (primary + secondary tables), 1 = mask-aware, // 2 = slot-pinned. See scoreboard_redesign_plan.md. Scoreboard(unsigned sid, unsigned n_warps, class gpgpu_t *gpu, unsigned mode = 0); unsigned mode() const { return m_mode; } void reserveRegisters(const warp_inst_t *inst); void releaseRegisters(const warp_inst_t *inst); void releaseRegister(unsigned wid, unsigned regnum); bool checkCollision(unsigned wid, const inst_t *inst) const; bool pendingWrites(unsigned wid) const; void printContents() const; const bool islongop(unsigned warp_id, unsigned regnum); // Secondary scoreboard for intra-warp co-issue (split-level tracking). // Mode 0 (legacy) only — bypassed under modes 1 and 2. void reserveRegisterSecondary(unsigned wid, unsigned regnum); void releaseRegisterSecondary(unsigned wid, unsigned regnum); bool checkCollisionSecondary(unsigned wid, const inst_t *inst) const; void clearSecondary(unsigned wid); // Mode 1: mask-aware single scoreboard. // Each reservation entry tracks (reg, active_mask, ref_count). Hazard // checks return true iff any of the inst's read/written regs has an // entry whose mask overlaps the candidate's active_mask. See // for_claude/docs/scoreboard_redesign_plan.md for design. void reserveRegisterMask(unsigned wid, unsigned reg, const active_mask_t &mask); void releaseRegisterMask(unsigned wid, unsigned reg, const active_mask_t &mask); bool checkCollisionMask(unsigned wid, const inst_t *inst, const active_mask_t &mask) const; // Mask-agnostic helper: any in-flight writes for this warp under the // active scoreboard table. In mode 1 this checks mask_reg_table; in // mode 0 it falls through to legacy reg_table emptiness. bool pendingWritesAny(unsigned wid) const; // Per-set release dispatcher used at writeback. In mode 0, picks // primary vs secondary release based on `is_intra_legacy`. In mode 1, // releases (reg, mask) from mask_reg_table; `is_intra_legacy` ignored. void releaseSetReg(unsigned wid, unsigned reg, const active_mask_t &mask, bool is_intra_legacy); public: // Accounting / leak-detection (called from gpu-sim end-of-run dump). // Aggregates reserve/release counts, reservation-duration histogram, // and any registers still reserved at the end of simulation. void dumpAccounting(FILE *out) const; // Read-only inspector — dumps the primary and secondary reg sets for one // warp. Called from the deadlock-detection path under MEMCO_DBG_DEADLOCK // env var. No state mutation. void dump_warp_state(FILE *out, unsigned wid) const; private: void reserveRegister(unsigned wid, unsigned regnum); int get_sid() const { return m_sid; } unsigned m_sid; unsigned m_mode; // 0=legacy, 1=mask-aware, 2=slot-pinned // keeps track of pending writes to registers // indexed by warp id, reg_id => pending write count std::vector > reg_table; // Register that depend on a long operation (global, local or tex memory) std::vector > longopregs; // Secondary path register tracking (for I-Buffer half 1, intra-warp co-issue) std::vector > sec_reg_table; // Mode 1: per-warp list of mask-aware reservations. struct mask_resv { unsigned reg; active_mask_t mask; unsigned ref_count; unsigned long long resv_cycle; }; std::vector > mask_reg_table; // Mode 1 accounting (used by dumpAccounting + dump_warp_state for leak // detection on the deadlock path). unsigned long long m_mask_reserve_inserts; // new entry pushes unsigned long long m_mask_reserve_inc_refcount; // ref_count++ on existing unsigned long long m_mask_release_match; // found and decremented unsigned long long m_mask_release_nomatch; // no matching entry unsigned long long m_mask_release_erase; // ref_count hit 0 + erased class gpgpu_t *m_gpu; // ---- Accounting (per-shader, scalar; cheap to update) ---- // primary reg_table activity unsigned long long m_primary_reserve_calls; // reserveRegister insertions unsigned long long m_primary_release_calls; // releaseRegister erases // secondary sec_reg_table activity unsigned long long m_sec_reserve_calls; unsigned long long m_sec_release_calls; unsigned long long m_sec_clear_calls; // clearSecondary invocations unsigned long long m_sec_clear_regs_dropped; // total regs cleared by clearSecondary // duration tracking — sum of (release_cycle - reserve_cycle) over all completed reservations unsigned long long m_primary_total_duration_cycles; unsigned long long m_primary_completed_reservations; unsigned long long m_primary_max_duration_cycles; unsigned long long m_sec_total_duration_cycles; unsigned long long m_sec_completed_reservations; unsigned long long m_sec_max_duration_cycles; // reservation timestamp lookup: (wid,reg) -> cycle_reserved // typedef std::map, unsigned long long> resv_map_t; std::map, unsigned long long> m_primary_resv_cycle; std::map, unsigned long long> m_sec_resv_cycle; }; #endif /* SCOREBOARD_H_ */