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

Category Archives: Embedded

Embedded anything, software, hardware, tools.

A Few Electrons too Many

2013 May 9 22:16 / 2 Comments / Jakob

Adding electronics to systems that used to be mechanical has been the great wave of innovation for a quite a while now. Modern transportation just would not work without all the electronics and computers inside (someone once quipped that a modern fighter is just a plastic airplane full of software), and so much convenience has been provided by automation and smarts driven by electronics. However, this also introduces brand new ways that things can break, and sometimes I wonder if we really are not setting ourselves up for major problems when the electrons stop flowing.

Read More →

Tweet
Posted in: embedded systeme, trains, transportation

Logging (Some More Thoughts)

2012 October 28 23:38 / 1 Comment / Jakob

Logging as as debug method is not new, and I have been writing about it to and from over the past few years myself.  At the S4D conference, tracing and logging keeps coming up as a topic (see my reports from 2009, 2010  and 2012 ).  I recently found an interesting piece on logging from the IT world in the ACM Queue (“Advances and Challenges in Log Analysis“, Adam Oliner, ACM Queue December 2011).  Here, I want to address some of my current thoughts on the topic.

Read More →

Tweet
Posted in: embedded software, embedded systeme, programming / Tagged: ACM Queue, Adam Oliner, debugging, logging, tracing

Reverse Execution History Updates

2012 September 29 21:33 / Leave a Comment / Jakob

After some discussions at the S4D conference last week, I have some additional updates to the history and technologies of reverse execution. I have found one new commercial product at a much earlier point in time, and an interesting note on memory consistency.

Read More →

Tweet
Posted in: embedded systeme, history of computing, programming / Tagged: CTS, Lauterbach, reverse debugging, reverse execution

S4D 2012 – Notes

2012 September 24 22:11 / 2 Comments / Jakob

Last week, I attended my fourth System, Software, SoC and Silicon Degug conference (S4D) in a row. I think the silicon part is getting less attention these days, most of the papers were on how to debug software. Often with the help of hardware, and with an angle to how software runs in SoCs and systems. I presented a paper reviewing the technology and history of reverse debugging, which went down pretty well.

Read More →

Tweet
Posted in: appearances, articles, conferences, EDA, embedded software, embedded systeme / Tagged: debugging, Hardware debug support, S4D, software

SiCS Multicore Day 2012

2012 September 16 22:12 / 4 Comments / Jakob

The 2012 edition of the SiCS Multicore Day was fun, like they have always been in the past. I missed it in 2010 and 2011, but could make it back this year. It was interesting to see that the points where keynote speakers disagreed was similar to previous years, albeit with some new twists. There was also a trend in architecture, moving crypto operations into the core processor ISA, that indicates another angle on the hardware accelerator space.

Read More →

Tweet
Posted in: computer architecture, conferences, embedded software, multicore computer architecture, multicore debug, multicore software, parallel computing, programming / Tagged: Erik Hagersten, heterogeneous, homogeneous, James Larus, Rich Hetherington, SiCS Multicore days, Stephen Hill

Paper & Talk at S4D 2012: Reverse Debug

2012 September 10 11:03 / Leave a Comment / Jakob

I am going to the S4D conference for the third year in a row. This year, I have a paper on reverse debugging, reviewing the technology, products, and history of the idea. I will probably write a longer blog post after the conference, interesting things tend to come up.

Tweet
Posted in: appearances, articles, conferences, embedded systeme, programming / Tagged: reverse debugging, reverse execution, S4D

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

Speaking at SiCS Multicore Day 2012

2012 August 16 11:43 / Leave a Comment / Jakob

I am scheduled to talk at the SiCS multicore day 2012 (like I did back in 2009 and 2008). The event takes palce on September 13, at SiCS in Kista. My topic will be on System-Level Debug – how we can make debuggers that work for big systems.

This year, the multicore day is part of a bigger Software Week event, which also covers cloud and internet of things. See you there!

Tweet
Posted in: appearances, embedded systeme, programming / Tagged: debugging, SiCS Multicore days, system-level debug

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

Back to Bare Metal

2012 March 30 22:10 / 1 Comment / Jakob

Once upon a time, all programming was bare metal programming. You coded to the processor core, you took care of memory, and no operating system got in your way. Over time, as computer programmers, users, and designers got more sophisticated and as more clock cycles and memory bytes became available, more and more layers were added between the programmer and the computer. However, I have recently spotted what might seem like a trend away from ever-thicker software stacks, in the interest of performance and, in particular, latency.

Read More →

Tweet
Posted in: computer architecture, embedded software, multicore software, programming / Tagged: Communications of the ACM, ethernet, Luigi Rizzo, NetMap, networking

Keynote on System-Level Debug

2012 January 1 22:12 / 2 Comments / Jakob

I have now posted the slides from my keynote talk at the S4D 2011 conference to the presentations list on my regular home page. The topic of that talk was “System-Level Debug”, something which has started to interest me in recent years.

Read More →

Tweet
Posted in: appearances, conferences, embedded software, embedded systeme, programming

My Bug Doesn’t Work!

2011 September 14 05:27 / 7 Comments / Jakob

Every once in a while I need to build demo setups to show debugging in action. As I have blogged before, finding a good bug when you need one isn’t always easy.  The solution is to try to invent artificial bugs, and I was very happy when I managed to stage a buffer overrun in a VxWorks program.

It is pretty very nice demo in which you first start a period program A, which prints the value of an incrementing counter every target second.  You then run a supposedly unrelated program B, resulting in the values that program A prints to become corrupted.  Perfect to show off reverse execution and data breakpoints in reverse as you go from the point where the corrupted value is printed to the piece of code that overwrote the variable.

But then I ported the demo to a new platform… and the bug didn’t work anymore. My bug had caught a bug and was now not working, or at least not they way I expected it to. What had happened?
Read More →

Tweet
Posted in: embedded software, programming / Tagged: bugs, compilers, demo, VxWorks

Software is Concrete – is it?

2011 May 7 22:13 / 1 Comment / Jakob

I this quote:

Software is Concrete. Once poured it becomes extremely difficult and very expensive to change.

It comes from a blog post by Robert Howe, CEO of Verum, a company selling formal-methods-based and model-based programming tools. It does capture something of the phenomenon we all know: that software can be pretty darn hard to change, once it has shipped and is in use. It fits well with the fact that the later bugs are found, the more expensive they are to fix.

But it also provoked quite a bit of opposition when I put the quote up on Facebook, and I have to agree that maybe not all is as simple as that blog makes it out to be.

Read More →

Tweet
Posted in: embedded software, programming / Tagged: Robert Howe, verum

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: Testing Integrated Software in Simulation

2011 March 13 22:36 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about the testing on an integrated software stack in simulation. I base the discussion on the very interesting report about the Toyota “unintended acceleration” problems and the deep investigation into the control software of the affected vehicles performed by a NASA team (!). The report covers a lot of different tools, but also notes that about the only thing not done was to integrate the complete software stack in simulation.

Tweet
Posted in: computer simulation technology, embedded software, embedded systeme, Wind River Blog / Tagged: control software, NASA, Toyota

Wind River Blog: Working Smarter, not Harder

2011 February 24 15:16 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about how you can use a virtual platform to complete work faster. Not by making the virtual platform execution of target code faster, but by optimizing the way you work and taking advantage of the features of a virtual platform.

Tweet
Posted in: embedded systeme, testing, virtual machines, Wind River Blog

Wind River Blog: Being Helpful or Being Correct?

2011 February 11 10:12 / Leave a Comment / Jakob

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.

Tweet
Posted in: embedded software, programming, virtual platforms, Wind River Blog

Wind River Blog: Iterative Hardware-Software Interface Design

2010 December 22 21:00 / Leave a Comment / Jakob

There is a new post at my Wind River blog, about iterative hardware-software interface design. It is a discussion with some examples of why hardware designers would do well to use virtual platforms to include software designers in the loop when designing new devices and their programming interfaces.

Tweet
Posted in: embedded software, embedded systeme, programming, Wind River Blog

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

Interesting Blog: “Embedded in Academia”

2010 October 14 11:50 / Leave a Comment / Jakob

I  just found the blog of an old real-time researcher friend of mine, John Regehr at the University of Utah.

It is at http://blog.regehr.org/ and covers a range of embedded topics relevant to his academic research (which is more embedded that most).

Tweet
Posted in: blogging, embedded systeme / Tagged: John Regehr

S4D 2010 Part 2

2010 September 19 21:10 / 4 Comments / Jakob

My previous post on S4D did omit some of my notes from the conference. In particular, the very entertaining and serious keynote of Barry Lock from Lauterbach and some more philosophical observations on the nature of debugging.

Read More →

Tweet
Posted in: EDA, embedded, embedded software, embedded systeme, programming / Tagged: Barry Lock, debugging, Lauterbach, S4D

Wind River Blog: Shiny Old Hardware

2010 August 20 12:10 / Leave a Comment / Jakob

I just posted a blog post called “Shiny Old Hardware” at my Wind River blog. In it, I discuss why modeling old computer hardware to build virtual systems make sense. Virtual platforms are just not all about the next-generation stuff.

Tweet
Posted in: embedded systeme, virtual platforms, Wind River Blog

Worm Attacking Industrial Control Systems

2010 July 21 20:18 / 2 Comments / Jakob

There is a very interesting worm going around the world right now which is specifically targeting industrial control systems. According to Business Week, the worm is targeting a Siemens plant control system, probably with the intent to steal production secrets and maybe even information useful to create counterfeit products. This is the first instance I have seen of malware targeting the area of embedded systems. However, the actual systems targeted are not really embedded systems, but rather regular PCs running supervision and control software.

Read More →

Tweet
Posted in: embedded software, embedded systeme, security / Tagged: SCADA, Siemens, USB, Windows, worm

Poking Holes in Products

2010 June 14 10:42 / 3 Comments / Jakob

I recently started using a new mobile phone, a Blackberry Bold 9700. I am a bit ambivalent on some of its design features, but it is certainly a very different device from the much more friendly SonyEricsson I had before. Like anybody would do, I have been playing around with it to see what it can do and what not (notable things not working: the “AppWorld” application store is not available in Sweden, YouTube videos do not play in any way that I can figure out).

And almost inevitably, as you play around with a complex modern piece of software (which is what most of the phone is, after all), you find some obvious things which are just plain broken. You wonder, “why didn’t they think of this”, and “how could this ever escape testing?” My current best example is that the built-in web browser does not render the pages from Blackberry’s own support knowledgebase.

Read More →

Tweet
Posted in: embedded software, embedded systeme, programming, testing / Tagged: Blackberry, bug, software testing

More Kindgarten Robot Videos Online

2010 June 6 08:57 / Leave a Comment / Jakob

I have now torn down the Kindergarten Robot, as I wanted to build some other things. However, before tearing it down, I did take a few more movies of its critical functions.

Read More →

Tweet
Posted in: embedded systeme, programming / Tagged: Kindergarten, lego, MEPROM, Mindstorms

Wind River Blog: Simics Analyzer

2010 May 26 20:40 / Leave a Comment / Jakob

I have a new blog post up at the Wind River blog network, about the new target analysis tools in Simics 4.4. It is a very fun piece of technology to play with, and you learn a lot just by poking around at existing software systems…

Tweet
Posted in: embedded software, multicore debug, virtual platforms, Wind River Blog

Kindergarten Robot 3: Programming is Kid’s Play

2010 March 9 17:40 / Leave a Comment / Jakob

Today I finally got to try my MEPROM-equipped Lego Mindstorms robot with a larger group of kids. As expected, this did not go quite as expected.

Read More →

Tweet
Posted in: embedded systeme, programming, teaching / Tagged: Kindergarten, lego, MEPROM, Mindstorms

Kindergarten Robot 2: Going Programmable

2010 February 21 21:32 / 5 Comments / Jakob

lego mindstorms nxt2

As discussed in my previous blog post about Kindergarten robots, I wanted to see if I can teach kids the core idea of programming. This project has now progressed to the point that I have a working prototype of a programmable robot.

Essentially, the robot is programmed by putting colored Lego bricks in a sequence on top of the robot. This should be accessible and direct enough to work with kids — and with no computer needed, just direct physical interaction with the system. For some reason, I think the extra level of abstraction from a screen to a robot is just an unnecessary obstacle at this level.

Read More →

Tweet
Posted in: embedded systeme, programming, teaching / Tagged: Kindergarten, lego, MEPROM, Mindstorms

Kindergarten Robot

2010 February 9 21:16 / 3 Comments / Jakob

lego mindstorms nxt2One of my little projects while on parental leave has been to play around with my Lego Mindstorms NXT 2.0 robotics kit. Apart from being fun for a serious dad like myself, I always had in mind how I could use it with kids to get them interested in technology.

When I was a PhD student in Uppsala back around 2000, we bought a pile of the Lego Mindstorms RCX kits, for use in real-time courses. Obviously, the students loved the opportunity to play with Lego (including the few females). What was less obvious and much more interesting was what happened when we brought in a bunch of children from a local kindergarten to visit — they really took a liking to our little yellow robots running around a classroom. They treated the robots as little animals, wondering what they were doing and why…

With that in mind, I decided to try to reprise this myself with my own son and his kindergarten friends. Last week, I took my robot kit with me and went to meet the kids.

Read More →

Tweet
Posted in: appearances, embedded systeme, teaching / Tagged: lego, Mindstorms

Neat Register Design to Avoid Races

2010 January 28 19:59 / 1 Comment / Jakob

raceconditionIn his most recent Embedded Bridge Newsletter, Gary Stringham describes a solution to a common read-modify-write race-condition hazard on device registers accessed by multiple software units in parallel. Some of the solutions are really neat!

I have seen the “write 1 clears” solution before in real hardware, but I was not aware of the other two variants. The idea of having a “write mask” in one half of a 32-bit word is really clever.

However, this got me thinking about what the fundamental issue here really is.

Read More →

Tweet
Posted in: embedded software, embedded systeme, ESL, programming / Tagged: 64-bit computing, device driver, Gary Stringham, high-level synthesis, programming register, race condition

Post Navigation

1 2 3 Next »

Recent Posts

  • 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
  • Programming like Lego
  • Does ISA Matter for Performance?
  • Wind River Blog: Debugging Simics using Simics
  • Wind River Blog: Simics and Flying Piggies
  • Dragons can be Useful – when AT Models Make Sense

Categories

  • appearances (30)
  • articles (21)
  • blogging (10)
  • books (6)
  • 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 (107)
  • review (8)
  • security (19)
  • teaching (7)
  • testing (9)
  • uncategorized (12)
  • virtual things (129)
    • computer simulation technology (68)
    • virtual machines (17)
    • virtual platforms (98)
    • virtualization (14)
  • Wind River Blog (40)

Tags

ARM blog commentary Cadence Checkpointing clock-cycle models Communications of the ACM computer architecture conference cycle accuracy debugging DML Domain-specific languages 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

  • May 2013 (2)
  • 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