From 61fc994d6ea31258432b2d5879b7e514c1810a0a Mon Sep 17 00:00:00 2001 From: tongbing Date: Fri, 4 Apr 2025 18:34:07 +0800 Subject: [PATCH 1/4] add automatic test mode --- .../org/graphybench/driver/driver/Db.java | 43 +- .../PoolingOperationHandlerRunnerFactory.java | 5 + .../graphybench/driver/driver/Workload.java | 61 +- .../ConsoleAndFileDriverConfiguration.java | 919 +++++++++++++----- .../driver/control/DriverConfiguration.java | 18 + .../driver/driver/control/OperationMode.java | 3 +- .../driver/driver/driver/Driver.java | 22 +- .../driver/driver/ExecuteWorkloadMode.java | 261 ++--- .../driver/driver/runtime/WorkloadRunner.java | 249 +++-- .../ResultsLogValidationResult.java | 28 + .../validation/ResultsLogValidator.java | 111 ++- ...c_finbench_automatic_test_dummy.properties | 107 ++ .../ldbc_finbench_driver_dummy.properties | 2 +- 13 files changed, 1302 insertions(+), 527 deletions(-) create mode 100644 src/main/resources/example/ldbc_finbench_automatic_test_dummy.properties diff --git a/src/main/java/org/graphybench/driver/driver/Db.java b/src/main/java/org/graphybench/driver/driver/Db.java index 218efef..56c3fa6 100644 --- a/src/main/java/org/graphybench/driver/driver/Db.java +++ b/src/main/java/org/graphybench/driver/driver/Db.java @@ -36,17 +36,17 @@ public abstract class Db implements Closeable { private OperationHandlerRunnerFactory operationHandlerRunnableContextFactory = null; public final synchronized void init( - Map params, - LoggingService loggingService, - Map> operationTypeToClassMapping) - throws DbException { + Map params, + LoggingService loggingService, + Map> operationTypeToClassMapping) + throws DbException { if (isInitialized) { throw new DbException("DB may be initialized only once"); } onInit(params, loggingService); dbConnectionState = getConnectionState(); operationHandlerRunnableContextFactory = new PoolingOperationHandlerRunnerFactory( - new InstantiatingOperationHandlerRunnerFactory() + new InstantiatingOperationHandlerRunnerFactory() ); operationHandlersArray = toOperationHandlerArray(operationTypeToClassMapping, operationHandlers); operationHandlers = null; @@ -81,7 +81,18 @@ public abstract class Db implements Closeable { throw new DbException("Error shutting down operation handler runnable factory", e); } operationHandlerRunnableContextFactory = new PoolingOperationHandlerRunnerFactory( - new InstantiatingOperationHandlerRunnerFactory() + new InstantiatingOperationHandlerRunnerFactory() + ); + } + + public final synchronized void reInitAutomatic() throws DbException { + try { + ((PoolingOperationHandlerRunnerFactory) operationHandlerRunnableContextFactory).shutdownAutomatic(); + } catch (OperationException e) { + throw new DbException("Error shutting down operation handler runnable factory", e); + } + operationHandlerRunnableContextFactory = new PoolingOperationHandlerRunnerFactory( + new InstantiatingOperationHandlerRunnerFactory() ); } @@ -91,7 +102,7 @@ public abstract class Db implements Closeable { protected abstract void onClose() throws IOException; public final > void registerOperationHandler( - Class operationType, Class operationHandlerType) throws DbException { + Class operationType, Class operationHandlerType) throws DbException { if (operationHandlers.containsKey(operationType)) { throw new DbException(format("Client already has handler registered for %s", operationType.getClass())); } @@ -100,23 +111,23 @@ public abstract class Db implements Closeable { operationHandlers.put(operationType, operationHandler); } catch (OperationException e) { throw new DbException( - format("%s could not instantiate instance of %s", - getClass().getSimpleName(), - operationHandlerType.getSimpleName() - ), - e); + format("%s could not instantiate instance of %s", + getClass().getSimpleName(), + operationHandlerType.getSimpleName() + ), + e); } } public final OperationHandlerRunnableContext getOperationHandlerRunnableContext(Operation operation) - throws DbException { + throws DbException { OperationHandler operationHandler = operationHandlersArray[operation.type()]; if (null == operationHandler) { throw new DbException(format("No handler registered for %s", operation.getClass())); } try { OperationHandlerRunnableContext operationHandlerRunnableContext = - operationHandlerRunnableContextFactory.newOperationHandlerRunner(); + operationHandlerRunnableContextFactory.newOperationHandlerRunner(); operationHandlerRunnableContext.setOperationHandler(operationHandler); operationHandlerRunnableContext.setDbConnectionState(dbConnectionState); return operationHandlerRunnableContext; @@ -126,8 +137,8 @@ public abstract class Db implements Closeable { } private static OperationHandler[] toOperationHandlerArray( - Map> operationTypeToClassMapping, - Map, OperationHandler> operationHandlers) throws DbException { + Map> operationTypeToClassMapping, + Map, OperationHandler> operationHandlers) throws DbException { if (operationTypeToClassMapping.isEmpty()) { return new OperationHandler[] {}; } else { diff --git a/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java b/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java index 9309bd9..88bedc2 100644 --- a/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java +++ b/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java @@ -131,6 +131,11 @@ public class PoolingOperationHandlerRunnerFactory implements OperationHandlerRun } } + public void shutdownAutomatic() throws OperationException { + innerOperationHandlerRunnerFactory.shutdown(); + operationHandlerRunnerPool.shutdown(); + } + @Override public String toString() { return PoolingOperationHandlerRunnerFactory.class.getSimpleName() + "{" diff --git a/src/main/java/org/graphybench/driver/driver/Workload.java b/src/main/java/org/graphybench/driver/driver/Workload.java index bc95c1a..82efa8c 100644 --- a/src/main/java/org/graphybench/driver/driver/Workload.java +++ b/src/main/java/org/graphybench/driver/driver/Workload.java @@ -44,18 +44,41 @@ public abstract class Workload implements Closeable { * @return */ public ResultsLogValidationTolerances resultsLogValidationTolerances( - DriverConfiguration configuration, - boolean warmup + DriverConfiguration configuration, + boolean warmup ) { long excessiveDelayThresholdAsMilli = TimeUnit.SECONDS.toMillis(1); - double toleratedExcessiveDelayCountPercentage = 0.05; // 95% of the queries must run below delay threshold + // Specifies the fraction of the delay threshold that is allowed to be exceeded + double toleratedExcessiveDelayCountPercentage = configuration.timeoutRate(); long toleratedExcessiveDelayCount = // Total tolerated excessive delay count - (warmup) ? Math.round(configuration.warmupCount() * toleratedExcessiveDelayCountPercentage) - : Math.round(configuration.operationCount() * toleratedExcessiveDelayCountPercentage); + (warmup) ? Math.round(configuration.warmupCount() * toleratedExcessiveDelayCountPercentage) + : Math.round(configuration.operationCount() * toleratedExcessiveDelayCountPercentage); return new ResultsLogValidationTolerances( - excessiveDelayThresholdAsMilli, - toleratedExcessiveDelayCount, - toleratedExcessiveDelayCountPercentage + excessiveDelayThresholdAsMilli, + toleratedExcessiveDelayCount, + toleratedExcessiveDelayCountPercentage + ); + } + + /** + * resultsLogValidationTolerances Automated beta version of the method + * + * @param operationCount + * @return + */ + public ResultsLogValidationTolerances resultsLogValidationTolerancesAutomatic( + DriverConfiguration configuration, + long operationCount + ) { + long excessiveDelayThresholdAsMilli = TimeUnit.SECONDS.toMillis(1); + // Specifies the fraction of the delay threshold that is allowed to be exceeded + double toleratedExcessiveDelayCountPercentage = configuration.timeoutRate(); + // Total tolerated excessive delay count + long toleratedExcessiveDelayCount = Math.round(operationCount * toleratedExcessiveDelayCountPercentage); + return new ResultsLogValidationTolerances( + excessiveDelayThresholdAsMilli, + toleratedExcessiveDelayCount, + toleratedExcessiveDelayCountPercentage ); } @@ -97,7 +120,7 @@ public abstract class Workload implements Closeable { } protected abstract WorkloadStreams getStreams(GeneratorFactory generators, boolean hasDbConnected) - throws WorkloadException; + throws WorkloadException; public DbValidationParametersFilter dbValidationParametersFilter(final Integer requiredValidationParameterCount) { return new DbValidationParametersFilter() { @@ -111,18 +134,18 @@ public abstract class Workload implements Closeable { @Override public DbValidationParametersFilterResult useOperationAndResultForValidation( - Operation operation, - Object operationResult) { + Operation operation, + Object operationResult) { if (validationParameterCount < requiredValidationParameterCount) { validationParameterCount++; return new DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance.ACCEPT_AND_CONTINUE, - injectedOperations + DbValidationParametersFilterAcceptance.ACCEPT_AND_CONTINUE, + injectedOperations ); } else { return new DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance.REJECT_AND_FINISH, - injectedOperations + DbValidationParametersFilterAcceptance.REJECT_AND_FINISH, + injectedOperations ); } } @@ -139,8 +162,8 @@ public abstract class Workload implements Closeable { boolean useOperation(Operation operation); DbValidationParametersFilterResult useOperationAndResultForValidation( - Operation operation, - Object operationResult); + Operation operation, + Object operationResult); } public enum DbValidationParametersFilterAcceptance { @@ -155,8 +178,8 @@ public abstract class Workload implements Closeable { private final List injectedOperations; public DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance acceptance, - List injectedOperations) { + DbValidationParametersFilterAcceptance acceptance, + List injectedOperations) { this.acceptance = acceptance; this.injectedOperations = injectedOperations; } diff --git a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java index c15f115..0344e7b 100644 --- a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java +++ b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java @@ -72,11 +72,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String IGNORE_SCHEDULED_START_TIMES_ARG = "ignore_scheduled_start_times"; public static final boolean IGNORE_SCHEDULED_START_TIMES_DEFAULT = false; public static final String IGNORE_SCHEDULED_START_TIMES_DEFAULT_STRING = - Boolean.toString(IGNORE_SCHEDULED_START_TIMES_DEFAULT); + Boolean.toString(IGNORE_SCHEDULED_START_TIMES_DEFAULT); public static final String RECORD_DELAYED_OPERATIONS_ARG = "log_delayed"; public static final boolean RECORD_DELAYED_OPERATIONS_DEFAULT = true; public static final String RECORD_DELAYED_OPERATIONS_DEFAULT_STRING = - Boolean.toString(RECORD_DELAYED_OPERATIONS_DEFAULT); + Boolean.toString(RECORD_DELAYED_OPERATIONS_DEFAULT); public static final String HELP_ARG = "help"; public static final boolean HELP_DEFAULT = false; public static final String HELP_DEFAULT_STRING = Boolean.toString(HELP_DEFAULT); @@ -84,7 +84,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final boolean FLUSH_LOG_DEFAULT = false; public static final String FLUSH_LOG_DEFAULT_STRING = Boolean.toString(FLUSH_LOG_DEFAULT); public static final String NAME_ARG = "nm"; - public static final String NAME_DEFAULT = ""; + public static final String NAME_DEFAULT = "LDBC"; public static final String NAME_DEFAULT_STRING = NAME_DEFAULT; public static final String RESULT_DIR_PATH_ARG = "rd"; public static final String RESULT_DIR_PATH_DEFAULT = "results"; @@ -104,7 +104,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String VALIDATION_SERIALIZATION_CHECK_ARG = "vsc"; public static final Boolean VALIDATION_SERIALIZATION_CHECK_DEFAULT = true; public static final String VALIDATION_SERIALIZATION_CHECK_DEFAULT_STRING = - Boolean.toString(VALIDATION_SERIALIZATION_CHECK_DEFAULT); + Boolean.toString(VALIDATION_SERIALIZATION_CHECK_DEFAULT); public static final String TIME_UNIT_ARG = "tu"; public static final TimeUnit TIME_UNIT_DEFAULT = TimeUnit.MILLISECONDS; public static final String TIME_UNIT_DEFAULT_STRING = TIME_UNIT_DEFAULT.toString(); @@ -120,32 +120,69 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String WARMUP_COUNT_ARG = "wu"; public static final long WARMUP_COUNT_DEFAULT = 0; public static final String WARMUP_COUNT_DEFAULT_STRING = Long.toString(WARMUP_COUNT_DEFAULT); + public static final String ESTIMATE_TEST_TIME_ARG = "ett"; + public static final long ESTIMATE_TEST_DEFAULT_TIME = 5 * 60 * 1000; + public static final String ESTIMATE_TEST_DEFAULT_TIME_STRING = Long.toString(ESTIMATE_TEST_DEFAULT_TIME); + public static final String ESTIMATE_TEST_TIME_DESCRIPTION = format( + "Quickly estimate the duration of each test in the phase (default: %s)." + + "if -1, the operation to complete the number of warmup is finished", + ESTIMATE_TEST_DEFAULT_TIME_STRING); + public static final String ACCURATE_TEST_TIME_ARG = "att"; + public static final long ACCURATE_TEST_DEFAULT_TIME = 7200 * 1000; + public static final String ACCURATE_TEST_DEFAULT_TIME_STRING = Long.toString(ACCURATE_TEST_DEFAULT_TIME); + public static final String ACCURATE_TEST_TIME_DESCRIPTION = format( + "The duration of each test in the precision tuning phase (default: %s)." + + "If -1, the operation on the number of operation_count is completed", + ACCURATE_TEST_DEFAULT_TIME_STRING); + public static final String DICHOTOMY_ERROR_RANGE_ARG = "der"; + public static final double DEFAULT_DICHOTOMY_ERROR_RANGE = 1E-5; + public static final String DEFAULT_DICHOTOMY_ERROR_RANGE_STRING = Double.toString(DEFAULT_DICHOTOMY_ERROR_RANGE); + public static final String DICHOTOMY_ERROR_RANGE_DESCRIPTION = format( + "Binary end condition, tolerance range, (default: %s)", DEFAULT_DICHOTOMY_ERROR_RANGE_STRING); + public static final String TCR_MIN_ARG = "tcrMin"; + public static final double DEFAULT_TCR_MIN = 1E-9; + public static final String DEFAULT_TCR_MIN_STRING = Double.toString(DEFAULT_TCR_MIN); + public static final String TCR_MIN_DESCRIPTION = format( + "Minimum time compression ratio limit (default: %s)", DEFAULT_TCR_MIN_STRING); + public static final String TCR_MAX_ARG = "tcrMax"; + public static final double DEFAULT_TCR_MAX = 1; + public static final String DEFAULT_TCR_MAX_STRING = Double.toString(DEFAULT_TCR_MAX); + public static final String TCR_MAX_DESCRIPTION = format( + "Maximum time compression ratio limit (default: %s)", DEFAULT_TCR_MAX_STRING); + public static final String TIMEOUT_RATE_ARG = "timeoutRate"; + public static final double DEFAULT_TIMEOUT_RATE = 0.05; // 95% of the queries must run below delay threshold + public static final String DEFAULT_TIMEOUT_RATE_STRING = Double.toString(DEFAULT_TIMEOUT_RATE); + public static final String TIMEOUT_RATE_DESCRIPTION = format( + "Specifies the fraction of the delay threshold that is allowed to be exceeded (default: %s)", + DEFAULT_TIMEOUT_RATE_STRING); + + public static final String PROPERTY_FILE_ARG = "P"; public static final String PROPERTY_ARG = "p"; private static final String THREADS_DESCRIPTION = - format("number of worker threads to execute with (default: %s)", THREADS_DEFAULT_STRING); - private static final String SKIP_COUNT_DESCRIPTION = - format("number of operations to skip over before beginning execution (default: %s)", SKIP_COUNT_DEFAULT_STRING); + format("number of worker threads to execute with (default: %s)", THREADS_DEFAULT_STRING); + private static final String SKIP_COUNT_DESCRIPTION = format( + "number of operations to skip over before beginning execution (default: %s)", SKIP_COUNT_DEFAULT_STRING); private static final String WARMUP_COUNT_DESCRIPTION = - format("number of operations to execute during warmup phase (default: %s)", WARMUP_COUNT_DEFAULT_STRING); + format("number of operations to execute during warmup phase (default: %s)", WARMUP_COUNT_DEFAULT_STRING); private static final TemporalUtil TEMPORAL_UTIL = new TemporalUtil(); private static final DecimalFormat INTEGRAL_FORMAT = new DecimalFormat("###,###,###,###,###"); private static final DecimalFormat FLOAT_FORMAT = new DecimalFormat("###,###,###,###,##0.0000000"); private static final String MODE_ARG_LONG = "mode"; private static final String MODE_DESCRIPTION = - "mode the driver should execute (e.g. CREATE_VALIDATION, VALIDATE_DATABASE, CREATE_STATISTICS, " - + "EXECUTE_BENCHMARK)"; + "mode the driver should execute (e.g. CREATE_VALIDATION, VALIDATE_DATABASE, CREATE_STATISTICS, " + + "EXECUTE_BENCHMARK)"; private static final String OPERATION_COUNT_ARG_LONG = "operation_count"; private static final String OPERATION_COUNT_DESCRIPTION = "number of operations to execute"; private static final String WORKLOAD_ARG_LONG = "workload"; private static final String WORKLOAD_EXAMPLE = SimpleWorkload.class.getName(); private static final String WORKLOAD_DESCRIPTION = - format("class name of the Workload to use (e.g. %s)", WORKLOAD_EXAMPLE); + format("class name of the Workload to use (e.g. %s)", WORKLOAD_EXAMPLE); private static final String DB_ARG_LONG = "database"; private static final String DB_EXAMPLE = SimpleDb.class.getName(); private static final String DB_DESCRIPTION = format("class name of the DB to use (e.g. %s)", DB_EXAMPLE); private static final String IGNORE_SCHEDULED_START_TIMES_DESCRIPTION = - "executes operations as fast as possible, ignoring their scheduled start times"; + "executes operations as fast as possible, ignoring their scheduled start times"; private static final String RECORD_DELAYED_OPERATIONS_DESCRIPTION = "print usage instruction"; private static final String HELP_DESCRIPTION = "print usage instruction"; private static final String FLUSH_LOG_DESCRIPTION = "flush log to disk after each operation"; @@ -153,38 +190,44 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { private static final String NAME_DESCRIPTION = format("name of the benchmark run. default = %s", NAME_DEFAULT); private static final String RESULT_DIR_PATH_ARG_LONG = "results_dir"; private static final String RESULT_DIR_PATH_DESCRIPTION = - format("directory where benchmark results will be written. default = %s", RESULT_DIR_PATH_DEFAULT); + format("directory where benchmark results will be written. default = %s", RESULT_DIR_PATH_DEFAULT); private static final String THREADS_ARG_LONG = "thread_count"; private static final String SHOW_STATUS_ARG_LONG = "status"; private static final String SHOW_STATUS_DESCRIPTION = - "interval between status printouts during benchmark execution (0 = disable)"; + "interval between status printouts during benchmark execution (0 = disable)"; private static final String DB_VALIDATION_FILE_PATH_ARG_LONG = "validate_database"; private static final String DB_VALIDATION_FILE_PATH_DESCRIPTION = - "path to validation parameters file, if provided database connector will be validated"; + "path to validation parameters file, if provided database connector will be validated"; private static final String VALIDATION_PARAMS_SIZE_ARG_LONG = "validation_parameters_size"; private static final String VALIDATION_PARAMS_SIZE_DESCRIPTION = "The size of validation set to create."; private static final String VALIDATION_SERIALIZATION_CHECK_ARG_LONG = "validation_parameters_serialization_check"; private static final String VALIDATION_SERIALIZATION_CHECK_DESCRIPTION = - "Check serialized queries and results by deserializing them and compare."; + "Check serialized queries and results by deserializing them and compare."; private static final String TIME_UNIT_ARG_LONG = "time_unit"; private static final TimeUnit[] VALID_TIME_UNITS = - new TimeUnit[] {TimeUnit.NANOSECONDS, TimeUnit.MICROSECONDS, TimeUnit.MILLISECONDS, TimeUnit.SECONDS, - TimeUnit.MINUTES}; + new TimeUnit[]{TimeUnit.NANOSECONDS, TimeUnit.MICROSECONDS, TimeUnit.MILLISECONDS, TimeUnit.SECONDS, + TimeUnit.MINUTES}; private static final String TIME_UNIT_DESCRIPTION = - format("time unit to use when gathering metrics. default:%s, valid:%s", TIME_UNIT_DEFAULT_STRING, - Arrays.toString(VALID_TIME_UNITS)); + format("time unit to use when gathering metrics. default:%s, valid:%s", TIME_UNIT_DEFAULT_STRING, + Arrays.toString(VALID_TIME_UNITS)); private static final String TIME_COMPRESSION_RATIO_ARG_LONG = "time_compression_ratio"; private static final String TIME_COMPRESSION_RATIO_DESCRIPTION = "change duration between operations of workload"; private static final String SPINNER_SLEEP_DURATION_ARG_LONG = "spinner_wait_duration"; private static final String SPINNER_SLEEP_DURATION_DESCRIPTION = - "sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)"; + "sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)"; private static final String SKIP_COUNT_ARG_LONG = "skip"; private static final String WARMUP_COUNT_ARG_LONG = "warmup"; + public static final String ESTIMATE_TEST_TIME_ARG_LONG = "estimate"; + public static final String ACCURATE_TEST_TIME_ARG_LONG = "accurate"; + public static final String DICHOTOMY_ERROR_RANGE_ARG_LONG = "error_range"; + public static final String TCR_MIN_ARG_LONG = "tcr_min"; + public static final String TCR_MAX_ARG_LONG = "tcr_max"; + public static final String TIMEOUT_RATE_ARG_LONG = "timeout_rate"; private static final String PROPERTY_FILE_DESCRIPTION = - "load properties from file(s) - files will be loaded in the order provided\n" - + "first files are highest priority; later values will not override earlier values"; + "load properties from file(s) - files will be loaded in the order provided\n" + + "first files are highest priority; later values will not override earlier values"; private static final String PROPERTY_DESCRIPTION = - "properties to be passed to DB and Workload - these will override properties loaded from files"; + "properties to be passed to DB and Workload - these will override properties loaded from files"; private static final char COMMANDLINE_SEPARATOR_CHAR = '|'; private static final Options OPTIONS = buildOptions(); private final Map paramsMap; @@ -192,12 +235,12 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { private final String name; private final String dbClassName; private final String workloadClassName; - private final long operationCount; + private long operationCount; private final int threadCount; private final int statusDisplayIntervalAsSeconds; private final TimeUnit timeUnit; private final String resultDirPath; - private final double timeCompressionRatio; + private double timeCompressionRatio; private final int validationParametersSize; private final boolean validationSerializationCheck; private final boolean recordDelayedOperations; @@ -205,19 +248,43 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { private final long spinnerSleepDurationAsMilli; private final boolean printHelp; private final boolean ignoreScheduledStartTimes; - private final long warmupCount; + private long warmupCount; private final long skipCount; private final boolean flushLog; - - public ConsoleAndFileDriverConfiguration(Map paramsMap, String mode, String name, - String dbClassName, String workloadClassName, long operationCount, - int threadCount, int statusDisplayIntervalAsSeconds, TimeUnit timeUnit, - String resultDirPath, double timeCompressionRatio, - int validationParametersSize, boolean validationSerializationCheck, - boolean recordDelayedOperations, String databaseValidationFilePath, - long spinnerSleepDurationAsMilli, boolean printHelp, - boolean ignoreScheduledStartTimes, long warmupCount, long skipCount, - boolean flushLog) { + private final long estimateTestTime; + private final long accurateTestTime; + private final double dichotomyErrorRange; + private final double tcrMin; + private final double tcrMax; + private final double timeoutRate; + + public ConsoleAndFileDriverConfiguration(Map paramsMap, + String mode, + String name, + String dbClassName, + String workloadClassName, + long operationCount, + int threadCount, + int statusDisplayIntervalAsSeconds, + TimeUnit timeUnit, + String resultDirPath, + double timeCompressionRatio, + int validationParametersSize, + boolean validationSerializationCheck, + boolean recordDelayedOperations, + String databaseValidationFilePath, + long spinnerSleepDurationAsMilli, + boolean printHelp, + boolean ignoreScheduledStartTimes, + long warmupCount, + long skipCount, + boolean flushLog, + long estimateTestTime, + long accurateTestTime, + double dichotomyErrorRange, + double tcrMin, + double tcrMax, + double timeoutRate) { if (null == paramsMap) { paramsMap = new HashMap<>(); } @@ -242,7 +309,12 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { this.warmupCount = warmupCount; this.skipCount = skipCount; this.flushLog = flushLog; - + this.estimateTestTime = estimateTestTime; + this.accurateTestTime = accurateTestTime; + this.dichotomyErrorRange = dichotomyErrorRange; + this.tcrMin = tcrMin; + this.tcrMax = tcrMax; + this.timeoutRate = timeoutRate; if (null != mode) { paramsMap.put(MODE_ARG, mode); } @@ -272,6 +344,12 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { paramsMap.put(WARMUP_COUNT_ARG, Long.toString(warmupCount)); paramsMap.put(SKIP_COUNT_ARG, Long.toString(skipCount)); paramsMap.put(FLUSH_LOG_ARG, Boolean.toString(flushLog)); + paramsMap.put(ESTIMATE_TEST_TIME_ARG, Long.toString(estimateTestTime)); + paramsMap.put(ACCURATE_TEST_TIME_ARG, Long.toString(accurateTestTime)); + paramsMap.put(DICHOTOMY_ERROR_RANGE_ARG, Double.toString(dichotomyErrorRange)); + paramsMap.put(TCR_MIN_ARG, Double.toString(tcrMin)); + paramsMap.put(TCR_MAX_ARG, Double.toString(tcrMax)); + paramsMap.put(TIMEOUT_RATE_ARG, Double.toString(timeoutRate)); // Validation specific if (null != databaseValidationFilePath) { paramsMap.put(DB_VALIDATION_FILE_PATH_ARG, databaseValidationFilePath); @@ -304,6 +382,12 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { defaultParamsMap.put(SPINNER_SLEEP_DURATION_ARG, SPINNER_SLEEP_DURATION_DEFAULT_STRING); defaultParamsMap.put(WARMUP_COUNT_ARG, WARMUP_COUNT_DEFAULT_STRING); defaultParamsMap.put(SKIP_COUNT_ARG, SKIP_COUNT_DEFAULT_STRING); + defaultParamsMap.put(ESTIMATE_TEST_TIME_ARG, ESTIMATE_TEST_DEFAULT_TIME_STRING); + defaultParamsMap.put(ACCURATE_TEST_TIME_ARG, ACCURATE_TEST_DEFAULT_TIME_STRING); + defaultParamsMap.put(DICHOTOMY_ERROR_RANGE_ARG, DEFAULT_DICHOTOMY_ERROR_RANGE_STRING); + defaultParamsMap.put(TCR_MIN_ARG, DEFAULT_TCR_MIN_STRING); + defaultParamsMap.put(TCR_MAX_ARG, DEFAULT_TCR_MAX_STRING); + defaultParamsMap.put(TIMEOUT_RATE_ARG, DEFAULT_TIMEOUT_RATE_STRING); return defaultParamsMap; } @@ -347,9 +431,10 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { return missingParams; } - public static ConsoleAndFileDriverConfiguration fromDefaults(String databaseClassName, String workloadClassName, + public static ConsoleAndFileDriverConfiguration fromDefaults(String databaseClassName, + String workloadClassName, long operationCount) - throws DriverConfigurationException { + throws DriverConfigurationException { try { Map paramsMap = defaultsAsMap(); paramsMap.put(DB_ARG, databaseClassName); @@ -362,7 +447,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } public static ConsoleAndFileDriverConfiguration fromParamsMap(Map paramsMap) - throws DriverConfigurationException { + throws DriverConfigurationException { try { paramsMap = convertComplexKeysToSimpleKeys(paramsMap); @@ -383,20 +468,28 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { double timeCompressionRatio = Double.parseDouble(paramsMap.get(TIME_COMPRESSION_RATIO_ARG)); int validationParametersSize = Integer.parseInt(paramsMap.get(VALIDATION_PARAMS_SIZE_ARG)); boolean validationSerializationCheck = - Boolean.parseBoolean(paramsMap.get(VALIDATION_SERIALIZATION_CHECK_ARG)); + Boolean.parseBoolean(paramsMap.get(VALIDATION_SERIALIZATION_CHECK_ARG)); String databaseValidationFilePath = paramsMap.get(DB_VALIDATION_FILE_PATH_ARG); long spinnerSleepDurationAsMilli = Long.parseLong(paramsMap.get(SPINNER_SLEEP_DURATION_ARG)); long skipCount = Long.parseLong(paramsMap.get(SKIP_COUNT_ARG)); long warmupCount = Long.parseLong(paramsMap.get(WARMUP_COUNT_ARG)); boolean printHelp = Boolean.parseBoolean(paramsMap.get(HELP_ARG)); + boolean recordDelayedOperations = Boolean.parseBoolean(paramsMap.get(RECORD_DELAYED_OPERATIONS_ARG)); boolean ignoreScheduledStartTimes = Boolean.parseBoolean(paramsMap.get(IGNORE_SCHEDULED_START_TIMES_ARG)); + long estimateTestTime = Long.parseLong(paramsMap.get(ESTIMATE_TEST_TIME_ARG)); + long accurateTestTime = Long.parseLong(paramsMap.get(ACCURATE_TEST_TIME_ARG)); + double dichotomyErrorRange = Double.parseDouble(paramsMap.get(DICHOTOMY_ERROR_RANGE_ARG)); + double tcrMin = Double.parseDouble(paramsMap.get(TCR_MIN_ARG)); + double tcrMax = Double.parseDouble(paramsMap.get(TCR_MAX_ARG)); + double timeoutRate = Double.parseDouble(paramsMap.get(TIMEOUT_RATE_ARG)); boolean flushLog = Boolean.parseBoolean(paramsMap.get(FLUSH_LOG_ARG)); return new ConsoleAndFileDriverConfiguration(paramsMap, mode, name, dbClassName, workloadClassName, - operationCount, threadCount, statusDisplayIntervalAsSeconds, timeUnit, resultDirPath, - timeCompressionRatio, validationParametersSize, validationSerializationCheck, recordDelayedOperations, - databaseValidationFilePath, spinnerSleepDurationAsMilli, printHelp, ignoreScheduledStartTimes, - warmupCount, skipCount, flushLog); + operationCount, threadCount, statusDisplayIntervalAsSeconds, timeUnit, resultDirPath, + timeCompressionRatio, validationParametersSize, validationSerializationCheck, + recordDelayedOperations, databaseValidationFilePath, spinnerSleepDurationAsMilli, + printHelp, ignoreScheduledStartTimes, warmupCount, skipCount, flushLog, estimateTestTime, + accurateTestTime, dichotomyErrorRange, tcrMin, tcrMax, timeoutRate); } catch (DriverConfigurationException e) { throw new DriverConfigurationException(format("%s\n%s", e.getMessage(), commandlineHelpString()), e); } @@ -415,11 +508,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } } - private static Map parseArgs(String[] args, Options options) - throws ParseException, DriverConfigurationException { + private static Map parseArgs(String[] args, + Options options) + throws ParseException, DriverConfigurationException { Map cmdParams = new HashMap<>(); Map fileParams = new HashMap<>(); - CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(options, args); @@ -512,23 +605,23 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { Map tempFileParams = MapUtils.propertiesToMap(tempFileProperties); boolean overwrite = true; fileParams = - MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(tempFileParams), fileParams, overwrite); + MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(tempFileParams), fileParams, overwrite); } catch (IOException e) { throw new ParseException( - format("Error loading properties file %s\n%s", propertyFilePath, e.getMessage())); + format("Error loading properties file %s\n%s", propertyFilePath, e.getMessage())); } } } if (cmd.hasOption(PROPERTY_ARG)) { - for (Entry cmdProperty : cmd.getOptionProperties(PROPERTY_ARG).entrySet()) { + for (Entry cmdProperty : cmd.getOptionProperties(PROPERTY_ARG) + .entrySet()) { cmdParams.put((String) cmdProperty.getKey(), (String) cmdProperty.getValue()); } } - boolean overwrite = true; return MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(fileParams), convertComplexKeysToSimpleKeys(cmdParams), - overwrite); + overwrite); } public static Map convertComplexKeysToSimpleKeys(Map paramsMap) { @@ -548,12 +641,20 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { paramsMap = replaceKey(paramsMap, SPINNER_SLEEP_DURATION_ARG_LONG, SPINNER_SLEEP_DURATION_ARG); paramsMap = replaceKey(paramsMap, WARMUP_COUNT_ARG_LONG, WARMUP_COUNT_ARG); paramsMap = replaceKey(paramsMap, SKIP_COUNT_ARG_LONG, SKIP_COUNT_ARG); + paramsMap = replaceKey(paramsMap, ESTIMATE_TEST_TIME_ARG_LONG, ESTIMATE_TEST_TIME_ARG); + paramsMap = replaceKey(paramsMap, ACCURATE_TEST_TIME_ARG_LONG, ACCURATE_TEST_TIME_ARG); + paramsMap = replaceKey(paramsMap, DICHOTOMY_ERROR_RANGE_ARG_LONG, DICHOTOMY_ERROR_RANGE_ARG); + paramsMap = replaceKey(paramsMap, TCR_MIN_ARG_LONG, TCR_MIN_ARG); + paramsMap = replaceKey(paramsMap, TCR_MAX_ARG_LONG, TCR_MAX_ARG); + paramsMap = replaceKey(paramsMap, TIMEOUT_RATE_ARG_LONG, TIMEOUT_RATE_ARG); return paramsMap; } // NOTE: not safe in general case, no check for duplicate keys, i.e., if newKey already exists its value will be // overwritten - private static Map replaceKey(Map paramsMap, String oldKey, String newKey) { + private static Map replaceKey(Map paramsMap, + String oldKey, + String newKey) { if (!paramsMap.containsKey(oldKey)) { return paramsMap; } @@ -570,105 +671,200 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { * Required */ Option modeOption = - OptionBuilder.hasArgs(1).withArgName("mode").withDescription(MODE_DESCRIPTION).withLongOpt(MODE_ARG_LONG) - .create(MODE_ARG); + OptionBuilder.hasArgs(1) + .withArgName("mode") + .withDescription(MODE_DESCRIPTION) + .withLongOpt(MODE_ARG_LONG) + .create(MODE_ARG); options.addOption(modeOption); Option dbOption = - OptionBuilder.hasArgs(1).withArgName("classname").withDescription(DB_DESCRIPTION).withLongOpt(DB_ARG_LONG) - .create(DB_ARG); + OptionBuilder.hasArgs(1) + .withArgName("classname") + .withDescription(DB_DESCRIPTION) + .withLongOpt(DB_ARG_LONG) + .create(DB_ARG); options.addOption(dbOption); - Option workloadOption = OptionBuilder.hasArgs(1).withArgName("classname").withDescription(WORKLOAD_DESCRIPTION) - .withLongOpt(WORKLOAD_ARG_LONG).create(WORKLOAD_ARG); + Option workloadOption = OptionBuilder.hasArgs(1) + .withArgName("classname") + .withDescription(WORKLOAD_DESCRIPTION) + .withLongOpt(WORKLOAD_ARG_LONG) + .create(WORKLOAD_ARG); options.addOption(workloadOption); Option operationCountOption = - OptionBuilder.hasArgs(1).withArgName("count").withDescription(OPERATION_COUNT_DESCRIPTION) - .withLongOpt(OPERATION_COUNT_ARG_LONG).create(OPERATION_COUNT_ARG); + OptionBuilder.hasArgs(1) + .withArgName("count") + .withDescription(OPERATION_COUNT_DESCRIPTION) + .withLongOpt(OPERATION_COUNT_ARG_LONG) + .create(OPERATION_COUNT_ARG); options.addOption(operationCountOption); /* * Optional */ Option nameOption = - OptionBuilder.hasArgs(1).withArgName("name").withDescription(NAME_DESCRIPTION).withLongOpt(NAME_ARG_LONG) - .create(NAME_ARG); + OptionBuilder.hasArgs(1) + .withArgName("name") + .withDescription(NAME_DESCRIPTION) + .withLongOpt(NAME_ARG_LONG) + .create(NAME_ARG); options.addOption(nameOption); Option resultFileOption = - OptionBuilder.hasArgs(1).withArgName("path").withDescription(RESULT_DIR_PATH_DESCRIPTION) - .withLongOpt(RESULT_DIR_PATH_ARG_LONG).create(RESULT_DIR_PATH_ARG); + OptionBuilder.hasArgs(1) + .withArgName("path") + .withDescription(RESULT_DIR_PATH_DESCRIPTION) + .withLongOpt(RESULT_DIR_PATH_ARG_LONG) + .create(RESULT_DIR_PATH_ARG); options.addOption(resultFileOption); - Option threadsOption = OptionBuilder.hasArgs(1).withArgName("count").withDescription(THREADS_DESCRIPTION) - .withLongOpt(THREADS_ARG_LONG).create(THREADS_ARG); + Option threadsOption = OptionBuilder.hasArgs(1) + .withArgName("count") + .withDescription(THREADS_DESCRIPTION) + .withLongOpt(THREADS_ARG_LONG) + .create(THREADS_ARG); options.addOption(threadsOption); - Option statusOption = OptionBuilder.hasArgs(1).withArgName("seconds").withDescription(SHOW_STATUS_DESCRIPTION) - .withLongOpt(SHOW_STATUS_ARG_LONG).create(SHOW_STATUS_ARG); + Option statusOption = OptionBuilder.hasArgs(1) + .withArgName("seconds") + .withDescription(SHOW_STATUS_DESCRIPTION) + .withLongOpt(SHOW_STATUS_ARG_LONG) + .create(SHOW_STATUS_ARG); options.addOption(statusOption); - Option timeUnitOption = OptionBuilder.hasArgs(1).withArgName("unit").withDescription(TIME_UNIT_DESCRIPTION) - .withLongOpt(TIME_UNIT_ARG_LONG).create(TIME_UNIT_ARG); + Option timeUnitOption = OptionBuilder.hasArgs(1) + .withArgName("unit") + .withDescription(TIME_UNIT_DESCRIPTION) + .withLongOpt(TIME_UNIT_ARG_LONG) + .create(TIME_UNIT_ARG); options.addOption(timeUnitOption); Option timeCompressionRatioOption = - OptionBuilder.hasArgs(1).withArgName("ratio").withDescription(TIME_COMPRESSION_RATIO_DESCRIPTION) - .withLongOpt(TIME_COMPRESSION_RATIO_ARG_LONG).create(TIME_COMPRESSION_RATIO_ARG); + OptionBuilder.hasArgs(1) + .withArgName("ratio") + .withDescription(TIME_COMPRESSION_RATIO_DESCRIPTION) + .withLongOpt(TIME_COMPRESSION_RATIO_ARG_LONG) + .create(TIME_COMPRESSION_RATIO_ARG); options.addOption(timeCompressionRatioOption); Option validationSerializationOption = OptionBuilder.withDescription(VALIDATION_SERIALIZATION_CHECK_DESCRIPTION) - .withLongOpt(VALIDATION_SERIALIZATION_CHECK_ARG_LONG).create(VALIDATION_SERIALIZATION_CHECK_ARG); + .withLongOpt(VALIDATION_SERIALIZATION_CHECK_ARG_LONG) + .create(VALIDATION_SERIALIZATION_CHECK_ARG); options.addOption(validationSerializationOption); Option validationParamsSizeOption = - OptionBuilder.hasArgs(1).withArgName("count").withDescription(VALIDATION_PARAMS_SIZE_DESCRIPTION) - .withLongOpt(VALIDATION_PARAMS_SIZE_ARG_LONG).create(VALIDATION_PARAMS_SIZE_ARG); + OptionBuilder.hasArgs(1) + .withArgName("count") + .withDescription(VALIDATION_PARAMS_SIZE_DESCRIPTION) + .withLongOpt(VALIDATION_PARAMS_SIZE_ARG_LONG) + .create(VALIDATION_PARAMS_SIZE_ARG); options.addOption(validationParamsSizeOption); Option databaseValidationFilePathOption = - OptionBuilder.hasArgs(1).withArgName("path").withDescription(DB_VALIDATION_FILE_PATH_DESCRIPTION) - .withLongOpt(DB_VALIDATION_FILE_PATH_ARG_LONG).create(DB_VALIDATION_FILE_PATH_ARG); + OptionBuilder.hasArgs(1) + .withArgName("path") + .withDescription(DB_VALIDATION_FILE_PATH_DESCRIPTION) + .withLongOpt(DB_VALIDATION_FILE_PATH_ARG_LONG) + .create(DB_VALIDATION_FILE_PATH_ARG); options.addOption(databaseValidationFilePathOption); Option recordDelayedOperations = - OptionBuilder.withDescription(RECORD_DELAYED_OPERATIONS_DESCRIPTION).create(RECORD_DELAYED_OPERATIONS_ARG); + OptionBuilder.withDescription(RECORD_DELAYED_OPERATIONS_DESCRIPTION) + .create(RECORD_DELAYED_OPERATIONS_ARG); options.addOption(recordDelayedOperations); Option spinnerSleepDurationOption = - OptionBuilder.hasArgs(1).withArgName("duration").withDescription(SPINNER_SLEEP_DURATION_DESCRIPTION) - .withLongOpt(SPINNER_SLEEP_DURATION_ARG_LONG).create(SPINNER_SLEEP_DURATION_ARG); + OptionBuilder.hasArgs(1) + .withArgName("duration") + .withDescription(SPINNER_SLEEP_DURATION_DESCRIPTION) + .withLongOpt(SPINNER_SLEEP_DURATION_ARG_LONG) + .create(SPINNER_SLEEP_DURATION_ARG); options.addOption(spinnerSleepDurationOption); Option warmupCountOption = - OptionBuilder.hasArgs(1).withArgName("count").withDescription(WARMUP_COUNT_DESCRIPTION) - .withLongOpt(WARMUP_COUNT_ARG_LONG).create(WARMUP_COUNT_ARG); + OptionBuilder.hasArgs(1) + .withArgName("count") + .withDescription(WARMUP_COUNT_DESCRIPTION) + .withLongOpt(WARMUP_COUNT_ARG_LONG) + .create(WARMUP_COUNT_ARG); options.addOption(warmupCountOption); - Option skipCountOption = OptionBuilder.hasArgs(1).withArgName("count").withDescription(SKIP_COUNT_DESCRIPTION) - .withLongOpt(SKIP_COUNT_ARG_LONG).create(SKIP_COUNT_ARG); + Option skipCountOption = OptionBuilder.hasArgs(1) + .withArgName("count") + .withDescription(SKIP_COUNT_DESCRIPTION) + .withLongOpt(SKIP_COUNT_ARG_LONG) + .create(SKIP_COUNT_ARG); options.addOption(skipCountOption); - Option printHelpOption = OptionBuilder.withDescription(HELP_DESCRIPTION).create(HELP_ARG); + Option estimateTestTimeOption = OptionBuilder.hasArgs(1) + .withArgName("milli") + .withDescription(ESTIMATE_TEST_TIME_DESCRIPTION) + .withLongOpt(ESTIMATE_TEST_TIME_ARG_LONG) + .create(ESTIMATE_TEST_TIME_ARG); + options.addOption(estimateTestTimeOption); + + Option accurateTestTimeOption = OptionBuilder.hasArgs(1) + .withArgName("milli") + .withDescription(ACCURATE_TEST_TIME_DESCRIPTION) + .withLongOpt(ACCURATE_TEST_TIME_ARG_LONG) + .create(ACCURATE_TEST_TIME_ARG); + options.addOption(accurateTestTimeOption); + + Option dichotomyErrorRangeOption = OptionBuilder.hasArgs(1) + .withArgName("error_range") + .withDescription(DICHOTOMY_ERROR_RANGE_DESCRIPTION) + .withLongOpt(DICHOTOMY_ERROR_RANGE_ARG_LONG) + .create(DICHOTOMY_ERROR_RANGE_ARG); + options.addOption(dichotomyErrorRangeOption); + + Option tcrMinOption = OptionBuilder.hasArgs(1) + .withArgName("min") + .withDescription(TCR_MIN_DESCRIPTION) + .withLongOpt(TCR_MIN_ARG_LONG) + .create(TCR_MIN_ARG); + options.addOption(tcrMinOption); + + Option tcrMaxOption = OptionBuilder.hasArgs(1) + .withArgName("max") + .withDescription(TCR_MAX_DESCRIPTION) + .withLongOpt(TCR_MAX_ARG_LONG) + .create(TCR_MAX_ARG); + options.addOption(tcrMaxOption); + + Option timeoutRateOption = OptionBuilder.hasArgs(1) + .withArgName("timeout") + .withDescription(TIMEOUT_RATE_DESCRIPTION) + .withLongOpt(TIMEOUT_RATE_ARG_LONG) + .create(TIMEOUT_RATE_ARG); + options.addOption(timeoutRateOption); + + Option printHelpOption = OptionBuilder.withDescription(HELP_DESCRIPTION) + .create(HELP_ARG); options.addOption(printHelpOption); - Option flushOption = OptionBuilder.withDescription(FLUSH_LOG_DESCRIPTION).create(FLUSH_LOG_ARG); + Option flushOption = OptionBuilder.withDescription(FLUSH_LOG_DESCRIPTION) + .create(FLUSH_LOG_ARG); options.addOption(flushOption); Option ignoreScheduledStartTimesOption = OptionBuilder.withDescription(IGNORE_SCHEDULED_START_TIMES_DESCRIPTION) - .create(IGNORE_SCHEDULED_START_TIMES_ARG); + .create(IGNORE_SCHEDULED_START_TIMES_ARG); options.addOption(ignoreScheduledStartTimesOption); - Option propertyFileOption = OptionBuilder.hasArgs().withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) - .withArgName("file1" + COMMANDLINE_SEPARATOR_CHAR + "file2").withDescription(PROPERTY_FILE_DESCRIPTION) - .create(PROPERTY_FILE_ARG); + Option propertyFileOption = OptionBuilder.hasArgs() + .withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) + .withArgName("file1" + COMMANDLINE_SEPARATOR_CHAR + "file2") + .withDescription(PROPERTY_FILE_DESCRIPTION) + .create(PROPERTY_FILE_ARG); options.addOption(propertyFileOption); - Option propertyOption = OptionBuilder.hasArgs(2).withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) - .withArgName("key" + COMMANDLINE_SEPARATOR_CHAR + "value").withDescription(PROPERTY_DESCRIPTION) - .create(PROPERTY_ARG); + Option propertyOption = OptionBuilder.hasArgs(2) + .withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) + .withArgName("key" + COMMANDLINE_SEPARATOR_CHAR + "value") + .withDescription(PROPERTY_DESCRIPTION) + .create(PROPERTY_ARG); options.addOption(propertyOption); return options; @@ -681,9 +877,10 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { */ private static Set coreConfigurationParameterKeys() { return Sets.newHashSet(MODE_ARG, NAME_ARG, DB_ARG, WORKLOAD_ARG, OPERATION_COUNT_ARG, THREADS_ARG, - SHOW_STATUS_ARG, TIME_UNIT_ARG, RESULT_DIR_PATH_ARG, TIME_COMPRESSION_RATIO_ARG, VALIDATION_PARAMS_SIZE_ARG, - VALIDATION_SERIALIZATION_CHECK_ARG, DB_VALIDATION_FILE_PATH_ARG, SPINNER_SLEEP_DURATION_ARG, HELP_ARG, - IGNORE_SCHEDULED_START_TIMES_ARG, WARMUP_COUNT_ARG, SKIP_COUNT_ARG); + SHOW_STATUS_ARG, TIME_UNIT_ARG, RESULT_DIR_PATH_ARG, TIME_COMPRESSION_RATIO_ARG, + VALIDATION_PARAMS_SIZE_ARG, + VALIDATION_SERIALIZATION_CHECK_ARG, DB_VALIDATION_FILE_PATH_ARG, SPINNER_SLEEP_DURATION_ARG, HELP_ARG, + IGNORE_SCHEDULED_START_TIMES_ARG, WARMUP_COUNT_ARG, SKIP_COUNT_ARG); } /** @@ -704,7 +901,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { PrintWriter writer = new PrintWriter(os); HelpFormatter helpFormatter = new HelpFormatter(); helpFormatter.printHelp(writer, printedRowWidth, commandLineSyntax, header, options, spacesBeforeOption, - spacesBeforeOptionDescription, footer, displayUsage); + spacesBeforeOptionDescription, footer, displayUsage); writer.flush(); writer.close(); return os.toString(); @@ -764,6 +961,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { return timeCompressionRatio; } + @Override + public void setTimeCompressionRatio(double tcr) { + this.timeCompressionRatio = tcr; + } + @Override public boolean validationSerializationCheck() { return validationSerializationCheck; @@ -809,6 +1011,16 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { return warmupCount; } + @Override + public void setWarmupCount(long warmupCount) { + this.warmupCount = warmupCount; + } + + @Override + public void setOperationCount(long operationCount) { + this.operationCount = operationCount; + } + @Override public long skipCount() { return skipCount; @@ -819,6 +1031,36 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { return flushLog; } + @Override + public long estimateTestTime() { + return estimateTestTime; + } + + @Override + public long accurateTestTime() { + return accurateTestTime; + } + + @Override + public double dichotomyErrorRange() { + return dichotomyErrorRange; + } + + @Override + public double tcrMin() { + return tcrMin; + } + + @Override + public double tcrMax() { + return tcrMax; + } + + @Override + public double timeoutRate() { + return timeoutRate; + } + @Override public Map asMap() { return paramsMap; @@ -848,66 +1090,84 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { Map newOtherParams = MapUtils.mergeMaps(this.paramsMap, newParamsMapWithSimpleKeys, true); String newMode = - (newParamsMapWithSimpleKeys.containsKey(MODE_ARG)) ? newParamsMapWithSimpleKeys.get(MODE_ARG) : mode; + (newParamsMapWithSimpleKeys.containsKey(MODE_ARG)) ? newParamsMapWithSimpleKeys.get(MODE_ARG) : mode; String newName = - (newParamsMapWithSimpleKeys.containsKey(NAME_ARG)) ? newParamsMapWithSimpleKeys.get(NAME_ARG) : name; + (newParamsMapWithSimpleKeys.containsKey(NAME_ARG)) ? newParamsMapWithSimpleKeys.get(NAME_ARG) : name; String newDbClassName = - (newParamsMapWithSimpleKeys.containsKey(DB_ARG)) ? newParamsMapWithSimpleKeys.get(DB_ARG) : dbClassName; + (newParamsMapWithSimpleKeys.containsKey(DB_ARG)) ? newParamsMapWithSimpleKeys.get(DB_ARG) : dbClassName; String newWorkloadClassName = - (newParamsMapWithSimpleKeys.containsKey(WORKLOAD_ARG)) ? newParamsMapWithSimpleKeys.get(WORKLOAD_ARG) - : workloadClassName; + (newParamsMapWithSimpleKeys.containsKey(WORKLOAD_ARG)) ? newParamsMapWithSimpleKeys.get(WORKLOAD_ARG) + : workloadClassName; long newOperationCount = (newParamsMapWithSimpleKeys.containsKey(OPERATION_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(OPERATION_COUNT_ARG)) : operationCount; + newParamsMapWithSimpleKeys.get(OPERATION_COUNT_ARG)) : operationCount; int newThreadCount = (newParamsMapWithSimpleKeys.containsKey(THREADS_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(THREADS_ARG)) : threadCount; + newParamsMapWithSimpleKeys.get(THREADS_ARG)) : threadCount; int newStatusDisplayIntervalAsSeconds = - (newParamsMapWithSimpleKeys.containsKey(SHOW_STATUS_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(SHOW_STATUS_ARG)) : statusDisplayIntervalAsSeconds; + (newParamsMapWithSimpleKeys.containsKey(SHOW_STATUS_ARG)) ? Integer.parseInt( + newParamsMapWithSimpleKeys.get(SHOW_STATUS_ARG)) : statusDisplayIntervalAsSeconds; TimeUnit newTimeUnit = (newParamsMapWithSimpleKeys.containsKey(TIME_UNIT_ARG)) ? TimeUnit.valueOf( - newParamsMapWithSimpleKeys.get(TIME_UNIT_ARG)) : timeUnit; + newParamsMapWithSimpleKeys.get(TIME_UNIT_ARG)) : timeUnit; String newResultDirPath = - (newParamsMapWithSimpleKeys.containsKey(RESULT_DIR_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( - RESULT_DIR_PATH_ARG) : resultDirPath; + (newParamsMapWithSimpleKeys.containsKey(RESULT_DIR_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( + RESULT_DIR_PATH_ARG) : resultDirPath; double newTimeCompressionRatio = - (newParamsMapWithSimpleKeys.containsKey(TIME_COMPRESSION_RATIO_ARG)) ? Double.parseDouble( - newParamsMapWithSimpleKeys.get(TIME_COMPRESSION_RATIO_ARG)) : timeCompressionRatio; + (newParamsMapWithSimpleKeys.containsKey(TIME_COMPRESSION_RATIO_ARG)) ? Double.parseDouble( + newParamsMapWithSimpleKeys.get(TIME_COMPRESSION_RATIO_ARG)) : timeCompressionRatio; int newValidationParametersSize = - (newParamsMapWithSimpleKeys.containsKey(VALIDATION_PARAMS_SIZE_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(VALIDATION_PARAMS_SIZE_ARG)) : validationParametersSize; + (newParamsMapWithSimpleKeys.containsKey(VALIDATION_PARAMS_SIZE_ARG)) ? Integer.parseInt( + newParamsMapWithSimpleKeys.get(VALIDATION_PARAMS_SIZE_ARG)) : validationParametersSize; boolean newValidationSerializationCheck = - (newParamsMapWithSimpleKeys.containsKey(VALIDATION_SERIALIZATION_CHECK_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(VALIDATION_SERIALIZATION_CHECK_ARG)) : validationSerializationCheck; + (newParamsMapWithSimpleKeys.containsKey(VALIDATION_SERIALIZATION_CHECK_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(VALIDATION_SERIALIZATION_CHECK_ARG)) : + validationSerializationCheck; String newDatabaseValidationFilePath = - (newParamsMapWithSimpleKeys.containsKey(DB_VALIDATION_FILE_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( - DB_VALIDATION_FILE_PATH_ARG) : databaseValidationFilePath; + (newParamsMapWithSimpleKeys.containsKey(DB_VALIDATION_FILE_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( + DB_VALIDATION_FILE_PATH_ARG) : databaseValidationFilePath; long newSpinnerSleepDurationAsMilli = - (newParamsMapWithSimpleKeys.containsKey(SPINNER_SLEEP_DURATION_ARG)) ? Long.parseLong( - (newParamsMapWithSimpleKeys.get(SPINNER_SLEEP_DURATION_ARG))) : spinnerSleepDurationAsMilli; + (newParamsMapWithSimpleKeys.containsKey(SPINNER_SLEEP_DURATION_ARG)) ? Long.parseLong( + (newParamsMapWithSimpleKeys.get(SPINNER_SLEEP_DURATION_ARG))) : spinnerSleepDurationAsMilli; boolean newPrintHelp = (newParamsMapWithSimpleKeys.containsKey(HELP_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(HELP_ARG)) : printHelp; + newParamsMapWithSimpleKeys.get(HELP_ARG)) : printHelp; boolean newRecordDelayedOperations = - (newParamsMapWithSimpleKeys.containsKey(RECORD_DELAYED_OPERATIONS_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(RECORD_DELAYED_OPERATIONS_ARG)) : recordDelayedOperations; + (newParamsMapWithSimpleKeys.containsKey(RECORD_DELAYED_OPERATIONS_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(RECORD_DELAYED_OPERATIONS_ARG)) : recordDelayedOperations; boolean newIgnoreScheduledStartTimes = - (newParamsMapWithSimpleKeys.containsKey(IGNORE_SCHEDULED_START_TIMES_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(IGNORE_SCHEDULED_START_TIMES_ARG)) : ignoreScheduledStartTimes; + (newParamsMapWithSimpleKeys.containsKey(IGNORE_SCHEDULED_START_TIMES_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(IGNORE_SCHEDULED_START_TIMES_ARG)) : ignoreScheduledStartTimes; long newWarmupCount = (newParamsMapWithSimpleKeys.containsKey(WARMUP_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(WARMUP_COUNT_ARG)) : warmupCount; + newParamsMapWithSimpleKeys.get(WARMUP_COUNT_ARG)) : warmupCount; long newSkipCount = (newParamsMapWithSimpleKeys.containsKey(SKIP_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(SKIP_COUNT_ARG)) : skipCount; + newParamsMapWithSimpleKeys.get(SKIP_COUNT_ARG)) : skipCount; boolean newFlushLog = (newParamsMapWithSimpleKeys.containsKey(FLUSH_LOG_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(FLUSH_LOG_ARG)) : flushLog; + newParamsMapWithSimpleKeys.get(FLUSH_LOG_ARG)) : flushLog; + + long newEstimateTestTime = (newParamsMapWithSimpleKeys.containsKey(ESTIMATE_TEST_TIME_ARG)) + ? Long.parseLong(paramsMap.get(ESTIMATE_TEST_TIME_ARG)) : estimateTestTime; + long newAccurateTestTime = (newParamsMapWithSimpleKeys.containsKey(ACCURATE_TEST_TIME_ARG)) + ? Long.parseLong(paramsMap.get(ACCURATE_TEST_TIME_ARG)) : accurateTestTime; + double newDichotomyErrorRange = (newParamsMapWithSimpleKeys.containsKey(DICHOTOMY_ERROR_RANGE_ARG)) + ? Double.parseDouble(paramsMap.get(DICHOTOMY_ERROR_RANGE_ARG)) : dichotomyErrorRange; + double newTcrMin = + (newParamsMapWithSimpleKeys.containsKey(TCR_MIN_ARG)) ? Double.parseDouble(paramsMap.get(TCR_MIN_ARG)) + : tcrMin; + double newTcrMax = + (newParamsMapWithSimpleKeys.containsKey(TCR_MAX_ARG)) ? Double.parseDouble(paramsMap.get(TCR_MAX_ARG)) + : tcrMax; + double newTimeoutRate = (newParamsMapWithSimpleKeys.containsKey(TIMEOUT_RATE_ARG)) + ? Double.parseDouble(paramsMap.get(TIMEOUT_RATE_ARG)) + : timeoutRate; return new ConsoleAndFileDriverConfiguration(newOtherParams, newMode, newName, newDbClassName, - newWorkloadClassName, newOperationCount, newThreadCount, newStatusDisplayIntervalAsSeconds, newTimeUnit, - newResultDirPath, newTimeCompressionRatio, newValidationParametersSize, newValidationSerializationCheck, - newRecordDelayedOperations, newDatabaseValidationFilePath, newSpinnerSleepDurationAsMilli, newPrintHelp, - newIgnoreScheduledStartTimes, newWarmupCount, newSkipCount, newFlushLog); + newWorkloadClassName, newOperationCount, newThreadCount, newStatusDisplayIntervalAsSeconds, newTimeUnit, + newResultDirPath, newTimeCompressionRatio, newValidationParametersSize, newValidationSerializationCheck, + newRecordDelayedOperations, newDatabaseValidationFilePath, newSpinnerSleepDurationAsMilli, newPrintHelp, + newIgnoreScheduledStartTimes, newWarmupCount, newSkipCount, newFlushLog, newEstimateTestTime, + newAccurateTestTime, newDichotomyErrorRange, newTcrMin, newTcrMax, newTimeoutRate); } /** @@ -916,7 +1176,8 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { * New instance contains all fields that original configuration instance contained. * New instance will contain additional fields if the new parameter introduced one. */ - public DriverConfiguration applyArg(String argument, String newValue) throws DriverConfigurationException { + public DriverConfiguration applyArg(String argument, + String newValue) throws DriverConfigurationException { Map newParamsMap = new HashMap<>(); newParamsMap.put(argument, newValue); return applyArgs(newParamsMap); @@ -952,14 +1213,14 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { if (!validationSerializationCheck) { argsList.addAll(Lists.newArrayList("-" + VALIDATION_SERIALIZATION_CHECK_ARG, - Boolean.toString(validationSerializationCheck))); + Boolean.toString(validationSerializationCheck))); } if (null != databaseValidationFilePath) { argsList.addAll(Lists.newArrayList("-" + DB_VALIDATION_FILE_PATH_ARG, databaseValidationFilePath)); } argsList.addAll( - Lists.newArrayList("-" + SPINNER_SLEEP_DURATION_ARG, Long.toString(spinnerSleepDurationAsMilli))); + Lists.newArrayList("-" + SPINNER_SLEEP_DURATION_ARG, Long.toString(spinnerSleepDurationAsMilli))); if (printHelp) { argsList.add("-" + HELP_ARG); } @@ -968,7 +1229,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } // additional, workload/database-related params Map additionalParameters = - MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); + MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); for (Entry additionalParam : MapUtils.sortedEntrySet(additionalParameters)) { argsList.addAll(Lists.newArrayList("-p", additionalParam.getKey(), additionalParam.getValue())); } @@ -980,7 +1241,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { StringBuilder sb = new StringBuilder(); sb.append("# -------------------------------------\n"); sb.append("# -------------------------------------\n"); - sb.append("# ----- Driver Configuration -----\n"); + sb.append("# ----- LDBC Driver Configuration -----\n"); sb.append("# -------------------------------------\n"); sb.append("# -------------------------------------\n"); sb.append("\n"); @@ -990,120 +1251,251 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("\n"); sb.append("# status display interval (intermittently show status during benchmark execution)\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ").append("-").append(MODE_ARG).append("/--").append(MODE_ARG_LONG).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(MODE_ARG) + .append("/--") + .append(MODE_ARG_LONG) + .append("\n"); sb.append("# INT-32 (seconds)\n"); - sb.append("# COMMAND: ").append("-").append(SHOW_STATUS_ARG).append("/--").append(SHOW_STATUS_ARG_LONG) - .append("\n"); - sb.append(SHOW_STATUS_ARG_LONG).append("=").append(statusDisplayIntervalAsSeconds).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(SHOW_STATUS_ARG) + .append("/--") + .append(SHOW_STATUS_ARG_LONG) + .append("\n"); + sb.append(SHOW_STATUS_ARG_LONG) + .append("=") + .append(statusDisplayIntervalAsSeconds) + .append("\n"); sb.append("\n"); sb.append("# thread pool size to use for executing operation handlers\n"); sb.append("# INT-32\n"); - sb.append("# COMMAND: ").append("-").append(THREADS_ARG).append("/--").append(THREADS_ARG_LONG).append("\n"); - sb.append(THREADS_ARG_LONG).append("=").append(threadCount).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(THREADS_ARG) + .append("/--") + .append(THREADS_ARG_LONG) + .append("\n"); + sb.append(THREADS_ARG_LONG) + .append("=") + .append(threadCount) + .append("\n"); sb.append("\n"); sb.append("# number of operations to execute during warmup phase of workload\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ").append("-").append(WARMUP_COUNT_ARG).append("/--").append(WARMUP_COUNT_ARG_LONG) - .append("\n"); - sb.append(WARMUP_COUNT_ARG_LONG).append("=").append(warmupCount).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(WARMUP_COUNT_ARG) + .append("/--") + .append(WARMUP_COUNT_ARG_LONG) + .append("\n"); + sb.append(WARMUP_COUNT_ARG_LONG) + .append("=") + .append(warmupCount) + .append("\n"); sb.append("\n"); sb.append("# number of operations to skip before beginning workload execution\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ").append("-").append(SKIP_COUNT_ARG).append("/--").append(SKIP_COUNT_ARG_LONG) - .append("\n"); - sb.append(SKIP_COUNT_ARG_LONG).append("=").append(skipCount).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(SKIP_COUNT_ARG) + .append("/--") + .append(SKIP_COUNT_ARG_LONG) + .append("\n"); + sb.append(SKIP_COUNT_ARG_LONG) + .append("=") + .append(skipCount) + .append("\n"); sb.append("\n"); sb.append("# name of the benchmark run\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ").append("-").append(NAME_ARG).append("/--").append(NAME_ARG_LONG).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(NAME_ARG) + .append("/--") + .append(NAME_ARG_LONG) + .append("\n"); if (null == name) { - sb.append("# ").append(NAME_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(NAME_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(NAME_ARG_LONG).append("=").append(name).append("\n"); + sb.append(NAME_ARG_LONG) + .append("=") + .append(name) + .append("\n"); } sb.append("\n"); sb.append("# path specifying where to write the benchmark results file\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ").append("-").append(RESULT_DIR_PATH_ARG).append("/--").append(RESULT_DIR_PATH_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(RESULT_DIR_PATH_ARG) + .append("/--") + .append(RESULT_DIR_PATH_ARG_LONG) + .append("\n"); if (null == resultDirPath) { - sb.append("# ").append(RESULT_DIR_PATH_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(RESULT_DIR_PATH_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(RESULT_DIR_PATH_ARG_LONG).append("=").append(resultDirPath).append("\n"); + sb.append(RESULT_DIR_PATH_ARG_LONG) + .append("=") + .append(resultDirPath) + .append("\n"); } sb.append("\n"); sb.append("# time unit to use for measuring performance metrics (e.g., query response time)\n"); - sb.append("# ENUM (").append(Arrays.toString(VALID_TIME_UNITS)).append(")\n"); - sb.append("# COMMAND: ").append("-").append(TIME_UNIT_ARG).append("/--").append(TIME_UNIT_ARG_LONG) - .append("\n"); - sb.append(TIME_UNIT_ARG_LONG).append("=").append(timeUnit).append("\n"); + sb.append("# ENUM (") + .append(Arrays.toString(VALID_TIME_UNITS)) + .append(")\n"); + sb.append("# COMMAND: ") + .append("-") + .append(TIME_UNIT_ARG) + .append("/--") + .append(TIME_UNIT_ARG_LONG) + .append("\n"); + sb.append(TIME_UNIT_ARG_LONG) + .append("=") + .append(timeUnit) + .append("\n"); sb.append("\n"); sb.append("# used to 'compress'/'stretch' durations between operation start times to increase/decrease " - + "benchmark load\n"); + + "benchmark load\n"); sb.append("# e.g. 2.0 = run benchmark 2x slower, 0.1 = run benchmark 10x faster\n"); sb.append("# DOUBLE\n"); - sb.append("# COMMAND: ").append("-").append(TIME_COMPRESSION_RATIO_ARG).append("/--") - .append(TIME_COMPRESSION_RATIO_ARG_LONG).append("\n"); - sb.append(TIME_COMPRESSION_RATIO_ARG_LONG).append("=").append(timeCompressionRatio).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(TIME_COMPRESSION_RATIO_ARG) + .append("/--") + .append(TIME_COMPRESSION_RATIO_ARG_LONG) + .append("\n"); + sb.append(TIME_COMPRESSION_RATIO_ARG_LONG) + .append("=") + .append(timeCompressionRatio) + .append("\n"); sb.append("\n"); sb.append("# enable validation that will check if the provided database implementation is correct\n"); sb.append("# parameter value specifies where to find the validation parameters file\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ").append("-").append(DB_VALIDATION_FILE_PATH_ARG).append("/--") - .append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(DB_VALIDATION_FILE_PATH_ARG) + .append("/--") + .append(DB_VALIDATION_FILE_PATH_ARG_LONG) + .append("\n"); if (null == databaseValidationFilePath) { - sb.append("# ").append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(DB_VALIDATION_FILE_PATH_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("=").append(databaseValidationFilePath).append("\n"); + sb.append(DB_VALIDATION_FILE_PATH_ARG_LONG) + .append("=") + .append(databaseValidationFilePath) + .append("\n"); } sb.append("\n"); sb.append("# generate validation parameters file for validating correctness of database implementations\n"); sb.append("# parameter values specify: (1) where to create the validation parameters file (2) how many " - + "validation parameters to generate\n"); + + "validation parameters to generate\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ").append("-").append(VALIDATION_SERIALIZATION_CHECK_ARG).append("/--") - .append(VALIDATION_SERIALIZATION_CHECK_ARG_LONG).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(VALIDATION_SERIALIZATION_CHECK_ARG) + .append("/--") + .append(VALIDATION_SERIALIZATION_CHECK_ARG_LONG) + .append("\n"); sb.append("# INT-32\n"); - sb.append("# COMMAND: ").append("-").append(VALIDATION_PARAMS_SIZE_ARG).append("/--") - .append(VALIDATION_PARAMS_SIZE_ARG_LONG).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(VALIDATION_PARAMS_SIZE_ARG) + .append("/--") + .append(VALIDATION_PARAMS_SIZE_ARG_LONG) + .append("\n"); sb.append("\n"); sb.append("# sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)\n"); sb.append("# INT-64 (milliseconds)\n"); - sb.append("# COMMAND: ").append("-").append(SPINNER_SLEEP_DURATION_ARG).append("/--") - .append(SPINNER_SLEEP_DURATION_ARG_LONG).append("\n"); - sb.append(SPINNER_SLEEP_DURATION_ARG_LONG).append("=").append(spinnerSleepDurationAsMilli).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(SPINNER_SLEEP_DURATION_ARG) + .append("/--") + .append(SPINNER_SLEEP_DURATION_ARG_LONG) + .append("\n"); + sb.append(SPINNER_SLEEP_DURATION_ARG_LONG) + .append("=") + .append(spinnerSleepDurationAsMilli) + .append("\n"); sb.append("\n"); sb.append("# print help string - usage instructions\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ").append("-").append(HELP_ARG).append("\n"); - sb.append(HELP_ARG).append("=").append(printHelp).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(HELP_ARG) + .append("\n"); + sb.append(HELP_ARG) + .append("=") + .append(printHelp) + .append("\n"); sb.append("\n"); sb.append("# executes operations as fast as possible, ignoring their scheduled start times\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ").append("-").append(IGNORE_SCHEDULED_START_TIMES_ARG).append("\n"); - sb.append(IGNORE_SCHEDULED_START_TIMES_ARG).append("=").append(ignoreScheduledStartTimes).append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(IGNORE_SCHEDULED_START_TIMES_ARG) + .append("\n"); + sb.append(IGNORE_SCHEDULED_START_TIMES_ARG) + .append("=") + .append(ignoreScheduledStartTimes) + .append("\n"); sb.append("\n"); sb.append("# ***************************************************************\n"); sb.append("# *** the following should be set by workload implementations ***\n"); sb.append("# ***************************************************************\n"); sb.append("\n"); sb.append("# fully qualified class name of the Workload (class) implementation to execute\n"); - sb.append("# STRING (e.g., ").append(GraphyBenchTransactionWorkload.class.getName()).append(")\n"); - sb.append("# COMMAND: ").append("-").append(WORKLOAD_ARG).append("/--").append(WORKLOAD_ARG_LONG).append("\n"); + sb.append("# STRING (e.g., ") + .append(GraphyBenchTransactionWorkload.class.getName()) + .append(")\n"); + sb.append("# COMMAND: ") + .append("-") + .append(WORKLOAD_ARG) + .append("/--") + .append(WORKLOAD_ARG_LONG) + .append("\n"); if (null == workloadClassName) { - sb.append("# ").append(WORKLOAD_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(WORKLOAD_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(WORKLOAD_ARG_LONG).append("=").append(workloadClassName).append("\n"); + sb.append(WORKLOAD_ARG_LONG) + .append("=") + .append(workloadClassName) + .append("\n"); } sb.append("\n"); sb.append("# number of operations to generate during benchmark execution\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ").append("-").append(OPERATION_COUNT_ARG).append("/--").append(OPERATION_COUNT_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ") + .append("-") + .append(OPERATION_COUNT_ARG) + .append("/--") + .append(OPERATION_COUNT_ARG_LONG) + .append("\n"); if (0 == operationCount) { - sb.append("# ").append(OPERATION_COUNT_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(OPERATION_COUNT_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(OPERATION_COUNT_ARG_LONG).append("=").append(operationCount).append("\n"); + sb.append(OPERATION_COUNT_ARG_LONG) + .append("=") + .append(operationCount) + .append("\n"); } sb.append("\n"); sb.append("# ************************************************************************************\n"); @@ -1111,16 +1503,29 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("# ************************************************************************************\n"); sb.append("\n"); sb.append("# fully qualified class name of the Db (class) implementation to execute\n"); - sb.append("# STRING (e.g., ").append(DummyGraphyBenchTransactionDb.class.getName()).append(")\n"); - sb.append("# COMMAND: ").append("-").append(DB_ARG).append("/--").append(DB_ARG_LONG).append("\n"); + sb.append("# STRING (e.g., ") + .append(DummyGraphyBenchTransactionDb.class.getName()) + .append(")\n"); + sb.append("# COMMAND: ") + .append("-") + .append(DB_ARG) + .append("/--") + .append(DB_ARG_LONG) + .append("\n"); if (null == dbClassName) { - sb.append("# ").append(DB_ARG_LONG).append("=").append("\n"); + sb.append("# ") + .append(DB_ARG_LONG) + .append("=") + .append("\n"); } else { - sb.append(DB_ARG_LONG).append("=").append(dbClassName).append("\n"); + sb.append(DB_ARG_LONG) + .append("=") + .append(dbClassName) + .append("\n"); } // Write additional, workload/database-related keys as well Map additionalConfigurationParameters = - MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); + MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); if (!additionalConfigurationParameters.isEmpty()) { sb.append("\n"); sb.append("# ************************************************************************************\n"); @@ -1128,9 +1533,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("# ************************************************************************************\n"); sb.append("\n"); for (Entry configurationParameter : MapUtils.sortedEntrySet( - additionalConfigurationParameters)) { - sb.append(configurationParameter.getKey()).append("=").append(configurationParameter.getValue()) - .append("\n"); + additionalConfigurationParameters)) { + sb.append(configurationParameter.getKey()) + .append("=") + .append(configurationParameter.getValue()) + .append("\n"); } } return sb.toString(); @@ -1140,47 +1547,91 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public String toString() { int padRightDistance = 32; StringBuilder sb = new StringBuilder(); - sb.append("Parameters:").append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Mode:")).append(mode).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Name:")).append(name).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "DB:")).append(dbClassName).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Workload:")).append(workloadClassName) - .append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Operation Count:")) - .append(INTEGRAL_FORMAT.format(operationCount)).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Warmup Count:")) - .append(INTEGRAL_FORMAT.format(warmupCount)).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Skip Count:")) - .append(INTEGRAL_FORMAT.format(skipCount)).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Worker Threads:")).append(threadCount) - .append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Status Display Interval:")) - .append(TEMPORAL_UTIL.milliDurationToString(TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds))) - .append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Time Unit:")).append(timeUnit).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Results Directory:")).append(resultDirPath()) - .append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Time Compression Ratio:")) - .append(FLOAT_FORMAT.format(timeCompressionRatio)).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Parameter Size:")) - .append(validationParametersSize).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Serialization Check:")) - .append(validationSerializationCheck).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Database File:")) - .append(databaseValidationFilePath).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Spinner Sleep Duration:")) - .append(TEMPORAL_UTIL.milliDurationToString(spinnerSleepDurationAsMilli)).append(" / ") - .append(spinnerSleepDurationAsMilli).append(" (ms)\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Print Help:")).append(printHelp).append("\n"); - sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Ignore Scheduled Start Times:")) - .append(ignoreScheduledStartTimes).append("\n"); + sb.append("Parameters:") + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Mode:")) + .append(mode) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Name:")) + .append(name) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "DB:")) + .append(dbClassName) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Workload:")) + .append(workloadClassName) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Operation Count:")) + .append(INTEGRAL_FORMAT.format(operationCount)) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Warmup Count:")) + .append(INTEGRAL_FORMAT.format(warmupCount)) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Skip Count:")) + .append(INTEGRAL_FORMAT.format(skipCount)) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Worker Threads:")) + .append(threadCount) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Status Display Interval:")) + .append(TEMPORAL_UTIL.milliDurationToString(TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds))) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Time Unit:")) + .append(timeUnit) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Results Directory:")) + .append(resultDirPath()) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Time Compression Ratio:")) + .append(FLOAT_FORMAT.format(timeCompressionRatio)) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Validation Parameter Size:")) + .append(validationParametersSize) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Validation Serialization Check:")) + .append(validationSerializationCheck) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Validation Database File:")) + .append(databaseValidationFilePath) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Spinner Sleep Duration:")) + .append(TEMPORAL_UTIL.milliDurationToString(spinnerSleepDurationAsMilli)) + .append(" / ") + .append(spinnerSleepDurationAsMilli) + .append(" (ms)\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Print Help:")) + .append(printHelp) + .append("\n"); + sb.append("\t") + .append(format("%1$-" + padRightDistance + "s", "Ignore Scheduled Start Times:")) + .append(ignoreScheduledStartTimes) + .append("\n"); Set excludedKeys = coreConfigurationParameterKeys(); Map filteredParamsMap = - MapUtils.copyExcludingKeys(convertComplexKeysToSimpleKeys(paramsMap), excludedKeys); + MapUtils.copyExcludingKeys(convertComplexKeysToSimpleKeys(paramsMap), excludedKeys); if (!filteredParamsMap.isEmpty()) { - sb.append("\t").append("User-defined parameters:").append("\n"); + sb.append("\t") + .append("User-defined parameters:") + .append("\n"); sb.append(MapUtils.prettyPrint(filteredParamsMap, "\t\t")); } diff --git a/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java b/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java index a0198cf..886e661 100644 --- a/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java +++ b/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java @@ -62,6 +62,24 @@ public interface DriverConfiguration { boolean flushLog(); + void setTimeCompressionRatio(double tcr); + + void setWarmupCount(long warmupCount); + + void setOperationCount(long operationCount); + + long estimateTestTime(); + + long accurateTestTime(); + + double dichotomyErrorRange(); + + double tcrMin(); + + double tcrMax(); + + double timeoutRate(); + String toPropertiesString() throws DriverConfigurationException; Map asMap(); diff --git a/src/main/java/org/graphybench/driver/driver/control/OperationMode.java b/src/main/java/org/graphybench/driver/driver/control/OperationMode.java index 8436d12..3d195ab 100644 --- a/src/main/java/org/graphybench/driver/driver/control/OperationMode.java +++ b/src/main/java/org/graphybench/driver/driver/control/OperationMode.java @@ -20,5 +20,6 @@ public enum OperationMode { CREATE_VALIDATION, VALIDATE_DATABASE, CREATE_STATISTICS, - EXECUTE_BENCHMARK + EXECUTE_BENCHMARK, + AUTOMATIC_TEST } diff --git a/src/main/java/org/graphybench/driver/driver/driver/Driver.java b/src/main/java/org/graphybench/driver/driver/driver/Driver.java index 4f66705..48254db 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/Driver.java +++ b/src/main/java/org/graphybench/driver/driver/driver/Driver.java @@ -41,17 +41,17 @@ public class Driver { // Initial loggin service LoggingServiceFactory loggingServiceFactory = new Log4jLoggingServiceFactory(detailedStatus); LoggingService loggingService = loggingServiceFactory.loggingServiceFor(Driver.class.getSimpleName()); + loggingService.info("Driver Simple Name：" + Driver.class.getSimpleName()); - // try { TimeSource systemTimeSource = new SystemTimeSource(); ConsoleAndFileDriverConfiguration configuration = ConsoleAndFileDriverConfiguration.fromArgs(args); long workloadStartTimeAsMilli = systemTimeSource.nowAsMilli() + TimeUnit.SECONDS.toMillis(5); controlService = new LocalControlService( - workloadStartTimeAsMilli, - configuration, - loggingServiceFactory, - systemTimeSource); + workloadStartTimeAsMilli, + configuration, + loggingServiceFactory, + systemTimeSource); Driver driver = new Driver(); DriverMode driverMode = driver.getDriverModeFor(controlService); driverMode.init(); @@ -63,11 +63,11 @@ public class Driver { System.exit(1); } catch (Exception e) { loggingService.info("Driver terminated unexpectedly\n" + ConcurrentErrorReporter.stackTraceToString(e)); - System.exit(1); } finally { if (null != controlService) { controlService.shutdown(); } + System.exit(0); } } @@ -79,17 +79,19 @@ public class Driver { * @throws DriverException When one or more required parameters are missing */ public DriverMode getDriverModeFor(ControlService controlService) throws DriverException { - if (controlService.configuration().shouldPrintHelpString()) { + if (controlService.configuration() + .shouldPrintHelpString()) { return new PrintHelpMode(controlService); } List missingParams = - ConsoleAndFileDriverConfiguration.checkMissingParams(controlService.configuration()); + ConsoleAndFileDriverConfiguration.checkMissingParams(controlService.configuration()); if (!missingParams.isEmpty()) { throw new DriverException(format("Missing required parameters: %s", missingParams.toString())); } - OperationMode mode = OperationMode.valueOf(controlService.configuration().mode()); + OperationMode mode = OperationMode.valueOf(controlService.configuration() + .mode()); switch (mode) { case CREATE_VALIDATION: @@ -98,6 +100,8 @@ public class Driver { return new CalculateWorkloadStatisticsMode(controlService, RANDOM_SEED); case VALIDATE_DATABASE: return new ValidateDatabaseMode(controlService); + case AUTOMATIC_TEST: + return new AutomaticTestMode(controlService, new SystemTimeSource(), RANDOM_SEED); case EXECUTE_BENCHMARK: default: // Execute benchmark is default behaviour return new ExecuteWorkloadMode(controlService, new SystemTimeSource(), RANDOM_SEED); diff --git a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java index 7b2dbdf..f026682 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java +++ b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java @@ -78,12 +78,13 @@ public class ExecuteWorkloadMode implements DriverMode { private ResultsLogWriter resultsLogWriter = null; public ExecuteWorkloadMode( - ControlService controlService, - TimeSource timeSource, - long randomSeed) throws DriverException { + ControlService controlService, + TimeSource timeSource, + long randomSeed) throws DriverException { this.controlService = controlService; this.timeSource = timeSource; - this.loggingService = controlService.loggingServiceFactory().loggingServiceFor(getClass().getSimpleName()); + this.loggingService = controlService.loggingServiceFactory() + .loggingServiceFor(getClass().getSimpleName()); this.randomSeed = randomSeed; this.temporalUtil = new TemporalUtil(); this.resultsDirectory = new ResultsDirectory(controlService.configuration()); @@ -105,11 +106,12 @@ public class ExecuteWorkloadMode implements DriverMode { @Override public Object startExecutionAndAwaitCompletion() throws DriverException { - if (controlService.configuration().warmupCount() > 0) { + if (controlService.configuration() + .warmupCount() > 0) { loggingService.info("\n" - + " --------------------\n" - + " --- Warmup Phase ---\n" - + " --------------------"); + + " --------------------\n" + + " --- Warmup Phase ---\n" + + " --------------------"); doInit(true); doExecute(true); try { @@ -118,19 +120,20 @@ public class ExecuteWorkloadMode implements DriverMode { // As objects in the pool would otherwise hold references to services used during warmup database.reInit(); } catch (DbException e) { - throw new DriverException(format("Error reinitializing DB: %s", database.getClass().getName()), e); + throw new DriverException(format("Error reinitializing DB: %s", database.getClass() + .getName()), e); } } else { loggingService.info("\n" - + " ---------------------------------\n" - + " --- No Warmup Phase Requested ---\n" - + " ---------------------------------"); + + " ---------------------------------\n" + + " --- No Warmup Phase Requested ---\n" + + " ---------------------------------"); } loggingService.info("\n" - + " -----------------\n" - + " --- Run Phase ---\n" - + " -----------------"); + + " -----------------\n" + + " --- Run Phase ---\n" + + " -----------------"); doInit(false); doExecute(false); @@ -157,14 +160,16 @@ public class ExecuteWorkloadMode implements DriverMode { File resultsLog = resultsDirectory.getOrCreateResultsLogFile(warmup); try { resultsLogWriter = (null == resultsLog) - ? new NullResultsLogWriter() - : new SimpleResultsLogWriter( - resultsLog, - controlService.configuration().timeUnit(), - controlService.configuration().flushLog()); + ? new NullResultsLogWriter() + : new SimpleResultsLogWriter( + resultsLog, + controlService.configuration() + .timeUnit(), + controlService.configuration() + .flushLog()); } catch (IOException e) { throw new DriverException( - format("Error creating results log writer for: %s", resultsLog.getAbsolutePath()), e); + format("Error creating results log writer for: %s", resultsLog.getAbsolutePath()), e); } // ================== @@ -173,43 +178,52 @@ public class ExecuteWorkloadMode implements DriverMode { loggingService.info("Scanning workload streams to calculate their limits..."); long offset = (warmup) - ? controlService.configuration().skipCount() - : controlService.configuration().skipCount() + controlService.configuration().warmupCount(); + ? controlService.configuration() + .skipCount() + : controlService.configuration() + .skipCount() + controlService.configuration() + .warmupCount(); long limit = (warmup) - ? controlService.configuration().warmupCount() - : controlService.configuration().operationCount(); + ? controlService.configuration() + .warmupCount() + : controlService.configuration() + .operationCount(); WorkloadStreams workloadStreams; long minimumTimeStamp; try { boolean returnStreamsWithDbConnector = true; Tuple3 streamsAndWorkloadAndMinimumTimeStamp = - WorkloadStreams.createNewWorkloadWithOffsetAndLimitedWorkloadStreams( - controlService.configuration(), - gf, - returnStreamsWithDbConnector, - offset, - limit, - controlService.loggingServiceFactory() - ); + WorkloadStreams.createNewWorkloadWithOffsetAndLimitedWorkloadStreams( + controlService.configuration(), + gf, + returnStreamsWithDbConnector, + offset, + limit, + controlService.loggingServiceFactory() + ); workloadStreams = streamsAndWorkloadAndMinimumTimeStamp._1(); workload = streamsAndWorkloadAndMinimumTimeStamp._2(); minimumTimeStamp = streamsAndWorkloadAndMinimumTimeStamp._3(); } catch (Exception e) { throw new DriverException(format("Error loading workload class: %s", - controlService.configuration().workloadClassName()), e); + controlService.configuration() + .workloadClassName()), e); } - loggingService.info(format("Loaded workload: %s", workload.getClass().getName())); + loggingService.info(format("Loaded workload: %s", workload.getClass() + .getName())); - loggingService.info(format("Retrieving workload stream: %s", workload.getClass().getSimpleName())); + loggingService.info(format("Retrieving workload stream: %s", workload.getClass() + .getSimpleName())); controlService.setWorkloadStartTimeAsMilli(System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(5)); WorkloadStreams timeMappedWorkloadStreams; try { timeMappedWorkloadStreams = WorkloadStreams.timeOffsetAndCompressWorkloadStreams( - workloadStreams, - controlService.workloadStartTimeAsMilli(), - controlService.configuration().timeCompressionRatio(), - gf + workloadStreams, + controlService.workloadStartTimeAsMilli(), + controlService.configuration() + .timeCompressionRatio(), + gf ); } catch (WorkloadException e) { throw new DriverException("Error while retrieving operation stream for workload", e); @@ -220,17 +234,23 @@ public class ExecuteWorkloadMode implements DriverMode { // ================ if (null == database) { try { - database = ClassLoaderHelper.loadDb(controlService.configuration().dbClassName()); + database = ClassLoaderHelper.loadDb(controlService.configuration() + .dbClassName()); database.init( - controlService.configuration().asMap(), - controlService.loggingServiceFactory().loggingServiceFor(database.getClass().getSimpleName()), - workload.operationTypeToClassMapping() + controlService.configuration() + .asMap(), + controlService.loggingServiceFactory() + .loggingServiceFor(database.getClass() + .getSimpleName()), + workload.operationTypeToClassMapping() ); } catch (DbException e) { throw new DriverException( - format("Error initializing DB: %s", controlService.configuration().dbClassName()), e); + format("Error initializing DB: %s", controlService.configuration() + .dbClassName()), e); } - loggingService.info(format("Loaded DB: %s", database.getClass().getName())); + loggingService.info(format("Loaded DB: %s", database.getClass() + .getName())); } // ======================== @@ -239,13 +259,14 @@ public class ExecuteWorkloadMode implements DriverMode { try { // TODO create metrics service factory so different ones can be easily created metricsService = new DisruptorSbeMetricsService( - timeSource, - errorReporter, - controlService.configuration().timeUnit(), - DisruptorSbeMetricsService.DEFAULT_HIGHEST_EXPECTED_RUNTIME_DURATION_AS_NANO, - resultsLogWriter, - workload.operationTypeToClassMapping(), - controlService.loggingServiceFactory() + timeSource, + errorReporter, + controlService.configuration() + .timeUnit(), + DisruptorSbeMetricsService.DEFAULT_HIGHEST_EXPECTED_RUNTIME_DURATION_AS_NANO, + resultsLogWriter, + workload.operationTypeToClassMapping(), + controlService.loggingServiceFactory() ); } catch (MetricsCollectionException e) { throw new DriverException("Error creating metrics service", e); @@ -257,10 +278,10 @@ public class ExecuteWorkloadMode implements DriverMode { CompletionTimeServiceAssistant completionTimeServiceAssistant = new CompletionTimeServiceAssistant(); try { completionTimeService = - completionTimeServiceAssistant.newThreadedQueuedCompletionTimeService( - timeSource, - errorReporter - ); + completionTimeServiceAssistant.newThreadedQueuedCompletionTimeService( + timeSource, + errorReporter + ); } catch (CompletionTimeException e) { throw new DriverException("Error instantiating Completion Time Service", e); } @@ -272,18 +293,22 @@ public class ExecuteWorkloadMode implements DriverMode { try { int operationHandlerExecutorsBoundedQueueSize = DefaultQueues.DEFAULT_BOUND_1000; workloadRunner = new WorkloadRunner( - timeSource, - database, - timeMappedWorkloadStreams, - metricsService, - errorReporter, - completionTimeService, - controlService.loggingServiceFactory(), - controlService.configuration().threadCount(), - controlService.configuration().statusDisplayIntervalAsSeconds(), - controlService.configuration().spinnerSleepDurationAsMilli(), - controlService.configuration().ignoreScheduledStartTimes(), - operationHandlerExecutorsBoundedQueueSize); + timeSource, + database, + timeMappedWorkloadStreams, + metricsService, + errorReporter, + completionTimeService, + controlService.loggingServiceFactory(), + controlService.configuration() + .threadCount(), + controlService.configuration() + .statusDisplayIntervalAsSeconds(), + controlService.configuration() + .spinnerSleepDurationAsMilli(), + controlService.configuration() + .ignoreScheduledStartTimes(), + operationHandlerExecutorsBoundedQueueSize); } catch (Exception e) { throw new DriverException(format("Error instantiating %s", WorkloadRunner.class.getSimpleName()), e); } @@ -294,7 +319,8 @@ public class ExecuteWorkloadMode implements DriverMode { // TODO note, this MUST be done after creation of Workload Runner because Workload Runner creates the // TODO "writers" for completion time service (refactor this mess at some stage) try { - if (completionTimeService.getAllWriters().isEmpty()) { + if (completionTimeService.getAllWriters() + .isEmpty()) { // There are no completion time writers, CT would never advance or be non-null, // set to max so nothing ever waits on it long nearlyMaxPossibleTimeAsMilli = Long.MAX_VALUE - 1; @@ -308,41 +334,42 @@ public class ExecuteWorkloadMode implements DriverMode { } else { // There are some completion time writers, initialize them to lowest time stamp in workload completionTimeServiceAssistant - .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp - 1); + .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp - 1); completionTimeServiceAssistant - .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp); + .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp); boolean completionTimeAdvancedToDesiredTime = - completionTimeServiceAssistant.waitForCompletionTime( - timeSource, - minimumTimeStamp - 1, - TimeUnit.SECONDS.toMillis(5), - completionTimeService, - errorReporter - ); + completionTimeServiceAssistant.waitForCompletionTime( + timeSource, + minimumTimeStamp - 1, + TimeUnit.SECONDS.toMillis(5), + completionTimeService, + errorReporter + ); long completionTimeWaitTimeoutDurationAsMilli = TimeUnit.SECONDS.toMillis(5); if (!completionTimeAdvancedToDesiredTime) { throw new DriverException( - format( - "Timed out [%s] while waiting for completion time to advance to workload " - + "start time\nCurrent CT: %s\nWaiting For CT: %s", - completionTimeWaitTimeoutDurationAsMilli, - completionTimeService.completionTimeAsMilli(), - controlService.workloadStartTimeAsMilli()) + format( + "Timed out [%s] while waiting for completion time to advance to workload " + + "start time\nCurrent CT: %s\nWaiting For CT: %s", + completionTimeWaitTimeoutDurationAsMilli, + completionTimeService.completionTimeAsMilli(), + controlService.workloadStartTimeAsMilli()) ); } loggingService.info("CT: " + temporalUtil - .milliTimeToDateTimeString(completionTimeService.completionTimeAsMilli()) + " / " - + completionTimeService.completionTimeAsMilli()); + .milliTimeToDateTimeString(completionTimeService.completionTimeAsMilli()) + " / " + + completionTimeService.completionTimeAsMilli()); } } catch (CompletionTimeException e) { throw new DriverException( - "Error while writing initial initiated and completed times to Completion Time Service", e); + "Error while writing initial initiated and completed times to Completion Time Service", e); } } private void doExecute(boolean warmup) throws DriverException { try { - ConcurrentErrorReporter errorReporter = workloadRunner.getFuture().get(); + ConcurrentErrorReporter errorReporter = workloadRunner.getFuture() + .get(); loggingService.info("Shutting down workload..."); workload.close(); if (errorReporter.errorEncountered()) { @@ -362,7 +389,8 @@ public class ExecuteWorkloadMode implements DriverMode { loggingService.info("Shutting down metrics collection service..."); WorkloadResultsSnapshot workloadResults; try { - workloadResults = metricsService.getWriter().results(); + workloadResults = metricsService.getWriter() + .results(); metricsService.shutdown(); } catch (MetricsCollectionException e) { throw new DriverException("Error during shutdown of metrics collection service", e); @@ -377,53 +405,60 @@ public class ExecuteWorkloadMode implements DriverMode { if (resultsDirectory.exists()) { File resultsSummaryFile = resultsDirectory.getOrCreateResultsSummaryFile(warmup); loggingService.info( - format("Exporting workload metrics to %s...", resultsSummaryFile.getAbsolutePath()) + format("Exporting workload metrics to %s...", resultsSummaryFile.getAbsolutePath()) ); MetricsManager.export(workloadResults, - new JsonWorkloadMetricsFormatter(), - new FileOutputStream(resultsSummaryFile), - Charsets.UTF_8 + new JsonWorkloadMetricsFormatter(), + new FileOutputStream(resultsSummaryFile), + Charsets.UTF_8 ); File configurationFile = resultsDirectory.getOrCreateConfigurationFile(warmup); Files.write( - configurationFile.toPath(), - controlService.configuration().toPropertiesString().getBytes(StandardCharsets.UTF_8) + configurationFile.toPath(), + controlService.configuration() + .toPropertiesString() + .getBytes(StandardCharsets.UTF_8) ); resultsLogWriter.close(); - if (!controlService.configuration().ignoreScheduledStartTimes()) { + if (!controlService.configuration() + .ignoreScheduledStartTimes()) { loggingService.info("Validating workload results..."); // TODO make this feature accessible directly ResultsLogValidator resultsLogValidator = new ResultsLogValidator(); ResultsLogValidationTolerances resultsLogValidationTolerances = - workload.resultsLogValidationTolerances(controlService.configuration(), warmup); + workload.resultsLogValidationTolerances(controlService.configuration(), warmup); ResultsLogValidationSummary resultsLogValidationSummary = resultsLogValidator.compute( - resultsDirectory.getOrCreateResultsLogFile(warmup), - resultsLogValidationTolerances.excessiveDelayThresholdAsMilli() + resultsDirectory.getOrCreateResultsLogFile(warmup), + resultsLogValidationTolerances.excessiveDelayThresholdAsMilli() ); File resultsValidationFile = resultsDirectory.getOrCreateResultsValidationFile(warmup); loggingService.info( - format("Exporting workload results validation to: %s", - resultsValidationFile.getAbsolutePath()) - ); - Files.write( - resultsValidationFile.toPath(), - resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) + format("Exporting workload results validation to: %s", + resultsValidationFile.getAbsolutePath()) ); + // Files.write( + // resultsValidationFile.toPath(), + // resultsLogValidationSummary.toJson() + // .getBytes(StandardCharsets.UTF_8) + // ); // TODO export result ResultsLogValidationResult validationResult = resultsLogValidator.validate( - resultsLogValidationSummary, - resultsLogValidationTolerances, - controlService.configuration().recordDelayedOperations(), - workloadResults + resultsLogValidationSummary, + resultsLogValidationTolerances, + controlService.configuration() + .recordDelayedOperations(), + workloadResults ); loggingService.info(validationResult.getScheduleAuditResult( - controlService.configuration().recordDelayedOperations() + controlService.configuration() + .recordDelayedOperations() )); Files.write( - resultsValidationFile.toPath(), - resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) + resultsValidationFile.toPath(), + resultsLogValidationSummary.toJson() + .getBytes(StandardCharsets.UTF_8) ); } } diff --git a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java index b8646c0..e02a3c2 100644 --- a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java +++ b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java @@ -20,6 +20,8 @@ import static java.lang.String.format; import java.util.ArrayList; import java.util.List; +import java.util.Timer; +import java.util.TimerTask; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; @@ -45,36 +47,37 @@ import org.graphybench.driver.driver.temporal.TimeSource; public class WorkloadRunner { static final long RUNNER_POLLING_INTERVAL_AS_MILLI = 100; + static final long RUNNER_POLLING_INTERVAL_AS_MILLI_AUTOMATIC = 500; private static final CompletionTimeWriter DUMMY_COMPLETION_TIME_WRITER = new DummyCompletionTimeWriter(); private final WorkloadRunnerFuture workloadRunnerFuture; public WorkloadRunner( - TimeSource timeSource, - Db db, - WorkloadStreams workloadStreams, - MetricsService metricsService, - ConcurrentErrorReporter errorReporter, - CompletionTimeService completionTimeService, - LoggingServiceFactory loggingServiceFactory, - int threadCount, - long statusDisplayIntervalAsSeconds, - long spinnerSleepDurationAsMilli, - boolean ignoreScheduleStartTimes, - int operationHandlerExecutorsBoundedQueueSize) throws WorkloadException, MetricsCollectionException { + TimeSource timeSource, + Db db, + WorkloadStreams workloadStreams, + MetricsService metricsService, + ConcurrentErrorReporter errorReporter, + CompletionTimeService completionTimeService, + LoggingServiceFactory loggingServiceFactory, + int threadCount, + long statusDisplayIntervalAsSeconds, + long spinnerSleepDurationAsMilli, + boolean ignoreScheduleStartTimes, + int operationHandlerExecutorsBoundedQueueSize) throws WorkloadException, MetricsCollectionException { this.workloadRunnerFuture = new WorkloadRunnerFuture( - timeSource, - db, - workloadStreams, - metricsService, - errorReporter, - completionTimeService, - loggingServiceFactory, - threadCount, - statusDisplayIntervalAsSeconds, - spinnerSleepDurationAsMilli, - ignoreScheduleStartTimes, - operationHandlerExecutorsBoundedQueueSize + timeSource, + db, + workloadStreams, + metricsService, + errorReporter, + completionTimeService, + loggingServiceFactory, + threadCount, + statusDisplayIntervalAsSeconds, + spinnerSleepDurationAsMilli, + ignoreScheduleStartTimes, + operationHandlerExecutorsBoundedQueueSize ); } @@ -83,6 +86,11 @@ public class WorkloadRunner { return workloadRunnerFuture; } + public ConcurrentErrorReporter getFuture(long milli) { + workloadRunnerFuture.startThread(milli); + return workloadRunnerFuture.errorReporter; + } + private enum WorkloadRunnerThreadState { NOT_STARTED, RUNNING, @@ -98,31 +106,31 @@ public class WorkloadRunner { private boolean isDone = false; private WorkloadRunnerFuture( - TimeSource timeSource, - Db db, - WorkloadStreams workloadStreams, - MetricsService metricsService, - ConcurrentErrorReporter errorReporter, - CompletionTimeService completionTimeService, - LoggingServiceFactory loggingServiceFactory, - int threadCount, - long statusDisplayIntervalAsSeconds, - long spinnerSleepDurationAsMilli, - boolean ignoreScheduleStartTimes, - int operationHandlerExecutorsBoundedQueueSize) throws MetricsCollectionException, WorkloadException { + TimeSource timeSource, + Db db, + WorkloadStreams workloadStreams, + MetricsService metricsService, + ConcurrentErrorReporter errorReporter, + CompletionTimeService completionTimeService, + LoggingServiceFactory loggingServiceFactory, + int threadCount, + long statusDisplayIntervalAsSeconds, + long spinnerSleepDurationAsMilli, + boolean ignoreScheduleStartTimes, + int operationHandlerExecutorsBoundedQueueSize) throws MetricsCollectionException, WorkloadException { this.workloadRunnerThread = new WorkloadRunnerThread( - timeSource, - db, - workloadStreams, - metricsService, - errorReporter, - completionTimeService, - loggingServiceFactory, - threadCount, - statusDisplayIntervalAsSeconds, - spinnerSleepDurationAsMilli, - ignoreScheduleStartTimes, - operationHandlerExecutorsBoundedQueueSize + timeSource, + db, + workloadStreams, + metricsService, + errorReporter, + completionTimeService, + loggingServiceFactory, + threadCount, + statusDisplayIntervalAsSeconds, + spinnerSleepDurationAsMilli, + ignoreScheduleStartTimes, + operationHandlerExecutorsBoundedQueueSize ); this.timeSource = timeSource; this.errorReporter = errorReporter; @@ -137,6 +145,39 @@ public class WorkloadRunner { } } + private void startThread(long milli) { + if (!workloadRunnerThread.state().equals(WorkloadRunnerThreadState.NOT_STARTED)) { + workloadRunnerThread.shutdownEverything(WorkloadRunnerThread.ShutdownType.FORCED, + new ConcurrentErrorReporter()); + } + workloadRunnerThread.start(); + // You cannot sleep(milli) directly, because if the execution finishes in the meantime, you will + // sleep for extra time + + AtomicBoolean expire = new AtomicBoolean(false); + Timer timer = new Timer(); + while (workloadRunnerThread.state().equals(WorkloadRunnerThreadState.NOT_STARTED)) { + Spinner.powerNap(RUNNER_POLLING_INTERVAL_AS_MILLI); + } + timer.schedule(new TimerTask() { + @Override + public void run() { + expire.set(true); + } + }, milli); + while (!expire.get() && workloadRunnerThread.state().equals(WorkloadRunnerThreadState.RUNNING)) { + Spinner.powerNap(RUNNER_POLLING_INTERVAL_AS_MILLI_AUTOMATIC); + } + timer.cancel(); + if (isCancelled || isDone) { + throw new IllegalStateException("Can not call method after future has been cancelled or completed"); + } + workloadRunnerThread.interrupt(); + isCancelled = true; + isDone = true; + workloadRunnerThread.stateRef.set(WorkloadRunnerThreadState.COMPLETED_SUCCEEDED); + } + @Override public boolean cancel(boolean mayInterruptIfRunning) { // After this method returns, subsequent calls to isDone will always return true @@ -172,9 +213,9 @@ public class WorkloadRunner { default: // Fail because task has already completed throw new IllegalStateException( - format("Unrecognized %s: %s", - workloadRunnerThread.state().getClass().getSimpleName(), - workloadRunnerThread.state()) + format("Unrecognized %s: %s", + workloadRunnerThread.state().getClass().getSimpleName(), + workloadRunnerThread.state()) ); } } @@ -188,7 +229,7 @@ public class WorkloadRunner { public boolean isDone() { if (!isDone) { if (workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_FAILED) - || workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_SUCCEEDED)) { + || workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_SUCCEEDED)) { isDone = true; } } @@ -211,7 +252,7 @@ public class WorkloadRunner { @Override public ConcurrentErrorReporter get(long timeout, TimeUnit unit) - throws InterruptedException, ExecutionException, TimeoutException { + throws InterruptedException, ExecutionException, TimeoutException { if (isCancelled || isDone) { throw new IllegalStateException("Can not call method after future has been cancelled or completed"); } @@ -226,9 +267,9 @@ public class WorkloadRunner { switch (workloadRunnerThread.state()) { case NOT_STARTED: throw new IllegalStateException(format( - "%s is in %s state, but should have already started", - WorkloadRunnerThread.class.getSimpleName(), - WorkloadRunnerThreadState.NOT_STARTED.name() + "%s is in %s state, but should have already started", + WorkloadRunnerThread.class.getSimpleName(), + WorkloadRunnerThreadState.NOT_STARTED.name() )); case RUNNING: Spinner.powerNap(RUNNER_POLLING_INTERVAL_AS_MILLI); @@ -239,9 +280,9 @@ public class WorkloadRunner { return; default: throw new IllegalStateException(format( - "Unknown %s: %s", - WorkloadRunnerThreadState.class.getSimpleName(), - WorkloadRunnerThreadState.NOT_STARTED.name() + "Unknown %s: %s", + WorkloadRunnerThreadState.class.getSimpleName(), + WorkloadRunnerThreadState.NOT_STARTED.name() )); } } @@ -272,7 +313,7 @@ public class WorkloadRunner { long spinnerSleepDurationAsMilli, boolean ignoreScheduleStartTimes, int operationHandlerExecutorsBoundedQueueSize) - throws WorkloadException, MetricsCollectionException { + throws WorkloadException, MetricsCollectionException { this.errorReporter = errorReporter; this.statusDisplayIntervalAsMilli = statusDisplayIntervalAsSeconds; @@ -280,11 +321,11 @@ public class WorkloadRunner { if (statusDisplayIntervalAsSeconds > 0) { this.workloadStatusThread = new WorkloadStatusThread( - TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds), - metricsService.getWriter(), - errorReporter, - completionTimeService, - loggingServiceFactory + TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds), + metricsService.getWriter(), + errorReporter, + completionTimeService, + loggingServiceFactory ); } // only create a completion time writer for an executor if it contains at least one READ_WRITE operation @@ -293,29 +334,29 @@ public class WorkloadRunner { CompletionTimeWriter completionTimeWriterForAsynchronous; try { completionTimeWriterForAsynchronous = (asynchronousStream.dependencyOperations().hasNext()) - ? completionTimeService.newCompletionTimeWriter() - : DUMMY_COMPLETION_TIME_WRITER; + ? completionTimeService.newCompletionTimeWriter() + : DUMMY_COMPLETION_TIME_WRITER; } catch (CompletionTimeException e) { throw new WorkloadException("Error while attempting to create completion time writer", e); } this.executorForAsynchronous = new ThreadPoolOperationExecutor( - threadCount, - operationHandlerExecutorsBoundedQueueSize, - db, - asynchronousStream, - completionTimeWriterForAsynchronous, - completionTimeService, - spinner, - timeSource, - errorReporter, - metricsService, - asynchronousStream.childOperationGenerator() + threadCount, + operationHandlerExecutorsBoundedQueueSize, + db, + asynchronousStream, + completionTimeWriterForAsynchronous, + completionTimeService, + spinner, + timeSource, + errorReporter, + metricsService, + asynchronousStream.childOperationGenerator() ); this.asynchronousStreamExecutorService = new OperationStreamExecutorService( - errorReporter, - asynchronousStream, - executorForAsynchronous, - completionTimeWriterForAsynchronous + errorReporter, + asynchronousStream, + executorForAsynchronous, + completionTimeWriterForAsynchronous ); /*for ( WorkloadStreams.WorkloadStreamDefinition blockingStream : workloadStreams.blockingStreamDefinitions() ) @@ -420,17 +461,17 @@ public class WorkloadRunner { // // if normal shutdown all executors have completed by this stage long shutdownWait = (shutdownType.equals(ShutdownType.FORCED)) - ? 1 - : OperationStreamExecutorService.SHUTDOWN_WAIT_TIMEOUT_AS_MILLI; + ? 1 + : OperationStreamExecutorService.SHUTDOWN_WAIT_TIMEOUT_AS_MILLI; try { asynchronousStreamExecutorService.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while shutting down %s\n%s\n", - asynchronousStreamExecutorService.getClass().getSimpleName(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while shutting down %s\n%s\n", + asynchronousStreamExecutorService.getClass().getSimpleName(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } @@ -439,10 +480,10 @@ public class WorkloadRunner { blockingStreamExecutorService.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while shutting down %s\n%s\n", - blockingStreamExecutorService.getClass().getSimpleName(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while shutting down %s\n%s\n", + blockingStreamExecutorService.getClass().getSimpleName(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } } @@ -454,12 +495,12 @@ public class WorkloadRunner { executorForAsynchronous.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while waiting for asynchronous executor to shutdown\n" - + "Handlers still running: %s\n" - + "%s", - executorForAsynchronous.uncompletedOperationHandlerCount(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while waiting for asynchronous executor to shutdown\n" + + "Handlers still running: %s\n" + + "%s", + executorForAsynchronous.uncompletedOperationHandlerCount(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } @@ -476,12 +517,12 @@ public class WorkloadRunner { uncompletedOperationHandlerCount += executorForBlocking.uncompletedOperationHandlerCount(); } errorReporter.reportError( - this, - format("Encountered error while waiting for a synchronous executor to shutdown\n" - + "Handlers still running: %s\n" - + "%s", - uncompletedOperationHandlerCount, - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while waiting for a synchronous executor to shutdown\n" + + "Handlers still running: %s\n" + + "%s", + uncompletedOperationHandlerCount, + ConcurrentErrorReporter.stackTraceToString(e)) ); } diff --git a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java index 624a727..853d23b 100644 --- a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java +++ b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java @@ -27,6 +27,34 @@ public class ResultsLogValidationResult { } private boolean aboveThreshold = false; + private Double onTimeRatio; + private Double throughput; + private Long operationCount; + + public void computeOnTimeRatio(Long excessiveDelayCount) { + onTimeRatio = (double) excessiveDelayCount / operationCount; + onTimeRatio = (1 - onTimeRatio) * 100; + } + + public Double onTimeRatio() { + return onTimeRatio; + } + + public void setThroughput(Double throughput) { + this.throughput = throughput; + } + + public Double throughput() { + return throughput; + } + + public void setOperationCount(Long operationCount) { + this.operationCount = operationCount; + } + + public Long operationCount() { + return operationCount; + } public static class ValidationError { private final ValidationErrorType errorType; diff --git a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java index 8c27724..c017e11 100644 --- a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java +++ b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java @@ -47,10 +47,10 @@ public class ResultsLogValidator { * @return ResultsLogValidationResult containing the list of delayed operations */ public ResultsLogValidationResult validate( - ResultsLogValidationSummary summary, - ResultsLogValidationTolerances tolerances, - boolean recordDelayedOperations, - WorkloadResultsSnapshot workloadResults) { + ResultsLogValidationSummary summary, + ResultsLogValidationTolerances tolerances, + boolean recordDelayedOperations, + WorkloadResultsSnapshot workloadResults) { ResultsLogValidationResult result = new ResultsLogValidationResult(); @@ -59,25 +59,74 @@ public class ResultsLogValidator { operationCountPerTypeMap.put(metric.name(), metric.count()); } - for (String operationType : summary.excessiveDelayCountPerType().keySet()) { + for (String operationType : summary.excessiveDelayCountPerType() + .keySet()) { + Long cnt = operationCountPerTypeMap.get(operationType); long allowedLateOperations = Math.round( - operationCountPerTypeMap.get(operationType) * tolerances.toleratedExcessiveDelayCountPercentage()); + (cnt == null ? 0 : cnt) * tolerances.toleratedExcessiveDelayCountPercentage()); if (recordDelayedOperations - && summary.excessiveDelayCountPerType().get(operationType) > allowedLateOperations) { + && summary.excessiveDelayCountPerType() + .get(operationType) > allowedLateOperations) { result.aboveThreshold(); result.addError( - ValidationErrorType.TOO_MANY_LATE_OPERATIONS, - format("Late Count for %s (%s) > (%s) Tolerated Late Count", - operationType, - summary.excessiveDelayCountPerType().get(operationType), - allowedLateOperations - ) + ValidationErrorType.TOO_MANY_LATE_OPERATIONS, + format("Late Count for %s (%s) > (%s) Tolerated Late Count", + operationType, + summary.excessiveDelayCountPerType() + .get(operationType), + allowedLateOperations + ) ); } } return result; } + /** + * validate Method Automation beta + */ + public ResultsLogValidationResult validateAutomatic( + ResultsLogValidationSummary summary, + ResultsLogValidationTolerances tolerances, + WorkloadResultsSnapshot workloadResults) { + + ResultsLogValidationResult result = new ResultsLogValidationResult(); + + Map operationCountPerTypeMap = new HashMap<>(); + for (OperationMetricsSnapshot metric : workloadResults.allMetrics()) { + operationCountPerTypeMap.put(metric.name(), metric.count()); + } + + for (String operationType : summary.excessiveDelayCountPerType() + .keySet()) { + Long cnt = operationCountPerTypeMap.get(operationType); + long allowedLateOperations = Math.round( + (cnt == null ? 0 : cnt) * tolerances.toleratedExcessiveDelayCountPercentage()); + if (summary.excessiveDelayCountPerType() + .get(operationType) > allowedLateOperations) { + result.addError( + ValidationErrorType.TOO_MANY_LATE_OPERATIONS, + format("Late Count for %s (%s) > (%s) Tolerated Late Count", + operationType, + summary.excessiveDelayCountPerType() + .get(operationType), + allowedLateOperations + ) + ); + } + } + + result.setThroughput(workloadResults.throughput()); + result.setOperationCount(workloadResults.totalOperationCount()); + // Determine whether time out + if (summary.excessiveDelayCount() > tolerances.toleratedExcessiveDelayCount()) { + result.aboveThreshold(); + } + // Calculated timeliness + result.computeOnTimeRatio(summary.excessiveDelayCount()); + return result; + } + /** * Loads the benchmark result file and uses the ResultsLogValidationSummaryCalculator to record delayed * operations. @@ -87,17 +136,18 @@ public class ResultsLogValidator { * @return Summary of the delayed operations in a ResultsLogValidationSummary object * @throws ValidationException When the result CSV file could not be opened or invalid delay is computed. */ - public ResultsLogValidationSummary compute(File resultsLog, long excessiveDelayThresholdAsMilli) - throws ValidationException { + public ResultsLogValidationSummary compute(File resultsLog, + long excessiveDelayThresholdAsMilli) + throws ValidationException { long maxDelayAsMilli = maxDelayAsMilli(resultsLog); ResultsLogValidationSummaryCalculator calculator = new ResultsLogValidationSummaryCalculator( - maxDelayAsMilli, - excessiveDelayThresholdAsMilli + maxDelayAsMilli, + excessiveDelayThresholdAsMilli ); try (SimpleCsvFileReader reader = new SimpleCsvFileReader( - resultsLog, - SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { + resultsLog, + SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { // skip headers reader.next(); while (reader.hasNext()) { @@ -127,8 +177,8 @@ public class ResultsLogValidator { private long maxDelayAsMilli(File resultsLog) throws ValidationException { long maxDelayAsMilli = 0; try (SimpleCsvFileReader reader = new SimpleCsvFileReader( - resultsLog, - SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { + resultsLog, + SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { // skip headers reader.next(); while (reader.hasNext()) { @@ -141,15 +191,16 @@ public class ResultsLogValidator { long delayAsMilli = actualStartTimeAsMilli - scheduledStartTimeAsMilli; if (delayAsMilli < 0) { throw new ValidationException( - format("Delay can not be negative\n" + "Delay: %s (ms) / %s\n" - + "Scheduled Start Time: %s (ms) / %s\n" + "Actual Start Time: %s (ms) / %s", - delayAsMilli, - TEMPORAL_UTIL.milliDurationToString(delayAsMilli), - scheduledStartTimeAsMilli, - TEMPORAL_UTIL.milliTimeToTimeString(scheduledStartTimeAsMilli), - actualStartTimeAsMilli, - TEMPORAL_UTIL.milliTimeToTimeString(actualStartTimeAsMilli) - ) + format("Delay can not be negative\n" + "Delay: %s (ms) / %s\n" + + "Scheduled Start Time: %s (ms) / %s\n" + + "Actual Start Time: %s (ms) / %s", + delayAsMilli, + TEMPORAL_UTIL.milliDurationToString(delayAsMilli), + scheduledStartTimeAsMilli, + TEMPORAL_UTIL.milliTimeToTimeString(scheduledStartTimeAsMilli), + actualStartTimeAsMilli, + TEMPORAL_UTIL.milliTimeToTimeString(actualStartTimeAsMilli) + ) ); } if (delayAsMilli > maxDelayAsMilli) { diff --git a/src/main/resources/example/ldbc_finbench_automatic_test_dummy.properties b/src/main/resources/example/ldbc_finbench_automatic_test_dummy.properties new file mode 100644 index 0000000..aff3eb6 --- /dev/null +++ b/src/main/resources/example/ldbc_finbench_automatic_test_dummy.properties @@ -0,0 +1,107 @@ +############################################################ +# SUT defined configurations # +############################################################ +host=localhost +port=9091 +user=admin +pass=123456 +path=cypher/ +############################################################ +# Driver configurations # +############################################################ +# Quickly estimate the duration of each test in the phase (millisecond). +# if -1, the operation to complete the number of warmup is finished +estimate=300000 +# The duration of each test in the precise tuning phase (millisecond). +# if -1, the operation to complete the number of operation_count is finished +accurate=7200000 +# Binary end condition, tolerance range +error_range=1E-5 +# Minimum time compression ratio limit +tcr_min=1E-9 +# Maximum time compression ratio limit +tcr_max=1 +# Specifies the fraction of the delay threshold that is allowed to be exceeded +timeout_rate=0.05 +# The ratio on the first test +time_compression_ratio=0.1 +status=1 +thread_count=1 +name=LDBC-FinBench +# Modes available: 1.CREATE_VALIDATION 2.VALIDATE_DATABASE 3.EXECUTE_BENCHMARK 4.AUTOMATIC_TEST +mode=AUTOMATIC_TEST +results_log=true +time_unit=MICROSECONDS +peer_identifiers= +workload_statistics=false +spinner_wait_duration=1 +help=false +ignore_scheduled_start_times=false +workload=org.ldbcouncil.finbench.driver.workloads.transaction.LdbcFinBenchTransactionWorkload +db=org.ldbcouncil.finbench.impls.dummy.DummyDb +operation_count=100000 +validation_parameters_size=1000 +validate_workload=true +validate_database=validation_params.csv +warmup=5 +graphybench.transaction.queries.parameters_dir=src/main/resources/example/data/read_params +graphybench.transaction.queries.updates_dir=src/main/resources/example/data/incremental +# param and update files suffix, `csv` or `parquet`, default is `csv` +graphybench.transaction.queries.files_suffix=csv +graphybench.transaction.queries.simple_read_dissipation=0.2 +graphybench.transaction.queries.update_interleave=10000000 +graphybench.transaction.queries.scale_factor=1 +# Frequency of complex read queries +graphybench.transaction.queries.ComplexRead1_freq=1 +graphybench.transaction.queries.ComplexRead2_freq=1 +graphybench.transaction.queries.ComplexRead3_freq=1 +graphybench.transaction.queries.ComplexRead4_freq=1 +graphybench.transaction.queries.ComplexRead5_freq=1 +graphybench.transaction.queries.ComplexRead6_freq=1 +graphybench.transaction.queries.ComplexRead7_freq=1 +graphybench.transaction.queries.ComplexRead8_freq=1 +graphybench.transaction.queries.ComplexRead9_freq=1 +graphybench.transaction.queries.ComplexRead10_freq=1 +graphybench.transaction.queries.ComplexRead11_freq=1 +graphybench.transaction.queries.ComplexRead12_freq=1 +# For debugging purposes +graphybench.transaction.queries.ComplexRead1_enable=true +graphybench.transaction.queries.ComplexRead2_enable=true +graphybench.transaction.queries.ComplexRead3_enable=true +graphybench.transaction.queries.ComplexRead4_enable=true +graphybench.transaction.queries.ComplexRead5_enable=true +graphybench.transaction.queries.ComplexRead6_enable=true +graphybench.transaction.queries.ComplexRead7_enable=true +graphybench.transaction.queries.ComplexRead8_enable=true +graphybench.transaction.queries.ComplexRead9_enable=true +graphybench.transaction.queries.ComplexRead10_enable=true +graphybench.transaction.queries.ComplexRead11_enable=true +graphybench.transaction.queries.ComplexRead12_enable=true +graphybench.transaction.queries.SimpleRead1_enable=true +graphybench.transaction.queries.SimpleRead2_enable=true +graphybench.transaction.queries.SimpleRead3_enable=true +graphybench.transaction.queries.SimpleRead4_enable=true +graphybench.transaction.queries.SimpleRead5_enable=true +graphybench.transaction.queries.SimpleRead6_enable=true +graphybench.transaction.queries.Write1_enable=true +graphybench.transaction.queries.Write2_enable=true +graphybench.transaction.queries.Write3_enable=true +graphybench.transaction.queries.Write4_enable=true +graphybench.transaction.queries.Write5_enable=true +graphybench.transaction.queries.Write6_enable=true +graphybench.transaction.queries.Write7_enable=true +graphybench.transaction.queries.Write8_enable=true +graphybench.transaction.queries.Write9_enable=true +graphybench.transaction.queries.Write10_enable=true +graphybench.transaction.queries.Write11_enable=true +graphybench.transaction.queries.Write12_enable=true +graphybench.transaction.queries.Write13_enable=true +graphybench.transaction.queries.Write14_enable=true +graphybench.transaction.queries.Write15_enable=true +graphybench.transaction.queries.Write16_enable=true +graphybench.transaction.queries.Write17_enable=true +graphybench.transaction.queries.Write18_enable=true +graphybench.transaction.queries.Write19_enable=true +graphybench.transaction.queries.ReadWrite1_enable=true +graphybench.transaction.queries.ReadWrite2_enable=true +graphybench.transaction.queries.ReadWrite3_enable=true \ No newline at end of file diff --git a/src/main/resources/example/ldbc_finbench_driver_dummy.properties b/src/main/resources/example/ldbc_finbench_driver_dummy.properties index 5204539..50eb2ea 100644 --- a/src/main/resources/example/ldbc_finbench_driver_dummy.properties +++ b/src/main/resources/example/ldbc_finbench_driver_dummy.properties @@ -12,7 +12,7 @@ path=cypher/ status=1 thread_count=1 name=GraphyBench -# Modes available: 1.CREATE_VALIDATION 2.VALIDATE_DATABASE 3.EXECUTE_BENCHMARK +# Modes available: 1.CREATE_VALIDATION 2.VALIDATE_DATABASE 3.EXECUTE_BENCHMARK 4.AUTOMATIC_TEST mode=EXECUTE_BENCHMARK results_log=true time_unit=MICROSECONDS -- Gitee From 283e511af0a33867019766e0f5b8af9dd2352b36 Mon Sep 17 00:00:00 2001 From: tongbing Date: Tue, 15 Apr 2025 11:46:24 +0800 Subject: [PATCH 2/4] update format about tab --- .../org/graphybench/driver/driver/Db.java | 32 +- .../graphybench/driver/driver/Workload.java | 32 +- .../ConsoleAndFileDriverConfiguration.java | 667 ++++++------------ .../driver/driver/AutomaticTestMode.java | 596 ++++++++++++++++ .../driver/driver/driver/Driver.java | 16 +- .../driver/driver/ExecuteWorkloadMode.java | 252 +++---- .../driver/driver/runtime/WorkloadRunner.java | 208 +++--- .../validation/ResultsLogValidator.java | 60 +- 8 files changed, 1085 insertions(+), 778 deletions(-) create mode 100644 src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java diff --git a/src/main/java/org/graphybench/driver/driver/Db.java b/src/main/java/org/graphybench/driver/driver/Db.java index 56c3fa6..30072e7 100644 --- a/src/main/java/org/graphybench/driver/driver/Db.java +++ b/src/main/java/org/graphybench/driver/driver/Db.java @@ -36,17 +36,17 @@ public abstract class Db implements Closeable { private OperationHandlerRunnerFactory operationHandlerRunnableContextFactory = null; public final synchronized void init( - Map params, - LoggingService loggingService, - Map> operationTypeToClassMapping) - throws DbException { + Map params, + LoggingService loggingService, + Map> operationTypeToClassMapping) + throws DbException { if (isInitialized) { throw new DbException("DB may be initialized only once"); } onInit(params, loggingService); dbConnectionState = getConnectionState(); operationHandlerRunnableContextFactory = new PoolingOperationHandlerRunnerFactory( - new InstantiatingOperationHandlerRunnerFactory() + new InstantiatingOperationHandlerRunnerFactory() ); operationHandlersArray = toOperationHandlerArray(operationTypeToClassMapping, operationHandlers); operationHandlers = null; @@ -81,7 +81,7 @@ public abstract class Db implements Closeable { throw new DbException("Error shutting down operation handler runnable factory", e); } operationHandlerRunnableContextFactory = new PoolingOperationHandlerRunnerFactory( - new InstantiatingOperationHandlerRunnerFactory() + new InstantiatingOperationHandlerRunnerFactory() ); } @@ -102,7 +102,7 @@ public abstract class Db implements Closeable { protected abstract void onClose() throws IOException; public final > void registerOperationHandler( - Class operationType, Class operationHandlerType) throws DbException { + Class operationType, Class operationHandlerType) throws DbException { if (operationHandlers.containsKey(operationType)) { throw new DbException(format("Client already has handler registered for %s", operationType.getClass())); } @@ -111,23 +111,23 @@ public abstract class Db implements Closeable { operationHandlers.put(operationType, operationHandler); } catch (OperationException e) { throw new DbException( - format("%s could not instantiate instance of %s", - getClass().getSimpleName(), - operationHandlerType.getSimpleName() - ), - e); + format("%s could not instantiate instance of %s", + getClass().getSimpleName(), + operationHandlerType.getSimpleName() + ), + e); } } public final OperationHandlerRunnableContext getOperationHandlerRunnableContext(Operation operation) - throws DbException { + throws DbException { OperationHandler operationHandler = operationHandlersArray[operation.type()]; if (null == operationHandler) { throw new DbException(format("No handler registered for %s", operation.getClass())); } try { OperationHandlerRunnableContext operationHandlerRunnableContext = - operationHandlerRunnableContextFactory.newOperationHandlerRunner(); + operationHandlerRunnableContextFactory.newOperationHandlerRunner(); operationHandlerRunnableContext.setOperationHandler(operationHandler); operationHandlerRunnableContext.setDbConnectionState(dbConnectionState); return operationHandlerRunnableContext; @@ -137,8 +137,8 @@ public abstract class Db implements Closeable { } private static OperationHandler[] toOperationHandlerArray( - Map> operationTypeToClassMapping, - Map, OperationHandler> operationHandlers) throws DbException { + Map> operationTypeToClassMapping, + Map, OperationHandler> operationHandlers) throws DbException { if (operationTypeToClassMapping.isEmpty()) { return new OperationHandler[] {}; } else { diff --git a/src/main/java/org/graphybench/driver/driver/Workload.java b/src/main/java/org/graphybench/driver/driver/Workload.java index 82efa8c..4f5320a 100644 --- a/src/main/java/org/graphybench/driver/driver/Workload.java +++ b/src/main/java/org/graphybench/driver/driver/Workload.java @@ -44,8 +44,8 @@ public abstract class Workload implements Closeable { * @return */ public ResultsLogValidationTolerances resultsLogValidationTolerances( - DriverConfiguration configuration, - boolean warmup + DriverConfiguration configuration, + boolean warmup ) { long excessiveDelayThresholdAsMilli = TimeUnit.SECONDS.toMillis(1); // Specifies the fraction of the delay threshold that is allowed to be exceeded @@ -76,9 +76,9 @@ public abstract class Workload implements Closeable { // Total tolerated excessive delay count long toleratedExcessiveDelayCount = Math.round(operationCount * toleratedExcessiveDelayCountPercentage); return new ResultsLogValidationTolerances( - excessiveDelayThresholdAsMilli, - toleratedExcessiveDelayCount, - toleratedExcessiveDelayCountPercentage + excessiveDelayThresholdAsMilli, + toleratedExcessiveDelayCount, + toleratedExcessiveDelayCountPercentage ); } @@ -120,7 +120,7 @@ public abstract class Workload implements Closeable { } protected abstract WorkloadStreams getStreams(GeneratorFactory generators, boolean hasDbConnected) - throws WorkloadException; + throws WorkloadException; public DbValidationParametersFilter dbValidationParametersFilter(final Integer requiredValidationParameterCount) { return new DbValidationParametersFilter() { @@ -134,18 +134,18 @@ public abstract class Workload implements Closeable { @Override public DbValidationParametersFilterResult useOperationAndResultForValidation( - Operation operation, - Object operationResult) { + Operation operation, + Object operationResult) { if (validationParameterCount < requiredValidationParameterCount) { validationParameterCount++; return new DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance.ACCEPT_AND_CONTINUE, - injectedOperations + DbValidationParametersFilterAcceptance.ACCEPT_AND_CONTINUE, + injectedOperations ); } else { return new DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance.REJECT_AND_FINISH, - injectedOperations + DbValidationParametersFilterAcceptance.REJECT_AND_FINISH, + injectedOperations ); } } @@ -162,8 +162,8 @@ public abstract class Workload implements Closeable { boolean useOperation(Operation operation); DbValidationParametersFilterResult useOperationAndResultForValidation( - Operation operation, - Object operationResult); + Operation operation, + Object operationResult); } public enum DbValidationParametersFilterAcceptance { @@ -178,8 +178,8 @@ public abstract class Workload implements Closeable { private final List injectedOperations; public DbValidationParametersFilterResult( - DbValidationParametersFilterAcceptance acceptance, - List injectedOperations) { + DbValidationParametersFilterAcceptance acceptance, + List injectedOperations) { this.acceptance = acceptance; this.injectedOperations = injectedOperations; } diff --git a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java index 0344e7b..5ed85bc 100644 --- a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java +++ b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java @@ -72,11 +72,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String IGNORE_SCHEDULED_START_TIMES_ARG = "ignore_scheduled_start_times"; public static final boolean IGNORE_SCHEDULED_START_TIMES_DEFAULT = false; public static final String IGNORE_SCHEDULED_START_TIMES_DEFAULT_STRING = - Boolean.toString(IGNORE_SCHEDULED_START_TIMES_DEFAULT); + Boolean.toString(IGNORE_SCHEDULED_START_TIMES_DEFAULT); public static final String RECORD_DELAYED_OPERATIONS_ARG = "log_delayed"; public static final boolean RECORD_DELAYED_OPERATIONS_DEFAULT = true; public static final String RECORD_DELAYED_OPERATIONS_DEFAULT_STRING = - Boolean.toString(RECORD_DELAYED_OPERATIONS_DEFAULT); + Boolean.toString(RECORD_DELAYED_OPERATIONS_DEFAULT); public static final String HELP_ARG = "help"; public static final boolean HELP_DEFAULT = false; public static final String HELP_DEFAULT_STRING = Boolean.toString(HELP_DEFAULT); @@ -84,7 +84,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final boolean FLUSH_LOG_DEFAULT = false; public static final String FLUSH_LOG_DEFAULT_STRING = Boolean.toString(FLUSH_LOG_DEFAULT); public static final String NAME_ARG = "nm"; - public static final String NAME_DEFAULT = "LDBC"; + public static final String NAME_DEFAULT = ""; public static final String NAME_DEFAULT_STRING = NAME_DEFAULT; public static final String RESULT_DIR_PATH_ARG = "rd"; public static final String RESULT_DIR_PATH_DEFAULT = "results"; @@ -104,7 +104,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String VALIDATION_SERIALIZATION_CHECK_ARG = "vsc"; public static final Boolean VALIDATION_SERIALIZATION_CHECK_DEFAULT = true; public static final String VALIDATION_SERIALIZATION_CHECK_DEFAULT_STRING = - Boolean.toString(VALIDATION_SERIALIZATION_CHECK_DEFAULT); + Boolean.toString(VALIDATION_SERIALIZATION_CHECK_DEFAULT); public static final String TIME_UNIT_ARG = "tu"; public static final TimeUnit TIME_UNIT_DEFAULT = TimeUnit.MILLISECONDS; public static final String TIME_UNIT_DEFAULT_STRING = TIME_UNIT_DEFAULT.toString(); @@ -160,29 +160,29 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String PROPERTY_FILE_ARG = "P"; public static final String PROPERTY_ARG = "p"; private static final String THREADS_DESCRIPTION = - format("number of worker threads to execute with (default: %s)", THREADS_DEFAULT_STRING); - private static final String SKIP_COUNT_DESCRIPTION = format( - "number of operations to skip over before beginning execution (default: %s)", SKIP_COUNT_DEFAULT_STRING); + format("number of worker threads to execute with (default: %s)", THREADS_DEFAULT_STRING); + private static final String SKIP_COUNT_DESCRIPTION = + format("number of operations to skip over before beginning execution (default: %s)", SKIP_COUNT_DEFAULT_STRING); private static final String WARMUP_COUNT_DESCRIPTION = - format("number of operations to execute during warmup phase (default: %s)", WARMUP_COUNT_DEFAULT_STRING); + format("number of operations to execute during warmup phase (default: %s)", WARMUP_COUNT_DEFAULT_STRING); private static final TemporalUtil TEMPORAL_UTIL = new TemporalUtil(); private static final DecimalFormat INTEGRAL_FORMAT = new DecimalFormat("###,###,###,###,###"); private static final DecimalFormat FLOAT_FORMAT = new DecimalFormat("###,###,###,###,##0.0000000"); private static final String MODE_ARG_LONG = "mode"; private static final String MODE_DESCRIPTION = - "mode the driver should execute (e.g. CREATE_VALIDATION, VALIDATE_DATABASE, CREATE_STATISTICS, " - + "EXECUTE_BENCHMARK)"; + "mode the driver should execute (e.g. CREATE_VALIDATION, VALIDATE_DATABASE, CREATE_STATISTICS, " + + "EXECUTE_BENCHMARK)"; private static final String OPERATION_COUNT_ARG_LONG = "operation_count"; private static final String OPERATION_COUNT_DESCRIPTION = "number of operations to execute"; private static final String WORKLOAD_ARG_LONG = "workload"; private static final String WORKLOAD_EXAMPLE = SimpleWorkload.class.getName(); private static final String WORKLOAD_DESCRIPTION = - format("class name of the Workload to use (e.g. %s)", WORKLOAD_EXAMPLE); + format("class name of the Workload to use (e.g. %s)", WORKLOAD_EXAMPLE); private static final String DB_ARG_LONG = "database"; private static final String DB_EXAMPLE = SimpleDb.class.getName(); private static final String DB_DESCRIPTION = format("class name of the DB to use (e.g. %s)", DB_EXAMPLE); private static final String IGNORE_SCHEDULED_START_TIMES_DESCRIPTION = - "executes operations as fast as possible, ignoring their scheduled start times"; + "executes operations as fast as possible, ignoring their scheduled start times"; private static final String RECORD_DELAYED_OPERATIONS_DESCRIPTION = "print usage instruction"; private static final String HELP_DESCRIPTION = "print usage instruction"; private static final String FLUSH_LOG_DESCRIPTION = "flush log to disk after each operation"; @@ -190,31 +190,31 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { private static final String NAME_DESCRIPTION = format("name of the benchmark run. default = %s", NAME_DEFAULT); private static final String RESULT_DIR_PATH_ARG_LONG = "results_dir"; private static final String RESULT_DIR_PATH_DESCRIPTION = - format("directory where benchmark results will be written. default = %s", RESULT_DIR_PATH_DEFAULT); + format("directory where benchmark results will be written. default = %s", RESULT_DIR_PATH_DEFAULT); private static final String THREADS_ARG_LONG = "thread_count"; private static final String SHOW_STATUS_ARG_LONG = "status"; private static final String SHOW_STATUS_DESCRIPTION = - "interval between status printouts during benchmark execution (0 = disable)"; + "interval between status printouts during benchmark execution (0 = disable)"; private static final String DB_VALIDATION_FILE_PATH_ARG_LONG = "validate_database"; private static final String DB_VALIDATION_FILE_PATH_DESCRIPTION = - "path to validation parameters file, if provided database connector will be validated"; + "path to validation parameters file, if provided database connector will be validated"; private static final String VALIDATION_PARAMS_SIZE_ARG_LONG = "validation_parameters_size"; private static final String VALIDATION_PARAMS_SIZE_DESCRIPTION = "The size of validation set to create."; private static final String VALIDATION_SERIALIZATION_CHECK_ARG_LONG = "validation_parameters_serialization_check"; private static final String VALIDATION_SERIALIZATION_CHECK_DESCRIPTION = - "Check serialized queries and results by deserializing them and compare."; + "Check serialized queries and results by deserializing them and compare."; private static final String TIME_UNIT_ARG_LONG = "time_unit"; private static final TimeUnit[] VALID_TIME_UNITS = - new TimeUnit[]{TimeUnit.NANOSECONDS, TimeUnit.MICROSECONDS, TimeUnit.MILLISECONDS, TimeUnit.SECONDS, - TimeUnit.MINUTES}; + new TimeUnit[] {TimeUnit.NANOSECONDS, TimeUnit.MICROSECONDS, TimeUnit.MILLISECONDS, TimeUnit.SECONDS, + TimeUnit.MINUTES}; private static final String TIME_UNIT_DESCRIPTION = - format("time unit to use when gathering metrics. default:%s, valid:%s", TIME_UNIT_DEFAULT_STRING, - Arrays.toString(VALID_TIME_UNITS)); + format("time unit to use when gathering metrics. default:%s, valid:%s", TIME_UNIT_DEFAULT_STRING, + Arrays.toString(VALID_TIME_UNITS)); private static final String TIME_COMPRESSION_RATIO_ARG_LONG = "time_compression_ratio"; private static final String TIME_COMPRESSION_RATIO_DESCRIPTION = "change duration between operations of workload"; private static final String SPINNER_SLEEP_DURATION_ARG_LONG = "spinner_wait_duration"; private static final String SPINNER_SLEEP_DURATION_DESCRIPTION = - "sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)"; + "sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)"; private static final String SKIP_COUNT_ARG_LONG = "skip"; private static final String WARMUP_COUNT_ARG_LONG = "warmup"; public static final String ESTIMATE_TEST_TIME_ARG_LONG = "estimate"; @@ -224,10 +224,10 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public static final String TCR_MAX_ARG_LONG = "tcr_max"; public static final String TIMEOUT_RATE_ARG_LONG = "timeout_rate"; private static final String PROPERTY_FILE_DESCRIPTION = - "load properties from file(s) - files will be loaded in the order provided\n" - + "first files are highest priority; later values will not override earlier values"; + "load properties from file(s) - files will be loaded in the order provided\n" + + "first files are highest priority; later values will not override earlier values"; private static final String PROPERTY_DESCRIPTION = - "properties to be passed to DB and Workload - these will override properties loaded from files"; + "properties to be passed to DB and Workload - these will override properties loaded from files"; private static final char COMMANDLINE_SEPARATOR_CHAR = '|'; private static final Options OPTIONS = buildOptions(); private final Map paramsMap; @@ -431,10 +431,9 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { return missingParams; } - public static ConsoleAndFileDriverConfiguration fromDefaults(String databaseClassName, - String workloadClassName, + public static ConsoleAndFileDriverConfiguration fromDefaults(String databaseClassName, String workloadClassName, long operationCount) - throws DriverConfigurationException { + throws DriverConfigurationException { try { Map paramsMap = defaultsAsMap(); paramsMap.put(DB_ARG, databaseClassName); @@ -447,7 +446,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } public static ConsoleAndFileDriverConfiguration fromParamsMap(Map paramsMap) - throws DriverConfigurationException { + throws DriverConfigurationException { try { paramsMap = convertComplexKeysToSimpleKeys(paramsMap); @@ -468,7 +467,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { double timeCompressionRatio = Double.parseDouble(paramsMap.get(TIME_COMPRESSION_RATIO_ARG)); int validationParametersSize = Integer.parseInt(paramsMap.get(VALIDATION_PARAMS_SIZE_ARG)); boolean validationSerializationCheck = - Boolean.parseBoolean(paramsMap.get(VALIDATION_SERIALIZATION_CHECK_ARG)); + Boolean.parseBoolean(paramsMap.get(VALIDATION_SERIALIZATION_CHECK_ARG)); String databaseValidationFilePath = paramsMap.get(DB_VALIDATION_FILE_PATH_ARG); long spinnerSleepDurationAsMilli = Long.parseLong(paramsMap.get(SPINNER_SLEEP_DURATION_ARG)); long skipCount = Long.parseLong(paramsMap.get(SKIP_COUNT_ARG)); @@ -508,11 +507,11 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } } - private static Map parseArgs(String[] args, - Options options) - throws ParseException, DriverConfigurationException { + private static Map parseArgs(String[] args, Options options) + throws ParseException, DriverConfigurationException { Map cmdParams = new HashMap<>(); Map fileParams = new HashMap<>(); + CommandLineParser parser = new BasicParser(); CommandLine cmd = parser.parse(options, args); @@ -605,23 +604,22 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { Map tempFileParams = MapUtils.propertiesToMap(tempFileProperties); boolean overwrite = true; fileParams = - MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(tempFileParams), fileParams, overwrite); + MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(tempFileParams), fileParams, overwrite); } catch (IOException e) { throw new ParseException( - format("Error loading properties file %s\n%s", propertyFilePath, e.getMessage())); + format("Error loading properties file %s\n%s", propertyFilePath, e.getMessage())); } } } if (cmd.hasOption(PROPERTY_ARG)) { - for (Entry cmdProperty : cmd.getOptionProperties(PROPERTY_ARG) - .entrySet()) { + for (Entry cmdProperty : cmd.getOptionProperties(PROPERTY_ARG).entrySet()) { cmdParams.put((String) cmdProperty.getKey(), (String) cmdProperty.getValue()); } } boolean overwrite = true; return MapUtils.mergeMaps(convertComplexKeysToSimpleKeys(fileParams), convertComplexKeysToSimpleKeys(cmdParams), - overwrite); + overwrite); } public static Map convertComplexKeysToSimpleKeys(Map paramsMap) { @@ -652,9 +650,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { // NOTE: not safe in general case, no check for duplicate keys, i.e., if newKey already exists its value will be // overwritten - private static Map replaceKey(Map paramsMap, - String oldKey, - String newKey) { + private static Map replaceKey(Map paramsMap, String oldKey, String newKey) { if (!paramsMap.containsKey(oldKey)) { return paramsMap; } @@ -671,131 +667,84 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { * Required */ Option modeOption = - OptionBuilder.hasArgs(1) - .withArgName("mode") - .withDescription(MODE_DESCRIPTION) - .withLongOpt(MODE_ARG_LONG) - .create(MODE_ARG); + OptionBuilder.hasArgs(1).withArgName("mode").withDescription(MODE_DESCRIPTION).withLongOpt(MODE_ARG_LONG) + .create(MODE_ARG); options.addOption(modeOption); Option dbOption = - OptionBuilder.hasArgs(1) - .withArgName("classname") - .withDescription(DB_DESCRIPTION) - .withLongOpt(DB_ARG_LONG) - .create(DB_ARG); + OptionBuilder.hasArgs(1).withArgName("classname").withDescription(DB_DESCRIPTION).withLongOpt(DB_ARG_LONG) + .create(DB_ARG); options.addOption(dbOption); - Option workloadOption = OptionBuilder.hasArgs(1) - .withArgName("classname") - .withDescription(WORKLOAD_DESCRIPTION) - .withLongOpt(WORKLOAD_ARG_LONG) - .create(WORKLOAD_ARG); + Option workloadOption = OptionBuilder.hasArgs(1).withArgName("classname").withDescription(WORKLOAD_DESCRIPTION) + .withLongOpt(WORKLOAD_ARG_LONG).create(WORKLOAD_ARG); options.addOption(workloadOption); Option operationCountOption = - OptionBuilder.hasArgs(1) - .withArgName("count") - .withDescription(OPERATION_COUNT_DESCRIPTION) - .withLongOpt(OPERATION_COUNT_ARG_LONG) - .create(OPERATION_COUNT_ARG); + OptionBuilder.hasArgs(1).withArgName("count").withDescription(OPERATION_COUNT_DESCRIPTION) + .withLongOpt(OPERATION_COUNT_ARG_LONG).create(OPERATION_COUNT_ARG); options.addOption(operationCountOption); /* * Optional */ Option nameOption = - OptionBuilder.hasArgs(1) - .withArgName("name") - .withDescription(NAME_DESCRIPTION) - .withLongOpt(NAME_ARG_LONG) - .create(NAME_ARG); + OptionBuilder.hasArgs(1).withArgName("name").withDescription(NAME_DESCRIPTION).withLongOpt(NAME_ARG_LONG) + .create(NAME_ARG); options.addOption(nameOption); Option resultFileOption = - OptionBuilder.hasArgs(1) - .withArgName("path") - .withDescription(RESULT_DIR_PATH_DESCRIPTION) - .withLongOpt(RESULT_DIR_PATH_ARG_LONG) - .create(RESULT_DIR_PATH_ARG); + OptionBuilder.hasArgs(1).withArgName("path").withDescription(RESULT_DIR_PATH_DESCRIPTION) + .withLongOpt(RESULT_DIR_PATH_ARG_LONG).create(RESULT_DIR_PATH_ARG); options.addOption(resultFileOption); - Option threadsOption = OptionBuilder.hasArgs(1) - .withArgName("count") - .withDescription(THREADS_DESCRIPTION) - .withLongOpt(THREADS_ARG_LONG) - .create(THREADS_ARG); + Option threadsOption = OptionBuilder.hasArgs(1).withArgName("count").withDescription(THREADS_DESCRIPTION) + .withLongOpt(THREADS_ARG_LONG).create(THREADS_ARG); options.addOption(threadsOption); - Option statusOption = OptionBuilder.hasArgs(1) - .withArgName("seconds") - .withDescription(SHOW_STATUS_DESCRIPTION) - .withLongOpt(SHOW_STATUS_ARG_LONG) - .create(SHOW_STATUS_ARG); + Option statusOption = OptionBuilder.hasArgs(1).withArgName("seconds").withDescription(SHOW_STATUS_DESCRIPTION) + .withLongOpt(SHOW_STATUS_ARG_LONG).create(SHOW_STATUS_ARG); options.addOption(statusOption); - Option timeUnitOption = OptionBuilder.hasArgs(1) - .withArgName("unit") - .withDescription(TIME_UNIT_DESCRIPTION) - .withLongOpt(TIME_UNIT_ARG_LONG) - .create(TIME_UNIT_ARG); + Option timeUnitOption = OptionBuilder.hasArgs(1).withArgName("unit").withDescription(TIME_UNIT_DESCRIPTION) + .withLongOpt(TIME_UNIT_ARG_LONG).create(TIME_UNIT_ARG); options.addOption(timeUnitOption); Option timeCompressionRatioOption = - OptionBuilder.hasArgs(1) - .withArgName("ratio") - .withDescription(TIME_COMPRESSION_RATIO_DESCRIPTION) - .withLongOpt(TIME_COMPRESSION_RATIO_ARG_LONG) - .create(TIME_COMPRESSION_RATIO_ARG); + OptionBuilder.hasArgs(1).withArgName("ratio").withDescription(TIME_COMPRESSION_RATIO_DESCRIPTION) + .withLongOpt(TIME_COMPRESSION_RATIO_ARG_LONG).create(TIME_COMPRESSION_RATIO_ARG); options.addOption(timeCompressionRatioOption); Option validationSerializationOption = OptionBuilder.withDescription(VALIDATION_SERIALIZATION_CHECK_DESCRIPTION) - .withLongOpt(VALIDATION_SERIALIZATION_CHECK_ARG_LONG) - .create(VALIDATION_SERIALIZATION_CHECK_ARG); + .withLongOpt(VALIDATION_SERIALIZATION_CHECK_ARG_LONG).create(VALIDATION_SERIALIZATION_CHECK_ARG); options.addOption(validationSerializationOption); Option validationParamsSizeOption = - OptionBuilder.hasArgs(1) - .withArgName("count") - .withDescription(VALIDATION_PARAMS_SIZE_DESCRIPTION) - .withLongOpt(VALIDATION_PARAMS_SIZE_ARG_LONG) - .create(VALIDATION_PARAMS_SIZE_ARG); + OptionBuilder.hasArgs(1).withArgName("count").withDescription(VALIDATION_PARAMS_SIZE_DESCRIPTION) + .withLongOpt(VALIDATION_PARAMS_SIZE_ARG_LONG).create(VALIDATION_PARAMS_SIZE_ARG); options.addOption(validationParamsSizeOption); Option databaseValidationFilePathOption = - OptionBuilder.hasArgs(1) - .withArgName("path") - .withDescription(DB_VALIDATION_FILE_PATH_DESCRIPTION) - .withLongOpt(DB_VALIDATION_FILE_PATH_ARG_LONG) - .create(DB_VALIDATION_FILE_PATH_ARG); + OptionBuilder.hasArgs(1).withArgName("path").withDescription(DB_VALIDATION_FILE_PATH_DESCRIPTION) + .withLongOpt(DB_VALIDATION_FILE_PATH_ARG_LONG).create(DB_VALIDATION_FILE_PATH_ARG); options.addOption(databaseValidationFilePathOption); Option recordDelayedOperations = - OptionBuilder.withDescription(RECORD_DELAYED_OPERATIONS_DESCRIPTION) - .create(RECORD_DELAYED_OPERATIONS_ARG); + OptionBuilder.withDescription(RECORD_DELAYED_OPERATIONS_DESCRIPTION).create(RECORD_DELAYED_OPERATIONS_ARG); options.addOption(recordDelayedOperations); Option spinnerSleepDurationOption = - OptionBuilder.hasArgs(1) - .withArgName("duration") - .withDescription(SPINNER_SLEEP_DURATION_DESCRIPTION) - .withLongOpt(SPINNER_SLEEP_DURATION_ARG_LONG) - .create(SPINNER_SLEEP_DURATION_ARG); + OptionBuilder.hasArgs(1).withArgName("duration").withDescription(SPINNER_SLEEP_DURATION_DESCRIPTION) + .withLongOpt(SPINNER_SLEEP_DURATION_ARG_LONG).create(SPINNER_SLEEP_DURATION_ARG); options.addOption(spinnerSleepDurationOption); Option warmupCountOption = - OptionBuilder.hasArgs(1) - .withArgName("count") - .withDescription(WARMUP_COUNT_DESCRIPTION) - .withLongOpt(WARMUP_COUNT_ARG_LONG) - .create(WARMUP_COUNT_ARG); + OptionBuilder.hasArgs(1).withArgName("count").withDescription(WARMUP_COUNT_DESCRIPTION) + .withLongOpt(WARMUP_COUNT_ARG_LONG).create(WARMUP_COUNT_ARG); options.addOption(warmupCountOption); - Option skipCountOption = OptionBuilder.hasArgs(1) - .withArgName("count") - .withDescription(SKIP_COUNT_DESCRIPTION) - .withLongOpt(SKIP_COUNT_ARG_LONG) - .create(SKIP_COUNT_ARG); + Option skipCountOption = OptionBuilder.hasArgs(1).withArgName("count").withDescription(SKIP_COUNT_DESCRIPTION) + .withLongOpt(SKIP_COUNT_ARG_LONG).create(SKIP_COUNT_ARG); options.addOption(skipCountOption); Option estimateTestTimeOption = OptionBuilder.hasArgs(1) @@ -845,26 +794,21 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { options.addOption(printHelpOption); - Option flushOption = OptionBuilder.withDescription(FLUSH_LOG_DESCRIPTION) - .create(FLUSH_LOG_ARG); + Option flushOption = OptionBuilder.withDescription(FLUSH_LOG_DESCRIPTION).create(FLUSH_LOG_ARG); options.addOption(flushOption); Option ignoreScheduledStartTimesOption = OptionBuilder.withDescription(IGNORE_SCHEDULED_START_TIMES_DESCRIPTION) - .create(IGNORE_SCHEDULED_START_TIMES_ARG); + .create(IGNORE_SCHEDULED_START_TIMES_ARG); options.addOption(ignoreScheduledStartTimesOption); - Option propertyFileOption = OptionBuilder.hasArgs() - .withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) - .withArgName("file1" + COMMANDLINE_SEPARATOR_CHAR + "file2") - .withDescription(PROPERTY_FILE_DESCRIPTION) - .create(PROPERTY_FILE_ARG); + Option propertyFileOption = OptionBuilder.hasArgs().withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) + .withArgName("file1" + COMMANDLINE_SEPARATOR_CHAR + "file2").withDescription(PROPERTY_FILE_DESCRIPTION) + .create(PROPERTY_FILE_ARG); options.addOption(propertyFileOption); - Option propertyOption = OptionBuilder.hasArgs(2) - .withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) - .withArgName("key" + COMMANDLINE_SEPARATOR_CHAR + "value") - .withDescription(PROPERTY_DESCRIPTION) - .create(PROPERTY_ARG); + Option propertyOption = OptionBuilder.hasArgs(2).withValueSeparator(COMMANDLINE_SEPARATOR_CHAR) + .withArgName("key" + COMMANDLINE_SEPARATOR_CHAR + "value").withDescription(PROPERTY_DESCRIPTION) + .create(PROPERTY_ARG); options.addOption(propertyOption); return options; @@ -877,10 +821,9 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { */ private static Set coreConfigurationParameterKeys() { return Sets.newHashSet(MODE_ARG, NAME_ARG, DB_ARG, WORKLOAD_ARG, OPERATION_COUNT_ARG, THREADS_ARG, - SHOW_STATUS_ARG, TIME_UNIT_ARG, RESULT_DIR_PATH_ARG, TIME_COMPRESSION_RATIO_ARG, - VALIDATION_PARAMS_SIZE_ARG, - VALIDATION_SERIALIZATION_CHECK_ARG, DB_VALIDATION_FILE_PATH_ARG, SPINNER_SLEEP_DURATION_ARG, HELP_ARG, - IGNORE_SCHEDULED_START_TIMES_ARG, WARMUP_COUNT_ARG, SKIP_COUNT_ARG); + SHOW_STATUS_ARG, TIME_UNIT_ARG, RESULT_DIR_PATH_ARG, TIME_COMPRESSION_RATIO_ARG, VALIDATION_PARAMS_SIZE_ARG, + VALIDATION_SERIALIZATION_CHECK_ARG, DB_VALIDATION_FILE_PATH_ARG, SPINNER_SLEEP_DURATION_ARG, HELP_ARG, + IGNORE_SCHEDULED_START_TIMES_ARG, WARMUP_COUNT_ARG, SKIP_COUNT_ARG); } /** @@ -901,7 +844,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { PrintWriter writer = new PrintWriter(os); HelpFormatter helpFormatter = new HelpFormatter(); helpFormatter.printHelp(writer, printedRowWidth, commandLineSyntax, header, options, spacesBeforeOption, - spacesBeforeOptionDescription, footer, displayUsage); + spacesBeforeOptionDescription, footer, displayUsage); writer.flush(); writer.close(); return os.toString(); @@ -1090,61 +1033,60 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { Map newOtherParams = MapUtils.mergeMaps(this.paramsMap, newParamsMapWithSimpleKeys, true); String newMode = - (newParamsMapWithSimpleKeys.containsKey(MODE_ARG)) ? newParamsMapWithSimpleKeys.get(MODE_ARG) : mode; + (newParamsMapWithSimpleKeys.containsKey(MODE_ARG)) ? newParamsMapWithSimpleKeys.get(MODE_ARG) : mode; String newName = - (newParamsMapWithSimpleKeys.containsKey(NAME_ARG)) ? newParamsMapWithSimpleKeys.get(NAME_ARG) : name; + (newParamsMapWithSimpleKeys.containsKey(NAME_ARG)) ? newParamsMapWithSimpleKeys.get(NAME_ARG) : name; String newDbClassName = - (newParamsMapWithSimpleKeys.containsKey(DB_ARG)) ? newParamsMapWithSimpleKeys.get(DB_ARG) : dbClassName; + (newParamsMapWithSimpleKeys.containsKey(DB_ARG)) ? newParamsMapWithSimpleKeys.get(DB_ARG) : dbClassName; String newWorkloadClassName = - (newParamsMapWithSimpleKeys.containsKey(WORKLOAD_ARG)) ? newParamsMapWithSimpleKeys.get(WORKLOAD_ARG) - : workloadClassName; + (newParamsMapWithSimpleKeys.containsKey(WORKLOAD_ARG)) ? newParamsMapWithSimpleKeys.get(WORKLOAD_ARG) + : workloadClassName; long newOperationCount = (newParamsMapWithSimpleKeys.containsKey(OPERATION_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(OPERATION_COUNT_ARG)) : operationCount; + newParamsMapWithSimpleKeys.get(OPERATION_COUNT_ARG)) : operationCount; int newThreadCount = (newParamsMapWithSimpleKeys.containsKey(THREADS_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(THREADS_ARG)) : threadCount; + newParamsMapWithSimpleKeys.get(THREADS_ARG)) : threadCount; int newStatusDisplayIntervalAsSeconds = - (newParamsMapWithSimpleKeys.containsKey(SHOW_STATUS_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(SHOW_STATUS_ARG)) : statusDisplayIntervalAsSeconds; + (newParamsMapWithSimpleKeys.containsKey(SHOW_STATUS_ARG)) ? Integer.parseInt( + newParamsMapWithSimpleKeys.get(SHOW_STATUS_ARG)) : statusDisplayIntervalAsSeconds; TimeUnit newTimeUnit = (newParamsMapWithSimpleKeys.containsKey(TIME_UNIT_ARG)) ? TimeUnit.valueOf( - newParamsMapWithSimpleKeys.get(TIME_UNIT_ARG)) : timeUnit; + newParamsMapWithSimpleKeys.get(TIME_UNIT_ARG)) : timeUnit; String newResultDirPath = - (newParamsMapWithSimpleKeys.containsKey(RESULT_DIR_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( - RESULT_DIR_PATH_ARG) : resultDirPath; + (newParamsMapWithSimpleKeys.containsKey(RESULT_DIR_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( + RESULT_DIR_PATH_ARG) : resultDirPath; double newTimeCompressionRatio = - (newParamsMapWithSimpleKeys.containsKey(TIME_COMPRESSION_RATIO_ARG)) ? Double.parseDouble( - newParamsMapWithSimpleKeys.get(TIME_COMPRESSION_RATIO_ARG)) : timeCompressionRatio; + (newParamsMapWithSimpleKeys.containsKey(TIME_COMPRESSION_RATIO_ARG)) ? Double.parseDouble( + newParamsMapWithSimpleKeys.get(TIME_COMPRESSION_RATIO_ARG)) : timeCompressionRatio; int newValidationParametersSize = - (newParamsMapWithSimpleKeys.containsKey(VALIDATION_PARAMS_SIZE_ARG)) ? Integer.parseInt( - newParamsMapWithSimpleKeys.get(VALIDATION_PARAMS_SIZE_ARG)) : validationParametersSize; + (newParamsMapWithSimpleKeys.containsKey(VALIDATION_PARAMS_SIZE_ARG)) ? Integer.parseInt( + newParamsMapWithSimpleKeys.get(VALIDATION_PARAMS_SIZE_ARG)) : validationParametersSize; boolean newValidationSerializationCheck = - (newParamsMapWithSimpleKeys.containsKey(VALIDATION_SERIALIZATION_CHECK_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(VALIDATION_SERIALIZATION_CHECK_ARG)) : - validationSerializationCheck; + (newParamsMapWithSimpleKeys.containsKey(VALIDATION_SERIALIZATION_CHECK_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(VALIDATION_SERIALIZATION_CHECK_ARG)) : validationSerializationCheck; String newDatabaseValidationFilePath = - (newParamsMapWithSimpleKeys.containsKey(DB_VALIDATION_FILE_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( - DB_VALIDATION_FILE_PATH_ARG) : databaseValidationFilePath; + (newParamsMapWithSimpleKeys.containsKey(DB_VALIDATION_FILE_PATH_ARG)) ? newParamsMapWithSimpleKeys.get( + DB_VALIDATION_FILE_PATH_ARG) : databaseValidationFilePath; long newSpinnerSleepDurationAsMilli = - (newParamsMapWithSimpleKeys.containsKey(SPINNER_SLEEP_DURATION_ARG)) ? Long.parseLong( - (newParamsMapWithSimpleKeys.get(SPINNER_SLEEP_DURATION_ARG))) : spinnerSleepDurationAsMilli; + (newParamsMapWithSimpleKeys.containsKey(SPINNER_SLEEP_DURATION_ARG)) ? Long.parseLong( + (newParamsMapWithSimpleKeys.get(SPINNER_SLEEP_DURATION_ARG))) : spinnerSleepDurationAsMilli; boolean newPrintHelp = (newParamsMapWithSimpleKeys.containsKey(HELP_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(HELP_ARG)) : printHelp; + newParamsMapWithSimpleKeys.get(HELP_ARG)) : printHelp; boolean newRecordDelayedOperations = - (newParamsMapWithSimpleKeys.containsKey(RECORD_DELAYED_OPERATIONS_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(RECORD_DELAYED_OPERATIONS_ARG)) : recordDelayedOperations; + (newParamsMapWithSimpleKeys.containsKey(RECORD_DELAYED_OPERATIONS_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(RECORD_DELAYED_OPERATIONS_ARG)) : recordDelayedOperations; boolean newIgnoreScheduledStartTimes = - (newParamsMapWithSimpleKeys.containsKey(IGNORE_SCHEDULED_START_TIMES_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(IGNORE_SCHEDULED_START_TIMES_ARG)) : ignoreScheduledStartTimes; + (newParamsMapWithSimpleKeys.containsKey(IGNORE_SCHEDULED_START_TIMES_ARG)) ? Boolean.parseBoolean( + newParamsMapWithSimpleKeys.get(IGNORE_SCHEDULED_START_TIMES_ARG)) : ignoreScheduledStartTimes; long newWarmupCount = (newParamsMapWithSimpleKeys.containsKey(WARMUP_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(WARMUP_COUNT_ARG)) : warmupCount; + newParamsMapWithSimpleKeys.get(WARMUP_COUNT_ARG)) : warmupCount; long newSkipCount = (newParamsMapWithSimpleKeys.containsKey(SKIP_COUNT_ARG)) ? Long.parseLong( - newParamsMapWithSimpleKeys.get(SKIP_COUNT_ARG)) : skipCount; + newParamsMapWithSimpleKeys.get(SKIP_COUNT_ARG)) : skipCount; boolean newFlushLog = (newParamsMapWithSimpleKeys.containsKey(FLUSH_LOG_ARG)) ? Boolean.parseBoolean( - newParamsMapWithSimpleKeys.get(FLUSH_LOG_ARG)) : flushLog; + newParamsMapWithSimpleKeys.get(FLUSH_LOG_ARG)) : flushLog; long newEstimateTestTime = (newParamsMapWithSimpleKeys.containsKey(ESTIMATE_TEST_TIME_ARG)) ? Long.parseLong(paramsMap.get(ESTIMATE_TEST_TIME_ARG)) : estimateTestTime; @@ -1176,8 +1118,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { * New instance contains all fields that original configuration instance contained. * New instance will contain additional fields if the new parameter introduced one. */ - public DriverConfiguration applyArg(String argument, - String newValue) throws DriverConfigurationException { + public DriverConfiguration applyArg(String argument, String newValue) throws DriverConfigurationException { Map newParamsMap = new HashMap<>(); newParamsMap.put(argument, newValue); return applyArgs(newParamsMap); @@ -1220,7 +1161,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } argsList.addAll( - Lists.newArrayList("-" + SPINNER_SLEEP_DURATION_ARG, Long.toString(spinnerSleepDurationAsMilli))); + Lists.newArrayList("-" + SPINNER_SLEEP_DURATION_ARG, Long.toString(spinnerSleepDurationAsMilli))); if (printHelp) { argsList.add("-" + HELP_ARG); } @@ -1229,7 +1170,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { } // additional, workload/database-related params Map additionalParameters = - MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); + MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); for (Entry additionalParam : MapUtils.sortedEntrySet(additionalParameters)) { argsList.addAll(Lists.newArrayList("-p", additionalParam.getKey(), additionalParam.getValue())); } @@ -1241,7 +1182,7 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { StringBuilder sb = new StringBuilder(); sb.append("# -------------------------------------\n"); sb.append("# -------------------------------------\n"); - sb.append("# ----- LDBC Driver Configuration -----\n"); + sb.append("# ----- Driver Configuration -----\n"); sb.append("# -------------------------------------\n"); sb.append("# -------------------------------------\n"); sb.append("\n"); @@ -1251,251 +1192,120 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("\n"); sb.append("# status display interval (intermittently show status during benchmark execution)\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ") - .append("-") - .append(MODE_ARG) - .append("/--") - .append(MODE_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(MODE_ARG).append("/--").append(MODE_ARG_LONG).append("\n"); sb.append("# INT-32 (seconds)\n"); - sb.append("# COMMAND: ") - .append("-") - .append(SHOW_STATUS_ARG) - .append("/--") - .append(SHOW_STATUS_ARG_LONG) - .append("\n"); - sb.append(SHOW_STATUS_ARG_LONG) - .append("=") - .append(statusDisplayIntervalAsSeconds) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(SHOW_STATUS_ARG).append("/--").append(SHOW_STATUS_ARG_LONG) + .append("\n"); + sb.append(SHOW_STATUS_ARG_LONG).append("=").append(statusDisplayIntervalAsSeconds).append("\n"); sb.append("\n"); sb.append("# thread pool size to use for executing operation handlers\n"); sb.append("# INT-32\n"); - sb.append("# COMMAND: ") - .append("-") - .append(THREADS_ARG) - .append("/--") - .append(THREADS_ARG_LONG) - .append("\n"); - sb.append(THREADS_ARG_LONG) - .append("=") - .append(threadCount) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(THREADS_ARG).append("/--").append(THREADS_ARG_LONG).append("\n"); + sb.append(THREADS_ARG_LONG).append("=").append(threadCount).append("\n"); sb.append("\n"); sb.append("# number of operations to execute during warmup phase of workload\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ") - .append("-") - .append(WARMUP_COUNT_ARG) - .append("/--") - .append(WARMUP_COUNT_ARG_LONG) - .append("\n"); - sb.append(WARMUP_COUNT_ARG_LONG) - .append("=") - .append(warmupCount) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(WARMUP_COUNT_ARG).append("/--").append(WARMUP_COUNT_ARG_LONG) + .append("\n"); + sb.append(WARMUP_COUNT_ARG_LONG).append("=").append(warmupCount).append("\n"); sb.append("\n"); sb.append("# number of operations to skip before beginning workload execution\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ") - .append("-") - .append(SKIP_COUNT_ARG) - .append("/--") - .append(SKIP_COUNT_ARG_LONG) - .append("\n"); - sb.append(SKIP_COUNT_ARG_LONG) - .append("=") - .append(skipCount) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(SKIP_COUNT_ARG).append("/--").append(SKIP_COUNT_ARG_LONG) + .append("\n"); + sb.append(SKIP_COUNT_ARG_LONG).append("=").append(skipCount).append("\n"); sb.append("\n"); sb.append("# name of the benchmark run\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ") - .append("-") - .append(NAME_ARG) - .append("/--") - .append(NAME_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(NAME_ARG).append("/--").append(NAME_ARG_LONG).append("\n"); if (null == name) { - sb.append("# ") - .append(NAME_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(NAME_ARG_LONG).append("=").append("\n"); } else { - sb.append(NAME_ARG_LONG) - .append("=") - .append(name) - .append("\n"); + sb.append(NAME_ARG_LONG).append("=").append(name).append("\n"); } sb.append("\n"); sb.append("# path specifying where to write the benchmark results file\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ") - .append("-") - .append(RESULT_DIR_PATH_ARG) - .append("/--") - .append(RESULT_DIR_PATH_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(RESULT_DIR_PATH_ARG).append("/--").append(RESULT_DIR_PATH_ARG_LONG) + .append("\n"); if (null == resultDirPath) { - sb.append("# ") - .append(RESULT_DIR_PATH_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(RESULT_DIR_PATH_ARG_LONG).append("=").append("\n"); } else { - sb.append(RESULT_DIR_PATH_ARG_LONG) - .append("=") - .append(resultDirPath) - .append("\n"); + sb.append(RESULT_DIR_PATH_ARG_LONG).append("=").append(resultDirPath).append("\n"); } sb.append("\n"); sb.append("# time unit to use for measuring performance metrics (e.g., query response time)\n"); - sb.append("# ENUM (") - .append(Arrays.toString(VALID_TIME_UNITS)) - .append(")\n"); - sb.append("# COMMAND: ") - .append("-") - .append(TIME_UNIT_ARG) - .append("/--") - .append(TIME_UNIT_ARG_LONG) - .append("\n"); - sb.append(TIME_UNIT_ARG_LONG) - .append("=") - .append(timeUnit) - .append("\n"); + sb.append("# ENUM (").append(Arrays.toString(VALID_TIME_UNITS)).append(")\n"); + sb.append("# COMMAND: ").append("-").append(TIME_UNIT_ARG).append("/--").append(TIME_UNIT_ARG_LONG) + .append("\n"); + sb.append(TIME_UNIT_ARG_LONG).append("=").append(timeUnit).append("\n"); sb.append("\n"); sb.append("# used to 'compress'/'stretch' durations between operation start times to increase/decrease " - + "benchmark load\n"); + + "benchmark load\n"); sb.append("# e.g. 2.0 = run benchmark 2x slower, 0.1 = run benchmark 10x faster\n"); sb.append("# DOUBLE\n"); - sb.append("# COMMAND: ") - .append("-") - .append(TIME_COMPRESSION_RATIO_ARG) - .append("/--") - .append(TIME_COMPRESSION_RATIO_ARG_LONG) - .append("\n"); - sb.append(TIME_COMPRESSION_RATIO_ARG_LONG) - .append("=") - .append(timeCompressionRatio) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(TIME_COMPRESSION_RATIO_ARG).append("/--") + .append(TIME_COMPRESSION_RATIO_ARG_LONG).append("\n"); + sb.append(TIME_COMPRESSION_RATIO_ARG_LONG).append("=").append(timeCompressionRatio).append("\n"); sb.append("\n"); sb.append("# enable validation that will check if the provided database implementation is correct\n"); sb.append("# parameter value specifies where to find the validation parameters file\n"); sb.append("# STRING\n"); - sb.append("# COMMAND: ") - .append("-") - .append(DB_VALIDATION_FILE_PATH_ARG) - .append("/--") - .append(DB_VALIDATION_FILE_PATH_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(DB_VALIDATION_FILE_PATH_ARG).append("/--") + .append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("\n"); if (null == databaseValidationFilePath) { - sb.append("# ") - .append(DB_VALIDATION_FILE_PATH_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("=").append("\n"); } else { - sb.append(DB_VALIDATION_FILE_PATH_ARG_LONG) - .append("=") - .append(databaseValidationFilePath) - .append("\n"); + sb.append(DB_VALIDATION_FILE_PATH_ARG_LONG).append("=").append(databaseValidationFilePath).append("\n"); } sb.append("\n"); sb.append("# generate validation parameters file for validating correctness of database implementations\n"); sb.append("# parameter values specify: (1) where to create the validation parameters file (2) how many " - + "validation parameters to generate\n"); + + "validation parameters to generate\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ") - .append("-") - .append(VALIDATION_SERIALIZATION_CHECK_ARG) - .append("/--") - .append(VALIDATION_SERIALIZATION_CHECK_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(VALIDATION_SERIALIZATION_CHECK_ARG).append("/--") + .append(VALIDATION_SERIALIZATION_CHECK_ARG_LONG).append("\n"); sb.append("# INT-32\n"); - sb.append("# COMMAND: ") - .append("-") - .append(VALIDATION_PARAMS_SIZE_ARG) - .append("/--") - .append(VALIDATION_PARAMS_SIZE_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(VALIDATION_PARAMS_SIZE_ARG).append("/--") + .append(VALIDATION_PARAMS_SIZE_ARG_LONG).append("\n"); sb.append("\n"); sb.append("# sleep duration (ms) injected into busy wait loops (to reduce CPU consumption)\n"); sb.append("# INT-64 (milliseconds)\n"); - sb.append("# COMMAND: ") - .append("-") - .append(SPINNER_SLEEP_DURATION_ARG) - .append("/--") - .append(SPINNER_SLEEP_DURATION_ARG_LONG) - .append("\n"); - sb.append(SPINNER_SLEEP_DURATION_ARG_LONG) - .append("=") - .append(spinnerSleepDurationAsMilli) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(SPINNER_SLEEP_DURATION_ARG).append("/--") + .append(SPINNER_SLEEP_DURATION_ARG_LONG).append("\n"); + sb.append(SPINNER_SLEEP_DURATION_ARG_LONG).append("=").append(spinnerSleepDurationAsMilli).append("\n"); sb.append("\n"); sb.append("# print help string - usage instructions\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ") - .append("-") - .append(HELP_ARG) - .append("\n"); - sb.append(HELP_ARG) - .append("=") - .append(printHelp) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(HELP_ARG).append("\n"); + sb.append(HELP_ARG).append("=").append(printHelp).append("\n"); sb.append("\n"); sb.append("# executes operations as fast as possible, ignoring their scheduled start times\n"); sb.append("# BOOLEAN\n"); - sb.append("# COMMAND: ") - .append("-") - .append(IGNORE_SCHEDULED_START_TIMES_ARG) - .append("\n"); - sb.append(IGNORE_SCHEDULED_START_TIMES_ARG) - .append("=") - .append(ignoreScheduledStartTimes) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(IGNORE_SCHEDULED_START_TIMES_ARG).append("\n"); + sb.append(IGNORE_SCHEDULED_START_TIMES_ARG).append("=").append(ignoreScheduledStartTimes).append("\n"); sb.append("\n"); sb.append("# ***************************************************************\n"); sb.append("# *** the following should be set by workload implementations ***\n"); sb.append("# ***************************************************************\n"); sb.append("\n"); sb.append("# fully qualified class name of the Workload (class) implementation to execute\n"); - sb.append("# STRING (e.g., ") - .append(GraphyBenchTransactionWorkload.class.getName()) - .append(")\n"); - sb.append("# COMMAND: ") - .append("-") - .append(WORKLOAD_ARG) - .append("/--") - .append(WORKLOAD_ARG_LONG) - .append("\n"); + sb.append("# STRING (e.g., ").append(GraphyBenchTransactionWorkload.class.getName()).append(")\n"); + sb.append("# COMMAND: ").append("-").append(WORKLOAD_ARG).append("/--").append(WORKLOAD_ARG_LONG).append("\n"); if (null == workloadClassName) { - sb.append("# ") - .append(WORKLOAD_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(WORKLOAD_ARG_LONG).append("=").append("\n"); } else { - sb.append(WORKLOAD_ARG_LONG) - .append("=") - .append(workloadClassName) - .append("\n"); + sb.append(WORKLOAD_ARG_LONG).append("=").append(workloadClassName).append("\n"); } sb.append("\n"); sb.append("# number of operations to generate during benchmark execution\n"); sb.append("# INT-64\n"); - sb.append("# COMMAND: ") - .append("-") - .append(OPERATION_COUNT_ARG) - .append("/--") - .append(OPERATION_COUNT_ARG_LONG) - .append("\n"); + sb.append("# COMMAND: ").append("-").append(OPERATION_COUNT_ARG).append("/--").append(OPERATION_COUNT_ARG_LONG) + .append("\n"); if (0 == operationCount) { - sb.append("# ") - .append(OPERATION_COUNT_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(OPERATION_COUNT_ARG_LONG).append("=").append("\n"); } else { - sb.append(OPERATION_COUNT_ARG_LONG) - .append("=") - .append(operationCount) - .append("\n"); + sb.append(OPERATION_COUNT_ARG_LONG).append("=").append(operationCount).append("\n"); } sb.append("\n"); sb.append("# ************************************************************************************\n"); @@ -1503,29 +1313,16 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("# ************************************************************************************\n"); sb.append("\n"); sb.append("# fully qualified class name of the Db (class) implementation to execute\n"); - sb.append("# STRING (e.g., ") - .append(DummyGraphyBenchTransactionDb.class.getName()) - .append(")\n"); - sb.append("# COMMAND: ") - .append("-") - .append(DB_ARG) - .append("/--") - .append(DB_ARG_LONG) - .append("\n"); + sb.append("# STRING (e.g., ").append(DummyGraphyBenchTransactionDb.class.getName()).append(")\n"); + sb.append("# COMMAND: ").append("-").append(DB_ARG).append("/--").append(DB_ARG_LONG).append("\n"); if (null == dbClassName) { - sb.append("# ") - .append(DB_ARG_LONG) - .append("=") - .append("\n"); + sb.append("# ").append(DB_ARG_LONG).append("=").append("\n"); } else { - sb.append(DB_ARG_LONG) - .append("=") - .append(dbClassName) - .append("\n"); + sb.append(DB_ARG_LONG).append("=").append(dbClassName).append("\n"); } // Write additional, workload/database-related keys as well Map additionalConfigurationParameters = - MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); + MapUtils.copyExcludingKeys(paramsMap, coreConfigurationParameterKeys()); if (!additionalConfigurationParameters.isEmpty()) { sb.append("\n"); sb.append("# ************************************************************************************\n"); @@ -1533,11 +1330,9 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { sb.append("# ************************************************************************************\n"); sb.append("\n"); for (Entry configurationParameter : MapUtils.sortedEntrySet( - additionalConfigurationParameters)) { - sb.append(configurationParameter.getKey()) - .append("=") - .append(configurationParameter.getValue()) - .append("\n"); + additionalConfigurationParameters)) { + sb.append(configurationParameter.getKey()).append("=").append(configurationParameter.getValue()) + .append("\n"); } } return sb.toString(); @@ -1547,91 +1342,47 @@ public class ConsoleAndFileDriverConfiguration implements DriverConfiguration { public String toString() { int padRightDistance = 32; StringBuilder sb = new StringBuilder(); - sb.append("Parameters:") - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Mode:")) - .append(mode) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Name:")) - .append(name) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "DB:")) - .append(dbClassName) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Workload:")) - .append(workloadClassName) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Operation Count:")) - .append(INTEGRAL_FORMAT.format(operationCount)) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Warmup Count:")) - .append(INTEGRAL_FORMAT.format(warmupCount)) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Skip Count:")) - .append(INTEGRAL_FORMAT.format(skipCount)) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Worker Threads:")) - .append(threadCount) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Status Display Interval:")) - .append(TEMPORAL_UTIL.milliDurationToString(TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds))) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Time Unit:")) - .append(timeUnit) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Results Directory:")) - .append(resultDirPath()) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Time Compression Ratio:")) - .append(FLOAT_FORMAT.format(timeCompressionRatio)) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Validation Parameter Size:")) - .append(validationParametersSize) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Validation Serialization Check:")) - .append(validationSerializationCheck) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Validation Database File:")) - .append(databaseValidationFilePath) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Spinner Sleep Duration:")) - .append(TEMPORAL_UTIL.milliDurationToString(spinnerSleepDurationAsMilli)) - .append(" / ") - .append(spinnerSleepDurationAsMilli) - .append(" (ms)\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Print Help:")) - .append(printHelp) - .append("\n"); - sb.append("\t") - .append(format("%1$-" + padRightDistance + "s", "Ignore Scheduled Start Times:")) - .append(ignoreScheduledStartTimes) - .append("\n"); + sb.append("Parameters:").append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Mode:")).append(mode).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Name:")).append(name).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "DB:")).append(dbClassName).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Workload:")).append(workloadClassName) + .append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Operation Count:")) + .append(INTEGRAL_FORMAT.format(operationCount)).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Warmup Count:")) + .append(INTEGRAL_FORMAT.format(warmupCount)).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Skip Count:")) + .append(INTEGRAL_FORMAT.format(skipCount)).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Worker Threads:")).append(threadCount) + .append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Status Display Interval:")) + .append(TEMPORAL_UTIL.milliDurationToString(TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds))) + .append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Time Unit:")).append(timeUnit).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Results Directory:")).append(resultDirPath()) + .append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Time Compression Ratio:")) + .append(FLOAT_FORMAT.format(timeCompressionRatio)).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Parameter Size:")) + .append(validationParametersSize).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Serialization Check:")) + .append(validationSerializationCheck).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Validation Database File:")) + .append(databaseValidationFilePath).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Spinner Sleep Duration:")) + .append(TEMPORAL_UTIL.milliDurationToString(spinnerSleepDurationAsMilli)).append(" / ") + .append(spinnerSleepDurationAsMilli).append(" (ms)\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Print Help:")).append(printHelp).append("\n"); + sb.append("\t").append(format("%1$-" + padRightDistance + "s", "Ignore Scheduled Start Times:")) + .append(ignoreScheduledStartTimes).append("\n"); Set excludedKeys = coreConfigurationParameterKeys(); Map filteredParamsMap = - MapUtils.copyExcludingKeys(convertComplexKeysToSimpleKeys(paramsMap), excludedKeys); + MapUtils.copyExcludingKeys(convertComplexKeysToSimpleKeys(paramsMap), excludedKeys); if (!filteredParamsMap.isEmpty()) { - sb.append("\t") - .append("User-defined parameters:") - .append("\n"); + sb.append("\t").append("User-defined parameters:").append("\n"); sb.append(MapUtils.prettyPrint(filteredParamsMap, "\t\t")); } diff --git a/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java b/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java new file mode 100644 index 0000000..3adcd77 --- /dev/null +++ b/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java @@ -0,0 +1,596 @@ +/* + * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.graphybench.driver.driver.driver; + +import static java.lang.String.format; + +import com.google.common.base.Charsets; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.time.Duration; +import java.time.Instant; +import java.util.concurrent.TimeUnit; +import org.graphybench.driver.driver.Db; +import org.graphybench.driver.driver.DbException; +import org.graphybench.driver.driver.Workload; +import org.graphybench.driver.driver.WorkloadException; +import org.graphybench.driver.driver.WorkloadStreams; +import org.graphybench.driver.driver.control.ControlService; +import org.graphybench.driver.driver.generator.GeneratorFactory; +import org.graphybench.driver.driver.generator.RandomDataGeneratorFactory; +import org.graphybench.driver.driver.log.LoggingService; +import org.graphybench.driver.driver.runtime.ConcurrentErrorReporter; +import org.graphybench.driver.driver.runtime.DefaultQueues; +import org.graphybench.driver.driver.runtime.SimpleResultsLogWriter; +import org.graphybench.driver.driver.runtime.WorkloadRunner; +import org.graphybench.driver.driver.runtime.coordination.CompletionTimeException; +import org.graphybench.driver.driver.runtime.coordination.CompletionTimeService; +import org.graphybench.driver.driver.runtime.coordination.CompletionTimeServiceAssistant; +import org.graphybench.driver.driver.runtime.coordination.CompletionTimeWriter; +import org.graphybench.driver.driver.runtime.metrics.DisruptorSbeMetricsService; +import org.graphybench.driver.driver.runtime.metrics.JsonWorkloadMetricsFormatter; +import org.graphybench.driver.driver.runtime.metrics.MetricsCollectionException; +import org.graphybench.driver.driver.runtime.metrics.MetricsManager; +import org.graphybench.driver.driver.runtime.metrics.MetricsService; +import org.graphybench.driver.driver.runtime.metrics.NullResultsLogWriter; +import org.graphybench.driver.driver.runtime.metrics.ResultsLogWriter; +import org.graphybench.driver.driver.runtime.metrics.WorkloadResultsSnapshot; +import org.graphybench.driver.driver.runtime.metrics.WorkloadStatusSnapshot; +import org.graphybench.driver.driver.temporal.TemporalUtil; +import org.graphybench.driver.driver.temporal.TimeSource; +import org.graphybench.driver.driver.util.ClassLoaderHelper; +import org.graphybench.driver.driver.util.Tuple3; +import org.graphybench.driver.driver.validation.ResultsLogValidationResult; +import org.graphybench.driver.driver.validation.ResultsLogValidationSummary; +import org.graphybench.driver.driver.validation.ResultsLogValidationTolerances; +import org.graphybench.driver.driver.validation.ResultsLogValidator; + + +/** + * Automatic test mode, using dichotomous method to test the configuration parameters suitable for the current machine + */ +public class AutomaticTestMode implements DriverMode { + private final ControlService controlService; + private final TimeSource timeSource; + private final LoggingService loggingService; + private final long randomSeed; + private final TemporalUtil temporalUtil; + private final ResultsDirectory resultsDirectory; + + private Workload workload = null; + private Db database = null; + private MetricsService metricsService = null; + private CompletionTimeService completionTimeService = null; + private WorkloadRunner workloadRunner = null; + private ResultsLogWriter resultsLogWriter = null; + + public AutomaticTestMode( + ControlService controlService, + TimeSource timeSource, + long randomSeed) throws DriverException { + this.controlService = controlService; + this.timeSource = timeSource; + this.loggingService = controlService.loggingServiceFactory() + .loggingServiceFor(getClass().getSimpleName()); + this.randomSeed = randomSeed; + this.temporalUtil = new TemporalUtil(); + this.resultsDirectory = new ResultsDirectory(controlService.configuration()); + } + + public WorkloadStatusSnapshot status() throws MetricsCollectionException { + throw new UnsupportedOperationException("Not yet implemented"); + } + + @Override + public void init() throws DriverException { + loggingService.info("Driver Configuration"); + loggingService.info(controlService.toString()); + } + + @Override + public Object startExecutionAndAwaitCompletion() throws DriverException { + double l = controlService.configuration().tcrMin(); + double r = controlService.configuration().tcrMax(); + // Record the results of the current and last successful one + ResultsLogValidationResult successfulResult = new ResultsLogValidationResult(); + ResultsLogValidationResult currentResult; + + loggingService.info("--------------------------Rapid estimate phase--------------------------"); + // Assuming that tcr=1, the approximate number of basic operations required in a minute + // (initially set to be larger, and later change according to the machine situation) + long baseCnt = 1000; + // Stores the original total number of operations + long sourceOpCnt = controlService.configuration().operationCount(); + long sourceWaCnt = controlService.configuration().operationCount(); + // Gets the binary end condition, tolerance range + double range = controlService.configuration().dichotomyErrorRange(); + // Time compression ratio of this round + double tcr = 0; + int numberOfRounds = 1; + while (r - l >= range) { + // The first time you try to run with the tcr specified by the configuration + if (tcr != 0) { + tcr = l + (r - l) / 2; + controlService.configuration().setTimeCompressionRatio(tcr); + } else { + tcr = controlService.configuration().timeCompressionRatio(); + } + // Sets the number of preheat operations + computeRunOperationCount(baseCnt, sourceWaCnt, sourceOpCnt); + loggingService.info(String.format("--New round %d: Compression ratio: %f,\t warmup count: %d--", + numberOfRounds++, tcr, controlService.configuration().warmupCount() + )); + currentResult = validationTest(true); + + if (currentResult.isSuccessful()) { + r = tcr; + successfulResult = currentResult; + } else { + l = tcr; + } + // Based on the current throughput, determine the base operand per minute at tcr=1 + baseCnt = (long) (Math.ceil(currentResult.throughput()) * tcr * 60); + } + + loggingService.info("--------------------------Accurate adjust parameter phase--------------------------"); + // The theory is accurate tcr >= estimated tcr, + r = Math.min(l * 10, controlService.configuration().tcrMax()); + // to prevent accidents and give a little bit of room that may be smaller + l = controlService.configuration().tcrMin() + (l - controlService.configuration().tcrMin()) * 0.7; + // Ensure that at least one precision tuning phase is performed + tcr = 0; + numberOfRounds = 1; + do { + // The first attempt is to run with the results of the estimation phase + if (tcr != 0) { + tcr = l + (r - l) / 2; + controlService.configuration().setTimeCompressionRatio(tcr); + } else { + tcr = controlService.configuration().timeCompressionRatio(); + } + // Set the number of operations for the warm-up and formal phases + computeRunOperationCount(baseCnt, sourceWaCnt, sourceOpCnt); + loggingService.info(String.format( + "--New round %d: Compression ratio: %f,\t warmup count: %d,\t operation count: %d--", + numberOfRounds++, tcr, controlService.configuration().warmupCount(), + controlService.configuration().operationCount() + )); + + currentResult = validationTest(false); + if (currentResult.isSuccessful()) { + r = tcr; + successfulResult = currentResult; + } else { + l = tcr; + } + baseCnt = (long) (Math.ceil(currentResult.throughput()) * tcr * 60); + } while (r - l >= range); + + // If finding the last l is not successful, replace it with the last successful one + if (!currentResult.isSuccessful()) { + controlService.configuration().setTimeCompressionRatio(r); + // At this point, the state of the machine has slipped, and there is no need to repeat the test + } + try { + loggingService.info("Shutting down database connector..."); + Instant dbShutdownStart = Instant.now(); + database.close(); + Duration shutdownDuration = Duration.between(dbShutdownStart, Instant.now()); + loggingService.info("Database connector shutdown successfully in: " + shutdownDuration); + } catch (IOException e) { + throw new DriverException("Error shutting down database", e); + } + loggingService.info("Workload completed successfully"); + loggingService.info(String.format("\n" + + "--------------------------------------------------------------------------\n" + + "------- time compression ratio suitable for the machine: %-10f-------\n" + + "--------------------------------------------------------------------------", + controlService.configuration().timeCompressionRatio())); + return successfulResult; + } + + /** + * Set the number of operations + * + * @param baseCnt Assuming that tcr=1, the approximate number of basic operations required in a minute + * @param sourceWaCnt Boot specified in the configuration source warmup count + * @param sourceOpCnt Boot specified in the configuration source operation count + */ + public void computeRunOperationCount(long baseCnt, + long sourceWaCnt, + long sourceOpCnt) { + // Enlarge baseCnt by 30 times to prevent accidents and adjust the quantity according to tcr + double perMinute = baseCnt * 30 / controlService.configuration().timeCompressionRatio(); + if (controlService.configuration().estimateTestTime() != -1) { + // baseCnt is one minute, now converted to estimate time + controlService.configuration().setWarmupCount((long) Math.max( + perMinute * (controlService.configuration().estimateTestTime() / 60000.0), sourceWaCnt + )); + } + if (controlService.configuration().accurateTestTime() != -1) { + controlService.configuration().setOperationCount((long) Math.max( + perMinute * (controlService.configuration().accurateTestTime() / 60000.0), sourceOpCnt + )); + } + } + + /** + * Perform a configuration parameter test + * + * @return ResultsLogValidationResult test result + */ + private ResultsLogValidationResult validationTest(boolean warmup) throws DriverException { + ResultsLogValidationResult result = executionAndAwaitCompletion(warmup); + if (result == null) { + loggingService.info("Obtain result The test result failed"); + return new ResultsLogValidationResult(); + } + loggingService.info(String.format("\n" + + "---------------------------- This test check %-8s-------------------\n" + + "---------------------------- tcr: %-10f----------------------------\n" + + "---------------------------- throughput: %-10f---------------------\n" + + "---------------------------- onTimeRatio: %-10f--------------------", + result.isSuccessful() ? "PASS" : "FAILURE", + controlService.configuration().timeCompressionRatio(), result.throughput(), result.onTimeRatio())); + return result; + } + + public ResultsLogValidationResult executionAndAwaitCompletion(boolean warmup) + throws DriverException { + ResultsLogValidationResult result = null; + if (controlService.configuration().warmupCount() > 0) { + loggingService.info("\n" + + " --------------------\n" + + " --- Warmup Phase ---\n" + + " --------------------"); + doInit(true); + result = doExecute(true, controlService.configuration().estimateTestTime()); + try { + // TODO remove in future + // This is necessary to clear the runnable context pool + // As objects in the pool would otherwise hold references to services used during warmup + loggingService.info("reInit database..."); + database.reInitAutomatic(); + } catch (DbException e) { + throw new DriverException(format("Error reinitializing DB: %s", database.getClass() + .getName()), e); + } + } else { + loggingService.info("\n" + + " ---------------------------------\n" + + " --- No Warmup Phase Requested ---\n" + + " ---------------------------------"); + } + + if (!warmup) { + loggingService.info("\n" + + " -----------------\n" + + " --- Run Phase ---\n" + + " -----------------"); + doInit(false); + result = doExecute(false, controlService.configuration().accurateTestTime()); + try { + // TODO remove in future + // This is necessary to clear the runnable context pool + // As objects in the pool would otherwise hold references to services used during warmup + loggingService.info("reInit database..."); + database.reInitAutomatic(); + } catch (DbException e) { + throw new DriverException(format("Error reinitializing DB: %s", database.getClass() + .getName()), e); + } + } + return result; + } + + private void doInit(boolean warmup) throws DriverException { + ConcurrentErrorReporter errorReporter = new ConcurrentErrorReporter(); + GeneratorFactory gf = new GeneratorFactory(new RandomDataGeneratorFactory(randomSeed)); + + // ================================ + // === Results Log CSV Writer === + // ================================ + File resultsLog = resultsDirectory.getOrCreateResultsLogFile(warmup); + try { + resultsLogWriter = (null == resultsLog) + ? new NullResultsLogWriter() + : new SimpleResultsLogWriter( + resultsLog, + controlService.configuration().timeUnit(), + controlService.configuration().flushLog()); + } catch (IOException e) { + throw new DriverException( + format("Error creating results log writer for: %s", resultsLog.getAbsolutePath()), e); + } + + // ------------------ + // --- Workload --- + // ------------------ + loggingService.info("Scanning workload streams to calculate their limits..."); + + long offset = (warmup) + ? controlService.configuration().skipCount() + : controlService.configuration().skipCount() + controlService.configuration().warmupCount(); + long limit = (warmup) + ? controlService.configuration().warmupCount() + : controlService.configuration().operationCount(); + + WorkloadStreams workloadStreams; + long minimumTimeStamp; + try { + boolean returnStreamsWithDbConnector = true; + Tuple3 streamsAndWorkloadAndMinimumTimeStamp = + WorkloadStreams.createNewWorkloadWithOffsetAndLimitedWorkloadStreams( + controlService.configuration(), + gf, + returnStreamsWithDbConnector, + offset, + limit, + controlService.loggingServiceFactory() + ); + workloadStreams = streamsAndWorkloadAndMinimumTimeStamp._1(); + workload = streamsAndWorkloadAndMinimumTimeStamp._2(); + minimumTimeStamp = streamsAndWorkloadAndMinimumTimeStamp._3(); + } catch (Exception e) { + throw new DriverException(format("Error loading workload class: %s", + controlService.configuration().workloadClassName()), e); + } + loggingService.info(format("Loaded workload: %s", workload.getClass().getName())); + + loggingService.info(format("Retrieving workload stream: %s", workload.getClass().getSimpleName())); + controlService.setWorkloadStartTimeAsMilli(System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(5)); + WorkloadStreams timeMappedWorkloadStreams; + try { + timeMappedWorkloadStreams = WorkloadStreams.timeOffsetAndCompressWorkloadStreams( + workloadStreams, + controlService.workloadStartTimeAsMilli(), + controlService.configuration().timeCompressionRatio(), + gf + ); + } catch (WorkloadException e) { + throw new DriverException("Error while retrieving operation stream for workload", e); + } + + // ---------------= + // ---== DB ---== + // ---------------= + if (null == database) { + try { + database = ClassLoaderHelper.loadDb(controlService.configuration().dbClassName()); + database.init( + controlService.configuration().asMap(), + controlService.loggingServiceFactory().loggingServiceFor(database.getClass().getSimpleName()), + workload.operationTypeToClassMapping() + ); + } catch (DbException e) { + throw new DriverException( + format("Error initializing DB: %s", controlService.configuration().dbClassName()), e); + } + loggingService.info(format("Loaded DB: %s", database.getClass().getName())); + } + + // ------------------------ + // --- Metrics Service == + // ------------------------ + try { + // TODO create metrics service factory so different ones can be easily created + metricsService = new DisruptorSbeMetricsService( + timeSource, + errorReporter, + controlService.configuration().timeUnit(), + DisruptorSbeMetricsService.DEFAULT_HIGHEST_EXPECTED_RUNTIME_DURATION_AS_NANO, + resultsLogWriter, + workload.operationTypeToClassMapping(), + controlService.loggingServiceFactory() + ); + } catch (MetricsCollectionException e) { + throw new DriverException("Error creating metrics service", e); + } + + // --------------------------------- + // --- Completion Time Service --- + // --------------------------------- + CompletionTimeServiceAssistant completionTimeServiceAssistant = new CompletionTimeServiceAssistant(); + try { + completionTimeService = + completionTimeServiceAssistant.newThreadedQueuedCompletionTimeService( + timeSource, + errorReporter + ); + } catch (CompletionTimeException e) { + throw new DriverException("Error instantiating Completion Time Service", e); + } + + // ------------------------ + // --- Workload Runner == + // ------------------------ + loggingService.info(format("Instantiating %s", WorkloadRunner.class.getSimpleName())); + try { + int operationHandlerExecutorsBoundedQueueSize = DefaultQueues.DEFAULT_BOUND_1000; + workloadRunner = new WorkloadRunner( + timeSource, + database, + timeMappedWorkloadStreams, + metricsService, + errorReporter, + completionTimeService, + controlService.loggingServiceFactory(), + controlService.configuration().threadCount(), + controlService.configuration().statusDisplayIntervalAsSeconds(), + controlService.configuration().spinnerSleepDurationAsMilli(), + controlService.configuration().ignoreScheduledStartTimes(), + operationHandlerExecutorsBoundedQueueSize); + } catch (Exception e) { + throw new DriverException(format("Error instantiating %s", WorkloadRunner.class.getSimpleName()), e); + } + + // ------------------------------------------= + // --- Initialize Completion Time Service == + // ------------------------------------------= + // TODO note, this MUST be done after creation of Workload Runner because Workload Runner creates the + // TODO "writers" for completion time service (refactor this mess at some stage) + try { + if (completionTimeService.getAllWriters().isEmpty()) { + // There are no completion time writers, CT would never advance or be non-null, + // set to max so nothing ever waits on it + long nearlyMaxPossibleTimeAsMilli = Long.MAX_VALUE - 1; + long maxPossibleTimeAsMilli = Long.MAX_VALUE; + // Create a writer to use for advancing CT + CompletionTimeWriter completionTimeWriter = completionTimeService.newCompletionTimeWriter(); + completionTimeWriter.submitInitiatedTime(nearlyMaxPossibleTimeAsMilli); + completionTimeWriter.submitCompletedTime(nearlyMaxPossibleTimeAsMilli); + completionTimeWriter.submitInitiatedTime(maxPossibleTimeAsMilli); + completionTimeWriter.submitCompletedTime(maxPossibleTimeAsMilli); + } else { + // There are some completion time writers, initialize them to lowest time stamp in workload + completionTimeServiceAssistant.writeInitiatedAndCompletedTimesToAllWriters( + completionTimeService, minimumTimeStamp - 1); + completionTimeServiceAssistant + .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp); + boolean completionTimeAdvancedToDesiredTime = + completionTimeServiceAssistant.waitForCompletionTime( + timeSource, + minimumTimeStamp - 1, + TimeUnit.SECONDS.toMillis(5), + completionTimeService, + errorReporter + ); + long completionTimeWaitTimeoutDurationAsMilli = TimeUnit.SECONDS.toMillis(5); + if (!completionTimeAdvancedToDesiredTime) { + throw new DriverException( + format( + "Timed out [%s] while waiting for completion time to advance to workload " + + "start time\nCurrent CT: %s\nWaiting For CT: %s", + completionTimeWaitTimeoutDurationAsMilli, + completionTimeService.completionTimeAsMilli(), + controlService.workloadStartTimeAsMilli()) + ); + } + loggingService.info("CT: " + temporalUtil + .milliTimeToDateTimeString(completionTimeService.completionTimeAsMilli()) + " / " + + completionTimeService.completionTimeAsMilli()); + } + } catch (CompletionTimeException e) { + throw new DriverException( + "Error while writing initial initiated and completed times to Completion Time Service", e); + } + } + + private ResultsLogValidationResult doExecute(boolean warmup, + long milli) throws DriverException { + try { + ConcurrentErrorReporter errorReporter = null; + if (milli == -1) { + // To execute normally, follow the EXECUTE_BENCHMARK process + errorReporter = workloadRunner.getFuture().get(); + } else { + errorReporter = workloadRunner.getFuture(milli); + } + loggingService.info("Shutting down workload..."); + workload.close(); + if (errorReporter.errorEncountered()) { + throw new DriverException("Error running workload\n" + errorReporter.toString()); + } + } catch (Exception e) { + throw new DriverException("Error running workload", e); + } + + loggingService.info("Shutting down completion time service..."); + try { + completionTimeService.shutdown(); + } catch (CompletionTimeException e) { + throw new DriverException("Error during shutdown of completion time service", e); + } + + loggingService.info("Shutting down metrics collection service..."); + WorkloadResultsSnapshot workloadResults; + try { + workloadResults = metricsService.getWriter().results(); + metricsService.shutdown(); + } catch (MetricsCollectionException e) { + throw new DriverException("Error during shutdown of metrics collection service", e); + } + + try { + if (warmup) { + loggingService.summaryResult(workloadResults); + } else { + loggingService.detailedResult(workloadResults); + } + if (resultsDirectory.exists()) { + File resultsSummaryFile = resultsDirectory.getOrCreateResultsSummaryFile(warmup); + loggingService.info( + format("Exporting workload metrics to %s...", resultsSummaryFile.getAbsolutePath()) + ); + MetricsManager.export(workloadResults, + new JsonWorkloadMetricsFormatter(), + new FileOutputStream(resultsSummaryFile), + Charsets.UTF_8 + ); + File configurationFile = resultsDirectory.getOrCreateConfigurationFile(warmup); + Files.write( + configurationFile.toPath(), + controlService.configuration().toPropertiesString().getBytes(StandardCharsets.UTF_8) + ); + resultsLogWriter.close(); + if (!controlService.configuration().ignoreScheduledStartTimes()) { + loggingService.info("Validating workload results..."); + // TODO make this feature accessible directly + ResultsLogValidator resultsLogValidator = new ResultsLogValidator(); + ResultsLogValidationTolerances resultsLogValidationTolerances = + workload.resultsLogValidationTolerancesAutomatic(controlService.configuration(), + workloadResults.totalOperationCount()); + + ResultsLogValidationSummary resultsLogValidationSummary = resultsLogValidator.compute( + resultsDirectory.getOrCreateResultsLogFile(warmup), + resultsLogValidationTolerances.excessiveDelayThresholdAsMilli() + ); + File resultsValidationFile = resultsDirectory.getOrCreateResultsValidationFile(warmup); + loggingService.info( + format("Exporting workload results validation to: %s", + resultsValidationFile.getAbsolutePath()) + ); + // Files.write( + // resultsValidationFile.toPath(), + // resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) + // ); + // TODO export result + ResultsLogValidationResult validationResult = resultsLogValidator.validateAutomatic( + resultsLogValidationSummary, + resultsLogValidationTolerances, + workloadResults + ); + loggingService.info(validationResult.getScheduleAuditResult( + controlService.configuration().recordDelayedOperations() + )); + Files.write( + resultsValidationFile.toPath(), + resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) + ); + return validationResult; + } + } + } catch (Exception e) { + throw new DriverException("Could not export workload metrics", e); + } + return null; + } +} + diff --git a/src/main/java/org/graphybench/driver/driver/driver/Driver.java b/src/main/java/org/graphybench/driver/driver/driver/Driver.java index 48254db..714d4a2 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/Driver.java +++ b/src/main/java/org/graphybench/driver/driver/driver/Driver.java @@ -48,10 +48,10 @@ public class Driver { ConsoleAndFileDriverConfiguration configuration = ConsoleAndFileDriverConfiguration.fromArgs(args); long workloadStartTimeAsMilli = systemTimeSource.nowAsMilli() + TimeUnit.SECONDS.toMillis(5); controlService = new LocalControlService( - workloadStartTimeAsMilli, - configuration, - loggingServiceFactory, - systemTimeSource); + workloadStartTimeAsMilli, + configuration, + loggingServiceFactory, + systemTimeSource); Driver driver = new Driver(); DriverMode driverMode = driver.getDriverModeFor(controlService); driverMode.init(); @@ -79,19 +79,17 @@ public class Driver { * @throws DriverException When one or more required parameters are missing */ public DriverMode getDriverModeFor(ControlService controlService) throws DriverException { - if (controlService.configuration() - .shouldPrintHelpString()) { + if (controlService.configuration().shouldPrintHelpString()) { return new PrintHelpMode(controlService); } List missingParams = - ConsoleAndFileDriverConfiguration.checkMissingParams(controlService.configuration()); + ConsoleAndFileDriverConfiguration.checkMissingParams(controlService.configuration()); if (!missingParams.isEmpty()) { throw new DriverException(format("Missing required parameters: %s", missingParams.toString())); } - OperationMode mode = OperationMode.valueOf(controlService.configuration() - .mode()); + OperationMode mode = OperationMode.valueOf(controlService.configuration().mode()); switch (mode) { case CREATE_VALIDATION: diff --git a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java index f026682..90fa01c 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java +++ b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java @@ -78,13 +78,12 @@ public class ExecuteWorkloadMode implements DriverMode { private ResultsLogWriter resultsLogWriter = null; public ExecuteWorkloadMode( - ControlService controlService, - TimeSource timeSource, - long randomSeed) throws DriverException { + ControlService controlService, + TimeSource timeSource, + long randomSeed) throws DriverException { this.controlService = controlService; this.timeSource = timeSource; - this.loggingService = controlService.loggingServiceFactory() - .loggingServiceFor(getClass().getSimpleName()); + this.loggingService = controlService.loggingServiceFactory().loggingServiceFor(getClass().getSimpleName()); this.randomSeed = randomSeed; this.temporalUtil = new TemporalUtil(); this.resultsDirectory = new ResultsDirectory(controlService.configuration()); @@ -106,12 +105,11 @@ public class ExecuteWorkloadMode implements DriverMode { @Override public Object startExecutionAndAwaitCompletion() throws DriverException { - if (controlService.configuration() - .warmupCount() > 0) { + if (controlService.configuration().warmupCount() > 0) { loggingService.info("\n" - + " --------------------\n" - + " --- Warmup Phase ---\n" - + " --------------------"); + + " --------------------\n" + + " --- Warmup Phase ---\n" + + " --------------------"); doInit(true); doExecute(true); try { @@ -120,20 +118,19 @@ public class ExecuteWorkloadMode implements DriverMode { // As objects in the pool would otherwise hold references to services used during warmup database.reInit(); } catch (DbException e) { - throw new DriverException(format("Error reinitializing DB: %s", database.getClass() - .getName()), e); + throw new DriverException(format("Error reinitializing DB: %s", database.getClass().getName()), e); } } else { loggingService.info("\n" - + " ---------------------------------\n" - + " --- No Warmup Phase Requested ---\n" - + " ---------------------------------"); + + " ---------------------------------\n" + + " --- No Warmup Phase Requested ---\n" + + " ---------------------------------"); } loggingService.info("\n" - + " -----------------\n" - + " --- Run Phase ---\n" - + " -----------------"); + + " -----------------\n" + + " --- Run Phase ---\n" + + " -----------------"); doInit(false); doExecute(false); @@ -160,16 +157,14 @@ public class ExecuteWorkloadMode implements DriverMode { File resultsLog = resultsDirectory.getOrCreateResultsLogFile(warmup); try { resultsLogWriter = (null == resultsLog) - ? new NullResultsLogWriter() - : new SimpleResultsLogWriter( - resultsLog, - controlService.configuration() - .timeUnit(), - controlService.configuration() - .flushLog()); + ? new NullResultsLogWriter() + : new SimpleResultsLogWriter( + resultsLog, + controlService.configuration().timeUnit(), + controlService.configuration().flushLog()); } catch (IOException e) { throw new DriverException( - format("Error creating results log writer for: %s", resultsLog.getAbsolutePath()), e); + format("Error creating results log writer for: %s", resultsLog.getAbsolutePath()), e); } // ================== @@ -178,52 +173,43 @@ public class ExecuteWorkloadMode implements DriverMode { loggingService.info("Scanning workload streams to calculate their limits..."); long offset = (warmup) - ? controlService.configuration() - .skipCount() - : controlService.configuration() - .skipCount() + controlService.configuration() - .warmupCount(); + ? controlService.configuration().skipCount() + : controlService.configuration().skipCount() + controlService.configuration().warmupCount(); long limit = (warmup) - ? controlService.configuration() - .warmupCount() - : controlService.configuration() - .operationCount(); + ? controlService.configuration().warmupCount() + : controlService.configuration().operationCount(); WorkloadStreams workloadStreams; long minimumTimeStamp; try { boolean returnStreamsWithDbConnector = true; Tuple3 streamsAndWorkloadAndMinimumTimeStamp = - WorkloadStreams.createNewWorkloadWithOffsetAndLimitedWorkloadStreams( - controlService.configuration(), - gf, - returnStreamsWithDbConnector, - offset, - limit, - controlService.loggingServiceFactory() - ); + WorkloadStreams.createNewWorkloadWithOffsetAndLimitedWorkloadStreams( + controlService.configuration(), + gf, + returnStreamsWithDbConnector, + offset, + limit, + controlService.loggingServiceFactory() + ); workloadStreams = streamsAndWorkloadAndMinimumTimeStamp._1(); workload = streamsAndWorkloadAndMinimumTimeStamp._2(); minimumTimeStamp = streamsAndWorkloadAndMinimumTimeStamp._3(); } catch (Exception e) { throw new DriverException(format("Error loading workload class: %s", - controlService.configuration() - .workloadClassName()), e); + controlService.configuration().workloadClassName()), e); } - loggingService.info(format("Loaded workload: %s", workload.getClass() - .getName())); + loggingService.info(format("Loaded workload: %s", workload.getClass().getName())); - loggingService.info(format("Retrieving workload stream: %s", workload.getClass() - .getSimpleName())); + loggingService.info(format("Retrieving workload stream: %s", workload.getClass().getSimpleName())); controlService.setWorkloadStartTimeAsMilli(System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(5)); WorkloadStreams timeMappedWorkloadStreams; try { timeMappedWorkloadStreams = WorkloadStreams.timeOffsetAndCompressWorkloadStreams( - workloadStreams, - controlService.workloadStartTimeAsMilli(), - controlService.configuration() - .timeCompressionRatio(), - gf + workloadStreams, + controlService.workloadStartTimeAsMilli(), + controlService.configuration().timeCompressionRatio(), + gf ); } catch (WorkloadException e) { throw new DriverException("Error while retrieving operation stream for workload", e); @@ -234,23 +220,17 @@ public class ExecuteWorkloadMode implements DriverMode { // ================ if (null == database) { try { - database = ClassLoaderHelper.loadDb(controlService.configuration() - .dbClassName()); + database = ClassLoaderHelper.loadDb(controlService.configuration().dbClassName()); database.init( - controlService.configuration() - .asMap(), - controlService.loggingServiceFactory() - .loggingServiceFor(database.getClass() - .getSimpleName()), - workload.operationTypeToClassMapping() + controlService.configuration().asMap(), + controlService.loggingServiceFactory().loggingServiceFor(database.getClass().getSimpleName()), + workload.operationTypeToClassMapping() ); } catch (DbException e) { throw new DriverException( - format("Error initializing DB: %s", controlService.configuration() - .dbClassName()), e); + format("Error initializing DB: %s", controlService.configuration().dbClassName()), e); } - loggingService.info(format("Loaded DB: %s", database.getClass() - .getName())); + loggingService.info(format("Loaded DB: %s", database.getClass().getName())); } // ======================== @@ -259,14 +239,13 @@ public class ExecuteWorkloadMode implements DriverMode { try { // TODO create metrics service factory so different ones can be easily created metricsService = new DisruptorSbeMetricsService( - timeSource, - errorReporter, - controlService.configuration() - .timeUnit(), - DisruptorSbeMetricsService.DEFAULT_HIGHEST_EXPECTED_RUNTIME_DURATION_AS_NANO, - resultsLogWriter, - workload.operationTypeToClassMapping(), - controlService.loggingServiceFactory() + timeSource, + errorReporter, + controlService.configuration().timeUnit(), + DisruptorSbeMetricsService.DEFAULT_HIGHEST_EXPECTED_RUNTIME_DURATION_AS_NANO, + resultsLogWriter, + workload.operationTypeToClassMapping(), + controlService.loggingServiceFactory() ); } catch (MetricsCollectionException e) { throw new DriverException("Error creating metrics service", e); @@ -278,10 +257,10 @@ public class ExecuteWorkloadMode implements DriverMode { CompletionTimeServiceAssistant completionTimeServiceAssistant = new CompletionTimeServiceAssistant(); try { completionTimeService = - completionTimeServiceAssistant.newThreadedQueuedCompletionTimeService( - timeSource, - errorReporter - ); + completionTimeServiceAssistant.newThreadedQueuedCompletionTimeService( + timeSource, + errorReporter + ); } catch (CompletionTimeException e) { throw new DriverException("Error instantiating Completion Time Service", e); } @@ -293,22 +272,18 @@ public class ExecuteWorkloadMode implements DriverMode { try { int operationHandlerExecutorsBoundedQueueSize = DefaultQueues.DEFAULT_BOUND_1000; workloadRunner = new WorkloadRunner( - timeSource, - database, - timeMappedWorkloadStreams, - metricsService, - errorReporter, - completionTimeService, - controlService.loggingServiceFactory(), - controlService.configuration() - .threadCount(), - controlService.configuration() - .statusDisplayIntervalAsSeconds(), - controlService.configuration() - .spinnerSleepDurationAsMilli(), - controlService.configuration() - .ignoreScheduledStartTimes(), - operationHandlerExecutorsBoundedQueueSize); + timeSource, + database, + timeMappedWorkloadStreams, + metricsService, + errorReporter, + completionTimeService, + controlService.loggingServiceFactory(), + controlService.configuration().threadCount(), + controlService.configuration().statusDisplayIntervalAsSeconds(), + controlService.configuration().spinnerSleepDurationAsMilli(), + controlService.configuration().ignoreScheduledStartTimes(), + operationHandlerExecutorsBoundedQueueSize); } catch (Exception e) { throw new DriverException(format("Error instantiating %s", WorkloadRunner.class.getSimpleName()), e); } @@ -319,8 +294,7 @@ public class ExecuteWorkloadMode implements DriverMode { // TODO note, this MUST be done after creation of Workload Runner because Workload Runner creates the // TODO "writers" for completion time service (refactor this mess at some stage) try { - if (completionTimeService.getAllWriters() - .isEmpty()) { + if (completionTimeService.getAllWriters().isEmpty()) { // There are no completion time writers, CT would never advance or be non-null, // set to max so nothing ever waits on it long nearlyMaxPossibleTimeAsMilli = Long.MAX_VALUE - 1; @@ -334,42 +308,41 @@ public class ExecuteWorkloadMode implements DriverMode { } else { // There are some completion time writers, initialize them to lowest time stamp in workload completionTimeServiceAssistant - .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp - 1); + .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp - 1); completionTimeServiceAssistant - .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp); + .writeInitiatedAndCompletedTimesToAllWriters(completionTimeService, minimumTimeStamp); boolean completionTimeAdvancedToDesiredTime = - completionTimeServiceAssistant.waitForCompletionTime( - timeSource, - minimumTimeStamp - 1, - TimeUnit.SECONDS.toMillis(5), - completionTimeService, - errorReporter - ); + completionTimeServiceAssistant.waitForCompletionTime( + timeSource, + minimumTimeStamp - 1, + TimeUnit.SECONDS.toMillis(5), + completionTimeService, + errorReporter + ); long completionTimeWaitTimeoutDurationAsMilli = TimeUnit.SECONDS.toMillis(5); if (!completionTimeAdvancedToDesiredTime) { throw new DriverException( - format( - "Timed out [%s] while waiting for completion time to advance to workload " - + "start time\nCurrent CT: %s\nWaiting For CT: %s", - completionTimeWaitTimeoutDurationAsMilli, - completionTimeService.completionTimeAsMilli(), - controlService.workloadStartTimeAsMilli()) + format( + "Timed out [%s] while waiting for completion time to advance to workload " + + "start time\nCurrent CT: %s\nWaiting For CT: %s", + completionTimeWaitTimeoutDurationAsMilli, + completionTimeService.completionTimeAsMilli(), + controlService.workloadStartTimeAsMilli()) ); } loggingService.info("CT: " + temporalUtil - .milliTimeToDateTimeString(completionTimeService.completionTimeAsMilli()) + " / " - + completionTimeService.completionTimeAsMilli()); + .milliTimeToDateTimeString(completionTimeService.completionTimeAsMilli()) + " / " + + completionTimeService.completionTimeAsMilli()); } } catch (CompletionTimeException e) { throw new DriverException( - "Error while writing initial initiated and completed times to Completion Time Service", e); + "Error while writing initial initiated and completed times to Completion Time Service", e); } } private void doExecute(boolean warmup) throws DriverException { try { - ConcurrentErrorReporter errorReporter = workloadRunner.getFuture() - .get(); + ConcurrentErrorReporter errorReporter = workloadRunner.getFuture().get(); loggingService.info("Shutting down workload..."); workload.close(); if (errorReporter.errorEncountered()) { @@ -389,8 +362,7 @@ public class ExecuteWorkloadMode implements DriverMode { loggingService.info("Shutting down metrics collection service..."); WorkloadResultsSnapshot workloadResults; try { - workloadResults = metricsService.getWriter() - .results(); + workloadResults = metricsService.getWriter().results(); metricsService.shutdown(); } catch (MetricsCollectionException e) { throw new DriverException("Error during shutdown of metrics collection service", e); @@ -405,38 +377,35 @@ public class ExecuteWorkloadMode implements DriverMode { if (resultsDirectory.exists()) { File resultsSummaryFile = resultsDirectory.getOrCreateResultsSummaryFile(warmup); loggingService.info( - format("Exporting workload metrics to %s...", resultsSummaryFile.getAbsolutePath()) + format("Exporting workload metrics to %s...", resultsSummaryFile.getAbsolutePath()) ); MetricsManager.export(workloadResults, - new JsonWorkloadMetricsFormatter(), - new FileOutputStream(resultsSummaryFile), - Charsets.UTF_8 + new JsonWorkloadMetricsFormatter(), + new FileOutputStream(resultsSummaryFile), + Charsets.UTF_8 ); File configurationFile = resultsDirectory.getOrCreateConfigurationFile(warmup); Files.write( - configurationFile.toPath(), - controlService.configuration() - .toPropertiesString() - .getBytes(StandardCharsets.UTF_8) + configurationFile.toPath(), + controlService.configuration().toPropertiesString().getBytes(StandardCharsets.UTF_8) ); resultsLogWriter.close(); - if (!controlService.configuration() - .ignoreScheduledStartTimes()) { + if (!controlService.configuration().ignoreScheduledStartTimes()) { loggingService.info("Validating workload results..."); // TODO make this feature accessible directly ResultsLogValidator resultsLogValidator = new ResultsLogValidator(); ResultsLogValidationTolerances resultsLogValidationTolerances = - workload.resultsLogValidationTolerances(controlService.configuration(), warmup); + workload.resultsLogValidationTolerances(controlService.configuration(), warmup); ResultsLogValidationSummary resultsLogValidationSummary = resultsLogValidator.compute( - resultsDirectory.getOrCreateResultsLogFile(warmup), - resultsLogValidationTolerances.excessiveDelayThresholdAsMilli() + resultsDirectory.getOrCreateResultsLogFile(warmup), + resultsLogValidationTolerances.excessiveDelayThresholdAsMilli() ); File resultsValidationFile = resultsDirectory.getOrCreateResultsValidationFile(warmup); loggingService.info( - format("Exporting workload results validation to: %s", - resultsValidationFile.getAbsolutePath()) + format("Exporting workload results validation to: %s", + resultsValidationFile.getAbsolutePath()) ); // Files.write( // resultsValidationFile.toPath(), @@ -445,20 +414,17 @@ public class ExecuteWorkloadMode implements DriverMode { // ); // TODO export result ResultsLogValidationResult validationResult = resultsLogValidator.validate( - resultsLogValidationSummary, - resultsLogValidationTolerances, - controlService.configuration() - .recordDelayedOperations(), - workloadResults + resultsLogValidationSummary, + resultsLogValidationTolerances, + controlService.configuration().recordDelayedOperations(), + workloadResults ); loggingService.info(validationResult.getScheduleAuditResult( - controlService.configuration() - .recordDelayedOperations() + controlService.configuration().recordDelayedOperations() )); Files.write( - resultsValidationFile.toPath(), - resultsLogValidationSummary.toJson() - .getBytes(StandardCharsets.UTF_8) + resultsValidationFile.toPath(), + resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) ); } } diff --git a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java index e02a3c2..678d8b1 100644 --- a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java +++ b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java @@ -53,31 +53,31 @@ public class WorkloadRunner { private final WorkloadRunnerFuture workloadRunnerFuture; public WorkloadRunner( - TimeSource timeSource, - Db db, - WorkloadStreams workloadStreams, - MetricsService metricsService, - ConcurrentErrorReporter errorReporter, - CompletionTimeService completionTimeService, - LoggingServiceFactory loggingServiceFactory, - int threadCount, - long statusDisplayIntervalAsSeconds, - long spinnerSleepDurationAsMilli, - boolean ignoreScheduleStartTimes, - int operationHandlerExecutorsBoundedQueueSize) throws WorkloadException, MetricsCollectionException { + TimeSource timeSource, + Db db, + WorkloadStreams workloadStreams, + MetricsService metricsService, + ConcurrentErrorReporter errorReporter, + CompletionTimeService completionTimeService, + LoggingServiceFactory loggingServiceFactory, + int threadCount, + long statusDisplayIntervalAsSeconds, + long spinnerSleepDurationAsMilli, + boolean ignoreScheduleStartTimes, + int operationHandlerExecutorsBoundedQueueSize) throws WorkloadException, MetricsCollectionException { this.workloadRunnerFuture = new WorkloadRunnerFuture( - timeSource, - db, - workloadStreams, - metricsService, - errorReporter, - completionTimeService, - loggingServiceFactory, - threadCount, - statusDisplayIntervalAsSeconds, - spinnerSleepDurationAsMilli, - ignoreScheduleStartTimes, - operationHandlerExecutorsBoundedQueueSize + timeSource, + db, + workloadStreams, + metricsService, + errorReporter, + completionTimeService, + loggingServiceFactory, + threadCount, + statusDisplayIntervalAsSeconds, + spinnerSleepDurationAsMilli, + ignoreScheduleStartTimes, + operationHandlerExecutorsBoundedQueueSize ); } @@ -106,31 +106,31 @@ public class WorkloadRunner { private boolean isDone = false; private WorkloadRunnerFuture( - TimeSource timeSource, - Db db, - WorkloadStreams workloadStreams, - MetricsService metricsService, - ConcurrentErrorReporter errorReporter, - CompletionTimeService completionTimeService, - LoggingServiceFactory loggingServiceFactory, - int threadCount, - long statusDisplayIntervalAsSeconds, - long spinnerSleepDurationAsMilli, - boolean ignoreScheduleStartTimes, - int operationHandlerExecutorsBoundedQueueSize) throws MetricsCollectionException, WorkloadException { + TimeSource timeSource, + Db db, + WorkloadStreams workloadStreams, + MetricsService metricsService, + ConcurrentErrorReporter errorReporter, + CompletionTimeService completionTimeService, + LoggingServiceFactory loggingServiceFactory, + int threadCount, + long statusDisplayIntervalAsSeconds, + long spinnerSleepDurationAsMilli, + boolean ignoreScheduleStartTimes, + int operationHandlerExecutorsBoundedQueueSize) throws MetricsCollectionException, WorkloadException { this.workloadRunnerThread = new WorkloadRunnerThread( - timeSource, - db, - workloadStreams, - metricsService, - errorReporter, - completionTimeService, - loggingServiceFactory, - threadCount, - statusDisplayIntervalAsSeconds, - spinnerSleepDurationAsMilli, - ignoreScheduleStartTimes, - operationHandlerExecutorsBoundedQueueSize + timeSource, + db, + workloadStreams, + metricsService, + errorReporter, + completionTimeService, + loggingServiceFactory, + threadCount, + statusDisplayIntervalAsSeconds, + spinnerSleepDurationAsMilli, + ignoreScheduleStartTimes, + operationHandlerExecutorsBoundedQueueSize ); this.timeSource = timeSource; this.errorReporter = errorReporter; @@ -213,9 +213,9 @@ public class WorkloadRunner { default: // Fail because task has already completed throw new IllegalStateException( - format("Unrecognized %s: %s", - workloadRunnerThread.state().getClass().getSimpleName(), - workloadRunnerThread.state()) + format("Unrecognized %s: %s", + workloadRunnerThread.state().getClass().getSimpleName(), + workloadRunnerThread.state()) ); } } @@ -229,7 +229,7 @@ public class WorkloadRunner { public boolean isDone() { if (!isDone) { if (workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_FAILED) - || workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_SUCCEEDED)) { + || workloadRunnerThread.state().equals(WorkloadRunnerThreadState.COMPLETED_SUCCEEDED)) { isDone = true; } } @@ -252,7 +252,7 @@ public class WorkloadRunner { @Override public ConcurrentErrorReporter get(long timeout, TimeUnit unit) - throws InterruptedException, ExecutionException, TimeoutException { + throws InterruptedException, ExecutionException, TimeoutException { if (isCancelled || isDone) { throw new IllegalStateException("Can not call method after future has been cancelled or completed"); } @@ -267,9 +267,9 @@ public class WorkloadRunner { switch (workloadRunnerThread.state()) { case NOT_STARTED: throw new IllegalStateException(format( - "%s is in %s state, but should have already started", - WorkloadRunnerThread.class.getSimpleName(), - WorkloadRunnerThreadState.NOT_STARTED.name() + "%s is in %s state, but should have already started", + WorkloadRunnerThread.class.getSimpleName(), + WorkloadRunnerThreadState.NOT_STARTED.name() )); case RUNNING: Spinner.powerNap(RUNNER_POLLING_INTERVAL_AS_MILLI); @@ -280,9 +280,9 @@ public class WorkloadRunner { return; default: throw new IllegalStateException(format( - "Unknown %s: %s", - WorkloadRunnerThreadState.class.getSimpleName(), - WorkloadRunnerThreadState.NOT_STARTED.name() + "Unknown %s: %s", + WorkloadRunnerThreadState.class.getSimpleName(), + WorkloadRunnerThreadState.NOT_STARTED.name() )); } } @@ -313,7 +313,7 @@ public class WorkloadRunner { long spinnerSleepDurationAsMilli, boolean ignoreScheduleStartTimes, int operationHandlerExecutorsBoundedQueueSize) - throws WorkloadException, MetricsCollectionException { + throws WorkloadException, MetricsCollectionException { this.errorReporter = errorReporter; this.statusDisplayIntervalAsMilli = statusDisplayIntervalAsSeconds; @@ -321,11 +321,11 @@ public class WorkloadRunner { if (statusDisplayIntervalAsSeconds > 0) { this.workloadStatusThread = new WorkloadStatusThread( - TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds), - metricsService.getWriter(), - errorReporter, - completionTimeService, - loggingServiceFactory + TimeUnit.SECONDS.toMillis(statusDisplayIntervalAsSeconds), + metricsService.getWriter(), + errorReporter, + completionTimeService, + loggingServiceFactory ); } // only create a completion time writer for an executor if it contains at least one READ_WRITE operation @@ -334,29 +334,29 @@ public class WorkloadRunner { CompletionTimeWriter completionTimeWriterForAsynchronous; try { completionTimeWriterForAsynchronous = (asynchronousStream.dependencyOperations().hasNext()) - ? completionTimeService.newCompletionTimeWriter() - : DUMMY_COMPLETION_TIME_WRITER; + ? completionTimeService.newCompletionTimeWriter() + : DUMMY_COMPLETION_TIME_WRITER; } catch (CompletionTimeException e) { throw new WorkloadException("Error while attempting to create completion time writer", e); } this.executorForAsynchronous = new ThreadPoolOperationExecutor( - threadCount, - operationHandlerExecutorsBoundedQueueSize, - db, - asynchronousStream, - completionTimeWriterForAsynchronous, - completionTimeService, - spinner, - timeSource, - errorReporter, - metricsService, - asynchronousStream.childOperationGenerator() + threadCount, + operationHandlerExecutorsBoundedQueueSize, + db, + asynchronousStream, + completionTimeWriterForAsynchronous, + completionTimeService, + spinner, + timeSource, + errorReporter, + metricsService, + asynchronousStream.childOperationGenerator() ); this.asynchronousStreamExecutorService = new OperationStreamExecutorService( - errorReporter, - asynchronousStream, - executorForAsynchronous, - completionTimeWriterForAsynchronous + errorReporter, + asynchronousStream, + executorForAsynchronous, + completionTimeWriterForAsynchronous ); /*for ( WorkloadStreams.WorkloadStreamDefinition blockingStream : workloadStreams.blockingStreamDefinitions() ) @@ -461,17 +461,17 @@ public class WorkloadRunner { // // if normal shutdown all executors have completed by this stage long shutdownWait = (shutdownType.equals(ShutdownType.FORCED)) - ? 1 - : OperationStreamExecutorService.SHUTDOWN_WAIT_TIMEOUT_AS_MILLI; + ? 1 + : OperationStreamExecutorService.SHUTDOWN_WAIT_TIMEOUT_AS_MILLI; try { asynchronousStreamExecutorService.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while shutting down %s\n%s\n", - asynchronousStreamExecutorService.getClass().getSimpleName(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while shutting down %s\n%s\n", + asynchronousStreamExecutorService.getClass().getSimpleName(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } @@ -480,10 +480,10 @@ public class WorkloadRunner { blockingStreamExecutorService.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while shutting down %s\n%s\n", - blockingStreamExecutorService.getClass().getSimpleName(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while shutting down %s\n%s\n", + blockingStreamExecutorService.getClass().getSimpleName(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } } @@ -495,12 +495,12 @@ public class WorkloadRunner { executorForAsynchronous.shutdown(shutdownWait); } catch (OperationExecutorException e) { errorReporter.reportError( - this, - format("Encountered error while waiting for asynchronous executor to shutdown\n" - + "Handlers still running: %s\n" - + "%s", - executorForAsynchronous.uncompletedOperationHandlerCount(), - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while waiting for asynchronous executor to shutdown\n" + + "Handlers still running: %s\n" + + "%s", + executorForAsynchronous.uncompletedOperationHandlerCount(), + ConcurrentErrorReporter.stackTraceToString(e)) ); } @@ -517,12 +517,12 @@ public class WorkloadRunner { uncompletedOperationHandlerCount += executorForBlocking.uncompletedOperationHandlerCount(); } errorReporter.reportError( - this, - format("Encountered error while waiting for a synchronous executor to shutdown\n" - + "Handlers still running: %s\n" - + "%s", - uncompletedOperationHandlerCount, - ConcurrentErrorReporter.stackTraceToString(e)) + this, + format("Encountered error while waiting for a synchronous executor to shutdown\n" + + "Handlers still running: %s\n" + + "%s", + uncompletedOperationHandlerCount, + ConcurrentErrorReporter.stackTraceToString(e)) ); } diff --git a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java index c017e11..18e531c 100644 --- a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java +++ b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java @@ -47,10 +47,10 @@ public class ResultsLogValidator { * @return ResultsLogValidationResult containing the list of delayed operations */ public ResultsLogValidationResult validate( - ResultsLogValidationSummary summary, - ResultsLogValidationTolerances tolerances, - boolean recordDelayedOperations, - WorkloadResultsSnapshot workloadResults) { + ResultsLogValidationSummary summary, + ResultsLogValidationTolerances tolerances, + boolean recordDelayedOperations, + WorkloadResultsSnapshot workloadResults) { ResultsLogValidationResult result = new ResultsLogValidationResult(); @@ -65,8 +65,7 @@ public class ResultsLogValidator { long allowedLateOperations = Math.round( (cnt == null ? 0 : cnt) * tolerances.toleratedExcessiveDelayCountPercentage()); if (recordDelayedOperations - && summary.excessiveDelayCountPerType() - .get(operationType) > allowedLateOperations) { + && summary.excessiveDelayCountPerType().get(operationType) > allowedLateOperations) { result.aboveThreshold(); result.addError( ValidationErrorType.TOO_MANY_LATE_OPERATIONS, @@ -105,13 +104,12 @@ public class ResultsLogValidator { if (summary.excessiveDelayCountPerType() .get(operationType) > allowedLateOperations) { result.addError( - ValidationErrorType.TOO_MANY_LATE_OPERATIONS, - format("Late Count for %s (%s) > (%s) Tolerated Late Count", - operationType, - summary.excessiveDelayCountPerType() - .get(operationType), - allowedLateOperations - ) + ValidationErrorType.TOO_MANY_LATE_OPERATIONS, + format("Late Count for %s (%s) > (%s) Tolerated Late Count", + operationType, + summary.excessiveDelayCountPerType().get(operationType), + allowedLateOperations + ) ); } } @@ -136,18 +134,17 @@ public class ResultsLogValidator { * @return Summary of the delayed operations in a ResultsLogValidationSummary object * @throws ValidationException When the result CSV file could not be opened or invalid delay is computed. */ - public ResultsLogValidationSummary compute(File resultsLog, - long excessiveDelayThresholdAsMilli) - throws ValidationException { + public ResultsLogValidationSummary compute(File resultsLog, long excessiveDelayThresholdAsMilli) + throws ValidationException { long maxDelayAsMilli = maxDelayAsMilli(resultsLog); ResultsLogValidationSummaryCalculator calculator = new ResultsLogValidationSummaryCalculator( - maxDelayAsMilli, - excessiveDelayThresholdAsMilli + maxDelayAsMilli, + excessiveDelayThresholdAsMilli ); try (SimpleCsvFileReader reader = new SimpleCsvFileReader( - resultsLog, - SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { + resultsLog, + SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { // skip headers reader.next(); while (reader.hasNext()) { @@ -177,8 +174,8 @@ public class ResultsLogValidator { private long maxDelayAsMilli(File resultsLog) throws ValidationException { long maxDelayAsMilli = 0; try (SimpleCsvFileReader reader = new SimpleCsvFileReader( - resultsLog, - SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { + resultsLog, + SimpleCsvFileReader.DEFAULT_COLUMN_SEPARATOR_REGEX_STRING)) { // skip headers reader.next(); while (reader.hasNext()) { @@ -191,16 +188,15 @@ public class ResultsLogValidator { long delayAsMilli = actualStartTimeAsMilli - scheduledStartTimeAsMilli; if (delayAsMilli < 0) { throw new ValidationException( - format("Delay can not be negative\n" + "Delay: %s (ms) / %s\n" - + "Scheduled Start Time: %s (ms) / %s\n" - + "Actual Start Time: %s (ms) / %s", - delayAsMilli, - TEMPORAL_UTIL.milliDurationToString(delayAsMilli), - scheduledStartTimeAsMilli, - TEMPORAL_UTIL.milliTimeToTimeString(scheduledStartTimeAsMilli), - actualStartTimeAsMilli, - TEMPORAL_UTIL.milliTimeToTimeString(actualStartTimeAsMilli) - ) + format("Delay can not be negative\n" + "Delay: %s (ms) / %s\n" + + "Scheduled Start Time: %s (ms) / %s\n" + "Actual Start Time: %s (ms) / %s", + delayAsMilli, + TEMPORAL_UTIL.milliDurationToString(delayAsMilli), + scheduledStartTimeAsMilli, + TEMPORAL_UTIL.milliTimeToTimeString(scheduledStartTimeAsMilli), + actualStartTimeAsMilli, + TEMPORAL_UTIL.milliTimeToTimeString(actualStartTimeAsMilli) + ) ); } if (delayAsMilli > maxDelayAsMilli) { -- Gitee From 8afe4979ef819c4cce93ff92fdd2a18586a4e6de Mon Sep 17 00:00:00 2001 From: tongbing Date: Wed, 16 Apr 2025 00:10:39 +0800 Subject: [PATCH 3/4] modify the details to the original version --- .../org/graphybench/driver/driver/driver/Driver.java | 3 +-- .../driver/driver/driver/ExecuteWorkloadMode.java | 9 ++++----- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/main/java/org/graphybench/driver/driver/driver/Driver.java b/src/main/java/org/graphybench/driver/driver/driver/Driver.java index 714d4a2..a3f1b8a 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/Driver.java +++ b/src/main/java/org/graphybench/driver/driver/driver/Driver.java @@ -41,7 +41,6 @@ public class Driver { // Initial loggin service LoggingServiceFactory loggingServiceFactory = new Log4jLoggingServiceFactory(detailedStatus); LoggingService loggingService = loggingServiceFactory.loggingServiceFor(Driver.class.getSimpleName()); - loggingService.info("Driver Simple Name：" + Driver.class.getSimpleName()); try { TimeSource systemTimeSource = new SystemTimeSource(); @@ -63,11 +62,11 @@ public class Driver { System.exit(1); } catch (Exception e) { loggingService.info("Driver terminated unexpectedly\n" + ConcurrentErrorReporter.stackTraceToString(e)); + System.exit(1); } finally { if (null != controlService) { controlService.shutdown(); } - System.exit(0); } } diff --git a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java index 90fa01c..7b2dbdf 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java +++ b/src/main/java/org/graphybench/driver/driver/driver/ExecuteWorkloadMode.java @@ -407,11 +407,10 @@ public class ExecuteWorkloadMode implements DriverMode { format("Exporting workload results validation to: %s", resultsValidationFile.getAbsolutePath()) ); - // Files.write( - // resultsValidationFile.toPath(), - // resultsLogValidationSummary.toJson() - // .getBytes(StandardCharsets.UTF_8) - // ); + Files.write( + resultsValidationFile.toPath(), + resultsLogValidationSummary.toJson().getBytes(StandardCharsets.UTF_8) + ); // TODO export result ResultsLogValidationResult validationResult = resultsLogValidator.validate( resultsLogValidationSummary, -- Gitee From e257ead96063b4fe456824763971680ab0a60cab Mon Sep 17 00:00:00 2001 From: tongbing Date: Tue, 22 Apr 2025 20:32:01 +0800 Subject: [PATCH 4/4] add auto test copyright --- src/main/java/org/graphybench/driver/driver/Db.java | 4 ++++ .../driver/driver/PoolingOperationHandlerRunnerFactory.java | 4 ++++ src/main/java/org/graphybench/driver/driver/Workload.java | 4 ++++ .../driver/control/ConsoleAndFileDriverConfiguration.java | 5 +++++ .../driver/driver/control/DriverConfiguration.java | 5 +++++ .../org/graphybench/driver/driver/control/OperationMode.java | 5 +++++ .../graphybench/driver/driver/driver/AutomaticTestMode.java | 4 +++- .../java/org/graphybench/driver/driver/driver/Driver.java | 4 ++++ .../graphybench/driver/driver/runtime/WorkloadRunner.java | 4 ++++ .../driver/driver/validation/ResultsLogValidationResult.java | 4 ++++ .../driver/driver/validation/ResultsLogValidator.java | 4 ++++ 11 files changed, 46 insertions(+), 1 deletion(-) diff --git a/src/main/java/org/graphybench/driver/driver/Db.java b/src/main/java/org/graphybench/driver/driver/Db.java index 30072e7..da3c8fb 100644 --- a/src/main/java/org/graphybench/driver/driver/Db.java +++ b/src/main/java/org/graphybench/driver/driver/Db.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver; diff --git a/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java b/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java index 88bedc2..2db3472 100644 --- a/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java +++ b/src/main/java/org/graphybench/driver/driver/PoolingOperationHandlerRunnerFactory.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver; diff --git a/src/main/java/org/graphybench/driver/driver/Workload.java b/src/main/java/org/graphybench/driver/driver/Workload.java index 4f5320a..93129b2 100644 --- a/src/main/java/org/graphybench/driver/driver/Workload.java +++ b/src/main/java/org/graphybench/driver/driver/Workload.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver; diff --git a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java index 5ed85bc..ae92258 100644 --- a/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java +++ b/src/main/java/org/graphybench/driver/driver/control/ConsoleAndFileDriverConfiguration.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,8 +13,12 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ + package org.graphybench.driver.driver.control; import static java.lang.String.format; diff --git a/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java b/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java index 886e661..d4d193c 100644 --- a/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java +++ b/src/main/java/org/graphybench/driver/driver/control/DriverConfiguration.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,8 +13,12 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ + package org.graphybench.driver.driver.control; import java.util.Map; diff --git a/src/main/java/org/graphybench/driver/driver/control/OperationMode.java b/src/main/java/org/graphybench/driver/driver/control/OperationMode.java index 3d195ab..8cea72f 100644 --- a/src/main/java/org/graphybench/driver/driver/control/OperationMode.java +++ b/src/main/java/org/graphybench/driver/driver/control/OperationMode.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,8 +13,12 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ + package org.graphybench.driver.driver.control; public enum OperationMode { diff --git a/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java b/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java index 3adcd77..e1bc6ad 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java +++ b/src/main/java/org/graphybench/driver/driver/driver/AutomaticTestMode.java @@ -1,5 +1,5 @@ /* - * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,8 +12,10 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * */ + package org.graphybench.driver.driver.driver; import static java.lang.String.format; diff --git a/src/main/java/org/graphybench/driver/driver/driver/Driver.java b/src/main/java/org/graphybench/driver/driver/driver/Driver.java index a3f1b8a..17681bc 100644 --- a/src/main/java/org/graphybench/driver/driver/driver/Driver.java +++ b/src/main/java/org/graphybench/driver/driver/driver/Driver.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver.driver; diff --git a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java index 678d8b1..11347be 100644 --- a/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java +++ b/src/main/java/org/graphybench/driver/driver/runtime/WorkloadRunner.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver.runtime; diff --git a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java index 853d23b..71d71b7 100644 --- a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java +++ b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidationResult.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver.validation; diff --git a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java index 18e531c..7342511 100644 --- a/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java +++ b/src/main/java/org/graphybench/driver/driver/validation/ResultsLogValidator.java @@ -1,5 +1,6 @@ /* * Copyright © 2022 Linked Data Benchmark Council (info@ldbcouncil.org) + * Copyright © 2025 BingTong@CreateLink (tongbing@chuanglintech.com) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -12,6 +13,9 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. + * + * Modifications: + * - Added automatic test mode (2025) by BingTong@CreateLink (tongbing@chuanglintech.com) */ package org.graphybench.driver.driver.validation; -- Gitee