Detecting Scalability Problems With Intel Parallel Universe Portal

Posted by Gaston Hillar 10:53 PM | November 22, 2009

You already know that achieving a linear speedup as the number of cores increases in real life parallelized applications is indeed very difficult. However, sometimes, the multicore scalability of certain algorithms for existing multicore systems could be worse than expected. The overhead and the bugs introduced by concurrency could bring really unexpected scalability problems when the number of cores increases. Intel can help you with a free service in the cloud.

Just Say No To SFAQL Parallelism

Posted by Cameron Hughes, Tracey Hughes 11:16 PM | November 16, 2009

I know, I know, a lot of folks out there are big subscribers to the 'just-get-'er -done' school of software maintenance and development. The idea of sitting somewhere while a design group is doing its work is just plain torture. It feels like a waste of time and money. Somehow there's always a fire that demands that we code now and capture the design later.

QuickThread: A New C++ Multicore Library

Posted by Gaston Hillar 10:54 AM | November 16, 2009

NUMA (Non-Uniform Memory Access) architectures are becoming popular in HPC (High-Performance Computing) scenarios. Therefore, it is very important to work with efficient and optimized memory allocators. QuickThread is a new commercial C++ multicore programming library loaded with many optimizations for NUMA architectures, bringing a new option to create high-performance parallelized code.

Speeding Up Code Without Doing Anything

Posted by Stephen Blair-chappell 11:25 AM | November 15, 2009

Of all the techniques I use to speed up code, the one I like the most comes with just the press of a button, or more precisely at the swap of a compiler Every Intel compiler has this particular option, and I consider to be a great friend. I'm making a point of keeping you in suspense for a little while longer. Let me first tell you a couple of stories that prove the point.

Multicore Scalability is Already Possible With the Intel Atom Family

Posted by Gaston Hillar 01:27 AM | November 12, 2009

Whilst designing and developing applications targeting netbooks and MIDs (Mobile Internet Devices), one of the great questions is whether there is a real possibility of scaling to more cores in the near future. There's no need to think about the future. The Intel Atom family is already offering a dual-core microprocessor with Hyper-Threading, two physical cores and four hardware threads.

Go: A New Concurrent Systems Programming Language from Google

Posted by Gaston Hillar 11:46 PM | November 10, 2009

Google launched Go, a new systems programming language born with concurrency, simplicity and performance in mind. Do you have time to learn another programming language this year?

There's Good News and There's Bad News ...

Posted by Cameron Hughes, Tracey Hughes 04:13 PM | November 10, 2009

Last week we gave the webinar scene a break. Instead, Tracey talked me into going with her to the new Bill Gates Hillman Complex located on Carnegie Mellon campus in Pittsburgh. Holger Hoos from the University of British Columbia was giving a talk called "Taming the Complexity Monster". I figured how could we go wrong!

Visual Studio 2010 Multi-Monitor Support Helps Debugging Parallel Code

Posted by Gaston Hillar 10:14 PM | November 9, 2009

Debugging a parallelized application requires more information on the screen than debugging sequential code. Sometimes, even Full HD monitors aren't enough to display all the necessary windows at the same time. Luckily, Visual Studio 2010 Beta 2 offers a very intuitive multi-monitor support.

Sequential Programming: Like Eating Peas with a Straw.

Posted by Stephen Blair-chappell 09:29 AM | October 30, 2009

Before the era of multicore chips, performance gains in CPUs was achieved by a combination of ever increasing speed and architectural enhancements. This resulted in more and more power being consumed by the processor -- a situation that could not continue forever.

Biomolecular device using self-assembled DNA nanostructures?

Posted by Cameron Hughes, Tracey Hughes 12:18 AM | October 30, 2009

As I sit at my computer with it multicores considering the advantages of parallelism, faster computers, better performance, a strange feeling comes over me, 'Haven't I heard this before?'

Petascale Tools and Genomic Evolution
Highly Scalable Parallel Sorting
SC09 Storage Challenge Award
A Structured, Unified Approach to Multi-Core and Many-Core Computing -- with Applications
The MathWorks Updates Parallel Computing Toolbox

All News
Welcome to the Parallel Universe Publication

Today's Question

My main development machine has:
1 core
    14%
2 cores
    38%
4 cores
    23%
8 cores
    12%
A whole bunch more cores
    13%

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.