diff --git a/CHANGES.txt b/CHANGES.txt index a6adfe03e2..b2b33b0bff 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -63,6 +63,7 @@ * Evaluate MurmurHash of Token once per query (CASSANDRA-7096) 2.1.4 + * cassandra-stress reports per-operation statistics, plus misc (CASSANDRA-8769) * Add SimpleDate (cql date) and Time (cql time) types (CASSANDRA-7523) * Use long for key count in cfstats (CASSANDRA-8913) * Make SSTableRewriter.abort() more robust to failure (CASSANDRA-8832) diff --git a/tools/stress/src/org/apache/cassandra/stress/Operation.java b/tools/stress/src/org/apache/cassandra/stress/Operation.java index 05045f8e6f..f4ac5ee1a6 100644 --- a/tools/stress/src/org/apache/cassandra/stress/Operation.java +++ b/tools/stress/src/org/apache/cassandra/stress/Operation.java @@ -176,7 +176,7 @@ public abstract class Operation } } - timer.stop(run.partitionCount(), run.rowCount()); + timer.stop(run.partitionCount(), run.rowCount(), !success); if (!success) { diff --git a/tools/stress/src/org/apache/cassandra/stress/StressAction.java b/tools/stress/src/org/apache/cassandra/stress/StressAction.java index 1433742a79..f906a55fe6 100644 --- a/tools/stress/src/org/apache/cassandra/stress/StressAction.java +++ b/tools/stress/src/org/apache/cassandra/stress/StressAction.java @@ -30,10 +30,11 @@ import com.google.common.util.concurrent.Uninterruptibles; import org.apache.cassandra.stress.operations.OpDistribution; import org.apache.cassandra.stress.operations.OpDistributionFactory; +import org.apache.cassandra.stress.settings.SettingsCommand; import org.apache.cassandra.stress.settings.StressSettings; import org.apache.cassandra.stress.util.JavaDriverClient; import org.apache.cassandra.stress.util.ThriftClient; -import org.apache.cassandra.stress.util.Timer; +import org.apache.cassandra.stress.util.TimingInterval; import org.apache.cassandra.transport.SimpleClient; public class StressAction implements Runnable @@ -53,13 +54,14 @@ public class StressAction implements Runnable // creating keyspace and column families settings.maybeCreateKeyspaces(); - // TODO: warmup should operate configurably over op/pk/row, and be of configurable length - if (!settings.command.noWarmup) - warmup(settings.command.getFactory(settings)); - output.println("Sleeping 2s..."); Uninterruptibles.sleepUninterruptibly(2, TimeUnit.SECONDS); + if (!settings.command.noWarmup) + warmup(settings.command.getFactory(settings)); + if (settings.command.truncate == SettingsCommand.TruncateWhen.ONCE) + settings.command.truncateTables(settings); + // TODO : move this to a new queue wrapper that gates progress based on a poisson (or configurable) distribution RateLimiter rateLimiter = null; if (settings.rate.opRateTargetPerSecond > 0) @@ -86,12 +88,19 @@ public class StressAction implements Runnable // warmup - do 50k iterations; by default hotspot compiles methods after 10k invocations PrintStream warmupOutput = new PrintStream(new OutputStream() { @Override public void write(int b) throws IOException { } } ); int iterations = 50000 * settings.node.nodes.size(); + int threads = 20; + + if (settings.rate.maxThreads > 0) + threads = Math.min(threads, settings.rate.maxThreads); + if (settings.rate.threadCount > 0) + threads = Math.min(threads, settings.rate.threadCount); + for (OpDistributionFactory single : operations.each()) { // we need to warm up all the nodes in the cluster ideally, but we may not be the only stress instance; // so warm up all the nodes we're speaking to only. output.println(String.format("Warming up %s with %d iterations...", single.desc(), iterations)); - run(single, 20, iterations, 0, null, null, warmupOutput); + run(single, threads, iterations, 0, null, null, warmupOutput); } } @@ -109,6 +118,9 @@ public class StressAction implements Runnable { output.println(String.format("Running with %d threadCount", threadCount)); + if (settings.command.truncate == SettingsCommand.TruncateWhen.ALWAYS) + settings.command.truncateTables(settings); + StressMetrics result = run(settings.command.getFactory(settings), threadCount, settings.command.count, settings.command.duration, rateLimiter, settings.command.durationUnits, output); if (result == null) @@ -146,7 +158,7 @@ public class StressAction implements Runnable } while (!auto || (hasAverageImprovement(results, 3, 0) && hasAverageImprovement(results, 5, settings.command.targetUncertainty))); // summarise all results - StressMetrics.summarise(runIds, results, output); + StressMetrics.summarise(runIds, results, output, settings.samples.historyCount); return true; } @@ -187,8 +199,8 @@ public class StressAction implements Runnable final Consumer[] consumers = new Consumer[threadCount]; for (int i = 0; i < threadCount; i++) { - Timer timer = metrics.getTiming().newTimer(settings.samples.liveCount / threadCount); - consumers[i] = new Consumer(operations, done, workManager, timer, metrics, rateLimiter); + consumers[i] = new Consumer(operations, done, workManager, metrics, rateLimiter, + settings.samples.liveCount / threadCount); } // starting worker threadCount @@ -240,28 +252,27 @@ public class StressAction implements Runnable private final OpDistribution operations; private final StressMetrics metrics; - private final Timer timer; private final RateLimiter rateLimiter; private volatile boolean success = true; private final WorkManager workManager; private final CountDownLatch done; - public Consumer(OpDistributionFactory operations, CountDownLatch done, WorkManager workManager, Timer timer, StressMetrics metrics, RateLimiter rateLimiter) + public Consumer(OpDistributionFactory operations, CountDownLatch done, WorkManager workManager, StressMetrics metrics, + RateLimiter rateLimiter, int sampleCount) { this.done = done; this.rateLimiter = rateLimiter; this.workManager = workManager; this.metrics = metrics; - this.timer = timer; - this.operations = operations.get(timer); + this.operations = operations.get(metrics.getTiming(), sampleCount); } public void run() { - timer.init(); + operations.initTimers(); + try { - SimpleClient sclient = null; ThriftClient tclient = null; JavaDriverClient jclient = null; @@ -324,11 +335,8 @@ public class StressAction implements Runnable finally { done.countDown(); - timer.close(); + operations.closeTimers(); } - } - } - } diff --git a/tools/stress/src/org/apache/cassandra/stress/StressMetrics.java b/tools/stress/src/org/apache/cassandra/stress/StressMetrics.java index 12bdc3e925..a640058c0d 100644 --- a/tools/stress/src/org/apache/cassandra/stress/StressMetrics.java +++ b/tools/stress/src/org/apache/cassandra/stress/StressMetrics.java @@ -24,17 +24,15 @@ package org.apache.cassandra.stress; import java.io.PrintStream; import java.util.Arrays; import java.util.List; +import java.util.Map; import java.util.concurrent.Callable; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ThreadFactory; +import org.apache.cassandra.stress.util.*; import org.apache.commons.lang3.time.DurationFormatUtils; import org.apache.cassandra.concurrent.NamedThreadFactory; import org.apache.cassandra.stress.settings.StressSettings; -import org.apache.cassandra.stress.util.JmxCollector; -import org.apache.cassandra.stress.util.Timing; -import org.apache.cassandra.stress.util.TimingInterval; -import org.apache.cassandra.stress.util.Uncertainty; public class StressMetrics { @@ -50,10 +48,12 @@ public class StressMetrics private final Timing timing; private final Callable gcStatsCollector; private volatile JmxCollector.GcStats totalGcStats; + private final StressSettings settings; public StressMetrics(PrintStream output, final long logIntervalMillis, StressSettings settings) { this.output = output; + this.settings = settings; Callable gcStatsCollector; totalGcStats = new JmxCollector.GcStats(0); try @@ -92,7 +92,9 @@ public class StressMetrics { try { - long sleep = timing.getHistory().endMillis() + logIntervalMillis - System.currentTimeMillis(); + long sleepNanos = timing.getHistory().endNanos() - System.nanoTime(); + long sleep = (sleepNanos / 1000000) + logIntervalMillis; + if (sleep < logIntervalMillis >>> 3) // if had a major hiccup, sleep full interval Thread.sleep(logIntervalMillis); @@ -153,9 +155,19 @@ public class StressMetrics { Timing.TimingResult result = timing.snap(gcStatsCollector); totalGcStats = JmxCollector.GcStats.aggregate(Arrays.asList(totalGcStats, result.extra)); - if (result.timing.partitionCount != 0) - printRow("", result.timing, timing.getHistory(), result.extra, rowRateUncertainty, output); - rowRateUncertainty.update(result.timing.adjustedRowRate()); + TimingInterval current = result.intervals.combine(settings.samples.reportCount); + TimingInterval history = timing.getHistory().combine(settings.samples.historyCount); + rowRateUncertainty.update(current.adjustedRowRate()); + if (current.partitionCount != 0) + { + if (result.intervals.intervals().size() > 1) + { + for (Map.Entry type : result.intervals.intervals().entrySet()) + printRow("", type.getKey(), type.getValue(), timing.getHistory().get(type.getKey()), result.extra, rowRateUncertainty, output); + } + + printRow("", "total", current, history, result.extra, rowRateUncertainty, output); + } if (timing.done()) stop = true; } @@ -163,19 +175,19 @@ public class StressMetrics // PRINT FORMATTING - public static final String HEADFORMAT = "%-10s,%10s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%7s,%9s,%7s,%8s,%8s,%8s,%8s"; - public static final String ROWFORMAT = "%-10d,%10.0f,%8.0f,%8.0f,%8.0f,%8.1f,%8.1f,%8.1f,%8.1f,%8.1f,%8.1f,%7.1f,%9.5f,%7.0f,%8.0f,%8.0f,%8.0f,%8.0f"; + public static final String HEADFORMAT = "%-10s%10s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%8s,%7s,%9s,%7s,%7s,%8s,%8s,%8s,%8s"; + public static final String ROWFORMAT = "%-10s%10d,%8.0f,%8.0f,%8.0f,%8.1f,%8.1f,%8.1f,%8.1f,%8.1f,%8.1f,%7.1f,%9.5f,%7d,%7.0f,%8.0f,%8.0f,%8.0f,%8.0f"; private static void printHeader(String prefix, PrintStream output) { - output.println(prefix + String.format(HEADFORMAT, "total ops","adj row/s","op/s","pk/s","row/s","mean","med",".95",".99",".999","max","time","stderr", "gc: #", "max ms", "sum ms", "sdv ms", "mb")); + output.println(prefix + String.format(HEADFORMAT, "type,", "total ops","op/s","pk/s","row/s","mean","med",".95",".99",".999","max","time","stderr", "errors", "gc: #", "max ms", "sum ms", "sdv ms", "mb")); } - private static void printRow(String prefix, TimingInterval interval, TimingInterval total, JmxCollector.GcStats gcStats, Uncertainty opRateUncertainty, PrintStream output) + private static void printRow(String prefix, String type, TimingInterval interval, TimingInterval total, JmxCollector.GcStats gcStats, Uncertainty opRateUncertainty, PrintStream output) { output.println(prefix + String.format(ROWFORMAT, + type + ",", total.operationCount, - interval.adjustedRowRate(), interval.opRate(), interval.partitionRate(), interval.rowRate(), @@ -187,6 +199,7 @@ public class StressMetrics interval.maxLatency(), total.runTime() / 1000f, opRateUncertainty.getUncertainty(), + interval.errorCount, gcStats.count, gcStats.maxms, gcStats.summs, @@ -199,16 +212,20 @@ public class StressMetrics { output.println("\n"); output.println("Results:"); - TimingInterval history = timing.getHistory(); - output.println(String.format("op rate : %.0f", history.opRate())); - output.println(String.format("partition rate : %.0f", history.partitionRate())); - output.println(String.format("row rate : %.0f", history.rowRate())); - output.println(String.format("latency mean : %.1f", history.meanLatency())); - output.println(String.format("latency median : %.1f", history.medianLatency())); - output.println(String.format("latency 95th percentile : %.1f", history.rankLatency(.95f))); - output.println(String.format("latency 99th percentile : %.1f", history.rankLatency(0.99f))); - output.println(String.format("latency 99.9th percentile : %.1f", history.rankLatency(0.999f))); - output.println(String.format("latency max : %.1f", history.maxLatency())); + + TimingIntervals opHistory = timing.getHistory(); + TimingInterval history = opHistory.combine(settings.samples.historyCount); + output.println(String.format("op rate : %.0f %s", history.opRate(), opHistory.opRates())); + output.println(String.format("partition rate : %.0f %s", history.partitionRate(), opHistory.partitionRates())); + output.println(String.format("row rate : %.0f %s", history.rowRate(), opHistory.rowRates())); + output.println(String.format("latency mean : %.1f %s", history.meanLatency(), opHistory.meanLatencies())); + output.println(String.format("latency median : %.1f %s", history.medianLatency(), opHistory.medianLatencies())); + output.println(String.format("latency 95th percentile : %.1f %s", history.rankLatency(.95f), opHistory.rankLatencies(0.95f))); + output.println(String.format("latency 99th percentile : %.1f %s", history.rankLatency(0.99f), opHistory.rankLatencies(0.99f))); + output.println(String.format("latency 99.9th percentile : %.1f %s", history.rankLatency(0.999f), opHistory.rankLatencies(0.999f))); + output.println(String.format("latency max : %.1f %s", history.maxLatency(), opHistory.maxLatencies())); + output.println(String.format("Total partitions : %d %s", history.partitionCount, opHistory.partitionCounts())); + output.println(String.format("Total errors : %d %s", history.errorCount, opHistory.errorCounts())); output.println(String.format("total gc count : %.0f", totalGcStats.count)); output.println(String.format("total gc mb : %.0f", totalGcStats.bytes / (1 << 20))); output.println(String.format("total gc time (s) : %.0f", totalGcStats.summs / 1000)); @@ -218,7 +235,7 @@ public class StressMetrics history.runTime(), "HH:mm:ss", true)); } - public static void summarise(List ids, List summarise, PrintStream out) + public static void summarise(List ids, List summarise, PrintStream out, int historySampleCount) { int idLen = 0; for (String id : ids) @@ -226,13 +243,27 @@ public class StressMetrics String formatstr = "%" + idLen + "s, "; printHeader(String.format(formatstr, "id"), out); for (int i = 0 ; i < ids.size() ; i++) + { + for (Map.Entry type : summarise.get(i).timing.getHistory().intervals().entrySet()) + { + printRow(String.format(formatstr, ids.get(i)), + type.getKey(), + type.getValue(), + type.getValue(), + summarise.get(i).totalGcStats, + summarise.get(i).rowRateUncertainty, + out); + } + TimingInterval hist = summarise.get(i).timing.getHistory().combine(historySampleCount); printRow(String.format(formatstr, ids.get(i)), - summarise.get(i).timing.getHistory(), - summarise.get(i).timing.getHistory(), + "total", + hist, + hist, summarise.get(i).totalGcStats, summarise.get(i).rowRateUncertainty, out ); + } } public Timing getTiming() diff --git a/tools/stress/src/org/apache/cassandra/stress/StressProfile.java b/tools/stress/src/org/apache/cassandra/stress/StressProfile.java index 1aa2063984..c93e8b9f5a 100644 --- a/tools/stress/src/org/apache/cassandra/stress/StressProfile.java +++ b/tools/stress/src/org/apache/cassandra/stress/StressProfile.java @@ -43,10 +43,7 @@ import org.apache.cassandra.stress.generate.*; import org.apache.cassandra.stress.generate.values.*; import org.apache.cassandra.stress.operations.userdefined.SchemaInsert; import org.apache.cassandra.stress.operations.userdefined.SchemaQuery; -import org.apache.cassandra.stress.settings.OptionDistribution; -import org.apache.cassandra.stress.settings.OptionRatioDistribution; -import org.apache.cassandra.stress.settings.StressSettings; -import org.apache.cassandra.stress.settings.ValidationType; +import org.apache.cassandra.stress.settings.*; import org.apache.cassandra.stress.util.JavaDriverClient; import org.apache.cassandra.stress.util.ThriftClient; import org.apache.cassandra.stress.util.Timer; @@ -188,6 +185,16 @@ public class StressProfile implements Serializable maybeLoadSchemaInfo(settings); } + public void truncateTable(StressSettings settings) + { + JavaDriverClient client = settings.getJavaDriverClient(false); + assert settings.command.truncate != SettingsCommand.TruncateWhen.NEVER; + String cql = String.format("TRUNCATE %s.%s", keyspaceName, tableName); + client.execute(cql, org.apache.cassandra.db.ConsistencyLevel.ONE); + System.out.println(String.format("Truncated %s.%s. Sleeping %ss for propagation.", + keyspaceName, tableName, settings.node.nodes.size())); + Uninterruptibles.sleepUninterruptibly(settings.node.nodes.size(), TimeUnit.SECONDS); + } private void maybeLoadSchemaInfo(StressSettings settings) { diff --git a/tools/stress/src/org/apache/cassandra/stress/operations/FixedOpDistribution.java b/tools/stress/src/org/apache/cassandra/stress/operations/FixedOpDistribution.java index 533b6308a4..f2616cf4a2 100644 --- a/tools/stress/src/org/apache/cassandra/stress/operations/FixedOpDistribution.java +++ b/tools/stress/src/org/apache/cassandra/stress/operations/FixedOpDistribution.java @@ -36,4 +36,14 @@ public class FixedOpDistribution implements OpDistribution { return operation; } + + public void initTimers() + { + operation.timer.init(); + } + + public void closeTimers() + { + operation.timer.close(); + } } diff --git a/tools/stress/src/org/apache/cassandra/stress/operations/OpDistribution.java b/tools/stress/src/org/apache/cassandra/stress/operations/OpDistribution.java index 0fc15a67f2..e09300aeaf 100644 --- a/tools/stress/src/org/apache/cassandra/stress/operations/OpDistribution.java +++ b/tools/stress/src/org/apache/cassandra/stress/operations/OpDistribution.java @@ -28,4 +28,6 @@ public interface OpDistribution Operation next(); + public void initTimers(); + public void closeTimers(); } diff --git a/tools/stress/src/org/apache/cassandra/stress/operations/OpDistributionFactory.java b/tools/stress/src/org/apache/cassandra/stress/operations/OpDistributionFactory.java index afbae7d481..7e13fcd879 100644 --- a/tools/stress/src/org/apache/cassandra/stress/operations/OpDistributionFactory.java +++ b/tools/stress/src/org/apache/cassandra/stress/operations/OpDistributionFactory.java @@ -21,13 +21,11 @@ package org.apache.cassandra.stress.operations; */ -import org.apache.cassandra.stress.util.Timer; +import org.apache.cassandra.stress.util.Timing; public interface OpDistributionFactory { - - public OpDistribution get(Timer timer); + public OpDistribution get(Timing timing, int sampleCount); public String desc(); Iterable each(); - } diff --git a/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistribution.java b/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistribution.java index 432e9913a0..9698421cc5 100644 --- a/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistribution.java +++ b/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistribution.java @@ -25,6 +25,7 @@ import org.apache.commons.math3.distribution.EnumeratedDistribution; import org.apache.cassandra.stress.Operation; import org.apache.cassandra.stress.generate.Distribution; +import org.apache.commons.math3.util.Pair; public class SampledOpDistribution implements OpDistribution { @@ -50,4 +51,20 @@ public class SampledOpDistribution implements OpDistribution remaining--; return cur; } + + public void initTimers() + { + for (Pair op : operations.getPmf()) + { + op.getFirst().timer.init(); + } + } + + public void closeTimers() + { + for (Pair op : operations.getPmf()) + { + op.getFirst().timer.close(); + } + } } diff --git a/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistributionFactory.java b/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistributionFactory.java index 9e1a5e8e41..40700d2e01 100644 --- a/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistributionFactory.java +++ b/tools/stress/src/org/apache/cassandra/stress/operations/SampledOpDistributionFactory.java @@ -26,6 +26,7 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import org.apache.cassandra.stress.util.Timing; import org.apache.commons.math3.distribution.EnumeratedDistribution; import org.apache.commons.math3.util.Pair; @@ -48,12 +49,13 @@ public abstract class SampledOpDistributionFactory implements OpDistributionF protected abstract Operation get(Timer timer, PartitionGenerator generator, T key); protected abstract PartitionGenerator newGenerator(); - public OpDistribution get(Timer timer) + public OpDistribution get(Timing timing, int sampleCount) { PartitionGenerator generator = newGenerator(); List> operations = new ArrayList<>(); for (Map.Entry ratio : ratios.entrySet()) - operations.add(new Pair<>(get(timer, generator, ratio.getKey()), ratio.getValue())); + operations.add(new Pair<>(get(timing.newTimer(ratio.getKey().toString(), sampleCount), generator, ratio.getKey()), + ratio.getValue())); return new SampledOpDistribution(new EnumeratedDistribution<>(operations), clustering.get()); } @@ -72,9 +74,9 @@ public abstract class SampledOpDistributionFactory implements OpDistributionF { out.add(new OpDistributionFactory() { - public OpDistribution get(Timer timer) + public OpDistribution get(Timing timing, int sampleCount) { - return new FixedOpDistribution(SampledOpDistributionFactory.this.get(timer, newGenerator(), ratio.getKey())); + return new FixedOpDistribution(SampledOpDistributionFactory.this.get(timing.newTimer(ratio.getKey().toString(), sampleCount), newGenerator(), ratio.getKey())); } public String desc() diff --git a/tools/stress/src/org/apache/cassandra/stress/settings/Command.java b/tools/stress/src/org/apache/cassandra/stress/settings/Command.java index 9a93e3448c..c47c5d2502 100644 --- a/tools/stress/src/org/apache/cassandra/stress/settings/Command.java +++ b/tools/stress/src/org/apache/cassandra/stress/settings/Command.java @@ -31,38 +31,37 @@ import com.google.common.collect.ImmutableList; public enum Command { - READ(false, "standard1", "Super1", + READ(false, "standard1", "Multiple concurrent reads - the cluster must first be populated by a write test", CommandCategory.BASIC ), - WRITE(true, "standard1", "Super1", + WRITE(true, "standard1", "insert", "Multiple concurrent writes against the cluster", CommandCategory.BASIC ), - MIXED(true, null, null, + MIXED(true, null, "Interleaving of any basic commands, with configurable ratio and distribution - the cluster must first be populated by a write test", CommandCategory.MIXED ), - COUNTER_WRITE(true, "counter1", "SuperCounter1", + COUNTER_WRITE(true, "counter1", "counter_add", "Multiple concurrent updates of counters.", CommandCategory.BASIC ), - COUNTER_READ(false, "counter1", "SuperCounter1", + COUNTER_READ(false, "counter1", "counter_get", "Multiple concurrent reads of counters. The cluster must first be populated by a counterwrite test.", CommandCategory.BASIC ), - USER(true, null, null, + USER(true, null, "Interleaving of user provided queries, with configurable ratio and distribution", CommandCategory.USER ), - HELP(false, null, null, "-?", "Print help for a command or option", null), - PRINT(false, null, null, "Inspect the output of a distribution definition", null), - LEGACY(false, null, null, "Legacy support mode", null) - + HELP(false, null, "-?", "Print help for a command or option", null), + PRINT(false, null, "Inspect the output of a distribution definition", null), + LEGACY(false, null, "Legacy support mode", null) ; private static final Map LOOKUP; @@ -87,17 +86,15 @@ public enum Command public final List names; public final String description; public final String table; - public final String supertable; - Command(boolean updates, String table, String supertable, String description, CommandCategory category) + Command(boolean updates, String table, String description, CommandCategory category) { - this(updates, table, supertable, null, description, category); + this(updates, table, null, description, category); } - Command(boolean updates, String table, String supertable, String extra, String description, CommandCategory category) + Command(boolean updates, String table, String extra, String description, CommandCategory category) { this.table = table; - this.supertable = supertable; this.updates = updates; this.category = category; List names = new ArrayList<>(); diff --git a/tools/stress/src/org/apache/cassandra/stress/settings/Option.java b/tools/stress/src/org/apache/cassandra/stress/settings/Option.java index a9e669ce45..b9e402ed95 100644 --- a/tools/stress/src/org/apache/cassandra/stress/settings/Option.java +++ b/tools/stress/src/org/apache/cassandra/stress/settings/Option.java @@ -32,6 +32,7 @@ abstract class Option abstract String longDisplay(); abstract List multiLineDisplay(); abstract boolean setByUser(); + abstract boolean present(); public int hashCode() { diff --git a/tools/stress/src/org/apache/cassandra/stress/settings/OptionAnyProbabilities.java b/tools/stress/src/org/apache/cassandra/stress/settings/OptionAnyProbabilities.java index e0a2061961..1a444a0141 100644 --- a/tools/stress/src/org/apache/cassandra/stress/settings/OptionAnyProbabilities.java +++ b/tools/stress/src/org/apache/cassandra/stress/settings/OptionAnyProbabilities.java @@ -73,6 +73,11 @@ public final class OptionAnyProbabilities extends OptionMulti { return !options.isEmpty(); } + + boolean present() + { + return setByUser(); + } } diff --git a/tools/stress/src/org/apache/cassandra/stress/settings/OptionDistribution.java b/tools/stress/src/org/apache/cassandra/stress/settings/OptionDistribution.java index b334384ced..7186efb967 100644 --- a/tools/stress/src/org/apache/cassandra/stress/settings/OptionDistribution.java +++ b/tools/stress/src/org/apache/cassandra/stress/settings/OptionDistribution.java @@ -134,6 +134,11 @@ public class OptionDistribution extends Option return spec != null; } + boolean present() + { + return setByUser() || defaultSpec != null; + } + @Override public String shortDisplay() { @@ -209,7 +214,7 @@ public class OptionDistribution extends Option stdev = ((max - min) / 2d) / stdevsToEdge; } return new GaussianFactory(min, max, mean, stdev); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params); } @@ -233,7 +238,7 @@ public class OptionDistribution extends Option // over entire range, but this results in overly skewed distribution, so take sqrt final double mean = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min))); return new ExpFactory(min, max, mean); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params); } @@ -258,7 +263,7 @@ public class OptionDistribution extends Option // over entire range, but this results in overly skewed distribution, so take sqrt final double scale = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min))); return new ExtremeFactory(min, max, shape, scale); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for extreme (Weibull) distribution: " + params); } @@ -284,7 +289,7 @@ public class OptionDistribution extends Option // over entire range, but this results in overly skewed distribution, so take sqrt final double scale = (max - min) / findBounds.inverseCumulativeProbability(1d - Math.sqrt(1d/(max-min))); return new QuantizedExtremeFactory(min, max, shape, scale, quantas); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for quantized extreme (Weibull) distribution: " + params); } @@ -305,7 +310,7 @@ public class OptionDistribution extends Option final long min = parseLong(bounds[0]); final long max = parseLong(bounds[1]); return new UniformFactory(min, max); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params); } @@ -324,7 +329,7 @@ public class OptionDistribution extends Option { final long key = parseLong(params.get(0)); return new FixedFactory(key); - } catch (Exception e) + } catch (Exception ignore) { throw new IllegalArgumentException("Invalid parameter list for uniform distribution: " + params); } diff --git a/tools/stress/src/org/apache/cassandra/stress/settings/OptionMulti.java b/tools/stress/src/org/apache/cassandra/stress/settings/OptionMulti.java index 6d11012789..ad89a5b75d 100644 --- a/tools/stress/src/org/apache/cassandra/stress/settings/OptionMulti.java +++ b/tools/stress/src/org/apache/cassandra/stress/settings/OptionMulti.java @@ -182,6 +182,11 @@ abstract class OptionMulti extends Option { return !options.isEmpty(); } + + boolean present() + { + return !options.isEmpty(); + } } List