开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
benchronja.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：43k
源码类别：

MySQL数据库

开发平台：

Visual C++

benchronja.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* ***************************************************
  19.        NODEREC
  20.        Perform benchmark of insert, update and delete transactions
  22.        Arguments:
  23.         -t Number of threads to start, default 1
  24.         -o Number of loops per thread, default 100000
  27.  * *************************************************** */
  29. #include <ndb_global.h>
  31. #include <NdbApi.hpp>
  32. #include <NdbTest.hpp>
  33. #include <NdbOut.hpp>
  34. #include <NdbThread.h>
  35. #include <NdbSleep.h>
  36. #include <NdbMain.h>
  37. #include <NdbTimer.hpp>
  38. #include <NdbTick.h>
  39. #include <random.h>
  41. #define MAX_TIMERS 4 
  42. #define MAXSTRLEN 16 
  43. #define MAXATTR 64
  44. #define MAXTABLES 64
  45. #define MAXTHREADS 256
  46. #define MAXATTRSIZE 8000
  47. #define START_TIMER NdbTimer timer; timer.doStart();
  48. #define STOP_TIMER timer.doStop();
  49. #define START_TIMER_TOP NdbTimer timer_top; timer_top.doStart();
  50. #define STOP_TIMER_TOP timer_top.doStop();
  52. void* ThreadExec(void*);
  53. struct ThreadNdb
  54. {
  55.   int NoOfOps;
  56.   int ThreadNo;
  57.   Ndb* NdbRef;
  58. };
  60. static NdbThread* threadLife[MAXTHREADS];
  61. static unsigned int tNoOfThreads;
  62. static unsigned int tNoOfOpsPerExecute;
  63. static unsigned int tNoOfRecords;
  64. static unsigned int tNoOfOperations;
  65. static int ThreadReady[MAXTHREADS];
  66. static int ThreadStart[MAXTHREADS];
  68. NDB_COMMAND(benchronja, "benchronja", "benchronja", "benchronja", 65535){
  69.   ndb_init();
  71.   ThreadNdb tabThread[MAXTHREADS];
  72.   int i = 0 ;
  73.   int cont = 0 ;
  74.   Ndb* pMyNdb = NULL ; //( "TEST_DB" );
  75.   int           tmp = 0 ;
  76.   int nTest = 0 ;
  77.   char inp[100] ;
  79.   tNoOfThreads = 1; // Default Value
  80.   tNoOfOpsPerExecute = 1; // Default Value
  81.   tNoOfOperations = 100000; // Default Value
  82.   tNoOfRecords = 500 ; // Default Value <epaulsa: changed from original 500,000 to match 'initronja's' default  
  83.   i = 1;
  84.   while (argc > 1)
  85.   {
  86.     if (strcmp(argv[i], "-t") == 0){
  87.       tNoOfThreads = atoi(argv[i+1]);
  88.       if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)) goto error_input;
  89.     }else if (strcmp(argv[i], "-o") == 0){
  90.       tNoOfOperations = atoi(argv[i+1]);
  91.       if (tNoOfOperations < 1) goto error_input;
  92.     }else if (strcmp(argv[i], "-r") == 0){
  93.       tNoOfRecords = atoi(argv[i+1]);
  94.       if ((tNoOfRecords < 1) || (tNoOfRecords > 1000000000)) goto error_input;
  95. }else if (strcmp(argv[i], "-p") == 0){
  96. nTest = atoi(argv[i+1]) ;
  97. if (0 > nTest || 18 < nTest) goto error_input ;
  98.     }else if (strcmp(argv[i], "-c") == 0){
  99.       tNoOfOpsPerExecute = atoi(argv[i+1]);
  100.       if ((tNoOfOpsPerExecute < 1) || (tNoOfOpsPerExecute > 1024)) goto error_input;
  101.     }else{
  102.       goto error_input;
  103.     }
  104.     argc -= 2;
  105.     i = i + 2;
  106.   }
  108.   ndbout << "Initialisation started. " << endl;
  109.   pMyNdb = new Ndb("TEST_DB") ;
  110.   pMyNdb->init();
  111.   ndbout << "Initialisation completed. " << endl;
  113.   ndbout << endl << "Execute Ronja Benchmark" << endl;
  114.   ndbout << "  NdbAPI node with id = " << pMyNdb->getNodeId() << endl;
  115.   ndbout << "  " << tNoOfThreads << " thread(s) " << endl;
  116.   ndbout << "  " << tNoOfOperations << " transaction(s) per thread and round " << endl;
  118.   if (pMyNdb->waitUntilReady(120) != 0) {
  119.     ndbout << "Benchmark failed - NDB is not ready" << endl;
  120. delete pMyNdb ;
  121.     return NDBT_ProgramExit(NDBT_FAILED);
  122.   }//if
  124.   NdbThread_SetConcurrencyLevel(2 + tNoOfThreads);
  126.   for (i = 0; i < tNoOfThreads ; i++) {
  127.     ThreadReady[i] = 0;
  128.     ThreadStart[i] = 0;
  129.   }//for
  131.   for (i = 0; i < tNoOfThreads ; i++) {
  132.     tabThread[i].ThreadNo = i;
  133.     tabThread[i].NdbRef = NULL;
  134.     tabThread[i].NoOfOps = tNoOfOperations;
  135.     threadLife[i] = NdbThread_Create(ThreadExec,
  136.                                        (void**)&tabThread[i],
  137.                                        32768,
  138.                                        "RonjaThread",
  139.                                        NDB_THREAD_PRIO_LOW);
  140.   }//for
  141.   
  142.   cont = 1;
  143.   while (cont) {
  144. NdbSleep_MilliSleep(10);
  145.     cont = 0;
  146.     for (i = 0; i < tNoOfThreads ; i++)
  147.       if (!ThreadReady[i]) cont = 1;
  148.   }//while
  150.   ndbout << "All threads started" << endl;
  151.   
  152.   if(!nTest){
  154.   for (;;){
  156.   inp[0] = 0;
  157.   ndbout << endl << "What to do next:" << endl;
  158.   ndbout << "1 t=> Perform lookups in short table" << endl;
  159.   ndbout << "2 t=> Perform lookups in long table" << endl;
  160.   ndbout << "3 t=> Perform updates in short table" << endl;
  161.   ndbout << "4 t=> Perform updates in long table" << endl;
  162.   ndbout << "5 t=> Perform 50% lookups/50% updates in short table" << endl;
  163.   ndbout << "6 t=> Perform 50% lookups/50% updates in long table" << endl;
  164.   ndbout << "7 t=> Perform 80% lookups/20% updates in short table" << endl;
  165.   ndbout << "8 t=> Perform 80% lookups/20% updates in long table" << endl;
  166.   ndbout << "9 t=> Perform 25% lookups short/25% lookups long/25% updates short/25% updates long" << endl;
  167.   ndbout << "10t=> Test bug with replicated interpreted updates, short table" << endl;
  168.   ndbout << "11t=> Test interpreter functions, short table" << endl;
  169.   ndbout << "12t=> Test bug with replicated interpreted updates, long table" << endl;
  170.   ndbout << "13t=> Test interpreter functions, long table" << endl;
  171.   ndbout << "14t=> Perform lookups in short table, no guess of TC" << endl;
  172.   ndbout << "15t=> Perform lookups in long table, no guess of TC" << endl;
  173.   ndbout << "16t=> Perform updates in short table, no guess of TC" << endl;
  174.   ndbout << "17t=> Perform updates in long table, no guess of TC" << endl;
  175.   ndbout << "18t=> Multi record updates of transactions" << endl;
  176.   ndbout << "All other responses will exit" << endl;
  177.   ndbout << "_____________________________" << endl << endl ;
  178.   
  179.   int inp_i = 0;
  180.   do {
  181.     inp[inp_i] = (char) fgetc(stdin);     
  182.     if (inp[inp_i] == 'n' || inp[inp_i] == EOF) {
  183.       inp[inp_i] ='';
  184.       break;
  185.     }
  186.     inp_i++;
  188.   } while (inp[inp_i - 1] != 'n' && inp[inp_i - 1] != EOF);
  189.   
  190.   tmp = atoi(inp);
  191.   
  192.   if ((tmp > 18) || (tmp <= 0)) break;
  193.   
  194.   ndbout << "Starting test " << tmp << "..." << endl;
  196.   for (i = 0; i < tNoOfThreads ; i++){ ThreadStart[i] = tmp; }
  197.   
  198.   cont = 1;
  199.   while (cont) {
  200.   NdbSleep_MilliSleep(10);
  201.   cont = 0;
  202.   for (i = 0; i < tNoOfThreads ; i++){
  203.   if (!ThreadReady[i]) cont = 1;
  204.   }
  205.   }//while
  206.   }//for(;;)
  208.   }else{
  210.   if(19 == nTest){
  211.   ndbout << "Executing all 18 available tests..." << endl << endl;
  212.   for (int count = 1; count < nTest; count++){
  213.   ndbout << "Test " << count << endl ;
  214.   ndbout << "------" << endl << endl ;
  215.   for (i = 0; i < tNoOfThreads ; i++) { ThreadStart[i] = count ; }
  216.   cont = 1;
  217.   while (cont) {
  218.   NdbSleep_MilliSleep(10);
  219.   cont = 0;
  220.   for (i = 0; i < tNoOfThreads ; i++){
  221.   if (!ThreadReady[i]) cont = 1;
  222.   }
  223.   }
  224.   }//for
  225.   }else{
  226.   ndbout << endl << "Executing test " << nTest << endl << endl;
  227.   for (i = 0; i < tNoOfThreads ; i++) { ThreadStart[i] = nTest ; }
  228.   cont = 1;
  229.   while (cont) {
  230.   NdbSleep_MilliSleep(10);
  231.   cont = 0;
  232.   for (i = 0; i < tNoOfThreads ; i++){
  233.   if (!ThreadReady[i]) cont = 1;
  234.   }
  235.   }
  236.   }//if(18 == nTest)
  237.   } //if(!nTest)
  239.   ndbout << "--------------------------------------------------" << endl;
  241.   for (i = 0; i < tNoOfThreads ; i++) ThreadReady[i] = 0;
  242.   // Signaling threads to stop 
  243.   for (i = 0; i < tNoOfThreads ; i++) ThreadStart[i] = 999;
  245.     // Wait for threads to stop
  246.   cont = 1;
  247.   do {
  248.      NdbSleep_MilliSleep(1);
  249.  cont = 0;
  250.  for (i = 0; i < tNoOfThreads ; i++){
  251.       if (ThreadReady[i] == 0) cont = 1;
  252.  }
  253.   } while (cont == 1);
  255.   delete pMyNdb ;
  256.   ndbout << endl << "Ronja Benchmark completed" << endl;
  257.   return NDBT_ProgramExit(NDBT_OK) ;
  259. error_input:
  260.   ndbout << endl << "  Ivalid parameter(s)" << endl;
  261.   ndbout <<         "  Usage: benchronja [-t threads][-r rec] [-o ops] [-c ops_per_exec] [-p test], where:" << endl;
  262.   ndbout << "  threads - the number of threads to start; default: 1" << endl;
  263.   ndbout << "  rec - the number of records in the tables; default: 500" << endl;
  264.   ndbout << "  ops - the number of operations per transaction; default: 100000" << endl;
  265.   ndbout << "  ops_per_exec - the number of operations per execution; default: 1" << endl ;
  266.   ndbout << "  test - the number of test to execute; 19 executes all available tests; default: 0"<< endl ;
  267.   ndbout << "  which enters a loop expecting manual input of test number to execute." << endl << endl ;
  268.   delete pMyNdb ;
  269.   return NDBT_ProgramExit(NDBT_WRONGARGS) ;
  271.   }
  272. ////////////////////////////////////////
  274. void commitTrans(Ndb* aNdb, NdbConnection* aCon)
  275. {
  276.   int ret = aCon->execute(Commit);
  277.   assert (ret != -1);
  278.   aNdb->closeTransaction(aCon);
  279. }
  281. void rollbackTrans(Ndb* aNdb, NdbConnection* aCon)
  282. {
  283.   int ret = aCon->execute(Rollback);
  284.   assert (ret != -1);
  285.   aNdb->closeTransaction(aCon);
  286. }
  288. void updateNoCommit(NdbConnection* aCon, Uint32* flip, unsigned int key)
  289. {
  290.   NdbOperation* theOperation;
  292.   *flip = *flip + 1;
  293.   theOperation = aCon->getNdbOperation("SHORT_REC");
  294.   theOperation->updateTuple();
  295.   theOperation->equal((Uint32)0, key);
  296.   theOperation->setValue((Uint32)1, (char*)flip);
  297.   int ret = aCon->execute(NoCommit);
  298.   assert (ret != -1);
  299. }
  301. void updateNoCommitFail(NdbConnection* aCon, unsigned int key)
  302. {
  303.   NdbOperation* theOperation;
  305.   Uint32 flip = 0;
  306.   theOperation = aCon->getNdbOperation("SHORT_REC");
  307.   theOperation->updateTuple();
  308.   theOperation->equal((Uint32)0, key);
  309.   theOperation->setValue((Uint32)1, (char*)flip);
  310.   int ret = aCon->execute(NoCommit);
  311.   assert (ret == -1);
  312. }
  314. void deleteNoCommit(NdbConnection* aCon, Uint32* flip, unsigned int key)
  315. {
  316.   NdbOperation* theOperation;
  318.   *flip = 0;
  319.   theOperation = aCon->getNdbOperation("SHORT_REC");
  320.   theOperation->deleteTuple();
  321.   theOperation->equal((Uint32)0, key);
  322.   int ret = aCon->execute(NoCommit);
  323.   assert (ret != -1);
  324. }
  326. void insertNoCommit(NdbConnection* aCon, Uint32* flip, unsigned int key)
  327. {
  328.   NdbOperation* theOperation;
  329.   Uint32 placeholder[100];
  331.   *flip = *flip + 1;
  332.   theOperation = aCon->getNdbOperation("SHORT_REC");
  333.   theOperation->insertTuple();
  334.   theOperation->equal((Uint32)0, key);
  335.   theOperation->setValue((Uint32)1, (char*)flip);
  336.   theOperation->setValue((Uint32)2, (char*)&placeholder[0]);
  337.   theOperation->setValue((Uint32)3, (char*)&placeholder[0]);
  338.   int ret = aCon->execute(NoCommit);
  339.   assert (ret != -1);
  340. }
  342. void writeNoCommit(NdbConnection* aCon, Uint32* flip, unsigned int key)
  343. {
  344.   NdbOperation* theOperation;
  345.   Uint32 placeholder[100];
  347.   *flip = *flip + 1;
  348.   theOperation = aCon->getNdbOperation("SHORT_REC");
  349.   theOperation->writeTuple();
  350.   theOperation->equal((Uint32)0, key);
  351.   theOperation->setValue((Uint32)1, (char*)flip);
  352.   theOperation->setValue((Uint32)2, (char*)&placeholder[0]);
  353.   theOperation->setValue((Uint32)3, (char*)&placeholder[0]);
  354.   int ret = aCon->execute(NoCommit);
  355.   assert (ret != -1);
  356. }
  358. void readNoCommit(NdbConnection* aCon, Uint32* flip, Uint32 key, int expected_ret)
  359. {
  360.   NdbOperation* theOperation;
  361.   Uint32 readFlip;
  363.   theOperation = aCon->getNdbOperation("SHORT_REC");
  364.   theOperation->readTuple();
  365.   theOperation->equal((Uint32)0, key);
  366.   theOperation->getValue((Uint32)1, (char*)&readFlip);
  367.   int ret = aCon->execute(NoCommit);
  368.   assert (ret == expected_ret);
  369.   if (ret == 0) 
  370.     assert (*flip == readFlip);
  371. }
  373. void readDirtyNoCommit(NdbConnection* aCon, Uint32* flip, Uint32 key, int expected_ret)
  374. {
  375.   NdbOperation* theOperation;
  376.   Uint32 readFlip;
  378.   theOperation = aCon->getNdbOperation("SHORT_REC");
  379.   theOperation->committedRead();
  380.   theOperation->equal((Uint32)0, key);
  381.   theOperation->getValue((Uint32)1, (char*)&readFlip);
  382.   int ret = aCon->execute(NoCommit);
  383.   assert (ret == expected_ret);
  384.   if (ret == 0) 
  385.     assert (*flip == readFlip);
  386. }
  388. void readVerify(Ndb* aNdb, Uint32* flip, Uint32 key, int expected_ret)
  389. {
  390.   NdbConnection* theTransaction;
  391.   theTransaction = aNdb->startTransaction();
  392.   readNoCommit(theTransaction, flip, key, expected_ret);
  393.   commitTrans(aNdb, theTransaction);
  394. }
  396. void readDirty(Ndb* aNdb, Uint32* flip, Uint32 key, int expected_ret)
  397. {
  398.   NdbOperation* theOperation;
  399.   NdbConnection* theTransaction;
  400.   Uint32 readFlip;
  402.   theTransaction = aNdb->startTransaction();
  403.   theOperation = theTransaction->getNdbOperation("SHORT_REC");
  404.   theOperation->committedRead();
  405.   theOperation->equal((Uint32)0, key);
  406.   theOperation->getValue((Uint32)1, (char*)&readFlip);
  407.   int ret = theTransaction->execute(Commit);
  408.   assert (ret == expected_ret);
  409.   if (ret == 0) 
  410.     assert (*flip == readFlip);
  411.   aNdb->closeTransaction(theTransaction);
  412. }
  414. int multiRecordTest(Ndb* aNdb, unsigned int key)
  415. {
  416.   NdbConnection* theTransaction;
  417.   Uint32 flip = 0;
  418.   Uint32 save_flip;
  419.   ndbout << "0" << endl;
  421.   theTransaction = aNdb->startTransaction();
  423.   updateNoCommit(theTransaction, &flip, key);
  425.   readNoCommit(theTransaction, &flip, key, 0);
  427.   updateNoCommit(theTransaction, &flip, key);
  429.   readNoCommit(theTransaction, &flip, key, 0);
  431.   commitTrans(aNdb, theTransaction);
  433.   ndbout << "1 " << endl;
  435.   readVerify(aNdb, &flip, key, 0);
  436.   readDirty(aNdb, &flip, key, 0);
  437.   save_flip = flip;
  438.   ndbout << "1.1 " << endl;
  440.   theTransaction = aNdb->startTransaction();
  442.   deleteNoCommit(theTransaction, &flip, key);
  444.   readNoCommit(theTransaction, &flip, key, -1);
  445.   readDirty(aNdb, &save_flip, key, 0);           // COMMITTED READ!!!
  446.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  447.   ndbout << "1.2 " << endl;
  449.   insertNoCommit(theTransaction, &flip, key);
  451.   readNoCommit(theTransaction, &flip, key, 0);
  452.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  453.   readDirty(aNdb, &save_flip, key, 0);           // COMMITTED READ!!!
  454.   ndbout << "1.3 " << endl;
  456.   updateNoCommit(theTransaction, &flip, key);
  458.   readNoCommit(theTransaction, &flip, key, 0);
  459.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  460.   readDirty(aNdb, &save_flip, key, 0);           // COMMITTED READ!!!
  461.   ndbout << "1.4 " << endl;
  463.   commitTrans(aNdb, theTransaction);
  465.   ndbout << "2 " << endl;
  467.   readDirty(aNdb, &flip, key, 0);           // COMMITTED READ!!!
  468.   readVerify(aNdb, &flip, key, 0);
  470.   save_flip = flip;
  471.   theTransaction = aNdb->startTransaction();
  473.   deleteNoCommit(theTransaction, &flip, key);
  475.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  476.   readDirtyNoCommit(theTransaction, &flip, key, -1);       // COMMITTED READ!!!
  477.   readNoCommit(theTransaction, &flip, key, -1);
  479.   insertNoCommit(theTransaction, &flip, key);
  481.   readNoCommit(theTransaction, &flip, key, 0);
  483.   updateNoCommit(theTransaction, &flip, key);
  485.   readNoCommit(theTransaction, &flip, key, 0);
  486.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  487.   readDirtyNoCommit(theTransaction, &flip, key, 0);        // COMMITTED READ!!!
  489.   deleteNoCommit(theTransaction, &flip, key);
  491.   readNoCommit(theTransaction, &flip, key, -1);
  492.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  493.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  495.   rollbackTrans(aNdb, theTransaction);
  497.   ndbout << "3 " << endl;
  499.   flip = save_flip;
  500.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  501.   readVerify(aNdb, &flip, key, 0);
  503.   theTransaction = aNdb->startTransaction();
  505.   updateNoCommit(theTransaction, &flip, key);
  507.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  508.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  509.   readNoCommit(theTransaction, &flip, key, 0);
  511.   deleteNoCommit(theTransaction, &flip, key);
  513.   readNoCommit(theTransaction, &flip, key, -1);
  514.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  515.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  517.   insertNoCommit(theTransaction, &flip, key);
  519.   readNoCommit(theTransaction, &flip, key, 0);
  520.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  521.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  523.   updateNoCommit(theTransaction, &flip, key);
  525.   readNoCommit(theTransaction, &flip, key, 0);
  526.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  527.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  529.   deleteNoCommit(theTransaction, &flip, key);
  531.   readDirty(aNdb, &save_flip, key, 0);                     // COMMITTED READ!!!
  532.   readNoCommit(theTransaction, &flip, key, -1);
  533.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  535.   commitTrans(aNdb, theTransaction);
  537.   ndbout << "4 " << endl;
  539.   readVerify(aNdb, &flip, key, -1);
  541.   theTransaction = aNdb->startTransaction();
  543.   insertNoCommit(theTransaction, &flip, key);
  545.   readDirty(aNdb, &save_flip, key, -1);                     // COMMITTED READ!!!
  546.   readNoCommit(theTransaction, &flip, key, 0);
  547.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  549.   deleteNoCommit(theTransaction, &flip, key);
  551.   readDirty(aNdb, &save_flip, key, -1);                     // COMMITTED READ!!!
  552.   readNoCommit(theTransaction, &flip, key, -1);
  553.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  555.   insertNoCommit(theTransaction, &flip, key);
  557.   readDirty(aNdb, &save_flip, key, -1);                     // COMMITTED READ!!!
  558.   readNoCommit(theTransaction, &flip, key, 0);
  559.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  561.   updateNoCommit(theTransaction, &flip, key);
  563.   readDirty(aNdb, &save_flip, key, -1);                     // COMMITTED READ!!!
  564.   readNoCommit(theTransaction, &flip, key, 0);
  565.   readDirtyNoCommit(theTransaction, &flip, key, 0);
  567.   deleteNoCommit(theTransaction, &flip, key);
  569.   readDirty(aNdb, &save_flip, key, -1);                     // COMMITTED READ!!!
  570.   readNoCommit(theTransaction, &flip, key, -1);
  571.   readDirtyNoCommit(theTransaction, &flip, key, -1);
  573.   commitTrans(aNdb, theTransaction);
  575.   ndbout << "5 " << endl;
  577.   readDirty(aNdb, &flip, key, -1);                         // COMMITTED READ!!!
  578.   readVerify(aNdb, &flip, key, -1);
  580.   theTransaction = aNdb->startTransaction();
  582.   insertNoCommit(theTransaction, &flip, key);
  584.   readDirty(aNdb, &flip, key, -1);                         // COMMITTED READ!!!
  585.   readDirtyNoCommit(theTransaction, &flip, key, 0);        // COMMITTED READ!!!
  587.   commitTrans(aNdb, theTransaction);
  588.   readDirty(aNdb, &flip, key, 0);                          // COMMITTED READ!!!
  590.   ndbout << "6 " << endl;
  592.   theTransaction = aNdb->startTransaction();
  594.   deleteNoCommit(theTransaction, &flip, key);
  595.   updateNoCommitFail(theTransaction, key);
  596.   rollbackTrans(aNdb, theTransaction);
  597.   return 0;
  598. }
  600. int lookup(Ndb* aNdb, unsigned int key, unsigned int long_short, int guess){
  602.   int placeholder[500];
  603.   unsigned int flip, count;
  604.   int ret_value, i;
  605.   NdbConnection* theTransaction;
  606.   NdbOperation* theOperation;
  607.   if ( !aNdb ) return -1 ;
  609.   if (guess != 0)
  610.     theTransaction = aNdb->startTransaction((Uint32)0, (const char*)&key, (Uint32)4);
  611.   else
  612.     theTransaction = aNdb->startTransaction();
  614.   for (i = 0; i < tNoOfOpsPerExecute; i++) {
  615.     if (long_short == 0)
  616.       theOperation = theTransaction->getNdbOperation("SHORT_REC");
  617.     else
  618.       theOperation = theTransaction->getNdbOperation("LONG_REC");
  619.     if (theOperation == NULL) {
  620.       ndbout << "Table missing" << endl;
  621.   aNdb->closeTransaction(theTransaction) ;
  622.   return -1;
  623.     }//if
  624.     theOperation->simpleRead();
  625.     theOperation->equal((Uint32)0, key);
  626.     theOperation->getValue((Uint32)1, (char*)&flip);
  627.     theOperation->getValue((Uint32)2, (char*)&count);
  628.     if (theOperation->getValue((Uint32)3, (char*)&placeholder[0]) == NULL) {
  629.       ndbout << "Error in definition phase = " << theTransaction->getNdbError() << endl;  
  630.       aNdb->closeTransaction(theTransaction);
  631.       return -1;
  632.     }//if
  633.   }//for
  634.   ret_value = theTransaction->execute(Commit);
  635.   if (ret_value == -1)
  636.     ndbout << "Error in lookup:" << theTransaction->getNdbError() << endl;
  637.     aNdb->closeTransaction(theTransaction);
  638. return ret_value;
  639. }//lookup()
  641. int update(Ndb* aNdb, unsigned int key, unsigned int long_short, int guess)
  642. {
  643.   int placeholder[500];
  644.   int ret_value, i;
  645.   unsigned int flip, count;
  646.   NdbConnection* theTransaction;
  647.   NdbOperation* theOperation;
  649.   if ( !aNdb ) return -1 ;
  651.   if (guess != 0)
  652.     theTransaction = aNdb->startTransaction((Uint32)0, (const char*)&key, (Uint32)4);
  653.   else
  654.     theTransaction = aNdb->startTransaction();
  656.   for (i = 0; i < tNoOfOpsPerExecute; i++) {
  657.     if (long_short == 0)
  658.       theOperation = theTransaction->getNdbOperation("SHORT_REC"); // Use table SHORT_REC
  659.     else
  660.       theOperation = theTransaction->getNdbOperation("LONG_REC"); // Use table LONG_REC
  661.     if (theOperation == NULL) {
  662.       ndbout << "Table missing" << endl;
  663.   aNdb->closeTransaction(theTransaction) ;
  664.   delete aNdb ;
  665.       return -1;
  666.     }//if
  667.     theOperation->interpretedUpdateTuple();                       // Send interpreted program to NDB kernel
  668.     theOperation->equal((Uint32)0, key);                          // Search key
  669.     theOperation->getValue((Uint32)1, (char*)&flip);              // Read value of flip
  670.     theOperation->getValue((Uint32)2, (char*)&count);             // Read value of count
  671.     theOperation->getValue((Uint32)3, (char*)&placeholder[0]);    // Read value of placeholder
  672.     theOperation->load_const_u32((Uint32)1, (Uint32)0);           // Load register 1 with 0
  673.     theOperation->read_attr((Uint32)1, (Uint32)2);                // Read Flip value into register 2
  674.     theOperation->branch_eq((Uint32)1, (Uint32)2, (Uint32)0);     // If Flip (register 2) == 0 (register 1) goto label 0
  675.     theOperation->branch_label((Uint32)1);                        // Goto label 1
  676.     theOperation->def_label((Uint32)0);                           // Define label 0
  677.     theOperation->load_const_u32((Uint32)1, (Uint32)1);           // Load register 1 with 1
  678.     theOperation->def_label((Uint32)1);                           // Define label 0
  679.     theOperation->write_attr((Uint32)1, (Uint32)1);               // Write 1 (register 1) into Flip
  680.     ret_value = theOperation->incValue((Uint32)2, (Uint32)1);     // Increment Count by 1
  681.     if (ret_value == -1) {
  682.       ndbout << "Error in definition phase " << endl;  
  683.       aNdb->closeTransaction(theTransaction);
  684.       return ret_value;
  685.     }//if
  686.   }//for
  687.   ret_value = theTransaction->execute(Commit);                  // Perform the actual read and update
  688.   if (ret_value == -1) {
  689.     ndbout << "Error in update:" << theTransaction->getNdbError() << endl;
  690.     aNdb->closeTransaction(theTransaction); // < epaulsa
  691. return ret_value ;
  692.   }//if
  693.   aNdb->closeTransaction(theTransaction);
  694.   return ret_value;
  695. }//update()
  697. int update_bug(Ndb* aNdb, unsigned int key, unsigned int long_short)
  698. {
  699.   int placeholder[500];
  700.   int ret_value, i;
  701.   unsigned int flip, count;
  702.   NdbConnection* theTransaction;
  703.   NdbOperation* theOperation;
  705.   if ( !aNdb ) return -1 ;
  707.   theTransaction = aNdb->startTransaction();
  708.   for (i = 0; i < tNoOfOpsPerExecute; i++) {
  709.     if (long_short == 0)
  710.       theOperation = theTransaction->getNdbOperation("SHORT_REC"); // Use table SHORT_REC
  711.     else
  712.       theOperation = theTransaction->getNdbOperation("LONG_REC"); // Use table LONG_REC
  713.     if (theOperation == NULL) {
  714.       ndbout << "Table missing" << endl;
  715.      aNdb->closeTransaction(theTransaction) ;
  716.       return -1;
  717.     }//if
  718.     theOperation->interpretedUpdateTuple();                       // Send interpreted program to NDB kernel
  719.     theOperation->equal((Uint32)0, key);                          // Search key
  720.     theOperation->getValue((Uint32)1, (char*)&flip);              // Read value of flip
  721.     theOperation->getValue((Uint32)2, (char*)&count);             // Read value of count
  722.     theOperation->getValue((Uint32)3, (char*)&placeholder[0]);    // Read value of placeholder
  723.     theOperation->load_const_u32((Uint32)1, (Uint32)0);           // Load register 1 with 0
  724.     theOperation->read_attr((Uint32)1, (Uint32)2);                // Read Flip value into register 2
  725.     theOperation->branch_eq((Uint32)1, (Uint32)2, (Uint32)0);     // If Flip (register 2) == 0 (register 1) goto label 0
  726.     theOperation->branch_label((Uint32)1);                        // Goto label 1
  727.     theOperation->def_label((Uint32)0);                           // Define label 0
  728.     theOperation->load_const_u32((Uint32)1, (Uint32)1);           // Load register 1 with 1
  729.     theOperation->def_label((Uint32)1);                           // Define label 0
  730.     theOperation->write_attr((Uint32)1, (Uint32)1);               // Write 1 (register 1) into Flip
  731.     ret_value = theOperation->incValue((Uint32)2, (Uint32)1);     // Increment Count by 1
  732.     if (ret_value == -1) {
  733.       ndbout << "Error in definition phase " << endl;  
  734.       aNdb->closeTransaction(theTransaction);
  735.       return ret_value;
  736.     }//if
  737.   }//for
  738.   ret_value = theTransaction->execute(NoCommit);                  // Perform the actual read and update
  739.   if (ret_value == -1) {
  740.     ndbout << "Error in update:" << theTransaction->getNdbError() << endl;
  741.     aNdb->closeTransaction(theTransaction);
  742. return ret_value ;
  743.   }//if
  744.   aNdb->closeTransaction(theTransaction);
  745.   return ret_value;
  746. }//update_bug()
  748. int update_interpreter_test(Ndb* aNdb, unsigned int key, unsigned int long_short)
  749. {
  750.   int placeholder[500];
  751.   int ret_value, i;
  752.   unsigned int flip, count;
  753.   NdbConnection* theTransaction;
  754.   NdbOperation* theOperation;
  755.   Uint32 Tlabel = 0;
  757.   if ( !aNdb ) return -1 ; 
  759. //------------------------------------------------------------------------------
  760. // Start the transaction and get a unique transaction id
  761. //------------------------------------------------------------------------------
  762.   theTransaction = aNdb->startTransaction();
  763.   for (i = 0; i < tNoOfOpsPerExecute; i++) {
  764. //------------------------------------------------------------------------------
  765. // Get the proper table object and load schema information if not already
  766. // present.
  767. //------------------------------------------------------------------------------
  768.     if (long_short == 0)
  769.       theOperation = theTransaction->getNdbOperation("SHORT_REC"); // Use table SHORT_REC
  770.     else
  771.       theOperation = theTransaction->getNdbOperation("LONG_REC"); // Use table LONG_REC
  772.     if (theOperation == NULL) {
  773.       ndbout << "Table missing" << endl;
  774.      aNdb->closeTransaction(theTransaction) ;
  775.       return -1;
  776.     }//if
  777. //------------------------------------------------------------------------------
  778. // Define the operation type and the tuple key (primary key in this case).
  779. //------------------------------------------------------------------------------
  780.     theOperation->interpretedUpdateTuple();                       // Send interpreted program to NDB kernel
  781.     theOperation->equal((Uint32)0, key);                          // Search key
  783. //------------------------------------------------------------------------------
  784. // Perform initial read of attributes before updating them
  785. //------------------------------------------------------------------------------
  786.     theOperation->getValue((Uint32)1, (char*)&flip);              // Read value of flip
  787.     theOperation->getValue((Uint32)2, (char*)&count);             // Read value of count
  788.     theOperation->getValue((Uint32)3, (char*)&placeholder[0]);    // Read value of placeholder
  790. //------------------------------------------------------------------------------
  791. // Test that the various branch operations can handle things correctly.
  792. // Test first 2 + 3 = 5 with 32 bit registers
  793. // Next test the same with 32 bit + 64 bit = 64 
  794. //------------------------------------------------------------------------------
  795.     theOperation->load_const_u32((Uint32)4, (Uint32)0);           // Load register 4 with 0
  797.     theOperation->load_const_u32((Uint32)0, (Uint32)0);
  798.     theOperation->load_const_u32((Uint32)1, (Uint32)3);
  799.     theOperation->load_const_u32((Uint32)2, (Uint32)5);
  800.     theOperation->load_const_u32((Uint32)3, (Uint32)1);
  801.     theOperation->def_label(Tlabel++);
  802.     theOperation->def_label(Tlabel++);
  803.     theOperation->sub_reg((Uint32)2, (Uint32)3, (Uint32)2);
  804.     theOperation->branch_ne((Uint32)2, (Uint32)0, (Uint32)0);
  805.     theOperation->load_const_u32((Uint32)2, (Uint32)5);
  806.     theOperation->sub_reg((Uint32)1, (Uint32)3, (Uint32)1);
  807.     theOperation->branch_ne((Uint32)1, (Uint32)0, (Uint32)1);  
  809.     theOperation->load_const_u32((Uint32)1, (Uint32)2);           // Load register 1 with 2
  810.     theOperation->load_const_u32((Uint32)2, (Uint32)3);           // Load register 2 with 3
  811.     theOperation->add_reg((Uint32)1, (Uint32)2, (Uint32)1);       // 2+3 = 5 into reg 1
  812.     theOperation->load_const_u32((Uint32)2, (Uint32)5);           // Load register 2 with 5
  814.     theOperation->def_label(Tlabel++);
  816.     theOperation->branch_eq((Uint32)1, (Uint32)2, Tlabel);
  817.     theOperation->interpret_exit_nok((Uint32)6001);
  819.     theOperation->def_label(Tlabel++);
  820.     theOperation->branch_ne((Uint32)1, (Uint32)2, Tlabel);
  821.     theOperation->branch_label(Tlabel + 1);
  822.     theOperation->def_label(Tlabel++);
  823.     theOperation->interpret_exit_nok((Uint32)6002);
  825.     theOperation->def_label(Tlabel++);
  826.     theOperation->branch_lt((Uint32)1, (Uint32)2, Tlabel);
  827.     theOperation->branch_label(Tlabel + 1);
  828.     theOperation->def_label(Tlabel++);
  829.     theOperation->interpret_exit_nok((Uint32)6003);
  831.     theOperation->def_label(Tlabel++);
  832.     theOperation->branch_gt((Uint32)1, (Uint32)2, Tlabel);
  833.     theOperation->branch_label(Tlabel + 1);
  834.     theOperation->def_label(Tlabel++);
  835.     theOperation->interpret_exit_nok((Uint32)6005);
  837.     theOperation->def_label(Tlabel++);
  838.     theOperation->branch_eq_null((Uint32)1, Tlabel);
  839.     theOperation->branch_label(Tlabel + 1);
  840.     theOperation->def_label(Tlabel++);
  841.     theOperation->interpret_exit_nok((Uint32)6006);
  843.     theOperation->def_label(Tlabel++);
  844.     theOperation->branch_ne_null((Uint32)1,Tlabel);
  845.     theOperation->interpret_exit_nok((Uint32)6007);
  847.     theOperation->def_label(Tlabel++);
  848.     theOperation->branch_ge((Uint32)1, (Uint32)2, Tlabel);
  849.     theOperation->interpret_exit_nok((Uint32)6008);
  851.     theOperation->def_label(Tlabel++);
  852.     theOperation->branch_eq_null((Uint32)6,Tlabel);
  853.     theOperation->interpret_exit_nok((Uint32)6009);
  855.     theOperation->def_label(Tlabel++);
  856.     theOperation->branch_ne_null((Uint32)6, Tlabel);
  857.     theOperation->branch_label(Tlabel + 1);
  858.     theOperation->def_label(Tlabel++);
  859.     theOperation->interpret_exit_nok((Uint32)6010);
  861.     theOperation->def_label(Tlabel++);
  863.     theOperation->load_const_u32((Uint32)5, (Uint32)1);
  864.     theOperation->add_reg((Uint32)4, (Uint32)5, (Uint32)4);
  866.     theOperation->load_const_u32((Uint32)5, (Uint32)1);
  867.     theOperation->branch_eq((Uint32)4, (Uint32)5, Tlabel);
  870.     theOperation->load_const_u32((Uint32)5, (Uint32)2);
  871.     theOperation->branch_eq((Uint32)4, (Uint32)5, (Tlabel + 1));
  873.     theOperation->load_const_u32((Uint32)5, (Uint32)3);
  874.     theOperation->branch_eq((Uint32)4, (Uint32)5, (Tlabel + 2));
  876.     theOperation->load_const_u32((Uint32)5, (Uint32)4);
  877.     theOperation->branch_eq((Uint32)4, (Uint32)5, (Tlabel + 3));
  878.        
  879.     theOperation->branch_label(Tlabel + 4);
  881.     theOperation->def_label(Tlabel++);
  882.     theOperation->load_const_u32((Uint32)1, (Uint32)200000);
  883.     theOperation->load_const_u32((Uint32)2, (Uint32)300000);
  884.     theOperation->add_reg((Uint32)1, (Uint32)2, (Uint32)1);
  885.     theOperation->load_const_u32((Uint32)2, (Uint32)500000);
  886.     theOperation->branch_label((Uint32)2);
  888.     theOperation->def_label(Tlabel++);
  889.     theOperation->load_const_u32((Uint32)1, (Uint32)200000);
  890.     theOperation->load_const_u32((Uint32)2, (Uint32)300000);
  891.     theOperation->add_reg((Uint32)1, (Uint32)2, (Uint32)1);
  892.     theOperation->load_const_u32((Uint32)2, (Uint32)500000);
  893.     theOperation->branch_label((Uint32)2);
  895.     theOperation->def_label(Tlabel++);
  896.     theOperation->load_const_u32((Uint32)1, (Uint32)2);
  897.     Uint64 x = 0;
  898.     theOperation->load_const_u64((Uint32)2, (Uint64)(x - 1));
  899.     theOperation->add_reg((Uint32)1, (Uint32)2, (Uint32)1);
  900.     theOperation->load_const_u32((Uint32)2, (Uint32)1);
  901.     theOperation->branch_label((Uint32)2);
  903.     theOperation->def_label(Tlabel++);
  904.     theOperation->load_const_u32((Uint32)1, (Uint32)2);
  905.     theOperation->load_const_u64((Uint32)2, (Uint64)(x - 1));
  906.     theOperation->add_reg((Uint32)1, (Uint32)2, (Uint32)1);
  907.     theOperation->load_const_u64((Uint32)2, (Uint64)1);
  908.     theOperation->branch_label((Uint32)2);
  910.     theOperation->def_label(Tlabel++);
  911.     theOperation->read_attr((Uint32)1, (Uint32)2);
  912.     theOperation->branch_eq((Uint32)1, (Uint32)2, Tlabel);
  913.     theOperation->load_const_u32((Uint32)1, (Uint32)0);
  914.     theOperation->branch_label(Tlabel + 1);
  915.     theOperation->def_label(Tlabel++);
  916.     theOperation->load_const_u32((Uint32)1, (Uint32)1);
  917.     theOperation->def_label(Tlabel++);
  918.     theOperation->write_attr((Uint32)1, (Uint32)1);
  919.     ret_value = theOperation->incValue((Uint32)2, (Uint32)1);
  920.     if (ret_value == -1) {
  921.       ndbout << "Error in definition phase " << endl;
  922.       ndbout << "Error = " << theOperation->getNdbError() << " on line = " << theOperation->getNdbErrorLine() << endl;
  923.       aNdb->closeTransaction(theTransaction);
  924.       return ret_value;
  925.     }//if
  926.   }//for
  927. //------------------------------------------------------------------------------
  928. //------------------------------------------------------------------------------
  929.   ret_value = theTransaction->execute(Commit);                  // Perform the actual read and update
  930.   if (ret_value == -1) {
  931.     ndbout << "Error in update:" << theTransaction->getNdbError() << endl;
  932.     aNdb->closeTransaction(theTransaction); // < epaulsa
  933. return ret_value ;
  934.   }//if
  935. //------------------------------------------------------------------------------
  936. //------------------------------------------------------------------------------
  937.   aNdb->closeTransaction(theTransaction);
  938.   return ret_value;
  939. }//update_interpreter_test()
  941. void* ThreadExec(void* ThreadData){
  943.   ThreadNdb* tabThread = (ThreadNdb*)ThreadData;
  944.   Ndb*    pMyNdb = NULL ;
  945.   myRandom48Init(NdbTick_CurrentMillisecond());
  947.   int    Tsuccess = 0 ;
  948.   int          check = 0 ;
  949.   int          loop_count_ops = 0;
  950.   int    count, i, Ti;
  951.   int    tType =  0 ;
  952.   int          remType = 0 ;
  953.   unsigned int thread_no = 0 ;
  954.   unsigned long total_milliseconds;
  955.   unsigned int key = 0 ;
  956.   unsigned int prob = 0 ;
  957.   unsigned long transaction_time = 0 ;
  958.   unsigned long transaction_max_time = 0 ;
  959.   unsigned long min_time, max_time[MAX_TIMERS];
  960.   double    mean_time, mean_square_time, std_time; 
  961.   
  962.   thread_no = tabThread->ThreadNo;
  963.   pMyNdb = tabThread->NdbRef;
  964.   if (!pMyNdb) {
  965.     pMyNdb = new Ndb( "TEST_DB" );
  966.     pMyNdb->init();
  967.   }//if
  969.   for (;;){
  971.     min_time = 0xFFFFFFFF;
  972.     //for (Ti = 0; Ti < MAX_TIMERS ; Ti++) max_time[Ti] = 0;
  973. memset(&max_time, 0, sizeof max_time) ;
  974.     mean_time = 0;
  975.     mean_square_time = 0;
  976.     ThreadReady[thread_no] = 1;
  978.     while (!ThreadStart[thread_no]){
  979. NdbSleep_MilliSleep(1);
  980. }
  982.     // Check if signal to exit is received
  983.     if (ThreadStart[thread_no] == 999){
  984. delete pMyNdb;
  985. pMyNdb = NULL ;
  986. ThreadReady[thread_no] = 1;
  987. return 0 ;
  988.     }//if
  990.     tType = ThreadStart[thread_no];
  991.     remType = tType;
  992.     ThreadStart[thread_no] = 0;
  993. ThreadReady[thread_no] = 0 ;
  995.     // Start transaction, type of transaction
  996.     // is received in the array ThreadStart
  997.     loop_count_ops = tNoOfOperations;
  999.     START_TIMER_TOP
  1000.     for (count=0 ; count < loop_count_ops ; count++) {
  1001.       
  1002. Tsuccess = 0;
  1003. //----------------------------------------------------
  1004. // Generate a random key between 0 and tNoOfRecords - 1
  1005. //----------------------------------------------------
  1006.       key = myRandom48(tNoOfRecords); 
  1007. //----------------------------------------------------
  1008. // Start time measurement of transaction.
  1009. //----------------------------------------------------
  1010.       START_TIMER
  1011.       //do {
  1012.         switch (remType){
  1013.           case 1:
  1014. //----------------------------------------------------
  1015. // Only lookups in short record table
  1016. //----------------------------------------------------
  1017.             Tsuccess = lookup(pMyNdb, key, 0, 1);
  1018.             break;
  1020.           case 2:
  1021. //----------------------------------------------------
  1022. // Only lookups in long record table
  1023. //----------------------------------------------------
  1024.             Tsuccess = lookup(pMyNdb, key, 1, 1);
  1025.             break;
  1026.           case 3:
  1027. //----------------------------------------------------
  1028. // Only updates in short record table
  1029. //----------------------------------------------------
  1030.             Tsuccess = update(pMyNdb, key, 0, 1);
  1031.             break;
  1032.           case 4:
  1033. //----------------------------------------------------
  1034. // Only updates in long record table
  1035. //----------------------------------------------------
  1036.             Tsuccess = update(pMyNdb, key, 1, 1);
  1037.             break;
  1038.           case 5:
  1039. //----------------------------------------------------
  1040. // 50% read/50 % update in short record table
  1041. //----------------------------------------------------
  1042.             prob = myRandom48(100);
  1043.             if (prob < 50)
  1044.               Tsuccess = update(pMyNdb, key, 0, 1);
  1045.             else
  1046.               Tsuccess = lookup(pMyNdb, key, 0, 1);
  1047.             break;
  1048.           case 6:
  1049. //----------------------------------------------------
  1050. // 50% read/50 % update in long record table
  1051. //----------------------------------------------------
  1052.             prob = myRandom48(100);
  1053.             if (prob < 50)
  1054.               Tsuccess = update(pMyNdb, key, 1, 1);
  1055.             else
  1056.               Tsuccess = lookup(pMyNdb, key, 1, 1);
  1057.             break;
  1058.           case 7:
  1059. //----------------------------------------------------
  1060. // 80 read/20 % update in short record table
  1061. //----------------------------------------------------
  1062.             prob = myRandom48(100);
  1063.             if (prob < 20)
  1064.               Tsuccess = update(pMyNdb, key, 0, 1);
  1065.             else
  1066.               Tsuccess = lookup(pMyNdb, key, 0, 1);
  1067.             break;
  1068.           case 8:
  1069. //----------------------------------------------------
  1070. // 80 read/20 % update in long record table
  1071. //----------------------------------------------------
  1072.             prob = myRandom48(100);
  1073.             if (prob < 20)
  1074.               Tsuccess = update(pMyNdb, key, 1, 1);
  1075.             else
  1076.               Tsuccess = lookup(pMyNdb, key, 1, 1);
  1077.             break;
  1078.           case 9:
  1079. //----------------------------------------------------
  1080. // 25 read short/25 % read long/25 % update short/25 % update long
  1081. //----------------------------------------------------
  1082.             prob = myRandom48(100);
  1083.             if (prob < 25)
  1084.               Tsuccess = update(pMyNdb, key, 0, 1);
  1085.             else if (prob < 50)
  1086.               Tsuccess = update(pMyNdb, key, 1, 1);
  1087.             else if (prob < 75)
  1088.               Tsuccess = lookup(pMyNdb, key, 0, 1);
  1089.             else
  1090.               Tsuccess = lookup(pMyNdb, key, 1, 1);
  1091.             break;
  1092.           case 10:
  1093. //----------------------------------------------------
  1094. // Test bug with replicated interpreted update, short table
  1095. //----------------------------------------------------
  1096.             Tsuccess = update_bug(pMyNdb, key, 0);
  1097.             break;
  1098.           case 11:
  1099. //----------------------------------------------------
  1100. // Test interpreter functions, short table
  1101. //----------------------------------------------------
  1102.             Tsuccess = update_interpreter_test(pMyNdb, key, 0);
  1103.             break;
  1104.           case 12:
  1105. //----------------------------------------------------
  1106. // Test bug with replicated interpreted update, long table
  1107. //----------------------------------------------------
  1108.             Tsuccess = update_bug(pMyNdb, key, 1);
  1109.             break;
  1110.           case 13:
  1111. //----------------------------------------------------
  1112. // Test interpreter functions, long table
  1113. //----------------------------------------------------
  1114.             Tsuccess = update_interpreter_test(pMyNdb, key, 1);
  1115.             break;
  1116.           case 14:
  1117. //----------------------------------------------------
  1118. // Only lookups in short record table
  1119. //----------------------------------------------------
  1120.             Tsuccess = lookup(pMyNdb, key, 0, 0);
  1121.             break;
  1122.           case 15:
  1123. //----------------------------------------------------
  1124. // Only lookups in long record table
  1125. //----------------------------------------------------
  1126.             Tsuccess = lookup(pMyNdb, key, 1, 0);
  1127.             break;
  1128.           case 16:
  1129. //----------------------------------------------------
  1130. // Only updates in short record table
  1131. //----------------------------------------------------
  1132.             Tsuccess = update(pMyNdb, key, 0, 0);
  1133.             break;
  1134.           case 17:
  1135. //----------------------------------------------------
  1136. // Only updates in long record table
  1137. //----------------------------------------------------
  1138.             Tsuccess = update(pMyNdb, key, 1, 0);
  1139.             break;
  1140.           case 18:
  1141.             Tsuccess = multiRecordTest(pMyNdb, key);
  1142.             break;
  1143.           default:
  1144.             break;
  1145.         }//switch
  1146.       //} while (0);//
  1147.   if(-1 == Tsuccess) {
  1148.   NDBT_ProgramExit(NDBT_FAILED);
  1149.   exit(-1);
  1150.   } // for
  1151. //----------------------------------------------------
  1152. // Stop time measurement of transaction.
  1153. //----------------------------------------------------     
  1154.   STOP_TIMER   
  1155.   transaction_time = (unsigned long)timer.elapsedTime() ;//stopTimer(&theStartTime);
  1156. //----------------------------------------------------
  1157. // Perform calculations of time measurements.
  1158. //----------------------------------------------------
  1159.       transaction_max_time = transaction_time;
  1160.       for (Ti = 0; Ti < MAX_TIMERS; Ti++) {
  1161.         if (transaction_max_time > max_time[Ti]) {
  1162.           Uint32 tmp = max_time[Ti];
  1163.           max_time[Ti] = transaction_max_time;
  1164.           transaction_max_time = tmp;
  1165.         }//if
  1166.       }//if
  1167.       if (transaction_time < min_time) min_time = transaction_time;
  1168.       mean_time = (double)transaction_time + mean_time;
  1169.       mean_square_time = (double)(transaction_time * transaction_time) + mean_square_time;
  1170.     }//for
  1171. //----------------------------------------------------
  1172. // Calculate mean and standard deviation
  1173. //----------------------------------------------------
  1174.     STOP_TIMER_TOP
  1175.     total_milliseconds = (unsigned long)timer_top.elapsedTime() ;//stopTimer(&total_time);
  1176.     mean_time = mean_time / loop_count_ops;
  1177.     mean_square_time = mean_square_time / loop_count_ops;
  1178.     std_time = sqrt(mean_square_time - (mean_time * mean_time));
  1179. //----------------------------------------------------
  1180. // Report statistics
  1181. //----------------------------------------------------
  1182. ndbout << "Thread = " << thread_no << " reporting:" << endl ;
  1183. ndbout << "------------------------------" << endl ;
  1184.     ndbout << "Total time is " << (unsigned int)(total_milliseconds /1000);
  1185.     ndbout << " seconds and " << (unsigned int)(total_milliseconds % 1000);
  1186.     ndbout << " milliseconds" << endl;
  1187.     ndbout << "Minimum time = " << (unsigned int)min_time << " milliseconds" << endl;
  1188.     for (Ti = 0; Ti < MAX_TIMERS; Ti++) {
  1189.       ndbout << "Maximum timer " << Ti << " = " << (unsigned int)max_time[Ti] << " milliseconds" << endl;
  1190.       ndbout << "Mean time = " << (unsigned int)mean_time << " milliseconds" << endl;
  1191.       ndbout << "Standard deviation on time = " << (unsigned int)std_time;
  1192.       ndbout << " milliseconds" << endl << endl ;
  1193.     }//for
  1194.     ndbout << endl ;
  1195.   
  1196.   } // for(;;)
  1197.   
  1198.   delete pMyNdb ;
  1199.   return 0 ;
  1200. }