5 |
|
*/ |
6 |
|
|
7 |
|
package java.util; |
8 |
< |
import java.util.concurrent.ForkJoinPool; |
8 |
> |
|
9 |
|
import java.util.concurrent.CountedCompleter; |
10 |
|
import java.util.function.BinaryOperator; |
11 |
+ |
import java.util.function.DoubleBinaryOperator; |
12 |
|
import java.util.function.IntBinaryOperator; |
13 |
|
import java.util.function.LongBinaryOperator; |
13 |
– |
import java.util.function.DoubleBinaryOperator; |
14 |
|
|
15 |
|
/** |
16 |
|
* ForkJoin tasks to perform Arrays.parallelPrefix operations. |
19 |
|
* @since 1.8 |
20 |
|
*/ |
21 |
|
class ArrayPrefixHelpers { |
22 |
< |
private ArrayPrefixHelpers() {}; // non-instantiable |
22 |
> |
private ArrayPrefixHelpers() {} // non-instantiable |
23 |
|
|
24 |
|
/* |
25 |
|
* Parallel prefix (aka cumulate, scan) task classes |
79 |
|
T in, out; |
80 |
|
final int lo, hi, origin, fence, threshold; |
81 |
|
|
82 |
– |
/** Root task constructor */ |
83 |
– |
public CumulateTask(CumulateTask<T> parent, |
84 |
– |
BinaryOperator<T> function, |
85 |
– |
T[] array, int lo, int hi) { |
86 |
– |
super(parent); |
87 |
– |
this.function = function; this.array = array; |
88 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
89 |
– |
int p; |
90 |
– |
this.threshold = |
91 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
92 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
93 |
– |
} |
94 |
– |
|
95 |
– |
/** Subtask constructor */ |
82 |
|
CumulateTask(CumulateTask<T> parent, BinaryOperator<T> function, |
83 |
|
T[] array, int origin, int fence, int threshold, |
84 |
|
int lo, int hi) { |
173 |
|
sum = t.in; |
174 |
|
t.out = sum; |
175 |
|
for (CumulateTask<T> par;;) { // propagate |
176 |
< |
if ((par = (CumulateTask<T>)t.getCompleter()) == null) { |
176 |
> |
@SuppressWarnings("unchecked") CumulateTask<T> partmp |
177 |
> |
= (CumulateTask<T>)t.getCompleter(); |
178 |
> |
if ((par = partmp) == null) { |
179 |
|
if ((state & FINISHED) != 0) // enable join |
180 |
|
t.quietlyComplete(); |
181 |
|
break outer; |
217 |
|
long in, out; |
218 |
|
final int lo, hi, origin, fence, threshold; |
219 |
|
|
232 |
– |
/** Root task constructor */ |
233 |
– |
public LongCumulateTask(LongCumulateTask parent, |
234 |
– |
LongBinaryOperator function, |
235 |
– |
long[] array, int lo, int hi) { |
236 |
– |
super(parent); |
237 |
– |
this.function = function; this.array = array; |
238 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
239 |
– |
int p; |
240 |
– |
this.threshold = |
241 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
242 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
243 |
– |
} |
244 |
– |
|
245 |
– |
/** Subtask constructor */ |
220 |
|
LongCumulateTask(LongCumulateTask parent, LongBinaryOperator function, |
221 |
|
long[] array, int origin, int fence, int threshold, |
222 |
|
int lo, int hi) { |
353 |
|
double in, out; |
354 |
|
final int lo, hi, origin, fence, threshold; |
355 |
|
|
382 |
– |
/** Root task constructor */ |
383 |
– |
public DoubleCumulateTask(DoubleCumulateTask parent, |
384 |
– |
DoubleBinaryOperator function, |
385 |
– |
double[] array, int lo, int hi) { |
386 |
– |
super(parent); |
387 |
– |
this.function = function; this.array = array; |
388 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
389 |
– |
int p; |
390 |
– |
this.threshold = |
391 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
392 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
393 |
– |
} |
394 |
– |
|
395 |
– |
/** Subtask constructor */ |
356 |
|
DoubleCumulateTask(DoubleCumulateTask parent, DoubleBinaryOperator function, |
357 |
< |
double[] array, int origin, int fence, int threshold, |
358 |
< |
int lo, int hi) { |
357 |
> |
double[] array, int origin, int fence, int threshold, |
358 |
> |
int lo, int hi) { |
359 |
|
super(parent); |
360 |
|
this.function = function; this.array = array; |
361 |
|
this.origin = origin; this.fence = fence; |
489 |
|
int in, out; |
490 |
|
final int lo, hi, origin, fence, threshold; |
491 |
|
|
532 |
– |
/** Root task constructor */ |
533 |
– |
public IntCumulateTask(IntCumulateTask parent, |
534 |
– |
IntBinaryOperator function, |
535 |
– |
int[] array, int lo, int hi) { |
536 |
– |
super(parent); |
537 |
– |
this.function = function; this.array = array; |
538 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
539 |
– |
int p; |
540 |
– |
this.threshold = |
541 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
542 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
543 |
– |
} |
544 |
– |
|
545 |
– |
/** Subtask constructor */ |
492 |
|
IntCumulateTask(IntCumulateTask parent, IntBinaryOperator function, |
493 |
< |
int[] array, int origin, int fence, int threshold, |
494 |
< |
int lo, int hi) { |
493 |
> |
int[] array, int origin, int fence, int threshold, |
494 |
> |
int lo, int hi) { |
495 |
|
super(parent); |
496 |
|
this.function = function; this.array = array; |
497 |
|
this.origin = origin; this.fence = fence; |