November 25, 2008
November 9, 2008
Last weekend I had the pleasure of photographing my friends Christoph and Manuel Mitasch, aka Jonglissimo, a world-class club passing duo, holders of four club-passing world records and two-time IJA stage competition gold medal winners.
We did the first shooting session at the Stephansplatz at around three in the morning. It was seriously cold but – our reason for shooting at such an uncommon hour – there were almost no people there:
After a few hours of sleep we had another session in a studio, where I learnt a few things: Motion-freezing juggling photos tend to suck. Even if you shoot from an uncommon angle they’re barely more than tolerable:
Shooting with glowing props is much more interesting:
Five club double backcrosses – I should have shot this from a ladder and with a longer exposure:
Club swinging sucks, but it looks kinda cool:
Shooting people while they’re jumping is fun:
Even more so if you throw stuff at them while they’re in the air:
Obligatory back-lit portrait:
Until about a week ago Mono’s Monitor implementation, which is used for synchronized methods and the lock statement, was comparatively slow. Each Monitor.Enter and Monitor.Exit called into unmanaged code, which is very inefficient compared to a normal method call. We improved this situation by implementing fast-paths that can be called cheaply and that can handle most cases.
The fast-paths come in two varieties: Portable fast-paths, implemented in CIL code, and native fast-paths, in hand-optimized assembler code. We only have assembler fast-paths for x86 and AMD64, as those are the most-used architectures that Mono runs on.
I did some micro-benchmarking to compare the fast-paths with the old unoptimized implementation. Each of the tests does 100 million calls to synchronized methods. Two of the tests call static methods, the other two non-static ones, and two of the tests call empty non-recursive methods whereas the other two call recursive ones.
Here are the results for my x86 machine (2.16 GHz Core Duo):
The blue bars represent our old implementation. The orange bars stand for the IL fast-paths and the yellow bars for the assembler fast-paths. The green bars represent the run-times for non-synchronized methods.
The results for my AMD64 machine (1.86 GHz Core 2) look quite similar:
To finish things off I also ran the benchmark on Microsoft .NET on my x86 machine. Here is the comparison to Mono with the assembler fastpaths: