• About Jakob Engblom and this blog
Observations from Uppsala Computer Simulation, Virtual Platforms, Embedded Programming, Multicore and More (by Jakob Engblom)

Tag Archives: Simics

Wind River Blog: Starting & Configuring Simics

2013 June 15 08:28 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about how Simics sessions are started and the mechanics of system setups in Simics. It also has a link to a Youtube video demonstrating various ways of starting Simics simulation sessions.

Read More →

Tweet
Posted in: programming, virtual machines, Wind River Blog / Tagged: Simics, video

Wind River Blog:

2013 June 7 05:09 / Leave a Comment / Jakob

There is a new post at my Wind River blog, with a video demo of the new Simics 4.8 System Editor function. Posts are coming out quite quickly now, with various aspects of Simics and in particular Simics 4.8 being highlighted. This particular feature is probably the biggest news in Simics 4.8 from a user interface perspective, as it allows you to (finally) inspect a target setup in a nice graphical tree view.

Tweet
Posted in: Wind River Blog / Tagged: eclipse, Simics, Simics 4.8

Nudge Theory and Graphical User Interfaces

2013 May 30 21:27 / Leave a Comment / Jakob

Nudge theory is an intriguing fairly new take on how to manage societies and modulate the behavior of people to make them behave in a “better” way. My layman’s interpretation of the idea is that instead of threating punishment and setting up rules, you try to encourage desired behavior with rewards and discourage undesired behavior by making it require an effort. When working with the new Test Runner view in the Simics 4.8 GUI, I realized that we had invented exactly such a nudge.

Read More →

Tweet
Posted in: programming / Tagged: BBC, nudge theory, Simics, Simics 4.8

Wind River Blog: Collaborating with Recording Checkpoints

2013 May 30 09:54 / Leave a Comment / Jakob

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.

Read More →

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: Checkpointing, reverse debug, reverse execution, Simics, Simics 4.8

Wind River Blog: Simics 4.8 is Here

2013 May 21 19:05 / Leave a Comment / Jakob

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).

 

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: 4.8, Simics

Wind River Blog: Visuality NQ CIFS Server on Simics

2013 April 23 11:05 / Leave a Comment / Jakob

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.

 

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: Simics, Visuality NQ, Windows

Wind River Blog: TCF and Simics

2013 March 26 11:00 / Leave a Comment / Jakob

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.

Read More →

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: debugging, reverse debugging, Simics, TCF

Wind River Blog and Movie: Demo of Simics Debugging

2013 January 9 22:40 / 5 Comments / Jakob

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.

Tweet
Posted in: programming, virtual platforms, Wind River Blog / Tagged: debugging, demo, endianness, networking, reverse debugging, Simics, video

Wind River Blog: Debugging Simics using Simics

2012 December 6 13:04 / 2 Comments / Jakob

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.

Tweet
Posted in: multicore debug, programming, virtual platforms / Tagged: Debug, race condition, reverse debugging, Simics

Wind River Blog: Simics and Flying Piggies

2012 November 28 11:59 / Leave a Comment / Jakob

I just added a new blog post at the Wind River blog, about determinism and illustrating Simics-style determinism is by looking at the game Bad Piggies. Games and simulators have quite a lot in common, actually.

Read More →

Tweet
Posted in: computer games, off-topic, virtual machines, Wind River Blog / Tagged: Bad Piggies, determinism, Rovio, Simics, variability

Wind River Blog: Exposing OS Kernel Races with Landslide

2012 September 26 21:18 / Leave a Comment / Jakob

There is a new blog post on my Wind River blog, about the Landslide system from CMU. It is a pretty impressive Master’s Thesis project that used the control that Simics has over interrupts to systematically try different OS kernel thread interleavings to find concurrency bugs. The blog is an interview with Ben Blum, the student who did the work. Ben is now a PhD student, and I bet that he will continue to generate cool stuff in the future.

Tweet
Posted in: parallel computing, programming, Wind River Blog / Tagged: Ben Blum, debugging, Landslide, operating systems, Simics

Speaking at Embedded Conference Scandinavia

2012 August 29 12:58 / Leave a Comment / Jakob

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).

 

Tweet
Posted in: appearances, embedded software, embedded systeme, programming, virtual platforms / Tagged: bug, bug transportation, debugging, Simics

Wind River Blog: Testing Multicore Scaling with a Simics QSP

2012 August 27 21:39 / Leave a Comment / Jakob

A few years ago, I built a demo on Simics that used a hacked Freescale MPC8641D target that was forced to scale from 1 to 8 cores. Some interesting experiements could be made using this target, and it was nicely scalable for its time. However, I always wanted to have something just a bit bigger. Say 20 cores, or 100. Just to see what would happen. Finally, I got it.

The Simics QSP target that we quietly launched earlier this Summer is such a scalable target. As discussed in a blog post describing the architecture, it is designed to scale to 128 cores currently. Using this ability, I repeated my old experiments, but trying very large threads counts and target core counts. The results show clearly that the way that I coded my parallel computation program was pretty bad, and I really would like to try to rewrite it using some more modern threading library. All I need is time and a way to cross-compile Wool…

Anyway, the new blog post is here.

Tweet
Posted in: multicore software, virtual machines, Wind River Blog / Tagged: multicore, QSP, Simics

Wind River Blog: Inside the Simics QSP – Additional Notes

2012 July 6 20:11 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about the design and technical contents of the new Simics Quick Start Platforms, more widely known as the QSP. The blog describes the virtual-only hardware that forms part of the QSP, and how it was designed. It is interesting to note that the hardware ended up a bit more complex that I initially thought it would be, since an ideal virtual platform should be very simple. Right? Turns out an OS complicates things.

Read More →

Tweet
Posted in: virtual machines, Wind River Blog / Tagged: Android, Carbon, CPAK, QSP, Simics

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

2012 June 27 21:04 / Leave a Comment / Jakob

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.

Read More →

Tweet
Posted in: appearances, embedded software, virtual platforms / Tagged: Blue Mic, reverse debugging, reverse execution, Simics, video

Wind River Blog: Teaching Networking with Simics

2012 May 28 21:19 / 1 Comment / Jakob

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.

Tweet
Posted in: teaching, virtual platforms, Wind River Blog / Tagged: networking, Simics

Wind River Blog: Forcing Rare Bugs to Appear using Simics

2012 May 3 10:59 / Leave a Comment / Jakob

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.

Tweet
Posted in: testing, virtual platforms, Wind River Blog / Tagged: Simics, University of Nebraska at Lincoln

Wind River Blog: 80186 and 8051

2012 March 19 13:13 / 1 Comment / Jakob

Wind River recently added a couple of new processor models to Simics: the 30-year-old 80186 and the 32-year-old 8051.

I have a blog post about this up on the Wind River tools blog. Pretty amazing to see us model an eight bit machine in 2012 – just proves how long-lived some hardware systems are.

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: 80186, 8051, Simics, x86

Wind River Blog: Crystal Forest on Simics

2012 March 12 12:08 / Leave a Comment / Jakob

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).

 

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: Crystal Forest, Intel, Simics

Wind River Blog: Fault Injection with Simics

2012 January 23 22:57 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about how you actually do fault injection in Simics. This particular post is pretty detailed, showing the actual architecture of a fault injector in Simics, not just “yes you can do it”. It includes actual diagrams of system components and how you can insert fault injection into an existing system, so it is a bit more technical than most my Wind River blog posts that tend to be more conceptual.

Tweet
Posted in: testing, Wind River Blog / Tagged: fault injection, Simics

Reverse History Part Three – Products

2012 January 8 21:51 / 4 Comments / Jakob

In this final part of my series on the history of reverse debugging I will look at the products that launched around the mid-2000s and that finally made reverse debugging available in a commercially packaged product and not just research prototypes. Part one of this series provided a background on the technology and part two discussed various research papers on the topic going back to the early 1970s. The first commercial product featuring reverse debugging was launched in 2003, and then there have been a steady trickle of new products up until today.

Post updated 2012-09-28 with a revised history.

Read More →

Tweet
Posted in: history of computing, programming / Tagged: debugging, gdb, Green Hills, Lauterbach, Multi, reverse debugging, reverse execution, Simics, TotalView, UndoDB, VMWare

Wind River Blog: Interview with a Networked Simics User

2011 November 16 17:58 / Leave a Comment / Jakob

There is a new post at my Wind River blog, an interview with Dan Poirot at RTI who is using Simics to model and test heterogeneous, distributed, networked systems.

Tweet
Posted in: testing, virtual platforms, Wind River Blog / Tagged: Dan Poirot, RTI, Simics

EETimes Articles on Simics

2011 September 23 21:26 / Leave a Comment / Jakob

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.

Tweet
Posted in: articles, programming, virtual platforms / Tagged: EETimes, Simics

Wind River Blog: A Virtual Year

2011 August 20 09:25 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about hypersimulation in virtual platforms and how it lets virtual time fly much faster than real time. It was the result of simple mistake of leaving Simics running in the background as I did other work on  my machine.

Tweet
Posted in: computer simulation technology, virtual platforms, Wind River Blog / Tagged: hypersimulation, Simics

Wind River Blog: How to Get Virtual

2011 August 2 14:10 / Leave a Comment / Jakob

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“.

Tweet
Posted in: computer simulation technology, programming, virtual platforms, Wind River Blog / Tagged: development methodology, Functional models, Modeling, Simics

Wind River Blog: Simics 4.6 Initial Impressions

2011 May 31 14:35 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about the new Simics 4.6 release. 4.6 has some serious new goodies in it, including an Eclipse source-code debugger and a way to build blinking lights front panels for boards.

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: eclipse, Simics, Simics 4.6

Wind River Blog: 20, 30, 60 years ago

2011 May 6 14:27 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about some computing history. Wind River turns thirty this year, Simics twenty, and simulation for debug (and probably debug in general) turns sixty. Computing has come a long way.

Tweet
Posted in: computer simulation technology, history of computing, Wind River Blog / Tagged: debugging, Simics, Wind River

Wind River Blog: VxWorks 64-bit using Simics

2011 March 25 21:52 / Leave a Comment / Jakob

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.

Tweet
Posted in: embedded software, embedded systeme, virtual platforms, Wind River Blog / Tagged: 64-bit, Simics, VxWorks

Wind River Blog: “IMA on Simics”

2010 October 26 15:00 / Leave a Comment / Jakob

I have a fairly lengthy new blog post at my Wind River blog. This time, I interview Tennessee Carmel-Veilleux, a Canadian MSc student who have done some very smart things with Simics. His research is in IMA, Integrated Modular Avionics, and how to make that work on multicore.

Read More →

Tweet
Posted in: computer simulation technology, embedded software, embedded systeme, multicore software, programming, Wind River Blog / Tagged: Integrated Modular Avionics, real-time, Simics, Tennessee Carmel-Veilleux, wcet

Wind River Blog: “Virtual Basil Fawlty”

2010 October 20 08:59 / Leave a Comment / Jakob

Last week, I posted a discussion about fault injection in virtual systems, using Basil Fawlty as the perfect example of a fault injection agent.

Tweet
Posted in: virtual platforms, Wind River Blog / Tagged: Basil Fawlty, fault injection, Simics, Wind River

Post Navigation

1 2 Next »

Recent Posts

  • Military Science Fiction – The Books Blur Together
  • Wind River Blog: Starting & Configuring Simics
  • Wind River Blog:
  • Nudge Theory and Graphical User Interfaces
  • Wind River Blog: Collaborating with Recording Checkpoints
  • Wind River Blog: Simics 4.8 is Here
  • A Few Electrons too Many
  • Wind River Blog: Visuality NQ CIFS Server on Simics
  • Everything in the Cloud?
  • Wind River Blog: TCF and Simics
  • Off-Topic: Moving Bad Piggies Save Games
  • Two Cores, Four Cores, Eight Cores – Mobile Variety
  • Bliss: Failing to Pivot for Ideology
  • Wind River Blog and Movie: Demo of Simics Debugging
  • Simulation vs Reality in Schlock Mercenary

Categories

  • appearances (30)
  • articles (21)
  • blogging (10)
  • books (7)
  • business issues (31)
  • computer architecture (35)
  • conferences (34)
  • EDA (50)
    • ESL (35)
  • embedded (78)
    • embedded software (57)
    • embedded systeme (50)
  • general research (6)
  • history (32)
    • general history (7)
    • history of computing (26)
  • off-topic (94)
    • biking (5)
    • board games (1)
    • computer games (3)
    • desktop software (35)
    • food and drink (1)
    • funny (12)
    • gadgets (24)
    • Politics (3)
    • popular culture (5)
    • trains (5)
    • transportation (10)
    • travel (10)
    • websites (3)
  • parallel computing (92)
    • multicore computer architecture (51)
    • multicore debug (22)
    • multicore software (65)
  • programming (109)
  • review (8)
  • security (19)
  • teaching (7)
  • testing (9)
  • uncategorized (12)
  • virtual things (131)
    • computer simulation technology (68)
    • virtual machines (18)
    • virtual platforms (99)
    • virtualization (14)
  • Wind River Blog (43)

Tags

ARM blog commentary Cadence Checkpointing clock-cycle models Communications of the ACM computer architecture conference cycle accuracy debugging Domain-specific languages eclipse embedded freescale G900 heterogeneous homogeneous IBM Intel iPod lego linux mobile phones multicore off-topic office 2007 operating systems p4080 podcast commentary power architecture rant research reverse debugging reverse execution S4D SiCS Multicore days Simics simulation software tools Sun SystemC video virtualization Vista Windows

1

  • F-Secure Blog

Blogs and news

  • Andras Vajda's blog (on multicore)
  • Embedded in Academia (John Regehr)
  • Grant Martin
  • Jack Ganssle
  • My Wind River Blog
  • Security Now podcast
  • Secworks (Joachim Strömbergson)
  • Simon Kågström
  • Synopsys View from the Top
  • Worse Than Failure

Archives

  • June 2013 (3)
  • May 2013 (4)
  • April 2013 (1)
  • March 2013 (4)
  • February 2013 (1)
  • January 2013 (3)
  • December 2012 (2)
  • November 2012 (2)
  • October 2012 (1)
  • September 2012 (6)
  • August 2012 (4)
  • July 2012 (4)
  • June 2012 (3)
  • May 2012 (4)
  • April 2012 (2)
  • March 2012 (3)
  • February 2012 (1)
  • January 2012 (6)
  • December 2011 (2)
  • November 2011 (3)
  • October 2011 (4)
  • September 2011 (5)
  • August 2011 (4)
  • July 2011 (3)
  • June 2011 (4)
  • May 2011 (7)
  • April 2011 (1)
  • March 2011 (3)
  • February 2011 (5)
  • January 2011 (1)
  • December 2010 (4)
  • November 2010 (3)
  • October 2010 (5)
  • September 2010 (5)
  • August 2010 (5)
  • July 2010 (6)
  • June 2010 (5)
  • May 2010 (3)
  • April 2010 (4)
  • March 2010 (3)
  • February 2010 (4)
  • January 2010 (7)
  • December 2009 (6)
  • November 2009 (6)
  • October 2009 (7)
  • September 2009 (6)
  • August 2009 (7)
  • July 2009 (11)
  • June 2009 (5)
  • May 2009 (10)
  • April 2009 (7)
  • March 2009 (8)
  • February 2009 (9)
  • January 2009 (12)
  • December 2008 (8)
  • November 2008 (9)
  • October 2008 (9)
  • September 2008 (10)
  • August 2008 (13)
  • July 2008 (12)
  • June 2008 (8)
  • May 2008 (9)
  • April 2008 (10)
  • March 2008 (7)
  • February 2008 (8)
  • January 2008 (5)
  • December 2007 (5)
  • November 2007 (7)
  • October 2007 (7)
  • September 2007 (12)
  • August 2007 (9)
  • July 2007 (2)
© Copyright 2013 - Observations from Uppsala
Infinity Theme by DesignCoral / WordPress