No, it isn't. Details lower down! Or you could just trust me ;-)
It's the max speed of LPDDR5 on a 128-bit bus. We know that Drake has a 128-bit bus from both the Nvidia hack and the Linux drivers, and LPDDR5 is the memory controller in Orin. Technically, it could go lower - Steam Deck also has a 128-bit bus and LPDDR5, but the OG model only goes up to 88 GB/s, probably for power reasons, though they jacked that up to the full 102.4 GB/s with the OLED model.
Technically it could also go
higher, if they use a newer standard like 5X instead of 5. 5X claims power savings and performance increases, but it doesn't actually apply to Drake. The way 5X (and 4X before it) work is that the LPDDR5 standard gets set, then afterward Samsung manages to node shrink the memory and the memory controller. That creates power savings, and 5X is just an "official overclock" that allows phone manufacturers (also Samsung) to take advantage of the node shrink while waiting for the next big standard (LPDDR6) to come out.
That means for Drake, the power draw is pretty much baked into the SOC regardless of the name of the standard. As for the extra performance, it probably isn't super useful (again, see below).
This is all true, but the
big win for Drake over the PS4 comes from the modern GPU. GPUs (both AMD and Nvidia's, though Nvidia got their first) changed their architecture so they don't use as much memory bandwidth.
Imagine you've got two shaders, one of which does anti-aliasing and another which does motion blur (these are just examples, the shaders can do anything). Both of these work per pixel, so they need to
read from memory all the information about each pixel then
write to memory the final result. Both of these use memory bandwidth.
The PS4 starts at the top right of the screen, and scans each pixel right to left, top to bottom, and runs the anti-aliasing shader. Then once that is complete, the motion-blur shader does the same thing.
Drake (and all other modern GPUs) cuts the screen up into smaller rectangles called tiles. For each tile, the GPU does the same process as the PS4, it starts in one corner, runs the first shader, and then when the shader completes, it starts the second shader.
This matters because of the cache. Both GPUs have caches that keep copies of data that is currently being worked on. Cache is much faster than memory, but also much more expensive, so it's much smaller. Newer data pushes old data out of cache, under the general principle that the thing you're most likely to use again is the thing you just used.
By running the anti-aliasing shader before the motion blur shader, the PS4 guarantees that the data the motion blur shader needs
first - the pixels in the top right corner of the screen - has been pushed out by the data it needs
last - the pixels in the bottom left that the anti-aliasing shader was just working on.
By splitting the screen up into much smaller tiles, the whole tile fits in cache. So for that tile, once the anti-aliasing shader is finished, the motion-blur shader
never needs to use memory bandwidth. It's all in cache from the previous shader!
This also has a second knock on effect - different GPU cores can be working on different tiles at the same time (there are multiple tiers of cache, some of which are shared between cores, and some of which are not). This allows a modern GPU to be reading data for one part of the frame while rendering another, instead of needing to read/render/read/render. It's like the difference between a garden hose that goes straight to the garden, and a big bucket that you have to haul from the kitchen. The kitchen faucet might push out water
faster but the garden hose never turns off, so they actually move the same amount of water in the same amount of time.
TL;DR - You can't compare the memory bandwidth situation on PS4 and Drake. That leads to the second question, is the 102.4 GB/s
enough for Drake. And the answer is probably "yes".
TDR;NTL;GM (Totally Did Read, Not Too Long, Gimme More):
Each core in the GPU needs a certain amount of memory to do it's work, and the faster the cores, the more reads they'll need to do, so the more bandwidth they'll need. How much bandwidth each core needs will depend on the kind of work the shader is being asked to do, which varies by engine, and by game.
So to answer this question for Drake, a chip we don't have, we need to 1) Figure out a way to measure the combination of cores and their speed. 2) Benchmark a bunch of modern games on Drake's architecture. 3) Benchmark at different levels of cores and speeds, to see how Drake's architecture scales, and 4) Benchmark with the
same cores and speed, but different amounts of memory bandwidth, to see what the right amount is. 5) Compare that to Drake
Number 1 is easy - that's what TFLOPS are. Number 2 is actually also easy, the internet is full of RTX 30 benchmarks and Digital Foundry's are particularly good for this purpose.
Number 3, I'll skip the big table, because I've shared this data before, but the entry level and midrange cards scale pretty well. In other words, if you look at the TFLOPS of a card, you can guess the performance pretty well. That says that Drake, which is a very small RTX 30 GPU, will probably run about how we expect, all else being equal.
Number 4 is hard, because we can't go build an RTX 30 GPU just for testing. Fortunately, Nvidia sells enough "Super" and "Ti" versions of cards, that we can actually compare benchmarks of the same chip with more memory bandwidth. And when we do, basically, the extra bandwidth doesn't seem to matter. 25GB/s/TFLOP is pretty consistently the sweet spot, across the line.
That leaves number 5, compare to Drake. Drake has 102.4GB/s of bandwidth, at max. One tiny challenge, that bandwidth has to also support a CPU. Let's be pessimistic and ballpark 20% of the bandwidth for the CPU. That leaves ~82GB/s for the GPU to eat.
We know that Drake has 1536 cores. So we just gotta ask what clock speed we can handle. Working backwards, that's enough bandwidth to support ~1.1Ghz clock speeds, or about 3.25 TFLOPS.
@Thraktor has done his own analysis with power and heat and landed on a "optimum" clock speed of ~1.3Ghz.
All of that nicely lines up. Drake has a design that seems optimized for power efficiency (lots of cores), memory bandwidth is power-expensive, and Drake's clock speed curves matches the amount of bandwidth allocated.
Those Nvidia folks seem to know what they're doing.