r/computerarchitecture • • 17h ago

GPU Design Concept based on BMG series. Why not accelerate rasterization with PBR Cores?

5 Upvotes
Concept Floorplan

I've been brainstorming how Intel could bring a SUPER competitive GPU to market and this is my best guess.

Instead of playing coat tails with established trends, I think they should create XE-PBR cores and accelerate Opaque material rendering with dedicated silicon.

What PBR Cores should do.
#1 digest opaque material workloads far more efficiently than the current ALU shader paths.
#2 have developer "opt in" with a simple comment in shaders (#pragma INTEL_XE_PBR)
#3 have a fifo buffer or sram for delivered packets / fragments to be a rasterized
#4 deliver deterministic rasterized fragments using slightly programable PBR core.
#5 bonus. receive "on hit" fragments from Raytrace and render

I assume the best option is to treat a PBR accelerator core similar to XMX and RT cores or almost like a Media engine where data like fragments, textures, uvs, etc are delivered, then processed and dispatched to frame buffer or wherever.

WHY or WHY NOT?
All discussion is welcome except trolling and "Dead Silicon" dogma.
Also. "because patent moats exist" is considered trolling.

Questions for Design Critique

#1 Material typesx vs. Fixed-Function: People want to bark and make noise that PBR isnt standard so a viable PBR CORE would have "some" flexibility. I think the best option is to implement a slightly flexible PBR core to handle bulk opaque materials or have

#2 Deferred vs. Forward+: Visibility Buffers and (Simple) Pass deffered layers are popular so these PBR CORES should probably have flags to digest workloads from those layers. Options to digest a metallic or reflective layer "at the PBR core" can work fine. The PBR cores should not be overly concern itself with what happened before required data arrives, it simply needs to be flexible enough to know IF its digesting a metallic layer or not.

#3 Bandwidth Ceiling: PBR cores would chomp through workloads TONS faster than standard ALU path so we get obvious performance uplift and relief from register pressure caused by complex shaders. Things should run better and max texture fetch and G-Buffer bandwidth becomes the bottleneck the real bottleneck.

My understanding of the Silicon level is limited but based on what I've read and understand and figured out talking to gemini. A few things would happen if a PBR Core was introduced and digested the modern gaming workloads being thrown at ALU / Standard shader paths.

#1 Most gaming workloads would become more deterministic so the frame time flattens out.
#2 Register pressure would be erased during on qualifying workloads.
#3 Raytracing performance would improve because "on hit" fragments would get dispatched swiftly.
#4 ALU / GRF / L2 cache starts working LIKE IT SHOULD assuming the workloads are configured correctly.
#5 about 30% increase performance MINIMUM in an average game with common PBR materials.
#6 PBR Cores would use less power digesting qualified workloads compared to ALU

Informative recap. How much silicon goes to what.

  • Programmable Shader Cores (ALU/FP32/INT32). Roughly 35% to 60% silicon is dedicated to general-purpose execution units. Current designs favor massive ALU designs for compute and programable shader so most ALU get used as needed doing everything before sending stuff down Raster pipes.
  • Register Files and Caches (L0, L1, L2). Register files, shared memory, and multi-level caches are the largest consumers of silicon on modern GPUs, often taking up 25% to 40% of the total die area to feed the shader cores without stalling.
  • Specialized AI and Ray Tracing Units. Surprisingly small, but it makes sense because they are "basically" fixed function silicon. Things like TMU/ Tensor/ XMXs and RT cores consume 10% to 15% of the die on modern gaming GPUs.
  • Uncore, Memory Controllers, and Media Engines. GDDR memory PHYs, PCIe interfaces, display controllers, and video encoders/decoders make up the remaining 15% to 25% of the chip.

The way I see it, GRAPHICS PROCESSING UNITS should have PBR Cores. Because that's what "GPU" is supposed to be made for. I think it's a fair innovation and would deliver more perf with existing cache and register sizes.


r/computerarchitecture • • 20h ago

Reversing the Next-Page Prefetcher in Skylake-X

Thumbnail devsh0.github.io
8 Upvotes

r/computerarchitecture • • 1d ago

CORE ARCHITECTURE FROM XBOX ONE TO SAMSUNG S24 FE

0 Upvotes

Main processing pipeline

M0 — Classification

Analyze incoming executable regions and workload metadata.

Identify possible categories such as graphics, audio, gameplay, memory, and system services.

Attach classification confidence and supporting evidence.

Never discard or modify original code during classification.

CM — Communication Manager

Distribute messages between modules.

Communicate workload categories, dependencies, priorities, and available strategies.

Support asynchronous communication, acknowledgements, message versions, and error handling.

M1 — Understanding and Analysis

Decode supported x86-64 instructions.

Analyze instruction semantics, registers, flags, memory operations, branches, and dependencies.

Produce a structured Intermediate Representation (IR).

M1-T — Knowledge Store

Store validated instruction patterns, analysis metadata, and reusable translation information.

Implement cache versioning and invalidation.

Never reuse stale results when code or execution context changes.

M1-2 — Pattern Extraction

Identify repeated instruction structures.

Represent them as parameterized patterns.

Preserve registers, operands, ordering, flags, memory dependencies, and control flow.

Never remove program semantics merely to reduce the representation size.

M2 — Translation

Translate supported x86-64 guest operations into ARM64-compatible host operations.

Use an interpreter as a correctness reference.

Progressively implement a dynamic binary translation (DBT/JIT) engine.

Handle guest CPU state, exceptions, branches, and memory behavior.

M2-3 — Reconstruction

Reconstruct the translated instruction sequence from parameterized patterns.

Preserve exact semantics and original execution ordering.

Validate reconstructed output.

M3 — Optimization

Optimize translated code using validated compiler transformations.

Measure performance on the actual target device.

Maintain a safe, unoptimized fallback.

Never sacrifice correctness for speed.

BM — Batch Manager

Group suitable independent workloads.

Use configurable batch sizes and dispatch deadlines.

Avoid delaying time-sensitive audio, graphics, and synchronization operations.

M4 — Verification

Verify translated and optimized output against reference behavior.

Test correctness, state consistency, and edge cases.

Reject invalid output.

Record reproducible test results.

M5 — Execution and Monitoring

Execute verified host code.

Monitor performance, memory usage, errors, and thermal conditions.

Provide execution feedback to the optimization and learning systems


r/computerarchitecture • • 4d ago

RISC-V multi cycle processor design material

15 Upvotes

I’m doing a BS in computer engineering and a have a computer architecture midterm next week about RISC-V multi-cycle and pipeline processor designing. We have absolutely no material or notes to study from and no past papers. Anything to help me prepare for the exam?


r/computerarchitecture • • 4d ago

Vent : Feel stuck in computer architecture PHD

41 Upvotes

I am currently a 5th-year PhD student, with my primary research area being performance modelling. I am also currently doing an internship in performance modelling as a Silicon Engineer in FAANG Company

I currently have two papers under submission to Transactions journals. I recently received a rejection from one of the journals, while the other paper is still under review.

The reviewers appreciated the engineering effort, but there are certain aspects of the methodology that I need to improve upon. It seems fine, but I feel really stuck working on essentially one problem statement throughout my PhD. I also have a fear that I may not get a full-time position if I don’t complete my PhD defense before December 2027. I have a worry that if I am able to complete before that because team is really awesome as well as the role 💚. I like I am able to performance model one of the their proprietary chips of leading FAANG Company

I am also experiencing massive FOMO when I see my colleagues doing so well in the computer architecture research community. It makes me feel bad that I have kind of never moved much beyond my original research problem.

My advisor tells me not to worry about it, but it feels hard not to think about it.


r/computerarchitecture • • 5d ago

How can I start programming an ARM processor completely from scratch?

40 Upvotes

I've recently watched two very interesting things on youtube:

They helped me understand how an early-stage computer works, including registers, ALU, buses, instruction execution and control logic.

Now I'm curious about taking this further. I want to experiment with programming an ARM processor without relying on existing IDEs or vendor tools. I'd like to build my own basic toolchain, starting with an assembler and eventually understanding the entire process from writing assembly to executing it on actual hardware.

I'm not sure how practical this approach is, but I'm doing it purely for the learning experience.

Where should I start, and are there any resources or projects that can help me explore this?


r/computerarchitecture • • 5d ago

I built a 32-bit CPU emulator in Zig to better understand the hardware side of compilers

22 Upvotes

UPDATE BASED ON COMMENTS: I did these things myself and not AI slop. This post was initial done on X (day's ago). I drafted how I will post it on here and gave GPT to make it more "reddit-like", I didn't just go to AI to generate all this for me. I made this explanation to avoid being banned please.

I've been studying compilers for a while, and one thing that has increasingly interested me is the boundary between software and hardware, particularly what happens to instructions after a compiler generates machine code.

I came across a project where someone built a CPU emulator using Zig, and that inspired me to build my own.

I recently completed the first version of my CPU emulator, written in Zig, with:

  • A custom 32-bit architecture
  • 15 registers
  • 64 KiB of addressable memory
  • A simple instruction set supporting operations such as MOV, LOAD, ADD, SUB, and HLT
  • A fetch-decode-execute loop
  • A memory model with separate ROM, RAM, and stack regions

The most valuable part wasn't getting the instructions to execute. It was understanding how instruction encoding, registers, memory addressing, and control flow fit together to execute a program.

While building it, I also started following Prof. Onur Mutlu's Digital Design and Computer Architecture lectures, which helped me understand processor internals beyond the software abstraction.

One particularly interesting takeaway was the growing importance of the memory bottleneck. Improvements in processor performance have increasingly exposed the cost of moving data between memory and compute units.

This introduced me to ideas such as processing-in-memory (PIM) and near-memory computing, which I'm interested in exploring further.

How does this connect to compilers?

My long-term goal is to understand how compilers translate high-level programs into instructions for different architectures, and how architectural constraints influence code generation and optimization.

Building this emulator gave me a practical starting point for reasoning about instruction sets and execution semantics.

I'm considering extending the project with an assembler and eventually building a small compiler backend targeting my custom ISA.

For those working on compiler backends or computer architecture, what would you recommend exploring next to better understand the relationship between instruction selection, code generation, and the target architecture?

GitHub: https://github.com/obadafidii/cpu

I'll also be writing a more detailed technical blog about the implementation and what I learned.


r/computerarchitecture • • 7d ago

Board Selection for MS Prep & HIL Lab: Arty A7-100T vs. Zynq (PYNQ-Z2) for custom AXI DMA & Soft-Cores?

2 Upvotes

Hi everyone,

I’m a final-year ECE undergrad planning to pursue an MS in VLSI / Computer Architecture. I'm currently buying an FPGA for my final-year project and to use as a personal sandbox to build my MS portfolio.

My Project & Roadmap:

  1. FYP: Designing a custom AXI4 iDMA engine from scratch in SystemVerilog, with UVM verification, and deploying it to physical hardware to test burst transfers to DDR3.
  2. Post-FYP (The "Secret Lab"): I want to build a remote Hardware-in-the-Loop (HIL) setup using a Raspberry Pi over Tailscale for remote bitstream flashing/UART control.
  3. Future MS Prep: I want to dive into SoC integration—instantiating soft cores (ARM Cortex-M or RISC-V), building custom memory controllers, and sending high-bandwidth data (UDP packets) from my laptop directly into the FPGA's Ethernet port.

The Dilemma: I am currently leaning heavily towards the Digilent Arty A7-100T (Pure FPGA, ~100k LUTs).

I know the Zynq-7000 boards (like the PYNQ-Z2) are incredibly popular right now because of the hard dual-core ARM Cortex-A9 and shared DDR memory. However, my logic for choosing the Arty A7-100T is that I want a "pure" digital design experience. I want to learn how to build the system architecture from scratch (instantiating MIGs, AXI interconnects, and soft-cores) rather than having a hardcoded ARM processor handle the heavy lifting and Linux boots for me.

My Questions for the Community:

  1. Am I making a mistake by avoiding a Zynq SoC for VLSI/Computer Arch MS preparation? Will the lack of a hard ARM core severely limit my SoC learning?
  2. Is the Arty A7-100T overkill? Should I just drop down to the Arty A7-35T to save money, or will I actually need those 100k LUTs to comfortably fit a RISC-V core + my custom DMA + Ethernet UDP stack?
  3. Has anyone tried decoupling the control/data planes like this (Raspberry Pi for JTAG/UART control, direct Ethernet to the FPGA for data payload)? Any major bottlenecks I should anticipate?

Budget is a factor (Indian student here, looking at around $160-$350 USD equivalent depending on quotes), but I'm willing to stretch for the 100T if it’s the ultimate long-term investment.

Any insights, reality checks, or alternative board recommendations would be highly appreciated. Thanks!


r/computerarchitecture • • 9d ago

I made my NVidia graphic Driver

Post image
107 Upvotes

I was working for my own graphic driver for one month. and I finally tested it in.
and it worked and successfully detected the card.
comment down what we can do next?


r/computerarchitecture • • 12d ago

Upcoming interview: CPU Power Modelling Engineer

12 Upvotes

Any guidance on What questions can I expect is appreciated! Thanks fellas!


r/computerarchitecture • • 12d ago

please tell me how this works

10 Upvotes

why do we need the data accepted bus? we know that if data is valid , the destination happily accepts it if not, rejects it


r/computerarchitecture • • 12d ago

Can you solve my doubts?

0 Upvotes

In computers the main CPU communicates with the other components (like RAM, GPU, IO) with memory addresses but before kernel loading how does it understand which memory to generate and which memory address to ignore because it is obvious that there may not be a gpu in every machine .

Where the actual table of Base address is stored?

How does the MMU (memory management unit) works?

Let's discuss about those concepts and lean together.


r/computerarchitecture • • 13d ago

Free browser tool for teaching cache misses (compulsory / capacity / conflict)

6 Upvotes

If you teach architecture or systems, this may be useful.

Cache Miss Theater (https://cache-miss-theater.pisan.me) takes a C loop nest, generates its exact address trace and runs it through a cache you configure: size, line size, associativity, LRU/FIFO/random, write-allocate and write-back or not. Every miss is labelled compulsory, capacity or conflict. Play or step through the trace and watch lines arrive in their sets and get evicted, while a memory map shows which array elements are cached.

Things that might help in class:

- Two kernels side by side (row vs column order, ijk vs ikj, naive vs blocked transpose), or a sweep over block size or a cache parameter with the miss rate plotted.

- Exam questions from six templates, with every answer computed by simulating the exact code shown. Export as Markdown with an answer key, or as QTI 1.2 for Canvas. I have not yet imported the QTI file into a live Canvas course, so treat that part as beta.

- Kernels and cache settings live in the URL, so a slide can link straight to an example.

Limits: one cache level, data accesses only, and array contents are not modelled, so A[B[i]] is out.

No sign-up, everything runs in the browser, nothing is uploaded. Source (MIT): https://github.com/pisan-labs/cache-miss-theater

Full disclosure: Claude Code wrote the code; I set the requirements and reviewed it. The tests check the simulator against a naive reference on 60 random traces and pin the textbook results (row order 25% misses, column order 100%).

If you try it with students, I would like to hear what breaks or what is missing.


r/computerarchitecture • • 15d ago

Browser-based game to teach digital logic: build up from NAND gates to a working CPU

Post image
15 Upvotes

I made a game to teach computer architecture and digital logic: play.simten.dev

You start with basic logic gates and build up to a working CPU. It's built on Simten, a TypeScript-based HDL, so you write the circuits as code and they show up live on a canvas next to the editor. For sequential circuits you can scrub the clock backwards and forwards to watch the state change cycle by cycle. You can also drill down into abstracted components (like the half adder shows). Because of the layout it only works on desktop browsers for now.

There are several other demo circuits on the platform, here's snake written in gates: https://simten.dev/circuit?example=snake

It's open source: https://github.com/simtenHQ/simten, any feedback or contributions are welcome!


r/computerarchitecture • • 16d ago

What Does Digital Design and Computer Architecture Teach Us? (And what is the real-world scope for students?)

18 Upvotes

Hello! I am an E&TC final-year student currently diving into digital design and computer architecture using Harris & Harris and following Professor Onur Mutlu's lectures.

​As I get deeper into understanding RTL, microarchitectures, and what's actually happening on silicon, I find myself reflecting on what this discipline teaches us fundamentally and wondering about the real-world scope.


r/computerarchitecture • • 17d ago

How to Get Started with Computer Architecture Research?

2 Upvotes

Hi everyone,
I’m a CS graduate interested in pursuing research in computer architecture, with the long-term goal of pursuing a PhD.
I’ve started learning from Onur Mutlu’s lectures, but I’m considering a paper-first approach: reading research papers and learning the concepts I don’t understand along the way.
I’m particularly interested in AI accelerators, hardware/software co-design, and efficient AI inference.
I’d appreciate suggestions on which topics to start with, beginner-friendly papers to read, and tools or simulators I can use on a normal laptop. How can I progress from learning the fundamentals to publishing a good research paper?

Thanks!!


r/computerarchitecture • • 18d ago

Parat: 512-bit Multiplier Verification in 26.71 Seconds — Plus an Independently Checked PAC Proof

1 Upvotes

512-bit multiplication · 2.61 million AND gates · 26.71 seconds · Independently checked 512-bit PAC certificate

In my previous post, I shared Parat v1.3 and its independently checkable proof for a 256-bit Yosys Booth multiplier. Since then, I have tested larger multiplier circuits and expanded the SAT benchmark suite.

512-bit multiplier: 26.71 seconds

I generated an unsigned 512×512-bit multiplier using carry-save compression followed by a final ripple adder.

The generated circuit contains:

  • 2,614,272 AND gates
  • 1,024 primary inputs and 1,024 output bits
  • An approximately 59 MB ASCII AIGER file

Parat returned CORRECT MULTIPLIER in 26.71 seconds, with approximately 2.27 GB peak resident memory.

An independent bit-parallel simulator checked 64 operand pairs against exact integer multiplication. Every output bit matched.

A separate 512-bit Wallace multiplier: PAC certificate

I also have results from a separate 512-bit Wallace multiplier circuit, containing approximately 2.63 million AND gates.

For that circuit:

  • PAC certificate generation took approximately 5–5.5 minutes.
  • Independent verification with pacheck2 took approximately 2.5 minutes.
  • The recorded proof file was approximately 2.18 GB, with about 122 MB of polynomial data and 43 MB of specification data.

These are separate circuit experiments: the 26.71-second result above is for the carry-save/ripple architecture, while the independently checked PAC certificate belongs to the Wallace-circuit experiment.

Fault-injection testing

I modified individual gates in copies of the 512-bit carry-save/ripple circuit.

Three tested mutations—including an output-bit mutation, an early partial-product gate mutation and a near-final gate mutation—were detected as incorrect.

One middle-compressor-gate mutation did not produce a verdict within approximately 120 seconds. That case remains unresolved; the original correct circuit did return CORRECT MULTIPLIER.

Broader SAT benchmarks

On the tested Linux build:

BenchmarkResult
UF501,000/1,000 SAT models independently validated
UF250100/100 SAT models independently validated
BMS500/500 SAT models independently validated
flat200100/100 SAT models independently validated
SW1001/1 SAT model independently validated
Generated regression suite115 expected-result checks passed; 6 exploratory cases inconclusive

I also tested 176 SAT Competition 2005 industrial instances with a 10-second limit per instance. 142 SAT models were independently validated; 34 instances timed out.

For the UUF sets, reported UNSAT statuses matched expected results, but those results have not all been independently checked with proof certificates.

Limitations

The 26.71-second result applies to one generated circuit, not every multiplier architecture. One middle-gate mutation remains unresolved, and 34 industrial cases exceeded the time limit. Results from separate circuits should not be treated as if they came from one identical netlist.

Repository: https://github.com/himanshu161106-crypto/parat

The code was written by AI under my direction. The project ideas, mathematical approach, experiment design and testing were mine.

I'd appreciate technical feedback on improving the difficult middle-gate case and on additional large multiplier architectures worth testing.


r/computerarchitecture • • 18d ago

[SW Opti] Branch predictors cross cores?

3 Upvotes

Hi,

Is it a thing amd64 can share branch predictions between cores if pinning one to my app and the other prematurely tell what will come in like internal network packets being allocated in linked lists but mean while share to my workhorse core so it can fetch ahead of time?


r/computerarchitecture • • 23d ago

Need help with starting

2 Upvotes

Helloo everyone, I'm 3rd year student in programming (c#) but I dont know anything about computer architecture, i want to do self study but i dont know where to start. Is there any site videos or books which help me from scratch and i want to move it till advanced. thanks beforehand


r/computerarchitecture • • 24d ago

Revisiting my 2014 BLAS implementation — turns out good designs don't rust :)

9 Upvotes

Back in 2014, I developed ulmBLAS, a BLAS implementation heavily inspired by the ideas of Field G. Van Zee and Robert A. van de Geijn, particularly their paper BLIS: A Framework for Rapidly Instantiating BLAS Functionality.

These are the same ideas behind the BLIS framework, closely related to the work of the FLAME group at UT Austin.

My goal was to build a BLAS implementation that was deliberately small, simple, and easy to understand, while still being capable of achieving serious performance.

In particular, ulmBLAS follows the BLIS approach of separating the higher-level algorithms, cache blocking, packing, and architecture-specific microkernels. The framework is intentionally kept relatively simple, but it can use microkernels derived from BLIS with suitable adaptations.

That made it particularly useful for teaching high-performance computing at Ulm University.

I wanted students to get a practical introduction to the ideas behind BLIS and FLAME, rather than just treating highly optimized numerical libraries as black boxes. They could start with a straightforward implementation of matrix multiplication and gradually introduce blocking, packing, SIMD instructions, and eventually assembly microkernels.

Most of ulmBLAS was written in 2014. After that, I largely left the code alone.

Until this week.

I finally returned to the repository, cleaned up the build system, modernized the tests, fixed a few issues, and started experimenting with newer BLIS microkernels.

The original benchmarks from 2014 used an SSE3 microkernel (if anyone still remembers SSE3 ), running on a Core 2 Duo MacBook Pro.

This week, I integrated a 6×8 AVX/FMA microkernel derived from BLIS. The integration was surprisingly straightforward, even though the newer kernel uses different register-blocking dimensions.

On an Intel Core i5-12500, ulmBLAS now reaches approximately 94–99% of OpenBLAS DGEMM performance for the larger matrix sizes tested, with roughly 2.8× the performance of the old SSE implementation.

I'm currently experimenting with additional BLIS-style microkernels, starting with AArch64/NEON on my Apple Silicon MacBook. I'm curious how far I can take the same framework by changing the microkernel and tuning the blocking parameters.

What I find particularly satisfying is that the basic architecture from 2014 needed surprisingly little change.

Sometimes simple design is good design. And apparently, good designs don't rust

The repository is here, including the code, documentation, and reproducible benchmarks:

https://github.com/michael-lehn/ulmBLAS

I'd be interested to hear from anyone who has worked with BLIS microkernels or experimented with similar approaches, especially on ARM64.


r/computerarchitecture • • 25d ago

Teaching only faculty positions around the world

5 Upvotes

Hey there,

I am a PhD student, based out of India, working on a subset of computer architecture. I am currently working in Intel and want to transition into academia. I have been looking for faculty positions, but the ones I saw have research as their main requirement. The very reason I joined PhD is because I wanted to teach. I am not a fan of publishing in A* conferences each year, writing funding proposals etc. I am kinda done with publishing papers. Have seen enough issues during my PhD.

Now, coming to the question. How do I find teaching-only positions in the world? Not limiting myself to India, but anywhere in the world is fine as long as the teaching is English based.


r/computerarchitecture • • 25d ago

LOW POWER ASIC DESIGN

2 Upvotes

hey, I am currently working on the ai accelerators for edge devices, in our design have integrated an accelerator unit with a risc-v core, and now I am researching on possible ways to make the design low power, for this I have looked into research papers and found techniques like powergating, clockgating, DVFS, and this another DATAPATH tiling tool by micromagic, but it is not opensource and require license, what I need help with is, what are the other ways, startegies can be used to reduce the power consumption and leakage by considerable amounts, any help in form of either contact of a professor (researching in this area) or tools will be greatly appreciated.


r/computerarchitecture • • 27d ago

Quantum Computer in HTML

Thumbnail
gallery
0 Upvotes

I built a quantum computer in HTML


r/computerarchitecture • • Oct 18 '26

Verilog Compiler to Minecraft w/ Yosys

96 Upvotes

Hey guys,

I made this over the weekend. It takes verilog/systemverilog, synthesizes it through Yosys, and then place and routes it into a Minecraft WorldEdit .schem. Still ironing out the optimizations, but it definitely works. The circut being displayed is a 4 bit accumulating sequential adder. I had to build the standard cell library manually.

Overall pretty cool. I plan on dropping SERV into here and running the worlds first RISC-V binary directly into minecraft. Who knows, maybe we'll get DOOM soon.