A Rubble of Bits

I spent the first week or so of my freedom working on the chicken coop.  It probably came out over engineered.
There are several public photo albums of the project on my facebook account: Coop Construction is the main one about the coop.
Here’s a photo, but see the album for many more.

I now have time to work on the chicken coop.
SiCortex wasn’t able to find financing in the current climate, and is shut down pending an asset sale.  See, for example, http://www.nytimes.com/external/gigaom/2009/05/28/28gigaom-on-the-block-sicortexs-delorean-style-green-super-23152.html
I haven’t written much here about the company or the technology, but I will do some more of that, because in the five years I spent working at SiCortex I learned a lot, and some of those things will be valuable to others somewhere down the line.
I follow the news of web 2.0 incubators, and the ease and low overhead of software startups, and you know, I am not impressed. SiCortex didn’t fail for lack of technology, or vision, or customers, but from the poor timing of having to raise money during a recession. I loved what we were doing. It wasn’t easy but we did it. We started with a pile of sand, and some ones and zeros, and built the most energy efficient high performance computers ever.
I know it is trite, but JFK pretty well nailed the concept of working on things that are worth doing.

We choose to go to the moon in this decade and do the other things, not because they are easy, but because they are hard, because that goal will serve to organize and measure the best of our energies and skills, because that challenge is one that we are willing to accept, one we are unwilling to postpone, and one which we intend to win, and the others, too. 

Best wishes to all my colleagues.

Today I am at the Marriott Courtyard near BWI. They have free wifi.  Actually it isn’t bad. Go Marriott. Unfortunately it is still screwed up in three ways:

• iPhone access is entirely broken. When you try to use the web browser you get an infinite series of “click here to continue”
• https access doesn’t work.  I have configured google so that it always connects with TLS.  No intercept screen or advice, just fail.
• When you finally think to try http, you get the incredibly busy ibahn login screens, with the free option, but then you get this acceptance screen:

May I rant?  Showing customers the stack trace of your broken application is Not Good.  And Microsoft! Thank you for advertising that your “.net” is so helpful.  I’ll be sure to not select .net for my next web project.

As I was planning this post, I thought I would check the fine print in the End User License Agreement for Microsoft Office Home and Student 2004 for the Mac.
I can’t find it.
The Microsoft website does have the license for the Windows version of Home and Student 2007, but only as a self-extracting EXE file.  (A) I don’t have a way to read that, since my XP won’t run under VMware and (B) Office on the Mac says to load the original CD to see the license.  Well the CD is at home.
For such a lawyer-crazed company as Microsoft, they sure make it hard to find out what their rules are.  I guess that is deliberate.
Anyway, AFAIK, I can’t use Home and Student for work related things.  Consequently, last week when I gave a talk at Microsoft Research Silicon Valley, I used Keynote.

May I rant?
I have a Macbook Pro, which I like, well, quite a lot.  When I first got it, I gave it to my wife to run Windows XP, using Boot Camp.  Why? Because I love her more than the Mac.
It turned out that she doesn’t like the trackpad having only one button, so I got it back, and I happily run MacOS.
The copy of Windows XP on the Mac is an OEM copy for computer builders, which I think is fine, since I replaced the hard drive.
Last night I had to run Windows in order to run Turbotax Business, which unaccountably is only available for Windows.  I fired up Vmware Fusion and had it boot the boot camp partition… and Windows refused to run because it had been installed on a different computer.
Um, no, Microsoft, this is NOT a different computer. I added a layer of emulation, but every transistor and wire is identical to before.  I am not sure how this behavior is supposed to benefit Microsoft shareholders.
And yes, by rebooting directly into Windows, it works fine.

I am so mad at myself for forgetting to take a photograph of this.
Earlier this week I spent a few days at the famed Claremont Resort and Spa in Berkeley, California.  I was there for the Hot Topics in Parallelism workshop, but that isn’t the point.
It used to be that in bathrooms, one had a “heat lamp.” This was a dull red PAR type bulb in a ceiling fixture, typically with a twist knob timer.  You turn it on and it runs for 10 minutes or whatever while you take a shower and dry off.
Now I know that California is Eco-Groovy, and Berkeley is about the epicenter of Eco Groovyness, but at the Claremont, they have replaced the bathroom heat lamps with, … wait for it… compact fluorescent bulbs.
They still have the 10 minute twist knob timers and everything.

Recently I’ve been writing an implementation of OpenSHMEM for the SiCortex platform. OpenSHMEM is a communications API that lets you write PGAS programs in C or FORTRAN.  PGAS stands for “partitioned global address space.”  A PGAS program is a parallel program that can run on a lot of cores or cluster nodes simultaneously. Each processing element (PE) can read and write the address spaces of the other PEs, but the program “knows” that the global address space is partitioned into a bunch of local address spaces. This is either taken care of by the language, like in UPC (unified parallel C) or by the programmer explicitly using something like OpenSHMEM.
All this is just introduction.  OpenSHMEM derives from the Cray/SGI SHMEM API, and one of the things it has are a lot of API calls that differ only in the datatypes of their arguments.
For example, OpenSHMEM has

extern void shmem_short_wait(short *var, short value);
extern void shmem_int_wait(int *var, int value);
extern void shmem_long_wait(long *var, long value);
extern void shmem_longlong_wait(longlong *var, longlong value);
all of which wait for a local variable to be set by some remote PE.

I am a lazy programmer.  I should write the same routine four times?  Instead, I used some C preprocessor magic and wrote this:

#define EmitWait(type)
void shmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
EmitWait(short);
EmitWait(int);
EmitWait(long);
EmitWait(longlong);
This uses the “token pasting” feature of CPP to write the proper function names for the different versions of the routine.
A bit later, I learned of the Global Address Space Performance initiative, a project at the University of Florida. By putting the performance analyzer library in front of the OpenSHMEM library on your search path, you can instrument the communications functions in your program without recompilation. This works via dynamic linking. The program calls shmem_long_wait, which is intercepted by the performance library. The library does whatever it does, then passes the call to pshmem_long_wait, which is provided by the OpenSHMEM implementation.
You can do this by providing two OpenSHMEM implementations, one with the names like shmem_long_wait, which is used when not profiling, and one with names like pshmem_long_wait, which is used when you are.  Alternatively, you can use the “weak symbol” feature of the GNU runtime. A weak symbol defines something, but it doesn’t complain if an alternative definition is present in the address space.  To make this work, you write all the functions as pshmem_long_wait, then add a weak symbol definition for the standard versions, like this:

#pragma “weak shmem_long_wait=pshmem_long_wait”

Now everything is in one library, and there is no performance penalty when you aren’t using the instrumentation library.
Well the obvious way for the lazy programmer to do this is like this:

#define EmitWait(type)
#pragma “weak shmem_##type##_wait=pshmem_##type##_wait”
void shmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
but this fails because you can’t use the C preprocessor to write C preprocessor items like #pragma. No problem! C99 provides an alternate version of pragma exactly for this reason. The GNU info file says:

C99 introduces the `_Pragma’ operator.  This feature addresses a major problem with `#pragma’: being a directive, it cannot be produced as the result of macro expansion.  `_Pragma’ is an operator, much like `sizeof’ or `defined’, and can be embedded in a macro.

Now I can write my macro with

_Pragma(“weak shmem_##type##_wait=pshmem_##type##_wait”)

right? Well, no. token pasting doesn’t work inside strings!  You can’t build up string constants this way. No problem! GCC automatically concatenates adjacent string constants into a single longer string. This was originally done so you can avoid line wrapping, but whatever. I can write this

_Pragma(“weak shmem_” #type “_wait=pshmem_” #type “_wait”)

This is using a different preprocessor feature, called “stringification” in which #type is expanded and turned into a string constant.
Unfortunately, this doesn’t work either, because _Pragma is processed earlier in the compiler than other uses of string constants, and before the string concatenation happens.  _Pragma has to have exactly one string constant as an argument.
How much time have I spent on this?  How many cases of _Pragma do I have to write by hand?  I give up.  The final version is

#define EmitWait(type)
void pshmem_##type##_wait(type *var, type value)
{
while (*((volatile type *) var) == value) shmem_progress();
}
_Pragma(“weak shmem_short_wait=pshmem_short_wait”)
_Pragma(“weak shmem_int_wait=pshmem_int_wait”)
_Pragma(“weak shmem_long_wait=pshmem_long_wait”)
_Pragma(“weak shmem_longlong_wait=pshmem_longlong_wait”)
_Pragma(“weak shmem_wait=pshmem_wait”)
EmitWait(short);
EmitWait(int);
EmitWait(long);
EmitWait(longlong);

It has more typing than ought to be necessary, but I got over it.

Internet access is free at cheap hotels and costly at expensive hotels.  Costly in money or inconvenience.  What I want from hotels is a friction free experience, and mostly that is easier at mid-range hotels like, say, Hampton Inn, than it is at “better” hotels.
Case in point – the Omni Austin.  I stayed there during the Supercomputing 2008 conference, and internet access is $9.99 per day or free for members of the frequent sleepers club. The system intercepts your web access until you log in by entering your frequest guest number or agreeing to the charge.  The user experience is hideous.
Here’s what I wrote to the hotel: