Guide to Computer Processor Architecture: A RISC-V Approach, with High-Level Synthesis

Preface
	Processor Architecture: A Do-It-Yourself Approach
	RISC-V Open-Source Processor Designs
	A Very Practical Introduction to Computer Architecture for Undergraduate Students
	A Teaching Tool for Instructors With a GitHub Support
	A Practical and Detailed Introduction to High-Level Synthesis and to RISC-V for FPGA Engineers
	What the Book Does Not Contain
	An Organization in Two Parts: Single Core Designs, Multiple Core Designs
	References
Acknowledgements
Contents
Acronyms
Single Core Processors
1 Introduction: What Is an FPGA, What Is High-Level Synthesis or HLS?
	1.1 What Hardware to Put in an FPGA?
	1.2 Look-Up Table (LUT): A Piece of Hardware to Store a Truth Table
	1.3 Combining LUTs
	1.4 The Structure of an FPGA
	1.5 Programming an FPGA
2 Setting up and Using the Vitis_HLS, Vivado, and Vitis IDE Tools
	2.1 Getting the Hardware
	2.2 Getting the Software: The Xilinx Vitis Tool
	2.3 Installing the Development Board Definition in the Vitis Software
	2.4 Installing the Book Resources
	2.5 Using the Software
		2.5.1 Creating a Project
		2.5.2 Creating an IP
		2.5.3 Simulating an IP
		2.5.4 Synthesizing an IP
	2.6 Creating a Design with Vivado
	2.7 Loading the IP and Running the FPGA with Vitis
3 Installing and Using the RISC-V Tools
	3.1 Installing a RISC-V Toolchain and an Emulator/Debugger
		3.1.1 Installing the RISC-V Toolchain
		3.1.2 The Spike Simulator
		3.1.3 Building Executable Code For the RISC-V FPGA Based Processors
	3.2 Debugging With Gdb
		3.2.1 Installing Gdb
		3.2.2 Installing OpenOCD
		3.2.3 Defining a Linker Script File Compatible With the Spike Simulated Machine
		3.2.4 Using the Linker Script File to Compile
		3.2.5 Defining a Spike Configuration File for OpenOCD
		3.2.6 Connecting Spike, OpenOCD, and Gdb
		3.2.7 A Debugging Session
	3.3 Debugging a Complex Code with Gdb
4 The RISC-V Architecture
	4.1 The RISC-V Instruction Set Architecture
		4.1.1 The RV32I Registers and the RISC-V Application Binary Interface
		4.1.2 The RV32I Instructions
		4.1.3 The RV32I Instruction Formats
		4.1.4 The Assembler Syntax
	4.2 Code Examples
		4.2.1 Expressions
		4.2.2 Tests
		4.2.3 Loops
		4.2.4 Function Calls
5 Building a Fetching, Decoding, and Executing Processor
	5.1 General Programming Concepts for HLS
		5.1.1 The Critical Path
		5.1.2 Computing More to Reduce the Critical Path
		5.1.3 Parallel Execution
	5.2 The Fundamental Execution Time Equation for a Processor
	5.3 First Step: Build the Path to Update PC
		5.3.1 The Fetching_ip Design
		5.3.2 The Fetching_ip Top Function
		5.3.3 The Fetch Function
		5.3.4 The Execute Function
		5.3.5 The IP Running Condition
		5.3.6 The IP Simulation with the Testbench
		5.3.7 The Simulation Prints
		5.3.8 The Fetching_ip Synthesis
		5.3.9 The Z1_fetching_ip Vivado Project
		5.3.10 The Helloworld.c Program to Drive the Fetching_ip on the FPGA
	5.4 Second Step: Add a Bit of Decoding to Compute the Next PC
		5.4.1 The RISC-V Instruction Encoding
		5.4.2 The Fetching_decoding_ip
		5.4.3 The Fetching_decoding_ip.h File
		5.4.4 The Fetch Function and the Running_cond_update Function
		5.4.5 The Decode Function
		5.4.6 The Instruction Execution (Computing Next PC)
		5.4.7 The Fetching_decoding_ip Simulation with the Testbench
		5.4.8 The Fetching_decoding_ip Synthesis
		5.4.9 The Z1_fetching_decoding_ip Vivado Project
		5.4.10 The Helloworld.c Code to Drive the Fetching_decoding_ip
	5.5 Third Step: Filling the Execute Stage to Build the Register Path
		5.5.1 A Fetching, Decoding, and Executing IP: The Fde_ip Design
		5.5.2 Two Debugging Tools: Register File Dump and Code Disassembling
		5.5.3 The IP Running Condition
		5.5.4 The Fde_ip.h File
		5.5.5 The Decode Function and the Execute Function
		5.5.6 The Register File
		5.5.7 Computing
		5.5.8 Simulating the Fde_ip With the Testbench
		5.5.9 The Fde_ip Synthesis
		5.5.10 The Z1_fde_ip Vivado Project
		5.5.11 The Helloworld.c Program to Drive the Fde_ip on the FPGA
6 Building a RISC-V Processor
	6.1 The Rv32i_npp_ip Top Function
		6.1.1 The Rv32i_npp_ip Top Function Prototype, Local Declarations, and Initializations
		6.1.2 The Do ... While Loop
	6.2 Decoding Update
	6.3 Data Memory Accesses: Alignment and Endianness
	6.4 The Execute Function
		6.4.1 The Computation of the Accessed Address
		6.4.2 The Compute_result Function
		6.4.3 The Mem_store Function
		6.4.4 The Mem_load Function
		6.4.5 The Write_reg Function
	6.5 Simulating the Rv32i_npp_ip With the Testbench
	6.6 Synthesis of the Rv32i_npp_ip
	6.7 The Z1_rv32i_npp_ip Vivado Project
	6.8 The Helloworld.c Program to Drive the Rv32i_npp_ip on the FPGA
7 Testing Your RISC-V Processor
	7.1 Testing the Rv32i_npp_ip Processor with my Test Programs
	7.2 More Testing with the Official Riscv-Tests
		7.2.1 Running the Riscv-Tests With Spike
		7.2.2 The Riscv-Tests Structure
		7.2.3 Adapting the Riscv-Tests Structure to the Vitis_HLS Environment
		7.2.4 Adding a _start.S Program to Glue All the Tests Together
		7.2.5 The Testbench to Simulate the Tests in Vitis_HLS
		7.2.6 Running the Riscv-Tests in the Vitis_HLS Environment
		7.2.7 Running the Tests on the FPGA
	7.3 Running a Benchmark Suite on the Rv32i_npp_ip Processor
		7.3.1 The Basicmath_small Benchmark From the Mibench Suite
		7.3.2 Running the Basicmath_Small Benchmark on the FPGA
		7.3.3 The Other Benchmarks of the Mibench Suite
		7.3.4 The Mibench and Riscv-Tests Benchmarks Execution Times on the Rv32i_npp_ip Implementation
	7.4 Proposed Exercises: The RISC-V M and F Instruction Extensions
		7.4.1 Adapt the Rv32i_npp_ip Design to the RISC-V M Extension
		7.4.2 Adapt the Rv32i_npp_ip Design to the RISC-V F Extension
	7.5 Debugging Hints
		7.5.1 Synthesis Is Not Simulation: You Can Disactivate Some Parts of the Simulation
		7.5.2 Infinite Simulation: Replace the  ``Do ... While'' Loop By a  ``For'' Loop
		7.5.3 Frozen IP on the FPGA: Check Ap_int and Ap_uint Variables
		7.5.4 Frozen IP on the FPGA: Check Computations Inside #Ifndef __SYNTHESIS__
		7.5.5 Frozen IP on the FPGA: Replace the ``While (!IsDone(...));'' Loop By a ``For'' Loop
		7.5.6 Frozen IP on the FPGA: Reduce the RISC-V Code Run
		7.5.7 Non Deterministic Behaviour on the FPGA: Check Initializations
		7.5.8 Debugging Prints Along the Run on the FPGA
8 Building a Pipelined RISC-V Processor
	8.1 First Step: Control a Pipeline
		8.1.1 The Difference Between a Non-pipelined and a Pipelined Microarchitecture
		8.1.2 The Inter-stage Connection Structures
		8.1.3 The IP Top Function
		8.1.4 Control Flow Instructions Handling in the Pipeline
		8.1.5 The Fetch_decode Pipeline Stage
		8.1.6 The Execute_wb Pipeline Stage
		8.1.7 The Simulation and Synthesis of the IP
		8.1.8 The Vivado Project Using the IP
		8.1.9 The Execution of the Vivado Project on the Development Board
		8.1.10 Further Testing of the Simple_pipeline_ip
		8.1.11 Comparison of the Non-pipelined Design with the Pipelined One
	8.2 Second Step: Slice a Pipeline into Stages
		8.2.1 A 4-Stage Pipeline
		8.2.2 The Inter-stage Connections
		8.2.3 The Decode Part of the Fetch_decode Stage
		8.2.4 The IP Top Function
		8.2.5 The Bypass Mechanism in the Execute Stage
		8.2.6 The Execute Stage
		8.2.7 Memory Load Hazards
		8.2.8 The Memory Access Stage
		8.2.9 The Writeback Stage
		8.2.10 The Testbench Function
		8.2.11 The IP Synthesis
		8.2.12 The Vivado Project
		8.2.13 The Execution of the Vivado Project on the Development Board
		8.2.14 Further Testing of the Rv32i_pp_ip
	8.3 The Comparison of the 2-Stage Pipeline with the 4-Stage One
9 Building a RISC-V Processor with a Multicycle Pipeline
	9.1 The Difference Between a Pipeline and a Multicycle Pipeline
		9.1.1 The Wait Signal to Freeze Stages
		9.1.2 The Valid Input and Output Bits
		9.1.3 Fetching and Computing the Next PC
		9.1.4 The Safe Structure of a Multicycle Stage
		9.1.5 Multiple Multicycle Stages
	9.2 The IP Top Function
	9.3 The Pipeline Stages
		9.3.1 The Fetch Stage
		9.3.2 The Decode Stage
		9.3.3 The Issue Stage
		9.3.4 The Execute Stage
		9.3.5 The Memory Access Stage
		9.3.6 The Writeback Stage
	9.4 Simulating, Synthesizing, and Running the IP
		9.4.1 Simulating and Synthesizing the IP
		9.4.2 The Vivado Project and the Implementation Report
		9.4.3 Running the IP on the Development Board
		9.4.4 Further Testing of the Multicycle_pipeline_ip
	9.5 Comparing the Multicycle Pipeline to the 4-Stage Pipeline
	9.6 Proposed Exercise: Reduce II to 1
10 Building a RISC-V Processor with a Multiple Hart Pipeline
	10.1 Handling Multiple Threads Simultaneously with a Multiple Hart Processor
	10.2 A Multiple Hart Memory Model
	10.3 The Multihart Pipeline
		10.3.1 The Number of Harts
		10.3.2 The Multihart Stage States
		10.3.3 The Occupation Arrays
		10.3.4 The Multihart_ip Top Function
		10.3.5 The New_cycle Function to Copy the _to_ Structures Into the _from_ Ones
		10.3.6 The Multihart Fetch Stage
		10.3.7 The Decode Stage
		10.3.8 The Issue Stage
		10.3.9 The Execute Stage
		10.3.10 The Memory Access Stage
		10.3.11 The Writeback Stage
		10.3.12 The Lock_unlock_update Function
		10.3.13 The Running_cond_update Function
	10.4 Simulating the Multihart_ip
		10.4.1 Filling Harts with Independent Codes
		10.4.2 Filling Harts with a Parallelized Code
	10.5 Synthesizing the IP
	10.6 The Vivado Project and the Implementation Report
	10.7 Running the Multihart_ip on the Development Board
		10.7.1 Running Independent Codes
		10.7.2 Running a Parallelized Application
		10.7.3 Further Testing of the Multihart_ip
	10.8 Comparing the Multihart_ip to the 4-stage Pipeline
		10.8.1 Two Harts
		10.8.2 Four Harts
		10.8.3 Eight Harts
Multiple Core Processors
11 Connecting IPs
	11.1 The AXI Interconnection System
	11.2 The Non Pipelined RISC-V Processor with External Memory IPs
		11.2.1 The Top Function with a Bram Interface
		11.2.2 The IP Synthesis
		11.2.3 The Vivado Project
		11.2.4 Running the IP on the Development Board
	11.3 Connecting Multiple CPUs and Multiple RAMs Through an AXI Interconnect
		11.3.1 The Multiple IPs Design
		11.3.2 The CPU Top Function
		11.3.3 The CPU Header File and the Testbench Code
	11.4 Simulating, Synthesizing, and Running a Multiple IP Design
		11.4.1 Simulation
		11.4.2 Synthesis
		11.4.3 The Vivado Project
		11.4.4 Running the Multiple IP Design
12 A Multicore RISC-V Processor
	12.1 An Adaptation of the Multicycle_pipeline_ip to Multicore
		12.1.1 Adding an IP Number to the Top Function Prototype
		12.1.2 The IP Top Function Declarations
		12.1.3 The IP Top Function Initializations
		12.1.4 The IP Top Function Main Loop
		12.1.5 The Register File Initialization
		12.1.6 The Memory Access
	12.2 Simulating the IP
		12.2.1 Simulating Independent Programs on the Different IPs
		12.2.2 Simulating a Parallelized Program
	12.3 Synthesizing the IP
	12.4 The Vivado Project
	12.5 Running the IPs on the Development Board
		12.5.1 Running Independent Programs
		12.5.2 Running a Parallelized Program
	12.6 Evaluating the Parallelism Efficiency of the Multicore IP
13 A Multicore RISC-V Processor with Multihart Cores
	13.1 An Adaptation of the Multihart_ip to Multicore
		13.1.1 The Multicore Multihart IP Top Function Prototype and Local Declarations
		13.1.2 The Data Memory Accesses
	13.2 Simulating the IP
		13.2.1 Simulating Independent Programs
		13.2.2 Simulating a Parallelized Program
		13.2.3 Synthesizing the IP
		13.2.4 The Vivado Project
	13.3 Running the IP on the Development Board
		13.3.1 Running Independent Programs
		13.3.2 Running a Parallelized Program
	13.4 Evaluating the Parallelism Efficiency of the Multicore Multihart IP
14 Conclusion: Playing with the Pynq-Z1/Z2 Development Board Leds and Push Buttons
	14.1 A Zynq Design to Access Buttons and Leds on the Development Board
	14.2 A Design to Access Buttons and Leds from a RISC-V Processor
	14.3 Conclusion
Index