234 T lout = lt.out;
235 par.out = (rt.hi == fnc ? lout :
236 fn.apply(lout, rt.out));
237 }
238 int refork = (((b & CUMULATE) == 0 &&
239 par.lo == org) ? CUMULATE : 0);
240 if ((nextState = b|state|refork) == b ||
241 par.compareAndSetPendingCount(b, nextState)) {
242 state = SUMMED; // drop finished
243 t = par;
244 if (refork != 0)
245 par.fork();
246 }
247 }
248 else if (par.compareAndSetPendingCount(b, b|state))
249 break outer; // sib not ready
250 }
251 }
252 }
253 }
254 private static final long serialVersionUID = 5293554502939613543L;
255 }
256
257 static final class LongCumulateTask extends CountedCompleter<Void> {
258 final long[] array;
259 final LongBinaryOperator function;
260 LongCumulateTask left, right;
261 long in, out;
262 final int lo, hi, origin, fence, threshold;
263
264 /** Root task constructor */
265 public LongCumulateTask(LongCumulateTask parent,
266 LongBinaryOperator function,
267 long[] array, int lo, int hi) {
268 super(parent);
269 this.function = function; this.array = array;
270 this.lo = this.origin = lo; this.hi = this.fence = hi;
271 int p;
272 this.threshold =
273 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
384 long lout = lt.out;
385 par.out = (rt.hi == fnc ? lout :
386 fn.applyAsLong(lout, rt.out));
387 }
388 int refork = (((b & CUMULATE) == 0 &&
389 par.lo == org) ? CUMULATE : 0);
390 if ((nextState = b|state|refork) == b ||
391 par.compareAndSetPendingCount(b, nextState)) {
392 state = SUMMED; // drop finished
393 t = par;
394 if (refork != 0)
395 par.fork();
396 }
397 }
398 else if (par.compareAndSetPendingCount(b, b|state))
399 break outer; // sib not ready
400 }
401 }
402 }
403 }
404 private static final long serialVersionUID = -5074099945909284273L;
405 }
406
407 static final class DoubleCumulateTask extends CountedCompleter<Void> {
408 final double[] array;
409 final DoubleBinaryOperator function;
410 DoubleCumulateTask left, right;
411 double in, out;
412 final int lo, hi, origin, fence, threshold;
413
414 /** Root task constructor */
415 public DoubleCumulateTask(DoubleCumulateTask parent,
416 DoubleBinaryOperator function,
417 double[] array, int lo, int hi) {
418 super(parent);
419 this.function = function; this.array = array;
420 this.lo = this.origin = lo; this.hi = this.fence = hi;
421 int p;
422 this.threshold =
423 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
534 double lout = lt.out;
535 par.out = (rt.hi == fnc ? lout :
536 fn.applyAsDouble(lout, rt.out));
537 }
538 int refork = (((b & CUMULATE) == 0 &&
539 par.lo == org) ? CUMULATE : 0);
540 if ((nextState = b|state|refork) == b ||
541 par.compareAndSetPendingCount(b, nextState)) {
542 state = SUMMED; // drop finished
543 t = par;
544 if (refork != 0)
545 par.fork();
546 }
547 }
548 else if (par.compareAndSetPendingCount(b, b|state))
549 break outer; // sib not ready
550 }
551 }
552 }
553 }
554 private static final long serialVersionUID = -586947823794232033L;
555 }
556
557 static final class IntCumulateTask extends CountedCompleter<Void> {
558 final int[] array;
559 final IntBinaryOperator function;
560 IntCumulateTask left, right;
561 int in, out;
562 final int lo, hi, origin, fence, threshold;
563
564 /** Root task constructor */
565 public IntCumulateTask(IntCumulateTask parent,
566 IntBinaryOperator function,
567 int[] array, int lo, int hi) {
568 super(parent);
569 this.function = function; this.array = array;
570 this.lo = this.origin = lo; this.hi = this.fence = hi;
571 int p;
572 this.threshold =
573 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
684 int lout = lt.out;
685 par.out = (rt.hi == fnc ? lout :
686 fn.applyAsInt(lout, rt.out));
687 }
688 int refork = (((b & CUMULATE) == 0 &&
689 par.lo == org) ? CUMULATE : 0);
690 if ((nextState = b|state|refork) == b ||
691 par.compareAndSetPendingCount(b, nextState)) {
692 state = SUMMED; // drop finished
693 t = par;
694 if (refork != 0)
695 par.fork();
696 }
697 }
698 else if (par.compareAndSetPendingCount(b, b|state))
699 break outer; // sib not ready
700 }
701 }
702 }
703 }
704 private static final long serialVersionUID = 3731755594596840961L;
705 }
706 }
|
234 T lout = lt.out;
235 par.out = (rt.hi == fnc ? lout :
236 fn.apply(lout, rt.out));
237 }
238 int refork = (((b & CUMULATE) == 0 &&
239 par.lo == org) ? CUMULATE : 0);
240 if ((nextState = b|state|refork) == b ||
241 par.compareAndSetPendingCount(b, nextState)) {
242 state = SUMMED; // drop finished
243 t = par;
244 if (refork != 0)
245 par.fork();
246 }
247 }
248 else if (par.compareAndSetPendingCount(b, b|state))
249 break outer; // sib not ready
250 }
251 }
252 }
253 }
254 @java.io.Serial
255 private static final long serialVersionUID = 5293554502939613543L;
256 }
257
258 static final class LongCumulateTask extends CountedCompleter<Void> {
259 final long[] array;
260 final LongBinaryOperator function;
261 LongCumulateTask left, right;
262 long in, out;
263 final int lo, hi, origin, fence, threshold;
264
265 /** Root task constructor */
266 public LongCumulateTask(LongCumulateTask parent,
267 LongBinaryOperator function,
268 long[] array, int lo, int hi) {
269 super(parent);
270 this.function = function; this.array = array;
271 this.lo = this.origin = lo; this.hi = this.fence = hi;
272 int p;
273 this.threshold =
274 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
385 long lout = lt.out;
386 par.out = (rt.hi == fnc ? lout :
387 fn.applyAsLong(lout, rt.out));
388 }
389 int refork = (((b & CUMULATE) == 0 &&
390 par.lo == org) ? CUMULATE : 0);
391 if ((nextState = b|state|refork) == b ||
392 par.compareAndSetPendingCount(b, nextState)) {
393 state = SUMMED; // drop finished
394 t = par;
395 if (refork != 0)
396 par.fork();
397 }
398 }
399 else if (par.compareAndSetPendingCount(b, b|state))
400 break outer; // sib not ready
401 }
402 }
403 }
404 }
405 @java.io.Serial
406 private static final long serialVersionUID = -5074099945909284273L;
407 }
408
409 static final class DoubleCumulateTask extends CountedCompleter<Void> {
410 final double[] array;
411 final DoubleBinaryOperator function;
412 DoubleCumulateTask left, right;
413 double in, out;
414 final int lo, hi, origin, fence, threshold;
415
416 /** Root task constructor */
417 public DoubleCumulateTask(DoubleCumulateTask parent,
418 DoubleBinaryOperator function,
419 double[] array, int lo, int hi) {
420 super(parent);
421 this.function = function; this.array = array;
422 this.lo = this.origin = lo; this.hi = this.fence = hi;
423 int p;
424 this.threshold =
425 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
536 double lout = lt.out;
537 par.out = (rt.hi == fnc ? lout :
538 fn.applyAsDouble(lout, rt.out));
539 }
540 int refork = (((b & CUMULATE) == 0 &&
541 par.lo == org) ? CUMULATE : 0);
542 if ((nextState = b|state|refork) == b ||
543 par.compareAndSetPendingCount(b, nextState)) {
544 state = SUMMED; // drop finished
545 t = par;
546 if (refork != 0)
547 par.fork();
548 }
549 }
550 else if (par.compareAndSetPendingCount(b, b|state))
551 break outer; // sib not ready
552 }
553 }
554 }
555 }
556 @java.io.Serial
557 private static final long serialVersionUID = -586947823794232033L;
558 }
559
560 static final class IntCumulateTask extends CountedCompleter<Void> {
561 final int[] array;
562 final IntBinaryOperator function;
563 IntCumulateTask left, right;
564 int in, out;
565 final int lo, hi, origin, fence, threshold;
566
567 /** Root task constructor */
568 public IntCumulateTask(IntCumulateTask parent,
569 IntBinaryOperator function,
570 int[] array, int lo, int hi) {
571 super(parent);
572 this.function = function; this.array = array;
573 this.lo = this.origin = lo; this.hi = this.fence = hi;
574 int p;
575 this.threshold =
576 (p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
687 int lout = lt.out;
688 par.out = (rt.hi == fnc ? lout :
689 fn.applyAsInt(lout, rt.out));
690 }
691 int refork = (((b & CUMULATE) == 0 &&
692 par.lo == org) ? CUMULATE : 0);
693 if ((nextState = b|state|refork) == b ||
694 par.compareAndSetPendingCount(b, nextState)) {
695 state = SUMMED; // drop finished
696 t = par;
697 if (refork != 0)
698 par.fork();
699 }
700 }
701 else if (par.compareAndSetPendingCount(b, b|state))
702 break outer; // sib not ready
703 }
704 }
705 }
706 }
707 @java.io.Serial
708 private static final long serialVersionUID = 3731755594596840961L;
709 }
710 }
|