use of java.util.TimerTask in project voltdb by VoltDB.
the class AsyncBenchmark method schedulePeriodicStats.
/**
* Create a Timer task to display performance data on the Vote procedure It
* calls printStatistics() every displayInterval seconds
*/
public void schedulePeriodicStats() {
timer = new Timer();
TimerTask statsPrinting = new TimerTask() {
@Override
public void run() {
printStatistics();
}
};
timer.scheduleAtFixedRate(statsPrinting, config.displayinterval * 1000, config.displayinterval * 1000);
}
use of java.util.TimerTask in project voltdb by VoltDB.
the class Benchmark method scheduleRunTimer.
/**
* Create a Timer task to time the run
* at end of run, check if we actually did anything
*/
private void scheduleRunTimer() throws IOException {
runTimer = new Timer("Run Timer", true);
TimerTask runEndTask = new TimerTask() {
@Override
public void run() {
log.info(HORIZONTAL_RULE);
log.info("Benchmark Complete");
int exitcode = 0;
// check if loaders are done or still working
if (partBiglt != null) {
int lpcc = partBiglt.getPercentLoadComplete();
if (!partBiglt.isAlive() && lpcc < 100) {
exitcode = reportDeadThread(partBiglt, " yet only " + Integer.toString(lpcc) + "% rows have been loaded");
} else
log.info(partBiglt + " was at " + lpcc + "% of rows loaded");
}
if (replBiglt != null) {
int lpcc = replBiglt.getPercentLoadComplete();
if (!replBiglt.isAlive() && lpcc < 100) {
exitcode = reportDeadThread(replBiglt, " yet only " + Integer.toString(lpcc) + "% rows have been loaded");
} else
log.info(replBiglt + " was at " + lpcc + "% of rows loaded");
}
// check if all threads still alive
if (partTrunclt != null && !partTrunclt.isAlive())
exitcode = reportDeadThread(partTrunclt);
if (replTrunclt != null && !replTrunclt.isAlive())
exitcode = reportDeadThread(replTrunclt);
/* XXX if (! partLoadlt.isAlive())
exitcode = reportDeadThread(partLoadlt);
if (! replLoadlt.isAlive())
exitcode = reportDeadThread(replLoadlt);
*/
if (readThread != null && !readThread.isAlive())
exitcode = reportDeadThread(readThread);
if (adHocMayhemThread != null && !config.disableadhoc && !adHocMayhemThread.isAlive())
exitcode = reportDeadThread(adHocMayhemThread);
if (idpt != null && !idpt.isAlive())
exitcode = reportDeadThread(idpt);
/* XXX if (! ddlt.isAlive())
exitcode = reportDeadThread(ddlt);*/
for (ClientThread ct : clientThreads) {
if (!ct.isAlive()) {
exitcode = reportDeadThread(ct);
}
}
/*
replBiglt.shutdown();
partBiglt.shutdown();
replTrunclt.shutdown();
partTrunclt.shutdown();
readThread.shutdown();
adHocMayhemThread.shutdown();
idpt.shutdown();
ddlt.shutdown();
for (ClientThread clientThread : clientThreads) {
clientThread.shutdown();
}
replBiglt.join();
partBiglt.join();
readThread.join();
adHocMayhemThread.join();
idpt.join();
ddlt.join();
//Shutdown LoadTableLoader
replLoadlt.shutdown();
partLoadlt.shutdown();
replLoadlt.join();
partLoadlt.join();
for (ClientThread clientThread : clientThreads) {
clientThread.join();
}
*/
// cancel periodic stats printing
timer.cancel();
checkpointTimer.cancel();
/*
shutdown.set(true);
es.shutdownNow();
// block until all outstanding txns return
client.drain();
client.close();
permitsTimer.cancel();
*/
long count = txnCount.get();
log.info("Client thread transaction count: " + count + "\n");
if (exitcode > 0 && txnCount.get() == 0) {
System.err.println("Shutting down, but found that no work was done.");
exitcode = 2;
}
System.exit(exitcode);
}
};
runTimer.schedule(runEndTask, config.duration * 1000);
}
use of java.util.TimerTask in project voltdb by VoltDB.
the class JDBCBenchmark method main.
// Application entry point
public static void main(String[] args) {
try {
KVConfig config = new KVConfig();
config.parse(JDBCBenchmark.class.getName(), args);
System.out.println(config.getConfigDumpString());
// ---------------------------------------------------------------------------------------------------------------------------------------------------
// We need only do this once, to "hot cache" the JDBC driver reference so the JVM may realize it's there.
Class.forName(DRIVER_NAME);
// Prepare the JDBC URL for the VoltDB driver
String url = "jdbc:voltdb://" + config.servers;
// Prepare the Datasource if choose to use a connection pool
if (config.externalConnectionPool.equalsIgnoreCase(C3P0_CONNECTIONPOOL)) {
useConnectionPool = true;
ComboPooledDataSource cpds = new ComboPooledDataSource();
//loads the jdbc driver
cpds.setDriverClass(DRIVER_NAME);
cpds.setJdbcUrl(url);
Ds = cpds;
} else if (config.externalConnectionPool.equalsIgnoreCase(TOMCAT_CONNECTIONPOOL)) {
useConnectionPool = true;
// read the config file for connection pool
String configName = "tomcat.properties";
boolean useDefaultConnectionPoolConfig = true;
Properties cpProperties = new Properties();
try {
FileInputStream fileInput = new FileInputStream(new File(configName));
cpProperties.load(fileInput);
fileInput.close();
useDefaultConnectionPoolConfig = false;
} catch (FileNotFoundException e) {
System.out.println("connection pool property file '" + configName + "' not found, use default settings");
}
PoolProperties p = new PoolProperties();
p.setUrl(url);
p.setDriverClassName(DRIVER_NAME);
if (useDefaultConnectionPoolConfig) {
p.setInitialSize(config.threads + 1);
} else {
p.setInitialSize(Integer.parseInt(cpProperties.getProperty("tomcat.initialSize", "40")));
}
org.apache.tomcat.jdbc.pool.DataSource tomcatDs = new org.apache.tomcat.jdbc.pool.DataSource();
tomcatDs.setPoolProperties(p);
Ds = tomcatDs;
} else if (config.externalConnectionPool.equalsIgnoreCase(BONECP_CONNECTIONPOOL)) {
useConnectionPool = true;
String configName = "bonecp.properties";
boolean useDefaultConnectionPoolConfig = true;
Properties cpProperties = new Properties();
try {
FileInputStream fileInput = new FileInputStream(new File(configName));
cpProperties.load(fileInput);
fileInput.close();
useDefaultConnectionPoolConfig = false;
} catch (FileNotFoundException e) {
System.out.println("connection pool property file '" + configName + "' not found, use default settings");
}
BoneCPConfig p;
if (useDefaultConnectionPoolConfig) {
p = new BoneCPConfig();
p.setDefaultReadOnly(false);
p.setPartitionCount(config.threads / 2);
p.setMaxConnectionsPerPartition(4);
} else {
p = new BoneCPConfig(cpProperties);
}
// set the JDBC url
p.setJdbcUrl(url + "?enableSetReadOnly=true");
BoneCPDataSource boneDs = new BoneCPDataSource(p);
Ds = boneDs;
} else if (config.externalConnectionPool.equalsIgnoreCase(HIKARI_CONNECTIONPOOL)) {
useConnectionPool = true;
HikariConfig p = new HikariConfig("hikari.properties");
p.setDriverClassName(DRIVER_NAME);
p.setJdbcUrl(url);
HikariDataSource hiDs = new HikariDataSource(p);
Ds = hiDs;
} else {
useConnectionPool = false;
Ds = null;
}
// Get a client connection - we retry for a while in case the server hasn't started yet
System.out.printf("Connecting to: %s\n", url);
int sleep = 1000;
while (true) {
try {
if (useConnectionPool) {
Ds.getConnection();
System.out.printf("Using Connection Pool: %s\n", config.externalConnectionPool);
}
Con = DriverManager.getConnection(url, "", "");
break;
} catch (Exception e) {
System.err.printf("Connection failed - retrying in %d second(s).\n " + e, sleep / 1000);
try {
Thread.sleep(sleep);
} catch (Exception tie) {
}
if (sleep < 8000)
sleep += sleep;
}
}
// Statistics manager objects from the connection, used to generate latency histogram
ClientStatsContext fullStatsContext = ((IVoltDBConnection) Con).createStatsContext();
periodicStatsContext = ((IVoltDBConnection) Con).createStatsContext();
System.out.println("Connected. Starting benchmark.");
// 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 = new PayloadProcessor(config.keysize, config.minvaluesize, config.maxvaluesize, config.entropy, config.poolsize, config.usecompression);
// Initialize the store
if (config.preload) {
System.out.print("Initializing data store... ");
final PreparedStatement removeCS = Con.prepareStatement("DELETE FROM store;");
final CallableStatement putCS = Con.prepareCall("{call STORE.upsert(?,?)}");
for (int i = 0; i < config.poolsize; i++) {
if (i == 0) {
removeCS.execute();
}
putCS.setString(1, String.format(processor.KeyFormat, i));
putCS.setBytes(2, processor.generateForStore().getStoreValue());
putCS.execute();
}
System.out.println(" Done.");
}
// start the stats
fullStatsContext.fetchAndResetBaseline();
periodicStatsContext.fetchAndResetBaseline();
benchmarkStartTS = System.currentTimeMillis();
// ---------------------------------------------------------------------------------------------------------------------------------------------------
// Create a Timer task to display performance data on the operating procedures
Timer timer = new Timer();
TimerTask statsPrinting = new TimerTask() {
@Override
public void run() {
printStatistics();
}
};
timer.scheduleAtFixedRate(statsPrinting, config.displayinterval * 1000l, config.displayinterval * 1000l);
// ---------------------------------------------------------------------------------------------------------------------------------------------------
// Create multiple processing threads
ArrayList<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < config.threads; i++) threads.add(new Thread(new ClientThread(url, processor, config.duration, config.getputratio)));
// Start threads
for (Thread thread : threads) thread.start();
// Wait for threads to complete
for (Thread thread : threads) thread.join();
// ---------------------------------------------------------------------------------------------------------------------------------------------------
// We're done - stop the performance statistics display task
timer.cancel();
// ---------------------------------------------------------------------------------------------------------------------------------------------------
// Now print application results:
// stop and fetch the stats
ClientStats stats = fullStatsContext.fetch().getStats();
// 1. Store statistics as tracked by the application (ops counts, payload traffic)
System.out.printf("\n-------------------------------------------------------------------------------------\n" + " Store Results\n" + "-------------------------------------------------------------------------------------\n\n" + "A total of %,d operations was posted...\n" + " - GETs: %,9d Operations (%,9d Misses/Failures)\n" + " %,9d MB in compressed store data\n" + " %,9d MB in uncompressed application data\n" + " Network Throughput: %6.3f Gbps*\n\n" + " - PUTs: %,9d Operations (%,9d Failures)\n" + " %,9d MB in compressed store data\n" + " %,9d MB in uncompressed application data\n" + " Network Throughput: %6.3f Gbps*\n\n" + " - Total Network Throughput: %6.3f Gbps*\n\n" + "* Figure includes key & value traffic but not database protocol overhead.\n" + "\n" + "-------------------------------------------------------------------------------------\n", GetStoreResults.get(0) + GetStoreResults.get(1) + PutStoreResults.get(0) + PutStoreResults.get(1), GetStoreResults.get(0), GetStoreResults.get(1), GetCompressionResults.get(0) / 1048576l, GetCompressionResults.get(1) / 1048576l, ((double) GetCompressionResults.get(0) + (GetStoreResults.get(0) + GetStoreResults.get(1)) * config.keysize) / (134217728d * config.duration), PutStoreResults.get(0), PutStoreResults.get(1), PutCompressionResults.get(0) / 1048576l, PutCompressionResults.get(1) / 1048576l, ((double) PutCompressionResults.get(0) + (PutStoreResults.get(0) + PutStoreResults.get(1)) * config.keysize) / (134217728d * config.duration), ((double) GetCompressionResults.get(0) + (GetStoreResults.get(0) + GetStoreResults.get(1)) * config.keysize) / (134217728d * config.duration) + ((double) PutCompressionResults.get(0) + (PutStoreResults.get(0) + PutStoreResults.get(1)) * config.keysize) / (134217728d * config.duration));
System.out.println("\n\n-------------------------------------------------------------------------------------\n" + " Client Latency Statistics\n" + "-------------------------------------------------------------------------------------\n\n");
System.out.printf("Average latency: %,9.2f ms\n", stats.getAverageLatency());
System.out.printf("10th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.1));
System.out.printf("25th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.25));
System.out.printf("50th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.5));
System.out.printf("75th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.75));
System.out.printf("90th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.9));
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.printf("99.5th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.995));
System.out.printf("99.9th percentile latency: %,9.2f ms\n", stats.kPercentileLatencyAsDouble(.999));
System.out.println("\n\n" + stats.latencyHistoReport());
// Dump statistics to a CSV file
Con.unwrap(IVoltDBConnection.class).saveStatistics(stats, config.statsfile);
Con.close();
// ---------------------------------------------------------------------------------------------------------------------------------------------------
} catch (Exception x) {
System.out.println("Exception: " + x);
x.printStackTrace();
}
}
use of java.util.TimerTask in project voltdb by VoltDB.
the class KafkaImportBenchmark method scheduleCheckTimer.
protected static void scheduleCheckTimer() {
final Timer timer = new Timer("checkTimer", true);
final long period = config.displayinterval;
timer.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
long count = 0;
if (!config.useexport) {
// imported count
count = MatchChecks.getImportTableRowCount(config.alltypes, client);
} else {
// deleted count
count = MatchChecks.getImportRowCount(client);
}
importProgress.add((int) count);
if (config.alltypes) {
// for alltypes, if a column in mirror doesn't match import, key will be a row key, and non-zero
long key = MatchChecks.checkRowMismatch(client);
if (key != 0) {
log.error("Import value mismatch at row " + key + ". Exiting.");
System.exit(-1);
}
}
int sz = importProgress.size();
if (sz > 1) {
log.info("Import Throughput " + (count - importProgress.get(sz - 2)) / period + "/s, Total Rows: " + count);
}
log.info("Import stats: " + MatchChecks.getImportStats(client));
}
}, config.displayinterval * 1000, config.displayinterval * 1000);
}
use of java.util.TimerTask in project voltdb by VoltDB.
the class KafkaImportBenchmark method schedulePeriodicStats.
/**
* Create a Timer task to display performance data on the Vote procedure
* It calls printStatistics() every displayInterval seconds
*/
public static void schedulePeriodicStats() {
statsTimer = new Timer("periodicStats", true);
TimerTask statsPrinting = new TimerTask() {
@Override
public void run() {
printStatistics();
}
};
statsTimer.scheduleAtFixedRate(statsPrinting, config.displayinterval * 1000, config.displayinterval * 1000);
}
Aggregations