Mat and I were scanning through github one day and a pretty lengthy, complex piece of code caught our eye (Caution: Do not read if you’re prone to seizures or have a heart condition). This code is one of the many intricacies involved in mono’s bytecode interpreter, and it was beautiful, at least to us. Why must it be so complex? How hard can it be? After a lengthy discussion, we decided the best thing to do at this point was have a competition to see which one of us can write the fastest VM bytecode interpreter in two hours. A few insults later (“Your mother’s filesystem is so fat etc.”), we decided to set a few ground rules and agree on a benchmark.

I came up with a pretty simple piece of code that contains addition, multiplication, and conditional branches. I then generated a generic bytecode equivalent of the benchmark to be used in our interpreter.

int s, i, j;
for (s=0,i=0;i<10000;i++) {
	for (j=0;j<10000;j++)
		s+=i*j;
}
printf("%d\n",s);

As a control, the C benchmark runs on the native machine at an average time of 0.233 secs. In my first attempt, I wrote a simple C program that reads each instruction and jumps to a corresponding block of code.

...
int vm(inst *i) {
	static void *optable[]={
		[OP_NOP]=&&op_nop,	[OP_LDI]=&&op_ldi,	[OP_LDR]=&&op_ldr,
		[OP_STO]=&&op_sto,	[OP_ADD]=&&op_add,	[OP_SUB]=&&op_sub,
		[OP_MUL]=&&op_mul,	[OP_DIV]=&&op_div,	[OP_MOD]=&&op_mod,
		[OP_ORR]=&&op_orr,	[OP_XOR]=&&op_xor,	[OP_AND]=&&op_and,
		[OP_SHL]=&&op_shl,	[OP_SHR]=&&op_shr,	[OP_NOT]=&&op_not,
		[OP_NEG]=&&op_neg,	[OP_CMP]=&&op_cmp,	[OP_BEQ]=&&op_beq,
		[OP_BNE]=&&op_bne,	[OP_BGT]=&&op_bgt,	[OP_BLT]=&&op_blt,
		[OP_BGE]=&&op_bge,	[OP_BLE]=&&op_ble,	[OP_CAL]=&&op_cal,
		[OP_JMP]=&&op_jmp,	[OP_RET]=&&op_ret,	[OP_EOF]=&&op_eof
	};
	int r[4], s[32], *sp=s;
	inst *ip=i;
	...
	op_nop:                         goto *(++ip)->jmp;
	op_ldi:     *sp++=ip->arg;      goto *(++ip)->jmp;
	op_ldr:     *sp++=r[ip->arg];   goto *(++ip)->jmp;
	op_sto:     r[ip->arg]=*--sp;   goto *(++ip)->jmp;
	op_add:     sp--, sp[-1]+=*sp;  goto *(++ip)->jmp;
	op_sub:     sp--, sp[-1]-=*sp;  goto *(++ip)->jmp;
	op_mul:     sp--, sp[-1]*=*sp;  goto *(++ip)->jmp;
	...
}

Click here to download the Full Source Code.

This works by creating an array of goto pointers (I believe this is a gcc extension), a pseudo-stack, and a list of registers, then jumping to each instruction while increasing the instruction pointer. This simple virtual machine executed the bytecode in 6.421 secs, which was way too slow for my taste, so I had to figure out another approach.

Why don’t I just compile the bytecode into x86 machine code, like modern JIT VMs? That could easily be my ticket to victory. I had about an hour left in the competition so I made haste. I began to replace the optable full of goto addresses into x86 instructions, then allocated some executable memory, copied the instructions, and jumped to it.

...
int vm(inst *i) {
	struct {
		int32_t size, arg, jmp;
		char data[16];
	} *op, optable[]={
		INS(op_nop, 0, 0, 0, 0x90),
		INS(op_ldi, 4, 1, 0, 0x68),
		INS(op_ld0, 0, 0, 0, 0x53),
		...
		INS(op_add, 0, 0, 0, 0x58, LONG 0x01, 0x04, 0x24),
		INS(op_sub, 0, 0, 0, 0x58, LONG 0x29, 0x04, 0x24),
		INS(op_mul, 0, 0, 0, 0x5a, LONG 0x8b, 0x04, 0x24, LONG 0x0f,
			0xaf, 0xc2, LONG 0x89, 0x04, 0x24),
		...
		INS(op_ble, 4, 0, 2, 0x0f, 0x8e),
		INS(op_cal, 4, 0, 1, 0xe8),
		INS(op_jmp, 4, 0, 1, 0xe9),
		INS(op_ret, 0, 0, 0, 0xc3),
		...
	};
	...
	if (!(pn=mmap(0,m,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_PRIVATE|MAP_ANON,-1,0)))
		return 0;
	...
	((void(*)())pn)();
	printf("%d\n",r0);
	return 0;
}

Click here to download the Full Source Code.

On runtime this created a small, 122 byte x86 program based upon the benchmark bytecode which clocked in at an average speed of 0.518 secs. This was only around twice as slow as the control so I was fairly confident at this point.

I slickly inquired into what Mat was working on, and he informed me he was writing his bytecode interpreter in Visual Basic.NET. I was a bit skeptical at first, considering he did not know Visual Basic, but was reassured he wasn’t joking. Evidently he taught himself Visual Basic in the span of 2 hours to what amounts to be the ultimate coding troll. He’s not one to lose these competitions, so I assumed he has some trick up his sleeve. He submitted his code for approval:

	...
	For ip = 0 to ops.Length - 1
		Dim i as VMI = ops(ip)
		il.MarkLabel(jmp(ip))
		Select Case i.Opcode
			Case "ldi"
				il.Emit(Opcodes.Ldc_i4, i.Operand)
			Case "ldr"
				il.Emit(Opcodes.Ldloc, i.Operand)
			Case "sto"
				il.Emit(Opcodes.Stloc, i.Operand)
			Case "jmp"
				il.Emit(Opcodes.Br_S, jmp(i.operand))
			Case "mul"
				il.Emit(Opcodes.Mul)
			Case "add"
				il.Emit(Opcodes.Add)
			Case "eof"
				il.Emit(Opcodes.Ldloc, 0)
				il.Emit(Opcodes.Ret)
			Case "cmp"
				Select Case (ops(ip+1).opcode)
					Case "blt"
						il.Emit(Opcodes.Blt, jmp(ops(ip+1).operand))
					Case Else
						Console.WriteLine("unsupported branch: {0}", ops(ip+1).opcode)
				End Select
				ip = ip + 1
			Case Else
				Console.WriteLine("unsupported opcode: {0}", i.Opcode)
		End Select
	Next

	Console.WriteLine("{0}", _
		CType(program.CreateDelegate(GetType(tmplP1(Of Long, Integer))), tmplP1(Of Long, Integer))(0))
	...

Click here to download the Full Source Code.

Once compiled, his code ran the benchmark at an average speed of 0.127 secs….. Wait, what?

# vbnc simvm.vb && time mono simvm.exe
857419840

real	0m0.127s
user	0m0.120s
sys	0m0.000s

I wouldn’t have believed it if I didn’t see it myself. My code generates native Assembly… Assembly! And his is written in Visual Basic. I’m sure there is some trickery going on, like mono optimizing the emitted instructions, but I haven’t as of yet ruled out witchcraft. I was forced to conclude that Visual Basic is faster than Assembly, that I’m a horrible coder, and Mat wins.

UPDATE: Its been mentioned that I didn’t compile the control with optimization on. I turned optimization off because gcc is way too damn smart. It almost literally translated the code into ‘printf(“857419840\n”);’. I think a better example would be if we didn’t give gcc the answer on compile-time, since none of the VM’s were given that opportunity until it read the instructions on run-time. The VM’s did not, and could not know ahead of time the loop amount, or even the general flow of the bytecode for that matter. So by saving the loop amount in a variable declared as volatile, you prevent gcc from optimizing it out:

#include <stdio.h>

int main(int argc, char **argv) {
    volatile int k=10000;
    int s, i, j;
    for (s=0,i=0;i<k;i++) {
        for (j=0;j<k;j++)
            s+=i*j;
    }
    printf("%d\n",s);
    return 0;
}

That code compiled with -O3 runs at 0.085 sec on my machine. Surprisingly its only 66% faster then the Visual Basic example.

Why spend money on expensive CDN hosting when there’s a perfectly good, free, global one available? Thats right, DNS cache. Most open recursive DNS servers will cache requests (A, CNAME, PTR, TXT, etc.) for the length of the specified TTL value, and there’s millions of them worldwide. Once a public DNS server has the records in cache (usually after a single request), it requires no further bandwidth from the originating server.

Unfortunately there’s a limit to the size of a record a DNS server will cache, and a limit to the length of the DNS packet itself. To store files using DNS cache we must encode the file and split it into multiple records. We’re going to use TXT records for this example, which is limited by 255 characters.

file1.part1.cdn 14400 IN TXT
"ICAgICAgQ2FuYWRhIEludmFzaW9uIFBsYW4KICAgIFRPUCBTRUNSRVQg
IENPTkZJREVOVElBTAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tL
QoKU3RlcCAxKSBBcm0gYmVhdmVycyB3aXRoIHJpZmxlcwpTdGVw"

file1.part2.cdn 14400 IN TXT
"IDIpIFRyYWluIG1vbmtleXMgdG8gam91c3QKU3RlcCAzKSBQcm9maXQ
KCldlIGhhdmUgYSBncm91cCB0aGF0IG1lZXRzIEZyaWRheXMgYXQgbWl
kbmlnaHQgdW5kZXIgdGhlCmJyb29rbHluIGJyaWRnZSBhbmQgdGhlIHBh"

file1.part3.cdn 14400 IN TXT
"c3N3b3JkIGlzIHNpYyBzZW1wZXIgdHlyYW5uaXMuCg=="

The receiver simply has to request all parts of the file, reassemble, and decode it. I’ve included an example program that does just that (both CDN client and server).

# ./server --path example_data
...

# ./client --domain virtserve.com --list
Inode      Size         Path
------------------------------------
4068250    254          Epicfail.txt
4068229    283          Important_Plan.txt

# ./client --domain virtserve.com --get 4068250
<gh0st-> epicfail.c?
<matja> bysin wrote that
<bysin> its 3000 lines of nothing but preprocessor macros that turns gcc into a tetris game
<matja> if you distcc it, can you play multplayer?
<bysin> hold on, i'll #include you on the next round
<matja> thx

In the program above, the first request for a file uses the CDN server and any subsequent requests do not, since the public DNS server has it in cache. I look forward to seeing streaming videos via DNS in the future.

Click here to download the DNS CDN Source Code

For those of you who have the new Nehalem processor from Intel, there’s an interesting new instruction that is used to speed up calculating checksums called CRC32. This instruction is part of the SSE4.2 set, and just like most SSE instructions, its fairly useless. But I just spent my hard earned money on a new processor and I’ll be damned if I don’t get my moneys worth, so here’s my evaluation of CRC32.

We’ll start off with a standard 32-bit checksum function:

uint32_t slowcrc_table[1<<8];

void slowcrc_init() {
	uint32_t i, j, a;

	for (i=0;i<(1<<8);i++) {
		a=((uint32_t)i)<<24;
		for (j=0;j<8;j++) {
			if (a&0x80000000)
				a=(a<<1)^0x11EDC6F41;
			else
				a=(a<<1);
		}
		slowcrc_table[i]=a;
	}
}

uint32_t slowcrc(char *str, uint32_t len) {
	uint32_t lcrc=~0;
	char *p, *e;

	e=str+len;
	for (p=str;p < e;++p)
		lcrc=(lcrc>>8)^slowcrc_table[(lcrc^(*p))&0xff];
	return ~lcrc;
}

Not including the table setup, the standard checksum function took 0.30 seconds to process a random 64 MB string. Unfortunately, the compiler I’m using currently doesn’t support SSE4.2 instructions, so I’m forced to write the hardware checksum function in byte code.

uint32_t fastcrc(char *str, uint32_t len) {
	uint32_t q=len/sizeof(uint32_t),
		r=len%sizeof(uint32_t),
		*p=(uint32_t*)str, crc;

	crc=0;
	while (q--) {
		__asm__ __volatile__(
			".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
			:"=S"(crc)
			:"0"(crc), "c"(*p)
		);
		p++;
	}

	str=(char*)p;
	while (r--) {
		__asm__ __volatile__(
			".byte 0xf2, 0xf, 0x38, 0xf0, 0xf1"
			:"=S"(crc)
			:"0"(crc), "c"(*str)
		);
		str++;
	}

	return crc;
}

The hardware accelerated checksum instruction processed the same 64 MB of random data in 0.05 seconds. That’s around 6 times faster then the standard checksum function.

Not many people know this, but the C language (with the help of gcc extensions) can support templates and lambda expressions.

I know I’m going to get emails / comments about how I butchered the C language, and how Dennis Ritchie is turning in his grave (hes dead right?). So let me start out with a word of caution, this is for educational use only, and is not intended to be used in production code.

We start off with a little known gcc extension that allows functions to be declared inside of functions. These functions are normally only accessible from inside the scope in which it was declared.

void parent() {
    int child() {
        return 42;
    }
    printf("%d\n",child());
}

Theres also a gcc extension that allows you to nest instructions inside of scope operators, where the instructions are evaluated and returned.

void parent() {
    int a = ({ int n=17; n+=25; n; });
    printf("%d\n",a);
}

If we were to combine these two examples we can have a scope operator return a function pointer to a nested function. The result would look very similar to a lambda expression, but in C! FYI: You can use the dollar sign as a symbol name.

#include <stdio.h>

void eval(int(*func)(char*)) {
	func("lambda");
	func("expression");
}

void main() {
	int (*func)(char*);
	func = ({ int $(char*str){ printf("Test: %s\n",str); } $; });
	eval(func);
}

And here is the expected output:

Test: lambda
Test: expression

So here’s where it gets tricky. You can create a template class in C if you combine lambda expressions with structures and an incredibly large macro (what Mat Anger likes to call Uber-Macros ©2010).

#include <stdio.h>
#include <stdlib.h>

typedef struct stack {
    int (*push)(struct stack*, ...);
    void *(*pop)(struct stack*);
    void *ptr;
    int length;
} *stack;

#define stack_new(T)                                                  \
    ({                                                                \
        stack __n;                                                    \
        if ((__n=calloc(sizeof(struct stack),1))) {                   \
                                                                      \
            __n->push=(void*)({int $(stack n, T p) {                  \
                T *np;                                                \
                if (!(np=realloc(n->ptr,sizeof(*np)*(n->length+1))))  \
                    return 0;                                         \
                np[n->length++]=p;                                    \
                n->ptr=np;                                            \
                return 1;                                             \
            }$;});                                                    \
                                                                      \
            __n->pop=(void*)({T *$(stack n){                          \
                T *np;                                                \
                if (!n->length)                                       \
                    return (T*)0;                                     \
                np=n->ptr;                                            \
                return &np[--n->length];                              \
            }$;});                                                    \
                                                                      \
        }                                                             \
        __n;                                                          \
    })

void main() {
    stack p;
    int *num;
    char **str;

    p=stack_new(int);
    p->push(p,42);
    p->push(p,666);
    printf("%d\n",*(num=p->pop(p)));
    printf("%d\n",*(num=p->pop(p)));

    p=stack_new(char*);
    p->push(p,"template");
    p->push(p,"class");
    printf("%s\n",*(str=p->pop(p)));
    printf("%s\n",*(str=p->pop(p)));

}

As you can see, we created a pseudo-template that took a type, and it generated function pointers based upon the type. Here is the expected output:

666
42
class
template

Using those techniques I was able to create a small container library for C. It has map, list, and array objects that can be used in a syntax almost as easy as its C++ counterpart:

c_object n;

n=c_array_new(int);
c_insert(n,5);
c_insert(n,512);
c_insert(n,-125);
c_foreach(n,t_int) {
	printf("%d\n",t_int);
}
c_free(n);

c_object n;
c_pair(char*,int) t_map;

n=c_map_new(char*,int);
c_append(n,"test",4);
c_append(n,"foo",12345);
c_append(n,"bar",-423);
printf("foo is most definitely %d\n",c_at(n,"foo"));
c_erase(n,"foo");
c_foreach(n,t_map) {
	printf("%s = %d\n",t_map.left,t_map.right);
}
c_free(n);

Click here to download the Container Source Code