Archives

Posts from Arch Robison (Intel) RSS

Arch Robison (Intel)

Arch is the architect of Threading Building Blocks. He was the lead developer for KAI C++. At Shell he worked on seismic imaging on a 256 node nCUBE. He has a Ph.D. in computer science from the University of Illinois.

Specification for Low Overhead Tool Annotations Released

By Arch Robison (Intel) (30 posts) on November 11, 2011 at 7:17 am
Comments (1)

Program analysis tools can be valuable for debugging program correctness and performance issues, even more so for multi-threaded programs.   Some of these tools need to know about certain events in the program. For example, race detection for Intel® Cilk™ Plus programs requires knowing precisely when spawn and sync events happen.  Similar events are necessary to analyze [...]

Continued ›

Category: Open Source, Parallel Programming, Software Tools

New Rules for Array Sections in Intel(R) Cilk(TM) Plus

By Arch Robison (Intel) (30 posts) on July 26, 2011 at 9:54 am
Comments (0)

Fans of Cilk Plus or language specifications may be interested in the revised specification of Intel® Cilk™ Plus posted at http://software.intel.com/file/37679/Intel_Cilk_plus_lang_spec_2.htm .   Clark Nelson did most of the work for turning the previous specification into something closer to standardese and illuminating ambiguities in the previous specification.  I'll mention two important changes that the new specification to [...]

Continued ›

Category: Parallel Programming, Performance and Optimization
Tags: ,

Lambda + std::move + Array Notation

By Arch Robison (Intel) (30 posts) on May 5, 2011 at 9:06 am
Comments (1)

Here is an interesting example of combining new language features. I needed to write a routine similar to std::copy, except that the routine needed to destroy its source sequence; i.e., revert it to raw memory.  I was amused that I could exploit both C++ 2011 and the Intel Array Notation extension to give the compiler [...]

Continued ›

Category: Parallel Programming, Performance and Optimization, Uncategorized

Detecting Theft by Hyperobject Abuse

By Arch Robison (Intel) (30 posts) on November 22, 2010 at 9:56 am
Comments (1)

Holder hyperobjects can be abused to detect work stealing.

Continued ›

Category: Parallel Programming
Tags: , , ,

Thread Parallelism Using Cilk Notation for C/C++

By Arch Robison (Intel) (30 posts) on September 13, 2010 at 7:43 pm
Comments (6)

Getting top performance out of  modern processors requires both SIMD and thread  parallelism.   Intel® Cilk Plus is an easy way to express both.   My first blog covered the SIMD part.   This blog explains the thread part. Background As outlined in the first blog, fork-join and SIMD parallelism can be combined to solve a [...]

Continued ›

Category: Open Source, Parallel Programming
Tags: ,

SIMD Parallelism using Array Notation

By Arch Robison (Intel) (30 posts) on September 3, 2010 at 6:56 am
Comments (0)

C++ programmers need not envy APL and Fortran90 anymore.

Continued ›

Category: Parallel Programming, Software Tools
Tags: , , ,

Seismic Duck goes Open Source

By Arch Robison (Intel) (30 posts) on August 28, 2010 at 7:42 pm
Comments (5)

Seismic Duck

Continued ›

Category: Open Source, Parallel Programming, Software Tools

Parallel Patterns in Seismic Duck – Part 3 (Vectorization and Tiling)

By Arch Robison (Intel) (30 posts) on August 7, 2010 at 9:08 pm
Comments (0)

How vectorization, tiling, and wide halo patterns speed up the Seismic Duck kernel.

Continued ›

Category: Parallel Programming

Parallel Patterns in Seismic Duck – Part 2 (Thread Parallelism)

By Arch Robison (Intel) (30 posts) on May 9, 2010 at 2:10 pm
Comments (4)

This blog is part two of four about how I applied parallel patterns to Seismic Duck, the most exciting game you will ever find about reflection seismology. I admit it’s probably the only game about reflection seismology. Part 1 covered background material and overall parallelization strategy for the game. This part covers threading. Part 3 [...]

Continued ›

Category: Parallel Programming, Software Tools, Uncategorized
Tags:

Transitioning to TBB 3.0

By Arch Robison (Intel) (30 posts) on May 4, 2010 at 7:29 am
Comments (0)

Unless your code is using pointers to member functions of class tbb::task, your TBB 2.2 code should work just as well with TBB 3.0.

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Parallelism Patterns in Seismic Duck - Part 1 (Background)

By Arch Robison (Intel) (30 posts) on April 21, 2010 at 9:54 am
Comments (1)

This blog is first of four about applying parallel patterns to a real program.  I'll point out some excellent parallel pattern documents on the Web and an unusual video game of mine.  This blog discusses background material and overall parallelization strategy.  Part 2 covers threading.  Part 3 covers vectorization and cache optimizations.  Part 4 covers [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Implementing task_group interface in TBB

By Arch Robison (Intel) (30 posts) on July 2, 2008 at 5:53 am
Comments (4)

The TBB class task was designed for high-performance implementations of the TBB templates.  It's efficiency, particularly its emphasis on continuation-passing style, comes at some price in convenience.  Rick Molloy of Microsoft has posted a description of a task_group interface that Microsoft is considering.  It's more convenient for than the TBB interface, particularly when your compiler supports C++ [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Tasks for Doing and Threads for Waiting

By Arch Robison (Intel) (30 posts) on June 5, 2008 at 7:35 pm
Comments (5)

TBB started out as a task-based framework for parallel programming.  TBB 2.1 adds threads.  This note explains the new threading interface, when to use it, and when to use tasks instead. TBB tasks rely on non-preemptive cooperative scheduling based on work stealing, similar to Cilk. Once the TBB scheduler starts a task on a software [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Abstracting Thread Local Storage

By Arch Robison (Intel) (30 posts) on January 31, 2008 at 11:25 am
Comments (8)

[Disclaimer: I'm sketching possibilities here. There is no commitment from the TBB group to implement any of this.] Threading packages often have some notion of a thread id or thread local storage. The two are equivalent in the sense if given one, you can easily build the other. For example, thread local storage can be [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Linked Lists - Incompatible with Parallel Programming?

By Arch Robison (Intel) (30 posts) on December 20, 2007 at 3:08 pm
Comments (16)

I've been asked several times why TBB does not have a concurrent list class; i.e., a list that supports concurrent access. The answer is that we'd add one if: We could figure out semantics that are useful for parallel programming and We could implement it reasonably efficiently on current hardware. I usually try to avoid [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Volatile: Almost Useless for Multi-Threaded Programming

By Arch Robison (Intel) (30 posts) on November 30, 2007 at 12:44 pm
Comments (41)

There is a widespread notion that the keyword volatile is good for multi-threaded programming. I've seen interfaces with volatile qualifiers justified as "it might be used for multi-threaded programming". I thought was useful until the last few weeks, when it finally dawned on me (or if you prefer, got through my thick head) that volatile [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Supercomputing '07: Computer Environment and Evolution

By Arch Robison (Intel) (30 posts) on November 17, 2007 at 8:50 pm
Comments (9)

I'm back from Supercomputing '07. Gone is the heyday of wacky hyper-dimensional topologies and strange new architectures like the Connection Machine. Clusters built from commodity parts have become the ubiquitous denizens of the High Performance Computing (HPC) ecological niche. The Precambrian explosion seems to be over. The environment directs evolution. It was good to walk [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Have a Fish - How Break from a Parallel Loop in TBB

By Arch Robison (Intel) (30 posts) on November 8, 2007 at 7:57 am
Comments (1)

"Give people a fish, and you feed them for a day. Teach people how to fish, and you feed them forever." This blog does both. A recurring question from TBB users is how to break from a parallel loop. This blog shows one way to do it, by writing a new kind of range type. It's not a perfect solution, [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Boo! Three Parallelism Bogeymen for Halloween

By Arch Robison (Intel) (30 posts) on October 31, 2007 at 9:00 am
Comments (4)

If you are trick-or-treating tonight, and visiting the house of a parallel programming researcher, just dress up as one of the bogeymen listed here and you'll give them a good scare! Seriously, in discussions of new languages for parallel programming, pundits trot out various bogeymen, declare them evil, and imply that by removing them, parallel [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Retooling Exceptions for Parallelism - Part 2

By Arch Robison (Intel) (30 posts) on October 22, 2007 at 9:44 am
Comments (2)

My previous blog discussed exceptions as alternative control flow versus exceptions as alternative data values.  Here I'll take that notion further and sketch how I think the TBB task scheduler should be deal with exceptions. A quick review of the TBB task scheduler. It's the low-level engine that drives the high-level templates like parallel_for. The [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Retooling Exceptions for Parallelism

By Arch Robison (Intel) (30 posts) on October 16, 2007 at 4:44 pm
Comments (5)

Exception handling is one of the big improvements of C++ over C. C code that checks for erroneous or unusual conditions is littered with tests for those conditions, making programs harder to read. Worse yet, the programmer might forget to check one of those conditions. Exceptions eliminated most of those problems, albeit opened up the [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Cache affinity support for TBB - low level task interface

By Arch Robison (Intel) (30 posts) on October 4, 2007 at 8:34 am
Comments (0)

Last week I showed how cache affinity support might be supported by the high-level algorithm templates. Here's what the low-level task interface might look like. There would be a new subclass of class task for tasks with affinity, called task_with_affinity.  As much as I would prefer to avoid subclassing here, we have to because introducing new [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Cache affinity support for TBB

By Arch Robison (Intel) (30 posts) on September 25, 2007 at 5:16 pm
Comments (4)

I'm currently working on improving cache reuse (cache affinity) for loops in TBB. This note describes why it is being improved, and the direction of the high-level interface for cache affinity in TBB. The TBB task scheduler is based upon task stealing a la Cilk. If a processor runs out of work to do, it [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

The Importance of a Sequential Backbone

By Arch Robison (Intel) (30 posts) on April 5, 2007 at 10:56 am
Comments (6)

There seems to be a widespread notion that in order to do parallel programming, you have to write an inherently parallel program.  By inherently parallel, I mean one that must have more than one thread to run correctly.  A simple example is a producer-consumer program with a bounded buffer.  A single thread cannot execute such [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

TBB: Beyond Do Loops

By Arch Robison (Intel) (30 posts) on December 18, 2006 at 11:20 pm
Comments (3)

Clay's blog http://softwarecommunity.intel.com/ISN/Community/en-us/blogs/multi-core-thredmonkey/archive/2006/12/18/30228042.aspx asks if Intel® Threading Building Blocks [Intel® TBB] is a solution looking for a problem. OpenMP is great if you have Fortran code, or C code that looks like Fortran, or C++ that looks like Fortran. In other words, flat do-loop centric parallelism. With TBB, we're trying to go beyond that and [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Dependence breaking speeds up Frequon Invaders

By Arch Robison (Intel) (30 posts) on December 13, 2006 at 10:39 pm
Comments (2)

I recently updated my video game Frequon Invaders. It's a free download from http://home.comcast.net/~arch.robison/frequon.html , which is strictly my own product, not Intel's. In doing the update, I optimized it for Intel® Core™2 Duo processor, and ran into a tale of dependence breaking that I'll tell here. Frequon Invaders has a very unusual display for [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Grainsize - Director's Cut

By Arch Robison (Intel) (30 posts) on November 20, 2006 at 5:16 pm
Comments (0)

The parallel loop templates in Intel® TBB require a grainsize parameter. Ideally, we'd have some sort of profile-guided optimization. But that's tough to do within TBB's goal of working with standard-issue compilers. It's really not that difficult to understand and set. I had this analogy in a draft of the Tutorial, but it ended up [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Don't worry about sublinear speedup, be happy!

By Arch Robison (Intel) (30 posts) on October 30, 2006 at 8:20 pm
Comments (2)

Beginning programmers often expect linear speedup in parallel programs, thinking two cores should be twice as fast as one. Of course, this is usually not the case. Limitations such as serial portions, bus bandwidth, cache, communication etc. start to kick in. For Amdahl's law kicks in, the answer is the Gustafson-Basis Law http://en.wikipedia.org/wiki/Gustafson's_Law - more [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Direct support for double-check worth the trouble?

By Arch Robison (Intel) (30 posts) on October 16, 2006 at 10:50 pm
Comments (3)

I suspect blogs are like poetry - more are written than read. I've had this specific posting lost twice now by the system, so I'll need a total of three readers to break even. I'm the lead developer for Intel® Threading Building Blocks (Intel® TBB). I've been pondering whether TBB should have more direct support [...]

Continued ›

Category: Parallel Programming, Software Tools
Tags:

Unit test

By Arch Robison (Intel) (30 posts) on October 6, 2006 at 9:09 pm
Comments (0)

Well, my first blog, many lines, was completely lost. I should have applied two key lessons software engineering: Run unit tests. I.e., try a small blog like this first. Keep backups. Copy and paste the blog content somewhere else. - Arch

Continued ›

Category: Parallel Programming, Software Tools
Tags: