Nat!'s Web Journal

Mettigel Apotheosis

2012-05-06T16:03:44Z

I achieved my last remaining goal. I made it! 999,999,999 in Ducks. It took a lot of practicing to get it. It's quite possible, that I will resign from playing Rocksmith now.

No more non-removable battery products for me

2012-03-31T21:40:19Z

(unless I need it as a development target). I've decided, that I will not buy another product with a battery that can not be removed or that doesn't have an on/off switch so that power can be cut. It's a matter of principle. If I want to turn of the juice, then I decide, and no buggy hardware can interfere. Right this moment I have a Macbook Air, which is just stuck. I know in about an hour it will be good enough to boot again.

Mettigel Supertrumpf

2012-03-29T23:41:43Z

So now I am also the benign ruler of Big Swing Baseball, the last of the six Rocksmith games I wanted to dominate. This was a good fight with Ikel_The_Frog.

My last remaining goal is to score 999.999.999. on Ducks. Current highscore is 690.000.000 but it wasn't saved, because the internet connection failed :(

Reign in Mett

2012-03-16T00:13:48Z

I am enjoying a comfortable reign in the Ducks game. I finally pushed through to level 39 and I can almost taste 40, where I hope, I hit 999.999.999. I added another game to my kingdom: Dawn of the Chordead. Not sure how long that will last though. I guess at some time I want to see level 100. My goal of 1000 chains in Superslider was reached, a good thing because there's a revolt brewing… I had to fight a bit to keep Scale Runner in my possession. I'd think in a pinch, there is a million or so I can still make. The Superducks #1 slot is still secure, because I played to level #41. Finally I am trying to conquer the sixth and most complicated mini-game Big Swing Baseball. but I am only #2:

LOL @ SPON

2012-03-01T20:12:33Z

Ausgerechnet der SPIEGEL. Auf der einen Seite nervt einen Sohnemann Augstein mit seinem altjüngerferlichen Moralisierungsblog, das päpstlicher als der Papst ist. Aber hintenrum verkloppt der SPIEGEL einfach Promo-CDs, die ihm geschickt werden.

Am besten wäre, jetzt jeden Tag einen neuen Artikel darüber zu schreiben. Der Fundus an verhökertem Promomaterial sollte ja unerschöpflich sein. Wenn es mal nichts neues gibt, dann halt Reaktionen zu den vorigen Artikeln von Gegnern und Geschädigten des SPIEGELs sammeln. Dann damit wieder den SPIEGEL konfrontieren.

Egal wie der SPIEGEL reagiert, es kann nur zuwenig oder ganz falsch sein. Da haben wir dann den nächsten Artikel. Ev. auch mal ein Artikel über Nepotismus einstreuen. Wieder Reaktionen sammeln, usw. pp.

Endgame wäre dann der Rücktritt eines Verantworlichen. Und die Welt wäre wieder ein besserer Ort.

Mettigel Rising

2012-02-17T00:45:51Z

(not Lucifer rising :)

I finally got a score of 383M in Rocksmith's Guitarcade game "Ducks", thats going to be hard to beat. It's hard for me to get even get near the score, though I score in 100M-200M range consistently. But i have a dream, and that's 999M.

With a lot of effort i finally nabbed first place in Scale Runner too. I think the theoretical maximum is 165M, so there is still room for improvement.

Finally Super Slider is all mine, though the next guy seems to be trying to change that. Playing to level 255 is an affair that takes an hour or so. There is no maximum in this game it's more a question of stamina. Maybe I should target 1000 chains here.

Importing CVS into git on Mac OS X

2012-02-15T12:04:21Z

It's pretty simple, but you need to set some git config variables to make the import go smoothly.

First up, you need cvsps. The currently stable cvsps version 2.1 works better with the git version 1.7.4.4, that Xcode gave me, so download it.

Building cvsps is just make and installing into /usr/local is just sudo make install

Then get your CVSROOT environment variable set properly.

Finally you need to configure some variables in git, as they may be set to values, that preclude a working import. Here 's a shell script, which isn't foolproof, but useful enough.

#! /bin/sh

rm -rf .git

#
# my settings
# core.autocrlf=input
# core.safecrlf=true
#

old_autocrlf=`git config --get core.autocrlf`
old_safecrlf=`git config --get core.safecrlf`
old_encoding=`git config --get i18n.commitencoding`

git config --global core.autocrlf  false
git config --global core.safecrlf  false
git config --global i18n.commitencoding MacRoman

git cvsimport $*

if [ "$old_autocrlf" != "" ]
then
   git config --global core.autocrlf "$old_autocrlf"
else
   git config --global --unset core.autocrlf
fi

if [ "$old_safecrlf" != "" ]
then
   git config --global core.safecrlf "$old_safecrlf"
else
   git config --global --unset core.safecrlf
fi

if [ "$old_encoding" != "" ]
then
   git config --global i18n.commitencoding "$old_encoding"
else
   git config --global --unset i18n.commitencoding
fi

My Kimble Moment with Ducks and Superducks in Rocksmith (PS3)

2012-02-09T00:18:50Z

But I didn't get no cake.

Actually a score < 100 million is not that great for me, but it seems to be good enough for the world.

Ok. 999.999.999 is pretty much unbeatable, but getting it in Superducks is not really that hard. But I don't want to second guess these results too much :)

I stole my moniker from these guys.

Using --eh-frame-header when using -fobjc-exceptions GNU/Linux: good, but not necessarily good enough

2012-01-06T16:41:37Z

This is on Linux, with the gcc compiler (4.6). Not OS X.

When you compile code with -fobjc-exceptions, you presumably do that to somewhere execute a throw. Lets say, this is my callstack:

`abort`	// glibc
`objc_exception_throw`	// libobjc
`-[MyClass methodThrowingAnException]`	// myclass.so
`myClassMethodBouncer`	// myclass.so
`function_with_a_callback`	// thirdparty.so
`-[MyClass waitingForAnException]`	// myclass.so
`main`	// main

What has happened ? I compiled all the MyClass code with -fobjc-exceptions and even did not forget to link the resulting shared library with --eh-frame-header. So all my code and libobjc.so has PT_GNU_EH_FRAME information, which is necessary for the "modern" C++ like stack unwinding.

Still not good enough. The third party library code function_with_a_callback, was not linked with --eh-frame-header and the unwinding stops right there. No catch handler can be found and objc_exception_throw treats this as an uncaught exception.

An example for the rule, that with every increase of complexity, there is also an increase in brittleness.

Measuring context switches :: a small expedition. Part IV

2011-12-02T00:33:09Z

The results are all similiar for the other CPUs/Cores except for CPU0, where it's deterministically different each time:

(27 -> 540) 0.002849s

18859 : 0
19009 : 0
19197 : 0
19306 : 0
19438 : 0
19444 : 0
19444 : 0
19600 : 0
19650 : 0
19765 : 0
19874 : 0
19903 : 0
19912 : 0
19941 : 0
19965 : 0
20441 : 0
20547 : 0
20617 : 0
20629 : 0
20880 : 0
21409 : 0
21862 : 0
23376 : 0

First thing to notice, the program only runs for 0.0028s. That means the frequency of context switches is much higher on CPU 0. 100 times higher in this case. The duration of each context switch is also longer, lets say the average is 20000 cycles making that about 7 times longer.

Measuring context switches :: a small expedition. Part III

2011-12-01T22:06:25Z

Lets see some results:

(24 -> 480) 0.229874s

3356 : 18
3365 : 18
3376 : 18
3382 : 18
3388 : 18
3397 : 18
3403 : 18
3409 : 18
3412 : 18
3412 : 18
3415 : 18
3421 : 18
3429 : 18
3429 : 18
3432 : 18
3456 : 18
3479 : 18
3585 : 18
3647 : 18
3691 : 18
4471 : 18
4756 : 18
8265 : 18

The program took about 0.23s to run, in that time it received 23 context switches. That means a context switch happened every 0.1s i.e. 10Hz. Thats not suprisingly the documented preemption time slice for Mac OS X.

A context switch on CPU 18 took on average about 3.400 cycles. One may assume at these times, that the CPU is otherwise idle.

10 times 3.400 cycles is the approximate number of cycles lost per second: 34.000 cycles. Since my CPU is running at about 3.4GHz with Turboboost, that means - in relation to 3.400.000.000 cycles - context switching lost me about 0.001 % performance.

Thinking about this opens up some interesting questions, but lets gather another CPUs results to get some more data... Next time.

Measuring context switches :: a small expedition. Part II

2011-12-01T00:44:20Z

Here is the main routine, that is used for testing. Can't really say more than what's in the comments. The program will wait until a number (currently 23) context switches have hit it. It then prints out the number of seconds elapsed and a list with the durations of said context switches.

#include 
#include 
#include 
#include 
#include 
#include 


extern unsigned long long   _rdtsc();
extern unsigned int         _apicID();


typedef struct
{
   unsigned int   gap;
   unsigned int   apicID;
} context_switch_record;


static int   compare_context_switch_record( context_switch_record *a, 
                                            context_switch_record *b)
{
   return( (int) a->gap - (int) b->gap);
}


int   main( int argc, char *argv[]) 
{
   context_switch_record   infos[ 23];
   unsigned long long  a, b;
   unsigned long long  normal;
   unsigned long long  diff;
   unsigned int        i;
   struct timeval      start;
   struct timeval      stop;
   struct timeval      elapsed;
   
   gettimeofday( &start, NULL);

   //
   // establish a "gap" between two rdtsc() calls, that 
   // should be considered as normal (no interrupt)
   //
   a      = _rdtsc();
   b      = _rdtsc();
   normal = (b - a) * 20;
   printf( "(%qd -> %qd) ", b - a, normal);
   
   for( i = 0; i < sizeof( infos) / sizeof( context_switch_record); i++)
   {
      b  = _rdtsc();
      for(;;)
      {
         a    = b;
         b    = _rdtsc();
         diff = b - a;

	 //
	 // if the delay between a and b is to large
	 // then record it
	 //
         if( diff > normal)
            break;
      }
      assert( diff <= INT_MAX);
      
      // 
      // record cycles spent and current cpuID
      // 
      infos[ i].gap    = diff;
      infos[ i].apicID = _apicID();
   }
   
   gettimeofday( &stop, NULL);

   //
   // compute time spent waiting for n context switches
   //   
   elapsed.tv_sec  = stop.tv_sec - start.tv_sec;
   elapsed.tv_usec = stop.tv_usec - start.tv_usec;
   if( stop.tv_usec < start.tv_usec)
   {
      elapsed.tv_sec -= 1;
      elapsed.tv_usec = 1000000L - start.tv_usec + stop.tv_usec;
   }
   printf( "%d.%06lds\n\n", (int) elapsed.tv_sec, (long) elapsed.tv_usec);
   
   //
   // output data and done
   //   
   qsort( &infos, sizeof( infos) / sizeof( context_switch_record), 
          sizeof( context_switch_record), 
          (void *) compare_context_switch_record);
   
   for( i = 0; i < sizeof( infos) / sizeof( context_switch_record); i++)
      printf( "%u : %u\n", infos[ i].gap, infos[ i].apicID);

   return( 0);
}

Here is the Xcode Project.

Measuring context switches :: a small expedition. Part I

2011-12-01T00:30:07Z

First up some assembler code. It just works for i386 currently. The first routine gives me the core number the code is currently executing under (see Intel Application Note 485 for more details)

   .text
   .globl __apicID
__apicID:
   push     %ebx

   movl     $0x1,%eax
   cpuid

   mov      %ebx, %eax
   shr      $24,%eax

   popl     %ebx
   
   ret

and the second function returns the number of cycles elapsed since power on

	.text
.globl __rdtsc
__rdtsc:
	rdtsc
	ret

I haven't coded i386 assembler much, it probably shows :)

Small shell script to generate passwords

2011-11-11T11:36:39Z

#! /bin/sh
#
# Coded 2011 by Nat! - Mulle kybernetiK
#
# Public Domain
#
# Creates a password with pwgen 
#
#    http://sourceforge.net/projects/pwgen
#
# Advantages of passwords generated with this
# code:
# 
# 1) are "green" in Mac OS X password security 
#    check
# 2) do not contain characters that can be 
#    easily confused with one another in 
#    non-serif fonts
# 3) do not contain z and y or any special 
#    characters, so german or english keyboard 
#    doesn't make a difference
# 
OPTS="-s -B -c -n"

LENGTH=${1:-24}
shift

USER_OPTS="$*"
if [ "$USER_OPTS" != "" ]
then
   OPTS="$USER_OPTS"
fi

pw=""

while [ "$pw" = "" ]
do
    candidate=`pwgen $OPTS -1 $LENGTH 1`
    pw=`echo "$candidate" | grep -v '[zZyY0OlI1]'`
done

echo "$pw"

UnitKit fixes updated on bitbucket.org

2011-11-10T13:53:35Z

I updated my bitbucket.org project unitkit-fixes so that UnitKit works more nicely with the current Xcode. And for me the current Xcode is 3 :)

It's one of a few experimental projects I put on bitbucket.org. Eventually I will probably migrate it back to Mulle kybernetiK, because the added "social" doesn't really do anything for me.