Moving and Grooving to RISC-V

Enjoying the show? Hating the show? Want to let us know either way? Text us!

Exploring NVIDIA's Move from ARM to RISC V in GPUs

Rob and PJ return to discuss NVIDIA's strategic shift from Falcon and ARM microcontrollers in their GPUs to the open-source RISC V. The conversation delves into the history, technical considerations, and licensing challenges of microprocessors. They examine why ARM's longstanding presence is being challenged by RISC V, especially for embedded controllers, its flexibility, and cost advantages, alongside security concerns and the future potential of open-source hardware.

00:00 Welcome Back to Tricky Bits
00:27 NVIDIA's Shift to RISC V Microcontrollers
02:02 The Role of Microcontrollers in Modern Devices
04:33 Technical Challenges and Limitations
06:18 Designing Custom Microcontrollers
16:33 RISC V: The New Contender
18:00 Comparing ARM and RISC V
24:13 Apple's Strategic Choices
31:48 RISC V Maturity and Market Penetration
33:58 Challenges and Security Concerns
36:53 Financial Incentives and Reference Models
40:48 Comparing RISC V and ARM
42:25 Security Concerns with Chinese RISC V Chips
49:22 Microcontrollers and Their Ubiquity
54:34 Future of Processor Diversity
58:28 Open Source Innovation and Ecosystem

Episode Transcript

PJ (00:10):
welcome back, everybody.
It's Tricky Bits with Rob andPJ.
We know it's been a while and weapologize.
We had a few things going on,but we missed you.
We know you missed us and we'rehappy to be back.
Now, Rob, today we're going tobe kicking off the discussion a

(00:31):
bit around.
NVIDIA replacing its Falcon andARM microcontrollers within the
GPUs with RISC V or RISC V, Ithink there's a really
interesting question case studyhere with microprocessors in
general, in terms of like, Hey,we used to be all.

(00:52):
X 86 and arm risk fives comeonto the scene.
And I think there's someinteresting questions around
both technical areas, as well asthe licensing areas.
So let's kick it off with Rob.
why is Nvidia replacing theseFalcon and arm microcontrollers
within the GPUs?
Are they working just fine?

Rob (01:13):
Yeah, I guess they were working just fine, but they're
old, and at least especially theFalcons, the Falcons have been
in NVIDIA GPUs since theoriginal GeForce days.
So they're getting kind ofdated.
They need modernmicrocontrollers to be able to
do what they want to do with.
I mean, the amount of work thesemicrocontrollers do in these

(01:35):
bigger devices is quitesignificant.
So having a 20 year old embeddedcontroller that you're kind of
having to coerce into doingthese things is, is not the best
thing.
And if you're going to replaceit, obviously ARM is the obvious
place to go, but then you've gotall the licensing issues and
like that, that you have to dealwith, where if you go to RISC V,

(01:58):
do what you want.

PJ (01:59):
So let's talk a little bit about the microcontrollers
themselves.
These aren't the compute unitsthat are being used inside the
GPUs.
What are the Falcon and Armmicrocontrollers being used for
today?
Like what is their purpose?

Rob (02:12):
So.
NVIDIA GPUs, iPhones, all Appleproducts, like all NVIDIA
products, all Google productshave a significant number of
these embedded controllersthroughout the device a, on a
GPU, for example, the.

(02:32):
You send these command buffersto the GPU DMA'em, to the
command buffer, you DMA, thecommand buffer to the GPU and it
processes it.
It's really, you're sending itto a microcontroller and that
microcontroller is reading eachcommand one by one and sending
it on to its next destination,which could be another hardware
block or controller or whateverit may be.

(02:54):
And that's what these things do.
And there's a lot of them.
Each engine might have its ownin an iPhone.
There's probably multiple 20,30, 40 of these things embedded
across the device.
They are literally everywhere.
The ISP has a couple in it,inside the camera stack, a lot
of what the logic that's happensis done in software.

(03:18):
All the audio systems havemultiples of these things
stacked up and.
Apple currently use ARM, butthey are, at least when I was
there, they were looking atmoving to RISC V for audio and
then other things afterwards.
So these things are everywhereand it's not nothing to do with
the that you see as applicationprocessors.

(03:39):
They're the big processors,obviously, that you run your
applications on and the GPU is.
thing that gets the spotlight,but behind the facade of GPU,
like what is the bits in theGPU?
Yes, there are compute engines,there are shader engines, there
are a bit of fixed function forrasterizing, but it's all glued

(04:00):
together by these embeddedmicrocontrollers.
if you look, I like the Linuxcode.
There's a folder calledfirmware, and that's the that
loads into thesemicrocontrollers.

PJ (04:13):
So, these are the glue that really Makes the compute happen.
They, they, they're trafficcontrollers.
They're the ones who shuttlethis stuff around.

Rob (04:23):
They're not doing any real work.
They're just sending data towhere it needs to be, reporting
errors, flagging various thingsor whatever it may be.
They're not doing any real workas you see it as an end user.

PJ (04:33):
from a technical perspective, where are we
reaching the limits right now,where it's like, Hey, this
Falcon, this armmicrocontroller, you know, it
needs to be faster, it needsmore bandwidth or what are like
really the technical limits thatare.
Causing there to be some conceptof we need to make a change and
we have this decision gate.

(04:54):
We need to talk about whetherit's designing a new falcon chip
or licensing a new arm core orgoing to risk 5.
What is it?
Technically that is that ismotivating this.

Rob (05:04):
Features, as, as always, if like you couldn't, couldn't run
a modern application on a 6502,you wouldn't even attempt it.
Memories, not enough, what itcan access, how fast it can do
it are all big issues.
And obviously, 8851, which wasexisted alongside the 6502 still
exists to this day, Intel usedthem everywhere and they've

(05:26):
modified it and added things toit.
But, Ultimately it has limits.
These embedded controllers needto be able to see address space.
And if you're a 32 bitcontroller, and now you've in a
64 bit machine, then how do youpresent memory across that?
And we just make the embeddedsystem 64 bits so we can see

(05:47):
everything it needs to see?
Do you page it in piece bypiece, move it around?
It's all obviously part of thedesign, but at some point it
just becomes the problem itself.
Is this embedded controller onthis?
Getting the data you needthrough it becomes more and more
problematic.
And when that happens, do youextend it, make it bigger, make

(06:08):
it faster, it 64 bits, or do youjust go, why design a
microcontroller?
This one already exists.

PJ (06:17):
Well, let's talk about that.
So I'm NVIDIA.
I'm Apple.
I have the premier chipdesigners in the world working
for me.
Why not just design my ownmicrocontroller?
They did it with Falcon.
Why not do it again?

Rob (06:29):
Sure.
You can put verifying it,testing it and maintaining it
is.
super expensive and takes time.
Today it's, and toolset, all ofthat plays a factor.
You need, now you need asoftware team to go and modify
LLVM so it can generate code foryour processor.

(06:50):
All that's already done if youtake ARM or RISC V.

PJ (06:54):
Okay.
So I'm an NVIDIA or Apple RISC Vis really the new kid on the
block.
We're talking about somethingthat maybe is only, you know, 15
years old at this point in time.
Arm's been around forever.
It's power efficient.
has really stolen the thunder interms of like the mobile space.
It has done tremendous stuff interms of Apple changing over to

(07:14):
that instruction set for AppleSilicon.
Why not just continue to choosearm at that point in time?
That feels like a no brainer.

Rob (07:22):
So ARM has been around for a while, yeah.
I mean, I was working on theoriginal ARM 2 in 1985, 86,
something like that.
So it's It's a 40 years old.
So arm is no spring chicken.
People like to compare it to x86and it's only 10 years newer the
most.
arm is It's been around a longtime and.

(07:44):
Obviously, Arm's licensing modelplays into all of this is Arm
don't actually make processors.
They might make a few reference

PJ (07:52):
Silence.

Rob (08:08):
One of them, two of them, 10 of them, doesn't matter.
in there and add the

PJ (08:13):
going to go ahead and start the recording, and I'm going to
go ahead and start therecording.

Rob (08:34):
is.
And that's when you'll seethings like A72s.
That's

PJ (08:38):
Okay.

Rob (08:55):
Qualcomm, Apple and video, all of what's called
architectural licenses, and candesign their own ARM processors.
So it is, which is why AppleSilicon isn't an A72 and the.
The Qualcomm processors are notknown ARM cores because
internally architecturallydesigned by Qualcomm.
Now they have to play along withARM's rules.

(09:17):
Part of the licensing agreementis there's a book called the ARM
ARM, which is the, the Bible ofARM.
It tells you of every singleinstruction side effects and the
signals it needs to generate andthings like this.
And there's a whole test suitethat goes through that.
As long as your chip passes thattest suite and it's now a legal
ARM chip, you're good to go.
So there's no connection betweenall these big ARM processors.

(09:39):
They're all designed internally.
They all have architecturallicenses.
That's kind of where it ends.
So that, that accounts for thebig application processes, the
Apple silicon processors, theseembedded controllers, you still
have to license them.
some of these companies onlyhave an architectural license
for say 64 bit.
So they can't make a 32 bitversion of the processor.

(10:01):
They can buy an off the shelfone or call, but it costs.
And if you have 20, 30, 40 ofthese things in a device that
are just doing mundane jobs,then that cost starts to
significantly add up.
And yes, the cost of pennies onsome of these things, but it
adds up not having that controlof your own destiny is also a

(10:23):
factor for some of thesecompanies.
For example, You're not allowedto add instructions to ARM.
They very much frown upon you,the base and adding new
instructions.

PJ (10:33):
Well, let's do they frown or they just disallow it as part of
the licensing agreement?
I guess I want to be clear onthis one.

Rob (10:41):
other end of that license is really what it comes down to.

PJ (10:43):
I say, okay, so that's.

Rob (10:48):
have relaxed that a little bit in the last couple of years.
Because of the obvious issuesthat it creates.
It's traditionally it wasalways, I want to have this
extra feature to the processor.
And could do it as a coprocessor and then use the
existing co processorinstructions within ARM to
communicate with it.
But if you wanted to add thatactual new instruction to the

(11:10):
core instruction set, youweren't allowed to.
And this came up for Apple tosome extent because they added
AMX which is the matrixextensions.
And they added that as a coprocessor and then you have to.
They added a few instructions tocommunicate with it, but there
is a bank of instructions wherethey are vendor specific, but
that's all you get.
So modifying the corearchitecture, if you wanted to

(11:31):
change out the ad instructionworked, like I want add to do
something different to thecurrent ad instruction is.
I mean, what you would do, Idon't know, but you can't.
If you want to re implement howad works, that's fine.
As long as you pass the ARMchecks at the end.
If you want to make themultiplier be a single cycle

(11:52):
integer multiplier instead of amulti cycle integer multiplier,
that's absolutely allowedbecause you're not changing the

PJ (11:58):
Okay.
Okay.

Rob (12:16):
designated

PJ (12:17):
Okay.

Rob (12:17):
instructions.
That's all you get.

PJ (12:19):
So, so effectively you're allowed to change the
implementation to your heart'sdelight, but you cannot change
the

Rob (12:26):
license.

PJ (12:27):
got it if you're an architectural license, but you
cannot change the interfaceregardless of license is what
you're telling me.

Rob (12:33):
Yeah.
And yes, I mean, you're sayingregardless, but did it a little
bit.
So

PJ (12:39):
Sure.

Rob (12:40):
there are ways and means by playing by the rules as much as
you can, and then do the minimalwhat you need to do.
For example, if you took someAMX

PJ (12:48):
It's good.

Rob (12:49):
ran on an Apple Silicon, it wouldn't work on any other
device.
And I think that's what ARM as awhole want to avoid.
They want to avoid fragmentationof the Silicon, fragmentation of
the tool chains and things likethat.

PJ (13:01):
Got it.
I mean, I was going to say withApple, it's, it's good to be a 3
trillion company.
It gives you some leeway.

Rob (13:07):
And

PJ (13:07):
Now,

Rob (13:08):
I mean, they they almost bought ARM.
And it's probably reasons likethis that it would have made a
lot of sense for NVIDIA, or evenApple, to own ARM.
Business wise, globally, may notbe such a good idea.
Internally, once they had thatcontrol, they could do things
like this and they couldtechnically do it anyway, but
they'd be in violation of thatlicense.
And I mean, Arm aren't shy oftaking these people to court as

(13:30):
Qualcomm's fine enough.
Yeah,

PJ (13:31):
right, well, what's interesting is that we're
talking right now about alicensing agreement that
prevents you from doing what youwant to do technically.
So ideally, Apple would haveloved to place these matrix
extensions directly like theywouldn't have to design a
separate coprocessor and thenuse the.
Special magic to sendinstructions to that

(13:53):
coprocessor.
I would want it right in theprocessor to be able to do what
I want and not spend theoverhead technically to actually
like execute these instructions.

Rob (14:03):
And then you get into, I mean, these are all of the
application level processes.
It's still kind of way today.
The small embedded arms today,you can modify the instruction
set.
At least add to it.
You can't modify it, but you canadd to it.
it's these embedded controllersthat we're talking about.
We've obviously Apple Siliconand AMX are all of the big

(14:24):
application things.
small embedded ones.
Sometimes I like, I need acortex.
I need a dual core cortex M0,but I need atomic operations so
that can communicate between thetwo dual cores.
Cortex M0 doesn't have atomic.
Instructions.
now you're going to switch aninterrupts off and things like
that.
So you can update one withoutthe others being able to do it

(14:46):
at the same time.
Like old fashionedmultiprocessor things, like
this.
Like I can add atomicinstructions to this core, but
I'm not allowed.
I can add it, whatever this maybe, but I'm not allowed.
I could add this different busbut I'm not allowed where if you
take your own core and videowith Falcon or.
Something that they might wantto design in house.

(15:07):
They can add all this as theywish and modify it as they wish.
No one cares if X or processorY, or they will have the same
name or even the same thing.
Like, none of it's public.
It's all in deeply embedded.
It's,

PJ (15:23):
much.
Well, let's, I just want to stayon, yeah, we'll get the risk on
Wednesday.
I just want to stick on one morepoint.
So you're talking aboutextending the, the arm
microcontrollers.
Do I need a separate license forthat?

(15:43):
Cause we talked about, Hey, I'vegot a six.

Rob (15:45):
exists for that.

PJ (15:48):
Oh, for the microcontrollers.
You don't need to,

Rob (15:49):
can,

PJ (15:50):
you don't need to actually.

Rob (15:51):
but an architectural license for microcontrollers is,
I don't think anyone does itbecause this

PJ (15:56):
Okay.

Rob (15:57):
incident license is so expensive and it's so hard to
redesign these processes.
Why would you do it for a tinymicrocontroller?
Especially a

PJ (16:05):
Okay.
Got it.

Rob (16:06):
your hands are tied.

PJ (16:06):
Do we end up in a spot where it's like, I can't.
Make the changes I want to makebecause it's not worth it.
But these are starting to becomethe problem we talked about
earlier.
They're the bottleneck that Ineed to actually make a change
to.

Rob (16:18):
can't make the changes you want.
The license doesn't reallyexist.
If I could modify it, I'mbasically designing this tiny
little controller from scratch.
Might as well just make my own.
And that goes to the originalpoint of why not just make your
own?
The reason you don't make yourown is because RISC V exists.

PJ (16:33):
so 15 years ago, I didn't really have much of a choice,
right?
I basically like was stuck witharm and I don't know, Whomever
else I might want to try andlike snag a microcontroller
from.
Nowadays, we've got this newshiny open source RISC V.
What makes it appealing?
let's talk about the license ofit.
It is open source, correct?

Rob (16:54):
a license,

PJ (16:56):
So,

Rob (16:57):
you take,

PJ (16:58):
I mean,

Rob (16:58):
an ISA, which is defined.
That's the open source part.

PJ (17:02):
yeah.

Rob (17:02):
if you want to modify the ISA, you really need to be part
of the consortium that runs RISCV.
You can't just submit a PRsaying, I need a new
instruction.
There's a lot of big companiesinvolved now.
They're designing a very clean,very modern instruction set, and
can take that and implement itas you wish you want to add to
it, add to it.

(17:22):
Do you want to remove things?
Remove things.
If you want to make it opensource back to the public, do
so.
If you want to give your designsback to the public.
Do so, you don't have to, if youmake a really fast custom

PJ (17:35):
Um,

Rob (17:42):
and I get my little feature that I, that I need.
why wouldn't you go down thatpath?
It's already been, it's aninstruction set that's been
tested.
Again, it has tool support, ithas debug support, it has
fabrication layout support.
why would you start fromscratch?
I

PJ (17:58):
Okay, risk five.
It's ready to go.
Like we've got the, as you said,the tool chains, we've got the
fabs, we got everything likeready for it to action.
Why isn't it then like thenatural choice for everyone just
to jump on?
Like, are there any actualquestions about, do I still pick
arm today?

(18:18):
Or do I You know, create a RISCV chip.
what would be the blocker indoing this?
Other than, oh, we know ARMworks.
We have these, these long, deepsupply chains for this stuff.
What prevents us from likejumping to RISC V?
Because it seems like it solvesa whole lot of problems all at
once.

Rob (18:37):
think a lot of that depends on what you're aiming for.
If you're looking at these smallmicrocontrollers and you're
paying a license fee per, thenobviously there's a financial
incentive to use ARM for thesemicrocontrollers.
If you're looking at theapplication side, then RISC V is
only just getting up to speed atmulti gigahertz processors.
They're very expensive to layout.

(18:58):
They're very hard to lay out atthat speed.
And it takes somebody to go doit.
So people are,

PJ (19:07):
Okay.
You

Rob (19:34):
point, things like that.
And that's it.
It's the knowledge base ofknowing how to work with ARM and
knowing how to do this.
That's lacking in theseprocessors.
And a lot of these big companiesare not laying out these
massive, there's no Apple sizedcompany who's saying we're all
in on RISC V.
We're going to make a multigigahertz chip, multi core.

(19:55):
We're going to compete withApple Silicon with the RISC V
design.
Nobody's saying that.

PJ (20:00):
So, so, and is that purely a maturity question or is there
anything particular about riskfive that makes it difficult to
do this multi gigahertz support,we need time to literally bring
it up to speed.

Rob (20:14):
Some of that and.
maturity, there's things like,how does multi core work on with
atomics?
How does SIMD or wide vectorinstructions work?
Some of that's in RISC V, someof it's still getting added.
so ARM is definitely ahead ofthe game as far as modern
requirements, but a lot of it isin design of these chips.

(20:38):
Like, okay, we've got the ISA,how do I make silicon that runs
the ISA?
ARM's been around for a longtime.
They've been doing this for along time.
There's a lot of people who knowhow to do it with ARM.

PJ (20:46):
this is actually kind of a fascinating pattern, and when
ARM first came on the stage, Imean, obviously, it's been
around since the 80s, so it'sbeen around for quite a long
time.
I feel like it really hit thecultural zeitgeist with mobile
devices.
And people really got tuned intothe fact that, Hey, this is

(21:09):
efficient, low poweredprocessors that I'm using to run
my mobile phones.
x86 couldn't shrink downappropriately to become as power
efficient to compete in thatspace.
Risk five in this case againseems to be targeting these low
powered microcontrollers, butinstead of necessarily being a

(21:31):
big technical advantage, itseems like the main advantage
is, hey, I can get the power Iwant.
I can get the processing I wantout of these microcontrollers.
I just don't have to pay a loton the licensing side.
Is that a fair statement or doyou think that there's more to
it technically?

Rob (21:48):
it's very much that.
It's the same as the Linuxargument of how much would
Microsoft have loved to be inthe server that was on every
single.
server on the planet.

PJ (22:01):
Yeah.

Rob (22:02):
It's like, but it wasn't going to be the people were
like, we don't want to pay thelicense fee.
The license fee is a barrier toentry.
And how about the same thing forLinux?
It runs everywhere.
Yeah.
It runs in cars.
It runs in set top boxes,routers, phones, desktops,
servers, pretty much everywhereyou need a full fledged
operating system, you can takeLinux, modify it as you wish.

(22:24):
Make it work.
Can you do that with Windows?
Absolutely not.
You take what they give you andthat's what you get.
And

PJ (22:31):
Okay.
Okay.
Okay.

Rob (23:01):
If

PJ (23:01):
Okay.
Okay.
You

Rob (23:25):
you'll use to do that will be very different for the high
speed processor engineers whowill do it at a much higher,
higher clock speed.
And they're not even close tothe same.

PJ (23:33):
Again, it's fascinating because what we're talking about
here is that RISC V has thisability to really nip at the
heels of ARM at the low powersection simply because you can
eliminate that licensing fee.
It sounds like ARM doesn't havea lot to worry about near term
that these high powered chips,you know, in my phones where

(23:55):
it's like the main processorstill need to be ARM.
The one that's in my, my.
Like Macbook is still going tobe an ARM chip for the time
being, at least until they startto figure out how to make these
multi gigahertz RISC Vprocessors actually work,

Rob (24:13):
ARM obviously have an edge in the game because why did
Apple pick ARM when they went toApple Silicon?
They could have just been like,we'll make our own thing.
We're already going to do theentire internals ourselves.
If we have to stick to thislicensing agreement, Then it's
kind of a hindrance to them.
But there's also a lot of gainsyou get from it.
So, I mean, Apple were in aposition where they were already
going to switch instructionsets.
They could have just been, we'regoing to make something

(24:34):
completely new.
Apple don't give their processesaway to anybody else anyway.
So if it was

PJ (24:39):
right?

Rob (24:39):
It wouldn't have made any difference to anybody outside
except the compiler would havechanged.
it is just the way it is.
I mean, even with AMX now, it'sbarely documented and what is
documented is all been done byreverse they already have these
in house and it's very Apple tonot document anything and not
share anything.
They could have just said, no,we're not doing ARM.

(25:01):
We're just going to do AppleSilicon is Apple Silicon.
It's nothing to do with ARM.
It's not x86.
It's not ARM.
It's what we came up withinside.

PJ (25:09):
Okay.
Let's let's press it.

Rob (25:10):
of

PJ (25:11):
Why not do that?

Rob (25:12):
lot of architecture and a lot of

PJ (25:14):
Hmm.

Rob (25:14):
who come from experts.
And anyone can sit down anddesign an instruction set.
It's just how good will it bewhen you pull it into a real
application?
And that's why these have to bedesigned by real people and not
just.
Designed by, oh, look, I'll havean instruction that does this
and this and this.
You end up with x86 if you dothat.
Again, asks the question of whydid Apple go with ARM?
There's obviously a reason.

PJ (25:34):
it's, it's sort of a fascinating.
Progression because I could lookat the, you know, if you look
at, at, Hey, there's theMotorola days for Apple
transitioning to, to the Inteldays.
And in many ways I could, Icould almost look at those as
being incredibly similar in thesense that it was an instruction
set and a chip that was fabbedfor me in either of those cases.

(25:58):
And then,

Rob (25:59):
And none of Apple's history,

PJ (26:01):
yeah,

Rob (26:01):
68, 000, they went to PowerPC, which was the Motorola
connection.

PJ (26:06):
right.

Rob (26:06):
to Intel x86 and then And then ARM.

PJ (26:14):
Right.

Rob (26:15):
good at transition architectures.
They are actually very good atthat.
They never got in a positionbefore where you could do that.
You can't take an Intel chip andredesign it as you wish.
You can't take the Intelinstruction set.
And make your own executionengine for that instruction set.
do, because they have ahistorical connection to Intel,
a second sourcing and thingslike that, where it goes all the

PJ (26:36):
Right.

Rob (26:37):
been lots of lawsuits between them too.
And they're on better termsthese days.
But others have done it.
I mean, Trans Meta

PJ (26:45):
Syr Syrix!

Rob (26:46):
did it, there's a handful, but they all have to go through
the huge hoops to do it.
So it is

PJ (26:51):
Yeah.

Rob (26:53):
but why?
If you're going to do that, forsomething that's far more
modern.
And ARM is the child of choicetoday, but that's likely to
change in the future.
And

PJ (27:05):
talk a little bit about that.
So, arms gotta stay.

Rob (27:08):
those old processors.
It's always

PJ (27:10):
Okay, let's do that.

Rob (27:11):
if you want a 68, 000, became an embedded controller in
the end, but it took a longtime.
And you only got a 68, 000.
If you want to make a fast 68,000, no one ever did.
You always

PJ (27:22):
Hmm.

Rob (27:23):
68, or 1 0, or 2 0, or 3 0, blah, whatever these extended
68, 000s were.
They're all designed byMotorola.
You could get them as a cell youcould put into your own design
as that became a thing early on.
That wasn't even a thing.
You'd have your 68, in onepackage and you'd have your glue
in another package.

(27:43):
It wouldn't necessarily be inthe same piece of silicon.
By the time got to laying outtheir own SOCs and fabricated
them themselves.
The 68, 000 had gone away, MIPSwas on its way out.
PowerPC is still around, but itwas rubbish then, it's rubbish
now.
so it left the big players, leftx86, which was.

(28:03):
Dominated in the PC space wasn'tgoing to go anywhere, but it's
always been awful.
Intel have spent so much moneytrying to make x86 go fast when
it would have been, it wouldhave been better just to get rid
of it.
And they tried, they went toItanium and that was a huge
flop.
And again,

PJ (28:18):
Yeah.

Rob (28:19):
underestimate the power of the desktop space the legacy of
everything that exists for x86.
It's, it's really why you can'tget rid of it.
And it takes someone like Appleto actually get rid of it in a
closed system.

PJ (28:31):
The other thing I think Apple has done well to make that
possible is stuff like Rosetta.
They've done a nice job ofactually like being able to swap
stuff over.
So I think they've reallythought through that transition
plan.
Probably better than anyoneelse.

Rob (28:45):
absolutely.
I mean, they did Rosetta thefirst time around.
Yeah.
When they went to Intel, they

PJ (28:49):
Yeah,

Rob (28:49):
and now it's Rosetta 2 to go from

PJ (28:51):
right.
Hmm.

Rob (29:09):
can say, we're only going to support 64 apps.
And we'll jump from some hoopsto get the atomics and things
like that, which are hard toemulate to work.
I mean, I technically Apple didchange their Silicon.
So the memory model, which isvery hard to implementing
software and things like thecarry flag.
Work the same way on arm totechnically out of spec.

(29:30):
So that out of spec.
So Apple Silicon added a flagago.
This was probably the eight 12or 13 or something like that.
It was a long, long time agowhen they first had this
glimmer, they added Silicon.
And a flag in the processregisters where you could say,
do the R, do the Intel memorymodel.
So it was an ARM processor doingthe Intel memory model, one

(29:53):
being strong ordered and onebeing weakly ordered.
So on the strong ordered model,you have some guarantees if
like, if you do A before B, thenA will happen before B.
Where in a weakly ordered memorymodel, you could store two
things and you'd have no ideawhich order that will actually
occur in.
So you can't really model one inthe, from the other in software,

(30:15):
it would be cripplingly slow.
to guarantee the order when youcan't

PJ (30:20):
Hmm.

Rob (30:20):
hardware.
So to fix it, Apple was like,well, we'll just do ARM
instructions with Intel memoryordering, which is not an ARM
design.
It's not in spec, but theprocessor can still pass the ARM
arm and the reference designsand all of the tests.
You just don't set that flag.
So that flag is what I labeledthem to.
get Rosetta down because theydon't have to deal with all the

(30:42):
weird atomics that Intel can doand some guarantees like if I
write this, then this, it's notan official atomic operation,
but it's guaranteed to be atomicin result due to the memory
ordering on an arm, you can'tguarantee that.
how would you emulate that insoftware?.
That was their golden goose inmaking Rosetta work.

PJ (31:01):
Yeah, the pains of trying to guarantee that in software seems
like you would be having orquarter the, quartering the
speed pretty rapidly on, on agiven device.

Rob (31:11):
a hundredth of the speed, because you've got to commit all
those writes before you commit

PJ (31:14):
Yeah.

Rob (31:14):
to make sure the external visibility is true that flag was
a genius move in some ways.
And you've got to think, whenyou're emulating these
processors, you're not justemulating the instructions.
You have to emulate, if you havemulti cores, you have to emulate
the interaction between thosecores, which is where the memory
model comes into play more thananything.

PJ (31:31):
It's interesting.
I mean, there's especiallyapple, but I have mentioned
other people in the space arethinking through this.
There's a tremendous amount ofinvestment that's been done into
arm.
I have to believe they'relooking to pay off that
investment for yet another fiveto 10 years to come.
But.
I is, is really what we'relooking at here, a maturity

(31:53):
issue where.
Hey, down the line, RISC V willstart to eat, not just at the
microcontroller level, but atevery other level inside of
these chips where, at what pointin time is the next like set of
processors going to fall to RISCV?
Or will they?
what are some of the issues thatcould prevent this beyond

(32:15):
maturity?
Is there anything we have to beconcerned with security?

Rob (32:18):
cells available.
Right now, V isn't giving outcells of like, this is a working
processor in

PJ (32:26):
Oh, okay,

Rob (32:27):
RTL form, they're just an instruction set.
So you have to make your own.
I think currently do give outthe architectural licenses.
So you can go design your own.
It's got to pass all thesetests, but you can also just
take an A72, put it in yourdesign.
A72, designed

PJ (32:43):
Okay.
Let me go back.
It's a good call.
Let's go.
I think it's going to be a greatYeah, I think it's going to be a
great call.
Great.
I heard you all.
Bye.

Rob (32:55):
designs of macro cells that you can put inside an FPGA that
you can put inside RTL to go andget fabricated.
can the ARM model with actualcores, rather than just the ARM
model for the instruction set.
These are standard cores andmake them open source too.
So if you want to modify them,you can.
So you don't have to, it's notan all or nothing.

(33:16):
It's like, I want to take yourcore, but I want to add this to
it.
Today, you're starting fromscratch.
If you want to do that with RISCV, there's a handful of people
have done it.
Not many people are, there'ssome commercial licenses for
RISC be an open source licenseto really make it happen.

PJ (33:30):
Well, from a, from a financial sense,

Rob (33:33):
you take people who are making ultra high speed RISC V
cores, whether it be Apple forsome embedded controller,
whether it be NVIDIA, whether itbe Google, whoever it may be,
all these companies are puttingsignificant.
Investment into these designs,they're probably going to keep
it private because there's no,there's no law, even in the
license agreement that saysyou've got to give your design

(33:54):
back.
It's only the ISA that's opensource.

PJ (33:58):
well, it's interesting because it sounds like though
what you're saying it's becauseI can't just pull an equivalent
to an a 72 off the shelf to kindof put it in my design.
This is a limiting factor foranyone who's not a giant company
to implement a risk 5 design.
So I, it is.

Rob (34:19):
that the microcontrollers have.
It's.

PJ (34:21):
Yeah.

Rob (34:22):
It's the,

PJ (34:22):
this is capital intensive,

Rob (34:24):
Yes.
It really comes down to that.
On one side, you've got, we'lluse RISC V because the license
fee's a problem for ARM.
When you have 40 of thesedevices in a, in a product,
that's a lot of license fees.

PJ (34:34):
right?

Rob (34:34):
And so it's worth that capital expenditure get rid of
those.
On the big processors, then it'smassive capital expenditure,

PJ (34:44):
Yeah,

Rob (34:44):
and we're not going to give that back.
think RISC V, the consortiumshould start.
releasing reference models,because that's more down the ARM
path.
but again, 99 percent of ARMchips that are sold are not
architecturally designed ARMs.
They are existing cores.

PJ (35:00):
right.

Rob (35:01):
I mean, Raspberry Pi, for example, Raspberry Pi is just an
off the shelf ARM core.
They put them all together inwhatever package that they have
for their current design.
And, the Raspberry Pi.
It's, if they had to design thatfrom scratch, then they would
never have had enough resourcesor it would have been rubbish.
that's kind of the borderlinethere.
You can design a microcontrollerand it can be rubbish and it'll

(35:22):
still work.
It's just fine.
You

PJ (35:25):
Sure.

Rob (35:26):
you can make a, an ARM2 or a Cortex M0, which is probably
its closest relative, relativeto the original ARM.
can design them and of peoplehave done it and designed their
own.
In FPGA and it works fine.
You don't have to be a top notchsilicon designer to make these
microcontrollers.

(35:46):
only gets really difficult whenyou get to the really high end
stuff, when you've goteverything out of order,
multiple calls, multipleexecution resources, you decode
in instructions to micro ops, soyou can utilize all of these
internal resources.
That's when it gets state of theart chip design is at that
level.
This is the, the new Intellevel.
This is the Apple Silicon level.

(36:09):
That's not really in place yetfor RISC V I could quite easily
make a RISC V core that ran it.
20 megahertz, the interface to afew peripherals.
I probably screw a few thingsup.
It would work enough to get thejob done.
And that's all that matters.
I could, and I can do thattoday.
I can lay that myself.
Doing that at 5 gigahertz.

(36:32):
It's significantly moredifficult when you've got all
the silicon working against you.
You have all of the executionworking against you.
Yeah.
I mean, you can't literally runa processor at five gigahertz if
you execute them in in sequence.
You just can't do it.
You can't take an original insequence processor and clock it
to five gigahertz.
It just won't work.

PJ (36:53):
Well, it's interesting to think through this problem then
from the financial incentives,because as you say, you want
someone to start producing somereference chips where it's like,
Hey, you can go out and usethis.
But.
In order for someone to producesome reference chips, there has
to be sufficient financialincentive to justify, doing

(37:16):
everything needed to fabricateone of these things because it's
going to be expensive.
Like, we're not talking about,now I can get an ARM chip for
pennies on the, like, pennies onthe dollar.
Like, we're talking about asignificant amount of capital
that needs to be dumped intothis thing to actually produce
just even one reference chip.
Right?

Rob (37:35):
Yep, and that's kind of it.
Like, we're talking about theselicense fees, like the super
expensive.
It's pennies per chip at themost, because you could buy a
Cortex M0 for pennies.
If you buy them in bulk, you canliterally get them for a handful
of pennies so the license feeitself can't be that much, but
it adds up, I don't think Appleor Nvidia have a license where
they can redesign these.

(37:56):
I think they only have 64 bitlicenses.
So a lot of these embeddedcontrollers can't even be
designed under theirarchitectural license.
And obviously they could nottell anyone, but it's all comes
back down to how badly do youwant to break the license and
how much do you want to getsued?
But as far as I know, if, if, iflike Apple or Nvidia use a M0,
they just take it off the shelfone, pull it in.

(38:16):
So they

PJ (38:17):
Right.

Rob (38:17):
the license and they pay him for that core design.
RISC V should just start makingcore designs and be like, this
is a implementation of our baseinstruction set for a minimal
power microcontroller that runsup to 10 megahertz, basically,
and then have one that will runup to 100 megahertz and then
have a handful of differentdesigns for the base instruction

(38:38):
set, which is good forMicrocontrollers all the way up
to the full fledged thing thathas floating point and
everything else that runs atfive gigahertz.
It's like, that's it.
But who pays that is the bigquestion.

PJ (38:48):
That is it.

Rob (38:49):
cost those Apple silicon S level designs cost hundreds of
millions of dollars.

PJ (38:57):
Right.
And I could look at an analogyto this, which is.
I could say, hey, the Kronosgroup did this for OpenGL back
in the day, where theyeffectively define what the API
needs to look like and everyoneelse is responsible for actually
implementing this thing.
But the Kronos group wasn'tgoing to be manufacturing GPUs

(39:19):
at that point in time, like thatwas

Rob (39:20):
And it's

PJ (39:21):
ATI, that was NVIDIA.

Rob (39:23):
Linux exists in this exact same space, but anyone can take
a Linux and build it on a custompiece of hardware.
It's not that difficult to builda working kernel.
Now, imagine if you had to take,Oh, this is the Linux system
calls, but you've got to go reimplement a whole operating

PJ (39:39):
Yeah,

Rob (39:40):
it.
Looks like Linux.
Imagine taking, I want to takethe Linux user mode stack, I'll
take all of Ubuntu from thekernel up, and I'm going to
rewrite the kernel in my ownway, but all of Ubuntu is still
going to work.

PJ (39:54):
right.

Rob (39:55):
That's the sort of a thing you're taking on when you start
designing these high speedchips.
Like, this is just the shellinterface to the internals.
Design your own internals.
That's no different to saying,this is the syscall list for
Linux, make everything elsework.
It's incredible amount of work,and it's an incredible amount of

(40:16):
effort.
And in software, you don't haveto make these things.
So we just take what's alreadythere.

PJ (40:21):
Right.
Sure.

Rob (40:23):
RISC V exists in the same world as Linux.
Exists in, I mean, you couldliterally take risk five core
run Linux and everything fromthe RTL all the way up to the
application is open source.

PJ (40:33):
I, again, like, you know, I could take a Linux, I could toss
it onto a lot of existinghardware.
RISC V, like we actually needsome hardware to be created to
implement that.
Right.
Hmm.
Yeah.

Rob (40:48):
computers with high-ish powered risk five processors,
but they're not that high Powerarms still much faster and they
come in somewhat concerned, allthese higher powered RISC V
cores, not all, but a goodmajority of these high powered
RISC V cores are Chinese.
So you buy these Chinese single

PJ (41:08):
Let's talk on this front.

Rob (41:10):
Let's have a look at, see how fast they have RISC V up to.

PJ (41:13):
Yeah.
We haven't even gotten to thesecurity concerns, but I think
this is a good time to turn intothat topic.

Rob (41:21):
Some people are claiming like, Some of the best
performing risk fives are maybe30% faster and 20% more
efficient than a Cortex a 55,which is a 64 bit arm and maybe
have the same or better vectorperformance, and or a space mi

(41:44):
or something like that.
But the processor is gettingthere, but they're fairly old
arms.
It's like there's no a 78performance cause

PJ (41:55):
but to be sure, when we say efficient, we're talking about
power at that point in time,correct?

Rob (41:59):
yeah.
It's, uh, power efficiency andoverall performance are the two
metrics, I guess, that we usetoday for how good these things
are.
Just because you're twice thespeed, but you take 10 times the
power, doesn't make you terriblyuseful because you're soon going
to overheat and have to slowdown.
So you have to take thesenumbers with a grain of salt of

(42:20):
like, are they peak

PJ (42:21):
Right.

Rob (42:23):
Or are they sustained numbers?

PJ (42:25):
So you, made a comment a second ago about there's concern
with these higher powered riskfive chips being produced we
chatted a little bit offlineabout, Hey, are there potential
back doors that could be bakedinto the hardware that couldn't
be patched that would allowbasically.

(42:46):
You know, some foreign actor,let's say, to get access to
these chips at the deepestlevel.
How much of a concern is thisfor real?

Rob (42:54):
It's definitely a concern.
There are media tech chips outthere with a full hardware TCP
IP stack in them.
They're still ARM cores, butthey have a full TCP IP stack in
them in things like routers.

PJ (43:06):
Yeah.

Rob (43:06):
but that gives the access to the outside world.
The big problem with Hiding thissort of thing in a processor is
what's the chance of that goingin a device that has any access
to the outside world?
routers, the obvious one wherethere are obvious security
concerns that you have to lookat.
And there are some open sourcerouters that use the media tech
hardware stack of like.

(43:27):
though it's open source, itmight not be buying you anything
because it could be, who knowswhat that's

PJ (43:31):
Right.

Rob (43:31):
can't We can't have the designs.
It's all hardware.
is the truly a hardware TCP IPstack?
I doubt it.
I doubt anybody would.
to design TCP IP solely inhardware, because the logic gets

PJ (43:44):
Yeah.

Rob (43:45):
If logic gets then it makes more sense to do it in software,
which is why all these processesexist as embedded devices,
because replacing them withdedicated hardware means it's
not patchable, it means it's notupdatable and means that logic
is huge.
And at some point, the logic ismore complicated than.

PJ (44:03):
And it's expensive, right?
I mean, I can take something offthe shelf.

Rob (44:08):
I have an ARM processor and it can do A, B, and C, I mean,
imagine having, uh, any modernish device, the buttons that are
on the front of a CD player, forexample, device, it's 30 years
old, uh, all the buttons thatyou had for all trap skip and
then memory and indexing andblah, whatever it may be.
Imagine doing that in logic withgates.

PJ (44:30):
Yeah.

Rob (44:31):
It's to put a dirty processor in there writing
software.

PJ (44:34):
yeah.
Yeah.

Rob (44:35):
And if you get it just fix the software.
It's much easier than going backand redesigning all this
hardware.
Nobody in their right mind wouldmake a TCP IP stack and directly
in hardware, may have somehardware

PJ (44:44):
Sure.

Rob (44:45):
with some of the ultimately it'll be controlled by software
so concerns.
Are there security concernsabout this Chinese made RISC V
process that's just in anembedded device that's not doing
anything that's connected to theinternet?
There's certainly less of aconcern

PJ (45:01):
leak

Rob (45:03):
concerns about hardware designs and things that could
spy and you'd never know thatit's spying.
But this whole firmware, likeit's not up to, I read an
article where it's like, well,these chips are not updatable.
Most chips are not updatable.
I mean, Intel have replaceablemicrocode, but it's only for a
handful of instructions.
They can't.
It's not like the chips, allsoftware like that, microcode

(45:26):
Patch can't do much.
They couldn't patch, theycouldn't fix Specter or meltdown
with a Microcode patch.
So if it's like, if it's thisaddress in the microcode that
you're trying to run, and theseregisters all match, then
redirect to something in thewhich was put in by software.
Um, That's kind of how it works.
So you can't just go, Oh, I'mgoing to rewrite all the

(45:47):
internals of the chip.
It's, I'm sure over time it'sgetting more and more powerful,
but we're nowhere near thatlevel because now you've just
got more software running insidea processor that's supposed to
be hardware.
So like, that's just totals allthe way down.

PJ (45:58):
All right, so there's a little bit of FUD that's out
there that's not specific toRISC V around, hey, this is less
secure.
It sounds like you can have,especially in the use case we've
been talking about for theseEmbedded microcontrollers that
are the traffic cops.
They aren't going to be able toget contact with the outside

(46:19):
world.
And the likelihood of them beingable to spoil anything is
actually really low.

Rob (46:23):
Yeah.
bought Chinese calls to do thosethings, like I said, they're not
connected to anything.
They can't do anything.
do their job or they won't.
And if they're monitoring whatjob to monitor.
It's a processor.
Uh, It just, what's it doingwith it?
And if it's like, say, if it'sembedded in another chip that
that chip has, it's in the GPU.
And then ultimately, if thatwants to get data out, there has

(46:44):
to be a way for it to get allthe way back across through the
driver, out of the ethernetport, to whoever the Chinese
overlords are.
It's a bit of a far fetchwithout anybody spotting that
much traffic going.

PJ (46:56):
I mean, you have to like say, Oh, this is a, I don't
know.
It's like the, the processorshave been hacked and I've hacked
this game to send thisparticular set of stuff into
this.
But if you've hacked the game,you've probably get the data in
a much easier way.
So at that point in time,

Rob (47:14):
hacking the microcontroller inside a

PJ (47:17):
right.

Rob (47:18):
I don't V is not Chinese in itself,

PJ (47:21):
Correct.

Rob (47:21):
it's designed in Berkeley, I believe, and Now it's hosted
in Switzerland as a neutralcountry,

PJ (47:28):
Correct.

Rob (47:29):
can tariffs and, export Yeah, so it's like, if you pull
a RISC V processor with ahardware stack in a router, that
was made in China, then,potential, you've got to look at
that pretty closely.
You're also assuming that allChinese chips are bad and
they're not.
if you're designing your ownRISC V in a GPU and it's sending

(47:50):
data home, then you did it.
You designed it.

PJ (47:53):
and, you know, we should also point out that even if
there was a vulnerability, thatdoesn't mean it was intentional
just because shit happens andsomeone may have just made a
mistake, right?
Like it's like, does itnecessarily mean because of the
vulnerability and somethingthat, Oh, this is proof positive
that someone's trying to spy onus.
It could just be like, Oh, Ifucked up the instruction when

(48:15):
I, when I implemented it.

Rob (48:16):
There's all sorts of things like that.
And, and it does come down tolike, what can you leak from
that?
If you have the, some badimplementation or you can hack
the firmware in these GPUs oflike, are they being used for
crypto mining?
Can I find keys and It's like,the answer is probably yes.
Um, Why have tech securelyseriously at all levels.

(48:36):
is that any different than it istoday?
Not at all.

PJ (48:39):
Right.
Exactly.
From a, a typical user orprogrammer standpoint, this is
still an almost irrelevantargument or kind of like
happening because like thesemicrocontrollers are not going
to be noticed by the users andthey're unlikely to be ever
programmed by the theprogrammers.

Rob (49:01):
If you ask people like, what processes are in an iPhone,
they'll go, oh, there's the sixcalls of the main CPO, but they
don't realize that there's 35other

PJ (49:08):
Right.

Rob (49:09):
around everything from USB C to is, uh, the, the image
stack is full of them.
The, they have arm controllersat the end of PCIE.
Buzz is just a handle.
Various things.

PJ (49:22):
What's fascinating to me is that, you know, these decisions
about what processors to usereally are going to be up to
these high level chip designerswho, and, and the finance folks
to figure out what is the breakeven point for where it makes
sense to replace our arms andour cores, uh, with a risk five

(49:43):
design.
Because these microcontrollers,like, it's like, it's enough of
a savings going forward that.
We don't want to be dealing withthe the architectural license or
even just the off the shelflicense anymore We want to be
able to like save like at thisvery lowest level that most
people aren't gonna care about

Rob (50:00):
external users don't see any of

PJ (50:04):
Right

Rob (50:10):
I'm like, ultimately this chip needs to do ABC today.
We could do this this way, butwe'd like to get to a point
where we could do these otherthings.
And this leads towards.
A given architecture, that givenarchitecture might be RISC V, it
might be ARM, it might be doingit in house.
And that has this costassociated with it, this

(50:30):
development time and either sidesaying we have to do this for
cost.
We have to do this forarchitecture.
It's the whole plan.
I mean, like I said, none ofthis is visible to the external
All we're selling them is we'reselling this product of a GPU.
How we make that GPU internallyis our business.

PJ (50:47):
Okay.

Rob (51:16):
now, uh, I don't know, but ARM is expensive.
There's no, let's not, let's notbeat around the

PJ (51:21):
Thank you.

Rob (51:21):
It's not cheap have your own ARM processor.

PJ (51:24):
Yeah, and it's, but it's fascinating to think about a
world where, x86, we believewill still be a lot around for a
while to come just because ofhow much stuff requires x86.
ARM, I expect will be around fora while as well.
And then maybe we just start tosay like RISC V, you know,
occupies this lower end space.
So you have these sort of high,middle and low tiers for what

(51:47):
processors end up doing.
Silence.

Rob (52:02):
the Cortex A, R, and A series, like the M's are the
embedded ones.
The, A application processes arethe The big heavy weights at the
middle, uh, with slightly morepower than an embedded
controller, less thanapplication processor kind of
thing.
You could put in a car and thatsort of thing.

(52:24):
there is this massive spread andyes, you could put a
microprocessor in pretty muchany device these days and you
can get them for pennies they'rejust there to save logic.
If I can put all of this in.
Logic decision making into apiece of software and have this
50 cent chip, then I got a fixedcost and can add functionality

(52:48):
and software where if that wasadding hardware, we have to
redesign, redesign, redesign,and even if that's.
Yes, you could do logic inFPGAs, but they're crazy
expensive.

PJ (53:02):
most of the time, cost effective,

Rob (53:05):
Getting interface like of buttons.
And if you hold this one and youclick this one, or you hold it
into three seconds to reset it,

PJ (53:14):
correct?

Rob (53:14):
sort of behavior, it's software and it's running on a
tiny, tiny.
controller.
However, ARM's not the onlyplayer in the game yet.
The Chinese make some microcontrollers, which you can get
them for like three pennies andthey have a full dev kit.
PIC still exists.
There's a whole bunch on thesmall side.
There's a whole bunch.

PJ (53:35):
We

Rob (53:57):
controlled.
the buttons on your microwaveand your oven are all definitely
software controlled because it'seasier to do in software.
to do the rest of the software.
There's a whole gamut ofprocessors that are under it
that go all the way down to thesmallest, most mundane tasks
that you can imagine.
And, and cars are a hugeconsumer of microcontrollers.

(54:17):
These days because every singlelittle device will have its own
microcontroller because if ittalks to the cameras, it needs a
microcontroller.
So these things are literallyeverywhere in cars.
It's not just like there's theECU and that's it.
It's like there's hundreds ofthem scattered about doing all

PJ (54:34):
this actually then, you know, brings an interesting
question because do we, do weactually get to more divergence
of microprocessors thanconvergence?
Because it seems like, you know,we, still got its old, uh, AIX
machines, mainframe stillrunning.
We'll have x86 forever.
We'll have ARM forever.

(54:55):
RISC V's coming on board.
PIC seems like it's not goinganywhere.
Like, do we just basically justkeep multiplying out these
processors?
Like, for whatever things weneed.
And we never actually shrinkthem down.

Rob (55:09):
we're at a, point where no one's making

PJ (55:11):
Oh, fair.

Rob (55:14):
It's, like, if you want to operate, you'll use Linux or
you'll

PJ (55:17):
Yeah.

Rob (55:17):
and you'll modify it.
I mean, yeah, I exist and likeall the old Unix y things still
exist, but they've mostly beenreplaced by it's you're not
going to, well, I'm reallygonna, it's not going to write a
new one.
If you've of academic.
Experience.
You can go write all thatyourself and it would be an
academic exercise and you'dlearn a lot.

(55:38):
If you're a company, you want tohire people, then you need to
use their experience and theirexperience is probably in Linux.
And they don't want to buildexperience in your

PJ (55:48):
Right.

Rob (55:48):
fucked up system.
They want to build.
Experience and it's somethingthat's going to serve them in
the future.
And that's where we are todaywith Linux.
And RISC V going down.
That's the exact same path ofEveryone just knows how it
works.
Um, everyone just knows what todo in this scenario.

PJ (56:02):
Well, what's fascinating is like Linux, you know, obviously
is not a monolithic thing.
It splits into a lot ofdifferent flavors, but it's all
fundamentally Linux.
And I guess what you're like,part of what you're saying is
that the same thing will happenwhere it's like, Hey, we want to
reutilize our knowledge sets onrisk five.
So.
Because it's open source,because it's following a similar

(56:24):
pattern to Linux, that same setof people that basically just
want to do and not have to fuckaround with basically a new
instruction set every singletime, we'll just say, Hey, well,
it'll be risk five.
Maybe it'll be a slightlydifferent flavor, but it's all
the same.

Rob (56:38):
I mean, imagine if, if I was a RISC V designer working
for some company, I've done afew designs and I go work for a
new company, then I'm prettymuch going to promote

PJ (56:46):
Yeah,

Rob (56:46):
V because I can And I think that's a lot where arm strength
came from is because they're inthat peak

PJ (56:53):
yeah,

Rob (56:54):
where everyone who designs arm purchases and risk fives
just catching up.
But ultimately it's the peoplewho need to do this.
If you look at it from a verypersonal point of view of like,
I would do this, but you can'tdo the whole thing.
You need help.
A company needs to make moneyand it needs to be sustainable.
And that's kind of where thesetrends ebb

PJ (57:15):
yeah, Yeah.
I mean,

Rob (57:26):
financial incentive or a technical incentive.
It's It's the whole ecosystemthat will push it in the
direction that it wants or needsto go.
And the more easy you make it toadopt that ecosystem, more
traction it will get.
If like, if you have to fightarm every step of the way to do

(57:46):
something, then people are justgoing to go, we'll just do it in
this five, and at some point yougo, you know what, this worked
really well.
This was a dead end.
keeps that innovation goingwhere arms.
you start to get into theselicensing models where you can
do A, B, C, you can't do D, E,and F, it's kind of stagnated.
It's like, okay, you've decidedhow I'll make my thing, without

(58:07):
even knowing what it is.
Well, at least in RISC V you cango, I'm gonna have a go anyway.
And at some point you're like,Damn, that worked really,
really, really well.
Oh, that was a terrible idea.
Whichever.
It doesn't matter which path yougo down at the time.
It might, but in the, for theecosystem, it doesn't matter.
Everyone learns.
And ultimately this gets foldedback in and we all know not to

(58:28):
do that again.

PJ (58:28):
it's exciting times in that sense.
Like it means that we're back tothe wild, wild west again with
this and it opens up the doorfor possibilities.

Rob (58:37):
The ability to make the product as you want to make your
product has never been better.
You don't have to deal with thewindows license.
You don't have to deal with, canI add this to the windows kernel
answers?
No, you can't.
How much innovation do thesecompanies hold back not being
willing to play along?
And this happens to allcompanies.
Nvidia are equally bad of whenwe were also on, this may have

(59:00):
been the PlayStation.
It's.
Their engineers are going,you'll use the GPU this way, and
we're like, no we won't, we'lldo it this way.
And it just makes more sense forgames.
So, you always get these, theseclashes, and sometimes you work
through them, and sometimes youdon't.
And, that goes across the board,whether it be, going back to the
original Xbox, I want to put theNvidia chip and the Intel chip

(59:23):
in the same package.
Not possible, can't cost reduce.
can't be done.
You're not going to have enoughsynergy between those two
companies to get one of them togive up on the fabrication
process and let the other onesfabricate so there's it's never
just a technical solution orjust a business solution,
especially when you're askingother companies to invest a lot
of money in your

PJ (59:43):
Right.

Rob (59:44):
Companies want to own it.
And when they own it, you losethat innovation because you only
get their innovation.
Your innovation is irrelevantbecause it doesn't benefit them.
Where if this stays fully open,everyone gets the benefit of
everybody else.
And shining

PJ (01:00:01):
but I think, you know, you have the larger point here of
like at all levels of the stackwhere Linux is the example for
the operating system.
Unreal is the example for thegame engine and RISC V is the
example for hardware.

Rob (01:00:15):
Yeah.

PJ (01:00:15):
But it gets back to your point that because the
possibilities are starting to beincepted today.
Now, if you want to do somethinginteresting, it's available to
you.
May not be the cheapest thing inthe world, but it's possible,
which is pretty cool.
So let's see where thisinnovation goes.
I think the open source up anddown the stack is awesome.

(01:00:37):
And then who knows, maybe one ofthese days we'll figure out how
to get an open source GPU outthere until then.
Let's see where the visionariesin the economics take us.