ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/loops/ScalarLongSort.java
(Generate patch)

Comparing jsr166/src/test/loops/ScalarLongSort.java (file contents):
Revision 1.4 by dl, Sun Sep 19 12:55:37 2010 UTC vs.
Revision 1.9 by dl, Fri Aug 19 11:25:04 2011 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7   import java.util.concurrent.*;
# Line 10 | Line 10 | import java.util.*;
10   class ScalarLongSort {
11      static final long NPS = (1000L * 1000 * 1000);
12  
13 <    static int THRESHOLD;
13 >    static int THRESHOLD = -1;
14      static final boolean warmup = true;
15  
16      public static void main (String[] args) throws Exception {
# Line 18 | Line 18 | class ScalarLongSort {
18          int n = 1 << 22;
19          int reps = 20;
20          int sreps = 2;
21 +        int st = -1;
22          try {
23              if (args.length > 0)
24                  procs = Integer.parseInt(args[0]);
25              if (args.length > 1)
26                  n = Integer.parseInt(args[1]);
27              if (args.length > 2)
28 <                reps = Integer.parseInt(args[1]);
28 >                reps = Integer.parseInt(args[2]);
29 >            if (args.length > 3)
30 >                st = Integer.parseInt(args[3]);
31          }
32          catch (Exception e) {
33 <            System.out.println("Usage: java ScalarLongSort threads n reps");
33 >            System.out.println("Usage: java ScalarLongSort threads n reps sequential-threshold");
34              return;
35          }
36 <        ForkJoinPool pool = procs == 0? new ForkJoinPool() :
36 >        ForkJoinPool pool = (procs == 0) ? new ForkJoinPool() :
37              new ForkJoinPool(procs);
38  
39          long[] a = new long[n];
# Line 46 | Line 49 | class ScalarLongSort {
49              checkSorted(a);
50          }
51  
52 <        // for now hardwire 8 * #CPUs leaf tasks
53 <        THRESHOLD = 1 + ((n + 7) >>> 3) / pool.getParallelism();
54 <        //        THRESHOLD = 1 + ((n + 15) >>> 4) / pool.getParallelism();
55 <        //        THRESHOLD = 1 + ((n + 31) >>> 5) / pool.getParallelism();
52 >        if (st <= 0) // for now hardwire 8 * #CPUs leaf tasks
53 >            THRESHOLD = 1 + ((n + 7) >>> 3) / pool.getParallelism();
54 >        else
55 >            THRESHOLD = st;
56  
57          System.out.printf("Sorting %d longs, %d replications\n", n, reps);
58          for (int i = 0; i < reps; ++i) {
# Line 80 | Line 83 | class ScalarLongSort {
83      }
84  
85      static final class Sorter extends RecursiveAction {
86 <        final long[] a;
86 >        final long[] a;
87          final long[] w;
88 <        final int origin;
88 >        final int origin;
89          final int n;
90          Sorter(long[] a, long[] w, int origin, int n) {
91              this.a = a; this.w = w; this.origin = origin; this.n = n;
92          }
93  
94 <        public void compute()  {
94 >        public void compute() {
95              int l = origin;
96              if (n <= THRESHOLD)
97                  Arrays.sort(a, l, l+n);
# Line 111 | Line 114 | class ScalarLongSort {
114              }
115          }
116      }
117 <    
117 >
118      static final class SubSorter extends RecursiveAction {
119          final Sorter left;
120          final Sorter right;
# Line 145 | Line 148 | class ScalarLongSort {
148           * and finding index of right closest to split point.
149           * Uses left-spine decomposition to generate all
150           * merge tasks before bottomming out at base case.
151 <         *
151 >         *
152           */
153          public final void compute() {
154              Merger rights = null;
# Line 169 | Line 172 | class ScalarLongSort {
172                  nleft = lh;
173                  nright = rh;
174              }
175 <            
175 >
176              merge(nleft, nright);
177 <            if (rights != null)
177 >            if (rights != null)
178                  collectRights(rights);
179 <            
179 >
180          }
181  
182          final void merge(int nleft, int nright) {
# Line 206 | Line 209 | class ScalarLongSort {
209  
210      }
211  
212 <    static void checkSorted (long[] a)  {
212 >    static void checkSorted (long[] a) {
213          int n = a.length;
214          for (int i = 0; i < n - 1; i++) {
215              if (a[i] > a[i+1]) {
216 <                throw new Error("Unsorted at " + i + ": " +
216 >                throw new Error("Unsorted at " + i + ": " +
217                                  a[i] + " / " + a[i+1]);
218              }
219          }

Diff Legend

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