test/loops/RLJBar.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

// Yet another contended object monitor throughput test
// adapted from bug reports

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

class Producer extends Thread
{
    //  private static Hashtable buddiesOnline = new Hashtable();
    private static Map buddiesOnline = new ConcurrentHashMap();
    public Producer(String name) { super(name); }

    public void run() {
        Object key = null;
        final ReentrantLock dr = RLJBar.DeathRow;
        final ReentrantLock bar = RLJBar.bar;
        final ReentrantLock end = RLJBar.End;
        final Condition endCondition = RLJBar.EndCondition;
        if (RLJBar.OneKey) key = new Integer(0);         // per-thread v. per iteration

        // The barrier has a number of interesting effects:
        // 1.     It enforces full LWP provisioning on T1.
        //                (nearly all workers park concurrently).
        // 2.     It gives the C2 compiler thread(s) a chance to run.
        //                By transiently quiescing the workings the C2 threads
        //                might avoid starvation.
        //

        try {
            bar.lock();
            try {
                ++RLJBar.nUp;
                if (RLJBar.nUp == RLJBar.nThreads) {
                    if (RLJBar.quiesce != 0) {
                        RLJBar.barCondition.awaitNanos(RLJBar.quiesce * 1000000);
                    }
                    RLJBar.epoch = System.currentTimeMillis();
                    RLJBar.barCondition.signalAll();
                    //                  System.out.print ("Consensus ");
                }
                if (RLJBar.UseBar) {
                    while (RLJBar.nUp != RLJBar.nThreads) {
                        RLJBar.barCondition.await();
                    }
                }
            }
            finally {
                bar.unlock();
            }
        } catch (Exception ex) {
            System.out.println("Exception in barrier: " + ex);
        }

        // Main execution time ... the code being timed ...
        // HashTable.get() is highly contended (serial).
        for (int loop = 1; loop < 100000 ;loop++) {
            if (!RLJBar.OneKey) key = new Integer(0);
            buddiesOnline.get(key);
        }

        // Mutator epilog:
        // The following code determines if the test will/wont include (measure)
        // thread death time.

        end.lock();
        try {
            ++RLJBar.nDead;
            if (RLJBar.nDead == RLJBar.nUp) {
                //          System.out.print((System.currentTimeMillis()-RLJBar.epoch) + " ms");
                endCondition.signalAll();
            }
        }
        finally {
            end.unlock();
        }
        dr.lock();
        dr.unlock();
    }
}

public class RLJBar                             // ProdConsTest
{

    public static final int ITERS = 10;
    public static boolean OneKey = false;                        // alloc once or once per iteration

    public static boolean UseBar = false;
    public static int nThreads = 100;
    public static int nUp = 0;
    public static int nDead = 0;
    public static ReentrantLock bar = new ReentrantLock();
    public static Condition barCondition = bar.newCondition();
    public static long epoch;
    public static ReentrantLock DeathRow = new ReentrantLock();
    public static ReentrantLock End = new ReentrantLock();
    public static int quiesce = 0;
    public static Condition EndCondition = End.newCondition();

    public static void main(String[] args) {
        int argix = 0;
        if (argix < args.length && args[argix].equals("-o")) {
            ++argix;
            OneKey = true;
            System.out.println("OneKey");
        }
        if (argix < args.length && args[argix].equals ("-b")) {
            ++argix;
            UseBar = true;
            System.out.println("UseBar");
        }
        if (argix < args.length && args[argix].equals ("-q")) {
            ++argix;
            if (argix < args.length) {
                quiesce = Integer.parseInt(args[argix++]);
                System.out.println("Quiesce " + quiesce + " msecs");
            }
        }
        for (int k = 0; k < ITERS; ++k)
            oneRun();
    }

    public static void oneRun() {
        DeathRow = new ReentrantLock();
        End = new ReentrantLock();
        EndCondition = End.newCondition();

        nDead = nUp = 0;
        long cyBase = System.currentTimeMillis();
        DeathRow.lock();
        try {
            for (int i = 1; i <= nThreads; i++) {
                new Producer("Producer" + i).start();
            }
            try {
                End.lock();
                try {
                    while (nDead != nThreads)
                        EndCondition.await();
                }
                finally {
                    End.unlock();
                }
            } catch (Exception ex) {
                System.out.println("Exception in End: " + ex);
            }
        }
        finally {
            DeathRow.unlock();
        }
        System.out.println("Outer time: " + (System.currentTimeMillis()-cyBase));

        // Let workers quiesce/exit.
        try { Thread.sleep (1000); } catch (Exception ex) {}
    }
}
Revision:	1.11
Committed:	Sun Feb 22 04:38:58 2015 UTC (9 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.10:	+1 -1 lines
Log Message:	stray semicolon
#	User	Rev	Content
1	dl	1.2	/*
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	jsr166	1.6	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.2	*/
6
7	dl	1.1	// Yet another contended object monitor throughput test
8			// adapted from bug reports
9
10			import java.util.*;
11			import java.util.concurrent.*;
12			import java.util.concurrent.locks.*;
13	jsr166	1.3
14			class Producer extends Thread
15	dl	1.1	{
16			// private static Hashtable buddiesOnline = new Hashtable();
17	jsr166	1.7	private static Map buddiesOnline = new ConcurrentHashMap();
18			public Producer(String name) { super(name); }
19	dl	1.1
20	jsr166	1.7	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			// 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	dl	1.1	}
86			}
87
88	jsr166	1.4	public class RLJBar // ProdConsTest
89	dl	1.1	{
90
91			public static final int ITERS = 10;
92	jsr166	1.7	public static boolean OneKey = false; // alloc once or once per iteration
93	dl	1.1
94	jsr166	1.7	public static boolean UseBar = false;
95			public static int nThreads = 100;
96			public static int nUp = 0;
97			public static int nDead = 0;
98			public static ReentrantLock bar = new ReentrantLock();
99			public static Condition barCondition = bar.newCondition();
100			public static long epoch;
101			public static ReentrantLock DeathRow = new ReentrantLock();
102			public static ReentrantLock End = new ReentrantLock();
103			public static int quiesce = 0;
104			public static Condition EndCondition = End.newCondition();
105
106	jsr166	1.8	public static void main(String[] args) {
107	jsr166	1.7	int argix = 0;
108			if (argix < args.length && args[argix].equals("-o")) {
109			++argix;
110			OneKey = true;
111			System.out.println("OneKey");
112			}
113			if (argix < args.length && args[argix].equals ("-b")) {
114			++argix;
115			UseBar = true;
116			System.out.println("UseBar");
117			}
118			if (argix < args.length && args[argix].equals ("-q")) {
119			++argix;
120			if (argix < args.length) {
121			quiesce = Integer.parseInt(args[argix++]);
122			System.out.println("Quiesce " + quiesce + " msecs");
123			}
124			}
125			for (int k = 0; k < ITERS; ++k)
126			oneRun();
127			}
128	dl	1.1
129			public static void oneRun() {
130	jsr166	1.5	DeathRow = new ReentrantLock();
131			End = new ReentrantLock();
132	dl	1.1	EndCondition = End.newCondition();
133	jsr166	1.3
134	jsr166	1.5	nDead = nUp = 0;
135			long cyBase = System.currentTimeMillis();
136	dl	1.1	DeathRow.lock();
137			try {
138	jsr166	1.5	for (int i = 1; i <= nThreads; i++) {
139	dl	1.1	new Producer("Producer" + i).start();
140			}
141	jsr166	1.3	try {
142	dl	1.1	End.lock();
143			try {
144	jsr166	1.3	while (nDead != nThreads)
145	jsr166	1.5	EndCondition.await();
146	dl	1.1	}
147			finally {
148			End.unlock();
149			}
150	jsr166	1.3	} catch (Exception ex) {
151	jsr166	1.5	System.out.println("Exception in End: " + ex);
152	dl	1.1	}
153			}
154			finally {
155			DeathRow.unlock();
156			}
157	jsr166	1.5	System.out.println("Outer time: " + (System.currentTimeMillis()-cyBase));
158	jsr166	1.3
159			// Let workers quiesce/exit.
160	jsr166	1.11	try { Thread.sleep (1000); } catch (Exception ex) {}
161	dl	1.1	}
162			}