Loading video...

Video Failed to Load

Go Home

See the CPU execution, Pipeline stages and Caches in action. This emulator animates the high level CPU and Cache state-machine. You can track the state (fetch, decode, execute, memory access, write back and ) of a given instruction... Try it here:

110,499 views • 1 year ago •via X (Twitter)

4 Comments

Matt Figdore's profile picture
Matt Figdore2 years ago

This is the biggest productivity cheat code right now. Kiss reading documents goodbye. You can get an instant summary of any document with this tool.

William Selby's profile picture
William Selby1 year ago

So cool!

Forestman's profile picture
Forestman1 year ago

Impressive, very nice. Great learning tool

Oron Port's profile picture
Oron Port1 year ago

@splinedrive you might be interested

Related Videos

Why did so many languages copy async/await from C#? Anders Hejlsberg(Anders Hejlsberg) - creator of TypeScript, C# & Turbo Pascal - on what they got right with the design: #1 - async/await was designed to solve a common problem in the event-loop model: "A lot of languages are built around cooperative multitasking in the sense that they have an event loop that sits and dispatches events. Then you handle the event and then you yield back to the event handler loop. And it all runs in a single thread cooperatively. The problem with that is if you then want to do some long running work: how do I stop in the middle of this piece of long running work and yield back to the event loop cooperatively? And then when my result is ready, I can come back and continue executing here." #2 - state machines are the solution, but hard to build: "Well, in order to do that in an inverted architecture like that, you have to build a state machine. State machines are notoriously hard for people to implement because you've got to move all of your state off of the stack into objects. And then you have this big case statement that envelopes your entire logic. It's a nightmare to figure out. But, the transformation from serially executing code into a state machine, its continuation-passing-style translation is actually one that you can do in a machine-based fashion." #3 - compilers are good at writing state machines: "You can have the compiler write the state machine if you introduce syntax that allows you to indicate where you want to yield. And that's what await is. Await is basically saying, I want to yield here, and I want to yield this promise, and then when the promise completes, I want you to come back here and continue executing. Then the compiler writes a state machine around it and it actually turns it into this big switch statement and moves all of the state that survives across the await into something that's heap allocated. So it can be brought back. And doing all of that work is something that compilers are great at. And so that was sort of the idea that we have this new style of programming where we're using promises or the equivalent of promises and the ability to yield and then we have callbacks. But trying to write your program in that style, that's also what JavaScript suffered from a lot. It's like all this callback style stuff. With Async and Await, you get the illusion that you're just writing normal sequential code and then the compiler does the painful transformation for you. That turns out to be really useful."

The Pragmatic Engineer

13,258 views • 28 days ago

Jensen Huang just identified the next $200 billion market (Save this). The shift starts with a observation about agentic AI that changes everything about infrastructure. In the era of training and inference, the GPU was everything while CPU was a traffic cop, scheduling work, managing memory, dispatching tasks while the GPU did the heavy lifting. Agentic AI breaks that model entirely. An AI agent does not just run a single inference pass but rather it plans, calls tools, executes code in sandboxes, retrieves data from multiple sources and loops through complex multi-step reasoning sequences often thousands of times per second at scale. Every one of those operations runs through the CPU and the GPU sits idle waiting for the CPU to prepare the next task, supply the right context and execute the retrieval and tool calling logic fast enough to keep the accelerators fed. The CPU is now the conductor and the GPU is the orchestra and the bottleneck is the conductor falling behind. This is showing up in production AI factory utilization right now, which is exactly why Jensen built Vera from scratch rather than licensing x86. Vera achieves 40% lower peak memory latency than x86, 50% faster core to core communication, and 1.8 times the agentic sandbox performance of current x86 processors on a purpose-built architecture designed around the agentic loop. Now here is where the investment thesis gets interesting. The obvious beneficiary is Nvidia itself, and that thesis is real. Nvidia's CFO has guided for nearly $20 billion in Vera CPU revenue this fiscal year alone, a market Nvidia had zero presence in just three years ago. Intel held 60% of server CPU market share as recently as Q4 2025 and that transition is now happening at a pace Intel structurally cannot respond to. But the deeper question is, what architecture is Vera actually built on? Vera's Olympus cores are ARM compatible and every single Vera CPU deployed in every Vera Rubin rack in every data center in the world runs on ARM architecture. And ARM Holdings collects a royalty on every one of them. ARM does not make chips but rather licenses the instruction set architecture and CPU core designs that others build on top of. Every time Nvidia ships a Vera CPU, every time a hyperscaler deploys a Vera Rubin rack, every time an enterprise qualifies Vera for their AI factory, ARM earns a royalty. The secular tailwind here is almost perfectly constructed for ARM's business model. Amazon's Graviton, Microsoft's Cobalt, Google's Axion, Apple's silicon stack, and Qualcomm's data center push all run on ARM. And now Nvidia's Vera, which is projected to displace Intel as the largest server CPU supplier by revenue in a single fiscal year, is ARM. ARM's royalty rate on high end server chips is estimated at roughly 1 to 2% of chip selling price. At $5,000 per Vera CPU and 4 million units projected for FY2027, that is a royalty line growing from near zero to potentially $400 million to $800 million annually from Nvidia's data center CPU business alone before counting Amazon, Microsoft, Google, Apple, and Qualcomm. The total ARM addressable royalty base across all the silicon it already licenses is compounding at a rate that the current $130 billion market cap does not fully reflect. Jensen's CPU thesis is the most underappreciated catalyst in ARM's fundamental story, and the royalty compounding has barely started. Come join Milk Road Pro and get our full ARM royalty model and our entire AI trade thesis. Link below!

Milk Road AI

11,819 views • 1 month ago