7 |
|
package java.util; |
8 |
|
|
9 |
|
import java.util.concurrent.CountedCompleter; |
10 |
– |
import java.util.concurrent.ForkJoinPool; |
10 |
|
import java.util.function.BinaryOperator; |
11 |
|
import java.util.function.DoubleBinaryOperator; |
12 |
|
import java.util.function.IntBinaryOperator; |
72 |
|
/** The smallest subtask array partition size to use as threshold */ |
73 |
|
static final int MIN_PARTITION = 16; |
74 |
|
|
75 |
< |
static final class CumulateTask<T> extends CountedCompleter<Void> { |
75 |
> |
private static final class CumulateTask<T> |
76 |
> |
extends CountedCompleter<Void> { |
77 |
|
final T[] array; |
78 |
|
final BinaryOperator<T> function; |
79 |
|
CumulateTask<T> left, right; |
80 |
|
T in, out; |
81 |
|
final int lo, hi, origin, fence, threshold; |
82 |
|
|
83 |
– |
/** Root task constructor */ |
84 |
– |
public CumulateTask(CumulateTask<T> parent, |
85 |
– |
BinaryOperator<T> function, |
86 |
– |
T[] array, int lo, int hi) { |
87 |
– |
super(parent); |
88 |
– |
this.function = function; this.array = array; |
89 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
90 |
– |
int p; |
91 |
– |
this.threshold = |
92 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
93 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
94 |
– |
} |
95 |
– |
|
96 |
– |
/** Subtask constructor */ |
83 |
|
CumulateTask(CumulateTask<T> parent, BinaryOperator<T> function, |
84 |
|
T[] array, int origin, int fence, int threshold, |
85 |
|
int lo, int hi) { |
211 |
|
private static final long serialVersionUID = 5293554502939613543L; |
212 |
|
} |
213 |
|
|
214 |
< |
static final class LongCumulateTask extends CountedCompleter<Void> { |
214 |
> |
private static final class LongCumulateTask |
215 |
> |
extends CountedCompleter<Void> { |
216 |
|
final long[] array; |
217 |
|
final LongBinaryOperator function; |
218 |
|
LongCumulateTask left, right; |
219 |
|
long in, out; |
220 |
|
final int lo, hi, origin, fence, threshold; |
221 |
|
|
235 |
– |
/** Root task constructor */ |
236 |
– |
public LongCumulateTask(LongCumulateTask parent, |
237 |
– |
LongBinaryOperator function, |
238 |
– |
long[] array, int lo, int hi) { |
239 |
– |
super(parent); |
240 |
– |
this.function = function; this.array = array; |
241 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
242 |
– |
int p; |
243 |
– |
this.threshold = |
244 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
245 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
246 |
– |
} |
247 |
– |
|
248 |
– |
/** Subtask constructor */ |
222 |
|
LongCumulateTask(LongCumulateTask parent, LongBinaryOperator function, |
223 |
|
long[] array, int origin, int fence, int threshold, |
224 |
|
int lo, int hi) { |
348 |
|
private static final long serialVersionUID = -5074099945909284273L; |
349 |
|
} |
350 |
|
|
351 |
< |
static final class DoubleCumulateTask extends CountedCompleter<Void> { |
351 |
> |
private static final class DoubleCumulateTask |
352 |
> |
extends CountedCompleter<Void> { |
353 |
|
final double[] array; |
354 |
|
final DoubleBinaryOperator function; |
355 |
|
DoubleCumulateTask left, right; |
356 |
|
double in, out; |
357 |
|
final int lo, hi, origin, fence, threshold; |
358 |
|
|
385 |
– |
/** Root task constructor */ |
386 |
– |
public DoubleCumulateTask(DoubleCumulateTask parent, |
387 |
– |
DoubleBinaryOperator function, |
388 |
– |
double[] array, int lo, int hi) { |
389 |
– |
super(parent); |
390 |
– |
this.function = function; this.array = array; |
391 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
392 |
– |
int p; |
393 |
– |
this.threshold = |
394 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
395 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
396 |
– |
} |
397 |
– |
|
398 |
– |
/** Subtask constructor */ |
359 |
|
DoubleCumulateTask(DoubleCumulateTask parent, DoubleBinaryOperator function, |
360 |
< |
double[] array, int origin, int fence, int threshold, |
361 |
< |
int lo, int hi) { |
360 |
> |
double[] array, int origin, int fence, int threshold, |
361 |
> |
int lo, int hi) { |
362 |
|
super(parent); |
363 |
|
this.function = function; this.array = array; |
364 |
|
this.origin = origin; this.fence = fence; |
485 |
|
private static final long serialVersionUID = -586947823794232033L; |
486 |
|
} |
487 |
|
|
488 |
< |
static final class IntCumulateTask extends CountedCompleter<Void> { |
488 |
> |
private static final class IntCumulateTask |
489 |
> |
extends CountedCompleter<Void> { |
490 |
|
final int[] array; |
491 |
|
final IntBinaryOperator function; |
492 |
|
IntCumulateTask left, right; |
493 |
|
int in, out; |
494 |
|
final int lo, hi, origin, fence, threshold; |
495 |
|
|
535 |
– |
/** Root task constructor */ |
536 |
– |
public IntCumulateTask(IntCumulateTask parent, |
537 |
– |
IntBinaryOperator function, |
538 |
– |
int[] array, int lo, int hi) { |
539 |
– |
super(parent); |
540 |
– |
this.function = function; this.array = array; |
541 |
– |
this.lo = this.origin = lo; this.hi = this.fence = hi; |
542 |
– |
int p; |
543 |
– |
this.threshold = |
544 |
– |
(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3)) |
545 |
– |
<= MIN_PARTITION ? MIN_PARTITION : p; |
546 |
– |
} |
547 |
– |
|
548 |
– |
/** Subtask constructor */ |
496 |
|
IntCumulateTask(IntCumulateTask parent, IntBinaryOperator function, |
497 |
< |
int[] array, int origin, int fence, int threshold, |
498 |
< |
int lo, int hi) { |
497 |
> |
int[] array, int origin, int fence, int threshold, |
498 |
> |
int lo, int hi) { |
499 |
|
super(parent); |
500 |
|
this.function = function; this.array = array; |
501 |
|
this.origin = origin; this.fence = fence; |