ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/loops/CachedThreadPoolLoops.java

Comparing jsr166/src/test/loops/CachedThreadPoolLoops.java (file contents):
Revision 1.1 by dl, Tue May 31 15:08:32 2005 UTC vs.
Revision 1.8 by jsr166, Thu Dec 18 18:13:06 2014 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. Use, modify, and
4	<	* redistribute this code in any way without acknowledgement.
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	+	//import jsr166y.*;
8		import java.util.concurrent.*;
9		import java.util.concurrent.atomic.*;
10
11		public class CachedThreadPoolLoops {
12	+	static final int NCPUS = Runtime.getRuntime().availableProcessors();
13		static final AtomicInteger remaining = new AtomicInteger();
14		static final int maxIters = 1000000;
15
16		public static void main(String[] args) throws Exception {
17	<	int maxThreads = 100;
18	<
17	<	if (args.length > 0)
17	>	int maxThreads = NCPUS * 3 / 2; // 100;
18	>	if (args.length > 0)
19		maxThreads = Integer.parseInt(args[0]);
20	<
21	<	int k = 1;
22	<	for (int i = 1; i <= maxThreads;) {
20	>
21	>	System.out.print("Warmup:");
22	>	for (int j = 0; j < 1; ++j) {
23	>	for (int k = 1, i = 1; i <= maxThreads;) {
24	>	System.out.print(" " + i);
25	>	oneTest(i, 10000, false);
26	>	Thread.sleep(100);
27	>	if (i == k) {
28	>	k = i << 1;
29	>	i = i + (i >>> 1);
30	>	}
31	>	else
32	>	i = k;
33	>	}
34	>	}
35	>	System.out.println();
36	>
37	>	for (int k = 1, i = 1; i <= maxThreads;) {
38		System.out.println("Threads:" + i);
39	<	oneTest(i);
39	>	oneTest(i, maxIters, true);
40		Thread.sleep(100);
41		if (i == k) {
42		k = i << 1;
43		i = i + (i >>> 1);
44	<	}
45	<	else
44	>	}
45	>	else
46		i = k;
47		}
48	<	}
48	>	}
49	>
50	>	static void oneTest(int nThreads, int iters, boolean print) throws Exception {
51	>	Thread.sleep(100); // System.gc();
52	>	if (print) System.out.print("LinkedTransferQueue      ");
53	>	oneRun(new LinkedTransferQueue<Runnable>(), nThreads, iters, print);
54	>
55	>	Thread.sleep(100); // System.gc();
56	>	if (print) System.out.print("LinkedBlockingQueue      ");
57	>	oneRun(new LinkedBlockingQueue<Runnable>(), nThreads, iters, print);
58	>
59	>	Thread.sleep(100); // System.gc();
60	>	if (print) System.out.print("SynchronousQueue         ");
61	>	oneRun(new SynchronousQueue<Runnable>(false), nThreads, iters, print);
62	>
63	>	Thread.sleep(100); // System.gc();
64	>	if (print) System.out.print("SynchronousQueue(fair)   ");
65	>	oneRun(new SynchronousQueue<Runnable>(true), nThreads, iters, print);
66	>
67	>	Thread.sleep(100); // System.gc();
68	>	if (print) System.out.print("LinkedTransferQueue(xfer)");
69	>	oneRun(new LTQasSQ<Runnable>(), nThreads, iters, print);
70	>
71	>	Thread.sleep(100); // System.gc();
72	>	if (print) System.out.print("LinkedTransferQueue(half)");
73	>	oneRun(new HalfSyncLTQ<Runnable>(), nThreads, iters, print);
74	>
75	>	Thread.sleep(100); // System.gc();
76	>	if (print) System.out.print("ArrayBlockingQueue(256) ");
77	>	oneRun(new ArrayBlockingQueue<Runnable>(256), nThreads, iters, print);
78
34	–	static void oneTest(int nThreads) throws Exception {
35	–	System.out.print("SynchronousQueue        ");
36	–	oneRun(new SynchronousQueue<Runnable>(), nThreads);
37	–	System.out.print("SynchronousQueue(fair)  ");
38	–	oneRun(new SynchronousQueue<Runnable>(true), nThreads);
79		}
80
81		static final class Task implements Runnable {
82		final ThreadPoolExecutor pool;
83		final CountDownLatch done;
84	<	Task(ThreadPoolExecutor p, CountDownLatch d) {
85	<	pool = p;
84	>	Task(ThreadPoolExecutor p, CountDownLatch d) {
85	>	pool = p;
86		done = d;
87		}
88		public void run() {
#	Line 50 | Line 90 | public class CachedThreadPoolLoops {
90		remaining.incrementAndGet();
91		int n;
92		while (!Thread.interrupted() &&
93	<	(n = remaining.get()) > 0 &&
93	>	(n = remaining.get()) > 0 &&
94		done.getCount() > 0) {
95		if (remaining.compareAndSet(n, n-1)) {
96		try {
#	Line 65 | Line 105 | public class CachedThreadPoolLoops {
105		}
106		}
107		}
108	<
109	<	static void oneRun(BlockingQueue<Runnable> q, int nThreads) throws Exception {
110	<
111	<	ThreadPoolExecutor pool =
108	>
109	>	static void oneRun(BlockingQueue<Runnable> q, int nThreads, int iters, boolean print) throws Exception {
110	>
111	>	ThreadPoolExecutor pool =
112		new ThreadPoolExecutor(nThreads+1, Integer.MAX_VALUE,
113		1L, TimeUnit.SECONDS, q);
114
115	<	CountDownLatch done = new CountDownLatch(maxIters);
115	>	CountDownLatch done = new CountDownLatch(iters);
116		remaining.set(nThreads-1);
117		pool.prestartAllCoreThreads();
118		Task t = new Task(pool, done);
#	Line 80 | Line 120 | public class CachedThreadPoolLoops {
120		pool.execute(t);
121		done.await();
122		long time = System.nanoTime() - start;
123	<	System.out.println("\t: " + LoopHelpers.rightJustify(time / maxIters) + " ns per task");
123	>	if (print)
124	>	System.out.println("\t: " + LoopHelpers.rightJustify(time / iters) + " ns per task");
125	>	q.clear();
126	>	Thread.sleep(100);
127	>	pool.shutdown();
128	>	Thread.sleep(100);
129		pool.shutdownNow();
130		}
131
132	+	static final class LTQasSQ<T> extends LinkedTransferQueue<T> {
133	+	LTQasSQ() { super(); }
134	+	public void put(T x) {
135	+	try { super.transfer(x);
136	+	} catch (InterruptedException ex) { throw new Error(); }
137	+	}
138	+	}
139	+
140	+	static final class HalfSyncLTQ<T> extends LinkedTransferQueue<T> {
141	+	int calls;
142	+	HalfSyncLTQ() { super(); }
143	+	public void put(T x) {
144	+	if ((++calls & 1) == 0)
145	+	super.put(x);
146	+	else {
147	+	try { super.transfer(x);
148	+	} catch (InterruptedException ex) {
149	+	throw new Error();
150	+	}
151	+	}
152	+	}
153	+	}
154	+
155		}

Diff Legend

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