core28Example_main.c

TPC-B Inmemory. This example needs a compiled schema, core28Example.sdl.

#include <stdio.h>
#include <stdlib.h>
#include "example_fcns.h"
#include "rdm.h"
#include "rdmstartupapi.h"
/* Generated \c struct and \c typedef definitions to be used with the RDM APIs
*/
#include "core28Example_structs.h"
/* Generated catalog definition to be used with the RDM rdm_dbSetCatalog() API
*/
#include "core28Example_cat.h"
/* Number of records to insert */
#define RAMPUPTIME 15
#define TPS 5
#define NUM_BRANCHES 1
#define NUM_TELLERS 10
#define NUM_ACCOUNTS 100000L
#define STEADYSTATE 60
const char *const description =
"Performance Test (inmemory) using TPC-B test specifications.";
const RDM_CMDLINE_OPT opts[] = {{NULL, NULL, NULL, NULL}};
/*
* \mainpage core28 Popcorn Example
*
* The core28 example is based on the TPC-B Benchmark published by the
* Transaction Processing Performance Council (TPC) in 1994. This inmemory
* benchmark test uses a single, simple, update-intensive transaction to load
* the system.
*
* \par The Transaction Profile
*
* \code
* BEGIN TRANSACTION
* Update Account where Account_ID = Aid:
* Read Account_Balance from Account
* Set Account_Balance = Account_Balance + Delta
* Write Account_Balance to Account
* Update Teller where Teller_ID = Tid:
* Set Teller_Balance = Teller_Balance + Delta
* Write Teller_Balance to Teller
* Update Branch where Branch_ID = Bid:
* Set Branch_Balance = Branch_Balance + Delta
* Write Branch_Balance to Branch
* COMMIT TRANSACTION Return
* Account_Balance to driver
* \endcode
*
* \par TPS configuration
*
* For each nominal transaction-per-second configured, the test uses:
* \li 1 Branch Row for each TPS
* \li 10 Teller Rows for each Branch
* \li 100,000 Account Rows for each Branch
*
* \par Table of Contents
*
* - \subpage hDB
* - \subpage hPGMfunc
*
* For additional information, please refer to the product documentation at
* http://docs.raima.com/.
*
* \page hDB Database Schema
*
* \par Database Schema Definition
*
* The components of the database are defined to consist of four separate and
* individual files/tables, Account, Branch, Teller, and History.
*
* \include core28.sdl
*
* The schema was compiled using the RDM rdm-compile utility with the -s and -a
* options to generate an embedded database dictionary.
*
* \code rdm-compile -s -a core28.sdl \endcode
*
* The schema catalog information (\c core28_cat.c) is embedded inside the
* application.
*
* \page hPGMfunc Program Functions
*
* For simplicity, this example does not check all return codes, but good
* programming practices would dictate that they are checked after each
* RDM call.
*
* \li populateDatabase() - \copybrief populateDatabase
* \li do_trans() - \copybrief do_trans
* \li delete_records() - \copybrief delete_records
* \li main() - \copybrief main
*/
/* \brief Initialize the RDM runtime library for use in the core28 example
*
* This function initializes the RDM Transactional File Server (TFS) to use
* the embedded implementation. It also creates an RDM database handle
* and opens the "core28" database in exclusive mode.
*
* @return Returns an RDM_RETCODE code (sOKAY if successful)
*/
RDM_RETCODE populateDatabase (
RDM_DB hDB) /*< [in] Pointer to the RDM database handle */
{
BRANCHES brnRec;
rdm_dbSetOption (hDB, "durability", "consistent");
printf ("Populate database with %d TPS configuration:\t", TPS);
for (brnRec.bid = 0; brnRec.bid < TPS; brnRec.bid++)
{
int ii;
rc = rdm_dbStartUpdate (hDB, RDM_LOCK_ALL, 0, NULL, 0, NULL);
if (rc == sOKAY)
{
brnRec.bbalance = 0.0;
brnRec._filler_has_value = RDM_FALSE;
hDB, TABLE_BRANCHES, &brnRec, sizeof (brnRec), NULL);
/* insert associated Tellers */
for (ii = 0; rc == sOKAY && ii < NUM_TELLERS; ii++)
{
TELLERS telRec;
telRec.bid = brnRec.bid;
telRec.tbalance = 0.0;
telRec.tid = (NUM_TELLERS * brnRec.bid) + ii;
telRec._filler_has_value = RDM_FALSE;
hDB, TABLE_TELLERS, &telRec, sizeof (telRec), NULL);
}
/* insert associated Accounts */
for (ii = 0; rc == sOKAY && ii < NUM_ACCOUNTS; ii++)
{
ACCOUNTS accRec;
accRec.bid = brnRec.bid;
accRec.abalance = 0.0;
accRec.aid = (NUM_ACCOUNTS * brnRec.bid) + ii;
accRec._filler_has_value = RDM_FALSE;
hDB, TABLE_ACCOUNTS, &accRec, sizeof (accRec), NULL);
}
rdm_dbEnd (hDB);
}
}
timeMeasureEnd (&timer);
printf ("%u milliseconds\n", timeMeasureDiff (&timer));
return rc;
}
RDM_RETCODE do_trans (
RDM_DB hDB, /*< [in] Pointer to the RDM database handle */
unsigned int *elapsedTime)
{
double bal;
RDM_TRANS hTrans;
RDM_CURSOR cursor = NULL;
RDM_CURSOR brnCursor = NULL;
struct
{
int bid;
int aid;
int tid;
double delta;
} historyRow;
TELLERS_TELLERS_PK_KEY tellerKey;
ACCOUNTS_ACCOUNTS_PK_KEY acctKey;
/* Selct Delta value in the range of +/- 999999 */
historyRow.delta = (double) (rand () / (65536.0 * 65536.0));
/* first teller id = 0, last is Branches*10-1 */
historyRow.tid = (int) ((rand () % (TPS * NUM_TELLERS)));
/* assign this teller's branch id */
historyRow.bid = historyRow.tid / NUM_TELLERS;
historyRow.aid = (unsigned int) rand () % NUM_ACCOUNTS;
do
{
rc = rdm_dbStartUpdate (hDB, RDM_LOCK_ALL, 0, NULL, 0, &hTrans);
} while (rc == eUNAVAIL);
/* Update Account where Account_ID = Aid: */
acctKey.aid = historyRow.aid;
hDB, COL_ACCOUNTS_AID, &acctKey, sizeof (acctKey), &cursor);
cursor, COL_ACCOUNTS_ABALANCE, &bal, sizeof (bal), NULL);
bal += historyRow.delta;
cursor, COL_ACCOUNTS_ABALANCE, &bal, sizeof (bal));
/* Write to History (removed for inmemory version to save memory space) */
/* Update Teller where Teller_ID = Tid */
tellerKey.tid = historyRow.tid;
hDB, COL_TELLERS_TID, &tellerKey, sizeof (tellerKey), &cursor);
cursor, COL_TELLERS_TBALANCE, &bal, sizeof (bal), NULL);
bal += historyRow.delta;
cursor, COL_TELLERS_TBALANCE, &bal, sizeof (bal));
/* Update Branch where Branch_ID = Bid: */
rc = rdm_cursorGetOwnerRow (cursor, REF_TELLERS_FK, &brnCursor);
brnCursor, COL_BRANCHES_BBALANCE, &bal, sizeof (bal), NULL);
bal += historyRow.delta;
brnCursor, COL_BRANCHES_BBALANCE, &bal, sizeof (bal));
rc = rdm_transEnd (hTrans);
timeMeasureEnd (&timer);
if (cursor)
rdm_cursorFree (cursor);
if (brnCursor)
rdm_cursorFree (brnCursor);
*elapsedTime = timeMeasureDiff (&timer);
return rc;
}
RDM_RETCODE readDbStats (RDM_DB hDB)
{
RDM_CURSOR cursor = NULL;
uint64_t count;
printf ("\nTPC-B Database Statistics:\n");
rc = rdm_dbStartRead (hDB, RDM_LOCK_ALL, 0, NULL);
if (rc == sOKAY)
{
rc = rdm_dbGetRows (hDB, TABLE_BRANCHES, &cursor);
if (rc == sOKAY)
{
rc = rdm_cursorGetCount (cursor, &count);
printf (
"\tBRANCHES table contains %u rows\n", (unsigned int) count);
}
if (rc == sOKAY)
{
rc = rdm_dbGetRows (hDB, TABLE_TELLERS, &cursor);
}
if (rc == sOKAY)
{
rc = rdm_cursorGetCount (cursor, &count);
printf ("\tTELLERS table contains %u rows\n", (unsigned int) count);
}
if (rc == sOKAY)
{
rc = rdm_dbGetRows (hDB, TABLE_ACCOUNTS, &cursor);
}
if (rc == sOKAY)
{
rc = rdm_cursorGetCount (cursor, &count);
printf (
"\tACCOUNTS table contains %u rows\n", (unsigned int) count);
}
if (cursor)
rdm_cursorFree (cursor);
}
return rc;
}
/* \brief Main function for core28 example
*
* The function initializes the RDM environment and runs the insert operations.
* over a number of transaction block sizes
*
* @return Returns the RDM_RETCODE on exit.
*/
int main_core28 (int argc, const char *const *argv)
{
RDM_DB hDB;
RDM_TFS hTFS;
srand (100);
rc = rdm_cmdlineInit (&cmd, argc, argv, description, opts);
if (rc != sCMD_USAGE)
if (rc == sOKAY)
{
/* Initialize the TFS, task, and open/initialize the database */
rc = exampleOpenEmptyDatabase (&hTFS, &hDB, "core28Example", core28Example_cat);
if (rc == sOKAY)
{
rc = populateDatabase (hDB);
if (rc == sOKAY)
{
unsigned int thisTrans;
unsigned int minTrans = (unsigned int) -1;
unsigned int maxTrans = 0;
unsigned int numTrans = 0;
unsigned int totTrans = 0;
/* RAMP-UP transactions */
printf ("Perform RAMP-UP for %d seconds\n", RAMPUPTIME);
while (rc == sOKAY)
{
timeMeasureEnd (&timer);
if (timeMeasureDiff (&timer) > (RAMPUPTIME * 1000))
break;
rc = do_trans (hDB, &thisTrans);
}
/* TPC-B measurement */
printf ("Perform TPC-B test for %d seconds\n", STEADYSTATE);
while (rc == sOKAY)
{
timeMeasureEnd (&timer);
if (timeMeasureDiff (&timer) > (STEADYSTATE * 1000))
break;
rc = do_trans (hDB, &thisTrans);
/* update the statistics */
minTrans = RDM_MIN (minTrans, thisTrans);
maxTrans = RDM_MAX (maxTrans, thisTrans);
totTrans += thisTrans;
numTrans++;
}
/* prevent divide by 0 incase totTrans is 0 */
if (totTrans != 0)
{
printf (
"Steady state results: %.2f TPS-B\n\n",
(double) numTrans / (double) totTrans * 1000.0);
}
printf (
"\tMinimum transaction time: %u milliseconds\n", minTrans);
printf (
"\tMaximum transaction time: %u milliseconds\n", maxTrans);
printf (
"\tTotal number of transactions measured: %u\n", numTrans);
readDbStats (hDB);
}
exampleCleanup (hTFS, hDB);
}
}
return (int) rc;
}
RDM_RETCODE rdm_transEnd(RDM_TRANS trans)
End a transactional operation.
Header for the native RDM Runtime API.
#define exampleOpenEmptyDatabase(tfs, db, name, catalog)
Definition: example_fcns.h:22
void timeMeasureBegin(perfTimer_t *timer)
@ RDM_FALSE
Definition: psptypes.h:59
#define RDM_MAX(a, b)
Definition: psptypes.h:83
RDM_RETCODE rdm_dbEnd(RDM_DB db)
End a transactional operation.
@ sCMD_USAGE
Definition: rdmretcodetypes.h:72
struct RDM_CURSOR_S * RDM_CURSOR
Definition: rdmtypes.h:306
RDM_RETCODE rdm_dbStartRead(RDM_DB db, const RDM_TABLE_ID *tableIds, uint32_t numTableIds, RDM_TRANS *pTrans)
Get read locks.
void timeMeasureEnd(perfTimer_t *timer)
@ eUNAVAIL
Definition: rdmretcodetypes.h:194
The buffer used by the command line parser to hold state information.
Definition: rdmcmdlinetypes.h:85
RDM_RETCODE rdm_cursorGetCount(RDM_CURSOR cursor, uint64_t *count)
Get the row count for a cursor.
#define RDM_MIN(a, b)
Definition: psptypes.h:81
#define exampleCleanup(tfs, db)
Definition: example_fcns.h:30
RDM_RETCODE rdm_cursorUpdateColumn(RDM_CURSOR cursor, RDM_COLUMN_ID columnId, const void *columnValue, size_t bytesIn)
Update a single column in a row.
#define print_error(rc)
Definition: example_fcns.h:17
@ sOKAY
Definition: rdmretcodetypes.h:98
RDM_RETCODE rdm_dbGetRowsByKeyAtKey(RDM_DB db, RDM_KEY_ID keyId, const void *keyValue, size_t len, RDM_CURSOR *pCursor)
Associate an RDM_CURSOR with a row set that is ordered by key value and is initially positioned at th...
struct RDM_TRANS_S * RDM_TRANS
Definition: rdmtypes.h:307
Generic usage function option record.
Definition: rdmcmdlinetypes.h:32
RDM_RETCODE rdm_cursorFree(RDM_CURSOR cursor)
Free an RDM_CURSOR.
RDM_RETCODE rdm_dbSetOption(RDM_DB db, const char *keyword, const char *strValue)
Set a single RDM option from a string.
#define RDM_STARTUP_EXAMPLE(name)
Definition: rdmstartuptypes.h:73
RDM_RETCODE rdm_dbGetRows(RDM_DB db, RDM_TABLE_ID tableId, RDM_CURSOR *pCursor)
Associate an RDM_CURSOR with rows based on a table id.
unsigned int timeMeasureDiff(perfTimer_t *timer)
RDM_RETCODE rdm_dbInsertRow(RDM_DB db, RDM_TABLE_ID tableId, const void *colValues, size_t bytesIn, RDM_CURSOR *pCursor)
Insert a new row into a table at the specified rowId.
RDM_RETCODE rdm_cursorReadColumn(RDM_CURSOR cursor, RDM_COLUMN_ID columnId, void *columnValue, size_t bytesIn, size_t *bytesOut)
Read a single column from a table row.
struct RDM_TFS_S * RDM_TFS
RDM TFS Handle.
Definition: rdmtfstypes.h:21
RDM_RETCODE rdm_cmdlineInit(RDM_CMDLINE *cmd, int32_t argc, const char *const argv[], const char *description, const RDM_CMDLINE_OPT *opts)
Initialize an RDM_CMDLINE buffer and validate the command line.
struct RDM_DB_S * RDM_DB
Definition: rdmtypes.h:305
RDM_RETCODE rdm_cursorGetOwnerRow(RDM_CURSOR memberCursor, RDM_REF_ID refId, RDM_CURSOR *pCursor)
Associate an RDM_CURSOR with a set owner.
#define RDM_LOCK_ALL
Definition: rdmtypes.h:170
RDM_RETCODE rdm_dbStartUpdate(RDM_DB db, const RDM_TABLE_ID *writeTableIds, uint32_t numWriteTableIds, const RDM_TABLE_ID *readTableIds, uint32_t numReadTableIds, RDM_TRANS *pTrans)
Get write locks.
Definition: example_fcns.h:37
Internal RDM Startup API used by startup macros.
RDM_RETCODE
RDM status and error return codes.
Definition: rdmretcodetypes.h:44