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.5 by jsr166, Mon Sep 20 20:42:37 2010 UTC vs.
Revision 1.14 by jsr166, Mon Aug 10 03:13:33 2015 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.*;
7   import java.util.*;
8 + import java.util.concurrent.*;
9  
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 {
16 >    public static void main(String[] args) throws Exception {
17          int procs = 0;
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 75 | Line 78 | class ScalarLongSort {
78          }
79          System.out.println(pool);
80  
78 –
81          pool.shutdown();
82      }
83  
# Line 88 | Line 90 | class ScalarLongSort {
90              this.a = a; this.w = w; this.origin = origin; this.n = n;
91          }
92  
93 <        public void compute()  {
93 >        public void compute() {
94              int l = origin;
95              if (n <= THRESHOLD)
96                  Arrays.sort(a, l, l+n);
# Line 145 | Line 147 | class ScalarLongSort {
147           * and finding index of right closest to split point.
148           * Uses left-spine decomposition to generate all
149           * merge tasks before bottomming out at base case.
148 –         *
150           */
151          public final void compute() {
152              Merger rights = null;
# Line 173 | Line 174 | class ScalarLongSort {
174              merge(nleft, nright);
175              if (rights != null)
176                  collectRights(rights);
176 –
177          }
178  
179          final void merge(int nleft, int nright) {
# Line 206 | Line 206 | class ScalarLongSort {
206  
207      }
208  
209 <    static void checkSorted (long[] a)  {
209 >    static void checkSorted(long[] a) {
210          int n = a.length;
211          for (int i = 0; i < n - 1; i++) {
212              if (a[i] > a[i+1]) {
# Line 244 | Line 244 | class ScalarLongSort {
244              }
245          }
246      }
247 –
248 –
247   }

Diff Legend

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