Any Hope for the Sun Worshippers?

Posted by Cameron Hughes, Tracey Hughes @ 12:31:PM | April 28, 2009

At Ctest Labs, we have (or had?) really big plans for the Sun Ultrasparc T2 and maybe Niagra 3. These are very nice boxes and fit our multicore needs just fine. But now that Oracle is acquiring Sun, what will become of the Ultrasparc T1, T2, and that whole line of multicore computers that had CMT?

We already have a T1 as part of our Pantheon cluster at Ctest. It provides us with 8 Sparc V9 cores. The V9 cores are 64 bit technology. Each core has a L1 cache. This diagram shows simple layout of the Ultrasparc chip:

The eight cores all share a single floating-point unit. Each core has a six-stage pipleline. Our T1 keeps company with two dual processor Sun Blade 2000s, a Quad-Processor Sun Ultra 80, a few Sun Ultra 60s, a dual-core Opteron, and two Cell processors by way of the PS3. Together these boxes make up our Pantheon cluster. We tie all this together with MPI and PVM. Although PVM is not as hot as it once was, it works, its simple, and we like the dynamic node management. We do allot of our big bang theory stuff with MPI.

We were hoping to add the Sun Ultrasparc T2 to our Pantheon mix this year. The configuration we had in mind has 8 cores running at 1.4 Ghz, 64 hardware threads, and 4 MB of level 2 cache. But its not entirely clear what Oracle's plans are for the hardware division at Sun. Conventional wisdom says that Oracle will continue to support and feed the growth of Java. That's a good thing. Oracle also has a vested interest in keeping Solaris alive and well. That's another good thing. At Ctest, we use Solaris both on X86 and Ultrasparc technology. Solaris has quite nice support for multithreading and parallel programming. So with this Oracle thing now underway, we think the software from Sun is safe, but what about the hardware? It would be a tragedy for the advancement of multicore technology if the Sun hardware plans go the way of the dinosaur. That would also dampen our spirits here at Ctest Labs where Sun technology is a major part of our multithreading and parallelization strategies at the hardware level. Sun's T1000 and T2000 servers definitely brought a different flavor of multicore to the table, and as far as we're concerned Sun's C++ compiler's multithread support, OpenMP support are absolutely top rate. Sure, we can get by on Opterons from AMD, but there's a special place in our hearts for Sun. We grew up with and cut our teeth on Sun technology. We can only hope that Oracle does the right thing with the hardware division at Sun. But no matter how things turn out with Sun and Oracle, we will keep our Sun equipment running until the wheels fall off, third-party suppliers run out of parts, and eBay goes silent.

This Week's Multicore Reading List
MATLAB and Google App Engine
Logging In C++ : Part 2
 Improving log granularity
A Conversation with BitMagic's Developer
Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic

All Feature Stories

Real World Parallelism Webinar Series

  • November 17, 2009
    Visual Effects for Animation - presented by DreamWorks Animation
    Speaker: Ron Henderson (Bio)

    Ron Henderson manages the FX Tools group at DreamWorks Animation, where he is responsible for developing physical simulation and procedural modeling tools. These systems have been used for key visual effects in recent films such as Kung Fu Panda and Monsters vs. Aliens (March 2009).

    Prior to joining DreamWorks in 2002 he was a senior scientist at Caltech with a joint appointment to the Applied Math and Aeronautics departments, where he worked on efficient techniques for the direct numerical simulation of fluid turbulence.

    Abstract:
    In this webinar, Ron Henderson will show examples of visual effects, from hair and feathers to smoke and fire, from a variety of DreamWorks Animation feature films. He will discuss in general terms the kinds of techniques used to achieve particular visual effects. Finally, Henderson will show a detailed breakdown of the dam-breaking scene from Madagascar: Escape 2 Africa, demonstrating how different elements of key frame animation, simulation, and rendering are combined in a real production shot.

  • December 1, 2009
    A Quick and Easy Way to Parallelize a Legacy Codebase with Intel® Threading Building Blocks (TBBs)
    Speaker: Bernard Laberge, Avid, Senior Principal Engineer (Bio)

    Bernard Laberge is a senior principal engineer in the video editors division at Avid. During his seven years with the company he has been actively involved in the replacement of the legacy video processing engines used by Avid editors with a common hardware-abstracted, component-based video processing engine currently running on the CPU with SIMD optimized code, GPU, and dedicated hardware.

    Abstract:
    Learn how to overcome the limitations of a thread-based scheduler, including dealing with the absence of recursive parallelism support and the inefficient handling of unbalanced processing load. Bernard Laberge addresses how Avid resolved the expensive refactoring of their thread-based scheduler into a task-based solution by choosing Intel® Threading Building Blocks (TBBs). He explores how Avid was able to easily integrate the Intel TBBs into their video editor applications and more than 5 million lines of code.

  • December 15, 2009
    How to Use Intel® Parallel Studio to Streamline Code Development in a Multicore Environment
    Speaker: Matt Dunbar, Director for Performance Technology, SIMULIA (Bio)

    Matt Dunbar is the director for performance technology at SIMULIA. Since joining the company in 1993, he has worked on parallelization of the Abaqus suite of products, initially for shared memory architectures and more recently for distributed memory architectures. Dunbar has also been intimately involved in selecting both the hardware and software tools used in the development of the Abaqus product line.

    Abstract:
    Resolve elusive, costly multithreading errors quickly and efficiently with Intel® Parallel Studio. While many coding problems that lead to bugs in software applications are typically straightforward logic errors, errors in managing memory and in multithreading code can sometimes take weeks to months to diagnose and fix. Matt Dunbar explores how and why taking advantage of multicore processors through multithreaded code is critical for compute-intensive applications. While spotlighting his work on SIMULIA's Abaqus finite element solver, Dunbar addresses the need for multicore execution and shares his experiences using Intel Parallel Studio to streamline code development in a multicore environment.