#547 – Open Source Mindset with Michael Gielda

Chris Gammell: This is The Amp Hour Podcast. Released June 28th, 2021. Episode 547. Open Source Mindset with Michael Gielde. Welcome to the Amp Hour. I'm Chris Gammell of Contextual Electronics.

Michael Gielda: Hey, I'm Michael. I'm a co-founder of AntMicro.

Chris Gammell: Welcome back, Michael. How are you doing?

Michael Gielda: Very, very well. It's been, what, half a year, right?

Chris Gammell: It has been, yeah. Yeah, about half a year. So last time you were here, we were talking about Renode. We were talking about some of the open source tool chain stuff. AntMicro has not slowed down or stopped. What have you guys been doing in the meantime?

Michael Gielda: We tend to say, you know, it's been half a year in normal time, and then it's been 10 years in AntMicro time, most likely. I think the biggest kind of thing to say about this time is we've been just continuing on this road to using open source in various commercial contexts, do good stuff, especially somewhere at the borderline between hardware and software. And one big kind of announcement, one big thing that has come out of our stable is the open source portal that we launched just recently. If you go to opensource.antmicro.com, you'll just see quite a bunch of projects that we're running and different things we contribute to. And also like the story that connects all these things. And they cover things from like ASIC design and FPGA stuff all the way up to the cloud. Yeah. And there's a reason for it. It's like, you know, these things, we tend to see these things as connected.

Chris Gammell: Yeah. And we should remind people too. So AntMicro is a service company that works on a lot of different projects for different people. You've got developers, like you said, working on all these different open source projects. And some of it is like sponsored type work as well, right? So like you would be working for a particular company and then they're not only paying you to develop this thing for them, they're also agreeing to saying, hey, yeah, you could push this stuff back into an open source repository so that other people can benefit from it.

Michael Gielda: Yeah, absolutely. I mean, this is the best case scenario, of course, and it tends to be a mix. Obviously, there are sometimes things that we're asked not to contribute back for various reasons.

Chris Gammell: Yeah. I mean, there's business development type stuff or privacy, whatever. And yeah, that's up to the company.

Michael Gielda: Or stuff that's literally not interesting to anyone else. Like that's happened that like you're developing something very niche and open sourcing it is kind of, I do tend to say that, you know, you never know, you'd be surprised. But like there are things that are obviously like it would be almost, you know, it would be a bad idea not to open source things like, you know, you're doing, let's take the Renate example that we've been covering last time, you know, kind of we're doing a platform support in Renate for someone. If we didn't contribute it back, like what if someone else comes along and was the exact same thing? Like you don't want to be redoing that work, especially if you had to redo it in a different way. It's like counterintuitive. So many things that we tend to say that like you'd be surprised how many things are worthwhile, you know, contributing back. But of course, different people have their different comfort zones. And we tend to work with companies listening to what they have to say and how they work. And we just tend to encourage them to contribute to open source. And increasingly, we are successful in encouraging people. And even we have a lot of people approaching us and saying, hey, because you work like this, because you give us all the source code and you tend to complete things and so on, we'll work with you as opposed to someone else, because this is exactly what we want to do. We want to perhaps, you know, show ourselves as a more progressive company. We perhaps want to just kind of grow our business in various unprecedented contexts. You know, we want to kind of be more software driven. There's various reasons, but like increasingly, it's people approaching us, citing specifically this methodology and this mindset. And I especially liked several times in the last past year when people approached me and said, hey, I heard you on The Amp Hour Podcast and we want to work with you.

Chris Gammell: Well, that's good. Okay. Well, if anyone else wants to hire Michael, they can go through me. I'm now his agent. So Ant Micro is all business will be routed through Chris Gammell. Uh, just Jimmy Paul, very small 25% commission. No, I'm just kidding. Uh, that's great. That's really great. And I think that, I mean, it's interesting to me, like I think about, you know, CEOs at, you know, big co that might want to hire a software development firm or someone to help out with this particular product. My first instinct is like, well, why would, why would they go for open source? Why would they go for this? You know, I'm paying someone, but then it gets pushed back into the community. But the thing to remember is that they're probably already working within a context of open source anyways, right? So if they're, if they've decided to put Zephyr on a board or similar, and they want some extensibility for it, they've already benefited from other stuff that Ant Micro has written, other stuff that other companies have written, stuff that the chip companies have written. And there's like, they're already bought into the ecosystem. So that, that has to be an easier sell than I probably first imagined.

Michael Gielda: Precisely. Yeah. I mean, that's the first argument, right? You're benefiting from a lot of work that has been done by other people without you having to pay for it. So you can just imagine this transaction to just proceed into the future where whatever you contribute, other people will be happy about, and then they will perhaps do the same thing. And it tends to just self-perpetuate.

Chris Gammell: Yeah. Paying it forward, right?

Michael Gielda: And, you know, like a lot of our customers, we have people approaching us that are either engineers or perhaps past engineers, and they just understand how practically it's just easier to work with stuff that you can see and, you know, examine, you know, a lot of people tend to experiment with some things that we've built before they actually approach us. They download something, they play around, they see it's good. And then they come and say, okay, I've kind of, I've been able to convince my company, it's, it's a good thing. And now let's build it out to cover whatever we need to cover. Because there's, I tend to say there's an endless amount of work to be done to push humanity forward in various fronts. So we tend to focus on like the next awesome thing to do rather than kind of fighting over like this little thing. You know, we want to be the absolute masters of this little corner of the world. We'd rather just go into new corners and work with people that want to perform some change. And open source is a good way to do that. Because if you're exploring new territory, other people will, they'll be a little bit skeptical, you know. And if you just put things out there, if you show them, hey, I'm building this in the open, people will believe you much easier because they'll see you're serious, right? This is not like vaporware. This is not like marketing. It's really something that's there and you can test it out. And so like when people want to innovate, when people want to build some kind of a new capacity within their established company, many of our customers are really big companies, right? Kind of open source is a nice way to expose yourself also to criticism sometimes, you know? So it's this kind of exposure people are afraid of.

Chris Gammell: How much does it play in the idea of labor shortages? I mean, like that seems like something too, like, so I'm looking at the open source study at micro.com. There's a category on there. And so it's ASIC and FPGA, development platforms, edge AI and software and cloud systems. And specifically in the AI space, I just hear about like how hard it is to find software people, how hard it is to find, you know, experts in these various areas. A lot of them are very new areas. So how much is it that as well of like leaning into open source? Cause that's where there already is some expertise. You know, there already is a bunch of project happening, that sort of thing.

Michael Gielda: Oh, absolutely. I mean, you couldn't develop these things just by hiring, you know, 20 engineers and writing it all from scratch, right? Like, I mean, you could, and some people do. And sometimes there's a reason to, you know, write things from scratch and we do that too. But most of the time, the problems you're facing are just, you know, they've been faced by other people before. And you can just focus on this very important part that you want to work on yourself. It's funny that you should mention AI. We have just today, we've just released an AI framework called Kenning. It's also on the open source portal. And Kenning, you know, of course, like people will ask in this XKCD famous, famous comic, you know, we have 14 standards and now let's invent the 15th one. It's kind of like with both like front end frameworks and AI frameworks and so on. But first of all, we kind of, we think that, you know, it's a bad argument in the sense that plurality is good, right? Like you can use whatever you want. And secondly, we just saw a missing piece. We saw that we'd like to make how different kinds of AI models and AI frameworks work across a range of AI platforms from different vendors of different types, you know, CPUs, GPUs, FPGAs, specifically deployed on the edge. You know, we tend to kind of build AI systems for our customers. We use different kinds of platforms, like a lot of NVIDIA, of course, but also Intel Smooth Videos and Coral from Google and RISC-V, of course, increasingly BGA stuff. So lots of different platforms and they tend to, you know, kind of differ because everyone wants to have their own stack, their own compiler optimizer. Yeah, right. Everything's very fragmented. So we're kind of trying to bring it all together and make sure that these things can be compared, like an Apple's comparison and improved and thought of as like, these are just platforms. This is just hardware. Like hardware is super important. It's great. It's awesome. But like for a software person, it's just hardware that I want to run my workload.

Chris Gammell: So would that be like you'd switch out a flag and that would switch from a Movidius to like a Tegra or something similar?

Michael Gielda: Precisely, yeah.

Chris Gammell: Yeah. So you just abstract away all the lower levels that, well, not lower level, but like all of the various types of things and you have APIs to talk between them and things like that.

Michael Gielda: Yeah. We try to, of course, kind of expose quite a bit of functionality so that you can, you know, this is still available to you if you want to tweak it. But like by default, you're going to be able to quite quickly run a kind of model on different platforms and even generate, you know, nice matrices of results to see how they compare. Yeah. Because, you know, the comparison aspect is difficult because, of course, first of all, everyone's afraid of being compared. And second of all, if you have your own AI platform, you're going to, you know, focus on how do I protect my share of the markets. I think it's a fallacy in the sense that the market to be uncovered is much bigger than the one that we have today. So I think that the cool stuff lies somewhere ahead of us. It hasn't yet been discovered. So it's, I think, more interesting to focus on how we can enable new stuff and how we can make AI normal and especially edge AI, right? Like when I'm talking AI, I often talk about AI that's deployed somewhere in the field. How do we make it so that it's not as kind of black magic as it sometimes is? We tend to have customers who come and say, oh, we want to switch from this platform to that one. And then we have to explain to them, well, it's not going to be that easy because, you know, suddenly you have to switch out all the tools in your tool set to something else. And it's just because, you know, a certain platform is not supported here or like these operations are missing from that compiler. And of course, like you can always go and try to improve those things and make them work together. The challenge is, though, that many of those underlying tools are closed, right? Like a lot of the AI stuff actually is pretty closed. And we've had that complaint over the years from many, many customers. Like they come into the edge AI space and, you know, one of their major criticisms is that I wish I could just optimize things better. But like much of the stack is actually closed if you look deep enough, you know?

Chris Gammell: Yeah. So and when you say that sort of thing, I mean, so I'm looking at the projects page as well. And some of them are hardware things. Some of them are moving up to firmware and software and then network type stuff as well. So where in the stack does it usually do you run into a brick wall? Is it like, I would assume that most of these chip vendors want you to be able to put stuff on a board, but is it like you can't even get a NVIDIA data sheet or similar? Or where does that happen?

Michael Gielda: It's typically in the compiler slash optimizer here. Data sheets, I mean, you do get data sheets, right? But like they tend to explain and describe the things that you'd normally be interacting with directly, right? So if you're writing drivers for things, obviously you need data sheets. So like even if a vendor kind of doesn't provide a good data sheet, when people need to write drivers, they will complain, they will kind of bug them for it, and eventually they'll get what they want, right? So it's kind of almost unavoidable. Over time, data sheets tend to improve. The challenge of AI is that a lot of the time you don't only get a platform. You also get this little binary blob that kind of goes on top, right? So you're never interacting directly with the hardware.

Chris Gammell: Ah, yeah. Yeah. The magic bit.

Michael Gielda: Yeah. The magic bit. And then like you never actually get to see how the hardware works internally because like all you're talking to is like the, you know, some kind of a binary blob, right? And so you interface with something that's kind of artificial. It's not really in the hardware. Right. It's just some software you don't have access to.

Chris Gammell: Are you saying the right incantations? Are you waving your hands in the proper manner in order to get the black box to do what you expect the black box to do?

Michael Gielda: Basically. And we believe that black boxes are not only bad for the users, right? They're bad for the companies making them. So it's...

Chris Gammell: Yeah. You're not going to get any pull requests from a black box. That's for sure. On a black box rather.

Michael Gielda: And you could have this tremendous firepower that people have in just optimizing. If you look like, I don't know, LVM, right? How many people are there just sitting and optimizing those compilers, just tweaking them this one tiny part of a percent, just because that translates to like several hundred million dollars of income for some big company. Right.

Chris Gammell: Right. Yeah. Versus like a Kyle compiler where they have teams of engineers and they've worked, you know, they work through bugs, but they work through bugs based on, you know, what their top clients want. And they kind of do it hierarchically like that instead of, you know, Joe Schmo being like, well, I'm just going to fix this.

Michael Gielda: We've had that actually in Renaud, for example, where people just came and said, hmm, I found a problem, but here's a go. Here you go. Here's a fix, right? Like that's the best kind of thing to happen to you. It's like, because of course, like a bug report with good information about the bug is also very, very useful. I'm not saying that's bad. Sure. It's a great thing to have, but like more often than not, people will get frustrated with the bug and they'll say, well, I was tracking it down and I found it's happening here and here's a fix. And that's kind of, I think, just playing into the nature of software engineers a little bit. Like they're stubborn people, just like I am. No. So, and if you, but if you don't get access, right, if you, if you're never presented with the actual source code, like you're never going to be able to suggest what's broken because you just literally don't know. So, yeah, we've been trying to, by the way, kind of explain that to a lot of people and kind of show, lead the way a little bit, because, you know, on the one hand, we tend to build a lot of, you know, devices for our customers where we use whatever's on the market today. And, and that's a variety. I mean, it's, it's also like Snapdragons and it's, you know, NXP stuff. It's various kinds of platforms that we just build different devices, like industrial, medical, logistics, agriculture. Everyone is, you know, automating stuff these days. But we're also looking at the next gen. And we're also kind of, first of all, we're, you know, in the RISC-V international. And of course, RISC-V has managed to establish some kind of a credibility by now. And everyone understands, okay, yeah, CPUs can be open. So, so that's good progress. But I think that, you know, what we're really looking at is what we're trying to achieve in Chips Alliance, which is another organization focused more on the entire, you know, basic design process, not just the CPU, but also kind of interconnects and IOs and analog, all parts of the chip, as well as the tools that get you to actually making the chip what it is.

Chris Gammell: Yeah. So, well, let's talk before we get into the chip side of things, because it does seem, I mean, it's like you're approaching all these things and you're saying, okay, how can we be more open? How can we be more open? But let's go back to that, that binary blob piece. I mean, it must be at some point you've, you've convinced people to open up some of it, maybe not all of it. What does that look like? I mean, is that getting access to lower level registers and like just more information? How does that end up working and switching over to a more open kind of mindset?

Michael Gielda: Actually kind of convincing people, convincing, you know, Silicon vendors and so on to do that is very, very hard, right? And how that would happen would be quite simply, you know, hey, here's, here's the source code for this compiler, or here's, here's the source code for this binary blob. And a lot of people think, oh.

Chris Gammell: Well, we've had it on the show too, right? So we've had almost in, within a month, I believe we had Brian Faith from QuickLogic on here. They've completely gone for the open source route. And then we had Sammy Chung from Ethnix on here. And he said, nope, that's not us. And, you know, I asked him about it and he said, look, it just doesn't feel right to us right now. It seems like they're considering it. I feel like some of it though, is they don't see, they haven't seen the benefit because of the, because of the long history of like providing this software and people just using the software and not pushing it back upstream. They haven't gone for it yet. Right. Whereas Brian and his team, they, you know, talk to Tim, talk to you guys and just like, all right, we're all in for it. So what?

Michael Gielda: No, I mean, QuickLogic and Brian, they've been kind of the, the kind of outlier and a very good example of how that could actually happen. Right. And it's, it's a mixture of course, of, of, of, you know, humbleness you have to have. And I think that kind of Brian definitely shows that. And, and also an understanding that things won't happen overnight. Like your fate, like just open sourcing the tool chain or it doesn't magically fix all your problems, but what it does is it puts you in a different position where you can get external help more easily and over time that accumulates into making a radical difference, but like it takes time as well. And so the ability to kind of also just, just wait for, for this to happen without losing the faith, which coincidentally happens to be Brian's second name is, is, is like important here. And, uh, I can understand how it's difficult to understand this, you know, like if you have

Chris Gammell: a successful business and having different difficult situations, I think as well. Right. So like Xilinx is a, you know, billion, million, many billion dollar company, or I guess they're now all terrible. So they're, who do they get bought by AMD?

Michael Gielda: Yeah.

Chris Gammell: AMD. Right. And so it's just like, it's just juggernauts at a certain point. Right. So convincing a Xilinx or an Altera or AMD and Intel at this point, you know, like that's just a, that's a huge thing. It's a, that's, that's changing the direction of a aircraft carrier type of thing. When an iceberg is coming their way, uh, you know, it just takes, it's just going to take a long time, but I'm sure that it.

Michael Gielda: I can mention that, you know, and yeah, indeed that's, that's exactly how you say it. And, uh, we are already kind of working, uh, with, you know, bigger vendors in many areas. And one of them is we're building this interchange format for FPGA tooling. And, and, you know, we have Xilinx already contributing to that. Right. So, I mean. That's great.

Chris Gammell: Yeah.

Michael Gielda: This is, this is like on the side to whatever they're doing as their main focus.

Chris Gammell: Right. Yeah. They're, they're not dumping their ID anytime soon, but they're also, you know, there's pieces that, you know, you start to work together and then it builds from there.

Michael Gielda: And they can see that, you know, there's a lot of interest in research. There's some kind of niche use cases we've been able to address that we can kind of make stuff work very well. And so, you know, this mindset starts appearing when, when someone says, Hey, why not? You know, like we don't necessarily have to like double down and, and, and, you know, kind of make it our primary tool chain, but like, what if people could use that as well? And that's, that's pretty cool. Yeah.

Chris Gammell: I mean, and so I got, I got to the Z section and the V and the Z section of the open source board and there's vertex ultra scale PCIe example, and then zinc MK boot image zinc video board. So that you're making hardware or you're making some FPGA examples, things like that, where it's, there already are some paths in there to do some open source things, but it's, yeah, like you said, it's not the, it's not everything that Xilinx is all in on because they have other business use cases and other ways they're doing things.

Michael Gielda: Yeah. And of course the portal is kind of just scratching the surface. It's really, it's not, not all of our products are even on boarded as of this point, but yeah, I mean, I think that the broadness of the topics covered there should kind of signify the one thing that we we've understood throughout the years is that the pattern turns to repeat, like everyone thinks that it's just their market that's special, but it's not true. Many of these things, the, the, the phenomena are really, really similar. I mean, it's not, not a coincidence that we have, you know, the Linux foundation planting projects in different areas, like the Chipsy Alliance is LF project and the Zephyr project. By the way, we just became platinum member. It's also Linux foundation project. And, you know, there's many different projects out there in completely different areas, but like, if you dig deep enough, you'll understand that the processes, the methods, the problems that people face tend to repeat. But everyone thinks that their problem is special to us. We're trying to show, no, no, no, you don't understand. There is typically in your business, there's a huge part that could be easily open source and like nothing would happen because most people out there, they don't care about your business enough.

Chris Gammell: Yeah. Most people aren't paying attention.

Michael Gielda: They don't care enough about your business to be trying to kind of steal it away from you. They, they, they have their own stuff. They're ambitious. They want to do things that are not necessarily the same things as you're doing. And even if you open source half of your stuff, like nobody's going to be able to copy it easily. Like they're not going to see how this all connects well. And, and, you know, it's a process. It's, it's not that you kind of convince people and they see the light and then they open source everything. But it's more like they see those little niche areas where it wouldn't hurt to open source this part. And then we can do some interesting research here or, you know, something like this.

Chris Gammell: Yeah. I mean, if I think about like, I'm going to pick on, not pick on, I'm going to keep using Xilinx as an example, right? They're, they're huge or now AMD. And it's like, so if Xilinx decided to make their tool chain open source or even just part of their tool chain or whatever, that might give some insight into some of the, some of the stuff internally, some of the structures of their logic and how they're putting things together. But does that mean that Altera is going to go and copy it right away? Maybe they'll make some marketing material against it. Okay, sure. But it's not like they're like handing away their, their like masks at the fab, you know, it's not like there's a, you know, it's not like you're just handing over the keys to the entire kingdom. So yeah, it is, it is interesting to see what parts are, are valuable to a company and where the resistance actually is. I mean, I think some of it is probably just cultural as well, but yeah, there's a lot of inertia

Michael Gielda: as well. Like there's one particular thing that we get asked about a lot and perhaps it's good to use some time to, to explain that. A lot of people say that they don't open source stuff, not because it's like impossible for them to do so for strategic reasons, but it's more like, if we open source it, we'll also have to support it. And people will ask questions and we don't have time. We don't have engineering power to, to, to answer those questions.

Chris Gammell: That's interesting. Cause it feels like that's the opposite of what would be actually, I mean, you know, it's like there would be then community.

Michael Gielda: Initially, initially I think that's not a. The concern is not ridiculous, right? Like initially indeed you open source something, you get a lot of questions because there is no community yet. And you don't have like 20 engineers to go and start this community. And, uh, uh, and you are afraid rightfully so perhaps of this initial period where you have to figure out the strategy. How do you approach difficult questions and people, I don't know, poking fun at dealing

Chris Gammell: with engineers. Yeah. Yeah.

Michael Gielda: So, uh, and it's, so it's a valid fear, but it's, it's like, it should be much smaller than it actually is because over time you can literally tell people, Hey, this is open source. There's no support. And, and, and, you know, there really is no support and that's it. Like I, I don't owe anyone anything because I literally just, you know, pushed, you know, 20 years of my work open source, for example. And how, how do people expect me to also go and support that for 20 more years for free?

Chris Gammell: Right. Yeah.

Michael Gielda: And, and like, you can, you can say that you should be open about saying what you can and cannot support and people can be grumpy about it. People can say, Oh, in that case, I'm not going to use it. Uh, but, um, many people are like, I'm like this. I go online, I see a project. And of course I like when the project is well-maintained, there's a lot of, you know, issues, but at the end of the day, I look if the project is, you know, does what I want. And like, especially in the context of a company that I run, I'm like, well, it's a risk that I'll have to kind of put in work to kind of go and maintain this. But I mean, otherwise I'm just writing things from scratch, right? Or yeah, exactly. I can go and pay someone to do this. I mean, there are many ways and it's okay to talk about it.

Chris Gammell: Yeah. And I feel like there is a false sense of security too, right? If it's like, okay, so someone's writing a piece of software for 20 years, you've been paying a license fee for 20 years. You assume that you'll be able to pay for 20 more years, right? There's that assumption. But if the maintainer who you've been paying money gets hit by a bus, there's nothing there. I mean, like it's done. That's the end.

Michael Gielda: That's typically a fear in the open source community. But I'll translate that to the proprietary software space. Like companies disappear.

Chris Gammell: Oh, actually I was talking about the proprietary space. Yeah.

Michael Gielda: I know, but most people kind of, most people are associate open source with individuals, which is of course not true, but like this, this kind of tendency of thinking about people getting hit by a bus is typically about, you know, this kind of lone maintainer of an open source library.

Chris Gammell: I see. Yes. Everyone's using.

Michael Gielda: I mean, the thing that perhaps comes to mind more directly in the closed source world is a company that just exists, but then just goes bankrupt. I've just recently talked to a friend whose friend was running this company, selling licenses and, you know, like there was one bad year and like they couldn't sell the licenses. And, you know, suddenly there is no plan B, right? Because in open source world, you can kind of easily pivot. You can kind of, you get so much free marketing and, you know, you've got a community that you could perhaps exploit to kind of sell other things. And there are, exploit is a bad word, right? But you like work with the community to, to figure out a strategy to, to compensate for whatever has been happening. Whereas if you're just literally selling people software in a box and there's a year where the boxes don't sell well, you can be in trouble and your company goes under and, you know, you've got nothing. Like suddenly the software is not there and the code is not there. Like nothing's there. Whereas in open source, yeah, the maintainer gets hit by a bus, but like someone can pick it up and it's a sad thing to happen, but like the code, code doesn't care, right? It's on the server somewhere and it's your call. If you're going to take the code and maintain it, or perhaps just fork it and use it internally, you don't have to even maintain it publicly, but you're, you're allowed to do that. And what we've been saying about open source a lot is that literally the only difference between proprietary and open source software is like open source software, you get the code and you can, of course, and you can do with the code, whatever the license allows you to. And that's the only difference. There are implications, of course, like different things tend to happen to open source software versus proprietary software. But it's not that doing open source implies doing everything else that people think you should do when you're doing open source and vice versa. Doing proprietary stuff doesn't mean you're a big evil corporation, right? Right.

Chris Gammell: Yeah, exactly.

Michael Gielda: It's all kind of related to how people behave, but it's like a spectrum, right? It's just code, right? Yeah.

Chris Gammell: Yeah. Interesting. Okay. Well, I mean, let's, let's talk a little bit about the, I mean, so we, we talked last time about Renode, can you remind people what Renode is?

Michael Gielda: Sure. It's a simulation framework and open source, of course, simulation framework that especially works very well in the context of simulating IoT systems. We can do multi-node systems. Typically, like we have a lot of Cortex-M support in the ARM world. And of course we have a lot of RISC-V support, both 32 and 64 bit. And you can go up to fairly big devices running Linux and, you know, build networks. And increasingly also we've been used in like prototyping of new SOCs, new platforms, because of course you can just build a simulation model and we have, you know, the ability to trace and debug and, and measure different things. And so people have been also taking it up in, in this kind of pre-silicon development context. But like much of our use is also in just, I do have a dev board, but the dev board is just hard to put in a CI on a server. So instead I'm using simulation to kind of automate my processes easier.

Chris Gammell: Yeah. Yeah. This is, this is something we actually talked about in the last episode as well, about like continuous integration, continuous deployment, that sort of thing. And Renode being a part of it where you're not actually pushing maybe a new piece of firmware or software to a board, you're pushing it to a simulation. That's that kind of idea, right? Yep.

Speaker ?: Yeah.

Chris Gammell: That's cool. So then let's talk a little bit about the, I mean, so we kind of touched on the FPGA stuff last time, but obviously there's more and more happening in the past six months just, and continue on in the open source silicon space and the tool chains, FPGAs and ASICs. So where, where is that stuff moving?

Michael Gielda: Oh, that's, that's kind of moving pretty, moving on pretty nicely. I mean, there's, there's many things. First up is generally speaking. Yeah. risk five is, has established itself as, as a very important player. And, and one of the top choices, you know, for, for new designs, if you need to build something with a core in it, you're probably going to use a risk five, especially in the PGA. Of course that's, you know, trivial because there's just so many things you can grab and run on a $50 board. But also in, in ASICs in Silicon, you know, kind of more and more people just, they come to us and say, Hey, I want to adopt risk five for our next product. Can you advise me what, what core implementation to use and what are the draw box and benefits and trade-offs?

Chris Gammell: Right. Right. And just to remind people, risk five is a ISA or instruction set architecture, but then there's a bunch of, I mean, I think what you're saying, Michael, is that there are a wide variety of actual implementations, like actual cores. Right. So how, how does that interplay happen?

Michael Gielda: Well, I mean, different people want different things. There's different regions of the world and, you know, everyone wants to have their own flavor of risk five in a sense that ISA, the specification is common and it's developed by a consortium who has to like negotiate what kind of stuff goes in and out of the spec. But as the spec gets ratified, you know, certain things are like fairly fixed by now. So kind of, you just have to play along, play along with the rules, but then the micro architectural implementation or how many cores you're going to have or how these cores are going to talk to each other, what kind of IO are you going to put in a chip? All of this is up to you. So in fact, there's still a lot of variation, even though the ISA is the same.

Chris Gammell: Yeah. It's interesting to me because when I think about like, you know, an open source project broadly, you know, I usually think about large software, open source projects, you know, Ubuntu or sorry, Linux more broadly rather, you know, and you think about these, I think about them as kind of this monolithic thing, but that is very much not the case. And it really does become these, because there's so much opportunity for customization. Again, just use a Linux example. There's however many distributions are out there. There's maybe like some strong contenders for, you know, the center of gravity around new users using Ubuntu or others are, you know, using, you know, like corporate users might be in Red Hat World or CentOS or whatever. And so like, how does that end up playing out in the space as well? It seems like there is, are we in that realm where people are still figuring out the variety of different cores and, and combinations that are available? Is there a center of gravity yet, I guess?

Michael Gielda: I mean, there are a few at least, but apart from the centers of gravity, there's, you know, a lot of variation as well. So you can't not mention Sci-5, of course, who are the original people behind RISC-V that kind of came out of Berkeley and founded the company. And they, of course, have a big portfolio, of course, and recently just released some, you know, performance oriented cores, interesting stuff just, just a few days ago. And they tend to, of course, do quite a lot of stuff and, and we work a lot with them and their customers. But having said that, you know, Sci-5 uses Chisel, Sci-5 has specific, you know, design choices that they do, a certain, you know, set of alignments and so on. And there's, there's plenty of other choices that other people might be inclined to use instead. We're, we're, we're kind of neutral in the sense that we tend to suggest whatever people feel best with, because ultimately it's going to be their design. They're going to have to live with it and continue to develop it. So some people, you know, love Chisel, other people hate it.

Chris Gammell: Opinions and engineers. This is, this is very weird to have opinionated engineers.

Michael Gielda: So that's, that's kind of one of the angles. But of course there's many more. There's kind of implementation stuff. There's like different kinds of processes that you can build those chips in or, or research interests and stuff like this. So, you know, there's another center of gravity somewhere in, you know, more in Europe around ETH Zurich. These guys have cores written in System Verilog, which is, you know, also a love-hate thing. Some people believe it's the only way. Other people say, no, that's like, so 20th century. We're interesting. We're in this camp, which says, well, both of these things are great. Like we use Chisel a lot for doing like, we did a DMA core in Chisel. We did, you know, we're doing a bunch of projects in Chisel, but we're also using System Verilog for other things and kind of building tools. We have this, two efforts actually. One is just supporting System Verilog better in open source tooling for parsers and linters and formaters. That's what we're doing with Google and kind of putting a lot of effort into this in the Chips Alliance. And, you know, this is kind of trying to enable all this code base. You know, there's a huge code base of System Verilog stuff out there that people would still want to continue using and you can't just throw it into a dumpster. So we're kind of enabling use of that code in open source tools by enabling the constructs of the System Verilog language, the HDL that they're using to work in different kinds of like parsers and linters and formaters and synthesis tools. And then another effort is focused on doing, you know, UVM style verification with open source tools because everyone keeps saying, oh, it's impossible. It's impossible. And we tend to say it's impossible as of yet. But we have done good progress. And if we, you know, put in more work into it at some point, you just will be able to go take UVM benchmark, sorry, test benches and, you know, push them through like very later.

Chris Gammell: And what is UVM?

Michael Gielda: It's the universal verification methodology. You know, it's kind of a well-established methodology to verify chips. And for those of you that don't know, building ASICs is kind of much of the work ends up being in the verification space, because if you're going to tape it out, you'd better be sure that it's working. So, of course, design is important, but then you spend a lot of time in, well, testing in a sense, right? You just have to verify that the thing you've done works in various contexts. So UVM is very often used by people that do System Verilog, and then that's not supported in open source yet. And we're kind of working to get Verilator to support this. We've just had a talk with the Chips Alliance last week, I think, where we presented the recent progress, and there's been really good progress. So we're kind of trying to tell people, look, probably the future is going to be diverse. Like, there's going to be people working in Chisel. Other people will be using Midgen, which is a Python-based, you know, framework and language. Other people will focus on System Verilog. There's a, you know, VHDL is, of course, still quite popular in Europe and at IBM, I believe, and other places.

Chris Gammell: In the military industrial complex, I believe, as well.

Michael Gielda: For example. So in general, there's just going to have to be plurality. Like, and we're okay with that, because we've seen that in software, it's exactly like this. Like, some people love Docker, and others are like, we have to use Kubernetes for everything. And others are like, no, we've invented a new container runtime. And that's just how it works when you get a lot of engineers into one room.

Chris Gammell: So that's right. I mean, so when we look at all this stuff, I mean, the variety of things that are out there, is it more that it's just kind of coming to light, and it's been behind closed doors, and now it's less behind closed doors? Are these actually new platforms around this stuff as well? I mean, I know we covered some of this stuff last time, but if I'm being completely honest, some of it is so far over my head, I've forgotten some of it, Michael.

Michael Gielda: No, there's a lot of both. Like, there's both stuff that's been around just very, very niche, and nobody's heard about it. And there's just new concepts and new tools. And I think that's great, because, you know, getting people to uncover stuff that they've been working on for 20 years is an incredible thing. And Chips Elias kind of has been involved in this kind of community building where you get people that used to just develop something in the corner and, you know, see the value of the tool and, like, think about how do we make it into something that's useful to broader community.

Chris Gammell: One thing I'm also wondering about, though, is, is there still stuff behind closed doors? So if you, if you walked into an Intel or an AMD, is there stuff and proprietary tool chains that are, like, not on this list that are actually, you know, like, because I'm a very big fan of this, and, you know, I'm in charge of scheduling guests on the Amp Hour, and, you know, we've had a lot of people in here talking about it, and I'm excited about it. That doesn't necessarily mean that represents all of reality, you know, so, so how much does this represent the broader industry in terms of percentages as well? I mean, is this, are the intels of the world using something completely different that we're not even including on this list in terms of verification and that sort of thing?

Michael Gielda: It depends, like, because in different areas, it's a bit different. But in general, you can think of it as there is a lot of stuff behind closed doors that could potentially be open sourced, for example. And we are talking to different people, different big companies explaining the benefits of doing so. And it's, it's, it's hit or miss, right? It depends on who you talk to, and how do you present the benefits and how afraid they are of the consequences of opening up some things. Sure.

Chris Gammell: Well, I remember I had a particular interaction with, with someone about, about this stuff. I was, you know, talking to someone about doing, so they were at a large lab and, you know, designing hardware there and they were using like ultra zinc, ultra scale chips. And I had mentioned like, oh, have you looked at like the, you know, open tool chain things? And he just kind of looks at me. He's like, I mean, I, I, there's, there's nothing there, Chris. I can't, I can't do that. You know, like there's, it's just not there yet, you know? And so it is these, you know, just to, maybe it's a little bit of a splash of cold water, but like there are certain areas and certain realms where we're just not in yet. You know, it's just, this is not. Yeah.

Michael Gielda: Yeah. It's like the work to be done vastly outweighs the work that has been done so far. And that's, that's not, not just, you know, FPGA tool chains or something. It's everywhere in the world. If you look at it, most of the stuff out there is, is, is just closed. You don't understand how it works. Nobody describes it to you and it's nobody's fault. It's just how it turned out. But yeah.

Chris Gammell: Yeah. To use, to use that example again, it's just like he had a certain specification, right? He needed to use something that had a gigundous FPGA with some, you know, hardcores in there and stuff like that. Okay. That means you have pretty much two choices. And then it's like, all right, how do I write software for this thing? Well, you get what the, you get what you get, you know? And it's like, you know, you can't just turn around and like use something smaller because of the, you know, the hardware requirements and you aren't going to go and write, you know, try and blow up a tool chain when you have a deadline. So like, that's when it really becomes difficult, I think.

Michael Gielda: And it's a struggle. Like we basically want to approach it from different angles is that you remember, you have to remember that the tools are super exciting and really important and want to change this. But I don't think we'll be able to change that without at least some degree of cooperation with the vendors. But totally. There's also the IPs, right? There's also the platforms, the hardware. And we're trying to work on all of these levels. So the reason why we're spitting out, you know, open source hardware boards for different kinds of FPGAs is that if you show people it's possible in different areas and you like chip away at this block, you eventually get to the part where it's just the tool chain. Like there's nothing else. And that's right. And it starts that you start seeing the problem because the problem is typically convoluted. Like you get a tool chain and there's like IP cores that you get for free bundled there. Everyone's kind of a bit lazy, just like I am. Right. Like even in my team, right. Someone comes over and says, I want this FPGA project. Right. We have customers building FPGA stuff. And if you tell them, hey, building this from scratch is twice the work that just grabbing Silenx IP. Well, obviously for many people, the economics are going to be simple. That's right. Like let's just grab the stuff that's available off the shelf and just is there. So what you have to do is like figure out where is open source already good enough or almost good enough to be immediately used in practice. And we've been able, especially in the past few months to, you know, do a bunch of projects where we've been able to show how open source stuff can outperform even, you know, the stuff. Yeah. And it's, it's, it's islands. Right. But you kind of over time, you merge those islands and you push more and more. And RISC-V, for example, has been instrumental because with RISC-V, like whenever you, we've been able to achieve really incredible performance results with cores like VEXRISC-V and FPGA where, you know, you can put a multi-core Linux capable SOC into your FPGA. And I'm not talking about like a huge VU19 FPGA. I'm talking about something that has, you know, 35K LUTs or less, right?

Chris Gammell: Like the high end of a, of a micro semi. Oh God, that's an old name. I think that's the low end right now.

Michael Gielda: Like the high end of a semi thing goes to like the polar fires up to, I don't know. Oh, that's true. I don't want to say the wrong thing, but they have hundreds of K LUTs, right? So I'm talking fairly small commodity FPGAs that you can buy on a hundred dollar dev board. Got it.

Chris Gammell: Yeah.

Michael Gielda: And that can run Linux and Doom and, and people are shocked because like, they're, they're like, oh, we thought that was implicit, like explicitly impossible. And you show them, no, actually, you know, you could fly to, to, to, to the moon.

Chris Gammell: Yeah.

Michael Gielda: On this kind of hardware before. Why, why wouldn't you be able to, to run Linux on this? And of course it's, it's the result of a lot of different pieces coming together, but that's exactly the, the, the, the progress. When you do incremental progress in different areas over time, you take a step back and you see you've, you know, you've doubled the performance or you're fast improved the ecosystem. So that's kind of what we're trying to achieve. Like playing at it from different angles, a little bit, you know, tool chain work here, a lot of IP work. We do a lot of, you know, open source of PGAP stuff, methodologies flows. Perhaps if you can't do open source place and route, you can do open source synthesis with something like IOSIS. So there's many ways you can, you can kind of approach this problem, but ultimately, of course, the problem is pretty complex and it's, it's not going away anytime soon.

Chris Gammell: I have a, I have a example that is not actually a FPGA example. It's a firmware example, but it's kind of the same thing, although it's kind of also a bad example given recent news. But like one thing, like, so Nordic put their Bluetooth stack into Zephyr, which is another thing you guys work on. And the bad news is that there was a security vulnerability recently found, but that's neither here nor there. And, but like before it was like, you have the binary blob and it's tested and that also could have had a vulnerability as well, but you don't know that. But then you could start to actually, when it becomes more open, you can actually like whittle away the things you do or don't need. Right. So in terms of space, in terms of speed, you can start to optimize things and you have visibility into it. I imagine that same kind of thing is happening in the FPGA space of just like, you have more visibility into the code, into what you need, and it becomes more piecewise instead of like being handed up a blob or just a block of code that you can use. You can kind of pick and choose and it's, it's a tighter integration. Is that, is that a good example or no?

Michael Gielda: Absolutely. I mean, you know, the part of security vulnerability, we should definitely go back and replay the part where you said there might've been a vulnerability. You just didn't know about it. That's right. Yeah.

Chris Gammell: I mean, yeah.

Michael Gielda: I mean, so, so in fact, like that's the whole point of open source is that yes, vulnerabilities are easier to expose, but like that's the whole point. It doesn't make the vulnerabilities go away. Right. It just puts them in plain sight, which sometimes is detrimental, of course, but like, that's only because you haven't been doing your security analysis well enough. And, uh, I think that you're correct in this analysis. Like you can start tweaking things in various different ways, but just, they wouldn't come to mind to the vendor or some kind of, especially, you know, a lot of the FPGA space you have to remember is like people buying, you know, various little IP cores from various tiny vendors. Right. Right. Yeah. Yeah.

Chris Gammell: It is. It is surprising. Sometimes you're handing over 10 grand for like a, you know, some code and they say it works, but like, do, do you know it works?

Michael Gielda: It's probably tested. And so I'm not saying it's bad per se, but like, it's definitely hasn't been optimized for each and every use case out there. Yeah. Right. It definitely hasn't been tailored for you. It's just like, you're getting a stock black box and you're not, I'm not saying, you know, it's unreasonable to expect you to be paid for, for something you've put in a lot of work into. It is just like, I think personally, this model will be going away and open source will just take over because it's just, it makes sense where you have this building block type of system, right? Where literally you can kind of switch things to other things and they interface to each other over kind of almost physical, you know, APIs. It almost feels like it's even a better example of why things should be open source than software is. Because like a software, software doesn't have to have an API. You can write software that's like, it's very hard to integrate with and you just have to rewrite it to make it integrable with other stuff. For, for, for IP cores. I mean, literally they have, you know, buses and, and, you know, there's interfaces like AXI that you connect those over those buses. And, and, and so that's what we've been showing with re-node as well. You can kind of plug it into that conversation where we're showing, look, the SOC is, you know, a bunch of things sitting on a bus and talking to each other. And there's no magic. Like, sure. There's some magic internally in the hardware in terms of the micro architectural implementation of things. And, but on the top level for a software engineer, like whether it's this UART or that UART, like it's just literally a difference of the registers are different. The memory map is different, you know, but it's more or less works the same. And, and, and all of these things are kind of synonymous and, and you should be able to think about them in a much more like, Hmm, should I use this or that? And, and, and you should be thinking about it from like, what do I need for my software for my end use case perspective? What do you end up doing instead very often is what's available in the market. And you, then you take it and you try to map it onto your application. Right. Writing wrappers. And you're frustrated. Yeah. And you're frustrated because like the hardware you need actually doesn't exist at all. Or perhaps there's just one thing that fits your bill. And then of course there's the chip shortage right now. So it turns out that the thing. I haven't heard about that. So, so, you know, it's kind of actually the chip shortage has revealed a lot of the ridiculousness of hardware.

Chris Gammell: Yeah.

Michael Gielda: As long as everything is available, you can get by, like you just go and you're like, Oh, okay, that's not possible. That's not, but this one works. But if most of these things are not available upfront and you have to wait like a year to get them, you realize that not only is it bad, it's also not there. And, and, and, and those things pile up. And I think software people are starting to realize that, Hey, we'd, we'd like to be more in control of the hardware that we're getting because then like we could dictate whatever gets manufactured. And of course, like in theory, that's the case because I'm not saying that the semiconductor is not listening to, to software engineers, but they're typically listening to them through, you know, 10 layers of, of corporate structure. And possibly they're also listening, you know, just to a few big guys, but they're not necessarily listening to thousands of voices out there who might have something interesting to say. And open source will not change that like in one day, right? You will still have a lot of confusion and frustration, but the frustration, what I like about open source is that you can take your frustration and turn it into something productive. You can take the stuff and improve it.

Chris Gammell: Yeah. It does sound like, uh, like have taking action in a, uh, a situation where there is no control. I'm not, yeah, I'm not completely sure. I mean, like abstraction just to solve a problem like this is maybe not something I'd necessarily recommend, right? Like if you can't get a certain chip and you're like, well, I could just switch to another chip and, but I just need to go and write a huge framework to make everything look exactly the same to my software. Or I'm not sure I completely agree with that as a solution, but I do agree with it more broadly of like, but if it would, but the porting would become a lot easier if it was from the beginning, you know, a more abstracted type of interface. And then it just becomes a moving some parts around at the end and re-verifying.

Michael Gielda: Yeah. And believe it or not, it's, it's, it's already quite abstract and it's already, it should be quite prone to, to this. And much of the movement around making it stay like, like it is right now, like making IP cores close and so on. This is just a legacy mindset. This is just inertia, but like, there's nothing other than, you know, there's nobody that has big enough interest in making these things open. That would just give it a strong enough push. And, and so we're trying to, you know, be what, one of those sources where we just kind of try to give it a much stronger push than we normally would, because ultimately we think that open source will really transform the space because you'll be able to just go and build your thing without asking anyone questions, without signing NDAs, without getting frustrated. And that means FPJs will go into many more places. FPJs will be much more easy to use and, and, and less frustrating for people. And overall, I think it's going to be a huge benefit to the FPJ vendors themselves.

Chris Gammell: Sure. So one, one thing I want to get back to too, is the, the idea, kind of like the mindset shift as well of, you know, that, that idea, just to go back to the buying of IP versus kind of using IP that's out there or test, you know, whatever. But it does seem like implicit and all that is a testing mindset. And this is something I kind of brought up last episode. I was kind of marveling at node and how all these different independence, interdependencies can, can work. And it really is only possible because it's all tested in the first place, you know, pulling in a thousand different sub modules and, you know, getting everything to work like that. There has to be testing there. Whereas it feels like if you're buying an IP module, it's like, you're basically kind of handing off that responsibility. You're saying, well, I paid you all this money. You have to make sure it does exactly what I say it does. You need to hand me traces that show that it's doing what I asked you to do. But now it's like, you're pulling now an open source module off the shelf and you're saying, actually, does it work in my specific scenario? Does it work in my chip, in my design? And does it work how I want it to work?

Michael Gielda: Yep. And you can, you know, test it much more easily yourself and you can pay someone to test it. And like, it doesn't mean that the thing that you're going to get is always going to be of superior quality than whatever proprietary IP core would be. But at least you get a fair chance of checking it yourself if you need to and or just finding someone to help you. And, you know, we offer those kinds of services. But like, it's never exclusive in open source, right? You have choice. You like, you don't like one vendor, you go to someone else. In this proprietary landscape, the challenge becomes that it effectively becomes an oligopoly where it's just very hard to break through because, you know, most of the pie is already eaten. Nobody is interested in growing the pie because, like, they own the pie. But I think that what open source IP will do, it'll just grow the pie. It won't necessarily make, you know, traditional vendors go away. They'll have to change a little bit. But there's always going to be niche applications and different kinds of people that just prefer to pay and not have the problem. What we're typically, as in my quote, we're looking for is customers who actually want to have the problem. Like, they want to own their stack a bit more. They want to be more vertically integrated. They're okay with learning how to do development in order to be able to sustainably kind of improve things without having to rely on third parties or exclusively rely on third parties. We are a third party, too. And people rely on us. Right, right.

Chris Gammell: But you also hand the code back at the end of the engagement. You're like, well, yeah, you don't like our services. Go ahead and, you know, do it yourself or hand it to someone else or whatever.

Michael Gielda: And most often, it's not like someone doesn't like the services. It's more like people want to take it over internally, for example. It does happen. Yeah, that's a big one. You're developing it for years, and it's gone to the point where most of the heavy lifting has been done. And there's this occasional tweak and, you know, a comma that needs to be moved from phase 8 to phase 8.

Chris Gammell: Right, right.

Michael Gielda: It's okay for you to take it over and do it internally. It's actually probably the best way to do it because the overhead of telling someone somewhere else to do it for you is just too big. But, of course, a lot of our projects end up being very, very long running. Because as people get to start building their own things, they realize there's just so much more they could build and, you know, they stay with us for a very long time. But we do have those kind of drive-by customers, right? Like they build a product and the product's finished and they take it over and disappear. And that's also fine.

Chris Gammell: Right. You still see the commit messages from them. So, you know, they're doing something there or something like that, right? Yeah.

Michael Gielda: Or even they come back after three years and say, hey, we're building Magento. That's even cooler.

Chris Gammell: Right. That's good, too. I mean, so if someone was... Okay. So someone... Let's contrive an example here, if you don't mind, because I do love doing that. If someone was completely disenchanted from... Say they're like doing a FPGA security camera. They've gone through a previous channel and it's completely closed source. And now they're like ready to be... They're like, all right, I'm picking up what Michael's putting down. I'm ready. I'm ready to do this. Like, what is the most open path right now to do this sort of thing? I mean, if they're ready... If they were ready to go all in, what would be the most open scenario that you could think of? Because one thing I want to type... You know, we've been talking about open source in the abstract for the past hour. And we... Obviously, people can go check out the open source at antmicro.com. But like piecing it all together in terms of putting hardware and firmware and software and maybe even stuff all the way up to the cloud in line. What does that look like? I mean, what is the most open example you've seen?

Michael Gielda: Funnily enough, we've actually had customers that ask the same question, right? Oh, really? Interesting. We want to build like a fully open source flow from beginning to end. How do we do that? What kind of platform do we need to use? And so on. It depends on what you want to build, of course. I can talk about this example of it's a security-focused company.

Chris Gammell: No, I said a security camera. It's just... I'm just... Like I said, it's just a contrived example, right? Okay, let's take the camera. It's got network connectivity. Yeah. It wants some kind of smarts on it for doing like human detection in a space, right?

Michael Gielda: Yep. So basically, first of all, open source like Ethernet IP cores or open source PCI Express and so on. These exist. These are being used. We are implementing them in projects. So kind of that part is actually pretty well sorted out.

Chris Gammell: Okay. All right.

Michael Gielda: Probably kind of if you really wanted to go full open source, if you're going to wanting to use an open source tool chain, you might grab a 7-series FPGA and that's kind of a simple project. Sure. You could also use Lattice, you know, an ACP5 or the Crosslink and X. Actually, we're working with Dave Shah right now to also kind of open up the tools for that platform.

Chris Gammell: Sorry, what was that last one?

Michael Gielda: Crosslink and X. It's a fairly new FPGA from Lattice. Oh, cool.

Chris Gammell: Okay. Yeah.

Michael Gielda: And those kind of platforms, this family of platforms, you'd get pretty decent coverage of open source tooling. Again, it depends on what you want to do, really.

Chris Gammell: Well, we've had people on the show before, yourself included, talking about all of the up and down the tool chain. We have Claire on here. We've had Peter talking about stuff. I mean, just a lot of different. Tim has been on a couple of times talking about it. So people can go and listen to all the various episodes about the open source tool chain stuff for FPGAs. And it's improving, right?

Michael Gielda: So if they listen to something that was being talked about some time ago, chances are things are better now. Then you'd go and basically boards, also there exist, you know, open source hardware boards. If you want to have dev kit, that's open source. We have some dev kits and we've been kind of pushing out a bunch of open source hardware. But of course, especially I think for the Lattice parts, there's quite a bunch of hardware available right now.

Chris Gammell: So, and are you actually manufacturing and selling that yourself or is it just like it's under your brand and someone else is making it?

Michael Gielda: So in the FPGA space, I don't believe we're selling any or even someone's selling any of our stuff yet, right? We're doing this, as you know, for the NVIDIA Jetson board that we've designed. We're working with Capable Robot and that one is being sold and actually selling very well and getting into a lot of projects. But we'll probably do that with FPGA boards as well.

Chris Gammell: And that's Chris Osterwood as well, past guest of the show.

Michael Gielda: Yeah, you've had Chris, of course. So basically for FPGA boards, we don't do that yet, but like I think we should. So it's an open topic.

Chris Gammell: But I mean, the designs are out there too. So people could go and fork those and manufacture them themselves as well. So again, if they want to do completely open, they could go all the way down to the sending files over to an assembler and be like, hey, let's do this.

Michael Gielda: And then, you know, in terms of if I was doing a security camera, I'd probably go either I'd use something like, you know, a zinc. But then if you really want to stay with, you know, a pure FPGA, RISC-V would be your choice. And then for RISC-V, I'd probably go with VEX RISC-V, which is like our canonical, you know, RISC-V implementation that we're using from Charles Pupon. And VEX RISC-V is really, really performant and quite small. So it doesn't really take up a lot of your FPGA space. You probably wouldn't necessarily need to put Linux in the camera unless you want it. Like depends on what kind of camera you're building.

Chris Gammell: Sure. Let's say why not, right?

Michael Gielda: Then you could, right? Like you can do that. And then you'd have, if you want to output the data over, say, Ethernet or something, you could grab, you know, LightX or something to output that data. You need RAM. But like we're working a lot with LightDRAM, which is an open source, well, DRAM controller. And implementing support for various parts and testing it with various hardware platforms. So you could interface with RAM using an open source controller, you know, and so on and so on.

Chris Gammell: And you said there's an Ethernet core as well. Like then, so an Ethernet core is just, is that the everything but the FI kind of idea?

Michael Gielda: Yeah, yeah. So basically a lot of the time you end up kind of, some part of it ends up being, you know, some little Xilinx or, you know, lattice wrapper here and there. But you can kind of, all of the digital logic is typically open and shared between platforms. Because that's one other thing with these things. As you create open source IP cores, you realize, well, you could actually reuse a lot of this across different vendors. And, you know, vendors don't do that because, of course, each of them wants to, you could stay on their platform.

Chris Gammell: Right, right. Lock in.

Michael Gielda: But for the IP cores that you're doing, you realize, okay, like actually it's very useful because then you can start comparing and perhaps like recommending things to customers that they really need. Right. Like if you had this apples to apples comparison ability between different platforms, you would just be able to kind of help people do whatever needs to be done.

Chris Gammell: And you would actually push sales, right? I think so. So you would be able to go to sales and you'd be like, they'd, you know, they'd come back to you and say, why didn't we win this socket? And you'd say, well, I compared the lattice part and the Xilinx part and the Xilinx part had X and I compared it to the lattice part and it didn't have X and you didn't win that socket. And then there's like a money anchor for why they should take that back up the chain and maybe actually do that. Right. And that's when I feel like the rubber hits the road is like a very realistic, like we lost because of this feature missing. And then that gets put into a roadmap and that ends up changing stuff down the line.

Michael Gielda: Yeah. Or even like the funny thing is most of the time what's missing is just, you know, better IP. Like sure, a better, a better class of PGA with more, you know, IO or faster IO or something. This is very, very important. And it's good that you can kind of help vendors put stuff on their roadmap. That's important.

Chris Gammell: Yeah. It is always interesting when they, when, when they all say like the, you know, the LUTs, the LUT is such a soft term. I mean, I know that it actually represents something, but a LUT from Xilinx is different than a LUT from Lattice or Altera or who, you know what I mean? Like the actual comparison, it's like these soft comparisons. Well, this isn't quite, you know, 35,000 is actually 30,000 on our platform. It's better, you know, it's like, oh, okay, well, I need to actually compare these things. I need to make an engineering decision.

Michael Gielda: Absolutely. And, you know, the truth is that people are confused. Like in the end, people go away. People don't go into FPGA design. People get frustrated and change jobs. They go into front-end design because how frustrated can you get before?

Chris Gammell: You see that, Xilinx? This is how we get more JavaScript developers. Damn it.

Michael Gielda: Nothing with JavaScript developers. Sure. So in a sense, I do believe that actually it would be a win-win situation for everyone if we had like a shared ecosystem of IP cores and tools. Because that would mean you could just build stuff in FPGAs more easily. Because we do get a lot of customers who come and say, well, we could use like an NVIDIA Jetson or an FPGA. And FPGAs are kind of complex and like nobody likes them.

Chris Gammell: Right, right. Look at these dev kits that we can get from Jetson and just, you know, just have all the SDK ready to go. And I just, you know, use the example and it looks like my example. And it's like, oh, yeah, that's actually pretty compelling. Just a hint. Hopefully someone's listening. Yeah. It becomes like an application thing, right? I mean, and like, I don't know, it runs very quickly into like money constraints, right? Of I can't spend tons and tons and tons of time and resources for something that might not work. I have to, you know, it's a development project. It's not a research project. And it's like, but as the FPGA stuff increases, it becomes more of just a development project. It's turning, you know, turning the crank, turning the next thing to make, you know, to pull in that Ethernet core, pull in that PCIe bus or whatever.

Michael Gielda: And, you know, in terms of this open source camera project that you mentioned, right?

Chris Gammell: Oh, yeah. Right.

Michael Gielda: And then there's lots of tools around, you know, simulation. You just use Verilator. And you can use Renode for the software development on the RISC-V core. Or we have, you know, support for all the kind of major RISC-V implementations and much of the soft IP that they're leading. Yeah.

Chris Gammell: Well, let's tie that together, too. So, like, so now, okay, so I'm talking to my software engineer. They're writing code. It's being simulated on Renode, right? I go and push a change to the FPGA stuff. That gets pushed to Renode so that they can see the change and test that, right? But then that also gets pushed down the stack so that it can be tested against what will eventually get pushed out as a firmware package to the camera. Is that right?

Michael Gielda: Yeah. Yeah, you can do it like this. So in FPGA development, of course, when you change your building blocks a lot, then if you model that in Renode, you'd have to kind of change the models, too. Except, of course, you can co-simulate with Verilator. So that's one way. And then you just take the HDL, the code for the IP directly, and you simulate it in Verilator. And you just plug it in. How we typically end up doing this is we partition the design into a slowly changing part, you know, like your core, the fixed IO stuff that, like, doesn't really do much. Like, Ethernet might be an example. It's typically you're not really tweaking that much, right? But say you're interfacing into different cameras, so you're changing your MIPI-CSI core a lot. And that part you can potentially just simulate in Verilator and plug it into the rest of the system. And some of these things are simpler to do. Some of them are more tricky. But in general, partitioning is your friend. You can kind of co-simulate both between something like Renode and Verilator. You can also co-simulate between Renode and physical hardware. That's another way you can partition the design. And we've done some cool projects where we'd use extremely large, you know, FPGAs, extremely large designs, and helped some big clients, you know, integrate fairly complicated building blocks by just, you know, doing the right partitioning.

Chris Gammell: Does that then cut down on, like, compile time, simulation time, build time?

Speaker ?: Yes, yeah.

Chris Gammell: Developing time.

Michael Gielda: That's key. Because in FPGAs, the development time is ridiculous, typically. Like, you know, you do something and then you have an hour to where you don't know what to do with yourself.

Chris Gammell: Another XKCD comic there, right? Of the codes compiling?

Michael Gielda: And that's true in FPGA development, right? It's no longer so true very often in software. Although we do a lot, I don't know, Android development is, as well, kind of frustrating sometimes because, you know, building Android from scratch is, like, again, an hour or more. But in FPGAs, it's especially visible because as you go to any practical design, I'm not talking about, like, toys and small things. But if you're building some kind of a streaming device or, like, a security camera or something, very quickly, it'll hit fairly long compile times. And, you know, if you want to do some kind of tests against various scenarios, you know, each and every piece of this will make your entire development cycle longer. In some sense, there's no going away from it.

Chris Gammell: I have a very long ago example of this where I used to work on Vertex 4, so a long time ago. This is 2004 or so. But we would be changing things and, like, it was, like, a DSP generator type of thing that was in there. And it'd be six hours, right? It would literally be six hours to build on the computers we had. And so it was like, well, you get it first thing in the morning. You give it a shot from the, you know, the night. You test the thing you did the night before. You have about two hours to figure out if you want to make any changes. You do a build. And then you test it again before you go home. And it's like, yeah, that's the whole day. You get two builds a day. And that's it. And so if you can cut down on that, you start to get more iteration cycles. And you can do better like that.

Michael Gielda: That actually ties very well to a bunch of things. And one of the things that we didn't mention much so far is, like, our involvement in, you know, kind of cloud development. And how do you accelerate workflows using just, you know, disposable compute power? We're working with, you know, Google Cloud. And generally speaking, we're helping figure out. There are ways to accelerate those processes like design, development, test for FPGAs, for ASICs in the cloud. Partitioning those into smaller chunks. Running them potentially in a parallel setup. and this is kind of a very promising area because of course normally this is not how this kind of development has been done and the IDEs and the tools used are typically like monolithic and you just put them on a PC and you just buy a very big PC.

Chris Gammell: Yeah, the best you can do is buy a bigger PC, right?

Michael Gielda: But increasingly people realize, okay, you could actually just scale it up and use a big server and also use it just for a while. You don't have to use it all the time. And open source kind of leans very well into making things more distributed because you can experiment with how the tool chains are built and perhaps see some opportunity in partitioning designs into smaller chunks or for example, one interesting approach is getting tools to simultaneously, for example, place in routed design with various seeds, right? And see what happens and the best design wins and stuff like that.

Chris Gammell: Right, it becomes like evolutionary at that point, right? Instead of like one cycle, now you have lots and lots of family or branches on the tree.

Michael Gielda: So there's a lot of work in that area. We're kind of actively involved. We've been building, you know, kind of integrating stuff with GitHub and Google Cloud, building, you know, custom GitHub runners because what ends up happening is that since most of the time the CI frameworks and the cloud providers, all of this is typically used with software where the build times are not as long. Yeah, yeah. And the requirements might be like some of the tools have ridiculous like RAM requirements and you just, the default machines just don't have that. So you have to go and implement, you know, support for your own machines that can sustain those loads, perhaps from the point of view of RAM or perhaps you want to kind of measure some additional metrics. And then we've been building these kind of custom setups where you're using GitHub. So like it's a, and that's been done in the simple field context, but also in other contexts, also for EDA stuff where, you know, you're using GitHub as a platform, but in reality, you're running your own servers or perhaps Google Cloud servers as the compute power provider. And then you can do whatever you want and the machines can be however beefy you want them to be.

Chris Gammell: Is this an open source project that's, or is this for a particular client that stayed closed?

Michael Gielda: No, parts of it is our open source and like it's a work in progress, right? So it's not- Oh, sure.

Chris Gammell: I'm just wondering, I'm sure someone's listening. They're like, oh my God, I need that. So like, how would someone find out more about that?

Michael Gielda: And I think that we're just kind of getting started. It's like people have seen the opportunity, but like, I don't think we have yet exploited, you know, everything that there is. To improve those workflows and especially for chip design, you know, these are really massive and problematic projects which are just waiting to be optimized. Google has been showing some incredible results with, you know, using AI to improve the design process. But again, it's probably just scratching the surface because this has been such a manual process and such a resource intensive process that people have just lost the forest for the trees, you know?

Chris Gammell: Yeah. Yeah. Google just renounced that, or they just published that paper, right? One of the AI researchers was doing like a chip design using AI, right?

Michael Gielda: Yep. I think they even were multiple papers, but it's just getting better.

Michael Gielda: you know, as long as you can get superhuman results results in fairly limited time, that's when things start getting interesting because you can then experiment with lots and lots and lots of runs and different kinds of AI approaches and just improve it. Whereas, you know, I mean, you can teach a human designer to be better, but like, it's going to take years for them to have a measurable improvement. But for computers, of course, we can just go and tweak things all the time. So yeah, I think the cloud is a huge opportunity and, you know, we're doing a lot of work. Also kind of, interestingly, it ties also some other areas of our activity where we do, you know, over-the-year update stuff or like just remote device management working with a bunch of big clients there. And it seems to be unrelated, but like, as you take it apart, you realize, oh, the problems are kind of similar in many ways where you try to abstract out the physicality, for example, for agile devices, you know, like you want them to, you want to be able to test them in something like WeNote, for example. You want to partition the problems. You want to use open source, right? That's what you asked for is this open source. Yeah. Sure. Yeah. If it wasn't, then like cloud is all great, but if just you know how to do this and they have to come to you for you to explain it to them, you're always going to be a bottleneck. It's better to do things that are open and then some people will just experiment and go away and some people will experiment and fail, but there will be a large group of people that will come to you and they'll already have tried this stuff and they want more of it and that's the kind of customers that typically are the best ones to work with.

Chris Gammell: Yeah. Yeah. I think the fear that like there's going to be work, the work runs out is a bit unfounded because there's a, there's a whole lot of stuff to do and I think, I think increasingly too, I mean like just the complexity of the things you've been talking about in this hour, have been so crazy, so over the top in terms of like just thinking about how many people it would have taken by themselves in the past and now it's because it's been parallelized and because there's open source software on top of it and there's more capabilities that, you know, one person can do a lot more with software. Yep. Awesome. Well, Michael, what else, what else should people know about? I mean, obviously there's a ton of stuff going on with Ant Micro. How can people keep in touch about what is new and, you know, kind of keep an eye on what Ant Micro is doing?

Michael Gielda: I think the best way to do that is the blog, of course, and just looking at the blog notes we're pushing out. We tend to co-promote them, of course, with like RISC-V and Chips and Zephyr, but, of course, various things go into various outlets. The best way to follow us as such is, of course, our own blog and the open source portal since some time. So, from things worth mentioning, perhaps we won't have enough time to kind of talk about them in detail but just to put out there, since we're kind of invested so much right now into kind of making things work in the cloud and kind of scaling up stuff, we're also building some of our own server infrastructure we have some projects called like Scale Runner and Scale Node. As the name implies, the Scale Node is like a originally a Raspberry Pi compute module for baseboard for like server room use and basically you can put, I think, 18 of those in a single new rack, right, and then you can just scale resources very quickly. It's like part of our Ethernet single compute module per one board and then you just can have many, many of those and we're building this cluster approach because we want to give our developers as well as our customers as much compute power as they need. So the Scale Node is one project but then since we'd already built that board, one other project we'd been involved with is the ARV sum which is effectively a RISC-V sum based on this star 5 7100 7100 sorry, now it's 7100 it's going to be 7100 in the next generation. This is the chip that's used on the Beagle 5 Starlight board.

Chris Gammell: Oh, cool. Okay.

Michael Gielda: Yeah, so you have choice you can use Raspberry Pi but you can also put in a module that's kind of compatible with the Raspberry Pi compute module and run it in your server room. And these are of course open source designs that we're building or we have built in some cases or we're building and so not something you can buy off the shelf at this point but we are typically you know when we do these things typically people approach us and say hey, we'd like to figure out a way to kind of scale it up and make it work for us and so on. So definitely looking forward to that getting traction and moving faster.

Chris Gammell: Yeah, that's cool.

Michael Gielda: Yeah, yeah. It's pretty exciting. And when we're in the server room there's also a project called DCSCM and this one is it's called Board Management Controller BMC board that fulfills this kind of standard developed by I believe Microsoft and Facebook primarily for just managing servers. You have this slot in the server you put your board in there and the board manages the server and the board typically has been just hard silicon and ASIC but many people simultaneously like OpenPower team ourselves came up with this idea what if you could just put an FPGA there and make it much more configurable and secure and transparent because you know what's going on in the FPGA you put an open source core in it and open source IO peripherals and so yeah we have this project called Liber BMC that's run by the OpenPower Foundation where we're developing this entire platform and so we've built the hardware board it's also open source of course now bringing that up and that the aim is to create a completely open source BMC so that you know all those big companies that use this standard can have a reference design for fully open source transparent FPGA based BMC and then it's also a great use case for SymbiFlow and stuff like that example of how it can be useful and like very practical and mass market also use cases right because it's not a niche thing it's a huge standard driven by I think OCP OpenCompute Project

Chris Gammell: yeah that's the Facebook thing you're talking about the Facebook server or is it someone else

Michael Gielda: well it's not just Facebook not just Facebook but that's how I first heard about it yeah I think that's yeah right

Chris Gammell: yeah yeah and it started with like a power standard I think and then it's grown from there I believe

Michael Gielda: yeah it's it's grown tremendously it's actually a huge organization

Chris Gammell: yeah yeah I mean it's a great example I mean I think it's a great example of you know it's a hardware space it's a open source thing there's not like a time I mean yeah there there is there are companies that benefit from having some kind of prowess in hardware and like being able to make a better data center but I feel like the growth is just so fast that it's like they kind of just threw their hands up like look we're all going to be growing we might as well do a little bit of it together and we'll customize where we see the true value right it might not be in the power system it might be in the in the custom silicon or whatever we decide to put on the server boards or the you know HVAC system or the interface networking type stuff but but some of it is not you know the stuff that is the plumbing why not make that common and that is

Michael Gielda: that is absolutely what happened I mean it's like there's so much opportunity it's not sensible to be wasting your time protecting stuff that's not really key just cooperate around that and focus on the stuff that you think is key

Chris Gammell: yeah yeah right and and that is born itself out in software a lot as well you know that we see that all the time in software and now it's it's coming to the hardware space more and

Michael Gielda: more yeah so kind of I could talk more of course about you know some of the reno related updates or or you know we've been doing some interesting stuff around row hammer research so kind of row hammer being a security vulnerability and RAM memory and that's again using you know the open source controller again it has its own open hardware platform called just LPDDR4 tester I know it's not a very original name

Chris Gammell: yeah yeah you guys need to hire like just a name maker you know I

Michael Gielda: typically that's me so okay I failed here but anyway the point is the the this row hammer tester it's it's like an entire framework for doing research that you know normally that would be done behind closed doors right it's right it's kind of it's security it feels like you should kind of protect the secret of the fact that right don't let

Chris Gammell: don't let it out until it's until it's fixed sort of thing

Michael Gielda: the problem is that that always leaks right and you kind of at the worst possible time and doing this kind of research in the open with together with Google that has been a nice you know change because you know we've become members of Jada consortium to participate in this work and we've kind of managed to convince them that this platform and this methodology is like a good one that should be used more in this consortium we're you know encouraging all those players to to transparently cooperate because they're not able to find and fix all the vulnerabilities by themselves they can use the help of you know people like Google or ourselves to just do more digging and the way you can do more digging is using open source stuff we have you know being able to tweak your controller means that you can you know fiddle around with what kind of stuff triggers a problem much more easily than you would be able to do if you just had like an SOC where you don't even like directly control the controller right like it's just there and it works in a certain way versus an FPGA because this is a kentic 7 board right it's an FPGA board that we're using there and we put the controller in FPGA and we talk to it and we tell it hey can you kind of attack those roles in this way and Google actually managed to discover new types of vulnerabilities in existing memories that are supposedly protected against rollhammer which is of course unfortunately not the case and this sounds scary but it's better that we're finding it

Chris Gammell: that's right right then it's like undisclosed and it's you know the NSA is just using it yes

Michael Gielda: hopefully not so I think that the rollhammer testing framework it's really a great example of how open source can be used in admittedly a little bit of a niche use case but now we're also talking of taking this to the next level and actually taping out this controller specifically to you know in a fairly new manufacturing process so that we can show hey and by the way the same open source runs in a real chip and it's just literally the same digital logic there has to be of course a bit more fun to be had around the analog part and the file and so on but in in general the reusability of open source across various types of use cases is I think a key thing to to highlight and stress because like even though it might feel to you that your use case doesn't warrant all this custom development like why would you go and open source something if you can aggregate use cases across different fields and show that there's reuse going on all the time people start believing that perhaps it's worthwhile to put in a little brick into this building and perhaps in the future I can benefit back from the building being complete so

Chris Gammell: yeah I like the idea of there being so many problems to be to solve and there's being so many people that are looking to hire help and they just keep hiring Ant Micro and you're just being like well this should be open source and like yeah whatever and then just eventually that keeps changing the changing the industries bit by bit you know there's just a lot of problems to solve so why not solve them and share them yep well I hope other people take take the hint and follow in your footsteps where can people find out more about Ant Micro where can people contact me in order to hire Ant Micro at that very reasonable 25% commission that I mentioned earlier in the show

Michael Gielda: we'll just set up you know a special mailbox just Venmo

Chris Gammell: Venmo's fine Venmo started doing Bitcoin so I guess you know whatever but for real how do people actually find you that's sorry that's what I really meant to say

Michael Gielda: our website of course and and the contact form there are just like right to contact at Ant Micro dot com it's not that hard to find us if you want to we're on GitHub of course with like hundreds of projects and but like traditionally of course if you need something something commercial it's best to just shoot us an email and then of course we do attend various shows and we tend to present different things that we do they tend to go on panels and of course like if you have questions just you can ask those to me and of course like whenever people shoot us an email and the things that they want to do make sense we just get on a call and talk about it

Chris Gammell: sure sure any any shows coming up that you'd recommend or virtual or dare I say in person

Michael Gielda: ah well I mean not in the nearest months unfortunately it's it's there's one called the my5 virtual summit from from microchip where they're going to be talking about this polar fire so see and I'm on on one of the panels there yeah and I think we also have a talk but other than that I think the next big shows will be you know the the embeddance conference summer in the fall it's it's been shifted around you know that there was supposed to be one in Europe but it's not happening so I don't remember the exact dates but there'll be the win one big event that we might go and present something for but otherwise I think it's it's summer seasons kicking in you know and there isn't as much going on as there would be normally yeah we've just had a Zephyr developer summit a very very successful one yeah yeah it's great I think 700 people came

Chris Gammell: yeah and the talks are starting to get released I believe soon too so they yeah there's one

Michael Gielda: about we know there's a panel I was on so if you don't have enough of me yet it's

Chris Gammell: just do the Michael playlist yeah that's great all right great well we'll link all this stuff in and I appreciate you coming back and chatting more about all this open source stuff I hope we can chat again in another six to twelve months and just hear what else Ant Micro has been up to so thanks for joining

Michael Gielda: today perfect thanks for your time it's been a pleasure and thank you all for listening bye bye x