Documentation > Development > Writing New Benchmarks

public enum ProjectType {
    // "Benchmark Identifier" ("Benchmark Name", "Benchmark Package")
    ABC ("ABC Benchmark", "com.example.benchmark.abc");
    ...
}

CREATE TABLE TABLEA (
   A_ID     BIGINT NOT NULL,
   A_VALUE  VARCHAR(64),
   PRIMARY KEY (A_ID)
);
CREATE TABLE TABLEB (
   B_ID     BIGINT NOT NULL,
   B_A_ID   BIGINT NOT NULL REFERENCES TABLEA (A_ID),
   B_VALUE  VARCHAR(64),
   PRIMARY KEY (B_ID, B_A_ID)
);

package com.example.benchmark.abc.procedures;
import org.voltdb.*;
 
public class GetData extends VoltProcedure {
 
    public final SQLStmt GetA = new SQLStmt("SELECT * FROM TABLEA WHERE A_ID = ? ");
 
    public VoltTable[] run(long a_id) {
        voltQueueSQL(GetA, a_id);
        return (voltExecuteSQL());
    }   
}

package com.example.benchmark.abc;
 
import edu.brown.benchmark.AbstractProjectBuilder;
import edu.brown.api.BenchmarkComponent;
import com.example.benchmark.abc.procedures.*;
 
public class ABCProjectBuilder extends AbstractProjectBuilder {
 
    // REQUIRED: Retrieved via reflection by BenchmarkController
    public static final Class<? extends BenchmarkComponent> m_clientClass = ABCClient.class;
 
    // REQUIRED: Retrieved via reflection by BenchmarkController
    public static final Class<? extends BenchmarkComponent> m_loaderClass = ABCLoader.class;
 
    public static final Class<?> PROCEDURES[] = new Class<?>[] {
        GetData.class,
    };
    public static final String PARTITIONING[][] = new String[][] {
        // { "TABLE NAME", "PARTITIONING COLUMN NAME" }
        {"TABLEA", "A_ID"},
        {"TABLEB", "B_A_ID"},
    };
 
    public ABCProjectBuilder() {
        super("abc", ABCProjectBuilder.class, PROCEDURES, PARTITIONING);
 
        // Create a single-statement stored procedure named 'DeleteData'
        addStmtProcedure("DeleteData", "DELETE FROM TABLEA WHERE A_ID < ?");
    }
}

package com.example.benchmark.abc
 
import org.voltdb.catalog.*;
import org.voltdb.client.Client;
import edu.brown.api.Loader;
import edu.brown.catalog.CatalogUtil;
 
public class ABCLoader extends Loader {
 
    public static void main(String args[]) throws Exception {
        BenchmarkComponent.main(ABCLoader.class, args, true);
    }
 
    public ABCLoader(String[] args) {
        super(args);
        for (String key : m_extraParams.keySet()) {
            // TODO: Retrieve extra configuration parameters
        } // FOR
    }
 
    @Override
    public void load() {
        // The catalog contains all the information about the database (e.g., tables, columns, indexes)
        // It is loaded from the benchmark's project JAR file
        Catalog catalog = this.getCatalog();
 
        // Iterate over all of the Table handles in the catalog and generate
        // tuples to upload into the database
        for (Table catalog_tbl : CatalogUtil.getDatabase(catalog).getTables()) {
            // TODO: Create an empty VoltTable handle and then populate it in batches to 
            //       be sent to the DBMS
            VoltTable table = CatalogUtil.getVoltTable(catalog_tbl);
 
            // Invoke the BenchmarkComponent's data loading method
            // This will upload the contents of the VoltTable into the DBMS cluster
            this.loadVoltTable(catalog_tbl.getName(), table);
        } // FOR
    }
}

package com.example.benchmark.abc
 
import java.io.IOException;
import java.util.Random;
import org.voltdb.client.*;
import edu.brown.api.BenchmarkComponent;
 
public class ABCClient extends BenchmarkComponent {
 
    public static void main(String args[]) {
        BenchmarkComponent.main(ABCClient.class, args, false);
    }
 
    public ABCClient(String[] args) {
        super(args);
        for (String key : m_extraParams.keySet()) {
            // TODO: Retrieve extra configuration parameters
        } // FOR
    }
 
    @Override
    public void runLoop() {
        try {
            Client client = this.getClientHandle();
            Random rand = new Random();
            while (true) {
                // Select a random transaction to execute and generate its input parameters
                // The procedure index (procIdx) needs to the same as the array of procedure
                // names returned by getTransactionDisplayNames()
                int procIdx = rand.nextInt(ABCProjectBuilder.PROCEDURES.length);
                String procName = ABCProjectBuilder.PROCEDURES[procIdx].getSimpleName();
                Object procParams[] = null; // TODO
 
                // Create a new Callback handle that will be executed when the transaction completes
                Callback callback = new Callback(procIdx);
 
                // Invoke the stored procedure through the client handle. This is non-blocking
                client.callProcedure(callback, procName, procIdx);
 
                // Check whether all the nodes are backed-up and this client should block
                // before sending new requests. 
                client.backpressureBarrier();
            } // WHILE
        } catch (NoConnectionsException e) {
            // Client has no clean mechanism for terminating with the DB.
            return;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // At shutdown an IOException is thrown for every connection to
            // the DB that is lost Ignore the exception here in order to not
            // get spammed, but will miss lost connections at runtime
        }
    }
 
    private class Callback implements ProcedureCallback {
        private final int idx;
 
        public Callback(int idx) {
            this.idx = idx;
        }
        @Override
        public void clientCallback(ClientResponse clientResponse) {
            // Increment the BenchmarkComponent's internal counter on the
            // number of transactions that have been completed
            incrementTransactionCounter(this.idx);
        }
    } // END CLASS
 
    @Override
    public String[] getTransactionDisplayNames() {
        // Return an array of transaction names
        String procNames[] = new String[ABCProjectBuilder.PROCEDURES.length];
        for (int i = 0; i < procNames.length; i++) {
            procNames[i] = ABCProjectBuilder.PROCEDURES[i].getSimpleName();
        }
        return (procNames);
    }
}