Elektroniktidningen Magazine Article about DML

The November 2022 on-paper magazine from Swedish electronics news site Elektroniktidningen features an article I wrote about the Device Modeling Language (DML). Among many other really good articles.

Update: The article is now available online in HTML format.

Cover of Elektroniktidningen 11/2022
Continue reading “Elektroniktidningen Magazine Article about DML”

Intel Blog: Catching a Tricky Bug by Running Simics on Simics

I recently published a long post on the Intel Community Blog, talking about how my colleague Evgeny solved a nicely complicated bug using Simics-on-Simics. The bug involved UEFI, an operating system, SMM, SMI, and virtualization. Just another day in the office (or more like a year, given how long it took to get this one resolved).

Was this a UTF-8 WTF?

Today I observed something very odd in Powerpoint. I was pasting in some text from the Simics command-line interface into a text box in Powerpoint to show the output of some commands. Commands whose output relied on box-drawing characters to produce nice tables. But for some reason… it did not work in Powerpoint. Weird.

Continue reading “Was this a UTF-8 WTF?”

SystemC Evolution Fika: Parallel SystemC

The SystemC Evolution Fika on April 7 had threading/parallelism as its theme. There were four speakers who presented various angles on how to parallelize SystemC models. The presentations and following discussion provided a variety of perspectives on threading as it can be applied in virtual platforms and other computer architecture simulations. It was pretty clear that the presenters and audience had quite different ideas about just what the target domain looks like and the best way to introduce parallelism to SystemC. Here is my take on what was said.

Continue reading “SystemC Evolution Fika: Parallel SystemC”

Some Notes on Temporal Decoupling (Reposted)

This blog post was originally posted at Intel back in 2018, but it has since been retired from the Intel blog system. As it is of general interest (in my opinion), here is a reposting (with a few small updates here and there).

Temporal decoupling is a key technology in virtual platforms, and can speed up the execution of a system by several orders of magnitude. In my own experiments, I have seen it provide a speedup of more than 1000x. Here, I will dig a little deeper into temporal decoupling and its semantic effects.

Continue reading “Some Notes on Temporal Decoupling (Reposted)”

Blog – Damn the Torpedoes, Full Code Ahead!

I have recently got back to developing training labs for the Simics simulator (and related technologies).  During the process of developing a new accelerator model using as many of the latest frameworks and APIs as possible, it was basically guaranteed that I would hit some bugs and unexpected behaviors. That is a natural part of and benefit from creating training materials in the first place. It also provides a good illustration of two fundamentally different ways to look at software development. One is to play it safe and get things done in known ways, and the other is charge ahead, try the unknown, and see what happens. Damn the torpedoes, bugs are a benefit. No bug reports, no glory. In this post, I will share some recent examples of just coding ahead and breaking thing.

Continue reading “Blog – Damn the Torpedoes, Full Code Ahead!”

Presenting a Simics Tutorial at DVCon Europe (2021)

DVCon Europe is coming up in late October. This year, I am going to present a tutorial on using the public release of the Intel Simics Simulator to model a PCIe-attached accelerator subsystem. It is fun to be back speaking at the DVCon, after a couple of years of not having talked at the conference. DVCon Europe is a virtual event this year too due to Covid.

Continue reading “Presenting a Simics Tutorial at DVCon Europe (2021)”

Intel Blog: How Teaching Users Drives Product Improvements in Simics

I have a post out on the Intel Software blog about my experience developing and delivering training for Simics over the past few years. A key observation is that building training is a great way to test the product, and drives changes and improvements in the product. The blog is found at https://software.intel.com/content/www/us/en/develop/articles/teaching-users-drives-product-improvements-in-simics-sw.html

Continue reading “Intel Blog: How Teaching Users Drives Product Improvements in Simics”

Adjusting to Work-from-Home: Remote Live Simics Training

In the current world-wide lockdown due to Covid-19, many things that were done in-person in the past have to become virtual. The Simics® New User Training that we run at Intel and with our customers and partners is no different. In normal times, we run in-person classes around the world, but that is not an option right now.  Thus, we shifted to running remote live classes as a substitute for the time being. This blog shares some of my experience from running remote live classes.

We changed the cover page of the Simics training to symbolize the change.
Continue reading “Adjusting to Work-from-Home: Remote Live Simics Training”

Intel Blog Post: “Quit Thinking and Look” – Mea Culpa Chasing a Performance Bug

I have written before about the debug advice to “Quit thinking and look.” It means that you should not form conclusions prematurely. Stop and look at what is going on instead of guessing and cooking up theoretical scenarios. Sound advice that I completely failed to follow in the case that I just chronicled on my Intel Blog: https://software.intel.com/en-us/blogs/2020/03/18/quit-thinking-and-look-chasing-simics-performance

Continue reading “Intel Blog Post: “Quit Thinking and Look” – Mea Culpa Chasing a Performance Bug”

Intel Blog Post: Shift-Left for a Snowy Ridge

There is a new blog post on the Intel Developer Zone on how we used Simics virtual platforms for the new Intel® Atom® P5900 series of system-on-chip (previously known as Snow Ridge). It talks about how shift-left works both inside of Intel and with our customers for the new chip, and the kinds of virtual platform models you use for different types of use cases.

See https://software.intel.com/en-us/blogs/2020/03/17/seeing-the-early-snow-on-the-ridge

Intel Blog Post: Simulating Caches 10x Faster with Simics

Earlier this year, Arianna Delsante defended her Master’s Thesis in computer science at Uppsala University. Her thesis topic was to speed up cache and branch prediction simulation in Simics, and in the end she got a speed up of about 10x compared to previous implementations in Simics. I explain a bit more about cache simulation in fast functional simulators and what she did in my latest Intel Developer Zone Blog post, “Speeding-Up Cache Simulation in Simics by 10x“.

Continue reading “Intel Blog Post: Simulating Caches 10x Faster with Simics”

Intel Blog: A Mountain and Threading for Simics 6

A new short blog post on my Intel Developer Zone blog talks about the improved threading simulation core we have added in Simics version 6… and about how a colleague of mine climbed to the top of the highest mountain in Europe and showed a flag with our new Simics icon! Read the story at https://software.intel.com/en-us/blogs/2019/09/10/simics-6-at-the-mountain-top.

Intel Blog: Simics 6 Device Register Coverage

I have a new blog post out on the Intel Developer Zone, about the Simics 6 device register coverage feature. I use device register coverage to look at how different operating systems use the same hardware. The differences are significant, demonstrating the (rather expected) observation that different software stacks use the same hardware in different ways.

Continue reading “Intel Blog: Simics 6 Device Register Coverage”

Intel Blog Post: Clear Linux for Simics Demo & Training

For Simics training and demo purposes, we often use Linux* running on the virtual platforms. In the early days of Simics and embedded Linux, we built our own minimal configurations by hand to run on simple target systems. Most recently, we changed our Linux default demo and training setup to use Clear Linux*. This change showed us just how sophisticated modern Linux setups are – which is good in general, but it also can make some low-level details more complicated.

I wrote an Intel Developer Zone Blog Post about our experience moving to Clear Linux for Simics demos and training, which contains a lot more details of what we observed and did to make this work for our purposes.

DAC 2019 – Cloud, a Book, an Award, and More

Last week was spent at the Design Automation Conference (DAC) in Las Vegas. I had a presentation and poster in the Designer/IP track about Clouds, Containers, and Virtual Platforms , and worked in the Intel Simulation Solutions booth at the show floor. The DAC was good as always, meeting many old friends in the industry as well as checking out the latest trends in EDA (hint: same trends as everywhere else).  One particularly nice surprise was a book (the printed type, not the Vegas “book” that means something else entirely).

Continue reading “DAC 2019 – Cloud, a Book, an Award, and More”

Intel Blog Post: Simics in the DARPA Cyber Grand Challenge

The US Defense Advanced Projects Agency (DARPA) ran a “Cyber Grand Challenge” in 2016, where automated cyber-attack and cyber-defense systems were pitted against each other to drive progress in autonomous cyber-security. The competition was run on physical computers (obviously), but Simics was used in a parallel flow to check that competitors’ programs were not trying to undermine the infrastructure of the competition rather than compete fairly inside the rules of the competition.

Continue reading “Intel Blog Post: Simics in the DARPA Cyber Grand Challenge”

Intel Blog Posts: Running Simics in Containers

Running Simics inside a container is a topic that has come up several times in recent years. In a two-part Intel Developer Zone blog post, my colleague Mambwe Mumbwa and I discuss both some background on container technology, how and how well Simics can run inside of containers, and what you can with containerized Simicses. Overall, containers offer a very good alternative to virtual machines for running programs like Simics, and the tool ecosystem opens up some exciting new ways to manage Simics installations and simulation instances.

Update: this post was extended to link to both part 1 and part 2 of the blog.

Continue reading “Intel Blog Posts: Running Simics in Containers”

Intel Blog Post: Additional Notes on Temporal Decoupling

A few weeks ago, I talked about temporal decoupling in virtual platforms at DVCon Europe 2018. I just posted some additional notes on the topic temporal decoupling on my Intel blog. In this new blog post, I discuss some more aspects of temporal decoupling, and how it affects simulation semantics. I also explain some of the clever techniques used to minimize the impact of temporal decoupling on the software running on the virtual target system.

Update: The blog post is no longer available on the Intel site, instead it was reposted here on this blog to keep it available on the Internet.

Intel Blog Post: Interview with Bengt Werner on the Early Days of Simics

Bengt Werner was one of the first people to work on the simulator that would become Simics, way back in 1992. On my Intel Blog, I published an interview with Bengt a while back where we discuss the early days of Simics and the original product vision and use cases.

Continue reading “Intel Blog Post: Interview with Bengt Werner on the Early Days of Simics”

Intel Blog Post: The Simics Fulprompt, Fulöl, and Fuldans

I have a new blog post up at the Intel Developer Zone, this time about the Simics “fulprompt”. Every software team has its legends about spectacular mistakes, crazy users, and customer calls with strange questions.  The Simics “fulprompt” is one example of this from the early days of Simics. It was a prompt that appeared where no prompt would normally appear, right in the middle of executing an instruction. As such, it was an ugly hack… and for Swedes who were around in the 1990s, the only name for a ugly hack is a fulhack.

Continue reading “Intel Blog Post: The Simics Fulprompt, Fulöl, and Fuldans”

Intel Blog Post: Fault Injection in the Early Days of Simics

Injecting faults into systems and subjecting them to extreme situations at or beyond their nominal operating conditions is an important part of making sure they keep working even when things go bad.  It was realized very early in the history of Simics (and the same observation had been made by other virtual platform and simulator providers) that using a virtual platform makes it much easier to provide cheap, reliable, and repeatable fault injection for software testing. In an Intel Developer Zone (IDZ) blog post, I describe some early cases of fault injection with Simics.

Continue reading “Intel Blog Post: Fault Injection in the Early Days of Simics”

Intel Blog Post: Simulation a Thousand Target Machines – in 2004 and 2018

Back in 2004, the startup Virtutech built a crazy demo for the 2004 Embedded Systems Conference (ESC). Back then, ESC was the place to be, and Virtutech was there with a battery of demos to blast the competition.  The most interesting demo from a technology perspective was the 1002-machine network, as described in an Intel Developer Zone blog post of mine.

Continue reading “Intel Blog Post: Simulation a Thousand Target Machines – in 2004 and 2018”

Intel Blog Post: Running Large Workloads on Simics – in 1998 and 2018

I have just released a new blog post on my Intel Developer Zone blog, about how Simics runs large huge workloads. I look back at the kinds of workloads that ran on Simics back in 1998 when the product first went commercial, and then look at some current examples running on Simics.  This is the first post in a series intended to celebrate 20 years of Simics as a commercial product.

Continue reading “Intel Blog Post: Running Large Workloads on Simics – in 1998 and 2018”

Talking at the Embedded World 2018

I will be presenting an Exhibitor Forum talk at the Embedded World in Nürnberg next week, about how to get to Agile and small batches for embedded. Using simulation to get around the annoying hard aspect of hardware.

More details at https://software.intel.com/en-us/blogs/2018/02/19/embedded-world-getting-agile-with-simulation

Intel Blog Post: Simulation in the Gartner Top Ten Tech Trends for 2018

There is a blog post out on my Intel Developer Zone blog where I take a look at the Gartner “Top Ten Tech Trends” for 2018.  There are a couple of them where I found clear roles for the kinds of simulation tools we build in my little corner of Intel. In particular, Digital Twins is a concept that is all about simulation.  To find the other trend where I found a big role for simulation, read the full blog post.

Intel Blog Post: Using Wind River® Simics® to Inspire Teachers and Researchers in Costa Rica

A while ago, I visited my Intel colleagues in Costa Rica and ran a workshop for university teachers and researchers, showing how Simics could be used in academia.  I worked with a very smart and talented intern, Jose Fernando Molina, and after a rather long process I have published an interview with him on my Intel blog: https://software.intel.com/en-us/blogs/2017/12/05/windriver-simics-to-inspire-teachers-costarica

Continue reading “Intel Blog Post: Using Wind River® Simics® to Inspire Teachers and Researchers in Costa Rica”

Intel Blog: Question: Does Software Actually Use New Instruction Sets?

Over time, Intel and other processor core designers add more and more instructions to the cores in our machines. A good question is how quickly and easily new instructions added to an Instruction-Set Architecture (ISA) actually gets employed by software to improve performance and add new capabilities. Considering that our operating systems and programs are generally backwards-compatible, and run on all kind of hardware, can they actually take advantage of new instructions?

Continue reading “Intel Blog: Question: Does Software Actually Use New Instruction Sets?”

Intel Blog Post: Getting to Small Batches in System Development using Simulation

I have posted a two-part blog post to the public Intel Developer Zone blog, about the “Small Batches Principle” and how simulation helps us achieve it for complicated hardware-software systems. I found the idea of the “small batch” a very good way to frame my thinking about what it is that simulation really brings to system development. The key idea I want to get at is this:

[…] the small batches principle: it is better to do work in small batches than big leaps. Small batches permit us to deliver results faster, with higher quality and less stress.

Continue reading “Intel Blog Post: Getting to Small Batches in System Development using Simulation”