final void test() throws Exception {
Future[] futures = new Future[nthreads];
for (int i = 0; i < nthreads; ++i) futures[i] = pool.submit(this);
barrier.await();
Thread.sleep(TIMEOUT);
boolean tooLate = false;
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].cancel(true)) tooLate = true;
// Unbunch some of the cancels
if ((i & 3) == 0) Thread.sleep(1 + rng.next() % 10);
}
Object f0 = futures[0].get();
if (!tooLate) {
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].isDone() || !futures[i].isCancelled())
throw new Error("Only one thread should complete");
}
} else System.out.print("(cancelled too late) ");
long endTime = System.nanoTime();
long time = endTime - timer.startTime;
if (print) {
double secs = (double) (time) / 1000000000.0;
System.out.println("\t " + secs + "s run time");
}
}
int oneStep(int j) {
int n = key.length;
int r = rng.next() & 0x7FFFFFFF;
int jinc = (r & 7);
j += jinc - 3;
if (j >= n) j -= n;
if (j < 0) j += n;
int l = n / 4 + j;
if (l >= n) l -= n;
String k = key[j];
String x = map.get(k);
if (x == null) {
++nagets;
if (r < pctins) {
map.put(k, key[l]);
++nputs;
int csz = nputs - nremoves;
if (csz > maxsz) maxsz = csz;
}
} else {
if (k == x) ++npgets;
if (r < pctrem) {
map.remove(k);
++nremoves;
j += ((r >>> 8) & 7) + n / 2;
if (j >= n) j -= n;
}
}
return j;
}
static final class FutureLoop implements Callable {
private int v = rng.next();
private final ReentrantLock lock = new ReentrantLock();
private final LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
private final CyclicBarrier barrier;
private final int nthreads;
FutureLoop(int nthreads) {
this.nthreads = nthreads;
barrier = new CyclicBarrier(nthreads + 1, timer);
}
final void test() throws Exception {
Future[] futures = new Future[nthreads];
for (int i = 0; i < nthreads; ++i) futures[i] = pool.submit(this);
barrier.await();
Thread.sleep(TIMEOUT);
boolean tooLate = false;
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].cancel(true)) tooLate = true;
// Unbunch some of the cancels
if ((i & 3) == 0) Thread.sleep(1 + rng.next() % 10);
}
Object f0 = futures[0].get();
if (!tooLate) {
for (int i = 1; i < nthreads; ++i) {
if (!futures[i].isDone() || !futures[i].isCancelled())
throw new Error("Only one thread should complete");
}
} else System.out.print("(cancelled too late) ");
long endTime = System.nanoTime();
long time = endTime - timer.startTime;
if (print) {
double secs = (double) (time) / 1000000000.0;
System.out.println("\t " + secs + "s run time");
}
}
public final Object call() throws Exception {
barrier.await();
int sum = v;
int x = 0;
int n = ITERS;
while (n-- > 0) {
lock.lockInterruptibly();
try {
v = x = LoopHelpers.compute1(v);
} finally {
lock.unlock();
}
sum += LoopHelpers.compute2(LoopHelpers.compute2(x));
}
return new Integer(sum);
}
}
static void randomWords(Object[] ws, int origin, int size) {
for (int i = origin; i < size; ++i) {
int k = 0;
int len = 2 + (srng.next() & 0xf);
char[] c = new char[len * 4 + 1];
for (int j = 1; j < len; ++j) {
int r = srng.next();
c[k++] = (char) (' ' + (r & 0x7f));
r >>>= 8;
c[k++] = (char) (' ' + (r & 0x7f));
r >>>= 8;
c[k++] = (char) (' ' + (r & 0x7f));
r >>>= 8;
c[k++] = (char) (' ' + (r & 0x7f));
}
c[k++] = (char) ((i & 31) | 1); // never == to any testword
ws[i] = new String(c);
}
}
static void initInts(Object[] key, Object[] absent, int size) {
for (int i = 0; i < size; ++i) key[i] = Integer.valueOf(i);
Map m = newMap();
int k = 0;
while (k < size) {
int r = srng.next();
if (r < 0 || r >= size) {
Integer ir = Integer.valueOf(r);
if (m.put(ir, ir) == null) absent[k++] = ir;
}
}
}