Jakob Engblom

How Simics Gets Started (with video)

Having worked with Simics for more than a decade, it is easy to get blind to the obvious. To me, starting a Simics simulation is a trivial thing that I do many times per day. However, to a newcomer to the product, it is not so obvious, and it might even seem a bit daunting. It is not daunting, and it is not difficult, as shown in this video on YouTube.

As can be seen in the video, we start Simics sessions by invoking a target setup script or opening a checkpoint. This can be done from Eclipse, from a command-line, or from the old Simics stand-alone GUI. Whether on Windows or Linux host, the same options are available. No matter how you do it, the end result is the same. The same Simics engine is used in all cases, interpreting the startup script in the same way.

Inspecting and Reconfiguring a Target in Simics 4.8

As we said in the first blog post on Simics 4.8, a really big new feature is the System Editor function. The system editor combines two functions into a single view, both the exploration of an existing target as well as the modification and even construction of a new target from existing pieces. A demo video is available on the Wind River channel on Youtube, and read on for more information on how it works.

Collborating using Simics Recording Checkpoints

One of the main themes of the Simics 4.8 release is the use of Simics to collaborate between team members, teams, and organizations. To facilitate this, Simics checkpoints have been extended with significant new metadata capabilities as well as the ability to record a simulation session and communicate the recording as part of a checkpoint. Checkpointing can really transform how developers and testers and users communicate issues in their systems, and the new checkpointing features and metadata makes the mechanism even more powerful. We have a video up on YouTubedemonstrating this Simics feature. 

Simics 4.8 is Here

Simics 4.8 is now generally available for old and new users to enjoy. I will be doing a series of blog posts going into the details on what is new and improved in this release. Simics 4.8 represents a significant improvement in the Simics user interface and collaboration features, as well as tweaks to the simulator performance, debugger, and modeling workflow, so there  is quite a bit to talk about. We start off with an overview of the news.

Serving Windows Files from a Simics Quick-Start Platform

Windows file sharing has always felt a bit magical to me. I use it all the time, certainly, but I never quite understood how it worked; it was just this big chunk of Microsoft protocol that felt like it really did not want to talk to other types of operating systems. Sure, I have used the open-source "samba" server for a long time with great success… but it always seemed to suffer from issues with access rights (probably the fault of me and server setup and mixing Unix and Windows accounts, not a fault in the server itself).

With this background, I was really delighted and surprised when I managed to almost effortlessly get a Simics target to share and serve files to my Windows host. A big-endian Power Architecture QSP target at that, running VxWorks, how cool isn’t that? The key to the puzzle was the Visuality NQ Server  from Visuality Systems Ltd. in Israel. It just worked, and let me try some interesting and educational setups.

Debug Quicker with Simics (video)

Late last year, I presented a one-hour webinar on how Simics lets you “resolve bugs in minutes instead of weeks.” Part of that webinar were two Simics demos that show Simics in action, from the first booting of a target system through loading software onto it and debugging a nasty crash in a server program. The webinar demos are now available as a single Youtube movie, on the Wind River Youtube channel.

Debugging Simics - on Simics

I often write and talk about how useful Simics is for debugging concurrency bugs and glitches in multithreaded and multicore systems. Recently, we had a case where we proved this on a very complex application, namely Simics itself. This nicely demonstrated both the recursive completeness of Simics, and its usefulness for conquering tricky bugs in complex software.

Determinism, Simics, and Flying Piggies

In a recent Simics seminar, I was asked about repeatability, variability, determinism and Simics. This is a question that comes up almost every time I present about Simics in front of an audience with testing experience. The people asking the question intuitively think that determinism is a bad thing - since it sounds like it will limit the execution scenarios that will be explored in testing. For a tester, variation is a good thing. However, determinism is not in conflict with variation. And I think I found a perfect illustration of this in a setting that is a bit more accessible and easy to understand than computer simulators. In a computer game, Bad Piggies, from Rovio.  

Systematically Exposing OS Kernel Races – An Interview with Ben Blum

Full-system simulators like Simics provide unparalleled insight into what is going on in a target system. Indeed, better insight is one of the main features of simulation that we get regardless of what we simulate and how. In addition, if we want to, we can also exert control over the target system to make it take different execution paths than it otherwise would. Earlier this year, Ben Blum at Carnegie-Mellon University  CMU presented a Master’s thesis that provides a very good example of just what can be achieved by combing the insight and control of a simulator with intelligence and domain knowledge. The system is called Landslide, and it is used to expose race conditions inside of operating-system kernels.

Analyzing Manycore Scaling with Simics

In my previous blog post on multicore scaling investigations with Simics, I tested a simple parallel program on a variety of machines. The scaling obtained was not particularly impressive, especially not on a 60-core target machine. In this post, we will use the Simics timeline view to look a bit closer at what is going on inside the target machines. In particular, with respect to operating system scheduling of the target threads.