Current attempts at solving the programming challenges associated with multicore processors are based on established ideas and research: The Actor model, task queues, data flow parallelism and so on were all invented some thirty years ago, but are enjoying renewed interest because of the need to harness the power of multicore processors.

Apple's Grand Central Dispatch, introduced in the most recent version of OS X, is based on such a venerable idea as well—task parallelism—but offers novel features thanks to its deep integration into the operating system. According to an overview paper [PDF document] published by Apple:

GCD shifts the responsibility for managing threads and their execution from applications to the operating system. Mac OS X Snow Leopard provides APIs for GCD throughout the system, and uses a highly scalable and efficient runtime mechanism to process work from applications...

GCD gives developers a simple way to describe the different pieces of work that your applications need to do, and an easy way to describe how those pieces might be dependent upon one another. Units of work are described as blocks in your code, while queues are used to organize blocks based on how you believe they need to be executed. By using blocks and queues, you no longer need to worry about threads, thread managers, or locking data, making an application’s code easier to understand. You can simply let the system manage the work queues and execute the blocks for optimal performance...

GCD has a multicore execution engine that reads the queues created by each application and assigns work from the queues to the threads it is managing. GCD manages threads based on the number of cores available and the demands being made at any given point in time by the applications on the system. Because the system is responsible for managing the threads used to execute blocks, the same application code runs efficiently on single-processor machines, large multiprocessor servers, and everything in between.

In order to define such tasks, GCD provides extensions to Objective-C, C, and C++. Such tasks are essentially lambda expressions, a feature also planned for the upcoming C++0x version of the C++ language, although GCD uses a different syntax to describe such expressions:

Blocks are a simple extension to C (as well as Objective-C and C++) that make it easy for you to define self-contained units of work. A block in code is denoted by a caret at the beginning of a function. For example, you could declare a block and assign it to x by writing:

x = ^{ printf("hello world\n"); }

This turns the variable x into a way of calling the function so that calling x( ); in the code would print the words hello world.

A novel feature of GCD is that it schedules block execution on work queues based on the load characteristics of an entire system. This can be accomplished by GCD being integrated deep into the operating system:

You schedule blocks for execution by placing them on various system- or user-queues. GCD then uses those queues to describe concurrency, serialization, and callbacks. Queues are lightweight user-space data structures, which generally makes them far more efficient than manually managing threads and locks...

Whenever a queue has blocks to run, GCD removes one block at a time and schedules it on the next available thread from the pool of threads that GCD manages. This saves the cost of creating a new thread for each request, dramatically reducing the latency associated with processing a block...

Blocks are added and removed from queues using atomic operations available on modern Intel processors, which are guaranteed to execute completely (without interruption) even in the presence of multiple cores.

What do you think of Apple's OS-centric approach to multicore programming?