Search in sources :

Example 46 with TimerTask

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);
}
Also used : Timer(java.util.Timer) TimerTask(java.util.TimerTask)

Example 47 with TimerTask

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);
}
Also used : Timer(java.util.Timer) TimerTask(java.util.TimerTask)

Example 48 with TimerTask

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();
    }
}
Also used : HikariDataSource(com.zaxxer.hikari.HikariDataSource) FileNotFoundException(java.io.FileNotFoundException) ArrayList(java.util.ArrayList) BoneCPDataSource(com.jolbox.bonecp.BoneCPDataSource) PoolProperties(org.apache.tomcat.jdbc.pool.PoolProperties) Properties(java.util.Properties) PoolProperties(org.apache.tomcat.jdbc.pool.PoolProperties) ClientStats(org.voltdb.client.ClientStats) ClientStatsContext(org.voltdb.client.ClientStatsContext) TimerTask(java.util.TimerTask) CallableStatement(java.sql.CallableStatement) IVoltDBConnection(org.voltdb.jdbc.IVoltDBConnection) PreparedStatement(java.sql.PreparedStatement) HikariConfig(com.zaxxer.hikari.HikariConfig) FileInputStream(java.io.FileInputStream) FileNotFoundException(java.io.FileNotFoundException) ComboPooledDataSource(com.mchange.v2.c3p0.ComboPooledDataSource) DataSource(javax.sql.DataSource) BoneCPDataSource(com.jolbox.bonecp.BoneCPDataSource) HikariDataSource(com.zaxxer.hikari.HikariDataSource) ComboPooledDataSource(com.mchange.v2.c3p0.ComboPooledDataSource) Timer(java.util.Timer) BoneCPConfig(com.jolbox.bonecp.BoneCPConfig) File(java.io.File)

Example 49 with TimerTask

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);
}
Also used : Timer(java.util.Timer) TimerTask(java.util.TimerTask)

Example 50 with TimerTask

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);
}
Also used : Timer(java.util.Timer) TimerTask(java.util.TimerTask)

Aggregations

TimerTask (java.util.TimerTask)900 Timer (java.util.Timer)653 IOException (java.io.IOException)90 Date (java.util.Date)58 Test (org.junit.Test)57 File (java.io.File)30 ArrayList (java.util.ArrayList)29 Intent (android.content.Intent)25 AtomicLong (java.util.concurrent.atomic.AtomicLong)21 Handler (android.os.Handler)20 AtomicInteger (java.util.concurrent.atomic.AtomicInteger)20 HashMap (java.util.HashMap)17 List (java.util.List)14 TextView (android.widget.TextView)13 CountDownLatch (java.util.concurrent.CountDownLatch)13 View (android.view.View)12 Map (java.util.Map)12 AtomicBoolean (java.util.concurrent.atomic.AtomicBoolean)12 InputMethodManager (android.view.inputmethod.InputMethodManager)11 Random (java.util.Random)11