Parallel Programming with .NET

I added the link to my blog.

Very useful

THANKS,

Josh

Great document, a bible for parallel developper.

Thanks you so much,

Bruno

Thanks!! Very interesting stuff. As i'm starting to figure out, thread safe code does not equal effectively utilizing all those cores. This kind of  information is very welcome! Keep up th egood work,

GJ

If I have only one processor ,how I can increase the number of tasks/threads for this specific proccessor? because it seems that w/o that the code run the same as w/o parallel,.

Thanks,

Great paper, however here is a pattern that I did not find any guidance on:

We have a highly parallel system with a few thousand very independent tasks executing concurrently (I hope soon to get a 64 core box to run it on). The system runs for days. From each of these tasks I would like to collect statistics: Number of items processed, Average processing time per item, etc.  At regular intervals I would like to sample these statistics.

A naive implementation would protect the collected statistics with a lock, essentially serializing update of it. However such a pattern do not scale very well (and I would not like to introduce such locks in our otherwise almost lock free design).

A nicer solution would keep an array of statistics data. Each update would only update one slot of statistics data thus removing the need for a lock. When sampling the data, we would loop through the array and aggregate statistics. The tricky thing is to find a good key for the array. ThreadId is not a good candidate as it can grow quite large (As I understand it, there are ~500 IO completion port threads allocated per core). A “core id” would be better, although there are some interesting synchronization issues there.

I suspect the new ThreadLocal<T> class will not solve the problem either, as there will be one slot per thread (which is the essence of the ThreadLocal abstraction).

What are your comments?

But that still leaves me with potentially thousands of values to sample (in case different IOCP threads are posting threadlocal results).

What I was hoping for was more like "CoreLocal<T>" ... that way I would only need to sample one value per core.

Great paper. I'm really looking forward to the F# version!

Great paper.

Are you sure about the SerialPi algorithm on page 67? On my machine, with NUM_STEPS = 1000, the result is 4.28601621355331E+298; NUM_STEPS = 10000 gives Infinity.

OK, I've found the problem:

double partial = sum + 4.0 / (1.0 + x * x);

sum += partial;

You're adding sum twice. It should be:

double partial = 4.0 / (1.0 + x * x);

sum += partial;