Skip to content

MICROARCHITECTURE.md

Latest commit

 

History

History
363 lines (334 loc) · 33.3 KB

MICROARCHITECTURE.md

File metadata and controls

363 lines (334 loc) · 33.3 KB
Raw

Matrix Core ISA - Microarchitecture Implementation

1. Overall 5-Stage Pipeline Datapath

                                    ┌─────────────────────────────────────────────────────────────────┐
                                    │                     FORWARDING UNIT                              │
                                    └────────┬──────────────────────────────┬─────────────────────────┘
                                             │                              │
    ┌────────────┐   ┌────────────┐   ┌──────▼─────┐   ┌────────────┐   ┌───▼────────┐
    │            │   │            │   │            │   │            │   │            │
    │     IF     │──▶│     ID     │──▶│     EX     │──▶│    MEM     │──▶│     WB     │
    │            │   │            │   │            │   │            │   │            │
    └────────────┘   └────────────┘   └────────────┘   └────────────┘   └────────────┘
          │               │                │                │                │
       IF/ID           ID/EX           EX/MEM           MEM/WB              │
        reg             reg              reg              reg               │
                                                                            ▼
                                                                      Register File
                                    ┌─────────────────────────────────────────────────────────────────┐
                                    │                   HAZARD DETECTION UNIT                          │
                                    └─────────────────────────────────────────────────────────────────┘

2. Instruction Fetch (IF) Stage

                         ┌─────────────────────────────────────────────┐
                         │              IF STAGE                        │
                         │                                              │
    Branch Target ──────▶│    ┌─────┐                                  │
                         │ ┌─▶│ MUX │───┐                              │
    PC+2 ───────────────▶│ │  └─────┘   │                              │
                         │ │            ▼                              │
                         │ │      ┌──────────┐      ┌──────────────┐   │
                         │ │      │    PC    │─────▶│  Instruction │   │
                         │ │      │ Register │      │    Memory    │   │
                         │ │      └─────┬────┘      └───────┬──────┘   │
                         │ │            │                   │          │
                         │ │     ┌──────▼──────┐            │          │
                         │ │     │    +2       │            │          │
                         │ │     │   Adder     │            │          │
                         │ │     └──────┬──────┘            │          │
                         │ │            │                   │          │
                         │ └────────────┘                   │          │
                         │                                  │          │
                         └──────────────────────────────────┼──────────┘
                                                            │
                                                            ▼
                                                      ┌───────────┐
                                                      │  IF/ID    │
                                                      │ Register  │
                                                      │ • PC      │
                                                      │ • Instr   │
                                                      └───────────┘

3. Instruction Decode (ID) Stage

┌──────────────────────────────────────────────────────────────────────────────────┐
│                                 ID STAGE                                          │
│                                                                                   │
│   ┌──────────────────────────────────────────────────────────────────────────┐   │
│   │                         16-bit Instruction                                │   │
│   │  ┌─────────┬─────────┬─────────┬─────────┬─────────┐                     │   │
│   │  │ Opcode  │   Rd    │  Rs1    │  Rs2    │  funct  │   R-type            │   │
│   │  │ [15:12] │ [11:9]  │  [8:6]  │  [5:3]  │  [2:0]  │                     │   │
│   │  └─────────┴─────────┴─────────┴─────────┴─────────┘                     │   │
│   │  ┌─────────┬─────────┬─────────┬─────────────────┐                       │   │
│   │  │ Opcode  │   Rt    │   Rs    │      Imm6       │   I-type              │   │
│   │  │ [15:12] │ [11:9]  │  [8:6]  │      [5:0]      │                       │   │
│   │  └─────────┴─────────┴─────────┴─────────────────┘                       │   │
│   └──────────────────────────────────────────────────────────────────────────┘   │
│                    │           │         │         │                              │
│                    ▼           ▼         ▼         ▼                              │
│              ┌─────────┐ ┌─────────────────────────────┐  ┌────────────────┐     │
│              │ Control │ │      Register File          │  │ Sign Extend    │     │
│              │  Unit   │ │      (8 x 16-bit)           │  │ Unit (6→16)    │     │
│              │         │ │                             │  │                │     │
│              │ RegWrite│ │  Read   Read   Read  Write  │  │  Imm6 → Imm16  │     │
│              │ MemRead │ │  Port1  Port2  Port3 Port   │  │                │     │
│              │ MemWrite│ │    ↓      ↓      ↓     ↑    │  └───────┬────────┘     │
│              │ Branch  │ │   Rs1   Rs2    Rd    WB     │          │              │
│              │ ALUOp   │ │  Value  Value Value  Data   │          │              │
│              └────┬────┘ └─────────────────────────────┘          │              │
│                   │            │      │      │                    │              │
└───────────────────┼────────────┼──────┼──────┼────────────────────┼──────────────┘
                    │            │      │      │                    │
                    ▼            ▼      ▼      ▼                    ▼
              ┌──────────────────────────────────────────────────────────┐
              │                      ID/EX Register                       │
              │  Control | Rs1_Val | Rs2_Val | Rd_Val | Imm | Rd | Rs1 | Rs2
              └──────────────────────────────────────────────────────────┘

4. Execute (EX) Stage with MAC Unit

┌────────────────────────────────────────────────────────────────────────────────────┐
│                                   EX STAGE                                          │
│                                                                                     │
│   From Forwarding Unit                                                              │
│         │         │         │                                                       │
│         ▼         ▼         ▼                                                       │
│   ┌─────────┐ ┌─────────┐ ┌─────────┐                                              │
│   │ MUX A   │ │ MUX B   │ │ MUX RD  │                                              │
│   └────┬────┘ └────┬────┘ └────┬────┘                                              │
│        │           │           │                                                    │
│        │    Rs1    │    Rs2    │    Rd (for MAC)                                   │
│        │           │           │                                                    │
│        │           ▼           ▼                                                    │
│        │    ┌─────────────────────────────────┐                                    │
│        │    │        MULTIPLIER               │                                    │
│        │    │                                 │                                    │
│        │    │    Product = Rs1 × Rs2          │                                    │
│        │    │         (16-bit)                │                                    │
│        │    └──────────────┬──────────────────┘                                    │
│        │                   │                                                        │
│        │                   ▼                                                        │
│        │    ┌─────────────────────────────────┐                                    │
│        │    │          ADDER                  │◀────── Rd (accumulator)            │
│        │    │                                 │                                    │
│        │    │    For MAC: Result = Rd + Prod  │                                    │
│        │    │    For ADD: Result = Rs1 + Rs2  │                                    │
│        │    └──────────────┬──────────────────┘                                    │
│        │                   │                                                        │
│        └───────────────────┼────────────────────────────────────────▶ For LOAD/    │
│                            │                                          STORE addr   │
│                            ▼                                                        │
│              ┌─────────────────────────────────┐                                    │
│              │         ALU Result MUX          │                                    │
│              │                                 │                                    │
│              │  Select based on ALUOp:         │                                    │
│              │  • ADD:  Rs1 + Rs2              │                                    │
│              │  • MUL:  Rs1 × Rs2              │                                    │
│              │  • MAC:  Rd + (Rs1 × Rs2)       │                                    │
│              │  • LOAD: Rs1 + Imm (address)    │                                    │
│              │  • BEQ:  Rs1 - Rt (compare)     │                                    │
│              └──────────────┬──────────────────┘                                    │
│                             │                                                       │
│                             │              Zero?                                    │
│                             │               │                                       │
└─────────────────────────────┼───────────────┼───────────────────────────────────────┘
                              │               │
                              ▼               ▼
                    ┌─────────────────────────────────┐
                    │          EX/MEM Register         │
                    │  ALU_Result | Rs2_Val | Zero     │
                    └─────────────────────────────────┘

5. Memory (MEM) Stage

┌────────────────────────────────────────────────────────────────────────────┐
│                              MEM STAGE                                      │
│                                                                             │
│                        ┌─────────────────────────────┐                     │
│   ALU_Result ─────────▶│         ADDRESS             │                     │
│   (from EX)            │                             │                     │
│                        │    ┌─────────────────┐      │                     │
│                        │    │   Data Memory   │      │                     │
│                        │    │    (64 KB)      │      │                     │
│                        │    │                 │      │                     │
│   Rs2_Value ──────────▶│    │  Read    Write  │      │                     │
│   (Store Data)         │    │  Port    Port   │      │                     │
│                        │    │    │       │    │      │                     │
│                        │    └────┼───────┼────┘      │                     │
│   MemRead ────────────▶│         │       │           │                     │
│   MemWrite ───────────▶│         │       │           │                     │
│                        │         │       │           │                     │
│                        │         ▼       │           │                     │
│                        │    ┌─────────┐  │           │                     │
│                        │    │MemData  │  │           │                     │
│                        │    └────┬────┘  │           │                     │
│                        │         │       │           │                     │
│                        └─────────┼───────┼───────────┘                     │
│                                  │       │                                  │
│   ALU_Result ────────────────────┼───────┼──────────────────────────────▶  │
│   (passthrough)                  │       │                                  │
│                                  │       │                                  │
└──────────────────────────────────┼───────┼──────────────────────────────────┘
                                   │       │
                                   ▼       │
                         ┌─────────────────▼──────────┐
                         │       MEM/WB Register       │
                         │  MemData | ALU_Result | Rd  │
                         └────────────────────────────┘

6. Write Back (WB) Stage

┌────────────────────────────────────────────────────────────────┐
│                         WB STAGE                                │
│                                                                 │
│   MemData ─────────────────┐                                   │
│   (from LOAD)              │                                   │
│                            ▼                                   │
│                      ┌─────────┐                               │
│   ALU_Result ───────▶│   MUX   │──────▶ Write Data             │
│   (from ALU)         │         │              │                │
│                      └─────────┘              │                │
│                           ▲                   │                │
│                           │                   │                │
│   MemToReg ───────────────┘                   │                │
│   (select signal)                             │                │
│                                               ▼                │
│                            ┌────────────────────────────────┐  │
│                            │        Register File           │  │
│                            │                                │  │
│   Rd ─────────────────────▶│  Write Address                 │  │
│   (dest register)          │                                │  │
│                            │  Write Data ◀──────────────────┤  │
│   RegWrite ───────────────▶│                                │  │
│   (enable)                 │  Write Enable                  │  │
│                            │                                │  │
│                            └────────────────────────────────┘  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

7. Forwarding Unit

┌─────────────────────────────────────────────────────────────────────────────┐
│                           FORWARDING UNIT                                    │
│                                                                              │
│   From ID/EX:              From EX/MEM:              From MEM/WB:           │
│   Rs1_Addr ────┐           EX_MEM.Rd ────┐          MEM_WB.Rd ────┐         │
│   Rs2_Addr ────┤           EX_MEM.RegWrite ─┤       MEM_WB.RegWrite ─┤      │
│   Rd_Addr ─────┤           EX_MEM.ALU_Result│       MEM_WB.Result ────┤     │
│                │                            │                         │     │
│                ▼                            ▼                         ▼     │
│   ┌─────────────────────────────────────────────────────────────────────┐  │
│   │                      COMPARATORS                                     │  │
│   │                                                                      │  │
│   │   EX Hazard:                        MEM Hazard:                     │  │
│   │   if (EX_MEM.RegWrite &&            if (MEM_WB.RegWrite &&          │  │
│   │       EX_MEM.Rd != 0 &&                 MEM_WB.Rd != 0 &&           │  │
│   │       EX_MEM.Rd == ID_EX.Rs1)           MEM_WB.Rd == ID_EX.Rs1 &&   │  │
│   │     → Forward from EX/MEM               NOT covered by EX hazard)   │  │
│   │                                       → Forward from MEM/WB         │  │
│   └─────────────────────────────────────────────────────────────────────┘  │
│                │                                │                           │
│                ▼                                ▼                           │
│        ┌────────────┐                   ┌────────────┐                     │
│        │ ForwardA   │                   │ ForwardB   │                     │
│        │ 00=RegFile │                   │ 00=RegFile │                     │
│        │ 10=EX/MEM  │                   │ 10=EX/MEM  │                     │
│        │ 01=MEM/WB  │                   │ 01=MEM/WB  │                     │
│        └────────────┘                   └────────────┘                     │
│                │                                │                           │
│                └────────────────┬───────────────┘                          │
│                                 │                                           │
│                                 ▼                                           │
│                          To EX Stage MUXes                                  │
│                                                                              │
└──────────────────────────────────────────────────────────────────────────────┘

8. Hazard Detection Unit

┌────────────────────────────────────────────────────────────────────────────┐
│                        HAZARD DETECTION UNIT                                │
│                                                                             │
│   From ID/EX:                     From IF/ID:                              │
│   ID_EX.MemRead ─────┐            IF_ID.Rs1 ─────┐                         │
│   ID_EX.Rd ──────────┤            IF_ID.Rs2 ─────┤                         │
│                      │            IF_ID.Rd ──────┤                         │
│                      │                           │                         │
│                      ▼                           ▼                         │
│   ┌──────────────────────────────────────────────────────────────────┐    │
│   │                    LOAD-USE HAZARD DETECTOR                       │    │
│   │                                                                   │    │
│   │   if (ID_EX.MemRead == 1)               ← LOAD in EX stage?      │    │
│   │   AND (ID_EX.Rd == IF_ID.Rs1            ← Next instr uses Rd?    │    │
│   │        OR ID_EX.Rd == IF_ID.Rs2)                                 │    │
│   │                                                                   │    │
│   │   → STALL = 1                                                    │    │
│   │                                                                   │    │
│   └──────────────────────────────────────────────────────────────────┘    │
│                              │                                             │
│                              ▼                                             │
│                        ┌───────────┐                                       │
│                        │   STALL   │                                       │
│                        │   Signal  │                                       │
│                        └─────┬─────┘                                       │
│                              │                                             │
│              ┌───────────────┼───────────────┐                            │
│              │               │               │                            │
│              ▼               ▼               ▼                            │
│        ┌──────────┐   ┌──────────┐   ┌──────────────┐                    │
│        │ PC Write │   │ IF/ID    │   │ ID/EX        │                    │
│        │ Disable  │   │ Write    │   │ Flush        │                    │
│        │          │   │ Disable  │   │ (insert NOP) │                    │
│        └──────────┘   └──────────┘   └──────────────┘                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

9. Control Unit Signals

┌─────────────────────────────────────────────────────────────────────────┐
│                         CONTROL UNIT                                     │
│                                                                          │
│   Opcode [15:12] ───────▶ ┌─────────────────────────────────────────┐   │
│                           │          CONTROL DECODER                 │   │
│                           │                                          │   │
│                           │  ┌─────────────────────────────────────┐ │   │
│                           │  │ Opcode │RegWr│MemRd│MemWr│Branch│ALU││   │
│                           │  ├────────┼─────┼─────┼─────┼──────┼───┤│   │
│                           │  │ LOAD   │  1  │  1  │  0  │  0   │ADD││   │
│                           │  │ STORE  │  0  │  0  │  1  │  0   │ADD││   │
│                           │  │ ADD    │  1  │  0  │  0  │  0   │ADD││   │
│                           │  │ MUL    │  1  │  0  │  0  │  0   │MUL││   │
│                           │  │ MAC    │  1  │  0  │  0  │  0   │MAC││   │
│                           │  │ SCAL   │  1  │  0  │  0  │  0   │MUL││   │
│                           │  │ BEQ    │  0  │  0  │  0  │  1   │SUB││   │
│                           │  │ NOP    │  0  │  0  │  0  │  0   │ - ││   │
│                           │  └─────────────────────────────────────┘ │   │
│                           └─────────────────────────────────────────────┘│
│                                          │                               │
│                     ┌────────────────────┼────────────────────┐         │
│                     │                    │                    │         │
│                     ▼                    ▼                    ▼         │
│               ┌──────────┐        ┌──────────┐         ┌──────────┐    │
│               │ RegWrite │        │ MemRead  │         │  ALUOp   │    │
│               │ MemWrite │        │ MemToReg │         │  Branch  │    │
│               └──────────┘        └──────────┘         └──────────┘    │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘

Summary

The hardware implementation includes:

  1. 5 pipeline stages with registers between each
  2. Forwarding unit to resolve RAW hazards without stalling
  3. Hazard detection unit to stall on load-use hazards
  4. MAC unit combining multiplier and adder for fused multiply-accumulate
  5. Control unit generating signals based on opcode