| package org.hsqldb.test; |
| |
| // nbazin@users - enhancements to the original code |
| // fredt@users - 20050202 - corrected getRandomID(int) to return a randomly distributed value |
| /* |
| * This is a sample implementation of the Transaction Processing Performance |
| * Council Benchmark B coded in Java and ANSI SQL2. |
| * |
| * This version is using one connection per thread to parallellize |
| * server operations. |
| * @author Mark Matthews (mark@mysql.com) |
| */ |
| import java.io.FileOutputStream; |
| import java.io.PrintStream; |
| import java.sql.Connection; |
| import java.sql.DriverManager; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| |
| class JDBCBench { |
| |
| /* tpc bm b scaling rules */ |
| public static int tps = 1; /* the tps scaling factor: here it is 1 */ |
| public static int nbranches = 1; /* number of branches in 1 tps db */ |
| public static int ntellers = 10; /* number of tellers in 1 tps db */ |
| public static int naccounts = 100000; /* number of accounts in 1 tps db */ |
| public static int nhistory = 864000; /* number of history recs in 1 tps db */ |
| public static final int TELLER = 0; |
| public static final int BRANCH = 1; |
| public static final int ACCOUNT = 2; |
| int failed_transactions = 0; |
| int transaction_count = 0; |
| static int n_clients = 10; |
| static int n_txn_per_client = 10; |
| long start_time = 0; |
| static boolean transactions = true; |
| static boolean prepared_stmt = false; |
| static String tableExtension = ""; |
| static String createExtension = ""; |
| static String ShutdownCommand = ""; |
| static PrintStream TabFile = null; |
| static boolean verbose = false; |
| MemoryWatcherThread MemoryWatcher; |
| |
| /* main program, creates a 1-tps database: i.e. 1 branch, 10 tellers,... |
| * runs one TPC BM B transaction |
| * example command line: |
| * -driver org.hsqldb.jdbc.JDBCDriver -url jdbc:hsqldb:/hsql/jdbcbench/test -user SA -clients 20 -tpc 10000 |
| */ |
| public static void main(String[] Args) { |
| |
| String DriverName = ""; |
| String DBUrl = ""; |
| String DBUser = ""; |
| String DBPassword = ""; |
| boolean initialize_dataset = false; |
| |
| for (int i = 0; i < Args.length; i++) { |
| if (Args[i].equals("-clients")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| n_clients = Integer.parseInt(Args[i]); |
| } |
| } else if (Args[i].equals("-driver")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| DriverName = Args[i]; |
| |
| if (DriverName.equals( |
| "org.enhydra.instantdb.jdbc.idbDriver")) { |
| ShutdownCommand = "SHUTDOWN"; |
| } |
| |
| if (DriverName.equals( |
| "com.borland.datastore.jdbc.DataStoreDriver")) {} |
| |
| if (DriverName.equals("com.mckoi.JDBCDriver")) { |
| ShutdownCommand = "SHUTDOWN"; |
| } |
| |
| if (DriverName.equals("org.hsqldb.jdbc.JDBCDriver") |
| || DriverName.equals("org.hsqldb.jdbcDriver")) { |
| |
| tableExtension = "CREATE CACHED TABLE "; |
| // ShutdownCommand = "SHUTDOWN"; |
| } |
| } |
| } else if (Args[i].equals("-url")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| DBUrl = Args[i]; |
| } |
| } else if (Args[i].equals("-user")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| DBUser = Args[i]; |
| } |
| } else if (Args[i].equals("-tabfile")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| try { |
| FileOutputStream File = new FileOutputStream(Args[i]); |
| |
| TabFile = new PrintStream(File); |
| } catch (Exception e) { |
| TabFile = null; |
| } |
| } |
| } else if (Args[i].equals("-password")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| DBPassword = Args[i]; |
| } |
| } else if (Args[i].equals("-tpc")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| n_txn_per_client = Integer.parseInt(Args[i]); |
| } |
| } else if (Args[i].equals("-init")) { |
| initialize_dataset = true; |
| } else if (Args[i].equals("-tps")) { |
| if (i + 1 < Args.length) { |
| i++; |
| |
| tps = Integer.parseInt(Args[i]); |
| } |
| } else if (Args[i].equals("-v")) { |
| verbose = true; |
| } |
| } |
| |
| if (DriverName.length() == 0 || DBUrl.length() == 0) { |
| System.out.println( |
| "usage: java JDBCBench -driver [driver_class_name] -url [url_to_db] -user [username] -password [password] [-v] [-init] [-tpc n] [-clients n]"); |
| System.out.println(); |
| System.out.println("-v verbose error messages"); |
| System.out.println("-init initialize the tables"); |
| System.out.println("-tpc transactions per client"); |
| System.out.println("-clients number of simultaneous clients"); |
| System.exit(-1); |
| } |
| |
| System.out.println( |
| "*********************************************************"); |
| System.out.println( |
| "* JDBCBench v1.1 *"); |
| System.out.println( |
| "*********************************************************"); |
| System.out.println(); |
| System.out.println("Driver: " + DriverName); |
| System.out.println("URL:" + DBUrl); |
| System.out.println(); |
| System.out.println("Scale factor value: " + tps); |
| System.out.println("Number of clients: " + n_clients); |
| System.out.println("Number of transactions per client: " |
| + n_txn_per_client); |
| System.out.println(); |
| |
| try { |
| Class.forName(DriverName); |
| |
| JDBCBench Me = new JDBCBench(DBUrl, DBUser, DBPassword, |
| initialize_dataset); |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| } |
| |
| public JDBCBench(String url, String user, String password, boolean init) { |
| |
| Vector vClient = new Vector(); |
| Thread Client = null; |
| Enumeration e = null; |
| Connection guardian = null; |
| |
| try { |
| java.util.Date start = new java.util.Date(); |
| |
| if (init) { |
| System.out.println("Start: " + start.toString()); |
| System.out.print("Initializing dataset..."); |
| createDatabase(url, user, password); |
| |
| double seconds = (System.currentTimeMillis() - start.getTime()) |
| / 1000D; |
| |
| System.out.println("done. in " + seconds + " seconds\n"); |
| System.out.println("Complete: " |
| + (new java.util.Date()).toString()); |
| } |
| |
| System.out.println("* Starting Benchmark Run *"); |
| |
| MemoryWatcher = new MemoryWatcherThread(); |
| |
| MemoryWatcher.start(); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| /* |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| oneRound(url, user, password, transactions, true); |
| */ |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } finally { |
| MemoryWatcher.end(); |
| |
| try { |
| MemoryWatcher.join(); |
| |
| if (ShutdownCommand.length() > 0) { |
| guardian = connect(url, user, password); |
| |
| Statement Stmt = guardian.createStatement(); |
| |
| Stmt.execute("SHUTDOWN IMMEDIATELY"); |
| Stmt.close(); |
| connectClose(guardian); |
| } |
| |
| if (TabFile != null) { |
| TabFile.close(); |
| } |
| } catch (Exception E1) {} |
| |
| // System.exit(0); |
| } |
| } |
| |
| void oneRound(String url, String user, String password, |
| boolean transactions, |
| boolean prepared) throws InterruptedException, SQLException { |
| |
| Vector vClient = new Vector(); |
| Thread Client = null; |
| Enumeration e = null; |
| Connection guardian = null; |
| |
| // |
| this.transactions = transactions; |
| this.prepared_stmt = prepared; |
| start_time = System.currentTimeMillis(); |
| |
| for (int i = 0; i < n_clients; i++) { |
| Client = new ClientThread(n_txn_per_client, url, user, password, |
| Connection.TRANSACTION_READ_COMMITTED); |
| |
| Client.start(); |
| vClient.addElement(Client); |
| } |
| |
| /* |
| ** Barrier to complete this test session |
| */ |
| e = vClient.elements(); |
| |
| while (e.hasMoreElements()) { |
| Client = (Thread) e.nextElement(); |
| |
| Client.join(); |
| } |
| |
| vClient.removeAllElements(); |
| reportDone(); |
| |
| guardian = connect(url, user, password); |
| |
| checkSums(guardian); |
| connectClose(guardian); |
| } |
| |
| public void reportDone() { |
| |
| long end_time = System.currentTimeMillis(); |
| double completion_time = ((double) end_time - (double) start_time) |
| / 1000; |
| |
| if (TabFile != null) { |
| TabFile.print(tps + ";" + n_clients + ";" + n_txn_per_client |
| + ";"); |
| } |
| |
| System.out.println("\n* Benchmark Report *"); |
| System.out.print("* Featuring "); |
| |
| if (prepared_stmt) { |
| System.out.print("<prepared statements> "); |
| |
| if (TabFile != null) { |
| TabFile.print("<prepared statements>;"); |
| } |
| } else { |
| System.out.print("<direct queries> "); |
| |
| if (TabFile != null) { |
| TabFile.print("<direct queries>;"); |
| } |
| } |
| |
| if (transactions) { |
| System.out.print("<transactions> "); |
| |
| if (TabFile != null) { |
| TabFile.print("<transactions>;"); |
| } |
| } else { |
| System.out.print("<auto-commit> "); |
| |
| if (TabFile != null) { |
| TabFile.print("<auto-commit>;"); |
| } |
| } |
| |
| System.out.println("\n--------------------"); |
| System.out.println("Time to execute " + transaction_count |
| + " transactions: " + completion_time |
| + " seconds."); |
| System.out.println("Max/Min memory usage: " + MemoryWatcher.max |
| + " / " + MemoryWatcher.min + " kb"); |
| System.out.println(failed_transactions + " / " + transaction_count |
| + " failed to complete."); |
| |
| double rate = (transaction_count - failed_transactions) |
| / completion_time; |
| |
| System.out.println("Transaction rate: " + rate + " txn/sec."); |
| |
| if (TabFile != null) { |
| TabFile.print(MemoryWatcher.max + ";" + MemoryWatcher.min + ";" |
| + failed_transactions + ";" + rate + "\n"); |
| } |
| |
| transaction_count = 0; |
| failed_transactions = 0; |
| |
| MemoryWatcher.reset(); |
| } |
| |
| public synchronized void incrementTransactionCount() { |
| transaction_count++; |
| } |
| |
| public synchronized void incrementFailedTransactionCount() { |
| failed_transactions++; |
| } |
| |
| void createDatabase(String url, String user, |
| String password) throws Exception { |
| |
| Connection Conn = connect(url, user, password); |
| String s = Conn.getMetaData().getDatabaseProductName(); |
| |
| System.out.println("DBMS: " + s); |
| |
| transactions = true; |
| |
| if (transactions) { |
| try { |
| Conn.setAutoCommit(false); |
| System.out.println("In transaction mode"); |
| } catch (SQLException Etrxn) { |
| transactions = false; |
| } |
| } |
| |
| try { |
| int accountsnb = 0; |
| Statement Stmt = Conn.createStatement(); |
| String Query; |
| |
| // |
| Stmt.execute("SET WRITE_DELAY 10000 MILLIS;"); |
| Stmt.execute("SET PROPERTY \"hsqldb.cache_scale\" 16;"); |
| |
| // |
| Query = "SELECT count(*) "; |
| Query += "FROM accounts"; |
| |
| ResultSet RS = Stmt.executeQuery(Query); |
| |
| Stmt.clearWarnings(); |
| |
| while (RS.next()) { |
| accountsnb = RS.getInt(1); |
| } |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| Stmt.close(); |
| |
| if (accountsnb == (naccounts * tps)) { |
| System.out.println("Already initialized"); |
| connectClose(Conn); |
| |
| return; |
| } |
| } catch (Exception E) {} |
| |
| System.out.println("Drop old tables if they exist"); |
| |
| try { |
| Statement Stmt = Conn.createStatement(); |
| String Query; |
| |
| Query = "DROP TABLE history"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DROP TABLE accounts"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DROP TABLE tellers"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DROP TABLE branches"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| Stmt.close(); |
| } catch (Exception E) {} |
| |
| System.out.println("Creates tables"); |
| |
| try { |
| Statement Stmt = Conn.createStatement(); |
| String Query; |
| |
| if (tableExtension.length() > 0) { |
| Query = tableExtension + " branches ("; |
| } else { |
| Query = "CREATE TABLE branches ("; |
| } |
| |
| Query += "Bid INTEGER NOT NULL PRIMARY KEY, "; |
| Query += "Bbalance INTEGER,"; |
| Query += "filler CHAR(88))"; /* pad to 100 bytes */ |
| |
| if (createExtension.length() > 0) { |
| Query += createExtension; |
| } |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| if (tableExtension.length() > 0) { |
| Query = tableExtension + " tellers ("; |
| } else { |
| Query = "CREATE TABLE tellers ("; |
| } |
| |
| Query += "Tid INTEGER NOT NULL PRIMARY KEY,"; |
| Query += "Bid INTEGER,"; |
| Query += "Tbalance INTEGER,"; |
| Query += "filler CHAR(84))"; /* pad to 100 bytes */ |
| |
| if (createExtension.length() > 0) { |
| Query += createExtension; |
| } |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| if (tableExtension.length() > 0) { |
| Query = tableExtension + " accounts ("; |
| } else { |
| Query = "CREATE TABLE accounts ("; |
| } |
| |
| Query += "Aid INTEGER NOT NULL PRIMARY KEY, "; |
| Query += "Bid INTEGER, "; |
| Query += "Abalance INTEGER, "; |
| Query += "filler CHAR(84))"; /* pad to 100 bytes */ |
| |
| if (createExtension.length() > 0) { |
| Query += createExtension; |
| } |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| if (tableExtension.length() > 0) { |
| Query = tableExtension + " history ("; |
| } else { |
| Query = "CREATE TABLE history ("; |
| } |
| |
| Query += "Tid INTEGER, "; |
| Query += "Bid INTEGER, "; |
| Query += "Aid INTEGER, "; |
| Query += "delta INTEGER, "; |
| Query += "tstime TIMESTAMP, "; |
| Query += "filler CHAR(22))"; /* pad to 50 bytes */ |
| |
| if (createExtension.length() > 0) { |
| Query += createExtension; |
| } |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| /* |
| Stmt.execute("SET TABLE ACCOUNTS SOURCE \"ACCOUNTS.TXT\""); |
| Stmt.execute("SET TABLE BRANCHES SOURCE \"BBRANCHES.TXT\""); |
| Stmt.execute("SET TABLE TELLERS SOURCE \"TELLERS.TXT\""); |
| Stmt.execute("SET TABLE HISTORY SOURCE \"HISTORY.TXT\""); |
| */ |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| Stmt.close(); |
| } catch (Exception E) { |
| System.out.println( |
| "Delete elements in table in case Drop didn't work"); |
| } |
| |
| System.out.println( |
| "Delete elements in table in case Drop didn't work"); |
| |
| try { |
| Statement Stmt = Conn.createStatement(); |
| String Query; |
| |
| Query = "DELETE FROM history"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DELETE FROM accounts"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DELETE FROM tellers"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "DELETE FROM branches"; |
| |
| Stmt.execute(Query); |
| Stmt.clearWarnings(); |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| /* prime database using TPC BM B scaling rules. |
| ** Note that for each branch and teller: |
| ** branch_id = teller_id / ntellers |
| ** branch_id = account_id / naccounts |
| */ |
| PreparedStatement pstmt = null; |
| |
| prepared_stmt = true; |
| |
| if (prepared_stmt) { |
| try { |
| Query = "INSERT INTO branches(Bid,Bbalance) VALUES (?,0)"; |
| pstmt = Conn.prepareStatement(Query); |
| |
| System.out.println("Using prepared statements"); |
| } catch (SQLException Epstmt) { |
| pstmt = null; |
| prepared_stmt = false; |
| } |
| } |
| |
| System.out.println("Insert data in branches table"); |
| |
| for (int i = 0; i < nbranches * tps; i++) { |
| if (prepared_stmt) { |
| pstmt.setInt(1, i); |
| pstmt.executeUpdate(); |
| pstmt.clearWarnings(); |
| } else { |
| Query = "INSERT INTO branches(Bid,Bbalance) VALUES (" + i |
| + ",0)"; |
| |
| Stmt.executeUpdate(Query); |
| } |
| |
| if ((i % 100 == 0) && (transactions)) { |
| Conn.commit(); |
| } |
| } |
| |
| if (prepared_stmt) { |
| pstmt.close(); |
| } |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| if (prepared_stmt) { |
| Query = "INSERT INTO tellers(Tid,Bid,Tbalance) VALUES (?,?,0)"; |
| pstmt = Conn.prepareStatement(Query); |
| } |
| |
| System.out.println("Insert data in tellers table"); |
| |
| for (int i = 0; i < ntellers * tps; i++) { |
| if (prepared_stmt) { |
| pstmt.setInt(1, i); |
| pstmt.setInt(2, i / ntellers); |
| pstmt.executeUpdate(); |
| pstmt.clearWarnings(); |
| } else { |
| Query = "INSERT INTO tellers(Tid,Bid,Tbalance) VALUES (" |
| + i + "," + i / ntellers + ",0)"; |
| |
| Stmt.executeUpdate(Query); |
| } |
| |
| if ((i % 100 == 0) && (transactions)) { |
| Conn.commit(); |
| } |
| } |
| |
| if (prepared_stmt) { |
| pstmt.close(); |
| } |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| if (prepared_stmt) { |
| Query = |
| "INSERT INTO accounts(Aid,Bid,Abalance) VALUES (?,?,0)"; |
| pstmt = Conn.prepareStatement(Query); |
| } |
| |
| System.out.println("Insert data in accounts table"); |
| |
| for (int i = 0; i < naccounts * tps; i++) { |
| if (prepared_stmt) { |
| pstmt.setInt(1, i); |
| pstmt.setInt(2, i / naccounts); |
| pstmt.executeUpdate(); |
| pstmt.clearWarnings(); |
| } else { |
| Query = "INSERT INTO accounts(Aid,Bid,Abalance) VALUES (" |
| + i + "," + i / naccounts + ",0)"; |
| |
| Stmt.executeUpdate(Query); |
| } |
| |
| if ((i % 10000 == 0) && (transactions)) { |
| Conn.commit(); |
| } |
| |
| if ((i > 0) && ((i % 10000) == 0)) { |
| System.out.println("\t" + i + "\t records inserted"); |
| } |
| } |
| |
| if (prepared_stmt) { |
| pstmt.close(); |
| } |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| System.out.println("\t" + (naccounts * tps) |
| + "\t records inserted"); |
| |
| // for tests |
| if (ShutdownCommand.length() > 0) { |
| Stmt.execute(ShutdownCommand); |
| } |
| |
| Stmt.close(); |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| |
| connectClose(Conn); |
| } /* end of CreateDatabase */ |
| |
| public static int getRandomInt(int lo, int hi) { |
| |
| int ret = 0; |
| |
| ret = (int) (Math.random() * (hi - lo + 1)); |
| ret += lo; |
| |
| return ret; |
| } |
| |
| public static int getRandomID(int type) { |
| |
| int min = 0, |
| max = 0; |
| |
| switch (type) { |
| |
| case TELLER : |
| max = ntellers * tps - 1; |
| break; |
| |
| case BRANCH : |
| max = nbranches * tps - 1; |
| break; |
| |
| case ACCOUNT : |
| max = naccounts * tps - 1; |
| break; |
| } |
| |
| return (getRandomInt(min, max)); |
| } |
| |
| public static Connection connect(String DBUrl, String DBUser, |
| String DBPassword) { |
| |
| try { |
| Connection conn = DriverManager.getConnection(DBUrl, DBUser, |
| DBPassword); |
| |
| return conn; |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| |
| return null; |
| } |
| |
| public static void connectClose(Connection c) { |
| |
| if (c == null) { |
| return; |
| } |
| |
| try { |
| c.close(); |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| } |
| |
| void checkSums(Connection conn) throws SQLException { |
| |
| Statement st1 = null; |
| ResultSet rs = null; |
| int bbalancesum; |
| int tbalancesum; |
| int abalancesum; |
| int deltasum; |
| |
| try { |
| st1 = conn.createStatement(); |
| rs = st1.executeQuery("select sum(bbalance) from branches"); |
| |
| rs.next(); |
| |
| bbalancesum = rs.getInt(1); |
| |
| rs.close(); |
| |
| rs = st1.executeQuery("select sum(tbalance) from tellers"); |
| |
| rs.next(); |
| |
| tbalancesum = rs.getInt(1); |
| |
| rs.close(); |
| |
| rs = st1.executeQuery("select sum(abalance) from accounts"); |
| |
| rs.next(); |
| |
| abalancesum = rs.getInt(1); |
| |
| rs.close(); |
| |
| rs = st1.executeQuery("select sum(delta) from history"); |
| |
| rs.next(); |
| |
| deltasum = rs.getInt(1); |
| |
| rs.close(); |
| |
| rs = null; |
| |
| st1.close(); |
| |
| st1 = null; |
| |
| if (abalancesum != bbalancesum || bbalancesum != tbalancesum |
| || tbalancesum != deltasum) { |
| System.out.println("sums don't match!"); |
| } else { |
| System.out.println("sums match!"); |
| } |
| |
| System.out.println("A " + abalancesum + " B " + bbalancesum |
| + " T " + tbalancesum + " H " + deltasum); |
| } finally { |
| if (st1 != null) { |
| st1.close(); |
| } |
| } |
| } |
| |
| class ClientThread extends Thread { |
| |
| int ntrans = 0; |
| Connection Conn; |
| PreparedStatement pstmt1 = null; |
| PreparedStatement pstmt2 = null; |
| PreparedStatement pstmt3 = null; |
| PreparedStatement pstmt4 = null; |
| PreparedStatement pstmt5 = null; |
| |
| public ClientThread(int number_of_txns, String url, String user, |
| String password, int transactionMode) { |
| |
| System.out.println(number_of_txns); |
| |
| ntrans = number_of_txns; |
| Conn = connect(url, user, password); |
| |
| if (Conn == null) { |
| return; |
| } |
| |
| try { |
| if (transactions) { |
| Conn.setAutoCommit(false); |
| } |
| |
| Conn.setTransactionIsolation(transactionMode); |
| |
| if (prepared_stmt) { |
| String Query; |
| |
| Query = "UPDATE accounts "; |
| Query += "SET Abalance = Abalance + ? "; |
| Query += "WHERE Aid = ?"; |
| pstmt1 = Conn.prepareStatement(Query); |
| Query = "SELECT Abalance "; |
| Query += "FROM accounts "; |
| Query += "WHERE Aid = ?"; |
| pstmt2 = Conn.prepareStatement(Query); |
| Query = "UPDATE tellers "; |
| Query += "SET Tbalance = Tbalance + ? "; |
| Query += "WHERE Tid = ?"; |
| pstmt3 = Conn.prepareStatement(Query); |
| Query = "UPDATE branches "; |
| Query += "SET Bbalance = Bbalance + ? "; |
| Query += "WHERE Bid = ?"; |
| pstmt4 = Conn.prepareStatement(Query); |
| Query = "INSERT INTO history(Tid, Bid, Aid, delta) "; |
| Query += "VALUES (?,?,?,?)"; |
| pstmt5 = Conn.prepareStatement(Query); |
| } |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| } |
| |
| public void run() { |
| |
| while (ntrans-- > 0) { |
| int account = JDBCBench.getRandomID(ACCOUNT); |
| int branch = JDBCBench.getRandomID(BRANCH); |
| int teller = JDBCBench.getRandomID(TELLER); |
| int delta = JDBCBench.getRandomInt(0, 1000); |
| |
| doOne(branch, teller, account, delta); |
| incrementTransactionCount(); |
| } |
| |
| if (prepared_stmt) { |
| try { |
| if (pstmt1 != null) { |
| pstmt1.close(); |
| } |
| |
| if (pstmt2 != null) { |
| pstmt2.close(); |
| } |
| |
| if (pstmt3 != null) { |
| pstmt3.close(); |
| } |
| |
| if (pstmt4 != null) { |
| pstmt4.close(); |
| } |
| |
| if (pstmt5 != null) { |
| pstmt5.close(); |
| } |
| } catch (Exception E) { |
| System.out.println(E.getMessage()); |
| E.printStackTrace(); |
| } |
| } |
| |
| connectClose(Conn); |
| |
| Conn = null; |
| } |
| |
| /* |
| ** doOne() - Executes a single TPC BM B transaction. |
| */ |
| int doOne(int bid, int tid, int aid, int delta) { |
| |
| int aBalance = 0; |
| |
| if (Conn == null) { |
| incrementFailedTransactionCount(); |
| |
| return 0; |
| } |
| |
| try { |
| if (prepared_stmt) { |
| pstmt1.setInt(1, delta); |
| pstmt1.setInt(2, aid); |
| pstmt1.executeUpdate(); |
| pstmt1.clearWarnings(); |
| pstmt2.setInt(1, aid); |
| |
| ResultSet RS = pstmt2.executeQuery(); |
| |
| pstmt2.clearWarnings(); |
| |
| while (RS.next()) { |
| aBalance = RS.getInt(1); |
| } |
| |
| pstmt3.setInt(1, delta); |
| pstmt3.setInt(2, tid); |
| pstmt3.executeUpdate(); |
| pstmt3.clearWarnings(); |
| pstmt4.setInt(1, delta); |
| pstmt4.setInt(2, bid); |
| pstmt4.executeUpdate(); |
| pstmt4.clearWarnings(); |
| pstmt5.setInt(1, tid); |
| pstmt5.setInt(2, bid); |
| pstmt5.setInt(3, aid); |
| pstmt5.setInt(4, delta); |
| pstmt5.executeUpdate(); |
| pstmt5.clearWarnings(); |
| } else { |
| Statement Stmt = Conn.createStatement(); |
| String Query = "UPDATE accounts "; |
| |
| Query += "SET Abalance = Abalance + " + delta + " "; |
| Query += "WHERE Aid = " + aid; |
| |
| int res = Stmt.executeUpdate(Query); |
| |
| Stmt.clearWarnings(); |
| |
| Query = "SELECT Abalance "; |
| Query += "FROM accounts "; |
| Query += "WHERE Aid = " + aid; |
| |
| ResultSet RS = Stmt.executeQuery(Query); |
| |
| Stmt.clearWarnings(); |
| |
| while (RS.next()) { |
| aBalance = RS.getInt(1); |
| } |
| |
| Query = "UPDATE tellers "; |
| Query += "SET Tbalance = Tbalance + " + delta + " "; |
| Query += "WHERE Tid = " + tid; |
| |
| Stmt.executeUpdate(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "UPDATE branches "; |
| Query += "SET Bbalance = Bbalance + " + delta + " "; |
| Query += "WHERE Bid = " + bid; |
| |
| Stmt.executeUpdate(Query); |
| Stmt.clearWarnings(); |
| |
| Query = "INSERT INTO history(Tid, Bid, Aid, delta) "; |
| Query += "VALUES ("; |
| Query += tid + ","; |
| Query += bid + ","; |
| Query += aid + ","; |
| Query += delta + ")"; |
| |
| Stmt.executeUpdate(Query); |
| Stmt.clearWarnings(); |
| Stmt.close(); |
| } |
| |
| if (transactions) { |
| Conn.commit(); |
| } |
| |
| return aBalance; |
| } catch (Exception E) { |
| if (verbose) { |
| System.out.println("Transaction failed: " |
| + E.getMessage()); |
| E.printStackTrace(); |
| } |
| |
| incrementFailedTransactionCount(); |
| |
| if (transactions) { |
| try { |
| Conn.rollback(); |
| } catch (SQLException E1) {} |
| } |
| } |
| |
| return 0; |
| } /* end of DoOne */ |
| } /* end of class ClientThread */ |
| |
| class MemoryWatcherThread extends Thread { |
| |
| long min = 0; |
| long max = 0; |
| boolean keep_running = true; |
| |
| public MemoryWatcherThread() { |
| |
| this.reset(); |
| |
| keep_running = true; |
| } |
| |
| public void reset() { |
| |
| System.gc(); |
| |
| long currentFree = Runtime.getRuntime().freeMemory(); |
| long currentAlloc = Runtime.getRuntime().totalMemory(); |
| |
| min = max = (currentAlloc - currentFree); |
| } |
| |
| public void end() { |
| keep_running = false; |
| } |
| |
| public void run() { |
| |
| while (keep_running) { |
| long currentFree = Runtime.getRuntime().freeMemory(); |
| long currentAlloc = Runtime.getRuntime().totalMemory(); |
| long used = currentAlloc - currentFree; |
| |
| if (used < min) { |
| min = used; |
| } |
| |
| if (used > max) { |
| max = used; |
| } |
| |
| try { |
| sleep(100); |
| } catch (InterruptedException E) {} |
| } |
| } |
| } /* end of class MemoryWatcherThread */ |
| } |
