001: /*
002: * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright
003: * notice. All rights reserved.
004: */
005: package com.tctest;
006:
007: import EDU.oswego.cs.dl.util.concurrent.CyclicBarrier;
008:
009: import com.tc.object.config.ConfigVisitor;
010: import com.tc.object.config.DSOClientConfigHelper;
011: import com.tc.object.config.TransparencyClassSpec;
012: import com.tc.simulator.app.ApplicationConfig;
013: import com.tc.simulator.listener.ListenerProvider;
014: import com.tc.util.Assert;
015: import com.tctest.runner.AbstractTransparentApp;
016:
017: import java.util.ArrayList;
018: import java.util.Collections;
019: import java.util.List;
020: import java.util.concurrent.atomic.AtomicInteger;
021:
022: public class AtomicIntegerTestApp extends AbstractTransparentApp {
023:
024: private final CyclicBarrier barrier;
025:
026: private final DataRoot root = new DataRoot();
027: private final AtomicInteger sum = new AtomicInteger(0);
028:
029: public AtomicIntegerTestApp(String appId, ApplicationConfig cfg,
030: ListenerProvider listenerProvider) {
031: super (appId, cfg, listenerProvider);
032: barrier = new CyclicBarrier(getParticipantCount());
033: }
034:
035: public void run() {
036: try {
037: atomicIntegerTesting();
038: } catch (Throwable t) {
039: notifyError(t);
040: }
041: }
042:
043: private void atomicIntegerTesting() throws Exception {
044: loadTest();
045: basicSetTesting();
046: basicGetTesting();
047: addAndGetTesting();
048: compareAndSetTesting();
049: weakCompareAndSetTesting();
050: getAndIncrementTesting();
051: getAndDecrementTesting();
052: getAndSetTesting();
053: getAndAddTesting();
054: incrementAndGetTesting();
055: decrementAndGetTesting();
056: }
057:
058: private void clear() throws Exception {
059: synchronized (root) {
060: root.clear();
061: }
062:
063: barrier.barrier();
064: }
065:
066: private void initialize() throws Exception {
067:
068: int index = barrier.barrier();
069:
070: if (index == 0) {
071: root.getIntValue().set(10);
072: }
073:
074: barrier.barrier();
075:
076: }
077:
078: private void loadTest() throws Exception {
079: List errors = Collections.synchronizedList(new ArrayList());
080:
081: Loader[] loaders = new Loader[3];
082:
083: for (int i = 0; i < loaders.length; i++) {
084: loaders[i] = new Loader(sum, errors);
085: loaders[i].start();
086: }
087:
088: for (int i = 0; i < loaders.length; i++) {
089: loaders[i].join();
090: }
091: if (errors.size() == 0) {
092: if (barrier.barrier() == 0) {
093: Assert.assertEquals(100 * getParticipantCount()
094: * loaders.length, sum.intValue());
095: }
096: } else {
097: throw new Exception((Throwable) errors.get(0));
098: }
099: }
100:
101: private void basicSetTesting() throws Exception {
102: clear();
103: initialize();
104:
105: Assert.assertEquals(10, root.getIntValue().get());
106:
107: barrier.barrier();
108: }
109:
110: private void basicGetTesting() throws Exception {
111: clear();
112: initialize();
113:
114: Assert.assertEquals(10, root.getIntValue().get());
115: Assert.assertEquals(10.0D, root.getIntValue().doubleValue());
116: Assert.assertEquals((byte) 10, root.getIntValue().byteValue());
117: Assert.assertEquals(10.0f, root.getIntValue().floatValue());
118: Assert.assertEquals(10, root.getIntValue().intValue());
119: Assert.assertEquals(10L, root.getIntValue().longValue());
120: Assert.assertEquals(10, root.getIntValue().shortValue());
121:
122: barrier.barrier();
123: }
124:
125: private void addAndGetTesting() throws Exception {
126: clear();
127: initialize();
128:
129: int index = barrier.barrier();
130:
131: if (index == 0) {
132: int val = root.getIntValue().addAndGet(4);
133: Assert.assertEquals(14, val);
134: }
135:
136: barrier.barrier();
137:
138: Assert.assertEquals(14, root.getIntValue().get());
139:
140: barrier.barrier();
141: }
142:
143: private void compareAndSetTesting() throws Exception {
144: clear();
145: initialize();
146:
147: int index = barrier.barrier();
148: if (index == 0) {
149: root.getIntValue().compareAndSet(10, 18);
150: }
151:
152: barrier.barrier();
153:
154: Assert.assertEquals(18, root.getIntValue().get());
155:
156: barrier.barrier();
157: }
158:
159: private void weakCompareAndSetTesting() throws Exception {
160: clear();
161: initialize();
162:
163: int index = barrier.barrier();
164: if (index == 0) {
165: root.getIntValue().weakCompareAndSet(10, 20);
166: }
167:
168: barrier.barrier();
169:
170: Assert.assertEquals(20, root.getIntValue().get());
171:
172: barrier.barrier();
173: }
174:
175: private void getAndIncrementTesting() throws Exception {
176: clear();
177: initialize();
178:
179: int index = barrier.barrier();
180: if (index == 0) {
181: int val = root.getIntValue().getAndIncrement();
182: Assert.assertEquals(10, val);
183: }
184:
185: barrier.barrier();
186:
187: Assert.assertEquals(11, root.getIntValue().get());
188:
189: barrier.barrier();
190: }
191:
192: private void getAndDecrementTesting() throws Exception {
193: clear();
194: initialize();
195:
196: int index = barrier.barrier();
197: if (index == 0) {
198: int val = root.getIntValue().getAndDecrement();
199: Assert.assertEquals(10, val);
200: }
201:
202: barrier.barrier();
203:
204: Assert.assertEquals(9, root.getIntValue().get());
205:
206: barrier.barrier();
207: }
208:
209: private void getAndSetTesting() throws Exception {
210: clear();
211: initialize();
212:
213: int index = barrier.barrier();
214: if (index == 0) {
215: int val = root.getIntValue().getAndSet(200);
216: Assert.assertEquals(10, val);
217: }
218:
219: barrier.barrier();
220:
221: Assert.assertEquals(200, root.getIntValue().get());
222:
223: barrier.barrier();
224: }
225:
226: private void getAndAddTesting() throws Exception {
227: clear();
228: initialize();
229:
230: int index = barrier.barrier();
231: if (index == 0) {
232: int val = root.getIntValue().getAndAdd(5);
233: Assert.assertEquals(10, val);
234: }
235:
236: barrier.barrier();
237:
238: Assert.assertEquals(15, root.getIntValue().get());
239:
240: barrier.barrier();
241: }
242:
243: private void incrementAndGetTesting() throws Exception {
244: clear();
245: initialize();
246:
247: int index = barrier.barrier();
248: if (index == 0) {
249: int val = root.getIntValue().incrementAndGet();
250: Assert.assertEquals(11, val);
251: }
252:
253: barrier.barrier();
254:
255: Assert.assertEquals(11, root.getIntValue().get());
256:
257: barrier.barrier();
258: }
259:
260: private void decrementAndGetTesting() throws Exception {
261: clear();
262: initialize();
263:
264: int index = barrier.barrier();
265: if (index == 0) {
266: int val = root.getIntValue().decrementAndGet();
267: Assert.assertEquals(9, val);
268: }
269:
270: barrier.barrier();
271:
272: Assert.assertEquals(9, root.getIntValue().get());
273:
274: barrier.barrier();
275: }
276:
277: public static void visitL1DSOConfig(ConfigVisitor visitor,
278: DSOClientConfigHelper config) {
279: TransparencyClassSpec spec = config
280: .getOrCreateSpec(CyclicBarrier.class.getName());
281: config.addWriteAutolock("* " + CyclicBarrier.class.getName()
282: + "*.*(..)");
283:
284: String testClass = AtomicIntegerTestApp.class.getName();
285: spec = config.getOrCreateSpec(testClass);
286:
287: config.addIncludePattern(testClass + "$*");
288:
289: String methodExpression = "* " + testClass + "*.*(..)";
290: config.addWriteAutolock(methodExpression);
291:
292: spec.addRoot("barrier", "barrier");
293: spec.addRoot("root", "root");
294: spec.addRoot("sum", "sum");
295: }
296:
297: private static class DataRoot {
298: private AtomicInteger intValue = new AtomicInteger(0);
299:
300: public DataRoot() {
301: super ();
302: }
303:
304: public AtomicInteger getIntValue() {
305: return intValue;
306: }
307:
308: public void setIntValue(AtomicInteger intValue) {
309: this .intValue = intValue;
310: }
311:
312: public void clear() {
313: intValue.set(0);
314: }
315: }
316:
317: private static class Loader extends Thread {
318: private AtomicInteger sum;
319: private List errors;
320:
321: public Loader(AtomicInteger sum, List errors) {
322: this .sum = sum;
323: this .errors = errors;
324: }
325:
326: public void run() {
327: try {
328: for (int i = 0; i < 100; i++) {
329: sum.addAndGet(1);
330: }
331: } catch (Throwable t) {
332: errors.add(t);
333: }
334: }
335: }
336:
337: }
|