Java tutorial
/* This file is part of VoltDB. * Copyright (C) 2008-2015 VoltDB Inc. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /* * This samples uses the native asynchronous request processing protocol * to post requests to the VoltDB server, thus leveraging to the maximum * VoltDB's ability to run requests in parallel on multiple database * partitions, and multiple servers. * * While asynchronous processing is (marginally) more convoluted to work * with and not adapted to all workloads, it is the preferred interaction * model to VoltDB as it guarantees blazing performance. * * Because there is a risk of 'firehosing' a database cluster (if the * cluster is too slow (slow or too few CPUs), this sample performs * self-tuning to target a specific latency (10ms by default). * This tuning process, as demonstrated here, is important and should be * part of your pre-launch evalution so you can adequately provision your * VoltDB cluster with the number of servers required for your needs. */ package voltkvqa; import java.io.IOException; import java.nio.ByteBuffer; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Random; import java.util.Timer; import java.util.TimerTask; import java.util.Map.Entry; import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import org.apache.commons.lang3.time.DateFormatUtils; import org.voltdb.CLIConfig; import org.voltdb.VoltTable; import org.voltdb.VoltTableRow; import org.voltdb.client.Client; import org.voltdb.client.ClientConfig; import org.voltdb.client.ClientFactory; import org.voltdb.client.ClientResponse; import org.voltdb.client.ClientStats; import org.voltdb.client.ClientStatsContext; import org.voltdb.client.ClientStatusListenerExt; import org.voltdb.client.NoConnectionsException; import org.voltdb.client.NullCallback; import org.voltdb.client.ProcedureCallback; public class AsyncBenchmark { boolean slow = false; boolean debug = false; // handy, rather than typing this out several times static final String HORIZONTAL_RULE = "----------" + "----------" + "----------" + "----------" + "----------" + "----------" + "----------" + "----------" + "\n"; // validated command line configuration final KVConfig config; // Reference to the database connection we will use final Client client; // Timer for periodic stats printing Timer timer; // Benchmark start time long benchmarkStartTS; // Get a payload generator to create random Key-Value pairs to store in the database // and process (uncompress) pairs retrieved from the database. final PayloadProcessor processor; // random number generator with constant seed final Random rand = new Random(0); // Statistics manager objects from the client final ClientStatsContext periodicStatsContext; final ClientStatsContext fullStatsContext; // kv benchmark state final AtomicLong successfulGets = new AtomicLong(0); final AtomicLong missedGets = new AtomicLong(0); final AtomicLong failedGets = new AtomicLong(0); final AtomicLong rawGetData = new AtomicLong(0); final AtomicLong networkGetData = new AtomicLong(0); final AtomicLong successfulPuts = new AtomicLong(0); final AtomicLong failedPuts = new AtomicLong(0); final AtomicLong rawPutData = new AtomicLong(0); final AtomicLong networkPutData = new AtomicLong(0); private AtomicInteger totalConnections = new AtomicInteger(0); private static AtomicInteger fatalLevel = new AtomicInteger(0); private static final AtomicLong successfulPutCount = new AtomicLong(0); private static final AtomicLong missingPutCount = new AtomicLong(0); private static final AtomicLong incorrectPutCount = new AtomicLong(0); private static Map<String, Long> hashMap = Collections.synchronizedMap(new HashMap<String, Long>()); final AtomicLong successfulGetsMPT = new AtomicLong(0); final AtomicLong successfulGetsMPF = new AtomicLong(0); final AtomicLong successfulPutsMPT = new AtomicLong(0); final AtomicLong successfulPutsMPF = new AtomicLong(0); long lastSuccessfulResponse = 0; /** * Uses included {@link CLIConfig} class to * declaratively state command line options with defaults * and validation. */ static class KVConfig extends CLIConfig { @Option(desc = "If it's set false, it'll quit right away when lost all connections.") boolean recover = true; @Option(desc = "Interval for performance feedback, in seconds.") long displayinterval = 5; @Option(desc = "Benchmark duration, in seconds.") int duration = 120; @Option(desc = "Max number of puts. This does not count any preloading or warmup and may not be reached if duration is too short.") long maxputs = Long.MAX_VALUE; @Option(desc = "Warmup duration in seconds.") int warmup = 0; @Option(desc = "Comma separated list of the form server[:port] to connect to.") String servers = "localhost"; @Option(desc = "Number of keys to preload.") int poolsize = 100000; @Option(desc = "Whether to preload a specified number of keys and values.") boolean preload = true; @Option(desc = "Preload starting key value.") int preloadLowKey = 0; @Option(desc = "Whether to run the benchmark (permits exiting after the preload.") boolean runbenchmark = true; @Option(desc = "Controls if counts are checked at end of run.") boolean checkdata = true; @Option(desc = "Fraction of ops that are gets (vs puts).") double getputratio = 0.90; @Option(desc = "Fraction of ops that are gets (singlePartition vs multiPartition) " + "and puts (singlePartition vs multiPartition).") double multisingleratio = 0; // By default, don't run multi-partition @Option(desc = "Size of keys in bytes.") int keysize = 32; @Option(desc = "Minimum value size in bytes.") int minvaluesize = 1024; @Option(desc = "Maximum value size in bytes.") int maxvaluesize = 1024; @Option(desc = "Number of values considered for each value byte.") int entropy = 127; @Option(desc = "Compress values on the client side.") boolean usecompression = false; @Option(desc = "Maximum TPS rate for benchmark.") int ratelimit = Integer.MAX_VALUE; @Option(desc = "Determine transaction rate dynamically based on latency.") boolean autotune = false; @Option(desc = "Server-side latency target for auto-tuning.") int latencytarget = 5; @Option(desc = "Filename to write raw summary statistics to.") String statsfile = ""; @Override public void validate() { if (duration <= 0) exitWithMessageAndUsage("duration must be > 0"); if (warmup < 0) exitWithMessageAndUsage("warmup must be >= 0"); if (displayinterval <= 0) exitWithMessageAndUsage("displayinterval must be > 0"); if (poolsize <= 0) exitWithMessageAndUsage("poolsize must be > 0"); if (getputratio < 0) exitWithMessageAndUsage("getputratio must be >= 0"); if (getputratio > 1) exitWithMessageAndUsage("getputratio must be <= 1"); if (multisingleratio < 0) exitWithMessageAndUsage("multisingleratio must be >= 0"); if (multisingleratio > 1) exitWithMessageAndUsage("multisingleratio must be <= 1"); if (keysize <= 0) exitWithMessageAndUsage("keysize must be > 0"); if (keysize > 250) exitWithMessageAndUsage("keysize must be <= 250"); if (minvaluesize <= 0) exitWithMessageAndUsage("minvaluesize must be > 0"); if (maxvaluesize <= 0) exitWithMessageAndUsage("maxvaluesize must be > 0"); if (entropy <= 0) exitWithMessageAndUsage("entropy must be > 0"); if (entropy > 127) exitWithMessageAndUsage("entropy must be <= 127"); if (ratelimit <= 0) exitWithMessageAndUsage("ratelimit must be > 0"); if (latencytarget <= 0) exitWithMessageAndUsage("latencytarget must be > 0"); if (preloadLowKey < 0) exitWithMessageAndUsage("preloadlowkey must be >= 0"); } } /** * Fake an internal jstack to the log */ static public void printJStack() { prt(new Date().toString() + " Full thread dump"); Map<String, List<String>> deduped = new HashMap<String, List<String>>(); // collect all the output, but dedup the identical stack traces for (Entry<Thread, StackTraceElement[]> e : Thread.getAllStackTraces().entrySet()) { Thread t = e.getKey(); String header = String.format("\"%s\" %sprio=%d tid=%d %s", t.getName(), t.isDaemon() ? "daemon " : "", t.getPriority(), t.getId(), t.getState().toString()); String stack = ""; for (StackTraceElement ste : e.getValue()) { stack += " at " + ste.toString() + "\n"; } if (deduped.containsKey(stack)) { deduped.get(stack).add(header); } else { ArrayList<String> headers = new ArrayList<String>(); headers.add(header); deduped.put(stack, headers); } } for (Entry<String, List<String>> e : deduped.entrySet()) { String logline = ""; for (String header : e.getValue()) { logline += header + "\n"; } logline += e.getKey(); prt(logline); } } /** * Provides a callback to be notified on node failure. * This example only logs the event. */ class StatusListener extends ClientStatusListenerExt { @Override public void connectionLost(String hostname, int port, int connectionsLeft, DisconnectCause cause) { // if the benchmark is still active long currentTime = System.currentTimeMillis(); if ((currentTime - benchmarkStartTS) < (config.duration * 1000)) { if (debug) { long diff = currentTime - benchmarkStartTS; String msg = "Time remaining in seconds: " + diff / 1000l + ", connectionsLeft: " + connectionsLeft + ", Total Connections detected by this client: " + totalConnections.get(); prt(msg); } System.err.printf("Connection to %s:%d was lost.\n", hostname, port); totalConnections.decrementAndGet(); if (!config.recover) { if (totalConnections.get() == 0) { //totalConnections.set(-1); System.exit(1); } } } // if ((currentTime - benchmarkStartTS) < (config.duration * 1000)) } } /** * Constructor for benchmark instance. * Configures VoltDB client and prints configuration. * * @param config Parsed & validated CLI options. */ public AsyncBenchmark(KVConfig config) { this.config = config; ClientConfig clientConfig = new ClientConfig("", "", new StatusListener()); clientConfig.setReconnectOnConnectionLoss(config.recover); if (config.autotune) { clientConfig.enableAutoTune(); clientConfig.setAutoTuneTargetInternalLatency(config.latencytarget); } else { clientConfig.setMaxTransactionsPerSecond(config.ratelimit); } client = ClientFactory.createClient(clientConfig); periodicStatsContext = client.createStatsContext(); fullStatsContext = client.createStatsContext(); processor = new PayloadProcessor(config.keysize, config.minvaluesize, config.maxvaluesize, config.entropy, config.poolsize, config.usecompression); System.out.print(HORIZONTAL_RULE); System.out.println(" Command Line Configuration"); System.out.println(HORIZONTAL_RULE); System.out.println(config.getConfigDumpString()); } /** * Connect to a single server with retry. Limited exponential backoff. * No timeout. This will run until the process is killed if it's not * able to connect. * * @param server hostname:port or just hostname (hostname can be ip). */ void connectToOneServerWithRetry(String server, String info) { /* * Possible exceptions are: * 1) Exception: java.net.ConnectException: Connection refused * 2) Exception: java.io.IOException: Failed to authenticate to rejoining node * 3) Exception: java.io.IOException: Cluster instance id mismatch. * The third one could indicate a bug. */ int sleep = 1000; boolean flag = true; String msg; if (fatalLevel.get() > 0) { System.err.printf("In connectToOneServerWithRetry, don't bother to try reconnecting to this host: %s\n", server); flag = false; } while (flag) { try { client.createConnection(server); totalConnections.incrementAndGet(); msg = "Connected to VoltDB node at: " + server + ", IDs: " + client.getInstanceId()[0] + " - " + client.getInstanceId()[1] + ", totalConnections = " + totalConnections.get(); prt(msg); break; } catch (Exception e) { if (debug) { msg = "\n---------------\n" + info + "\n---------------\n" + "Failed to connect server: " + server + ", remaining totalConnections = '" + totalConnections.get() + "'\nReason for connection failed: '" + e.getMessage() + "'"; prt(msg); } msg = "Connection to " + server + " failed - retrying in " + sleep / 1000 + " second(s)"; prt(msg); try { Thread.sleep(sleep); } catch (Exception interruted) { msg = "A possible hiccup, seriously?? Exception: '" + interruted.getMessage() + "'.\nStop trying to reconnect to this host: " + server; prt(msg); fatalLevel.incrementAndGet(); flag = false; } if (sleep < 8000) sleep += sleep; if ((e.getMessage().contains("Cluster instance id mismatch"))) { msg = "A possible bug? Could be a serious exception:" + e.getMessage() + "\nStop trying to reconnect to this host: " + server; prt(msg); fatalLevel.incrementAndGet(); flag = false; } else if ((e.getMessage().contains("Client instance is shutdown"))) { msg = "Dangling client is detected. Stop trying to connect to this host: " + server; prt(msg); flag = false; } } } } /** * Connect to a set of servers in parallel. Each will retry until * connection. This call will block until all have connected. * * @param servers A comma separated list of servers using the hostname:port * syntax (where :port is optional). * @throws InterruptedException if anything bad happens with the threads. */ void connect(String servers, final String info) throws InterruptedException { String[] serverArray = servers.split(","); String msg; final CountDownLatch connections = new CountDownLatch(1); if (debug) { msg = "\n=========\n" + info + "\nIn connect Server counts: " + serverArray.length + ", Server Names: " + servers; prt(msg); } // use a new thread to connect to each server for (final String server : serverArray) { new Thread(new Runnable() { @Override public void run() { connectToOneServerWithRetry(server, info); connections.countDown(); } }).start(); } connections.await(); } /** * Create a Timer task to display performance data on the Vote procedure * It calls printStatistics() every displayInterval seconds */ public void schedulePeriodicStats() { timer = new Timer(true); TimerTask statsPrinting = new TimerTask() { @Override public void run() { printStatistics(); } }; timer.scheduleAtFixedRate(statsPrinting, config.displayinterval * 1000, config.displayinterval * 1000); } /** * Prints a one line update on performance that can be printed * periodically during a benchmark. */ public synchronized void printStatistics() { try { ClientStats stats = periodicStatsContext.fetchAndResetBaseline().getStats(); System.out.printf("%s ", dateformat(getTime())); System.out.printf("Throughput %d/s, ", stats.getTxnThroughput()); System.out.printf("Aborts/Failures %d/%d, ", stats.getInvocationAborts(), stats.getInvocationErrors()); System.out.printf("Avg/95%% Latency %.2f/%.2fms\n", stats.getAverageLatency(), stats.kPercentileLatencyAsDouble(0.95)); if (totalConnections.get() == -1 && stats.getTxnThroughput() == 0) { if (!config.recover) { String errMsg = "Lost all connections. Exit..."; exitOnError(errMsg); } } } catch (Exception e) { String msg = "In printStatistics. We got an exception: '" + e.getMessage() + "'!!"; prt(msg); } if (lastSuccessfulResponse > 0 && (System.currentTimeMillis() - lastSuccessfulResponse) > 6 * 60 * 1000) { prt("Not making any progress, last at " + (new SimpleDateFormat("yyyy-MM-DD HH:mm:ss.S")).format(new Date(lastSuccessfulResponse)) + ", exiting"); printJStack(); System.exit(1); } } public void exitOnError(String err) { prt(err); // cancel periodic stats printing timer.cancel(); // block until all outstanding txns return try { client.drain(); } catch (NoConnectionsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } // print the summary results try { printResults(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } // close down the client connections try { client.close(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.exit(1); } /** * Prints the results of the voting simulation and statistics * about performance. * * @throws Exception if anything unexpected happens. */ public synchronized void printResults() throws Exception { ClientStats stats = fullStatsContext.fetch().getStats(); // 1. Get/Put performance results String display = "\n" + HORIZONTAL_RULE + " KV Store Results\n" + HORIZONTAL_RULE + "\nA total of %,d operations were posted...\n" + " - GETs: %,9d Operations (%,d Misses and %,d Failures)\n" + " %,9d Multi-partition Operations (%.2f%%)\n" + " %,9d Single-partition Operations (%.2f%%)\n" + " %,9d MB in compressed store data\n" + " %,9d MB in uncompressed application data\n" + " Network Throughput: %6.3f Gbps*\n" + " - PUTs: %,9d Operations (%,d Failures)\n" + " %,9d Multi-partition Operations (%.2f%%)\n" + " %,9d Single-partition Operations (%.2f%%)\n" + " %,9d MB in compressed store data\n" + " %,9d MB in uncompressed application data\n" + " Network Throughput: %6.3f Gbps*\n" + " - Total Network Throughput: %6.3f Gbps*\n\n" + "* Figure includes key & value traffic but not database protocol overhead.\n\n"; double oneGigabit = (1024 * 1024 * 1024) / 8; long oneMB = (1024 * 1024); double getThroughput = networkGetData.get() + (successfulGets.get() * config.keysize); getThroughput /= (oneGigabit * config.duration); long totalPuts = successfulPuts.get() + failedPuts.get(); double putThroughput = networkGetData.get() + (totalPuts * config.keysize); putThroughput /= (oneGigabit * config.duration); long gtt = successfulGetsMPT.get() + successfulGetsMPF.get(); long gst = successfulGetsMPT.get(); long gsf = successfulGetsMPF.get(); double getMptR = (double) (100.00 * gst / gtt); double getMpfR = (double) (100.00 * gsf / gtt); //System.out.printf("st = %d, sf = %d, tt = %d, getMptR = '%.2f%%', getMpfR = '%.2f%%',", // gst, gsf, gtt, getMptR, getMpfR); long ptt = successfulPutsMPT.get() + successfulPutsMPF.get(); long pst = successfulPutsMPT.get(); long psf = successfulPutsMPF.get(); double putMptR = (double) (100.00 * pst / ptt); double putMpfR = (double) (100.00 * psf / ptt); System.out.printf(display, stats.getInvocationsCompleted(), successfulGets.get(), missedGets.get(), failedGets.get(), successfulGetsMPT.get(), getMptR, successfulGetsMPF.get(), getMpfR, networkGetData.get() / oneMB, rawGetData.get() / oneMB, getThroughput, successfulPuts.get(), failedPuts.get(), successfulPutsMPT.get(), putMptR, successfulPutsMPF.get(), putMpfR, networkPutData.get() / oneMB, rawPutData.get() / oneMB, putThroughput, getThroughput + putThroughput); // 2. Performance statistics System.out.print(HORIZONTAL_RULE); System.out.println(" Client Workload Statistics"); System.out.println(HORIZONTAL_RULE); System.out.printf("Average throughput: %,9d txns/sec\n", stats.getTxnThroughput()); System.out.printf("Average latency: %,9.2f ms\n", stats.getAverageLatency()); System.out.printf("95th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.95)); System.out.printf("99th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.99)); System.out.print("\n" + HORIZONTAL_RULE); System.out.println(" System Server Statistics"); System.out.println(HORIZONTAL_RULE); if (config.autotune) { System.out.printf("Targeted Internal Avg Latency: %,9d ms\n", config.latencytarget); } System.out.printf("Reported Internal Avg Latency: %,9.2f ms\n", stats.getAverageInternalLatency()); // 3. Write stats to file if requested client.writeSummaryCSV(stats, config.statsfile); } /** * Callback to handle the response to a stored procedure call. * Tracks response types. * */ class GetCallback implements ProcedureCallback { double rand; GetCallback(double rand) { this.rand = rand; } @Override public void clientCallback(ClientResponse response) throws Exception { // Track the result of the operation (Success, Failure, Payload traffic...) if (response.getStatus() == ClientResponse.SUCCESS) { final VoltTable pairData = response.getResults()[0]; // Cache miss (Key does not exist) if (pairData.getRowCount() == 0) { missedGets.incrementAndGet(); } else { final PayloadProcessor.Pair pair = processor.retrieveFromStore( pairData.fetchRow(0).getString(0), pairData.fetchRow(0).getVarbinary(1)); successfulGets.incrementAndGet(); lastSuccessfulResponse = System.currentTimeMillis(); if (rand < config.multisingleratio) successfulGetsMPT.incrementAndGet(); else successfulGetsMPF.incrementAndGet(); networkGetData.addAndGet(pair.getStoreValueLength()); rawGetData.addAndGet(pair.getRawValueLength()); } } else { failedGets.incrementAndGet(); } } } class PutCallback implements ProcedureCallback { final long storeValueLength; final long rawValueLength; PayloadProcessor.Pair thisPair; double rand; PutCallback(PayloadProcessor.Pair pair, double rand) { storeValueLength = pair.getStoreValueLength(); rawValueLength = pair.getRawValueLength(); thisPair = pair; this.rand = rand; } @Override public void clientCallback(ClientResponse response) throws Exception { // Track the result of the operation (Success, Failure, Payload traffic...) if (response.getStatus() == ClientResponse.SUCCESS) { successfulPuts.incrementAndGet(); if (rand < config.multisingleratio) successfulPutsMPT.incrementAndGet(); else successfulPutsMPF.incrementAndGet(); final VoltTable pairData = response.getResults()[0]; final VoltTableRow tablerow = pairData.fetchRow(0); final long counter = tablerow.getLong(0); hashMap.put(thisPair.Key, counter); lastSuccessfulResponse = System.currentTimeMillis(); } else { failedPuts.incrementAndGet(); } networkPutData.addAndGet(storeValueLength); rawPutData.addAndGet(rawValueLength); } } class SumCallback implements ProcedureCallback { String key = null; int c; int i; public SumCallback(String key, int c, int i) { this.c = c; // line count this.i = i; // print interval this.key = key; } @Override public void clientCallback(ClientResponse response) throws Exception { if (response.getStatus() == ClientResponse.SUCCESS) { final VoltTable pairData = response.getResults()[0]; if (pairData.getRowCount() != 0) { successfulPutCount.incrementAndGet(); final long hashMapCount = hashMap.get(key); final long dbCount = ByteBuffer.wrap(pairData.fetchRow(0).getVarbinary(1)).getLong(0); if (dbCount < hashMapCount) { missingPutCount.incrementAndGet(); incorrectPutCount.addAndGet(hashMapCount - dbCount); System.out.printf("ERROR: Key %s: count in db '%d' is less than client expected '%d'\n", key.replaceAll("\\s", ""), dbCount, hashMapCount); } } } else { System.out.print("ERROR: Bad Client response from Volt"); System.exit(1); } } } /** * Core benchmark code. * Connect. Initialize. Run the loop. Cleanup. Print Results. * * @throws Exception if anything unexpected happens. */ public void runBenchmark() throws Exception { System.out.print(HORIZONTAL_RULE); System.out.println(" Setup & Initialization"); System.out.println(HORIZONTAL_RULE); // preload keys if requested System.out.println(); if (config.preload) { System.out.println("Preloading data store..."); for (int i = config.preloadLowKey; i < config.poolsize; i++) { client.callProcedure(new NullCallback(), "Put", String.format(processor.KeyFormat, i), processor.generateForStore().getStoreValue()); lastSuccessfulResponse = System.currentTimeMillis(); } client.drain(); System.out.println("Preloading complete.\n"); } if (!config.runbenchmark) { System.out.println("Benchmark run disabled by --runbenchmark option, exiting now"); System.exit(0); } System.out.print(HORIZONTAL_RULE); System.out.println("Starting Benchmark"); System.out.println(HORIZONTAL_RULE); // Run the benchmark loop for the requested warmup time // The throughput may be throttled depending on client configuration if (config.warmup > 0) { System.out.println("Warming up..."); final long warmupEndTime = System.currentTimeMillis() + (1000l * config.warmup); while (warmupEndTime > System.currentTimeMillis()) { // Decide whether to perform a GET or PUT operation if (rand.nextDouble() < config.getputratio) { // Get a key/value pair, asynchronously client.callProcedure(new NullCallback(), "Get", processor.generateRandomKeyForRetrieval()); } else { // Put a key/value pair, asynchronously final PayloadProcessor.Pair pair = processor.generateForStore(); client.callProcedure(new NullCallback(), "Put", pair.Key, pair.getStoreValue()); } lastSuccessfulResponse = System.currentTimeMillis(); } } // reset the stats after warmup fullStatsContext.fetchAndResetBaseline(); periodicStatsContext.fetchAndResetBaseline(); // print periodic statistics to the console benchmarkStartTS = System.currentTimeMillis(); schedulePeriodicStats(); if (totalConnections.get() == 1) // If Volt is running on one node only, no need to run this test on multi-partition config.multisingleratio = 0; // Run the benchmark loop for the requested duration or txn count // The throughput may be throttled depending on client configuration System.out.println("\nRunning benchmark..."); final long benchmarkEndTime = System.currentTimeMillis() + (1000l * config.duration); long currentTime = System.currentTimeMillis(); long diff = benchmarkEndTime - currentTime; int i = 1; long putCount = 0; double mpRand; String msg = ""; while (benchmarkEndTime > currentTime && putCount < config.maxputs) { if (debug && diff != 0 && diff % 5000.00 == 0 && i % 5 == 0) { msg = "i = " + i + ", Time remaining in seconds: " + diff / 1000l + ", totalConnections = " + totalConnections.get(); prt(msg); i++; } if (totalConnections.get() < 1) { if (debug) { msg = "i = " + i + ", diff = '" + diff + ", totalConnections = " + totalConnections.get() + "\n"; } msg += "All connections are lost! VoltDB could be down!!"; prt(msg); System.exit(1); } // Decide whether to perform a GET or PUT operation if (rand.nextDouble() < config.getputratio) { // Get a key/value pair, asynchronously mpRand = rand.nextDouble(); if (mpRand < config.multisingleratio) { if (totalConnections.get() > 1 && config.poolsize > 10000) { slow = true; debug = true; } else debug = false; client.callProcedure(new GetCallback(mpRand), "GetMp", processor.generateRandomKeyForRetrieval()); } else { client.callProcedure(new GetCallback(mpRand), "Get", processor.generateRandomKeyForRetrieval()); } } else { // Put a key/value pair, asynchronously putCount++; final PayloadProcessor.Pair pair = processor.generateForStore(); mpRand = rand.nextDouble(); if (rand.nextDouble() < config.multisingleratio) { if (totalConnections.get() > 1 && config.poolsize > 10000) { slow = true; debug = true; } else debug = false; client.callProcedure(new PutCallback(pair, mpRand), "PutMp", pair.Key, pair.getStoreValue()); } else { client.callProcedure(new PutCallback(pair, mpRand), "Put", pair.Key, pair.getStoreValue()); } } currentTime = System.currentTimeMillis(); diff = benchmarkEndTime - currentTime; } timer.cancel(); } public void closeClient() { // cancel periodic stats printing try { timer.cancel(); } catch (Exception e) { String msg = "In closeOldClient exception = '" + e.getMessage() + "'."; prt(msg); } try { client.drain(); } catch (NoConnectionsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } // close down the client connections try { client.close(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public void readyToExit() { // block until all outstanding txns return try { client.drain(); } catch (NoConnectionsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } if (config.checkdata) summary4qa(); try { client.drain(); } catch (NoConnectionsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } // close down the client connections try { client.close(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.exit(0); } public void summary4qa() { // print the summary results try { printResults(); } catch (Exception e) { e.printStackTrace(); } System.out.printf("\n\nChecking put count in the database against expected data"); Iterator<String> it = hashMap.keySet().iterator(); if (debug) { System.out.printf("HashMap Size: %10d\n", hashMap.size()); System.out.println("poolsize = " + config.poolsize); } try { int printInterval = (int) hashMap.size() / 5; if (hashMap.size() > 10000) if (slow) printInterval = (int) config.poolsize / 200; int c = 0; String lastkey = "error"; while (it.hasNext()) { String key = it.next().toString(); if (debug && c % printInterval == 0) System.out.printf("in summary4qa() count = %d, key = '%s'\n", c, key); client.callProcedure(new SumCallback(key, c, printInterval), "Get", key); lastkey = key; c++; } if (debug) System.out.printf("In summary4qa, count = %d, Last Key = '%s'\n", c, lastkey); } catch (Exception x) { System.out.println("This is not working: " + x + "\n"); x.printStackTrace(); System.exit(1); } try { client.drain(); } catch (NoConnectionsException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("\n-------------------\nTest Results:\n-------------------\n"); System.out.printf("\n\t%10d\tKV Rows Checked\n", hashMap.size()); System.out.printf("\t%10d\tKV Rows Found in database\n", successfulPutCount.get()); System.out.printf("\t%10d\tKV Rows Missing in database\n", hashMap.size() - successfulPutCount.get()); System.out.printf("\n\t%10d\tKV Rows are Correct\n", successfulPutCount.get() - missingPutCount.get()); System.out.printf("\t%10d\tKV Rows are Incorrect (off by %d Puts)\n", missingPutCount.get(), incorrectPutCount.get()); if (successfulPutCount.get() == hashMap.size() && missingPutCount.get() == 0) { System.out.println("\n-------------------\nGood News: Database Put counts match\n"); } else { System.out.println("\n-------------------\nError! Database Put counts don't match!!\n"); System.exit(1); } } public AtomicInteger get_totalConnections() { return totalConnections; } public static String dateformat(long ctime) { return DateFormatUtils.format(ctime, "yyyy-MM-dd HH:mm:ss,SSS"); } public static long getTime() { return System.currentTimeMillis(); } public static void prt(String str) { System.out.println(dateformat(getTime()) + "\t" + str + "\n"); } /** * Main routine creates a benchmark instance and kicks off the run method. * * @param args Command line arguments. * @throws Exception if anything goes wrong. * @see {@link KVConfig} */ public static void main(String[] args) throws Exception { prt("\n\n"); String msg = "Test Starts!!!"; prt(msg); // create a configuration from the arguments KVConfig config = new KVConfig(); config.parse(AsyncBenchmark.class.getName(), args); AsyncBenchmark benchmark = new AsyncBenchmark(config); int numOfHosts = config.servers.split(",").length; benchmark.connect(config.servers, "In Main First Time"); AtomicInteger totalConnections; try { totalConnections = benchmark.get_totalConnections(); if (benchmark.debug) { msg = "In main..try block before runBenchmark. totalConnections = '" + totalConnections.get() + "'\n"; prt(msg); } if (numOfHosts != totalConnections.get() && fatalLevel.get() > 0) { msg = "Error!! We expect to connect " + numOfHosts + " hosts, which are " + config.servers + "\n"; msg += "However, the actual total connections are " + totalConnections.get() + "\n"; prt(msg); } else benchmark.runBenchmark(); if (benchmark.debug) { msg = "In main..try block after runBenchmark. totalConnections = '" + totalConnections.get() + "'\n"; prt(msg); } benchmark.readyToExit(); } catch (org.voltdb.client.NoConnectionsException x) { benchmark.closeClient(); if (benchmark.debug) { totalConnections = benchmark.get_totalConnections(); msg = "In main..catch block before instanciate benchmark\n" + "totalConnections = " + totalConnections.get() + ", hashMap size: " + AsyncBenchmark.hashMap.size(); prt(msg); } if (config.recover) { benchmark = new AsyncBenchmark(config); totalConnections = benchmark.get_totalConnections(); long currentTime = System.currentTimeMillis(); if (benchmark.debug) { msg = "In main..catch block after instanciate benchmark\n" + "currentTime = " + currentTime + ", totalConnections = " + totalConnections.get() + ",hashMap size: " + AsyncBenchmark.hashMap.size(); prt(msg); } Thread.sleep(5000); // sleep 5 seconds msg = "Reconnecting to these severs: " + config.servers; prt(msg); benchmark.connect(config.servers, "In catch Second Time"); totalConnections = benchmark.get_totalConnections(); msg = "Reconnected to these severs: '" + config.servers + "', totalConnections = " + totalConnections.get(); prt(msg); if (numOfHosts != totalConnections.get() && fatalLevel.get() > 0) { msg = "Error!! We expect to connect " + numOfHosts + " hosts, which are " + config.servers + "\n"; msg += "However, the actual total connections are " + totalConnections.get() + "\n"; prt(msg); benchmark.client.close(); } else if (fatalLevel.get() > 0) { msg = "There could be an error during this run which could be caused by a hick-up."; msg += "\nPlease check the logs for detailed infomation."; prt(msg); } if (benchmark.debug) { msg = "In main..catch block, these severs '" + config.servers + "' should be connected.\n"; msg += "totalConnections = '" + totalConnections.get() + "'\n"; prt(msg); } //Thread.sleep(120000); if (benchmark.debug) { totalConnections = benchmark.get_totalConnections(); msg = "In main..catch block Ready To Exit, totalConnections = " + totalConnections.get(); prt(msg); } benchmark.readyToExit(); } // if(config.recover) else { msg = "Lost all connections without recover. Exit..."; prt(msg); benchmark.timer.cancel(); System.exit(1); } } // catch(org.voltdb.client.NoConnectionsException x) } }