Wind River Blog: Simics Modeling Video Demo

There is a new post at my Wind River blog, featuring a recently-posted video demo of device and systems modeling with Simics. In this video demo, we show an outline of the modeling flow used with Simics 4.8, using only the Eclipse interface. It is actually quite new that we can do this much modeling from within Eclipse; recent efforts in improving the Simics user experience are starting to pay off. As part of the product design team, it feels good to see how even quite small features can really improve the usability of the product.

It is also my first blog post on the recently renovated Wind River blog network. I like the new look of the corporate blog, even if I will have to go back and adjust some older blog images to account for the change from a dark to a light background.

 

Wind River Blog: Reverse Execution (not Debugging)

There is a new post at my Wind River blog, where I go back to the basics of reverse execution in Simics and what it can do. The post is not about reverse debugging, about which I have written quite a bit (see for example my series of blog posts: 1, 2, 3, 4, 5, 6), but about the core of reverse execution. I.e., moving the system state back in time in a variety of ways. There is an accompanying video  demo on Youtube.

Wind River Blog: Collaborating with Recording Checkpoints

There is a new post at my Wind River blog, about how some new features in Simics 4.8 improve the collaboration power of Simics checkpoints. For the first time, Simics checkpoint can now carry a piece of history (slice of time), which also makes reverse execution and reverse debug work with checkpoints in a logical way.

Continue reading “Wind River Blog: Collaborating with Recording Checkpoints”

Wind River Blog: Simics 4.8 is Here

Simics 4.8 is finally released, and I put up a blog post explaining the most important news in this release. It is two years since we released Simics 4.6, so there is quite a bit of news in Simics 4.8 – even though lots of functionality has been released continuously into 4.6 over the past twenty four months. My personal favorite are the comments you can put on an execution and the stop log,  but then again, that might be because they have been a couple of pet ideas of mine so I am hardly an impartial judge. Everything else is also really good, and the engineering teams and marketing teams involved have put in a lot of effort into this release (as we do in all releases).

 

Wind River Blog: Visuality NQ CIFS Server on Simics

There is a new post at my Wind River blog, about how I ran a Windows file share server (CIFS) on a Simics-simulated VxWorks big-endian Power Architecture target. Something that just should work, given that the software in question is known to work in the real world. But still, pretty cool, and a bit eerie.

 

Wind River Blog: TCF and Simics

On my Wind River blog, you can now find a description on how we have used the Eclipse TCF (target connection framework) to build the Simics GUI. Or rather, the connection between the Simics GUI and the Simics simulation process. It is actually quite revolutionary what you can do with the TCF, compared to older debug protocols. In particular, TCF lets you combine many different services across a single connection.

Continue reading “Wind River Blog: TCF and Simics”

Wind River Blog and Movie: Demo of Simics Debugging

Last year, I did a Simics webinar which included a two-part demo of how to use Simics to debug an endianness bug in a networked system as it migrates from big-endian to a little-endian system. Along the way, I also showed off various Simics features like reverse execution and checkpointing and scripted execution.

The demo is now online at the Wind River Youtube channel, and the setup is explained in a blog post at the Wind River company blog which is worth reading before watching the video.

Wind River Blog: Debugging Simics using Simics

There is a new post at my Wind River blog, telling the story of how some of the Simics developers used Simics itself to debug an intermittent Simics program crash caused by a timing-sensitive race condition.

Running Simics on itself is pretty cool, and shows the power of the simulator and its applicability even to really complex software.

Dragons can be Useful – when AT Models Make Sense

Carbon Design Systems keeps putting out interesting blog posts at a good pace. Bill Neifert at recently put up a blog post about the various of speed/accuracy tradeoffs you can make when building virtual platforms. The main message of the blog is that you should use a mix of fast models (TLM + JIT, like the ARM Fast Models) and cycle-accurate generated-from-RTL models (like the models generated by Carbon’s tools). By switching between the levels of abstraction when you need to go fast or go deep, you get something that is pretty much the best of both worlds (I already blogged about the change between abstraction before). It makes perfect sense, and I am all with him. There are dragons in the middle land.

However, I do not quite agree with Bill about the absolute uselessness of the intermediate types of models, like SystemC TLM-2.0 AT.  Basically, what is traditionally called “cycle accurate modeling” (while not derived from RTL).

Continue reading “Dragons can be Useful – when AT Models Make Sense”

Speaking at Embedded Conference Scandinavia

I am going to be talking about how to transport bugs with virtual platform checkpoints, in the Software Tools track at the Embedded Conference Scandinavia, on October 3, 2012, in Stockholm (Sweden). The ECS is a nice event, and there are several tracks to choose from both on October 2 and October 3. In addition to the tracks, Jan Bosch from Chalmers is going to present a keynote that I am sure will be very entertaining (see my notes from a presentation he did in Göteborg last year).

 

“Eagle” Cycle-Accurate Simulator Anno 1979

I recently read the classic book The Soul of a New Machine by Tracy Kidder. Even though it describes the project to build a machine that was launched more than 30 years ago, the story is still fresh and familiar. Corporate intrigue, managing difficult people, clever engineering, high pressure, all familiar ingredients in computing today just as it was back then. With my interesting in computer history and simulation, I was delighted to actually find a simulator in the story too! It was a cycle-accurate simulator of the design, programmed in 1979.

Continue reading ““Eagle” Cycle-Accurate Simulator Anno 1979″

Youtube Movie on Reverse Execution (and a small bit of Reverse Debug)

We just uploaded a short movie about reverse execution and reverse debugging to Youtube, to the Wind River official channel. In the short time available in this demo, we really only show reverse execution. Reverse debug, as I define it, is not used much at all, as explaining what goes on when you start to put breakpoints into a program and analyze its behavior takes a surprising amount of time.

Continue reading “Youtube Movie on Reverse Execution (and a small bit of Reverse Debug)”

Wind River Blog: Teaching Networking with Simics

On the Wind River corporate blog, I have put up a blog post about how Wind River Education Services is going to use Simics to teach networking. What is interesting with this approach is that it shows how a virtual platform can be used for tasks like teaching that don’t have much to do with hardware modeling or similar “typical” VP uses. In this case, the key value is encapsulation of a set of machines running real operating systems and software stacks, and with lots of networks connecting them.

Wind River Blog: Forcing Rare Bugs to Appear using Simics

There is a new post at my Wind River blog, about how a team of researchers at the University of Nebraska at Lincoln is using Simics to force rare bugs to manifest themselves as errors. They used Simics to control a target system to force it into rare situations much more likely to trigger latent bugs, requiring far fewer test runs compared to just randomly rerunning tests again and again and hoping to see a bug.

Carbon “Swap ‘n’ Play” – A New Implementation of an Old Idea

Carbon Design Systems have been quite busy lately with a flurry of blog posts about various aspects of virtual prototype technology. Mostly good stuff, and I tend to agree with their push that a good approach is to mix fast timing-simplified models with RTL-derived cycle-accurate models. There are exceptions to this, in particular exploratoty architecture and design where AT-style models are needed. Recently, they posted about their new Swap ‘n’ Play technology, which is a old proven idea that has now been reimplemented using ARM fast simulators and Carbon-generated ARM processor models.

Continue reading “Carbon “Swap ‘n’ Play” – A New Implementation of an Old Idea”

Wind River Blog: Code Coverage over a Back Door

There is a new post at my Wind River blog, about how the LDRA code coverage tools have been brought to work on Simics using a simulation-only “back door “.

The most interesting part of this is how a simulator can provide an easy way to get information out of target software, without all the software and driver overhead associated with doing the same on a real target. In this case, all that is needed is a single memory-mapped location that can written to be software – which can be put into user-mode-accessible locations if necessary.

Continue reading “Wind River Blog: Code Coverage over a Back Door”

Wind River Blog: Crystal Forest on Simics

There is a new post at my Wind River blog, about Simics running a model of the new Intel Crystal Forest platform. Crystal Forest is a very complex piece of hardware, but I am pretty happy that we managed to demo it in an understandable way – by essentially using it as a black box and putting a pretty display on top of that (using Eclipse).

 

EETimes Articles on Simics

I just had two articles published the Embedded Design part of the EETimes.

First, “Rethink your project planning with a virtual platform“, which talks about how virtual platforms can change your entire project planning. Essentially, by reducing project friction and risks related to hardware availability, software integration, and show-stopper bugs, you can make projects work much better.

Then we have “Transporting bugs with virtual checkpoints“, which is a shorter, popular science, version of the paper I published last year at S4D. This describes how you can use checkpointing in a virtual platform to communicate bugs across time, space, and teams.

Wind River Blog: Stop, Think, and Tie Your Shoes Right

There is a new post at my Wind River blog, which could seem to be about shoes but which is really about process improvement. In particular, the need for companies to let their employees take a step or two back and look at what they are doing and what they could do better.

It is way too common to be so busy running around being inefficient that there is no time to think about how to become more efficient. Change also requires some discipline to actually keep pushing at habits until they change for the better.

All of this can be illustrated by tying shoes.

Wind River Blog: How to Get Virtual

There is a new post at my Wind River blog, about how you build virtual platforms with Simics. The post is more about the methodology than the nature of models, cycle accuracy, endianness, and all the other details of virtual platform modeling. I have written about modeling methodology on this blog too, and in particular I would recommend looking at “Two perspectives on modeling“.

Disappointing SystemC Debugger Integration Paper

Since I have a certain interest in debugging, I was happy find the article “Guidelines for SystemC – Debugger Integration” at the usually interesting Design and Reuse website. However, I must say that it was pretty disappointing.

Continue reading “Disappointing SystemC Debugger Integration Paper”

Wind River Blog: VxWorks 64-bit using Simics

There is a new post at my Wind River blog, about how Simics was used to kick-start the development of the 64-bit version of VxWorks. It is an interesting example of how to use a virtual platform as a model of something much simpler and gentler than actual hardware systems.

EETimes: James Aldis on Performance Modeling

James Aldis of TI has published an article in the EEtimes about how Texas Instruments uses SystemC in the modeling of their OMAP2 platform. SystemC is used for early architecture modeling and performance analysis, but not really for a virtual platform that can actually run software. The article offers a good insight into the virtual platform use of hardware designers, which is significantly different from the virtual platform use of software designers.
Continue reading “EETimes: James Aldis on Performance Modeling”

Interrupts and Temporal Decoupling

I am just finishing off reading the chapters of the Processor and System-on-Chip Simulation book (where I was part of contributing a chapter), and just read through the chapter about the Tensilica instruction-set simulator (ISS) solutions written by Grant Martin, Nenad Nedeljkovic and David Heine. They have a slightly different architecture from most other ISS solutions, since that they have an inherently variable target in the configurable and extensible Tensilica cores. However, the more interesting part of the chapter was the discussion on system modeling beyond the core. In particular, how they deal with interrupts to the core in the context of a temporally decoupled simulation.

Continue reading “Interrupts and Temporal Decoupling”

Evaluating HAVEGE Randomness

I previously blogged about the HAVEGE algorithm that is billed as extracting randomness from microarchitectural variations in modern processors. Since it was supposed to rely on hardware timing variations, I wondered what would happen if I ran it on Simics that does not model the processor pipeline, caches, and branch predictor. Wouldn’t that make the randomness of HAVEGE go away?

Continue reading “Evaluating HAVEGE Randomness”

Wind River Blog: Being Helpful or Being Correct?

There is a new post at my Wind River blog, about warnings in virtual platforms. It is an art to add good warnings to virtual platform models, and just being correct visavi the hardware behavior is not necessarily that helpful for a software developer. A virtual platform should warn about suspicious operations, even if they are technically “correct”.

I also have to apologize for the slow blogging in January of 2011. There was too much going on at work and quite a few days taking care of sick kids. Hopefully, the pace can improve going forward.