MùPùF.org

To many people out there, parallel programming may not sound very useful, and actually pretty complicated. However, everybody expects processors to have several cores and software to make use of them. The whole purpose of parallel programming is to leverage the capabilities of multi-core processors, but this comes with a cost: we need to rethink our way of programming, moving from the old single-threaded or "a thread per task" programs to applications that describe their work-flow in tasks that can be concurrently processed: what is called task-based programming.

This may sound difficult, but it is necessary to produce code that can actually use several cores, and also scale properly (ie. keep a decent performance level) from single-core processors to computer grids with hundreds of cores. The problem of multi-thread apps made by hand is that often, threads are planned per task, but even worse, the number of logical threads in the program is not equal to the number of physical threads on the CPU, but to the number of tasks, which is fixed. This means the program does not scale at all, unless thread pools are created and managed by hand, which means a huge code overhead for the thread pool management system. Besides, this means you still have to do load balancing between threads on your own, which is again a difficult task.

To the difference of multi-threaded apps with synchronisation code, the goal here is to leave all thread management and task assignment to a specifically built library. In this article, I am going to explain the very basics of Intel Threading Building Blocks, most likely one of the most efficient and simple multi-core programming libraries in the wild.

I've had a very boring problem for the last couple months, that I could never find the time to diagnose, till two days ago it finally got over my head. My computer would, sometimes, with no apparent reason, refuse to suspend (or actually, it would begin and then, after twenty seconds, interrupt the suspend procedure, breaking all my internet connections, and making the CPU and fans overwork).

This blog post is about how I found out what was going on, and about what changes in the design of the Linux kernel could have prevented it from happening.

Well, it's been a long time. This post will be dedicated to explanations on how to draw graphs in Qt's QGraphicsScene, using GraphViz. We're not talking about rendering an SVG graph with GraphViz and then printing it in a scene, however. What we will do, instead, is:

• represent a graph, using a C++ wrapper class for libgraph
• tell GraphViz to compute positions for each node, and the path of each edge
• draw our graph using QGraphicsEllipseItem and QGraphicsPathItem

The whole thing is used in a computer security research project on which I'm not allowed to give any information, so I will be vague on some parts of this tutorial, and I will not provide a whole bunch of ready-to-run code. I'm still going to give you the hints for fulfilling the three tasks above, and I will publish the class I wrote for my project (it is, of course, not generic at all, since it was designed for my particular needs).

This tutorial assumes you have a decent knowledge of how Graphviz works, and basic knowledge of the QGraphics API.

Today I was asked to write an article for my English lesson. It was asked to me about a week ago but of course I wrote it this very morning during my Shell programming lesson (yeah, I love Shell programming).

Here are the instructions of the exercise:

You see this notice in an in-flight magazine and decide to enter the competition.

What forms of transport will we be using in 50 years' time?

Where will we take our holidays?

Write us an article, giving us your views on both of these questions. Science fiction writer John T. Price will choose the most original article, which will receive a prize of $1,000 and be published in our magazine next year.

If I win the prize, I'll make sure to hire an actual artist in order to achieve the redrawing of our sexy header. Long life to the Invisible Pink Unicorn and the Flying Spaghetti Monster!

As I pointed out in previous blog entries, I've been running short on time in the last few months. The reason is that I put quite a lot of time into a project that was assigned to me as part of my studies. The goal of the project was to create an application allowing graphical monitoring of various system and network security tools, such as SELinux, PIGA (currently under development in my school, ENSI of Bourges), Osiris, Snort, etc.

While I was beginning to starve tonight, I noticed I had no idea what I'd cook. I was getting a bit fed up of noodles, and didn't eat vegetables for a while. I can already hear you saying (actually, I can't, unless I'm hooked to your micro, but that's very unlikely, isn't it?) “Hey wait, vegetables are dull”... No, they're not! Not when you cook them properly, and it kind of accidentally happened to me just about an hour and a half ago.

You may also be wondering what the hell a kesäkurpitsapaistos can be. Well, it's the Finnish name of gratin de courgettes. My Finnish friend Pasi took some time to find out what a courgette is, and he blamed me for not telling him in Finnish (well, now at least I know a word of that weird wonderful language).

So, shall we now get into the technical details?

This post is just a quick tutorial on how to modify NotifyOsd's display colours, font size, and bubble position. It includes source code edition, and thus is not advised for beginner users.

Also, if you're interested into a GConf-Xfconf customisable Debian NotifyOsd package, please leave a comment on the blog, and I'll see what I can do (there is already a patch for that, but I have to update it to the latest version of NotifyOsd).