test/loops/ExchangeLoops.java

/*
 * Written by Bill Scherer and 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/
 */

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

public class ExchangeLoops {
    static final int NCPUS = Runtime.getRuntime().availableProcessors();

    static final int  DEFAULT_THREADS = NCPUS + 2;
    static final long DEFAULT_TRIAL_MILLIS = 10000;

    public static void main(String[] args) throws Exception {
        int maxThreads = DEFAULT_THREADS;
        long trialMillis = DEFAULT_TRIAL_MILLIS;
        int nReps = 3;

        // Parse and check args
        int argc = 0;
        while (argc < args.length) {
            String option = args[argc++];
            if (option.equals("-t"))
                trialMillis = Integer.parseInt(args[argc]);
            else if (option.equals("-r"))
                nReps = Integer.parseInt(args[argc]);
            else
                maxThreads = Integer.parseInt(option);
            argc++;
        }

        // Display runtime parameters
        System.out.print("ExchangeTest");
        System.out.print(" -t " + trialMillis);
        System.out.print(" -r " + nReps);
        System.out.print(" max threads " + maxThreads);
        System.out.println();
        long warmupTime = 2000;
        long sleepTime = 100;
        int nw = (maxThreads >= 3) ? 3 : 2;

        System.out.println("Warmups..");
        oneRun(3, warmupTime);
        Thread.sleep(sleepTime);

        for (int i = maxThreads; i >= 2; i -= 1) {
            oneRun(i, warmupTime++);
            //            System.gc();
            Thread.sleep(sleepTime);
        }

        /*
        for (int i = maxThreads; i >= 2; i -= 1) {
            oneRun(i, warmupTime++);
        }
        */

        for (int j = 0; j < nReps; ++j) {
            System.out.println("Trial: " + j);
            for (int i = 2; i <= maxThreads; i += 2) {
                oneRun(i, trialMillis);
                //                System.gc();
                Thread.sleep(sleepTime);
            }
            for (int i = maxThreads; i >= 2; i -= 2) {
                oneRun(i, trialMillis);
                //                System.gc();
                Thread.sleep(sleepTime);
            }
            Thread.sleep(sleepTime);
        }

    }

    static void oneRun(int nThreads, long trialMillis) throws Exception {
        System.out.printf("%4d threads", nThreads);
        Exchanger x = new Exchanger();
        Runner[] runners = new Runner[nThreads];
        Thread[] threads = new Thread[nThreads];
        for (int i = 0; i < nThreads; ++i) {
            runners[i] = new Runner(x);
            threads[i] = new Thread(runners[i]);
            //            int h = System.identityHashCode(threads[i]);
            //            h ^= h << 1;
            //            h ^= h >>> 3;
            //            h ^= h << 10;
            //            System.out.printf("%10x\n", h);
        }

        long startTime = System.nanoTime();
        for (int i = 0; i < nThreads; ++i) {
            threads[i].start();
        }
        Thread.sleep(trialMillis);
        for (int i = 0; i < nThreads; ++i)
            threads[i].interrupt();
        long elapsed = System.nanoTime() - startTime;
        for (int i = 0; i < nThreads; ++i)
            threads[i].join();
        int iters = 1;
        //        System.out.println();
        for (int i = 0; i < nThreads; ++i) {
            int ipr = runners[i].iters;
            //            System.out.println(ipr);
            iters += ipr;
        }
        long rate = iters * 1000L * 1000L * 1000L / elapsed;
        long npt = elapsed / iters;
        System.out.printf("%9dms", elapsed / (1000L * 1000L));
        System.out.printf("%9d it/s ", rate);
        System.out.printf("%9d ns/it", npt);
        System.out.println();
        //        x.printStats();
    }

    static final class Runner implements Runnable {
        final Exchanger exchanger;
        final Object mine = new Integer(2688);
        volatile int iters;
        Runner(Exchanger x) { this.exchanger = x; }

        public void run() {
            Exchanger x = exchanger;
            Object m = mine;
            int i = 0;
            try {
                for (;;) {
                    Object e = x.exchange(m);
                    if (e == null || e == m)
                        throw new Error();
                    m = e;
                    ++i;
                }
            } catch (InterruptedException ie) {
                iters = i;
            }
        }
    }
}
Revision:	1.10
Committed:	Thu Jan 15 18:34:19 2015 UTC (9 years, 3 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.9:	+0 -1 lines
Log Message:	delete extraneous blank lines
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.2	* Written by Bill Scherer and Doug Lea with assistance from members
3	dl	1.4	* of JCP JSR-166 Expert Group and released to the public domain, as
4	jsr166	1.8	* explained at http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6
7			import java.util.concurrent.*;
8	dl	1.2	import java.util.concurrent.atomic.*;
9			import java.util.concurrent.locks.*;
10	dl	1.1
11			public class ExchangeLoops {
12	dl	1.2	static final int NCPUS = Runtime.getRuntime().availableProcessors();
13	dl	1.1
14	dl	1.2	static final int DEFAULT_THREADS = NCPUS + 2;
15	jsr166	1.9	static final long DEFAULT_TRIAL_MILLIS = 10000;
16	dl	1.1
17			public static void main(String[] args) throws Exception {
18	dl	1.2	int maxThreads = DEFAULT_THREADS;
19			long trialMillis = DEFAULT_TRIAL_MILLIS;
20			int nReps = 3;
21
22			// Parse and check args
23			int argc = 0;
24			while (argc < args.length) {
25			String option = args[argc++];
26			if (option.equals("-t"))
27			trialMillis = Integer.parseInt(args[argc]);
28			else if (option.equals("-r"))
29			nReps = Integer.parseInt(args[argc]);
30	jsr166	1.5	else
31	dl	1.2	maxThreads = Integer.parseInt(option);
32			argc++;
33			}
34	dl	1.1
35	jsr166	1.7	// Display runtime parameters
36			System.out.print("ExchangeTest");
37			System.out.print(" -t " + trialMillis);
38	dl	1.2	System.out.print(" -r " + nReps);
39	jsr166	1.7	System.out.print(" max threads " + maxThreads);
40			System.out.println();
41	dl	1.2	long warmupTime = 2000;
42			long sleepTime = 100;
43	jsr166	1.6	int nw = (maxThreads >= 3) ? 3 : 2;
44	dl	1.2
45			System.out.println("Warmups..");
46			oneRun(3, warmupTime);
47			Thread.sleep(sleepTime);
48
49			for (int i = maxThreads; i >= 2; i -= 1) {
50			oneRun(i, warmupTime++);
51			// System.gc();
52			Thread.sleep(sleepTime);
53			}
54	dl	1.1
55	dl	1.2	/*
56			for (int i = maxThreads; i >= 2; i -= 1) {
57			oneRun(i, warmupTime++);
58	dl	1.1	}
59	dl	1.2	*/
60	dl	1.1
61	dl	1.2	for (int j = 0; j < nReps; ++j) {
62			System.out.println("Trial: " + j);
63			for (int i = 2; i <= maxThreads; i += 2) {
64			oneRun(i, trialMillis);
65			// System.gc();
66			Thread.sleep(sleepTime);
67	dl	1.1	}
68	dl	1.2	for (int i = maxThreads; i >= 2; i -= 2) {
69			oneRun(i, trialMillis);
70			// System.gc();
71			Thread.sleep(sleepTime);
72	dl	1.1	}
73	dl	1.2	Thread.sleep(sleepTime);
74	dl	1.1	}
75	dl	1.2
76	dl	1.1	}
77
78	dl	1.2	static void oneRun(int nThreads, long trialMillis) throws Exception {
79			System.out.printf("%4d threads", nThreads);
80			Exchanger x = new Exchanger();
81			Runner[] runners = new Runner[nThreads];
82			Thread[] threads = new Thread[nThreads];
83			for (int i = 0; i < nThreads; ++i) {
84			runners[i] = new Runner(x);
85			threads[i] = new Thread(runners[i]);
86			// int h = System.identityHashCode(threads[i]);
87			// h ^= h << 1;
88			// h ^= h >>> 3;
89			// h ^= h << 10;
90			// System.out.printf("%10x\n", h);
91			}
92
93			long startTime = System.nanoTime();
94			for (int i = 0; i < nThreads; ++i) {
95			threads[i].start();
96			}
97			Thread.sleep(trialMillis);
98	jsr166	1.5	for (int i = 0; i < nThreads; ++i)
99	dl	1.2	threads[i].interrupt();
100			long elapsed = System.nanoTime() - startTime;
101	jsr166	1.5	for (int i = 0; i < nThreads; ++i)
102	dl	1.2	threads[i].join();
103			int iters = 1;
104			// System.out.println();
105			for (int i = 0; i < nThreads; ++i) {
106			int ipr = runners[i].iters;
107			// System.out.println(ipr);
108			iters += ipr;
109			}
110			long rate = iters * 1000L * 1000L * 1000L / elapsed;
111			long npt = elapsed / iters;
112	dl	1.3	System.out.printf("%9dms", elapsed / (1000L * 1000L));
113	dl	1.2	System.out.printf("%9d it/s ", rate);
114			System.out.printf("%9d ns/it", npt);
115			System.out.println();
116			// x.printStats();
117	dl	1.1	}
118	jsr166	1.5
119	dl	1.2	static final class Runner implements Runnable {
120			final Exchanger exchanger;
121			final Object mine = new Integer(2688);
122			volatile int iters;
123			Runner(Exchanger x) { this.exchanger = x; }
124	dl	1.1
125	dl	1.2	public void run() {
126			Exchanger x = exchanger;
127			Object m = mine;
128			int i = 0;
129			try {
130			for (;;) {
131			Object e = x.exchange(m);
132			if (e == null \|\| e == m)
133			throw new Error();
134			m = e;
135			++i;
136			}
137			} catch (InterruptedException ie) {
138			iters = i;
139			}
140			}
141			}
142	dl	1.1	}