6

When one has an array of objects it is often desirable (e.g. for performance reasons) to update (replace) some of the objects in place. For example, if you have an array of integers, you might want to replace the negative integers with positive ones:

// Faster for primitives
var i = 0
while (i < a.length) {
  if (a(i) < 0) a(i) = -a(i)
  i += 1
}

// Fine for objects, often okay for primitives
for (i <- a.indices) if (a(i) < 0) a(i) = -a(i)

What is the canonical way to perform a modification like this using the parallel collections library?

Rex Kerr
  • 166,841
  • 26
  • 322
  • 407
  • In case anyone wonders--even though it might seem like I should, I don't actually have the answer (only guesses), so I won't be answering my own question this time! – Rex Kerr May 26 '11 at 16:17

3 Answers3

6

As far as parallel arrays are considered - it's an oversight. A parallel transform for parallel arrays will probably be included in the next release.

You can, however, do it using a parallel range:

for (i <- (0 until a.length).par) a(i) = computeSomething(i)

Note that not all mutable collections are modifiable in place this way. In general, if you wish to modify something in place, you have to make sure it's properly synchronized. This is not a problem for arrays in this case, since different indices will modify different array elements (and the changes are visible to the caller at the end, since the completion of a parallel operation guarantees that all writes become visible to the caller).

axel22
  • 32,045
  • 9
  • 125
  • 137
2

Sequential mutable collections have methods like transform which work in-place.

Parallel mutable collections lack these methods, but I'm not sure there is a reason behind it or if it is just an oversight.

My answer is that you're currently out of luck, but you could write it yourself of course.

Maybe it would make sense filing a ticket after this has been discussed a bit more?

soc
  • 27,983
  • 20
  • 111
  • 215
2

How about creating a parallel collection that holds the indices into the array to transform and then run foreach to mutate one cell in an array, given the index.

That way you also have more control and it is possible to make four workers, that work on the four quarters of an array. Because simply flipping one single integer sign is probably not enough work to justify a parallel computation.

ziggystar
  • 28,410
  • 9
  • 72
  • 124
  • This depends on the size of your array - if it's really big, then it might make sense. – axel22 May 26 '11 at 18:28
  • Correction - if you create a parallel collection of indices, then probably not, but you could use a `ParRange`. – axel22 May 26 '11 at 18:34