jsr166e/extra/StripedAdderTable.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/
 */

package jsr166e.extra;
import jsr166e.StripedAdder;
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;
import java.util.Set;
import java.io.Serializable;

/**
 * A keyed table of scalable adders, that may be useful in computing
 * frequency counts and histograms, or may be used a form of multiset.
 * A {@link StripedAdder} is associated with each key. Keys may be
 * added to the table explicitly ({@link #install}, and are also added
 * implicitly upon any attempt to update.
 *
 * @author Doug Lea
 */
public class StripedAdderTable<K> implements Serializable {
    /** Relies on default serialization */
    private static final long serialVersionUID = 7249369246863182397L;

    /** Concurrency parameter for map -- we assume high contention */
    private static final int MAP_SEGMENTS =
        Math.max(16, Runtime.getRuntime().availableProcessors());

    /** The underlying map */
    private final ConcurrentHashMap<K, StripedAdder> map;

    /**
     * Creates a new empty table.
     */
    public StripedAdderTable() {
        map = new ConcurrentHashMap<K, StripedAdder>(16, 0.75f, MAP_SEGMENTS);
    }

    /**
     * If the given key does not already exist in the table, adds the
     * key with initial sum of zero; in either case returning the
     * adder associated with this key.
     *
     * @param key the key
     * @return the counter associated with the key
     */
    public StripedAdder install(K key) {
        StripedAdder a = map.get(key);
        if (a == null) {
            StripedAdder r = new StripedAdder();
            if ((a = map.putIfAbsent(key, r)) == null)
                a = r;
        }
        return a;
    }

    /**
     * Adds the given value to the sum associated with the given
     * key.  If the key does not already exist in the table, it is
     * inserted.
     *
     * @param key the key
     * @param x the value to add
     */
    public void add(K key, long x) {
        StripedAdder a = map.get(key);
        if (a == null) {
            StripedAdder r = new StripedAdder();
            if ((a = map.putIfAbsent(key, r)) == null)
                a = r;
        }
        a.add(x);
    }

    /**
     * Increments the sum associated with the given key.  If the key
     * does not already exist in the table, it is inserted.
     *
     * @param key the key
     */
    public void increment(K key) { add(key, 1L); }

    /**
     * Decrements the sum associated with the given key.  If the key
     * does not already exist in the table, it is inserted.
     *
     * @param key the key
     */
    public void decrement(K key) { add(key, -1L); }

    /**
     * Returns the sum associated with the given key, or zero if the
     * key does not currently exist in the table.
     *
     * @param key the key
     * @return the sum associated with the key, or zero if the key is
     * not in the table
     */
    public long sum(K key) {
        StripedAdder a = map.get(key);
        return a == null ? 0L : a.sum();
    }

    /**
     * Resets the sum associated with the given key to zero if the key
     * exists in the table.  This method does <em>NOT</em> add or
     * remove the key from the table (see {@link #remove}).
     *
     * @param key the key
     */
    public void reset(K key) {
        StripedAdder a = map.get(key);
        if (a != null)
            a.reset();
    }

    /**
     * Resets the sum associated with the given key to zero if the key
     * exists in the table.  This method does <em>NOT</em> add or
     * remove the key from the table (see {@link #remove}).
     *
     * @param key the key
     * @return the previous sum, or zero if the key is not
     * in the table
     */
    public long sumThenReset(K key) {
        StripedAdder a = map.get(key);
        return a == null ? 0L : a.sumThenReset();
    }

    /**
     * Returns the sum totalled across all keys.
     *
     * @return the sum totalled across all keys.
     */
    public long sumAll() {
        long sum = 0L;
        for (StripedAdder a : map.values())
            sum += a.sum();
        return sum;
    }

    /**
     * Resets the sum associated with each key to zero.
     */
    public void resetAll() {
        for (StripedAdder a : map.values())
            a.reset();
    }

    /**
     * Totals, then resets, the sums associated with all keys.
     *
     * @return the sum totalled across all keys.
     */
    public long sumThenResetAll() {
        long sum = 0L;
        for (StripedAdder a : map.values())
            sum += a.sumThenReset();
        return sum;
    }

    /**
     * Removes the given key from the table.
     *
     * @param key the key
     */
    public void remove(K key) { map.remove(key); }

    /**
     * Returns the current set of keys.
     *
     * @return the current set of keys
     */
    public Set<K> keySet() {
        return map.keySet();
    }

    /**
     * Returns the current set of key-value mappings.
     *
     * @return the current set of key-value mappings
     */
    public Set<Map.Entry<K,StripedAdder>> entrySet() {
        return map.entrySet();
    }

}
Revision:	1.3
Committed:	Sun Jul 31 14:20:06 2011 UTC (12 years, 10 months ago) by dl
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Rename classes
#	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			package jsr166e.extra;
8			import jsr166e.StripedAdder;
9			import java.util.concurrent.ConcurrentHashMap;
10			import java.util.Map;
11			import java.util.Set;
12			import java.io.Serializable;
13
14			/**
15			* A keyed table of scalable adders, that may be useful in computing
16			* frequency counts and histograms, or may be used a form of multiset.
17			* A {@link StripedAdder} is associated with each key. Keys may be
18	dl	1.2	* added to the table explicitly ({@link #install}, and are also added
19			* implicitly upon any attempt to update.
20	dl	1.1	*
21			* @author Doug Lea
22			*/
23			public class StripedAdderTable<K> implements Serializable {
24			/** Relies on default serialization */
25			private static final long serialVersionUID = 7249369246863182397L;
26
27			/** Concurrency parameter for map -- we assume high contention */
28			private static final int MAP_SEGMENTS =
29			Math.max(16, Runtime.getRuntime().availableProcessors());
30
31			/** The underlying map */
32			private final ConcurrentHashMap<K, StripedAdder> map;
33
34			/**
35			* Creates a new empty table.
36			*/
37			public StripedAdderTable() {
38			map = new ConcurrentHashMap<K, StripedAdder>(16, 0.75f, MAP_SEGMENTS);
39			}
40
41			/**
42	dl	1.2	* If the given key does not already exist in the table, adds the
43			* key with initial sum of zero; in either case returning the
44			* adder associated with this key.
45			*
46			* @param key the key
47			* @return the counter associated with the key
48			*/
49			public StripedAdder install(K key) {
50			StripedAdder a = map.get(key);
51			if (a == null) {
52			StripedAdder r = new StripedAdder();
53			if ((a = map.putIfAbsent(key, r)) == null)
54			a = r;
55			}
56			return a;
57			}
58
59			/**
60			* Adds the given value to the sum associated with the given
61			* key. If the key does not already exist in the table, it is
62			* inserted.
63	dl	1.1	*
64			* @param key the key
65	dl	1.2	* @param x the value to add
66	dl	1.1	*/
67	dl	1.2	public void add(K key, long x) {
68			StripedAdder a = map.get(key);
69			if (a == null) {
70			StripedAdder r = new StripedAdder();
71			if ((a = map.putIfAbsent(key, r)) == null)
72			a = r;
73			}
74			a.add(x);
75			}
76	dl	1.1
77			/**
78			* Increments the sum associated with the given key. If the key
79			* does not already exist in the table, it is inserted.
80			*
81			* @param key the key
82			*/
83			public void increment(K key) { add(key, 1L); }
84
85			/**
86			* Decrements the sum associated with the given key. If the key
87			* does not already exist in the table, it is inserted.
88			*
89			* @param key the key
90			*/
91			public void decrement(K key) { add(key, -1L); }
92
93			/**
94	dl	1.2	* Returns the sum associated with the given key, or zero if the
95			* key does not currently exist in the table.
96	dl	1.1	*
97			* @param key the key
98	dl	1.2	* @return the sum associated with the key, or zero if the key is
99			* not in the table
100	dl	1.1	*/
101	dl	1.2	public long sum(K key) {
102	dl	1.1	StripedAdder a = map.get(key);
103	dl	1.2	return a == null ? 0L : a.sum();
104	dl	1.1	}
105
106			/**
107	dl	1.2	* Resets the sum associated with the given key to zero if the key
108			* exists in the table. This method does <em>NOT</em> add or
109			* remove the key from the table (see {@link #remove}).
110	dl	1.1	*
111			* @param key the key
112			*/
113	dl	1.2	public void reset(K key) {
114	dl	1.1	StripedAdder a = map.get(key);
115	dl	1.2	if (a != null)
116			a.reset();
117	dl	1.1	}
118
119			/**
120			* Resets the sum associated with the given key to zero if the key
121	dl	1.2	* exists in the table. This method does <em>NOT</em> add or
122			* remove the key from the table (see {@link #remove}).
123	dl	1.1	*
124			* @param key the key
125	dl	1.2	* @return the previous sum, or zero if the key is not
126	dl	1.1	* in the table
127			*/
128	dl	1.2	public long sumThenReset(K key) {
129	dl	1.1	StripedAdder a = map.get(key);
130	dl	1.2	return a == null ? 0L : a.sumThenReset();
131	dl	1.1	}
132
133			/**
134	dl	1.2	* Returns the sum totalled across all keys.
135	dl	1.1	*
136	dl	1.2	* @return the sum totalled across all keys.
137	dl	1.1	*/
138			public long sumAll() {
139			long sum = 0L;
140			for (StripedAdder a : map.values())
141			sum += a.sum();
142			return sum;
143			}
144
145			/**
146	dl	1.2	* Resets the sum associated with each key to zero.
147			*/
148			public void resetAll() {
149			for (StripedAdder a : map.values())
150			a.reset();
151			}
152
153			/**
154			* Totals, then resets, the sums associated with all keys.
155	dl	1.1	*
156	dl	1.2	* @return the sum totalled across all keys.
157	dl	1.1	*/
158	dl	1.2	public long sumThenResetAll() {
159	dl	1.1	long sum = 0L;
160			for (StripedAdder a : map.values())
161	dl	1.2	sum += a.sumThenReset();
162	dl	1.1	return sum;
163			}
164
165			/**
166	dl	1.2	* Removes the given key from the table.
167	dl	1.1	*
168			* @param key the key
169			*/
170			public void remove(K key) { map.remove(key); }
171
172			/**
173			* Returns the current set of keys.
174			*
175			* @return the current set of keys
176			*/
177	dl	1.2	public Set<K> keySet() {
178	dl	1.1	return map.keySet();
179			}
180
181			/**
182			* Returns the current set of key-value mappings.
183			*
184			* @return the current set of key-value mappings
185			*/
186	dl	1.2	public Set<Map.Entry<K,StripedAdder>> entrySet() {
187	dl	1.1	return map.entrySet();
188			}
189
190	dl	1.2	}