Blog Archives

November, 2009

HPC Joins the Dummy Revolution?

We've been trying to figure out exactly what the attraction is. What is it that causes someone to be drawn to a book that explicitly states that it's for dummies? Is it the yellow and black motif? Maybe because 'dummy' rhymes with 'yummy'? What exactly causes someone to reach for a book entitled 'X for Dummies'?

Detecting Scalability Problems With Intel Parallel Universe Portal

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

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

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

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

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

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 ...

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

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.

Calendar

February 2010
January 2010
December 2009
November 2009
October 2009
September 2009
August 2009
July 2009
June 2009
May 2009
April 2009
March 2009
February 2009
January 2009
December 2008

Use Non-blocking Locks When Possible
Non-blocking system calls let competing threads return and useful work to be done
Automatic Parallelization
Multithreading an application to improve performance can be a time-consuming activity
Designing Parallel Algorithms: Part 4
Combining TBB and IPP with Intel Parallel Studio

Real World Parallelism Webinar Series
  • 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.