How to lock array for aggregation in Parallel.For

Question

I am trying to iterate through a 2D array and then add to parts of another 2D array in a Parallel.For loop. I have found examples where an accumulation is being done inside the loop on a single variable but am not sure what to do here. GridB is doing accumulation so surely it needs to be locked as items in it could be added to from different threads If it needs to be locked how do you go about locking an entire array like this?

int[,] GridA = new int[D + 2, D + 2];
int[,] GridB = new int[D + 2, D + 2];

Parallel.For(1, D+1 , r =>
{
for (int c = 1; c <= D ; c++)
    if (GridA[r, c] != 0)
    {
        int v = GridA[r, c];

        GridB[r - 1, c - 1] += v;
        GridB[r - 1, c] += v;
        GridB[r - 1, c + 1] += v;

        GridB[r, c - 1] += v;
        GridB[r, c + 1] += v;

        GridB[r + 1, c - 1] += v;
        GridB[r + 1, c] += v;
        GridB[r + 1, c + 1] += v;
    }
});

It'd be easier if you used jagged array [][] instead of a two dimensional array [,]. — YoryeNathan
– YoryeNathan, Commented Jun 3, 2013 at 1:03
As long as the threads don't access the same elements in the array, you can do this without locking. — Brian Rasmussen
– Brian Rasmussen, Commented Jun 3, 2013 at 2:02
@user2425056 You could lock the three relevant rows in GridB, which would pretty much secure the threading, while still allowing them to switch properly. — YoryeNathan
– YoryeNathan, Commented Jun 3, 2013 at 4:17

Mike Zboray · Accepted Answer · 2013-06-03 01:28:16Z

1

You could just lock GridB like so:

Parallel.For(1, D+1 , r =>
{
  for (int c = 1; c <= D ; c++)
  {
    if (GridA[r, c] != 0)
    {
      int v = GridA[r, c];
      lock(GridB) 
      { 
        GridB[r - 1, c - 1] += v;
        // etc.
      }
    }
  }
});

However, you are serializing all access to GridB which sort of defeats the purpose of using multiple threads.

If all you want to do is add a fixed value to each element, Interlocked.Add in the System.Threading namespace will do the add atomically, so you don't need to take out a lock on the whole array.

Here's a sample of the usage:

Parallel.For(1, D+1 , r =>
{
    for (int c = 1; c <= D ; c++)
      if (GridA[r, c] != 0)
      {
         int v = GridA[r, c];

          Interlocked.Add(ref GridB[r - 1, c - 1], v);
          // rinse, repeat
      }
}

edited Jun 3, 2013 at 1:28

answered Jun 3, 2013 at 1:19

Mike Zboray

41.1k3 gold badges102 silver badges132 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user2425056 Over a year ago

Thanks. This is working. At least the algorithm is running about 2x faster. Will still have to check for accuracy against the serial version.

user2425056 Over a year ago

@Yorye, I have changed the algorithm to use jagged arrays and the speedup is noticeable. While this was not the answer to my question it lead me to a fruitful discovery. Thanks.

Collectives™ on Stack Overflow

How to lock array for aggregation in Parallel.For

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related