test/loops/COWALAddIfAbsentLoops.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/
 */

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

/**
 * A simple test for evaluating different implementations of
 * CopyOnWriteArrayList.addIfAbsent.
 */
public class COWALAddIfAbsentLoops {

    static final int SIZE = Integer.getInteger("size", 35000);

    /**
     * Set to 1 for  0% cache hit ratio (every addIfAbsent a cache miss).
     * Set to 2 for 50% cache hit ratio.
     */
    static final int CACHE_HIT_FACTOR = Integer.getInteger("cache.hit.factor", 1);

    static final int MAX_STRIPES = Integer.getInteger("max.stripes", 4);

    static final int REPS = Integer.getInteger("reps", 3);

    public static void main(String[] args) throws Exception {
        for (int reps = 0; reps < REPS; ++reps) {
            for (int i = 1; i <= MAX_STRIPES; ++i)
                test(i);
        }
    }

    static final AtomicInteger result = new AtomicInteger();

    public static void test(int n) throws Exception {
        result.set(0);
        Thread[] ts = new Thread[CACHE_HIT_FACTOR*n];
        Phaser started = new Phaser(ts.length + 1);
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>();
        for (int i = 0; i < ts.length; ++i)
            (ts[i] = new Thread(new Task(i%n, n, list, started))).start();
        long p = started.arriveAndAwaitAdvance();
        long st = System.nanoTime();
        for (Thread thread : ts)
            thread.join();
        double secs = ((double)System.nanoTime() - st) / (1000L * 1000 * 1000);
        System.out.println("Threads: " + n + " Time: " + secs);
        if (result.get() != SIZE)
            throw new Error();
    }

    static final class Task implements Runnable {
        final int id, stride;
        final CopyOnWriteArrayList<Integer> list;
        final Phaser started;
        Task(int id, int stride,
             CopyOnWriteArrayList<Integer> list, Phaser started) {
            this.id = id;
            this.stride = stride;
            this.list = list;
            this.started = started;
        }
        public void run() {
            final CopyOnWriteArrayList<Integer> list = this.list;
            int origin = id, inc = stride, adds = 0;
            started.arriveAndAwaitAdvance();
            for (int i = origin; i < SIZE; i += inc) {
                if (list.addIfAbsent(i))
                    ++adds;
            }
            result.getAndAdd(adds);
        }
    }
}
Revision:	1.4
Committed:	Sat Apr 6 20:12:23 2013 UTC (11 years, 1 month ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.3:	+1 -1 lines
Log Message:	restore stripes back to 4
#	User	Rev	Content
1	dl	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/publicdomain/zero/1.0/
5			*/
6
7			import java.util.concurrent.*;
8			import java.util.concurrent.atomic.*;
9
10	jsr166	1.2	/**
11	dl	1.1	* A simple test for evaluating different implementations of
12			* CopyOnWriteArrayList.addIfAbsent.
13			*/
14	jsr166	1.2	public class COWALAddIfAbsentLoops {
15	dl	1.1
16	jsr166	1.3	static final int SIZE = Integer.getInteger("size", 35000);
17	dl	1.1
18	jsr166	1.2	/**
19			* Set to 1 for 0% cache hit ratio (every addIfAbsent a cache miss).
20			* Set to 2 for 50% cache hit ratio.
21			*/
22	jsr166	1.3	static final int CACHE_HIT_FACTOR = Integer.getInteger("cache.hit.factor", 1);
23
24	jsr166	1.4	static final int MAX_STRIPES = Integer.getInteger("max.stripes", 4);
25	jsr166	1.3
26			static final int REPS = Integer.getInteger("reps", 3);
27	dl	1.1
28			public static void main(String[] args) throws Exception {
29	jsr166	1.3	for (int reps = 0; reps < REPS; ++reps) {
30			for (int i = 1; i <= MAX_STRIPES; ++i)
31	dl	1.1	test(i);
32			}
33			}
34
35	jsr166	1.2	static final AtomicInteger result = new AtomicInteger();
36	dl	1.1
37			public static void test(int n) throws Exception {
38			result.set(0);
39	jsr166	1.2	Thread[] ts = new Thread[CACHE_HIT_FACTOR*n];
40			Phaser started = new Phaser(ts.length + 1);
41	dl	1.1	CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>();
42	jsr166	1.2	for (int i = 0; i < ts.length; ++i)
43			(ts[i] = new Thread(new Task(i%n, n, list, started))).start();
44	dl	1.1	long p = started.arriveAndAwaitAdvance();
45			long st = System.nanoTime();
46	jsr166	1.2	for (Thread thread : ts)
47			thread.join();
48	dl	1.1	double secs = ((double)System.nanoTime() - st) / (1000L * 1000 * 1000);
49			System.out.println("Threads: " + n + " Time: " + secs);
50			if (result.get() != SIZE)
51			throw new Error();
52			}
53
54			static final class Task implements Runnable {
55			final int id, stride;
56			final CopyOnWriteArrayList<Integer> list;
57			final Phaser started;
58			Task(int id, int stride,
59			CopyOnWriteArrayList<Integer> list, Phaser started) {
60			this.id = id;
61			this.stride = stride;
62			this.list = list;
63			this.started = started;
64			}
65			public void run() {
66			final CopyOnWriteArrayList<Integer> list = this.list;
67			int origin = id, inc = stride, adds = 0;
68			started.arriveAndAwaitAdvance();
69			for (int i = origin; i < SIZE; i += inc) {
70			if (list.addIfAbsent(i))
71			++adds;
72			}
73			result.getAndAdd(adds);
74			}
75			}
76			}