warp.hh

Go to the documentation of this file.

#ifndef SRC_WARP_WARP_HH_
#define SRC_WARP_WARP_HH_
 
#include<iostream>
#include<string>
#include<vector>
#include<array>
#include<bitset>
#include "../thread/thread.hh"
 
// Define the number of threads in a warp
#define WARP_THREAD_COUNT 32
 
// Type alias for the active mask of threads in a warp
using ActiveMask = std::bitset<WARP_THREAD_COUNT>;
 
 
enum InstructionType {
    ADD,
    SUB,
    LOAD,
    STORE,
    BRANCH
};
 
struct Instruction {
    InstructionType type;
    int dest;
    int src1;
    int src2;
    bool isBranch;
 
    Instruction(InstructionType t, int d, int s1, int s2, bool isBranch = false)
        : type(t), dest(d), src1(s1), src2(s2), isBranch(isBranch) {}
    Instruction() : type(ADD), dest(0), src1(0), src2(0), isBranch(false) {}
 
};
 
// Reconvergence point structure
struct reconvergencePoint {
    int pc;
    ActiveMask mask;
 
    reconvergencePoint(int pc_, const ActiveMask& mask_)
        : pc(pc_), mask(mask_) {}
    reconvergencePoint() : pc(0), mask() {}
};
 
enum WarpState {
    READY,
    RUNNING,
    STALLED
};
 
enum PipelineStage {
    NOT_STARTED,
    STAGE_0,
    STAGE_1,
    STAGE_2,
    STAGE_3,
    DONE
};
 
// Type alias for a group of threads in a warp
using ThreadGroup = std::array<Thread, WARP_THREAD_COUNT>;
 
class Warp {
    int id;
    int pc; // All threads in the warp share the same program counter
    ThreadGroup threads;
    ActiveMask activeMask;
    Instruction currentInstruction;
 
    std::vector<reconvergencePoint> reconvergenceStack;
 
    WarpState state;
    PipelineStage pipelineStage;
    bool isBranchDivergent = false; // Flag to indicate if the warp is currently divergent due to a branch instruction
 
    public:
    Warp();
    Warp(int warpId, const ThreadGroup& threadGroup, WarpState warpState = WarpState::READY, PipelineStage pipelineStage = PipelineStage::NOT_STARTED, bool isBranchDivergent = false);
 
     // Getter and Setter methods
    int getId() const;
    int getPc() const;
    void setPc(int pc_);
    void setCurrentInstruction(const Instruction& instr);
    Instruction getCurrentInstruction() const;
    PipelineStage getPipelineStage() const { return pipelineStage; }
    void setPipelineStage(PipelineStage stage) { pipelineStage = stage; }
    void setActiveMask(const ActiveMask& mask) { activeMask = mask; }
    std :: string getPipelineStageString() const;
    const ActiveMask& getActiveMask() const;
    WarpState getState() const { return state; }
    bool isDivergent() const { return isBranchDivergent; }
    void setDivergent() { isBranchDivergent = true; }
    // method to execute the instruction of the warp - to be called by ComputeUnit during execution
    void execute();
    std::string getInstructionTypeString(Instruction inst) const;
 
    // Methods to manage reconvergence points
 
    void addReconvergencePoint(int pc, const ActiveMask& mask);
 
    void peekReconvergencePoint() const;
 
    void popReconvergencePoint();
 
    // Method to get the size of the reconvergence stack, useful for checking if all reconvergence points have been processed
    size_t getReconvergenceStackSize() const;
 
    std::bitset<WARP_THREAD_COUNT> getActiveMaskFromReconvergenceStack() const;
};
 
 
#endif  // SRC_WARP_WARP_HH_