ViewVC Help

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

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

Comparing jsr166/src/test/loops/RLJBar.java (file contents):
Revision 1.2 by dl, Mon Feb 19 00:46:06 2007 UTC vs.
Revision 1.9 by jsr166, Wed Dec 31 17:00:58 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, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7		// Yet another contended object monitor throughput test
8		// adapted from bug reports
9
10		import java.util.*;
11	–	import java.lang.*;
11		import java.util.concurrent.*;
12		import java.util.concurrent.locks.*;
13	<
14	<	class Producer extends Thread
13	>
14	>	class Producer extends Thread
15		{
16		//  private static Hashtable buddiesOnline = new Hashtable();
17	<	private static Map buddiesOnline = new ConcurrentHashMap();
18	<	public Producer (String name) { super(name); }
17	>	private static Map buddiesOnline = new ConcurrentHashMap();
18	>	public Producer(String name) { super(name); }
19	>
20	>	public void run() {
21	>	Object key = null;
22	>	final ReentrantLock dr = RLJBar.DeathRow;
23	>	final ReentrantLock bar = RLJBar.bar;
24	>	final ReentrantLock end = RLJBar.End;
25	>	final Condition endCondition = RLJBar.EndCondition;
26	>	if (RLJBar.OneKey) key = new Integer(0);         // per-thread v. per iteration
27	>
28	>	// The barrier has a number of interesting effects:
29	>	// 1.     It enforces full LWP provisioning on T1.
30	>	//                (nearly all workers park concurrently).
31	>	// 2.     It gives the C2 compiler thread(s) a chance to run.
32	>	//                By transiently quiescing the workings the C2 threads
33	>	//                might avoid starvation.
34	>	//
35	>
36	>	try {
37	>	bar.lock();
38	>	try {
39	>	++RLJBar.nUp;
40	>	if (RLJBar.nUp == RLJBar.nThreads) {
41	>	if (RLJBar.quiesce != 0) {
42	>	RLJBar.barCondition.awaitNanos(RLJBar.quiesce * 1000000);
43	>	}
44	>	RLJBar.epoch = System.currentTimeMillis();
45	>	RLJBar.barCondition.signalAll();
46	>	//                  System.out.print ("Consensus ");
47	>	}
48	>	if (RLJBar.UseBar) {
49	>	while (RLJBar.nUp != RLJBar.nThreads) {
50	>	RLJBar.barCondition.await();
51	>	}
52	>	}
53	>	}
54	>	finally {
55	>	bar.unlock();
56	>	}
57	>	} catch (Exception ex) {
58	>	System.out.println("Exception in barrier: " + ex);
59	>	}
60	>
61	>	// Main execution time ... the code being timed ...
62	>	// HashTable.get() is highly contended (serial).
63	>	for (int loop = 1; loop < 100000 ;loop++) {
64	>	if (!RLJBar.OneKey) key = new Integer(0);
65	>	buddiesOnline.get(key);
66	>	}
67
68	<	public void run()
69	<	{
70	<	Object key = null ;
71	<	final ReentrantLock dr = RLJBar.DeathRow;
72	<	final ReentrantLock bar = RLJBar.bar;
73	<	final ReentrantLock end = RLJBar.End;
74	<	final Condition endCondition = RLJBar.EndCondition;
75	<	if (RLJBar.OneKey) key = new Integer(0) ;         // per-thread v. per iteration
76	<
77	<	// The barrier has a number of interesting effects:
78	<	// 1.     It enforces full LWP provisioning on T1.
79	<	//                (nearly all workers park concurrently).
80	<	// 2.     It gives the C2 compiler thread(s) a chance to run.
81	<	//                By transiently quiescing the workings the C2 threads
82	<	//                might avoid starvation.
83	<	//
84	<
38	<	try {
39	<	bar.lock();
40	<	try {
41	<	++RLJBar.nUp ;
42	<	if (RLJBar.nUp == RLJBar.nThreads) {
43	<	if (RLJBar.quiesce != 0) {
44	<	RLJBar.barCondition.awaitNanos(RLJBar.quiesce * 1000000) ;
45	<	}
46	<	RLJBar.epoch = System.currentTimeMillis () ;
47	<	RLJBar.barCondition.signalAll () ;
48	<	//                  System.out.print ("Consensus ") ;
49	<	}
50	<	if (RLJBar.UseBar) {
51	<	while (RLJBar.nUp != RLJBar.nThreads) {
52	<	RLJBar.barCondition.await () ;
53	<	}
54	<	}
55	<	}
56	<	finally {
57	<	bar.unlock();
58	<	}
59	<	} catch (Exception ex) {
60	<	System.out.println ("Exception in barrier: " + ex) ;
61	<	}
62	<
63	<	// Main execution time ... the code being timed ...
64	<	// HashTable.get() is highly contended (serial).
65	<	for (int loop = 1; loop < 100000 ;loop++) {
66	<	if (!RLJBar.OneKey) key = new Integer(0) ;
67	<	buddiesOnline.get(key);
68	<	}
69	<
70	<	// Mutator epilog:
71	<	// The following code determines if the test will/wont include (measure)
72	<	// thread death time.
73	<
74	<	end.lock();
75	<	try {
76	<	++RLJBar.nDead ;
77	<	if (RLJBar.nDead == RLJBar.nUp) {
78	<	//          System.out.print((System.currentTimeMillis()-RLJBar.epoch) + " ms") ;
79	<	endCondition.signalAll() ;
80	<	}
81	<	}
82	<	finally {
83	<	end.unlock();
84	<	}
85	<	dr.lock();
86	<	dr.unlock();
68	>	// Mutator epilog:
69	>	// The following code determines if the test will/wont include (measure)
70	>	// thread death time.
71	>
72	>	end.lock();
73	>	try {
74	>	++RLJBar.nDead;
75	>	if (RLJBar.nDead == RLJBar.nUp) {
76	>	//          System.out.print((System.currentTimeMillis()-RLJBar.epoch) + " ms");
77	>	endCondition.signalAll();
78	>	}
79	>	}
80	>	finally {
81	>	end.unlock();
82	>	}
83	>	dr.lock();
84	>	dr.unlock();
85		}
86		}
87
88
89	<	public class RLJBar                             // ProdConsTest
89	>	public class RLJBar                             // ProdConsTest
90		{
91
92		public static final int ITERS = 10;
93	<	public static boolean OneKey = false ;                        // alloc once or once per iteration
93	>	public static boolean OneKey = false;                        // alloc once or once per iteration
94
95	<	public static boolean UseBar = false ;
96	<	public static int nThreads = 100 ;
97	<	public static int nUp = 0 ;
98	<	public static int nDead = 0 ;
99	<	public static ReentrantLock bar = new ReentrantLock() ;
100	<	public static Condition barCondition = bar.newCondition() ;
101	<	public static long epoch ;
102	<	public static ReentrantLock DeathRow = new ReentrantLock () ;
103	<	public static ReentrantLock End = new ReentrantLock () ;
104	<	public static int quiesce = 0 ;
105	<	public static Condition EndCondition = End.newCondition();
106	<
107	<	public static void main (String[] args)    {
108	<	int argix = 0 ;
109	<	if (argix < args.length && args[argix].equals("-o")) {
110	<	++argix ;
111	<	OneKey = true ;
112	<	System.out.println ("OneKey") ;
113	<	}
114	<	if (argix < args.length && args[argix].equals ("-b")) {
115	<	++argix ;
116	<	UseBar = true ;
117	<	System.out.println ("UseBar") ;
118	<	}
119	<	if (argix < args.length && args[argix].equals ("-q")) {
120	<	++argix ;
121	<	if (argix < args.length) {
122	<	quiesce = Integer.parseInt (args[argix++]) ;
123	<	System.out.println ("Quiesce " + quiesce + " msecs") ;
124	<	}
125	<	}
126	<	for (int k = 0; k < ITERS; ++k)
127	<	oneRun();
128	<	}
95	>	public static boolean UseBar = false;
96	>	public static int nThreads = 100;
97	>	public static int nUp = 0;
98	>	public static int nDead = 0;
99	>	public static ReentrantLock bar = new ReentrantLock();
100	>	public static Condition barCondition = bar.newCondition();
101	>	public static long epoch;
102	>	public static ReentrantLock DeathRow = new ReentrantLock();
103	>	public static ReentrantLock End = new ReentrantLock();
104	>	public static int quiesce = 0;
105	>	public static Condition EndCondition = End.newCondition();
106	>
107	>	public static void main(String[] args) {
108	>	int argix = 0;
109	>	if (argix < args.length && args[argix].equals("-o")) {
110	>	++argix;
111	>	OneKey = true;
112	>	System.out.println("OneKey");
113	>	}
114	>	if (argix < args.length && args[argix].equals ("-b")) {
115	>	++argix;
116	>	UseBar = true;
117	>	System.out.println("UseBar");
118	>	}
119	>	if (argix < args.length && args[argix].equals ("-q")) {
120	>	++argix;
121	>	if (argix < args.length) {
122	>	quiesce = Integer.parseInt(args[argix++]);
123	>	System.out.println("Quiesce " + quiesce + " msecs");
124	>	}
125	>	}
126	>	for (int k = 0; k < ITERS; ++k)
127	>	oneRun();
128	>	}
129
130		public static void oneRun() {
131	<	DeathRow = new ReentrantLock () ;
132	<	End = new ReentrantLock () ;
131	>	DeathRow = new ReentrantLock();
132	>	End = new ReentrantLock();
133		EndCondition = End.newCondition();
134	<
135	<	nDead = nUp = 0 ;
136	<	long cyBase = System.currentTimeMillis () ;
134	>
135	>	nDead = nUp = 0;
136	>	long cyBase = System.currentTimeMillis();
137		DeathRow.lock();
138		try {
139	<	for (int i = 1; i <= nThreads ; i++) {
139	>	for (int i = 1; i <= nThreads; i++) {
140		new Producer("Producer" + i).start();
141		}
142	<	try {
142	>	try {
143		End.lock();
144		try {
145	<	while (nDead != nThreads)
146	<	EndCondition.await() ;
145	>	while (nDead != nThreads)
146	>	EndCondition.await();
147		}
148		finally {
149		End.unlock();
150		}
151	<	} catch (Exception ex) {
152	<	System.out.println ("Exception in End: " + ex) ;
151	>	} catch (Exception ex) {
152	>	System.out.println("Exception in End: " + ex);
153		}
154		}
155		finally {
156		DeathRow.unlock();
157		}
158	<	System.out.println ("Outer time: " + (System.currentTimeMillis()-cyBase)) ;
159	<
160	<	// Let workers quiesce/exit.
161	<	try { Thread.sleep (1000) ; } catch (Exception ex) {} ;
158	>	System.out.println("Outer time: " + (System.currentTimeMillis()-cyBase));
159	>
160	>	// Let workers quiesce/exit.
161	>	try { Thread.sleep (1000); } catch (Exception ex) {};
162		}
163		}
166	–
167	–
168	–

Diff Legend

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