com.datastax.brisk.demo.pricer.Pricer.java Source code

Introduction

Here is the source code for com.datastax.brisk.demo.pricer.Pricer.java

Source

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.datastax.brisk.demo.pricer;

import java.io.PrintStream;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

import org.apache.commons.cli.Option;

import com.datastax.brisk.demo.pricer.operations.HistoricalPriceInserter;
import com.datastax.brisk.demo.pricer.operations.PortfolioInserter;
import com.datastax.brisk.demo.pricer.operations.PriceInserter;
import com.datastax.brisk.demo.pricer.util.Operation;

import org.apache.cassandra.thrift.Cassandra;

public final class Pricer {
    public static enum Operations {
        INSERT_HISTORICAL_PRICES, INSERT_PRICES, UPDATE_PORTFOLIOS
    }

    public static Session session;
    public static Random randomizer = new Random();

    /**
     * Producer-Consumer model: 1 producer, N consumers
     */
    private static final BlockingQueue<Operation> operations = new SynchronousQueue<Operation>(true);

    public static void main(String[] arguments) throws Exception {
        long latency, oldLatency;
        int epoch, total, oldTotal, keyCount, oldKeyCount;

        try {
            session = new Session(arguments);
        } catch (IllegalArgumentException e) {
            printHelpMessage();
            return;
        }

        session.createKeySpaces();

        int threadCount = session.getThreads();
        Thread[] consumers = new Thread[threadCount];
        PrintStream out = session.getOutputStream();

        out.println("total,interval_op_rate,interval_key_rate,avg_latency,elapsed_time");

        int itemsPerThread = session.getKeysPerThread();
        int modulo = session.getNumKeys() % threadCount;

        // creating required type of the threads for the test
        for (int i = 0; i < threadCount; i++) {
            if (i == threadCount - 1)
                itemsPerThread += modulo; // last one is going to handle N + modulo items

            consumers[i] = new Consumer(itemsPerThread);
        }

        new Producer().start();

        // starting worker threads
        for (int i = 0; i < threadCount; i++) {
            consumers[i].start();
        }

        // initialization of the values
        boolean terminate = false;
        latency = 0;
        epoch = total = keyCount = 0;

        int interval = session.getProgressInterval();
        int epochIntervals = session.getProgressInterval() * 10;
        long testStartTime = System.currentTimeMillis();

        while (!terminate) {
            Thread.sleep(100);

            int alive = 0;
            for (Thread thread : consumers)
                if (thread.isAlive())
                    alive++;

            if (alive == 0)
                terminate = true;

            epoch++;

            if (terminate || epoch > epochIntervals) {
                epoch = 0;

                oldTotal = total;
                oldLatency = latency;
                oldKeyCount = keyCount;

                total = session.operations.get();
                keyCount = session.keys.get();
                latency = session.latency.get();

                int opDelta = total - oldTotal;
                int keyDelta = keyCount - oldKeyCount;
                double latencyDelta = latency - oldLatency;

                long currentTimeInSeconds = (System.currentTimeMillis() - testStartTime) / 1000;
                String formattedDelta = (opDelta > 0) ? Double.toString(latencyDelta / (opDelta * 1000)) : "NaN";

                out.println(String.format("%d,%d,%d,%s,%d", total, opDelta / interval, keyDelta / interval,
                        formattedDelta, currentTimeInSeconds));
            }
        }
    }

    private static Operation createOperation(int index) {
        switch (session.getOperation()) {

        case INSERT_PRICES:
            return new PriceInserter(index);

        case UPDATE_PORTFOLIOS:
            return new PortfolioInserter(index);

        case INSERT_HISTORICAL_PRICES:
            return new HistoricalPriceInserter(index);

        }

        throw new UnsupportedOperationException();
    }

    /**
     * Printing out help message
     */
    public static void printHelpMessage() {
        System.out.println("Usage: ./bin/pricer [options]\n\nOptions:");

        for (Object o : Session.availableOptions.getOptions()) {
            Option option = (Option) o;
            String upperCaseName = option.getLongOpt().toUpperCase();
            System.out.println(String.format("-%s%s, --%s%s%n\t\t%s%n", option.getOpt(),
                    (option.hasArg()) ? " " + upperCaseName : "", option.getLongOpt(),
                    (option.hasArg()) ? "=" + upperCaseName : "", option.getDescription()));
        }
    }

    /**
     * Produces exactly N items (awaits each to be consumed)
     */
    private static class Producer extends Thread {
        public void run() {
            for (int i = 0; i < session.getNumKeys(); i++) {
                try {
                    operations.put(createOperation(i));
                } catch (InterruptedException e) {
                    System.err.println("Producer error - " + e.getMessage());
                    return;
                }
            }
        }
    }

    /**
     * Each consumes exactly N items from queue
     */
    private static class Consumer extends Thread {
        private final int items;

        public Consumer(int toConsume) {
            items = toConsume;
        }

        public void run() {
            Cassandra.Client client = session.getClient();

            for (int i = 0; i < items; i++) {
                try {
                    operations.take().run(client); // running job
                } catch (Exception e) {
                    System.err.println(e.getMessage());
                    System.exit(-1);
                }
            }
        }
    }

}