ViewVC Help

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

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

Comparing jsr166/src/test/loops/RLIBar.java (file contents):
Revision 1.2 by dl, Mon May 9 19:33:30 2005 UTC vs.
Revision 1.3 by jsr166, Thu Oct 29 23:09:08 2009 UTC

#	Line 6 | Line 6
6		// Adapted from code that was in turn
7		// Derived from SocketPerformanceTest.java - BugID: 4763450
8		//
9	<	//
9	>	//
10
11		import java.io.*;
12		import java.net.*;
#	Line 15 | Line 15 | import java.util.concurrent.locks.*;
15
16		public class RLIBar {
17
18	<	static int batchLimit ;
19	<	static int mseq ;
20	<	static int nReady ;
21	<	static int ExThreads ;
22	<	static int ASum ;
23	<	static final ReentrantLock Gate = new ReentrantLock () ;
24	<	static final Condition GateCond = Gate.newCondition () ;
18	>	static int batchLimit ;
19	>	static int mseq ;
20	>	static int nReady ;
21	>	static int ExThreads ;
22	>	static int ASum ;
23	>	static final ReentrantLock Gate = new ReentrantLock () ;
24	>	static final Condition GateCond = Gate.newCondition () ;
25
26		static final ReentrantLock HoldQ = new ReentrantLock () ;
27		static final Condition HoldQCond = HoldQ.newCondition() ;
28	<	static boolean Hold = false ;
29	<	static int HoldPop ;
30	<	static int HoldLimit ;
31	<
32	<	static private boolean HoldCheck () {
33	<	try {
34	<	HoldQ.lock();
35	<	try {
28	>	static boolean Hold = false ;
29	>	static int HoldPop ;
30	>	static int HoldLimit ;
31	>
32	>	static private boolean HoldCheck () {
33	>	try {
34	>	HoldQ.lock();
35	>	try {
36		if (!Hold) return false;
37		else {
38	<	++HoldPop ;
39	<	if (HoldPop >= HoldLimit) {
40	<	System.out.print ("Holding ") ;
41	<	Thread.sleep (1000) ;
42	<	System.out.println () ;
43	<	Hold = false ;
44	<	HoldQCond.signalAll () ;
45	<	}
38	>	++HoldPop ;
39	>	if (HoldPop >= HoldLimit) {
40	>	System.out.print ("Holding ") ;
41	>	Thread.sleep (1000) ;
42	>	System.out.println () ;
43	>	Hold = false ;
44	>	HoldQCond.signalAll () ;
45	>	}
46		else
47	<	while (Hold)
48	<	HoldQCond.await() ;
49	<
50	<	if (--HoldPop == 0) HoldQCond.signalAll () ;
47	>	while (Hold)
48	>	HoldQCond.await() ;
49	>
50	>	if (--HoldPop == 0) HoldQCond.signalAll () ;
51		return true;
52		}
53		}
54	<	finally {
55	<	HoldQ.unlock();
54	>	finally {
55	>	HoldQ.unlock();
56		}
57	<	} catch (Exception Ex) {
58	<	System.out.println ("Unexpected exception in Hold: " + Ex) ;
57	>	} catch (Exception Ex) {
58	>	System.out.println ("Unexpected exception in Hold: " + Ex) ;
59		return false;
60		}
61		}
#	Line 63 | Line 63 | public class RLIBar {
63		private static class Server {
64		private int nClients;
65		final ReentrantLock thisLock = new ReentrantLock();
66	<	final Condition thisCond = thisLock.newCondition();
67	<
66	>	final Condition thisCond = thisLock.newCondition();
67	>
68		Server (int nClients) {
69		this.nClients = nClients;
70		try {
71		for (int i = 0; i < nClients; ++i) {
72	<	final int fix = i ;
72	>	final int fix = i ;
73		new Thread() { public void run () { runServer(fix); }}.start();
74		}
75		} catch (Exception e) {
76	<	System.err.println(e) ;
76	>	System.err.println(e) ;
77		}
78		}
79
#	Line 89 | Line 89 | public class RLIBar {
89		private int currentBatchSize = 0;
90
91		private void runServer (int id) {
92	<	int msg ;
92	>	int msg ;
93		boolean held = false;
94		final ReentrantLock thisLock = this.thisLock;
95	<	final Condition thisCond = this.thisCond;
95	>	final Condition thisCond = this.thisCond;
96
97		try {
98
99	<	// Startup barrier - rendezvous - wait for all threads.
99	>	// Startup barrier - rendezvous - wait for all threads.
100		// Forces all threads to park on their LWPs, ensuring
101	<	// proper provisioning on T1.
102	<	// Alternately, use THR_BOUND threads
103	<	Gate.lock(); try {
104	<	++nReady ;
105	<	if (nReady == ExThreads ) {
106	<	GateCond.signalAll () ;
101	>	// proper provisioning on T1.
102	>	// Alternately, use THR_BOUND threads
103	>	Gate.lock(); try {
104	>	++nReady ;
105	>	if (nReady == ExThreads ) {
106	>	GateCond.signalAll () ;
107		}
108	<	while (nReady != ExThreads )
109	<	GateCond.await() ;
108	>	while (nReady != ExThreads )
109	>	GateCond.await() ;
110		} finally { Gate.unlock(); }
111
112		for (;;) {
113		//                    if (!held && currentBatchSize == 0) held = HoldCheck () ;
114		msg = (++ mseq) ^ id ;
115	<	thisLock.lock();
115	>	thisLock.lock();
116		try {
117	<	ASum += msg ;
117	>	ASum += msg ;
118		++msgsReceived;
119		int myBatch = currentBatch;
120		if (++currentBatchSize >= batchLimit) {
#	Line 122 | Line 122 | public class RLIBar {
122		++currentBatch;
123		currentBatchSize = 0;
124		// and wake up everyone in this one
125	<	thisCond.signalAll () ;
125	>	thisCond.signalAll () ;
126		}
127		// Wait until our batch is complete
128		while (myBatch == currentBatch)
129	<	thisCond.await();
130	<	}
131	<	finally {
132	<	thisLock.unlock();
129	>	thisCond.await();
130	>	}
131	>	finally {
132	>	thisLock.unlock();
133		}
134		}
135		} catch (Exception e) {
#	Line 160 | Line 160 | public class RLIBar {
160		samplePeriod = Integer.parseInt(args[nextArg++]);
161		else if (arg.equals("-np"))
162		nSamples = Integer.parseInt(args[nextArg++]);
163	<	else {
164	<	System.err.println ("Argument error:" + arg) ;
165	<	System.exit (1) ;
166	<	}
163	>	else {
164	>	System.err.println ("Argument error:" + arg) ;
165	>	System.exit (1) ;
166	>	}
167		}
168		if (nClients <= 0 || nServers <= 0 || samplePeriod <= 0 || batchLimit > nClients) {
169	<	System.err.println ("Argument error") ;
170	<	System.exit (1) ;
169	>	System.err.println ("Argument error") ;
170	>	System.exit (1) ;
171		}
172
173		// default batch size is 2/3 the number of clients
#	Line 176 | Line 176 | public class RLIBar {
176		batchLimit = (2 * nClients + 1) / 3;
177
178		ExThreads = nServers * nClients ;       // expected # of threads
179	<	HoldLimit = ExThreads ;
179	>	HoldLimit = ExThreads ;
180
181		// start up all threads
182		Server[] servers = new Server[nServers];
#	Line 184 | Line 184 | public class RLIBar {
184		servers[i] = new Server(nClients);
185		}
186
187	<	// Wait for consensus
187	>	// Wait for consensus
188		try {
189	<	Gate.lock(); try {
190	<	while (nReady != ExThreads ) GateCond.await() ;
189	>	Gate.lock(); try {
190	>	while (nReady != ExThreads ) GateCond.await() ;
191		} finally { Gate.unlock(); }
192	<	} catch (Exception ex) {
193	<	System.out.println (ex);
192	>	} catch (Exception ex) {
193	>	System.out.println (ex);
194		}
195		System.out.println (
196	<	nReady + " Ready: nc=" + nClients + " ns=" + nServers + " batch=" + batchLimit) ;
196	>	nReady + " Ready: nc=" + nClients + " ns=" + nServers + " batch=" + batchLimit) ;
197
198		// Start sampling ...
199		// Methodological problem: all the mutator threads
200		// can starve the compiler threads, resulting in skewed scores.
201		// In theory, over time, the scores will improve as the compiler
202		// threads are granted CPU cycles, but in practice a "warm up" phase
203	<	// might be good idea to help C2.  For this reason I've implemented
204	<	// the "Hold" facility.
203	>	// might be good idea to help C2.  For this reason I've implemented
204	>	// the "Hold" facility.
205
206		long lastNumMsgs = 0;
207		long sampleStart = System.currentTimeMillis();
#	Line 218 | Line 218 | public class RLIBar {
218		Thread.sleep(sampleEnd - now);
219		}
220
221	<	if (false && j == 2) {
222	<	System.out.print ("Hold activated ...") ;
223	<	HoldQ.lock();
224	<	try  {
225	<	Hold = true ;
226	<	while (Hold) HoldQCond.await() ;
227	<	}
228	<	finally {
229	<	HoldQ.unlock();
221	>	if (false && j == 2) {
222	>	System.out.print ("Hold activated ...") ;
223	>	HoldQ.lock();
224	>	try  {
225	>	Hold = true ;
226	>	while (Hold) HoldQCond.await() ;
227	>	}
228	>	finally {
229	>	HoldQ.unlock();
230		}
231		}
232
#	Line 255 | Line 255 | public class RLIBar {
255		System.exit(0);
256		}
257		}
258	–
259	–

Diff Legend

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