23 lines
2.7 KiB
Markdown
23 lines
2.7 KiB
Markdown
# GPUResearch
|
||
|
||
## Overview
|
||
Welcome to **GPUResearch**, a project by The Joy of Hardware, Inc., dedicated to exploring the art and science of GPU IP design. While CPU IP design is a well-documented field with extensive literature, GPU IP design remains less charted, with fewer resources available. This repository aims to bridge that gap by capturing the knowledge we gain as we work toward designing a synthesizable GPU IP core in Bluespec Haskell (BH). Our journey begins with a C-based software model, progresses through functional simulation in Clash Haskell, and culminates in a Bluespec implementation ready for FPGA synthesis.
|
||
|
||
### Primary Purpose
|
||
Initially, this repository serves as a knowledge base for documenting the lessons, challenges, and insights we uncover while learning how to design a GPU. We aim to create a valuable resource for others interested in GPU architecture, whether for educational, research, or commercial purposes. Over time, we will transition to modeling GPU IP in Clash Haskell and finally implement a synthesizable design in Bluespec.
|
||
|
||
### Project Phases
|
||
1. **C-Based GPU Model (Knowledge Capture)**: A hardware model in C, driven by PortableGL, to explore GPU architecture and document design insights.
|
||
2. **Clash Haskell Model**: A functional simulation in Clash Haskell for verification and refinement of the GPU design.
|
||
3. **Bluespec Haskell Model**: A synthesizable hardware design in Bluespec Haskell, targeting FPGA implementation and eventual commercial IP.
|
||
|
||
### Current Status
|
||
We are in **Phase 1**, focusing on a rough sketch of GPU hardware in a C model. Our high-level design revolves around a central `tick` function that updates a single `gpu_state` struct, simulating the advancement of a hardware clock cycle. PortableGL drives this model by placing commands into a command buffer within the `gpu_state` struct and retrieving results (e.g., framebuffer data) from it. This phase is about experimentation and learning, with an emphasis on documenting our findings.
|
||
|
||
## Design Overview (Phase 1)
|
||
- **Core Concept**: The C model simulates GPU behavior using a `tick` function that updates a `gpu_state` struct, mirroring a hardware clock cycle.
|
||
- **Command Buffer**: PortableGL submits OpenGL-like commands (e.g., `glDrawArrays`) to a command buffer in `gpu_state`, which the `tick` function processes.
|
||
- **Components**:
|
||
- `gpu_state` struct: Holds the GPU’s state, including the command buffer, rasterizer state, shader core state, and memory (e.g., framebuffer, vertex buffers).
|
||
- `tick` function: Advances the GPU’s state by processing commands, executing shaders, rasterizing primitives, and updating the framebuffer.
|
||
- **Output**: Results (e.g., rendered frames) are stored in the `gpu_state`’s memory and can be retrieved for verification. |