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

Category Archives: Embedded Systeme

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

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

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

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: 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

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

Freescale Online Fault-Tolerance “Demo”

2009 November 18 13:21 / Leave a Comment / Jakob

freescale-logo-iconI just spotted a fun little application on Freescale’s homepage: an interactive demo of the fault tolerance functions of the MPC564XL dual-core microcontroller.

Read More →

Tweet
Posted in: computer architecture, embedded systeme / Tagged: fault injection, fault tolerance, freescale, MPC564XL

Freescale P4080, in Physical Form

2009 September 17 11:16 / Leave a Comment / Jakob

freescale-logo-iconPast Tuesday, I attended the Freescale Design With Freescale (DWF) one-day technology event in Kista, Stockholm. This is a small-scale version of the big Freescale Technology Forum, and featured four tracks of talks running from the morning into the afternoon. All very technical, aimed at designing engineers.

Read More →

Tweet
Posted in: appearances, embedded software, embedded systeme, multicore computer architecture, multicore debug, virtual platforms / Tagged: DWF, freescale, heterogeneous, homogeneous, Jonas Svennebring, MPC5606, p4080, Simics

Downloadable Book about Embedded Multicore

2009 August 8 20:27 / Leave a Comment / Jakob

freescale-logo-iconFreescale has now released the collected, updated, and restyled book version of the article series on embedded multicore that I wrote last year together with Patrik Strömblad of Enea, and Jonas Svennebring, and John Logan of Freescale. The book covers the basics of multicore software and hardware, as well as operating systems issues and virtual platforms. Obviously, the virtual platform part was my contribution.

Read More →

Tweet
Posted in: books, embedded software, embedded systeme, multicore computer architecture, multicore debug, multicore software, virtual platforms / Tagged: freescale, John Logan, Jonas Svennebring, Patrik Strömblad

LCTES 2010 Call for Papers

2009 August 1 00:26 / Leave a Comment / Jakob

The call for paper for LCTES 2010 is now out, the deadline is October 3. If you have something to publish in the area of “Languages, Compilers, and Tools for Embedded Systems”, please consider it! I am on the program committee, and looking forward to reading some really good papers. I used to publish at the LCTES myself when I was doing my PhD… see my older publications if you are curious.

The conference itself will take place in Stockholm in April of 2010, as part of the Cyber-Physical Systems Week (CPSWeek) 2010.

Tweet
Posted in: conferences, embedded software, embedded systeme / Tagged: CPSweek, LCTES

The Hardware-Software Interface is where the Action Is

2009 June 7 20:52 / 9 Comments / Jakob

pn4_quad-gigaswift-utp-adapterWhen I started out doing computer science “for real” way back, the emphasis and a lot of the fun was in the basics of algorithms, optimizing code, getting complex trees and sorts and hashes right an efficient. It was very much about computing defined as processor and memory (with maybe a bit of disk or printing or user interface accessed at a very high level, and providing the data for the interesting stuff). However, as time has gone on, I have come to feel that this is almost too clean, too easy to abstract… and gone back to where I started in my first home computer, programming close to the metal.

Read More →

Tweet
Posted in: computer architecture, embedded systeme / Tagged: Brian Cantrill, Gary Stringham, hardware design, hardware-software interface, Keith Adams, Steve Gibson

Cadence Industry Insight: “Virtual Platforms Unite HW and SW”

2009 May 22 07:41 / Leave a Comment / Jakob

opinionAnother Cadence guest blog entry, about the overall impact of virtual platforms on the interaction between hardware and software designers. Essentially, virtual platforms are a great tool to make software and hardware people talk to each other more, since it provides a common basis for understanding.

Read More →

Tweet
Posted in: articles, embedded software, embedded systeme, ESL, programming, virtual platforms / Tagged: Cadence, Domain-specific languages, ISX, Richard Goering, scdsource, software testing

EETimes.com – Multicore CPUs face slow road in comms

2009 March 22 22:16 / Leave a Comment / Jakob

eetimes logoThe  EETimes article Multicore CPUs face slow road in comms piqued my interest. There is an interesting chart in there about just how slow more-than-one-core processors will be in penetrating a vaguely defined “comms” market place. I can believe that, but I think their comments on the PowerQUICC series require some commentary…

Read More →

Tweet
Posted in: embedded systeme, multicore computer architecture, multicore software / Tagged: Cavium, Communications market, EETimes, freescale, heterogeneous, Linley Gwennap, Multicore Expo, Octeon, p4080, PowerQUICC, qoriq, Rick Merritt

Post Navigation

1 2 Next »

Recent Posts

  • 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
  • Logging (Some More Thoughts)

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 (128)
    • computer simulation technology (68)
    • virtual machines (17)
    • virtual platforms (97)
    • virtualization (14)
  • Wind River Blog (39)

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 (1)
  • 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