Parallel Programming Talk #47 - Software Development for N-core Processing

By Aaron Tersteeg (Intel) (151 posts) on September 16, 2009 at 1:21 pm

Hello Parallel Programers & Intel Software Partners.
Welcome to Episode 47 of Parallel Programming Talk

Download and MP3 of the show

First the News

Intel Threading Challenge Phase 2
PROBLEM 2 OF PHASE 2 IS NOW OPEN!
Kight's Tour
You will have until September 25, 2009 to submit your entry.

Intel Developer Forum - September 22-24 - Next week!

SC09 – Super Computer Conference - November 14-20

The first Tuesday of the month is our Listener Questions show.
October 6th is the next one. If you have a question or idea about the show send it in to ParallelProgrammingTalk@Intel.com

Today's Show

The Threading Methodology used at Intel has four major steps: Analysis, Design & Implementation, Debugging, and Performance Tuning. These steps are used to create a multithreaded application from a serial base code. Multithreaded programming is still more art than science. This show will gives 8 Simple Rules that you can add to your palette of threading design methods. By following these rules, you will have more success in writing the best and most efficient threaded implementation of your applications. We will also be discussing Parallel Programming Resources and tools available on Intel.com to support your parallel application development.

Clay and Aaron framed the show's discussion based on Clay's technical paper 8 Simple Rules for Designing Threaded Applications.

Why develop for N-cores?

* Flip answer: Because you have no choice. Future processor architectures will have multiple cores.

* Why are chip manufacturers making only multi-core processors?

-- Power consumption: using lowered clock speed (frequency)
-- Less power == less heat; approaching rocket nozzle temps before MC
-- Moore's Law gives more chip area; multiple cores at fixed speed leads to greater performance

Key Considerations for Enabling Your Software for N-cores?

* Find independent computations

* Implement concurrency at highest level of code
-- Increase chance for coarse-grained granularity
-- more tasks == better chance for dynamic load balancing

* Plan for scalable solutions; number of cores will only increase

* Use thread-safe libraries whenever possible

* Use right threading model
-- right functionality for parallelizing the code
-- easier to write, easier to maintain
-- Learn more about Patterns on Clay's blog post

* Never assume particular execution order
-- threads are non-deterministic -> data races and deadlocks
-- add logic (code, local variables, sync objects) to ensure order

* Use private variables when possible
-- cuts downon required sync overhead

* When sync needed, associate locks to specific data
-- one lock per data item (or group of items)
-- empty intersection of data between sync objects

* Don't be afraid to use less optimal serial algorithm
-- may be easier to parallelize inferior algorithm

Coming Up Next on Parallel Programming Talk

Clay and Aaron will be live at the Intel Developer Forum

Categories: Intel SW Partner Program, Parallel Programming
Tags:

For more complete information about compiler optimizations, see our Optimization Notice.

Comments (0)

Trackbacks (2)


Leave a comment  

To obtain technical support, please go to Software Support.
Name (required)*

Email (required; will not be displayed on this page)*

Your URL (optional)


Comment*