Partitioner Parallel Programming

 

void RenderParallel(Scene scene, Int32[] rgb)

{

int totalPixels = screenHeight * screenWidth;

Camera camera = scene.Camera;

Parallel.ForEach(Partitioner.Create(0, totalPixels), range =>

{

for (int i = range.Item1; i < range.Item2; i++)

{

int y = i / screenWidth, x = i % screenWidth;

Color color = TraceRay(

new Ray(camera.Pos, GetPoint(x, y, camera)), scene, 0);

rgb[i] = color.ToInt32();

}

});

}

Step in Parallel.For

 

Parallel.For does not provide direct support for such patterns. However, Parallel can still be used to implement

such patterns. One mechanism for doing so is through an iterator approach like that shown earlier for iterating

through linked lists:

private static IEnumerable<int> Iterate(

int fromInclusive, int toExclusive, int step)

{

for (int i = fromInclusive; i < toExclusive; i += step) yield return i;

}

A Parallel.ForEach loop can now be used to perform the iteration. For example, the previous code snippet for

iterating the even values between 0 and upperBound can be coded as:

Parallel.ForEach(Iterate(0, upperBound, 2), i=> { /*...*/ }); 

such an implementation, while straightforward, also incurs the additional costs of forcing the

Parallel.ForEach to takes locks while accessing the iterator. This drives up the per-element overhead of

parallelization, demanding that more work be performed per element to make up for the increased overhead in

order to still achieve parallelization speedups.

public static void ParallelForWithStep(

int fromInclusive, int toExclusive, int step, Action<int> body)

{

if (step < 1)

{

throw new ArgumentOutOfRangeException("step");

}

else if (step == 1)

{

Parallel.For(fromInclusive, toExclusive, body);

}

else // step > 1

{

int len = (int)Math.Ceiling((toExclusive - fromInclusive) / (double)step);

Parallel.For(0, len, i => body(fromInclusive + (i * step)));

}

}