test/loops/TimeoutExchangerLoops.java

/*
 * Written by Bill Scherer and Doug Lea with assistance from members
 * of JCP JSR-166 Expert Group and released to the public domain. Use,
 * modify, and redistribute this code in any way without
 * acknowledgement.
 */

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

public class TimeoutExchangerLoops {
    static final int  DEFAULT_THREADS        = 32;
    static final long DEFAULT_TRIAL_MILLIS   = 5000;
    static final long DEFAULT_PATIENCE_NANOS = 500000;

    static final ExecutorService pool = Executors.newCachedThreadPool();
    
    public static void main(String[] args) throws Exception {
        int maxThreads = DEFAULT_THREADS;
        long trialMillis = DEFAULT_TRIAL_MILLIS;
        long patienceNanos = DEFAULT_PATIENCE_NANOS;

        // Parse and check args
        int argc = 0;
        try {
            while (argc < args.length) {
                String option = args[argc++];
                if (option.equals("-t"))
                    trialMillis = Integer.parseInt(args[argc]);
                else if (option.equals("-p"))
                    patienceNanos = Long.parseLong(args[argc]);
                else 
                    maxThreads = Integer.parseInt(option);
                argc++;
            }
        }
        catch (Exception e) {
            e.printStackTrace();
            System.exit(0);
        }

        // Display runtime parameters
        System.out.print("TimeoutExchangerTest");
        System.out.print(" -t " + trialMillis);
        System.out.print(" -p " + patienceNanos);
        System.out.print(" max threads " + maxThreads);
        System.out.println();

        // warmup
        System.out.print("Threads: " + 2 + "\t");
        oneRun(2, trialMillis, patienceNanos);
        Thread.sleep(100);

        int k = 4;
        for (int i = 2; i <= maxThreads;) {
            System.out.print("Threads: " + i + "\t");
            oneRun(i, trialMillis, patienceNanos);
            Thread.sleep(100);
            if (i == k) {
                k = i << 1;
                i = i + (i >>> 1);
            } 
            else 
                i = k;
        }
        pool.shutdown();
    }

    static void oneRun(int nThreads, long trialMillis, long patienceNanos) 
        throws Exception {
        CyclicBarrier barrier = new CyclicBarrier(nThreads+1);
        long stopTime = System.currentTimeMillis() + trialMillis;
        Exchanger<MutableInt> x = new Exchanger<MutableInt>();
        Runner[] runners = new Runner[nThreads];
        for (int i = 0; i < nThreads; ++i) 
            runners[i] = new Runner(x, stopTime, patienceNanos, barrier);
        for (int i = 0; i < nThreads; ++i) 
            pool.execute(runners[i]);
        barrier.await();
        barrier.await();
        long iters = 0;
        long fails = 0;
        long check = 0;
        for (int i = 0; i < nThreads; ++i) {
            iters += runners[i].iterations;
            fails += runners[i].failures;
            check += runners[i].mine.value;
        }
        if (check != iters) 
            throw new Error("bad checksum " + iters + "/" + check);
        long rate = (iters * 1000) / trialMillis;
        double failRate = (fails * 100.0) / (double)iters;
        System.out.print(LoopHelpers.rightJustify(rate) + " iterations/s ");
        System.out.printf("%9.5f", failRate);
        System.out.print("% timeouts");
        System.out.println();
    }

    static final class MutableInt {
        int value;
    }
       
    static final class Runner implements Runnable {
        final Exchanger<MutableInt> x;
        volatile long iterations;
        volatile long failures;
        volatile MutableInt mine;
        final long stopTime;
        final long patience;
        final CyclicBarrier barrier;
        Runner(Exchanger<MutableInt> x, long stopTime, 
               long patience, CyclicBarrier b) {
            this.x = x;
            this.stopTime = stopTime;
            this.patience = patience;
            this.barrier = b;
            mine = new MutableInt();
        }

        public void run() {
            try {
                barrier.await();
                MutableInt m = mine;
                int i = 0;
                int fails = 0;
                do {
                    try {
                        ++i;
                        m.value++;
                        m = x.exchange(m, patience, TimeUnit.NANOSECONDS);
                    } catch (TimeoutException to) {
                        if (System.currentTimeMillis() >= stopTime) 
                            break;
                        else
                            ++fails;
                    }
                } while ((i & 127) != 0 || // only check time periodically
                         System.currentTimeMillis() < stopTime);
                
                mine = m;
                iterations = i;
                failures = fails;
                barrier.await();
            } catch(Exception e) {
                e.printStackTrace();
                return;
            }
        }
    }
}
        
Revision:	1.1
Committed:	Sun Aug 7 19:25:55 2005 UTC (18 years, 9 months ago) by dl
Branch:	MAIN
Log Message:	Add exchanger performance tests; update others
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Bill Scherer and Doug Lea with assistance from members
3			* of JCP JSR-166 Expert Group and released to the public domain. Use,
4			* modify, and redistribute this code in any way without
5			* acknowledgement.
6			*/
7
8			import java.util.concurrent.*;
9			import java.util.concurrent.atomic.*;
10			import java.util.concurrent.locks.*;
11
12			public class TimeoutExchangerLoops {
13			static final int DEFAULT_THREADS = 32;
14			static final long DEFAULT_TRIAL_MILLIS = 5000;
15			static final long DEFAULT_PATIENCE_NANOS = 500000;
16
17			static final ExecutorService pool = Executors.newCachedThreadPool();
18
19			public static void main(String[] args) throws Exception {
20			int maxThreads = DEFAULT_THREADS;
21			long trialMillis = DEFAULT_TRIAL_MILLIS;
22			long patienceNanos = DEFAULT_PATIENCE_NANOS;
23
24			// Parse and check args
25			int argc = 0;
26			try {
27			while (argc < args.length) {
28			String option = args[argc++];
29			if (option.equals("-t"))
30			trialMillis = Integer.parseInt(args[argc]);
31			else if (option.equals("-p"))
32			patienceNanos = Long.parseLong(args[argc]);
33			else
34			maxThreads = Integer.parseInt(option);
35			argc++;
36			}
37			}
38			catch (Exception e) {
39			e.printStackTrace();
40			System.exit(0);
41			}
42
43			// Display runtime parameters
44			System.out.print("TimeoutExchangerTest");
45			System.out.print(" -t " + trialMillis);
46			System.out.print(" -p " + patienceNanos);
47			System.out.print(" max threads " + maxThreads);
48			System.out.println();
49
50			// warmup
51			System.out.print("Threads: " + 2 + "\t");
52			oneRun(2, trialMillis, patienceNanos);
53			Thread.sleep(100);
54
55			int k = 4;
56			for (int i = 2; i <= maxThreads;) {
57			System.out.print("Threads: " + i + "\t");
58			oneRun(i, trialMillis, patienceNanos);
59			Thread.sleep(100);
60			if (i == k) {
61			k = i << 1;
62			i = i + (i >>> 1);
63			}
64			else
65			i = k;
66			}
67			pool.shutdown();
68			}
69
70			static void oneRun(int nThreads, long trialMillis, long patienceNanos)
71			throws Exception {
72			CyclicBarrier barrier = new CyclicBarrier(nThreads+1);
73			long stopTime = System.currentTimeMillis() + trialMillis;
74			Exchanger<MutableInt> x = new Exchanger<MutableInt>();
75			Runner[] runners = new Runner[nThreads];
76			for (int i = 0; i < nThreads; ++i)
77			runners[i] = new Runner(x, stopTime, patienceNanos, barrier);
78			for (int i = 0; i < nThreads; ++i)
79			pool.execute(runners[i]);
80			barrier.await();
81			barrier.await();
82			long iters = 0;
83			long fails = 0;
84			long check = 0;
85			for (int i = 0; i < nThreads; ++i) {
86			iters += runners[i].iterations;
87			fails += runners[i].failures;
88			check += runners[i].mine.value;
89			}
90			if (check != iters)
91			throw new Error("bad checksum " + iters + "/" + check);
92			long rate = (iters * 1000) / trialMillis;
93			double failRate = (fails * 100.0) / (double)iters;
94			System.out.print(LoopHelpers.rightJustify(rate) + " iterations/s ");
95			System.out.printf("%9.5f", failRate);
96			System.out.print("% timeouts");
97			System.out.println();
98			}
99
100			static final class MutableInt {
101			int value;
102			}
103
104			static final class Runner implements Runnable {
105			final Exchanger<MutableInt> x;
106			volatile long iterations;
107			volatile long failures;
108			volatile MutableInt mine;
109			final long stopTime;
110			final long patience;
111			final CyclicBarrier barrier;
112			Runner(Exchanger<MutableInt> x, long stopTime,
113			long patience, CyclicBarrier b) {
114			this.x = x;
115			this.stopTime = stopTime;
116			this.patience = patience;
117			this.barrier = b;
118			mine = new MutableInt();
119			}
120
121			public void run() {
122			try {
123			barrier.await();
124			MutableInt m = mine;
125			int i = 0;
126			int fails = 0;
127			do {
128			try {
129			++i;
130			m.value++;
131			m = x.exchange(m, patience, TimeUnit.NANOSECONDS);
132			} catch (TimeoutException to) {
133			if (System.currentTimeMillis() >= stopTime)
134			break;
135			else
136			++fails;
137			}
138			} while ((i & 127) != 0 \|\| // only check time periodically
139			System.currentTimeMillis() < stopTime);
140
141			mine = m;
142			iterations = i;
143			failures = fails;
144			barrier.await();
145			} catch(Exception e) {
146			e.printStackTrace();
147			return;
148			}
149			}
150			}
151			}
152