Pulling the Virtual Ethernet Plug

I just read the panel interview at the start of the latest issue (Number 4, 2008) of ACM Queue. Here, you have Bryan Cantrill of Sun (the man behind dTrace) bemoan the difficulty of testing faults. In particular:

Part of the reason I’m interested in virtualization is as a development methodology. It has not delivered on this, but one of the things that I ask is can I use virtualization to automate someone pulling the Ethernet cable out of the jack? I can get a lot closer to simulating it if you let me create a toy virtual machine than I can running on the live machine.

Well, this already exists. It is a common feature to any virtual platform that is not a datacenter-oriented runtime engine like VmWare, Xen, LPAR, and its ilk. Doing fault injection is a primary use case for virtual platforms, especially for larger servers and systems featuring redundancy and fault tolerance.

SiCS Multicore Days 2008: Talk about Threading Simics (updated)

Shrinking cores

I will give a presentation on how Simics was threaded and how we created a parallel virtual platform system at the SiCS Multicore Days 2008, which takes place in Kista, Sweden, on September 11 and 12. The schedule is now up (so I edited the post and added updated to the title), at http://www.sics.se/node/3182, and my talk is on Friday, Sept 12, at 13.00 in “track 2”. Speaker bios and abstracts are also online.

Even apart from my own humble participation, I think the event itself will be well worth attending. Last year was really good and serious fun! See my writeups from last year: part 1 and part 2 (and a short note on the Rock processor and transactional memory).

Software, Hardware, and Development Methods

opinionI just read an opinion-provoking piece “Software developer attitudes: just get on with it” by Frank Schirrmeister, as well as the article “Life imitating art: Hardware development imitating software development” by Glenn Perry that he linked to. Both these articles touch on the long-standing question of who does development the “best” in computing. I have heard these arguments many times, where software developers think that there is something mythical about hardware development that makes things work so much better with much fewer bugs, and hardware people looking at the speed of development and fanciful fireworks of coding that software engineers can do. It could be a case of the grass always looking greener on the other side… but there are some concrete things that are relevant here.

Continue reading “Software, Hardware, and Development Methods”

CouchDB: A Parallel Program in a Parallel Language

I just listened to another Floss Weekly show, Number 36 where they interviewed Jan Lehnard of the CouchDB project. CouchDB is very interesting, in that it is a database designed for replication, redundancy, and thus massive parallelism. It was initially written by Damien Katz on his own, but now it is an Apache Foundation project sponsored by IBM. The most interesting thing is that Damien decided in 2006 to rewrite the C++ prototype he had in Erlang, and did so in just a few months if I understood my Erlang friends right. So here we have a really good parallel program written in a true parallel language.

Continue reading “CouchDB: A Parallel Program in a Parallel Language”

Swedish Workshop on Multicore 2008: Nov 27-28: CFP!

Shrinking cores

The first Swedish Workshop on Multicore Computing (MCC) will take place in Ronneby on November 27 and 28, 2008. The call for papers is now out, and it is open until September 26. If you have something cool to present or publish about multicore computing, and happen to be here in Sweden, please do submit an abstract!

Disclosure: I am in the program committee for this event.

Off-topic: Excel to Wiki Table Converter

I work quite a lot with Wikipedia systems (mostly mediawiki-based) to structure data and make it accessible to other people at my job. Since I happen to love tables as a way to provide overviews and summaries of complex information, I keep creating wiki tables. Editing tables in a wiki is pretty painful, especially when it is time to do things like add columns. Excel is a much superior tool for this purpose, and I have been looking for a tool to let me create tables in Excel and then get a wiki rendering of them for insertion into a wiki. Finally, I have found it! Here, you can find a pretty good Excel VBA macro that lets you select a range of cells and then get a wiki table code corresponding to it on your clipboard, ready to paste into the wiki site. Thanks a million times to the creators of that tool, it is really useful. Note that in Office 2007, you must save documents in .xlsm, macro-enabled, format to be able to save the macro with your file.

DNS: Hardware Accelerator Time!

In Episode 157 of Security Now,Steve Gibson and Leo Laporte discuss the recently discovered security issues with DNS. In particular, the cost of making a good fix in terms of bandwidth and computation capacity. Fundamentally, according to Steve, today’s DNS servers are running at a fairly high load, and there is no room to improve the security of DNS updates by for example sending extra UDP packets or switching to TCP/IP. As this theoretically means a doubling or tripling of the number of packets per query, I can believe that. The “real solutions” to DNS problems should lie in the adoption of a truly secured protocol like DNSSEC. As this uses public key crypto (PKC), it would add a processing load to the servers that would kill the DNS servers on the CPU side instead…

Continue reading “DNS: Hardware Accelerator Time!”

FLOSS Weekly: Drizzle: Aggressive Push to Multicore

I listened to episode 35 of FLOSS Weekly that interviewed Brian Aker, creator of the Drizzle fork from MySQL. As most recent episodes of FLOSS Weekly, it is pretty good technical material. What I found interesting was the technical vision behind Drizzle, and how they are aggressively going for quite wide multicore hosts.

Continue reading “FLOSS Weekly: Drizzle: Aggressive Push to Multicore”

GPU Programming: a Good Pattern to Follow?

In the March/April 2008 issue of ACM Queue, there is an article on GPU Programming by Kayvon Fatahalian and Mike Houston of Stanford that I found a very interesting read. It presents and analyzes the programming model of modern GPUs, in the most coherent and understandable way that I have seen so far. The PC GPU has a model for programming parallel hardware that might be a good pattern for other areas of processing. Programmers do not have to write explicitly parallel code, the machinery and hardware takes care of ensuring parallel behavior, as long as the code follows the assumptions made in the model.

Continue reading “GPU Programming: a Good Pattern to Follow?”

Biking topic 2: Bike mounts for cars with no towbar!

One thing that has always annoyed me is that you seemed to have to have a tow bar (dragkrok in Swedish) on your car to be able to fit a bike mount. And tow bars are not that common, there are several good reasons not to get one, like added cost, not usually available on used cars, and that they compromise crash safety to some extent. But to put my bike on a car it seemed that I had to get one. I was thinking about how to build a bike mount that could actually work on a regular station wagon by making use of the cargo rails, in some clever way.

But it seems I do not have to invent and build and market this thing myself: it is already available! I found a whole set of varieties from a company called Thule when I browsed a biking catalogue recently. Seems to fit quite a few varieties of cars including even the odd sedan! Good to know that they exist if I ever need to carry bikes regularly.

Biking topic 1: I should have a commission on these!

Last year, we got ourselves one of the best child-related products we have ever seen: a Chariot Carriers Corsaire XL bike carriers. This might sound like marketing hype from their marketing department, but it really is a brilliantly designed product (mostly). At core, it is a carrier with two wheels, seating two children, and which can be quickly turned from a bike carrier into a regular city stroller. For us, this really means freedom! In particular, the freedom to quickly pop down town using the bike, and then not have to carry our son but rather have a decent stroller to push him around in (and to load up with shopped stuff).

Continue reading “Biking topic 1: I should have a commission on these!”

In Praise of Scripting: Something for Modeling as Well?

In the July 2008 issue of IEEE Computer, there is short article called “In Praise of Scripting: Real Programming Pragmatism“, by Ronald P. Loui, a professor at Washington University (WUSTL). The article deals with the issue of what is the appropriate first language to teach new CS (Computer Science) students, and considers that a “scripting” langauge like Python or Ruby might be way better than Java (no doubt about that I think).

The interesting material in the article is the background on WHY he thinks that this is the case. He points to the immense popularity and rise of scripting in much of computing land. In the past ten years, it is clear to him (and I would agree with this too mostly) that languages like Perl, PHP, Awk, Ruby, JavaScript, and Python have eclipse Java and C++ as the most interesting and important programming languages for many practical tasks. Especially for web applications, where Java seems to have a presence but noone would dream of using something as clunky and impractical as C.

What can this teach us for the purpose of simulation and the creation of models of computer system hardware for the purpose of simulation? Maybe a fair bit…

Continue reading “In Praise of Scripting: Something for Modeling as Well?”

Schirrmeister has a nice observation on model-based development

Model-based architecture (MDA) or model-based development is an idea that to me comes from the automotive field. To, it means that you use some tool that is capable of modeling both a computer controller system and the environment being controlled to create a simulation world where computer control and environment meet and the characteristics of the controller can be ascertained quickly. The key is to not have to convert controller algorithms to concrete code, and not have to run concrete code on concrete hardware against physical prototypes to test the controllers. Today, this seems to be applied to many fields where you are creating control systems (automotive, aviation, robotics). The tools are math-based like MatLab and LabView, along with special programming environments based on UML and StateCharts.

What is interesting is that most of these tools are graphical in nature. And they do seem to work quite well, which is quite surprising given the otherwise poor record of graphical programming as opposed to text-based programming. There were a pile of graphical programming environments in the 1980’s, none of which amounted to much. What survived and prospered were the good old text-based languages like C, C++, Java, VisualBasic, etc.  In practice, it seems like it is very hard to beat sequential text when it is time to actual get code working. More efficient programming seems to boil down to having to write less text and having text which is easier to write (for example, dynamic typing, rich libraries, garbage collection, and other modern language features that remove intellectual burdens from the programmer).

But graphics do seem to work for domain-specific cases (like control engineering or signal processing), especially for data-flow-style problems. And for abstract architecture work. So there has to be something to it… but what?

Continue reading “Schirrmeister has a nice observation on model-based development”