Example usage for com.google.common.base Stopwatch createStarted

List of usage examples for com.google.common.base Stopwatch createStarted

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.base.*
  5. Stopwatch
  6. createStarted

Introduction

In this page you can find the example usage for com.google.common.base Stopwatch createStarted.

Prototype

@CheckReturnValue
public static Stopwatch createStarted()

Source Link

Document

Creates (and starts) a new stopwatch using System#nanoTime as its time source.

Usage

From source file:qa.qcri.nadeef.console.Console.java

/**
 * Start of Console.//from   w  w  w.j  av a  2 s . com
 * @param args user input.
 */
public static void main(String[] args) {
    try {
        // bootstrap Nadeef.
        Stopwatch stopwatch = Stopwatch.createStarted();
        Bootstrap.start();

        console = new ConsoleReader();
        Tracer.setConsole(new ConsoleReaderAdaptor(console));
        List<Completer> loadCompleter = Arrays.asList(new StringsCompleter(commands), new FileNameCompleter(),
                new NullCompleter());
        console.addCompleter(new ArgumentCompleter(loadCompleter));

        console.clearScreen();
        console.println(logo);
        console.println();
        console.println(helpInfo);
        console.println();
        console.drawLine();
        console.setPrompt(prompt);
        console.println("Your NADEEF started in " + stopwatch.elapsed(TimeUnit.MILLISECONDS) + " ms.");

        String line;
        while ((line = console.readLine()) != null) {
            line = line.trim();
            String[] tokens = line.split(" ");

            if (tokens.length == 0) {
                continue;
            }

            // clear the statistics for every run.
            PerfReport.clear();
            try {
                if (tokens[0].equalsIgnoreCase("exit")) {
                    break;
                } else if (tokens[0].equalsIgnoreCase("load")) {
                    load(line);
                } else if (tokens[0].equalsIgnoreCase("list")) {
                    list();
                } else if (tokens[0].equalsIgnoreCase("help")) {
                    printHelp();
                } else if (tokens[0].equalsIgnoreCase("detect")) {
                    detect(line);
                } else if (tokens[0].equalsIgnoreCase("repair")) {
                    repair(line);
                } else if (tokens[0].equalsIgnoreCase("run")) {
                    run(line);
                } else if (tokens[0].equalsIgnoreCase("append")) {
                    append(line);
                } else if (tokens[0].equalsIgnoreCase("set")) {
                    set(line);
                } else if (!Strings.isNullOrEmpty(tokens[0])) {
                    console.println("I don't know this command.");
                }
            } catch (Exception ex) {
                console.println("Oops, something is wrong. Please check the log in the output dir.");

                tracer.err("", ex);
            }
        }
    } catch (Exception ex) {
        try {
            tracer.err("Bootstrap failed", ex);
        } catch (Exception ignore) {
        }
    } finally {
        Bootstrap.shutdown();
    }

    System.exit(0);
}

From source file:nl.knaw.huygens.timbuctoo.tools.importer.neww.WomenWritersImporter.java

public static void main(String[] args) throws Exception {
    Stopwatch stopWatch = Stopwatch.createStarted();

    // Handle commandline arguments
    String directory = (args.length > 0) ? args[0] : "../../timbuctoo-testdata/src/main/resources/neww/";

    WomenWritersImporter importer = null;
    try {//from w ww  .j  av  a2 s .  c  o  m
        Injector injector = ToolsInjectionModule.createInjector();
        Repository repository = injector.getInstance(Repository.class);
        IndexManager indexManager = injector.getInstance(IndexManager.class);

        importer = new WomenWritersImporter(repository, indexManager, directory);
        importer.importAll();
    } finally {
        if (importer != null) {
            importer.close();
        }
        LOG.info("Time used: {}", stopWatch);
    }
}

From source file:com.paolodragone.wsn.domain.PopulateDatabase.java

public static void main(String[] args) {
    try {/*from   w  w  w.jav  a  2  s.co  m*/
        // Readers
        WsnConfiguration configuration = WsnConfiguration.getInstance();
        Path semanticNetworkFilePath = configuration.getSemanticNetworkFilePath();
        Reader sensesFileReader = Files.newBufferedReader(configuration.getSensesFilePath());
        Reader termsFileReader = Files.newBufferedReader(configuration.getTermsFilePath());
        Reader semanticNetworkFileReader = Files.newBufferedReader(semanticNetworkFilePath);

        // Get sense Stream
        SensesDataSet sensesDataSet = new SensesDataSet();

        SensesDataSet sensesDataSetView;
        sensesDataSetView = sensesDataSet
                .getView(sensesDataSet.excludeColumns(SensesDataSet.SenseColumn.Gloss));
        Stream<com.paolodragone.wsn.entities.Sense> senseStream = sensesDataSetView
                .getEntityStream(sensesFileReader).parallel();
        senseStream = Senses.filterValidSenses(senseStream);
        Collection<com.paolodragone.wsn.entities.Sense> senses = DStreamSupport.toList(senseStream);
        Map<Integer, com.paolodragone.wsn.entities.Sense> senseMap = DCollections.collectionToMap(senses,
                com.paolodragone.wsn.entities.Sense::getId, new HashMap<>());

        // Set terms
        TermsDataSet termsDataSet = new TermsDataSet();
        Stream<com.paolodragone.wsn.entities.Term> termStream = termsDataSet.getEntityStream(termsFileReader);
        TermsDataSet.setTerms(senseMap, termStream);

        {

        }

        senseMap = null;

        SemanticNetworkDataSet semanticNetworkDataSet = new SemanticNetworkDataSet();
        Stream<SemanticEdge> semanticNetworkStream;
        semanticNetworkStream = semanticNetworkDataSet.getEntityStream(semanticNetworkFileReader);
        Collection<SemanticEdge> semanticNetwork = DStreamSupport.toList(semanticNetworkStream);
        Map<Integer, SemanticEdge> semanticNetworkMap = DCollections.collectionToMap(semanticNetwork,
                SemanticEdge::getTermId, new HashMap<>());

        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("wsn_unit");
        EntityManager entityManager = entityManagerFactory.createEntityManager();

        Stopwatch stopwatch = Stopwatch.createStarted();
        long lastElapsed = 0;

        Map<Integer, DomainSense> domainSenseMap = new LinkedHashMap<>();

        entityManager.getTransaction().begin();

        int senseCount = 0;
        for (Sense sense : senses) {
            DomainSense domainSense = new DomainSense();
            domainSense.setId(sense.getId());
            domainSense.setWord(sense.getWord());
            domainSense.setPos(sense.getPos());
            domainSense.setNumber(sense.getNumber());
            entityManager.persist(domainSense);
            domainSenseMap.put(domainSense.getId(), domainSense);
            senseCount++;
            long elapsed = stopwatch.elapsed(TimeUnit.SECONDS);
            if (elapsed > lastElapsed) {
                lastElapsed = elapsed;
                System.out.print("\rSenses: " + senseCount);
                entityManager.flush();
                entityManager.clear();
            }
        }

        entityManager.getTransaction().commit();
        entityManager.clear();
        entityManager.getTransaction().begin();

        System.out.println("\n");

        int termCount = 0;
        for (Sense sense : senses) {
            DomainSense domainSense = domainSenseMap.get(sense.getId());
            List<Term> terms = sense.getGlossTerms();
            for (Term term : terms) {
                DomainTerm domainTerm = new DomainTerm();
                domainTerm.setId(term.getId());
                domainTerm.setWord(term.getWord());
                domainTerm.setLemma(term.getLemma());
                domainTerm.setPos(term.getPos());
                domainTerm.setPosition(term.getPosition());
                domainTerm.setSense(domainSense);
                SemanticEdge semanticEdge = semanticNetworkMap.get(term.getId());
                if (semanticEdge != null) {
                    DomainSense targetDomainSense = domainSenseMap.get(semanticEdge.getTargetSenseId());
                    double confidence = semanticEdge.getConfidence();
                    domainTerm.setTargetSense(targetDomainSense);
                    domainTerm.setConfidence(confidence);
                }
                entityManager.persist(domainTerm);
                termCount++;
                long elapsed = stopwatch.elapsed(TimeUnit.SECONDS);
                if (elapsed > lastElapsed) {
                    lastElapsed = elapsed;
                    System.out.print("\rTerms: " + termCount);
                    entityManager.flush();
                    entityManager.clear();
                }
            }
        }

        entityManager.getTransaction().commit();

    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:com.mgmtp.perfload.perfalyzer.PerfAlyzer.java

public static void main(final String[] args) {
    JCommander jCmd = null;/* w  w w .jav a  2s  .  com*/
    try {
        Stopwatch stopwatch = Stopwatch.createStarted();
        LOG.info("Starting perfAlyzer...");

        LOG.info("Arguments:");
        for (String arg : args) {
            LOG.info(arg);
        }
        PerfAlyzerArgs perfAlyzerArgs = new PerfAlyzerArgs();

        jCmd = new JCommander(perfAlyzerArgs);
        jCmd.parse(args);

        Injector injector = Guice.createInjector(new PerfAlyzerModule(perfAlyzerArgs));
        PerfAlyzer perfAlyzer = injector.getInstance(PerfAlyzer.class);
        perfAlyzer.runPerfAlyzer();

        ExecutorService executorService = injector.getInstance(ExecutorService.class);
        executorService.shutdownNow();

        stopwatch.stop();
        LOG.info("Done.");
        LOG.info("Total execution time: {}", stopwatch);
    } catch (ParameterException ex) {
        LOG.error(ex.getMessage());
        StringBuilder sb = new StringBuilder(200);
        jCmd.usage(sb);
        LOG.info(sb.toString());
        System.exit(1);
    } catch (Exception ex) {
        LOG.error(ex.getMessage(), ex);
        System.exit(1);
    }
}

From source file:com.google.devtools.build.android.AndroidResourceMergingAction.java

public static void main(String[] args) throws Exception {
    final Stopwatch timer = Stopwatch.createStarted();
    OptionsParser optionsParser = OptionsParser.newOptionsParser(Options.class, AaptConfigOptions.class);
    optionsParser.parseAndExitUponError(args);
    AaptConfigOptions aaptConfigOptions = optionsParser.getOptions(AaptConfigOptions.class);
    Options options = optionsParser.getOptions(Options.class);

    final AndroidResourceProcessor resourceProcessor = new AndroidResourceProcessor(stdLogger);

    Preconditions.checkNotNull(options.primaryData);
    Preconditions.checkNotNull(options.primaryManifest);
    Preconditions.checkNotNull(options.classJarOutput);

    try (ScopedTemporaryDirectory scopedTmp = new ScopedTemporaryDirectory("android_resource_merge_tmp")) {
        Path tmp = scopedTmp.getPath();
        Path mergedAssets = tmp.resolve("merged_assets");
        Path mergedResources = tmp.resolve("merged_resources");
        Path generatedSources = tmp.resolve("generated_resources");
        Path processedManifest = tmp.resolve("manifest-processed/AndroidManifest.xml");

        logger.fine(String.format("Setup finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));

        VariantType packageType = VariantType.LIBRARY;
        AndroidResourceClassWriter resourceClassWriter = AndroidResourceClassWriter.createWith(
                aaptConfigOptions.androidJar, generatedSources, Strings.nullToEmpty(options.packageForR));
        resourceClassWriter.setIncludeClassFile(true);
        resourceClassWriter.setIncludeJavaFile(false);

        final MergedAndroidData mergedData = resourceProcessor.mergeData(options.primaryData,
                options.primaryManifest, options.directData, options.transitiveData, mergedResources,
                mergedAssets, new StubPngCruncher(), packageType, options.symbolsBinOut, resourceClassWriter);

        logger.fine(String.format("Merging finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));

        // Until enough users with manifest placeholders migrate to the new manifest merger,
        // we need to replace ${applicationId} and ${packageName} with options.packageForR to make
        // the manifests compatible with the old manifest merger.
        if (options.manifestOutput != null) {
            MergedAndroidData processedData = resourceProcessor.processManifest(packageType,
                    options.packageForR, null, /* applicationId */
                    -1, /* versionCode */
                    null, /* versionName */
                    mergedData, processedManifest);
            resourceProcessor.copyManifestToOutput(processedData, options.manifestOutput);
        }// www .j  av  a  2  s .  c  o  m

        resourceProcessor.createClassJar(generatedSources, options.classJarOutput);

        logger.fine(String.format("Create classJar finished at %sms", timer.elapsed(TimeUnit.MILLISECONDS)));

        if (options.resourcesOutput != null) {
            // For now, try compressing the library resources that we pass to the validator. This takes
            // extra CPU resources to pack and unpack (~2x), but can reduce the zip size (~4x).
            resourceProcessor.createResourcesZip(mergedData.getResourceDir(), mergedData.getAssetDir(),
                    options.resourcesOutput, true /* compress */);
            logger.fine(String.format("Create resources.zip finished at %sms",
                    timer.elapsed(TimeUnit.MILLISECONDS)));
        }
    } catch (MergingException e) {
        logger.log(Level.SEVERE, "Error during merging resources", e);
        throw e;
    } catch (Exception e) {
        logger.log(Level.SEVERE, "Unexpected", e);
        throw e;
    } finally {
        resourceProcessor.shutdown();
    }
    logger.fine(String.format("Resources merged in %sms", timer.elapsed(TimeUnit.MILLISECONDS)));
}

From source file:org.opendaylight.controller.netconf.test.tool.client.http.perf.RestPerfClient.java

public static void main(String[] args) throws IOException {

    Parameters parameters = parseArgs(args, Parameters.getParser());
    parameters.validate();/*w  w w .  j  a v  a  2 s .  co  m*/
    throttle = parameters.throttle / parameters.threadAmount;

    if (parameters.async && parameters.threadAmount > 1) {
        LOG.info("Throttling per thread: {}", throttle);
    }

    final String editContentString;
    try {
        editContentString = Files.toString(parameters.editContent, Charsets.UTF_8);
    } catch (final IOException e) {
        throw new IllegalArgumentException("Cannot read content of " + parameters.editContent);
    }

    final int threadAmount = parameters.threadAmount;
    LOG.info("thread amount: {}", threadAmount);
    final int requestsPerThread = parameters.editCount / parameters.threadAmount;
    LOG.info("requestsPerThread: {}", requestsPerThread);
    final int leftoverRequests = parameters.editCount % parameters.threadAmount;
    LOG.info("leftoverRequests: {}", leftoverRequests);

    final ArrayList<ArrayList<DestToPayload>> allThreadsPayloads = new ArrayList<>();
    for (int i = 0; i < threadAmount; i++) {
        final ArrayList<DestToPayload> payloads = new ArrayList<>();
        for (int j = 0; j < requestsPerThread; j++) {
            final int devicePort = parameters.sameDevice ? parameters.devicePortRangeStart
                    : parameters.devicePortRangeStart + i;
            final StringBuilder destBuilder = new StringBuilder(dest);
            destBuilder.replace(destBuilder.indexOf(HOST_KEY),
                    destBuilder.indexOf(HOST_KEY) + HOST_KEY.length(), parameters.ip)
                    .replace(destBuilder.indexOf(PORT_KEY), destBuilder.indexOf(PORT_KEY) + PORT_KEY.length(),
                            parameters.port + "");
            final StringBuilder suffixBuilder = new StringBuilder(parameters.destination);
            if (suffixBuilder.indexOf(DEVICE_PORT_KEY) != -1) {
                suffixBuilder.replace(suffixBuilder.indexOf(DEVICE_PORT_KEY),
                        suffixBuilder.indexOf(DEVICE_PORT_KEY) + DEVICE_PORT_KEY.length(), devicePort + "");
            }
            destBuilder.append(suffixBuilder);

            payloads.add(new DestToPayload(destBuilder.toString(), prepareMessage(i, j, editContentString)));
        }
        allThreadsPayloads.add(payloads);
    }

    for (int i = 0; i < leftoverRequests; i++) {
        ArrayList<DestToPayload> payloads = allThreadsPayloads.get(allThreadsPayloads.size() - 1);

        final int devicePort = parameters.sameDevice ? parameters.devicePortRangeStart
                : parameters.devicePortRangeStart + threadAmount - 1;
        final StringBuilder destBuilder = new StringBuilder(dest);
        destBuilder.replace(destBuilder.indexOf(HOST_KEY), destBuilder.indexOf(HOST_KEY) + HOST_KEY.length(),
                parameters.ip).replace(destBuilder.indexOf(PORT_KEY),
                        destBuilder.indexOf(PORT_KEY) + PORT_KEY.length(), parameters.port + "");
        final StringBuilder suffixBuilder = new StringBuilder(parameters.destination);
        if (suffixBuilder.indexOf(DEVICE_PORT_KEY) != -1) {
            suffixBuilder.replace(suffixBuilder.indexOf(DEVICE_PORT_KEY),
                    suffixBuilder.indexOf(DEVICE_PORT_KEY) + DEVICE_PORT_KEY.length(), devicePort + "");
        }
        destBuilder.append(suffixBuilder);
        payloads.add(new DestToPayload(destBuilder.toString(),
                prepareMessage(threadAmount - 1, requestsPerThread + i, editContentString)));
    }

    final ArrayList<PerfClientCallable> callables = new ArrayList<>();
    for (ArrayList<DestToPayload> payloads : allThreadsPayloads) {
        callables.add(new PerfClientCallable(parameters, payloads));
    }

    final ExecutorService executorService = Executors.newFixedThreadPool(threadAmount);

    LOG.info("Starting performance test");
    final Stopwatch started = Stopwatch.createStarted();
    try {
        final List<Future<Void>> futures = executorService.invokeAll(callables, 5, TimeUnit.MINUTES);
        for (final Future<Void> future : futures) {
            try {
                future.get(4L, TimeUnit.MINUTES);
            } catch (ExecutionException | TimeoutException e) {
                throw new RuntimeException(e);
            }
        }
        executorService.shutdownNow();
    } catch (final InterruptedException e) {
        throw new RuntimeException("Unable to execute requests", e);
    }
    started.stop();

    LOG.info("FINISHED. Execution time: {}", started);
    LOG.info("Requests per second: {}",
            (parameters.editCount * 1000.0 / started.elapsed(TimeUnit.MILLISECONDS)));

    System.exit(0);
}

From source file:org.opendaylight.netconf.test.tool.client.http.perf.RestPerfClient.java

public static void main(String[] args) throws IOException {

    Parameters parameters = parseArgs(args, Parameters.getParser());
    parameters.validate();/*  w ww  . j  a  v a  2s .c om*/
    throttle = parameters.throttle / parameters.threadAmount;

    if (parameters.async && parameters.threadAmount > 1) {
        LOG.info("Throttling per thread: {}", throttle);
    }

    final String editContentString;
    try {
        editContentString = Files.toString(parameters.editContent, Charsets.UTF_8);
    } catch (final IOException e) {
        throw new IllegalArgumentException("Cannot read content of " + parameters.editContent);
    }

    final int threadAmount = parameters.threadAmount;
    LOG.info("thread amount: {}", threadAmount);
    final int requestsPerThread = parameters.editCount / parameters.threadAmount;
    LOG.info("requestsPerThread: {}", requestsPerThread);
    final int leftoverRequests = parameters.editCount % parameters.threadAmount;
    LOG.info("leftoverRequests: {}", leftoverRequests);

    final ArrayList<ArrayList<DestToPayload>> allThreadsPayloads = new ArrayList<>();
    for (int i = 0; i < threadAmount; i++) {
        final ArrayList<DestToPayload> payloads = new ArrayList<>();
        for (int j = 0; j < requestsPerThread; j++) {
            final int devicePort = parameters.sameDevice ? parameters.devicePortRangeStart
                    : parameters.devicePortRangeStart + i;
            final StringBuilder destBuilder = new StringBuilder(dest);
            destBuilder.replace(destBuilder.indexOf(HOST_KEY),
                    destBuilder.indexOf(HOST_KEY) + HOST_KEY.length(), parameters.ip)
                    .replace(destBuilder.indexOf(PORT_KEY), destBuilder.indexOf(PORT_KEY) + PORT_KEY.length(),
                            parameters.port + "");
            final StringBuilder suffixBuilder = new StringBuilder(parameters.destination);
            if (suffixBuilder.indexOf(DEVICE_PORT_KEY) != -1) {
                suffixBuilder.replace(suffixBuilder.indexOf(DEVICE_PORT_KEY),
                        suffixBuilder.indexOf(DEVICE_PORT_KEY) + DEVICE_PORT_KEY.length(), devicePort + "");
            }
            destBuilder.append(suffixBuilder);

            payloads.add(new DestToPayload(destBuilder.toString(),
                    prepareMessage(i, j, editContentString, devicePort)));
        }
        allThreadsPayloads.add(payloads);
    }

    for (int i = 0; i < leftoverRequests; i++) {
        ArrayList<DestToPayload> payloads = allThreadsPayloads.get(allThreadsPayloads.size() - 1);

        final int devicePort = parameters.sameDevice ? parameters.devicePortRangeStart
                : parameters.devicePortRangeStart + threadAmount - 1;
        final StringBuilder destBuilder = new StringBuilder(dest);
        destBuilder.replace(destBuilder.indexOf(HOST_KEY), destBuilder.indexOf(HOST_KEY) + HOST_KEY.length(),
                parameters.ip).replace(destBuilder.indexOf(PORT_KEY),
                        destBuilder.indexOf(PORT_KEY) + PORT_KEY.length(), parameters.port + "");
        final StringBuilder suffixBuilder = new StringBuilder(parameters.destination);
        if (suffixBuilder.indexOf(DEVICE_PORT_KEY) != -1) {
            suffixBuilder.replace(suffixBuilder.indexOf(DEVICE_PORT_KEY),
                    suffixBuilder.indexOf(DEVICE_PORT_KEY) + DEVICE_PORT_KEY.length(), devicePort + "");
        }
        destBuilder.append(suffixBuilder);
        payloads.add(new DestToPayload(destBuilder.toString(),
                prepareMessage(threadAmount - 1, requestsPerThread + i, editContentString, devicePort)));
    }

    final ArrayList<PerfClientCallable> callables = new ArrayList<>();
    for (ArrayList<DestToPayload> payloads : allThreadsPayloads) {
        callables.add(new PerfClientCallable(parameters, payloads));
    }

    final ExecutorService executorService = Executors.newFixedThreadPool(threadAmount);

    LOG.info("Starting performance test");
    boolean allThreadsCompleted = true;
    final Stopwatch started = Stopwatch.createStarted();
    try {
        final List<Future<Void>> futures = executorService.invokeAll(callables, parameters.timeout,
                TimeUnit.MINUTES);
        for (int i = 0; i < futures.size(); i++) {
            Future<Void> future = futures.get(i);
            if (future.isCancelled()) {
                allThreadsCompleted = false;
                LOG.info("{}. thread timed out.", i + 1);
            } else {
                try {
                    future.get();
                } catch (final ExecutionException e) {
                    allThreadsCompleted = false;
                    LOG.info("{}. thread failed.", i + 1, e);
                }
            }
        }
    } catch (final InterruptedException e) {
        allThreadsCompleted = false;
        LOG.warn("Unable to execute requests", e);
    }
    executorService.shutdownNow();
    started.stop();

    LOG.info("FINISHED. Execution time: {}", started);
    // If some threads failed or timed out, skip calculation of requests per second value
    // and do not log it
    if (allThreadsCompleted) {
        LOG.info("Requests per second: {}",
                (parameters.editCount * 1000.0 / started.elapsed(TimeUnit.MILLISECONDS)));
    }
    System.exit(0);
}

From source file:com.tarvon.fractala.util.Xorshift.java

/**
 * Main method used for simple testing of the PRNG.
 * /*from   w w w. java2s.  c  om*/
 * @param args ignored arguments.
 */
public static void main(String... args) {
    Xorshift xorshift = Xorshift.create(0);
    Xorshift.Instance r = xorshift.getInstance();

    Stopwatch sw = Stopwatch.createStarted();
    double min = Double.MAX_VALUE;
    double max = Double.MIN_VALUE;
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        //long v = r.nextLong();
        //double d = Double.longBitsToDouble(v);
        double d = r.nextDouble();
        if (d < min)
            min = d;
        if (d > max)
            max = d;
    }
    System.out.printf("Making %d doubles took %s\n", Integer.MAX_VALUE, sw);
    System.out.printf("min double: %1.40f\n", min);
    System.out.printf("max double: %1.40f\n", max);

    // histogram to see if there is really bad clustering
    // on the doubles generator
    int[] bins = new int[100];
    for (int i = 0; i < Integer.MAX_VALUE; i++) {
        double d = r.nextDouble();
        int b = (int) (d * 100);
        bins[b]++;
    }
    System.out.println("Histogram of doubles:");
    for (int i = 0; i < 100; i++) {
        System.out.printf("bin %d:\t%d\n", i, bins[i]);
    }
}

From source file:org.opendaylight.controller.netconf.test.tool.client.stress.StressClient.java

public static void main(final String[] args) {

    final Parameters params = parseArgs(args, Parameters.getParser());
    params.validate();/* w ww.  j av a  2 s.c o m*/

    final ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) LoggerFactory
            .getLogger(Logger.ROOT_LOGGER_NAME);
    root.setLevel(params.debug ? Level.DEBUG : Level.INFO);

    final int threadAmount = params.threadAmount;
    LOG.info("thread amount: " + threadAmount);
    final int requestsPerThread = params.editCount / params.threadAmount;
    LOG.info("requestsPerThread: " + requestsPerThread);
    final int leftoverRequests = params.editCount % params.threadAmount;
    LOG.info("leftoverRequests: " + leftoverRequests);

    LOG.info("Preparing messages");
    // Prepare all msgs up front
    final List<List<NetconfMessage>> allPreparedMessages = new ArrayList<>(threadAmount);
    for (int i = 0; i < threadAmount; i++) {
        if (i != threadAmount - 1) {
            allPreparedMessages.add(new ArrayList<NetconfMessage>(requestsPerThread));
        } else {
            allPreparedMessages.add(new ArrayList<NetconfMessage>(requestsPerThread + leftoverRequests));
        }
    }

    final String editContentString;
    try {
        editContentString = Files.toString(params.editContent, Charsets.UTF_8);
    } catch (final IOException e) {
        throw new IllegalArgumentException("Cannot read content of " + params.editContent);
    }

    for (int i = 0; i < threadAmount; i++) {
        final List<NetconfMessage> preparedMessages = allPreparedMessages.get(i);
        int padding = 0;
        if (i == threadAmount - 1) {
            padding = leftoverRequests;
        }
        for (int j = 0; j < requestsPerThread + padding; j++) {
            LOG.debug("id: " + (i * requestsPerThread + j));
            preparedMessages.add(prepareMessage(i * requestsPerThread + j, editContentString));
        }
    }

    final NioEventLoopGroup nioGroup = new NioEventLoopGroup();
    final Timer timer = new HashedWheelTimer();

    final NetconfClientDispatcherImpl netconfClientDispatcher = configureClientDispatcher(params, nioGroup,
            timer);

    final List<StressClientCallable> callables = new ArrayList<>(threadAmount);
    for (final List<NetconfMessage> messages : allPreparedMessages) {
        callables.add(new StressClientCallable(params, netconfClientDispatcher, messages));
    }

    final ExecutorService executorService = Executors.newFixedThreadPool(threadAmount);

    LOG.info("Starting stress test");
    final Stopwatch started = Stopwatch.createStarted();
    try {
        final List<Future<Boolean>> futures = executorService.invokeAll(callables);
        for (final Future<Boolean> future : futures) {
            try {
                future.get(4L, TimeUnit.MINUTES);
            } catch (ExecutionException | TimeoutException e) {
                throw new RuntimeException(e);
            }
        }
        executorService.shutdownNow();
    } catch (final InterruptedException e) {
        throw new RuntimeException("Unable to execute requests", e);
    }
    started.stop();

    LOG.info("FINISHED. Execution time: {}", started);
    LOG.info("Requests per second: {}", (params.editCount * 1000.0 / started.elapsed(TimeUnit.MILLISECONDS)));

    // Cleanup
    timer.stop();
    try {
        nioGroup.shutdownGracefully().get(20L, TimeUnit.SECONDS);
    } catch (InterruptedException | ExecutionException | TimeoutException e) {
        LOG.warn("Unable to close executor properly", e);
    }
    //stop the underlying ssh thread that gets spawned if we use ssh
    if (params.ssh) {
        AsyncSshHandler.DEFAULT_CLIENT.stop();
    }
}

From source file:eu.thebluemountain.customers.dctm.brownbag.badcontentslister.Main.java

public static void main(String[] args) {
    try {//from w  w w.  ja v  a  2  s  . c  o  m
        Map<Command, Optional<String>> cmds = Command.parse(args);
        if ((cmds.containsKey(Command.HELP)) || (!cmds.containsKey(Command.CONFIG))) {
            usage();
            return;
        }
        final JDBCConfig config = config(cmds.get(Command.CONFIG).get());

        String pwd = config.password.orNull();
        if (null == pwd) {
            Optional<String> opt = passwordOf("database", config.user);
            if (!opt.isPresent()) {
                throw new ExitException(RetCode.ERR_CANCELLED);
            }
            pwd = opt.get();
        }
        try (JDBCConnection from = create(config, pwd); CSVWriter writer = makeLog(config.user)) {
            Stopwatch watch = Stopwatch.createStarted();
            Stores stores = StoresReader.STORESREADER.apply(from);
            System.out.println("spent " + watch.stop() + " to load stores");
            final Function<DecoratedContent, Checks.Result> checker = Checks.checker(stores);
            final Multiset<Checks.Code> codes = TreeMultiset.create();
            watch.reset().start();
            ResponseUI rui = ResponseUI.create(1024, 64);
            try (CloseableIterator<DecoratedContent> it = DCReader.reader(from, stores)) {
                long count = 0L;
                while (it.hasNext()) {
                    DecoratedContent dc = it.next();
                    count++;
                    final Checks.Result result = checker.apply(dc);
                    assert null != result;
                    rui.onResponse(result);
                    final Checks.Code code = result.code;
                    codes.add(code);
                    if (code != Checks.Code.OK) {
                        // we've got an error then ....
                        writer.writeError(dc, result);
                    }
                }
                rui.finish();
                System.out.println("spent " + watch.stop() + " to read " + count + " d.c.");
                System.out.println("stats: " + codes);
                System.out.println("bye");
            }
        }
    } catch (SQLException e) {
        e.printStackTrace(System.err);
        System.err.flush();
        System.out.println();
        usage();
        System.exit(RetCode.ERR_SQL.ordinal());
    } catch (ExitException e) {
        e.exit();
    } catch (RuntimeException | IOException e) {
        e.printStackTrace(System.err);
        System.err.flush();
        System.out.println();
        usage();
        System.exit(RetCode.ERR_OTHER.ordinal());
    }
}