Dimajix Developer Blog

Currently I am thinking of replacing my (rather new) ReadyNAS NAS server by a more powerful self-built server. Although the ReadyNAS is a very nice device with very good support from Infrant, it is still too slow for storing all remotely mounted user directories for my Linux and Mac box. Plus I am thinking of using a iSCSI volume for all user directories on my Windows box.

My ideal server would contain an Areca SATA controller with 16 channels and 15 disks in hot-swap carriers running in a RAID-6 plus one or two fast gigabit controllers. So much for the hardware.

But another important aspect is the software of course. Currently I would opt for OpenFiler as operating system for the server. OpenFiler is based on Linux and supports all features I want, except for efficient snapshots. Snapshots are a wonderful thing, they allow to keep an old state of a file-system without the need to do an explicit backup (although one still should backup ones data because of the risk of hardware faults). OpenFiler implements these snapshots using LVM (Logical Volume Manager), which in turn implements snapshots on a Copy-on-Write base. This snapshot implementation has two main drawbacks:

• You have to allocate space for the snapshot on your disks.


• The more snapshots you have, the slower gets your system .

And this is exactly the point where Suns filesystem ZFS comes in. ZFS also supports snapshots, but as it seems in a much more efficient way. You do not need to preallocate space for the snapshot and it seems that there is no performance penality by using them. So I'd love to use ZFS together with OpenFiler - but ZFS currently is only available in Solaris with a Linux port under the way. But I guess it will take more time for the Linux port to finish and to be integrated into OpenFiler than I want to wait with my new NAS server.

Snapshots really are the reasons why everyone wants ZFS on Linux. Okay, at least this is my personal top reasons why I want to see it soon. Or a port of OpenFiler to Solaris

I am a big fan of the english avantgarde director Peter Greenaway, who made the films (among many others)

• The Draughtsman's Contract (1982)


• A Zed & Two Noughts (1985)


• The Belly of an Architect (1987)


• The Cook the Thief His Wife & Her Lover (1989)


• Prospero's Books (1991) (one of my favorite films)


• The Pillow Book (1996)


• 8 ½ Women (1999)

Now Peter Greenaway has an exciting new project called The Tulse Luper Journey, which is more than only a film. It is a story about a fictive man called Tulse Luper (who already appeared in some of Greenaways previous works), who was imprisoned for his whole life - mistaken for someone important, a spy, a lover, an artist, a writer and an observer. Luper has packed a total of 92 suitcases in his life reflecting his subjective view of the history of the 20th century. The complete project includes three feature films, a TV series, 92 DVDs, CD-ROMs, and books.

The Tulse Luper Journey also contains an online game which is still going. You can win a Tulse Luper DVD box and a journey round the world.

As I already promised in this blog and in some emails to various people, I prepared a new developer release 0.4 of my framework "Magnum". It already contains a lot of changes and supports SCons for building it.

I also packed another archieve containing all data sets that are used for the demos - unfortunately you really need it in order to build the framework and all examples using the build scripts.

Among the changes are:

• SCons as build system.


• A much better directory structure.


• Much more pure virtual interface classes.


• XML parser and DOM-like document model.


• HTTP Server functionality.


• The skeleton of a meta-compiler for reflection and more.


• Lots of other changes that even are not documented in the changelog

I am also thinking about publishing a copy of my subversion repository online, so you can follow the development and access the most current version - but I am not sure about that and I currently don't have enough time to set up a replication mechanism.

Recently I got hands on an SGI Fuel, and I plan to use it for development (as soon as I ported my project to Linux - in other words, it will take a while). The Fuel offers some standard 64bit PCI expansion slots, and even supports some standard PCI cards. You can find a list of (inofficially) supported cards at Nekochan.

For myself, first I installed an M-Audio Revolution 7.1 card, which runs out-of-the-box. The next step was to install a gigabit ethernet card, as I have all my home directories stored on a central NAS Raid server. But this was not so easy, because of two problems: First the number of supported gigabit cards is rather low (and they are expensive), and they only work with a small kernel hack. But finally I got my hands onto two Compaq NC7770 Gigabit Server Adapter for 19EUR each. I installed one of the cards into my Fuel and followed the hacking instructions again found at Nekochan.

Now I have working a cheap but powerful gigabit ethernet card in my Fuel, the same trick should also work on an Octane with a PCI card cage and an Origin. Maybe I will try to install the second card into my O200 some time.

I really tried hard to post an entry onto this blog once a month - almost 9 months ago. Now I will retry to populate this blog again with some information. So what am I doing at the moment? I am still working a lot on Magnum in my spare time. Expect an intermediate release soonwith lots of changes inside and outside; among those are:

• Switch to subversion as a source control system.


• Switch to scons as a build system.


• Removal of NVI (non virtual interface) pattern from API.


• Basic functions for a generic meta-compiler.


• Added some kind of unittests.


• Lots of API refacturing and bugfixing.

As you can see, although I haven't updated Magnum for a while, I really have been busy making it a better framework. I guess the rework of the API and the final metacompiler won't be ready for some time, so there will be an intermediate release (I don't want to say "development release", as all releases are mainly for developers) giving a glimpse of the new features mentioned above. And I promise to you, the metacompiler will be really hot!

When working with inheritance and virtual methods, there might be some surprises when one tries to call a virtual method inside a constructor - and this is the reasons why one should never ever call virtual methods inside a constructor or inside a destructor.

Consider the following simple code

class A {
public:
  A() {
      printf("A::A() calls ");
      f();
  };
  ~A() {
      printf("A::~A() calls ");
      f();
  };
  virtual void f() {
      printf("A::f()\n");
  };
};


class B : public A {
public:
  B() {
      printf("B::B() calls ");
      f();
  };
  ~B() {
      printf("B::~B() calls ");
      f();
  };
  virtual void f() {
      printf("B::f()\n");
  };
};


void main(void) {
  B obj;
  obj.f();
};


Continue reading "Inheritance, Constructors, Virtual Methods and typeid"