Pandemonium Medicine Show

After a few days of fruitlessly searching the Internet for a procedure to upgrade my ZFS boot installation from 10u6 to 10u7 I contacted my Solaris oracle, Dave Clack and, of course he knew exactly how to do it. Since lots of people will undoubtedly need this procedure in the next couple of weeks, here it is. This procedure also works for OpenSolaris. Dave's instructions mount the DVD ISO using lofi loopback. If, like me, you are running you Solaris installations in VirtualBox then you can just mount the image as a virtual DVD. The procedure remains the same with a few path changes.

Upgrade a Solaris 10 ZFS Boot Installation from one "u" level to another

lofiadm -a /share/iso/solaris_dvd.iso mount -F hsfs /dev/lofi/1 /mnt pkgrm SUNWlur SUNWluu SUNWluzone SUNWlucfg cd /mnt/Solaris_10/Product pkgadd -d . SUNWlucfg SUNWlur SUNWluu SUNWluzone 10uX is currently installed version 10uY is the version number of the one you downloaded lucreate -c 10uX -n 10uY lustatus luupgrade -u -n 10uY -s /mnt luactivate 10uY init 6

EDIT: removed un-needed SUNWrmvolmgrr step.

One of the supposed C advantages is supposed to be that it offers greater opportunity for optimization. Maybe I have been looking at the wrong code lately but I see very little code these days that instruction-wise optimization, inline assembly or hand tweaking makes better. The biggest problem is not that careful optimization of small functions doesn't produce speed improvements but that those speed improvements are, overall, of marginal benefit. Here's some really bad code:

StinkoCode.java

static void main(String[] args) { List sortedArgs = new LinkedList(); for(String arg : args) { sortedArgs.add(arg); Collections.sort(sortedArgs); } System.out.println(sortedArgs); }

Even though this is just a contrived example, yes, I do regularly see code this inefficient. Would optimizing the sort() operation have much impact on the overall behaviour of this program? How about the choice of LinkedList? Would using a bulk insertion strategy such as addAll() help? If there are many arguments passed in the biggest gains would almost certainly come from sorting the arguments only once and possibly using a different data structure to store the strings. Let's try that again:

static void main(String[] args) {

    String[] sortedArgs = Arrays.copyOf(args, args.length);
    Arrays.sort(sortedArgs);

    System.out.println(Arrays.asList(sortedArgs));
}

As cautions against premature optimization suggest, is critical to carefully examine the causes your hot code is burning so many cycles before optimizing. Frequently the real problem is with the calling code and not the exact piece of code which shows up in the profiler as your hot spot. When planning optimizations it's usually best to look "up the stack" and evaluate the usage pattern for the bottleneck code being called before diving in to make a targeted fix. Most likely, at best, you'll only get a marginal improvement by making a local optimization. For the really big wins you should be focusing on the higher order causes.

A couple of weeks ago I heard Tom Waits' distinctive voice over a commercial on Hulu and immediately drew my attention because it was entirely unexpected. The commercial is a PSA for Feeding America. I now understand why Tom has chosen not to dilute the effect he gives the commercial by also shilling for Pepsi and Chrysler.

In the deep dark past there was this one commercial for Purina though. I find his intonation hilarious.

If that doesn't work you can suggest that you'll continue to use tables for formatting even after you convert to CSS or include multiple invisible iframes on every page.