Logical Inferences Per Second (LIPS) vs. Horsepower

Of course we're a little jealous of those developers who get to develop those fun and nifty IPhone apps! Perhaps we're just a tad bit curious too. But for the moment we are absolutely in the grips of a very different kind of software development.

It is a tricky distinction to make when we talk about the computer in terms of solving the problem as opposed to being part of a solution to problem. I guess in some ways its all a matter of perspective.

So if we can put it another way, we are currently involved in developing software that uses the process of inference to reach conclusions that when applied or understood represent the solution to some (normally nasty) problem or set of problems. This inference process usually takes the form of logical deduction, induction, or abduction. We want to contrast the process of inference to that of computation. So instead of focusing on the work required for a computation we focus on the work required for an inference. In particular we look at how many logical inferences an agent might use to solve some problem. Normally we are concerned with how many inferences an agent might use in the worst case scenario to solve the problem. Once we have some idea of how many inferences that is then we know how big the problem space is and how much computing power we could potentially need. For instance, in our 19 emails project, the worst case scenario for our agent was 19! * 3000 inferences. From a hardware perspective if I have a quad core processor and each processor is clocked at 1.8 GHZ, what are we talking about in terms of LIPS? That is 1.8 GHZ = How many LIPS?

Much like horsepower the metric of LIPS is from days gone by. The researchers at ICOT and the Fifth Generation Project used it as a way to measure system performance. ICOT had a target of 100 MLIPS (million LIPS) to 1 GLIPS (billion LIPS). At the time 1 Logical Inference Per Second took approximately 100 machine instructions. But who knows what machine instructions are these days? (I heard recently that they are similar to lines of Javascript.) Remember parallelism even massive parallelism was at the heart of ICOT and the Fifth Generation project. They produced answers in that project for questions that we are really just now asking today. In that project LIPS was the basic unit of measure for system performance. The ghosts of ICOT have presented me and Tracey with a very seductive argument and we are currently on some DaVinci-Code-Indiana-Jones-Raider-of-the-Lost-Ark adventure to discover the true path to massive parallelism by looking at the stones that were turned over by ICOT and the stones that weren't. At one point in time horsepower was a very hands on metric. The common man knew how many horses it took to plow a plot of land, pull up a tree stump, or get a stage coach to town in a day. At some point when steam engines are introduced horsepower was the metric to use to compare how much work a steam engine could get done. I'm still a little baffled why 400 horsepower is still used as the metric for my little SUV. I have no idea how many horses it takes to pull up a tree trunk or plow a field. I am sure it has meaning for somebody somewhere that has to get their hands dirty. LIPS has a similar function for those of us stuck with the totally futile task of trying to solve AI-complete, or AI-hard problems. Somebody manages to think of our cute little SUV in terms of 400 horsepower and Tracey and I have to think of duo, quad, and eight core * eight hardware thread processors in terms of LIPS. There is a very important relationship between LIPS and our ability to cope with massive parallelism. Stay tuned ...

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.