future : futures) {
total += future.get(5, TimeUnit.MINUTES);
}
return total;
} finally {
pool.shutdown();
pool.awaitTermination(30, TimeUnit.SECONDS);
}
}
private Rule buildEagerRule() {
Rule left = new FixedRule(1);
Rule right = new FixedRule(2);
return new AndRule(left, right);
}
Rule buildLazyRule() {
Rule left = new FixedRule(1);
Rule right = new FixedRule(2);
return new LazyAndRule(left, right);
}
Rule buildEagerRuleNoChildNames() {
Rule left = new FixedRule(1);
Rule right = new FixedRule(2);
return new NoNameLeakAndRule(left, right);
}
/**
* Lazy variant of AndRule that defers name construction to getName().
*/
static final class LazyAndRule extends AbstractRule {
private final Rule rule1;
private final Rule rule2;
LazyAndRule(Rule rule1, Rule rule2) {
this.rule1 = rule1;
this.rule2 = rule2;
}
@Override
public boolean isSatisfied(int index, TradingRecord tradingRecord) {
boolean satisfied = rule1.isSatisfied(index, tradingRecord) && rule2.isSatisfied(index, tradingRecord);
traceIsSatisfied(index, satisfied);
return satisfied;
}
@Override
protected String createDefaultName() {
setName(createCompositeName(getClass().getSimpleName(), rule1, rule2));
return getName();
}
}
/**
* Eager variant that constructs the name in the constructor but avoids calling
* getName() on children (to prevent triggering their lazy name resolution).
* This demonstrates that even when setName() is called eagerly, if getName() is
* never invoked on the rule, the JIT compiler may be able to optimize away some
* of the string construction overhead, though the volatile write itself cannot
* be eliminated.
*
* Note: The volatile write in setName() is an observable side effect that
* prevents complete dead-code elimination, but the string construction work
* (StringBuilder operations) may still be optimized if the result is never
* read.
*/
static final class NoNameLeakAndRule extends AbstractRule {
private final Rule rule1;
private final Rule rule2;
NoNameLeakAndRule(Rule rule1, Rule rule2) {
this.rule1 = rule1;
this.rule2 = rule2;
// Eagerly construct and set the name, but use class names instead of
// calling getName() on children to avoid triggering their lazy name resolution.
// This allows us to test if JIT can eliminate the string construction
// overhead when the name is never accessed.
setName(buildNameWithoutChildNames());
}
@Override
public boolean isSatisfied(int index, TradingRecord tradingRecord) {
boolean satisfied = rule1.isSatisfied(index, tradingRecord) && rule2.isSatisfied(index, tradingRecord);
traceIsSatisfied(index, satisfied);
return satisfied;
}
private String buildNameWithoutChildNames() {
StringBuilder builder = new StringBuilder(getClass().getSimpleName());
builder.append('(');
builder.append(rule1 == null ? "null" : rule1.getClass().getSimpleName());
builder.append(',');
builder.append(rule2 == null ? "null" : rule2.getClass().getSimpleName());
builder.append(')');
return builder.toString();
}
}
private static final class ScenarioStats {
int runs;
double totalDurationNanos;
double totalThroughput;
double minThroughput = Double.MAX_VALUE;
double maxThroughput = Double.MIN_VALUE;
long totalChecksum;
}
}