ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/ArrayPrefixHelpers.java
(Generate patch)

Comparing jsr166/src/main/java/util/ArrayPrefixHelpers.java (file contents):
Revision 1.3 by jsr166, Wed Dec 31 04:53:37 2014 UTC vs.
Revision 1.12 by jsr166, Thu Oct 10 16:53:08 2019 UTC

# Line 5 | Line 5
5   */
6  
7   package java.util;
8 < import java.util.concurrent.ForkJoinPool;
8 >
9   import java.util.concurrent.CountedCompleter;
10 + import java.util.concurrent.ForkJoinPool;
11   import java.util.function.BinaryOperator;
12 + import java.util.function.DoubleBinaryOperator;
13   import java.util.function.IntBinaryOperator;
14   import java.util.function.LongBinaryOperator;
13 – import java.util.function.DoubleBinaryOperator;
15  
16   /**
17   * ForkJoin tasks to perform Arrays.parallelPrefix operations.
# Line 73 | Line 74 | class ArrayPrefixHelpers {
74      static final int MIN_PARTITION = 16;
75  
76      static final class CumulateTask<T> extends CountedCompleter<Void> {
77 +        @SuppressWarnings("serial") // Not statically typed as Serializable
78          final T[] array;
79          final BinaryOperator<T> function;
80          CumulateTask<T> left, right;
81 <        T in, out;
81 >        @SuppressWarnings("serial") // Not statically typed as Serializable
82 >        T in;
83 >        @SuppressWarnings("serial") // Not statically typed as Serializable
84 >        T out;
85          final int lo, hi, origin, fence, threshold;
86  
87          /** Root task constructor */
# Line 117 | Line 122 | class ArrayPrefixHelpers {
122                          int mid = (l + h) >>> 1;
123                          f = rt = t.right =
124                              new CumulateTask<T>(t, fn, a, org, fnc, th, mid, h);
125 <                        t = lt = t.left  =
125 >                        t = lt = t.left =
126                              new CumulateTask<T>(t, fn, a, org, fnc, th, l, mid);
127                      }
128                      else {                           // possibly refork
# Line 221 | Line 226 | class ArrayPrefixHelpers {
226                  }
227              }
228          }
229 +        // OPENJDK @java.io.Serial
230          private static final long serialVersionUID = 5293554502939613543L;
231      }
232  
233      static final class LongCumulateTask extends CountedCompleter<Void> {
234          final long[] array;
235 +        @SuppressWarnings("serial") // Not statically typed as Serializable
236          final LongBinaryOperator function;
237          LongCumulateTask left, right;
238          long in, out;
# Line 269 | Line 276 | class ArrayPrefixHelpers {
276                          int mid = (l + h) >>> 1;
277                          f = rt = t.right =
278                              new LongCumulateTask(t, fn, a, org, fnc, th, mid, h);
279 <                        t = lt = t.left  =
279 >                        t = lt = t.left =
280                              new LongCumulateTask(t, fn, a, org, fnc, th, l, mid);
281                      }
282                      else {                           // possibly refork
# Line 371 | Line 378 | class ArrayPrefixHelpers {
378                  }
379              }
380          }
381 +        // OPENJDK @java.io.Serial
382          private static final long serialVersionUID = -5074099945909284273L;
383      }
384  
385      static final class DoubleCumulateTask extends CountedCompleter<Void> {
386          final double[] array;
387 +        @SuppressWarnings("serial") // Not statically typed as Serializable
388          final DoubleBinaryOperator function;
389          DoubleCumulateTask left, right;
390          double in, out;
# Line 383 | Line 392 | class ArrayPrefixHelpers {
392  
393          /** Root task constructor */
394          public DoubleCumulateTask(DoubleCumulateTask parent,
395 <                                DoubleBinaryOperator function,
396 <                                double[] array, int lo, int hi) {
395 >                                  DoubleBinaryOperator function,
396 >                                  double[] array, int lo, int hi) {
397              super(parent);
398              this.function = function; this.array = array;
399              this.lo = this.origin = lo; this.hi = this.fence = hi;
# Line 396 | Line 405 | class ArrayPrefixHelpers {
405  
406          /** Subtask constructor */
407          DoubleCumulateTask(DoubleCumulateTask parent, DoubleBinaryOperator function,
408 <                         double[] array, int origin, int fence, int threshold,
409 <                         int lo, int hi) {
408 >                           double[] array, int origin, int fence, int threshold,
409 >                           int lo, int hi) {
410              super(parent);
411              this.function = function; this.array = array;
412              this.origin = origin; this.fence = fence;
# Line 419 | Line 428 | class ArrayPrefixHelpers {
428                          int mid = (l + h) >>> 1;
429                          f = rt = t.right =
430                              new DoubleCumulateTask(t, fn, a, org, fnc, th, mid, h);
431 <                        t = lt = t.left  =
431 >                        t = lt = t.left =
432                              new DoubleCumulateTask(t, fn, a, org, fnc, th, l, mid);
433                      }
434                      else {                           // possibly refork
# Line 521 | Line 530 | class ArrayPrefixHelpers {
530                  }
531              }
532          }
533 +        // OPENJDK @java.io.Serial
534          private static final long serialVersionUID = -586947823794232033L;
535      }
536  
537      static final class IntCumulateTask extends CountedCompleter<Void> {
538          final int[] array;
539 +        @SuppressWarnings("serial") // Not statically typed as Serializable
540          final IntBinaryOperator function;
541          IntCumulateTask left, right;
542          int in, out;
# Line 533 | Line 544 | class ArrayPrefixHelpers {
544  
545          /** Root task constructor */
546          public IntCumulateTask(IntCumulateTask parent,
547 <                                IntBinaryOperator function,
548 <                                int[] array, int lo, int hi) {
547 >                               IntBinaryOperator function,
548 >                               int[] array, int lo, int hi) {
549              super(parent);
550              this.function = function; this.array = array;
551              this.lo = this.origin = lo; this.hi = this.fence = hi;
# Line 546 | Line 557 | class ArrayPrefixHelpers {
557  
558          /** Subtask constructor */
559          IntCumulateTask(IntCumulateTask parent, IntBinaryOperator function,
560 <                         int[] array, int origin, int fence, int threshold,
561 <                         int lo, int hi) {
560 >                        int[] array, int origin, int fence, int threshold,
561 >                        int lo, int hi) {
562              super(parent);
563              this.function = function; this.array = array;
564              this.origin = origin; this.fence = fence;
# Line 569 | Line 580 | class ArrayPrefixHelpers {
580                          int mid = (l + h) >>> 1;
581                          f = rt = t.right =
582                              new IntCumulateTask(t, fn, a, org, fnc, th, mid, h);
583 <                        t = lt = t.left  =
583 >                        t = lt = t.left =
584                              new IntCumulateTask(t, fn, a, org, fnc, th, l, mid);
585                      }
586                      else {                           // possibly refork
# Line 671 | Line 682 | class ArrayPrefixHelpers {
682                  }
683              }
684          }
685 +        // OPENJDK @java.io.Serial
686          private static final long serialVersionUID = 3731755594596840961L;
687      }
676 –
688   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines