Friday, October 9, 2009

Moblin v2.0 is Multicore Ready

Posted on http://www.ddj.com/go-parallel
Moblin v2.0 for Intel Atom Processor based netbooks is already available. Developers with Linux experience will find it easy to target this new attractive platform. However, many developers have many questions related to the multicore support offered this new operating system.
Read more here

Monday, October 5, 2009

Rich Services Cloud Applications Require Parallel Programming Skills

Posted on http://www.ddj.com/go-parallel
The interest on Rich Services Cloud Applications is growing fast. Users want responsive and immersive interactions from any locations. Nowadays, you cannot think about a business application without mobility in mind. However, you cannot avoid creating a rich user experience (UX) in mobile devices whilst accessing services on the cloud. If you want to offer a really nice experience, you'll have to use parallel programming skills everywhere.
Read more here

Downsizing Multicore Programming Skills to Take Advantage of Intel Atom

Posted on http://www.ddj.com/go-parallel
There is no doubt that Intel Atom is an attractive microprocessor. Netbooks, embedded systems, consumer electronic devices, and MIDs (Mobile Internet Devices) are using its different flavors. But can multicore programming skills be useful with these single-core CPUs?
Read more here

Process Monitor v2.7: A New Release to Watch Processes and Threads in Windows

Posted on http://www.ddj.com/go-parallel
Process Monitor is a very complete advanced monitoring tool that shows and logs real-time activity for the file system, the Registry, the running processes and their threads in Windows. Yesterday, the Windows Sysinternals team made the new version v2.7 of Process Monitor available for download.
Read more here

All CPU Meter: A Simple Windows Gadget to Monitor Cores

Posted on http://www.ddj.com/go-parallel
All CPU Meter is a very simple sidebar gadget available for Windows Vista and Windows 7. It allows developers and users to check the microprocessor's usage and it shows an independent graph for each available logical core (hardware thread).
Read more here

TMonitor: Understanding What Happens With Each Hardware Thread

Posted on http://www.ddj.com/go-parallel
TMonitor, a new tool developed by the CPUID team, offers the possibility to understand what's going on with each hardware thread (logical core) on some modern multicore microprocessors.
Read more here

Web Workers: A Draft Recommendation to Allow Parallelism in Scripts

Posted on http://www.ddj.com/go-parallel
Most modern Web pages run scripts. So far, there are many limitations to allow these scripts to take advantage of multicore microprocessors. However, Web Workers is a draft specification that defines an API to allow Web application authors to spawn background workers running scripts in parallel.
Read more here

Balder: A Silverlight 3 Managed 3D Engine Optimized for Multicore

Posted on http://www.ddj.com/go-parallel
Silverlight 3 doesn't offer native support for loading and rendering 3D models. However, Balder, an open source project, offers a very complete managed 3D engine for Silverlight 3. It achieved the necessary frame rate taking advantage of Silverlight's threading capabilities.
Read more here

Parallel Loops Require In-Depth Concurrency Knowledge

Posted on http://www.ddj.com/go-parallel
The new Parallel Extensions offered by .NET Framework 4 Beta 1 present developers the opportunity to use the new parallel loops. Using them, it is easier to distribute tasks in many cores. However, you don't have to forget about concurrency issues.
Read more here

New Parallel Debugging Windows in Visual Studio 2010 Beta 1

Posted on http://www.ddj.com/go-parallel
Visual Studio 2010, still in Beta 1, offers two new debugging windows: Parallel Stacks and Parallel Tasks. Using them, it is easier to understand the new Parallel Extensions offered by .NET 4.
Read more here

Tasks Are Not Threads in .NET 4 Beta 1

Posted on http://www.ddj.com/go-parallel
.Net Framework 4.0 with its Parallel Extensions, still in Beta 1, will add the possibility to work with tasks. It is very important to understand that tasks aren't threads. Tasks run using threads. However, it doesn't mean they replace threads.
Read more here

Fan: A Portable Language is Bringing Actors to JavaScript

Posted on http://www.ddj.com/go-parallel
Fan, another new programming language developed in the multicore era, has recently launched its 1.0.45 release. It is a very active open source project with a very interesting approach to many modern concurrent programming challenges.
Read more here

Keeping Parallelism Balanced is a Must

Posted on http://www.ddj.com/go-parallel
It is very important to optimize applications for existing and forthcoming multicore microprocessors. However, a lack of balance in parallelism levels could lead to explosive parallelism with resulting slowdown rather than speedup.
Read more here

Friday, July 10, 2009

Using VirtualBox 3.0 Virtualization Software to Measure Multicore Scalability

Posted on http://www.ddj.com/go-parallelThe new Sun's VirtualBox virtualization software release offers very interesting features to allow developers to measure multicore scalability. As these new features were not available in previous versions, it is very important to consider them when evaluating a virtualization solution in order to test parallel performance in different operating systems and hardware environments.
Read more here

Actors, Messages and Low Lock Contention for Java

Posted on http://www.ddj.com/go-parallel
Using actors and messages, concurrency is easier to understand. However, most developers don't want to learn a new programming language in order to use actors and messages. If you want to forget a bit about threads and locks, you can add nice actor support to an existing Java application using Jetlang.
Read more here

Using Intel Parallel Studio to teach the most difficult issues related to multi-core programming

Posted on Intel Software Network
When I finished installing Intel Parallel Studio and I saw the new toolbars integrated in Visual Studio 2008, I couldn’t help beginning to read the complete documentation for this exciting product.
I really liked the capabilities offered by Intel Parallel Studio. It helped me to work faster in order to parallelize existing serial code. It also helped me to find the most difficult bugs and to profile my applications. I do believe it is a unique tool. You’ll find a lot of information about Intel Parallel Studio on its main Website: http://software.intel.com/en-us/intel-parallel-studio-home/
Read more here

Thursday, July 2, 2009

A Domain-Specific Language to Let Groovy Go Parallel

Posted on http://www.ddj.com/go-parallel

Groovy is an agile dynamic language for the Java Platform. It runs on the JVM (Java Virtual Machine). It supports Domain-Specific Languages (DSLs). Last week, GParallelizer 0.7 release added exciting intuitive ways to handle tasks, actors and message. Great news for the Groovy community in order to go parallel.

Read more here

Work Stealing Queues in .Net 4 and in Previous Versions

Posted on http://www.ddj.com/go-parallel
.Net 4.0 Beta 1 offers a new and improved thread pool engine. It uses work stealing queues to provide nice load-balancing capabilities, better performance and greater scalability. The work stealing mechanism allows you to reduce the scheduling overhead in highly parallelized algorithms.
Read more here

Challenges in Multi-Core Era – Part 3

Previously, I compared the performance of today’s popular operating systems with respect to multi-core processors. In this final part to Challenges in Multi-Core Era, I’ll talk about the multi-core capabilities found in today’s programming languages and development tools.
Read more on Techdoer Times

Wednesday, June 24, 2009

Challenges in Multi-Core Era – Part 2

Previously I talked about the evolution of microprocessors and specialized hardware since the wide-spread adoption of multi-core began a few years ago. In this second part to Challenges in Multi-Core Era, I’ll compare the multi-core capabilities across today’s popular operating systems.
Read more on Techdoer Times

Thursday, June 18, 2009

Challenges in Multi-Core Era – Part 1

A few years ago, in 2005, Herb Sutter published an article in Dr. Dobb’s Journal, “The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software”. He talked about the need to start developing software considering concurrency to fully exploit continuing exponential microprocessors throughput gains.
Here we are in year 2009...
Read more on Techdoer Times

Saturday, May 30, 2009

Alternatives for Parallelizing Legacy Serial Code

Posted on http://www.ddj.com/go-parallel
Applications developed using modern programming languages can become legacy code faster than expected. Multicore microprocessors have been found guilty of transforming outstanding serial code into legacy code in just a few years. However, there are many alternatives to translate multicore power into application performance making small changes to the legacy serial code.
Read more here

Monday, May 25, 2009

Parallel Programming Talk - on getting business develop concurrent applications

I joined Dr. Clay Breshears and Aaron Tersteeg on this edition of the weekly Parallel Programming Talk (Intel Software Network) to discuss the state of parallel programming at software companies and developing applications with C# & .NET.

Listen to the podcast here

Sunday, May 24, 2009

New Garbage Collectors Designed With Parallelism in Mind

Posted on http://www.ddj.com/go-parallel
On the one hand, Garbage Collectors simplify developers' lives, but on the other hand, they can become the greatest enemies of a parallelized algorithm's performance. Finally, Java 7 and .Net 4 are going to offer new Garbage Collectors really targeted for multicore microprocessors with large memories.
Read more here

Friday, May 22, 2009

Tuesday, May 19, 2009

Microsoft Visual Studio 2010 and .Net Framework 4.0 Beta 1 Finally Arrived

Posted on www.ddj.com/go-parallel
After a long silence since the last CTP (Community Technology Preview), Microsoft released the Visual Studio 2010 Beta 1 that comes with the new .Net Framework 4.0. This new release will bring new promising features that empower parallel programming using the supported languages.

Wednesday, May 13, 2009

Use lambda expressions in C# to simplify the parallelized code

Posted on Intel Software Network
So, you want to start using Task Parallel Library Beta 1. You want to take advantage of the new features that will be available in .Net 4.0. Hold on! Are you familiar with lambda expressions?

Designing Rich Internet Applications With Parallelism in Mind

Posted on www.ddj.com/go-parallel
Are you still designing RIAs (Rich Internet Applications) using a serial programming approach? If that's the case, then you are losing a big opportunity to achieve a sustainable competitive advantage over competitors.

Wednesday, May 6, 2009

Counting cores in .Net and Java

Posted on Intel Software Network
As C# and Visual Basic (in the .Net world) and Java are high level programming languages, most developers were not used to check for some hardware information. With multicore microprocessors and a task-oriented programming model, trying to take full advantage of parallel processing capabilities offered by modern microprocessors, this is changing.

Monday, May 4, 2009

Measuring Parallelism: How Much Power Are You Wasting?

Posted on www.ddj.com/go-parallel
Management professionals love metrics. However, they don't like the idea to optimize applications that are currently running. Thus, what about showing them some metrics about the power that they are wasting using a free tool?

Wednesday, April 29, 2009

Invoking parallel tasks

Posted on Intel Software Network
In a recent post, Robert Chesebrough (Intel) talked about less focus on threads and more focus on tasks. I agree with him. I do believe that decomposing the job to be done into many tasks is the key to a successfully parallelized algorithm.

Tuesday, April 28, 2009

Using Intel Concurrency Checker 2.1 to benchmark threading and multicore metrics

This video uses Intel Concurrency Checker 2.1 to benchmark threading metrics on a parallelized and multithreaded C# application. Watching this video you will find out that there is an easy to use utility to test multicore optimizations in any executable.

For more information about Intel Concurrency Checker 2.1, visit: http://software.intel.com/

The application also uses AForge.NET imaging framework. For more information about AForge.NET, visit: http://www.aforgenet.com

For more information about .Net Parallel Extensions, visit: http://msdn.microsoft.com/en-us/concurrency/default.aspx

Parallel Extensions offer backward compatibility

Posted on Intel Software Network
Many developers are working with the features offered by C# 3.0 and .Net 3.5 to exploit multi-core CPUs. Parallel Extensions, which will be part of .Net 4.0 in Visual Studio 2010 are entering Beta 1. Luckily, they will offer backward compatibility.
Parallel Extension will offer a lot of interesting features related to multi-core programming. So, developers face many questions.

Intel's Hyper-Threading Strikes Back

Posted on www.ddj.com/go-parallel
Intel's Hyper-Threading technology was introduced with the 3.06 GHz Pentium 4 microprocessor. A few years later, the new Intel Core i7 processors offer Hyper-Threading again.

Novell's Mono brings SIMD support to C#

Posted on www.ddj.com/go-parallel
Parallel programming is not just about multi-threading and multi-core. There's also a lot of power in the SIMD (Single Instruction Multiple Data) extended instruction set available in most modern microprocessors from Intel and AMD.

Wednesday, March 11, 2009

Running a parallelized C# threaded application using different number of cores in Windows Vista

This video shows the difference between using one core and four cores in a highly threaded, parallelized application programmed in Visual C# 3.0 (2008). Many people say multicore CPUs are useless. Watching this video you will find out that there is a lot of power in multicore CPUs. Developers must tackle the multicore revolution to exploit multicore CPUs in new applications.



The application uses the excellent AForge.Net C# imaging library. For more information about it, visit: www.aforgenet.com
The application shown in the video is developed and explained in Chapter 12: Developing a Completely Parallelized Application.
This is the chapter's table of contents:

Joining many different parallelized pieces into a complete application
Time for action – Creating an opacity effect in an independent thread
Running code out of the UI thread
Time for action – Creating a safe method to change the opacity
Blocking the UI—Forbidden with multithreading code
Time for action – Creating a class to run a task in an independent thread
Time for action – Putting the logic into methods to simplify running tasks
in a pool of threads
Time for action – Queuing requests, running threads, and updating the UI
Combining threads with a pool of threads and the UI thread
Time for action – Creating a specialized parallel algorithm piece subclass
to run concurrently with the pool of threads
Time for action – Creating a specialized parallel algorithm coordination
subclass to run concurrently with the pool of threads
Time for action – Overriding methods in the brightness adjustment
coordination subclass
Time for action – Starting new threads in a new window
Creating threads inside other threads
Time for action – Showing new windows without blocking the user
interface
Multiple windows and one UI thread for all of them
Rationalizing multithreaded code
Summary

For more information visit: http://www.packtpub.com/beginners-guide-for-C-sharp-2008-and-2005-threaded-programming/book

Wednesday, March 4, 2009

C# 2008 and 2010, multicore, .Net Parallel Extensions and PLINQ


The book includes a lot of content dedicated to .Net Parallel Extensions (currently in CTP) and PLINQ (Parallelized LINQ). They will be available in C# 2010 (C# 4.0) and .Net 4.0.
This video shows the application developed in Chapter 11: Coding with .NET Parallel Extensions.
The chapter's table of contents:

Parallelizing loops using .NET extensions
Time for action – Downloading and installing the .NET Parallel Extensions
No silver bullet
Time for action – Downloading and installing the imaging library
Time for action – Creating an independent class to run in parallel without
side effects
Counting and showing blobs while avoiding side effects
Time for action – Running concurrent nebula finders using a
parallelized loop
Using a parallelized ForEach loop
Coding with delegates in parallelized loops
Working with a concurrent queue
Controlling exceptions in parallelized loops
Time for action – Showing the results in the UI
Combining delegates with a BackgroundWorker
Retrieving elements from a concurrent queue in a producer-consumer scheme
Time for action – Providing feedback to the UI using a producer-consumer
scheme
Creating an asynchronous task combined with a synchronous parallel loop
Time for action – Invoking a UI update from a task
Providing feedback when each job is finished
Using lambda expressions to simplify the code
Parallelizing loops with ranges
Parallelizing queries
Time for action – Parallelized counter
Parallelizing LINQ queries with PLINQ
Specifying the degree of parallelism for PLINQ
Parallelizing statistics and multiple queries
Summary

Tuesday, February 17, 2009

Exploiting a quad-core CPU using C# parallel programming


This is what you will learn following the exercises in the book "C# 2008 and 2005 Threaded Programming: Beginner's Guide". You will learn to develop applications that exploit modern multicore CPUs. No tricks, what you see is what you get!

Watch video in YouTube

Friday, February 6, 2009

Sample Chapter 8: Simplifying Parallelism Complexity

You can download the sample Chapter 8: Simplifying Parallelism Complexity from Packt's website:
http://www.packtpub.com/beginners-guide-for-C-sharp-2008-and-2005-threaded-programming/book/

UML diagrams to understand concurrent threads

This is a concise practical guide that will help you learn C# threaded programming, with lot of examples and clear explanations. It is packed with screenshots to aid your understanding of the process. Besides, it includes UML concurrent diagrams to offer a clear view of what is happening when multiple concurrent threads talk to each other.

The book design: Packt Publishing's quality















The book has an outstanding design and a great printing quality. It has lots of screenshots and diagrams to offer less theory and more results.

It follows the Beginner's Guide approach...
  • Clear step by step instructions for the most useful tasks
  • Learn by doing - start working right away
  • Leave out the boring bits
  • Inspiring, realistic examples give you ideas for your own work
  • Tasks and challenges to encourage experimentation
Besides, it is based in real-life experiences and it does not promote alpha or beta frameworks.
I explain the real advantages and trade-offs of each threading alternatives to exploit multicore and multiprocessor technologies.

C# 2008 and 2005 Threaded Programming: Beginner's Guide


Are you tired of watching your dual-core CPU usage around 50%?
Are you tired of watching your quad-core CPU usage around 25%?
Do you work with C#?
Do you want to exploit all the cores available in modern computers?
Do you want to parallelize your algorithms?
Do you want to improve your applications' performance without reading 2,000 pages?
If your answer to this six questions is YES, then, my new book "C# 2008 and 2005 Threaded Programming: Beginner's Guide", published by Packt Publishing, can help you.

The book offers a practical guide to developing responsive multi-threaded applications in C#to tackle the multicore complexity in around 400 pages.

This is a concise practical guide that will help you learn C# threaded programming, with lot of examples and clear explanations. It is packed with screenshots to aid your understanding of the process.

You can also download the code samples from Packt's website support for this book.

Comments and feedback about the book are both welcome!