Search in sources :

Example 31 with VoltTable

use of org.voltdb.VoltTable in project voltdb by VoltDB.

the class AsyncBenchmark method runBenchmark.

/**
     * Core benchmark code.
     * Connect. Initialize. Run the loop. Cleanup. Print Results.
     *
     * @throws Exception if anything unexpected happens.
     */
public void runBenchmark() throws Exception {
    log.info(HORIZONTAL_RULE);
    log.info(" Setup & Initialization");
    log.info(HORIZONTAL_RULE);
    // connect to one or more servers, loop until success
    connect();
    VoltTable[] rowResults = null;
    VoltTable[] replicatedResults = null;
    boolean succeeded = false;
    // If server fails during initialization, try again
    while (!succeeded) {
        Client initClient = clients.get(0);
        try {
            // initialize using synchronous call
            initClient.callProcedure("Initialize");
            ClientResponse rowResp = initClient.callProcedure("getLastRow");
            rowResults = rowResp.getResults();
            assert (rowResp.getStatus() == ClientResponse.SUCCESS);
            ClientResponse replicatedRowResp = initClient.callProcedure("getLastReplicatedRow");
            replicatedResults = replicatedRowResp.getResults();
            assert (replicatedRowResp.getStatus() == ClientResponse.SUCCESS);
            succeeded = true;
        } catch (Exception e) {
            log.error("Exception on init. Will sleep.", e);
            sleepUntilConnected(initClient, System.currentTimeMillis() + config.duration * 1000);
        }
    }
    // total of 127 cids
    final int cidCount = 127;
    final long windowPerCid = config.windowsize / cidCount;
    // rids per cid
    final Map<Integer, Long> rids = new HashMap<Integer, Long>();
    // reset all cids to 0 and initialize inFlight queues
    for (int i = -1; i < cidCount; i++) {
        rids.put(i, 0l);
    }
    // populate the rids with values from previous run
    while (rowResults[0].advanceRow()) {
        long cid = rowResults[0].getLong("cid");
        long last_rid = rowResults[0].getLong("last_rid");
        rids.put((int) cid, last_rid + 1);
    }
    rids.put(-1, replicatedResults[0].asScalarLong() + 1);
    log.info(HORIZONTAL_RULE);
    log.info("Starting Benchmark");
    log.info(HORIZONTAL_RULE);
    java.util.Random r = new java.util.Random(2);
    // print periodic statistics to the console
    benchmarkStartTS = System.currentTimeMillis();
    schedulePeriodicStats();
    // Run the benchmark loop for the requested duration
    // The throughput may be throttled depending on client configuration
    final long benchmarkEndTime = System.currentTimeMillis() + (1000l * config.duration);
    while (benchmarkEndTime > System.currentTimeMillis()) {
        int cid;
        if (r.nextDouble() < config.multisingleratio) {
            // MP uses cid -1
            cid = -1;
        } else {
            cid = (byte) r.nextInt(cidCount);
        }
        long rid = rids.get(cid);
        // txns for the same cid go to the same client
        Client client = null;
        try {
            if (cid == -1) {
                client = clients.get(0);
                // skip this work if the client is not connected
                if (client.getConnectedHostList().size() == 0) {
                    continue;
                }
                // update the replicated table
                try {
                    client.callProcedure(new updateReplicatedCallback(), "updateReplicated", rid);
                } catch (NoConnectionsException e) {
                    log.error("ClientThread got NoConnectionsException on updateReplicated proc call.");
                }
            } else {
                client = clients.get(cid % clients.size());
                // skip this work if the client is not connected
                if (client.getConnectedHostList().size() == 0) {
                    continue;
                }
                // asynchronously call the "doTxn" procedure
                try {
                    client.callProcedure(new doTxnCallback(), "doTxn", cid, rid, rid > windowPerCid ? rid - windowPerCid : 0, processor.generateForStore().getStoreValue());
                } catch (NoConnectionsException e) {
                    log.error("ClientThread got NoConnectionsException on doTxn proc call.");
                }
            }
        } catch (Exception e) {
            log.error("Benchark had a unexpected exception", e);
            System.exit(-1);
        }
        rids.put(cid, rid + 1);
    }
    // cancel periodic stats printing
    timer.cancel();
    shutdown.set(true);
    /* don't wait for a proper cleanup just go away the system may not be healthy -pr
        // block until all outstanding txns return
        for (Client client : clients) {
            client.drain();
            client.close();
        }*/
    log.info(HORIZONTAL_RULE);
    log.info("Benchmark Complete");
}
Also used : ClientResponse(org.voltdb.client.ClientResponse) HashMap(java.util.HashMap) VoltTable(org.voltdb.VoltTable) NoConnectionsException(org.voltdb.client.NoConnectionsException) NoConnectionsException(org.voltdb.client.NoConnectionsException) AtomicLong(java.util.concurrent.atomic.AtomicLong) Client(org.voltdb.client.Client)

Example 32 with VoltTable

use of org.voltdb.VoltTable in project voltdb by VoltDB.

the class Initialize method run.

public long run() {
    voltQueueSQL(checkStmt, EXPECT_ZERO_OR_ONE_ROW);
    VoltTable result = voltExecuteSQL()[0];
    // if the data is initialized, return the current count
    if (result.getRowCount() != 0) {
        result.advanceRow();
        return result.getLong("rid");
    }
    // initialize the data using the txnId
    @SuppressWarnings("deprecation") long txnId = DeprecatedProcedureAPIAccess.getVoltPrivateRealTransactionId(this);
    long uniqueId = getUniqueId();
    voltQueueSQL(insertStmt, EXPECT_SCALAR_MATCH(1), txnId, uniqueId, -1, 0);
    voltExecuteSQL(true);
    // return the rid
    return 0;
}
Also used : VoltTable(org.voltdb.VoltTable)

Example 33 with VoltTable

use of org.voltdb.VoltTable in project voltdb by VoltDB.

the class paymentByCustomerNameC method run.

public VoltTable[] run(short w_id, byte d_id, double h_amount, short c_w_id, byte c_d_id, String c_last, TimestampType timestamp) throws VoltAbortException {
    voltQueueSQL(getCustomersByLastName, c_last, c_d_id, c_w_id);
    final VoltTable customers = voltExecuteSQL()[0];
    final int namecnt = customers.getRowCount();
    if (namecnt == 0) {
        throw new VoltAbortException("paymentByCustomerNameC: no customers with last name: " + c_last + " in warehouse: " + c_w_id + " and in district " + c_d_id);
    }
    final int index = (namecnt - 1) / 2;
    final VoltTableRow customer = customers.fetchRow(index);
    final int c_id = (int) customer.getLong(C_ID_IDX);
    return processPayment(w_id, d_id, c_w_id, c_d_id, c_id, h_amount, customer, timestamp);
}
Also used : VoltTable(org.voltdb.VoltTable) VoltTableRow(org.voltdb.VoltTableRow)

Example 34 with VoltTable

use of org.voltdb.VoltTable in project voltdb by VoltDB.

the class neworder method run.

public VoltTable[] run(short w_id, byte d_id, int c_id, TimestampType timestamp, int[] item_id, short[] supware, int[] quantity) throws VoltAbortException {
    assert item_id.length > 0;
    assert item_id.length == supware.length;
    assert item_id.length == quantity.length;
    // CHEAT: Validate all items to see if we will need to abort.
    // Also determine if this is an all local order or not
    final VoltTableRow[] items = new VoltTableRow[item_id.length];
    boolean isAllLocal = true;
    for (int i = 0; i < item_id.length; ++i) {
        isAllLocal = isAllLocal && supware[i] == w_id;
        voltQueueSQL(getItemInfo, item_id[i]);
    }
    voltQueueSQL(getWarehouseTaxRate, w_id);
    voltQueueSQL(getDistrict, d_id, w_id);
    voltQueueSQL(getCustomer, w_id, d_id, c_id);
    final VoltTable[] itemresults = voltExecuteSQL();
    assert itemresults.length == item_id.length + 3;
    for (int i = 0; i < item_id.length; ++i) {
        if (itemresults[i].getRowCount() == 0) {
            // TPCC defines 1% of neworder gives a wrong itemid, causing rollback.
            throw new VoltAbortException(Constants.INVALID_ITEM_MESSAGE);
        }
        assert itemresults[i].getRowCount() == 1;
        items[i] = itemresults[i].fetchRow(0);
    }
    //final VoltTable[] backgroundInfo = executeSQL();
    VoltTable customer = itemresults[item_id.length + 2];
    final double w_tax = itemresults[item_id.length].fetchRow(0).getDouble(0);
    final int D_TAX_COL = 0, D_NEXT_O_ID = 1;
    final int C_DISCOUNT = 0;
    final VoltTableRow tempRow = itemresults[item_id.length + 1].fetchRow(0);
    final double d_tax = tempRow.getDouble(D_TAX_COL);
    final double c_discount = itemresults[item_id.length + 2].fetchRow(0).getDouble(C_DISCOUNT);
    final long d_next_o_id = tempRow.getLong(D_NEXT_O_ID);
    final long ol_cnt = item_id.length;
    final long all_local = isAllLocal ? 1 : 0;
    voltQueueSQL(incrementNextOrderId, d_next_o_id + 1, d_id, w_id);
    voltQueueSQL(createOrder, d_next_o_id, d_id, w_id, c_id, timestamp, Constants.NULL_CARRIER_ID, ol_cnt, all_local);
    voltQueueSQL(createNewOrder, d_next_o_id, d_id, w_id);
    voltExecuteSQL();
    // values the client is missing: i_name, s_quantity, brand_generic, i_price, ol_amount
    final VoltTable item_data = item_data_template.clone(2048);
    double total = 0;
    for (int i = 0; i < item_id.length; ++i) {
        final long ol_supply_w_id = supware[i];
        final long ol_i_id = item_id[i];
        // One getStockInfo SQL statement for each district
        voltQueueSQL(getStockInfo[d_id - 1], ol_i_id, ol_supply_w_id);
    }
    final VoltTable[] stockresults = voltExecuteSQL();
    assert stockresults.length == item_id.length;
    for (int i = 0; i < item_id.length; ++i) {
        final long ol_number = i + 1;
        final long ol_supply_w_id = supware[i];
        final long ol_i_id = item_id[i];
        final long ol_quantity = quantity[i];
        assert stockresults[i].getRowCount() == 1 : "Cannot find stock info for item; should not happen with valid database";
        final VoltTableRow itemInfo = items[i];
        final VoltTableRow stockInfo = stockresults[i].fetchRow(0);
        final int I_PRICE = 0, I_NAME = 1, I_DATA = 2;
        final byte[] i_name = itemInfo.getStringAsBytes(I_NAME);
        final byte[] i_data = itemInfo.getStringAsBytes(I_DATA);
        final double i_price = itemInfo.getDouble(I_PRICE);
        final int S_QUANTITY = 0, S_DATA = 1, S_YTD = 2, S_ORDER_CNT = 3, S_REMOTE_CNT = 4, S_DIST_XX = 5;
        long s_quantity = stockInfo.getLong(S_QUANTITY);
        long s_ytd = stockInfo.getLong(S_YTD);
        long s_order_cnt = stockInfo.getLong(S_ORDER_CNT);
        long s_remote_cnt = stockInfo.getLong(S_REMOTE_CNT);
        final byte[] s_data = stockInfo.getStringAsBytes(S_DATA);
        // Fetches data from the s_dist_[d_id] column
        final byte[] s_dist_xx = stockInfo.getStringAsBytes(S_DIST_XX);
        // Update stock
        s_ytd += ol_quantity;
        if (s_quantity >= ol_quantity + 10) {
            s_quantity = s_quantity - ol_quantity;
        } else {
            s_quantity = s_quantity + 91 - ol_quantity;
        }
        s_order_cnt++;
        if (ol_supply_w_id != w_id)
            s_remote_cnt++;
        // TODO(evanj): Faster to do s_ytd and s_order_cnt increment in SQL?
        // Saves fetching those columns the first time
        voltQueueSQL(updateStock, s_quantity, s_ytd, s_order_cnt, s_remote_cnt, ol_i_id, ol_supply_w_id);
        byte[] brand_generic;
        if (indexOf(i_data, Constants.ORIGINAL_BYTES) != -1 && indexOf(s_data, Constants.ORIGINAL_BYTES) != -1) {
            brand_generic = new byte[] { 'B' };
        } else {
            brand_generic = new byte[] { 'G' };
        }
        //Transaction profile states to use "ol_quantity * i_price"
        final double ol_amount = ol_quantity * i_price;
        total += ol_amount;
        voltQueueSQL(createOrderLine, d_next_o_id, d_id, w_id, ol_number, ol_i_id, ol_supply_w_id, timestamp, ol_quantity, ol_amount, s_dist_xx);
        // Add the info to be returned
        item_data.addRow(i_name, s_quantity, brand_generic, i_price, ol_amount);
    }
    voltExecuteSQL();
    // Adjust the total for the discount
    total *= (1 - c_discount) * (1 + w_tax + d_tax);
    // pack up values the client is missing (see TPC-C 2.4.3.5)
    final VoltTable misc = misc_template.clone(256);
    misc.addRow(w_tax, d_tax, d_next_o_id, total);
    return new VoltTable[] { customer, misc, item_data };
}
Also used : VoltTableRow(org.voltdb.VoltTableRow) VoltTable(org.voltdb.VoltTable)

Example 35 with VoltTable

use of org.voltdb.VoltTable in project voltdb by VoltDB.

the class paymentByCustomerNameW method run.

public VoltTable[] run(short w_id, byte d_id, double h_amount, short c_w_id, byte c_d_id, String c_last, TimestampType timestamp) throws VoltAbortException {
    // retrieve c_id from replicated CUSTOMER_NAME table
    voltQueueSQL(getCidByLastName, c_last, c_d_id, c_w_id);
    final VoltTable result = voltExecuteSQL()[0];
    final int namecnt = result.getRowCount();
    if (namecnt == 0) {
        throw new VoltAbortException("paymentByCustomerNameW: no customers with last name: " + c_last + " in warehouse: " + c_w_id + " and in district " + c_d_id);
    }
    final int index = (namecnt - 1) / 2;
    final VoltTableRow customer = result.fetchRow(index);
    final long c_id = customer.getLong(0);
    return processPayment(w_id, d_id, h_amount, c_w_id, c_d_id, c_id, timestamp);
}
Also used : VoltTable(org.voltdb.VoltTable) VoltTableRow(org.voltdb.VoltTableRow)

Aggregations

VoltTable (org.voltdb.VoltTable)887 Client (org.voltdb.client.Client)497 ClientResponse (org.voltdb.client.ClientResponse)193 ProcCallException (org.voltdb.client.ProcCallException)144 IOException (java.io.IOException)100 VoltTableRow (org.voltdb.VoltTableRow)57 NoConnectionsException (org.voltdb.client.NoConnectionsException)52 ColumnInfo (org.voltdb.VoltTable.ColumnInfo)42 TimestampType (org.voltdb.types.TimestampType)37 BigDecimal (java.math.BigDecimal)30 ArrayList (java.util.ArrayList)27 Test (org.junit.Test)26 File (java.io.File)25 HashMap (java.util.HashMap)21 ClientResponseImpl (org.voltdb.ClientResponseImpl)20 Timestamp (java.sql.Timestamp)15 Date (java.util.Date)15 VoltDB (org.voltdb.VoltDB)15 DependencyPair (org.voltdb.DependencyPair)14 Configuration (org.voltdb.VoltDB.Configuration)14