Things do get a bit dicey when one is in uncharted waters and decisions have to be made. This parallelism, multicore, and many core stuff has lots of different entry and exit points. We can have parallelism and concurrency at the hardware layers, operating system layers, network layers, database layers, application layers, design layers, and requirement layers.
Microsoft took into account the feedback around performance issues and bugs provided by Visual Studio 2010 Beta 2 users and decided to extend the Beta period. The new Visual Studio version introduces a lot of changes, including many features focused on multicore programming. A new checkpoint release, a Release Candidate would be publicly available during February 2010.
Visual Basic 10, part of Visual Studio 2010 Beta 2, also supports the new task-based programming model. Therefore, you can take advantage of multicore hardware using this programming language. In fact, it offers access to all the new features introduced in .NET Framework 4 Beta 2.
We admit to throwing around some pretty charged terms in a loose fashion. Sometimes we forget that not everybody is drinking the koolaid. We [assume] that words like paradigm, architecture, and model mean the same thing to everyone. Of course we are wrong (what they say about 'assume' is still in effect).
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'?
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.
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.
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.
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.
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.
Acumen Updates Thread Analysis Tool
| My main development machine has: |
| 1 core |
 14%
|
| 2 cores |
 37%
|
| 4 cores |
 23%
|
| 8 cores |
 13%
|
| A whole bunch more cores |
 13%
|
Fun with Locks and Waits: Performance Tuning
Figuring out where to make changes to get the biggest performance improvement
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.
