So one of my goals in developing DALIS/H2D2 was to make it possible to run a single instance of a program on multiple platforms. Since the H2D2 virtual machine can run code for a timeslice and then persist the entire state of the running program, it should be possible to put an executing H2D2 program into hibernation, move it to a different platform (ie a machine with an entirely different type of OS or processor) and then carry on running the same program. No matter what point the program was frozen at, the code should be able to carry on where it left off.
Well I've now gotten to the point where I can test that theory. The first experiment is to run a program on Windows for a few milliseconds and then complete the execution on Linux. To make this work I needed to make sure that all my data was persisted in sizes that are the same on different platforms, so I need to use
int32_t instead of
int, that type of thing. Since I've written my code in a cross-platform way and since I'm using data sizes that will be the same on different platforms everything should just work. So here we go, I'm running my mandelbrot program on Windows for 200ms:
...so that outputs a file called 'demo.hby' which is the H2D2 bytecode including its persisted state (all the program instructions, the call and data stacks and the values of all variables). Now I need to move that file to my Linux box and run the code from where it stopped. On the Linux machine I have already compiled the H2D2 virtual machine from source using GCC of course. Here goes:
Awesome! It works! I guess it's not much more than a neat trick at the moment, but I think it's an achievement of sorts. If you had some kind of long running process, it might be handy to be able to wake it, run it on whatever machine was available, and then put it back into hibernation. Okay, you can't start re-writing all your business logic in H2D2 just yet... but it's early days. This is why I always imagined DALIS / H2D2 to be a cloud based language, where you don't care what type of platform or processor is being used from one moment to the next.
So the next obvious experiment is to do the same thing, but on the Raspberry Pi... maybe I'll do it in reverse, by starting the program on the Raspberry Pi and then finishing it on Windows.
Well, I tried running my H2D2 programming language / virtual machine thingy on the Fez Panda II by means of RLP, but I wasn't successful. Alas, the amount of memory left for running native code is not big enough for it. If I was really brave I could use the board as a native ARM development board I think, but I'd rather do other stuff...
Speaking of which, I've gotten round to hacking up a makefile for H2D2 so I can compile it on Linux with GCC. It was easy really, I've just created the simplest makefile you can imagine. But here is my usual victory dance running on Debian Squeeze emulated in VirtualBox:
Which is awesome, and 440 milliseconds is rather quick - especially because it's running in an emulator. I also tried it on the machine I built from an Intel D410PT motherboard and it managed to do it in 400ms flat. These rather unscientific benchmarks seem to indicate that GCC on Linux is more efficient than Pelles C generating code for Windows.
So I guess the only logical step now is to compile it on the Raspberry Pi. It would be rude not to.
Since I've been writing the parser for H2D2 - the continuation of my work on DALIS, I thought
that it might be useful to see the syntax trees
that are being generated. So I found a
nifty tool called phpSyntaxTree
which is a website that will draw a graphical version of a tree from bracketed notation.
So I added some code to H2D2 which will output the syntax tree created by the parser in bracketed
notation, and now I can paste the resulting text into phpSyntaxTree and see what the results look like.
Whilst the H2D2 language doesn't have much of a syntax yet, I have been able to parse things like
this example code:
an = 99
mynum = 88
PRINT 1 + 2*3
IF 1 PRINT 1 PRINT 0
That program tests the majority of things that I have written so far, simple things like branching, expression parsing and assigning numeric variables. This is how that program comes out:
You can see the difference between the two expressions, one with brackets and the other without, and when I run
the program, the first result is 7 and the second result is 9, so it seems to be working fine. When H2D2 programs
are executed I'm using a non-recursive algorithm, which means that the code can be frozen at any point and then
resumed - even if the code was part way through evaluating an expression there's no problem in carrying on exactly
where the code was paused. So far I've only tested all this in Pelles C on Windows, but I will put a quick
makefile together soon so that I can compile it with GCC (on linux), I want to keep the C code for H2D2 as portable as I can. The next thing that I'm going to try and build is a loop, which is kinda important.
Of course, it wouldn't be me unless I tried drawing a mandelbrot on the Raspberry Pi. Here is the traditional ASCII character version, but with some low-res colours.
I have to admit that the colour idea was inspired by somebody called Paulo Lellis, who had read some of my previous posts and adapted my code to include colour codes. It was very kind of Paulo to show me what he had done. I've simply tweaked it some more.
Anyway, if you'd like to try it, here is the source code:
Compile like this:
Then run the code, like this
for(e=1.1; e>-1.2; e-=.1)
for(b=-2; b<1; b+=.04)
// see: http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
for(r=0; r*r+n*n<4 && --h>32; d=r)
r = r*r-n*n+b;
n = 2*d*n+e;
Well, I had to try the C compiler on the Raspberry Pi at some point.