Complex system simulation and HW/SW co-design with Renode open source simulation framework

so yeah, I was talking about how to console software and

complex

es in development with Reno Twitch is an

open

source

framework

that we make and as a company there are a lot of things to say about us but I think the most important thing is highlighted here we want to avoid proprietary work workflows and pursue not out of spite or something you already know in a strange emotional attachment to

open

source

, but rather out of pure pragmatism, we want to attack like an automated script, everything we are doing and, for of course, property. The software prevents us from doing that, so instead we're trying to figure out how to do things with more open source.

We participate in many initiatives. We run some fundamental risk. 5 And in fact, as of yesterday I am vice president of the marketing group, so you can always talk to us about cross-promoting and building the eco

system

and connecting different projects with each other, etc., we are part of Fosse, as people, but as there are no corporate sponsors yet, so I can't say where the members of Fosse are, but first of all we are, we do a lot of things in different areas, it's PGA stuff and their operating

system

s, but mainly I want to talk about methodology because in each From the other areas we eventually get to the problem that the methodologies are preventing us from iterating faster, so if we fix our tool stack, if we fix the way we work, all the other things become simpler, so why do we need parts of a central

design

?

The answer is quite simple, we need more and more features and more. software is available out of the box and some people complain and say oh why do these software people need this whole operating system? But we actually think it's good to expect a lot from your hardware. It's good that people expect hardware to ship with software from day one and we want to enable it and risk 5, for example, and open hardware in general has the promise that greater openness and more configurability will help with this driven approach. by software that could take us there, but it is not enough to have it open.

IPs and having open CPUs are not enough to solve the whole problem, we need tools and methodologies to take advantage of the fact that we have an open course and an open eyepiece, and that is what this truck today is about, so we actually need more parallelism in development we need more feedback loops we need people to work together we need to catch bugs early and we also need to improve relationships between different teams and companies, even between companies, so that more with fewer people can do more, that is one of the reasons why we were renowned in the first place.

I mean, of course, all of these great things weren't necessarily in scope from the beginning, but we had a feeling that it's strange how software and hardware are developed separately and it's so difficult. Sometimes developing software because you don't have the hardware is not very replicable, so we think okay, we need something else, we need something new. We were looking for a flexible simulator that would give us the ability to run different types of software without modification support. A lot of flexible platforms, particularly soft cores that we had been working with from the beginning, the company that could build full board

simulation

s and maybe even multi-board systems have this kind of plug-and-play multi-block nature and we also wanted something scripted to I made an IP that I rented and there was nothing like it out there, so we went out and built three nodes.

It's actually been in development for nine years, so it's not a very young project, but I'll just tell you a few words about it, it's an IT License Framework and as a core part of course there's a dynamic binary translation simulator ISS which is the core of the things we do, but on top of that there is a multi-layered, API-based, modular and building block-oriented

framework

, and this framework that we built is a solid experience in real use cases, we are working with a lot of armed systems and increasingly on RISC five systems, which is very happy, so we will give it a commercial backing and use it ourselves to make sure. that we are not talking nonsense and giving people a tool that doesn't do the things they need, we support a lot of platforms here and there, this is mainly based on our previous projects and use cases that we found and clients that we found, but we don't want to be exclusive of saying that we are at risk v simulator or we are in arms later we agree with something, the different things there are of course focused, the focus is mainly on five platforms recently, as well as many other similar ones.

Cortex and style are my drivers, but we also have things like Leon Leon or Zinc, we have different clients, but there are three of them that have contributed particularly significantly with a microchip, Google and Intel, all of them working in different areas, but In fact. All of these kinds of contributions and sponsorship, our work has aligned very well to do a lot of things that actually everyone could benefit from each other, so what Reno does is have a modeling framework that we can build on. peripherals, we have cores and, furthermore, the normal user is not expected to write much code.

You'll be able to take those building blocks and assemble them in a very flexible format, it's just a text file where you just specify how things are connected, and of course we're talking about instructions that like register-based

simulation

s, so I'm not talking here about psychoprecise things, very close to hardware. I'm talking about a fast simulator that is used for software development. Having said that, we understand that you know that to do good software development for

complex

, configurable systems, you have to create a configurable simulator, it can't be hard-coded, and to do what you need it to do, it has to be very hackable, so that's As far as we know, we have the ability to do Python scripting, so if you want to avoid modeling and a certain peripheral, you can just write a quick, improved hack and it will work, it will meet the APS that we need and you just say send the value if you need it, so this is all within scope and we really wanted to focus on this FPGA co-simulation use case and work closely with the people who actually develop my piece so that the Reno dancers meet those needs . somewhere in the software world where no one really understands what it is, so we have these multiple layers that we operate in and of course for you, probably the most interesting aspect is this system-on-chip aspect, it has a core or multiple cores and then you plug some peripherals around it and we're very flexible on that, you know, we even have an experimental UI where you can do that like it's gaming style but of course most of the things we do are they do online, you know? the UI is our only kind of sugar coating on top, then you can go to a full device, that's a big difference from a lot of the things other people do, so we can build a board that includes a sensor, a screen or a radio. module we model complete boards, there are some examples that you may recognize and we can even go to a complex system so you can connect multiple boards through a wired or wireless interface and again we can visualize this type of system that is actually connected through UART because in the world of venture it's hard to find multiple platforms that can connect through anything other than your work, that's going to change.

I think Ethernet is working pretty well. Button, for example, wireless platform, so it's not there yet, so if I wanted to show you an example of risk five wireless that it's just not possible to do in the real world. Of course, we could do it and we note that we can pretend that such a platform exists, we just put it together from the build box we have, but we tried. to work with real platforms that exist as much as possible and then of course you can run this multi-node system, a lot of console windows will appear and you can do this, it actually shows that you know the communication between two devices.

You can also connect two different tools like Wireshark and analyze packets flying over a simulated Ethernet network or a wireless network, so lots of capabilities? You can also simulate an environment where there is a temperature that your sensor is measuring, for example, and then you can have your entire system react to that change and do things, so we really focus on application software. We also want to enable a full lifecycle, not just the low-level pre-silicon development that you do first, but we want to keep people using Reno and you know they're developing their stuff in more and more complex scenarios to keep the same workflow so they can collaborate more actively and send that data to Heartland and ultimately it was showing you all those query windows and UI. but interactive workflow is one thing, but we also want to enable more test-driven development and not just for software people, although I think embedded software is the key user, but also more generally and I'll show an example Of how. one of our clients does it in layers and to enable this duration condition we actually integrate with a robot framework that performs testing, of course we could do other frameworks but robots are the first option, it is a framework based Python, write tests in a fairly simple way. language and then you get good reporting on all of this, all open source of course, and on top of that, we're also building a testing system in the cloud, so we want to offer this as a service over time, so based on all our open source. source framework, you want to have a way to offer people you know a preconfigured way to run their tests, but of course you know you can take that and do a local install as well without problems and then if you run a test you'll get the result, but you can also get safe points, like if you have been developing a system, you run a test and you want to see what happened like if a test failed.

I want to see what happened, you take this file. you load this file into Reno and you know the whole system appears just as it was at the time the SE file was created, so we have a couple of those cool features and developers that really help when you want to get something done quickly. So now I'm going to talk about some important new developments we've made and some things that should be especially interesting to you. I won't go over them now. I'll just start talking about them one by one to save them. time, the first one, a big one, which was announced at the last verse five summit is compatible with the micro micro semi or polar fire fpga microchip, it says there is no chip and the reason why it is really cool is that it was based on five, so it's very important.

What Microchip has been a major sponsor is five, so we're very excited about that platform. Its multicore has up to five cores and a pretty good and big PDA inside, so the first platform that Microchip had to develop this was this big board, it costs 3 thousand dollars and it's not really very useful, so they knew better. they could scale properly, they couldn't just give him a career board. I assumed that we are not a good representation of all of you, of course we are. We're hackers and we probably know these guys pretty well, so there may be some people who have a badge like that here in the room, but really, if you want to scale that to thousands of developers, it's not possible, so a microchip is sponsored to develop it. its Reno platform, so anyone can go to github now and download Reno and the platform is there and it's an important platform, the feeling that it has a lot of infrastructure, there are a lot of peripherals, the APIs that we had to improve and build to make it compatible, we have PCI Express, we have used B, we have Ethernet, in terms of connectivity, it is really great and also because it has an FPGA, this type of cold simulation aspect is very focused and that is really good because having this in focus of a commercial customer that you know and helps us do amazing things and we went ahead and did the integration much later to co-simulate IPS on FPGA, so people will build new things on Polaris to see the new IPs they have.

We will be able to plug it back into Reno and simulate sin directly much later, perhaps over time, we will also build a model of Reno which of course is also possible, so this newly built constellation capability through the Costa Mesa we need to work this out a little bit, but it's pretty simple and then we can drive it fromReno to comply with the entire API, so that it works as if it were a real native Reno block and you can mock most of your

design

in Reno in a quick way and then just download a bit. part of this - See later, so it's pretty quick and we've done it and suddenly everyone is interested, if there is so much interest in this feature, it looks like this.

I've shown you this format before so you can connect this UART to the system bus in some direction, like you pointed to the compensation layer that you made, it's very simple and done, you have a similar art and this really works to be fast. I don't have a video here, but this presentation links to that video and you can use this normal microchip. He has also been a very interesting user. They've been doing a lot of interesting experiments implementing their own models and doing some kind of visualizations. We have a lot of data. We take all this data and we show it to the user that we have, we can trace the CPU, we can look at the memory, we can visualize, you know, the calculations are cool, so the importance of the platform, like I said, is that you know it's an FPGA platform.

So naturally it's very good for prototyping. Like the RISC zinc five or so, it targets both Linux and real-time systems, which is good because Rinat wants to do all these things and targets all the systems very well and we can also do it so yeah we think overall it's It's going to be really cool and also we're already at the pre second pre silicon level so before the chip is actually available the next one is coming year, we have people who are already developing and we want to show with this platform how pre-silicon can be made. development and continue throughout the product life cycle working on this harvest of a core design burden.

Now, the second thing I want to talk about is a demo we've been showing at the Risk 5 workshop. It's an Ethan poem bridge to an FPGA, this FPGA is firm, ooh, what's the FPGA on your USB port, it's a really small board from Mythril and company, it's essentially a 5k batch of PDA and what we're showing, but we can also show it to you if you want to break out, we have this, it's actually here, you can't see it, but it's inside this and I'll also show you the formal one right now. I see very well, but you need a mirror to see it, so we are joining from Reno to most of the fpga. of the system on the chip is here and only one peripheral controls the cable, the LED flashes.

You have to trust me again. The video you can see when you click this link. We can control this LED from Reno Door from the software. There are many options, but in general this peripheral and this LED do not know that they are being, you know that they are operating, an assistant has been consumed euphorically from a PC for them, it is the same and again we did it and everyone is interested, right ? nxp Scott is great and also to make it even better we really had fun it was a giveaway and I think there should be a lot of interest in this group so basically come to us and tell us what you would like to do like it's formal or maybe . with the forum in Reno and we will give you a 5k bot that FPGA can produce with open tools and yes some of you already have some but I'm sure there is more interest than other developments that have been soft and substantial new FPGA courses . mom chips so we've supported things like the curvy vex era five in a Nerva and some chips like mirror at beacon stark white If you build this strange combination of things on your fpga, it's okay to also try to run this in minimal time and we know that it allows you to mix and match those things that we also have because of the work of In these topics we also had to introduce a couple of things like custom instruction support, a custom CSR, you know, interrupt handling that varies from core to core and we all want all of these things to be as configured as possible so that we can support a variety.

Some of you know Susie's software, so for example for the V selector, which is a fairly non-standard core, it's very small and nice, but it's also not a big risk. Sometimes we had to make this interrupt starless to handle additional reference registers that also work with the interrupts we had to handle the timer in a specific way because it was not remade according to the specifications, which is fine since we want enable these use cases. I think the main citizen of all the soft course that we are enabling is flex with five that can run as part of the light x SOC and the reason is that this is like Zephyr or Artists capable in general, but also compatible with Linux and Linux 32 bits is a pretty good thing to have on an fpga so if things around it in luz x we ​​are modeling the efnet peripheral, the UART, and we were able to build quite complicated configurations. with it and also because of the very literal integration, we can even think about extending this with additional things and potentially then contribute back to light x with new peripherals, so Renault has been instrumental in 32-bit Linux, worse than we've been doing before the summit last year for the hackathon that Western Digital wanted to organize we collaborated to try to build a 32-bit Linux it was very hockey, it was a very fast and hockey experience, but Renault helped us implement very basic Linux and then this work was taken on by Dave chef Laurent America and South Pole and in the end they got it working with mainline Linux, so through this collaboration we came up with something really cool: we now have Linux on vex with five running and one open.

FPGA source um so this kind of is also connecting to the main work like Foundation Research Foundation we are trying to make it visible to everyone and this is the introductory guide to risk five that as you can see we put the lighter vector . 5 things and both can run it on hardware but also on Reno and we are trying to make it as far as possible so that it takes the same binaries that runs it on Reno instead of hardware and it should work the same I know. how over time you delight so I'm not sure how much I can reach minus 5 ok I'll try to be quick it's the latest so don't worry the Dover Microsystems use case we've been working on a lot. and they're really cool because they're developing an IP that's actually protected by an XP, so it's a pretty serious thing and this secure IP that they built and they needed to control the execution of the code very closely and they needed to do a lot of things. of things, so they have the system that tries to protect the CPU, like a policy enforcer, it's very complex, you know, Harus Africa design tasks and they do it with RINO, they did design space exploration and implementation testing, but they also deliver it to customers and their Then customers also work with read to have this flow where they like reno development before doing hardware development and use this feedback loop to improve heart development and In fact, they spent several days or weeks to develop a feature two hours because of that, so they have really been able to improve and they also test hundreds and thousands of tests every day in reno to make sure that their IP is working and they have been working with things like, you know, cache profile testing. bootstrap code building pretty complex systems with video where they used reno to do all the software development before hardware even existed, so they are doing some really amazing things and I think it's good proof that their software teams from hardware suddenly collaborate a lot more closely than they used to and they are very happy yeah so go to github and get Reno it's 1.71 now probably soon point two we have documentation there's always very little so can you help us out and write a little and yes, we usually just want to enable these strange uses. cases you may have, so don't worry, contact us and tell us what you are trying to do and maybe we can tell you that yes, you can actually do this already or that it is not that difficult to do it and we think that actually modular hardware and open source is really helping things like we know because you know we're also a very open framework so these things really go very well together um yeah I think I opened with that so I'll do it. giving it some time to rest hungry and thirsty sounds pretty interesting if my 3rd party wants to add support for a different board, how easy is it, it depends on whether the building blocks are there or not correct, if the building is which server, it should be trivial because you just write scripts to assemble them, if you really need to add peripherals as models then you know there's a learning curve, but we try to make it as easy as possible so that when you're modeling a peripheral you're essentially deploying. a data sheet on the other side, so to speak, you're trying to implement a functional specification that you know, dating an API for the software, we try to make it as simple as possible so that you can inherit, you can inherit from classes that actually exist, we have You know, you want to build a spy peripheral, right, it will fulfill some interfaces for spying, etc. and of course you have to write the functions that we provide for different types of communication, but it should be simple enough that for Normally we write peripherals, you know, a couple of days depending on the complexity.

If it's a radio with thousands of records, of course the experience will be much longer, but that's purely related to the complexity of what you're trying to model. We will meet again in thank you very much.