trjhtr

I am getting the huge amount of data from a sensor. In order to speed up data processing, I thought of using Parallel.For. Below is the sample code:

object sync = new object();
private Random random = new Random();
private List<byte> container = new List<byte>();
private readonly int FRAME_WIDTH = 1000;
private readonly int DATA_LENGTH = 217088;
private readonly int FRAME_HEIGHT = 800;

private void getPointsFromSensor(out Point2D points2d, out Point3D points3d)

 points2d = new Point2D[DATA_LENGTH];
 points3d = new Point3D[DATA_LENGTH];
 for (var index = 0; index < DATA_LENGTH; index++)
 
 points2d[index] = new Point2D(random.Next(-index, index), random.Next(-index, index));
 points3d[index] = new Point3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
 


private void OnDataArrived(object sendor, DataArrivedEventArgs e)

 getPointsFromSensor(out Point2D points2d, out Point3D points3d);

 int validDataCount = 0;

 container.Clear(); // Remove old points
 // reserving 4 bytes for storing 'validDataCount' and we are going to modify it later
 container.AddRange(BitConverter.GetBytes(validDataCount));

 Parallel.For(0, DATA_LENGTH, index =>
 
 int points2dX = points2d[index].X;
 int points2dY = points2d[index].Y;

 if (points2dX >= 0 && points2dX < FRAME_WIDTH && points2dY >= 0 && points2dY < FRAME_HEIGHT)
 
 lock (sync)
 
 container.AddRange(BitConverter.GetBytes(points3d[index].X));
 container.AddRange(BitConverter.GetBytes(points3d[index].Y));
 container.AddRange(BitConverter.GetBytes(points3d[index].Z));
 
 Interlocked.Increment(ref validDataCount);
 
 );

 var validDataCountBytes = BitConverter.GetBytes(validDataCount);//4 bytes
 container[0] = validDataCountBytes[0]; container[1] = validDataCountBytes[1];
 container[2] = validDataCountBytes[2]; container[3] = validDataCountBytes[3];

The Point2D and Point3D are defined as follows:

class Point2D

 public int X;
 public int Y;

 public Point2D(int x, int y)
 
 X = x;
 Y = y;
 


class Point3D

 public double X;
 public double Y;
 public double Z;

 public Point3D(double x, double y, double z)
 
 X = x;
 Y = y;
 Z = z;
 

It turns out that the Parallel.For version is taking much time compared to simple for loop.

I am wondering if there exists is a better way to use Parallel.For inside a callback function in C#.

Usually it makes absolutely no sense to use a parallel loop with a lock inside it. The performance loss you are talking about comes most probably from it. They cannot run in parallel because they have to wait for each other. The lock also costs some time and if it happens to often, the parallel loop might actually be slower then the normal one.

You might gain some performance if you redesign it in a way that does not requrie synchronization.

There are three rules I find useful when working with parallel loops:

1. Do not lock inside the loop. (already explained in t3chb0t's answer)




2. Do not write to a shared buffer inside a loop, unless you can do it in a thread-safe manner without any additional synchronization (including concurrent collections or other objects that use locks internally). In case you can't, use one of the overloads that supports local states, and write to that local state without a lock.




3. Do not iterate over every element of array unless a significant amount of work is required to process each element. In general, you should split your initial data into reasonably-sized chunks (using ArraySegment class, for example), and use Parallel.For to iterate over array of those chunks.

Following those three rules should give you satisfactory results.

In addition to the other answers, it's worth noting that you're doing very little work inside the parallel.for - grabbing two random values, performing a few comparison, getting some bytes and performing some add-range and additions.

These are very fast, very cheap operations. Parallel.For adds in a ton of overhead that likely exceeds the cost of the operations.

Then its worth noting, as other answers have, that you have locked some of the slower operations - meaning that it'll run that part at no faster than single thread speed. Having a lock inside a parallel operation isn't necessarily bad (e.g. if it's only a very small fraction of that operations work) but by definition it adds a bottleneck.

When working on small, higher performance loops like this I try to do the following:

1) Have each thread work on its own data, and synchronize at the end (or in a thread-safe, high-speed manner like interlocked)

2) Batch the data into appropriately sized chunks before passing to the thread.

For example:

var threadCount = Enviroment.ProcessorCount;
var threadContainers = new Enumerable.Range(0,threadCount).Select(_ => new List<byte>()).ToArray();
Parallel.For(0, threadCount, thread=>
 
 //review, can easily be off by one due to division
 for (int index = 0; index<( DataLength/threadCount); index++)
 
 // Random values just in this code snippet
 int config_1 = random.Next(-index, index); 
 int config_2 = random.Next(-index, index);

 if (config_1 >= 0 && config_1 < FRAME_WIDTH && config_2 >= 0 && config_2 < FRAME_HEIGHT)
 
 //this *may* be threadsafe, but worth reviewing to be sure.
 threadContainers[thread].AddRange(BitConverter.GetBytes(config_1));
 threadContainers[thread].AddRange(BitConverter.GetBytes(config_2));
 Interlocked.Increment(ref validDataCount);
 
 
);
var container = containers.SelectMany(x=>x).ToList(); 
container.AddRange(BitConverter.GetBytes(validDataCount));

Of course, this can get tedious, So do consider other parallel tools and patterns to assist. For example PLinq might be a good example in this case, because it can do the batching behind the scenes and help manage the creation and flow of state between the threads (whereas we had to do that manually here.