CODEWITHSUNDEEP
c#c#-4.0
Alan B
Alan B

Reputation: 2299

Parallel For Loop

I am trying to utilize the parallel for loop in .NET Framework 4.0. However I noticed that, I am missing some elements in the result set.

I have snippet of code as below. lhs.ListData is a list of nullable double and rhs.ListData is a list of nullable double.

int recordCount = lhs.ListData.Count > rhs.ListData.Count ? rhs.ListData.Count : lhs.ListData.Count;

List<double?> listResult = new List<double?>(recordCount);
var rangePartitioner = Partitioner.Create(0, recordCount);  

Parallel.ForEach(rangePartitioner, range =>
                    {
                        for (int index = range.Item1; index < range.Item2; index++)
                        {
                            double? result = lhs.ListData[index] * rhs.ListData[index];
                            listResult.Add(result);
                        }
                    });

lhs.ListData has the length of 7964 and rhs.ListData has the length of 7962. When I perform the "*" operation, listResult has only 7867 as output. There are null elements in the both input list.

I am not sure what is happening during the execution. Is there any reason why I am seeing less elements in the result set? Please advice...

Upvotes: 1

Views: 376

Answers (3)

Matthew Kennedy
Matthew Kennedy

Reputation: 616

The correct way to do this is to use LINQ's IEnumerable.AsParallel() extention. It does all of the partitioning for you, and everything in PLINQ is inherently thread-safe. There is another LINQ extension called Zip that zips together two collections into one, based on a function that you give it. However, this isn't exactly what you need as it only goes to the length of the shorter of the two lists, not the longer. It would probably be easies to do this, but first expand the shorter of the two lists to the length of the longer one by padding it with null at the end of the list.

IEnumerable<double?> lhs, rhs;    // Assume these are filled with your numbers.
double?[] result = System.Linq.Enumerable.Zip(lhs, rhs, (a, b) => a * b).AsParallel().ToArray();

Here's the MSDN page on Zip:

http://msdn.microsoft.com/en-us/library/dd267698%28VS.100%29.aspx

Upvotes: 2

Konstantin Spirin
Konstantin Spirin

Reputation: 21321

You are using List<double?> to store results but Add method is not thread safe. You can use explicit index to store the result (instead of calling Add):

listResult[index] = result;

Upvotes: 0

BrokenGlass
BrokenGlass

Reputation: 161002

That's probably because the operations on a List<T> (e.g. Add) are not thread safe - your results may vary. As a workaround you could use a lock, but that would very much reduce performance.

It looks like you just want each item in the result list to be the product of the items at the corresponding index in the two input lists, how about this instead using PLINQ:

var listResult = lhs.AsParallel()
                    .Zip(rhs.AsParallel(), (a,b) => a*b)
                    .ToList();

Not sure why you chose parallelism here, I would benchmark if this is even necessary - is this truly the bottleneck in your application?

Upvotes: 0

Related Questions