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

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

MySQL数据库

开发平台：

Visual C++

flexTimedAsynch.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 */
  17. /* ***************************************************
  18.        FLEXTIMEDASYNCH
  19.        Perform benchmark of insert, update and delete transactions.
  21.        Arguments:
  22.         -t Number of threads to start, i.e., number of parallel loops, default 1
  23.         -p Number of transactions in a batch, default 32
  24.         -o Number of batches per loop, default 200
  25.         -i Time between batch starts, default 0
  26. -l Number of loops to run, default 1, 0=infinite
  27.         -a Number of attributes, default 25
  28.         -c Number of operations per transaction
  29. -s Size of each attribute in 32 bit word, default 1 (Primary Key is always of size 1,
  30.                                       independent of this value)
  31. -simple           Use simple read to read from database
  32.         -dirty            Use dirty read to read from database
  33. -write            Use writeTuple in insert and update
  34.         -n                Use standard table names
  35.         -no_table_create  Don't create tables in db
  36. -temp             Use temporary tables, no writing to disk.
  38.        Returns:
  39.         0 - Test passed
  40.        -1 - Test failed
  41.         1 - Invalid arguments
  43.  * *************************************************** */
  45. #include "NdbApi.hpp"
  47. #include <NdbThread.h>
  48. #include <NdbSleep.h>
  49. #include <NdbTick.h>
  50. #include <NdbOut.hpp>
  51. #include <NdbTimer.hpp>
  52. #include <string.h>
  53. #include <NdbMain.h>
  54. #include <NdbTest.hpp>
  56. #include <NDBT_Error.hpp>
  58. #define MAXSTRLEN 16 
  59. #define MAXATTR 64
  60. #define MAXTABLES 64
  61. #define MAXTHREADS 256
  62. #define MAXATTRSIZE 1000
  63. #define PKSIZE 1
  65. enum StartType { stIdle, 
  66.         stInsert,
  67. stRead,
  68. stUpdate,
  69. stDelete, 
  70.                 stStop } ;
  72. ErrorData * flexTimedAsynchErrorData;    
  74. struct ThreadNdb
  75. {
  76.   int NoOfOps;
  77.   int ThreadNo;  
  78.   unsigned int threadBase;
  79.   unsigned int transactionCompleted;
  80. };
  82. extern "C" void* threadLoop(void*);
  83. void setAttrNames(void);
  84. void setTableNames(void);
  85. void readArguments(int argc, const char** argv);
  86. void createAttributeSpace();
  87. void createTables(Ndb*);
  88. void defineOperation(NdbConnection* aTransObject, StartType aType, unsigned int key, int *);
  89. void execute(StartType aType);
  90. void executeThread(StartType aType, Ndb* aNdbObject, ThreadNdb* threadInfo);
  91. void executeCallback(int result, NdbConnection* NdbObject, void* aObject);
  93. /* epaulsa > *************************************************************/
  94. bool error_handler(const NdbError &) ; //replaces 'goto' things
  95. static int failed = 0 ; // lame global variable that keeps track of failed transactions
  96.                         // incremented in executeCallback() and reset in main()
  97. /************************************************************* < epaulsa */
  99. static NdbThread* threadLife[MAXTHREADS];
  100. static int tNodeId;
  101. static int ThreadReady[MAXTHREADS];
  102. static StartType ThreadStart[MAXTHREADS];
  103. static char tableName[MAXTABLES][MAXSTRLEN+1];
  104. static char attrName[MAXATTR][MAXSTRLEN+1];
  105. static int *getAttrValueTable;
  107. // Program Parameters
  108. static int tNoOfLoops = 1;
  109. static int tAttributeSize = 1;
  110. static unsigned int tNoOfThreads = 1;
  111. static unsigned int tNoOfTransInBatch = 32;
  112. static unsigned int tNoOfAttributes = 25;
  113. static unsigned int tNoOfBatchesInLoop = 200;
  114. static unsigned int tNoOfOpsPerTrans = 1;
  115. static unsigned int tTimeBetweenBatches = 0;
  117. //Program Flags
  118. static int theTestFlag = 0;
  119. static int theTempFlag = 1;
  120. static int theSimpleFlag = 0;
  121. static int theDirtyFlag = 0;
  122. static int theWriteFlag = 0;
  123. static int theStdTableNameFlag = 0;
  124. static int theTableCreateFlag = 0;
  126. #define START_REAL_TIME  NdbTimer timer; timer.doStart();
  127. #define STOP_REAL_TIME timer.doStop(); 
  129. #define START_TIMER { NdbTimer timer; timer.doStart();
  130. #define STOP_TIMER timer.doStop();
  131. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); }; 
  133. void 
  134. resetThreads(){
  136.   for (int i = 0; i < tNoOfThreads ; i++) {
  137.     ThreadReady[i] = 0;
  138.     ThreadStart[i] = stIdle;
  139.   }
  140. }
  142. void 
  143. waitForThreads(void)
  144. {
  145.   int cont;
  146.   do {
  147.     cont = 0;
  148.     NdbSleep_MilliSleep(20);
  149.     for (int i = 0; i < tNoOfThreads ; i++) {
  150.       if (ThreadReady[i] == 0) {
  151.         cont = 1;
  152.       }
  153.     }
  154.   } while (cont == 1);
  155. }
  157. void 
  158. tellThreads(StartType what)
  159. {
  160.   for (int i = 0; i < tNoOfThreads ; i++) 
  161.     ThreadStart[i] = what;
  162. }
  164. void createAttributeSpace(){
  165.   getAttrValueTable = new int[tAttributeSize*
  166.      tNoOfThreads * 
  167.      tNoOfAttributes ];
  169. }
  171. void deleteAttributeSpace(){
  172.   delete [] getAttrValueTable;
  173. }
  175. NDB_COMMAND(flexTimedAsynch, "flexTimedAsynch", "flexTimedAsynch [-tpoilcas]", "flexTimedAsynch", 65535)
  176. {
  177.   ndb_init();
  178.   ThreadNdb tabThread[MAXTHREADS];
  179.   int                   tLoops=0;
  180.   int                   returnValue;
  181.   //NdbOut flexTimedAsynchNdbOut;
  183.   flexTimedAsynchErrorData = new ErrorData;
  184.   flexTimedAsynchErrorData->resetErrorCounters();
  186.   Ndb* pNdb;
  187.   pNdb = new Ndb( "TEST_DB" );
  188.   pNdb->init();
  190.   readArguments(argc, argv);
  191.   
  192.   createAttributeSpace();
  194.   ndbout << endl << "FLEXTIMEDASYNCH - Starting normal mode" << endl;
  195.   ndbout << "Perform benchmark of insert, update and delete transactions" << endl << endl;
  197.   if(theTempFlag == 0)
  198.     ndbout << "  " << "Using temporary tables. " << endl;
  200.   // -t, tNoOfThreads
  201.   ndbout << "  " << tNoOfThreads << " number of concurrent threads " << endl;
  202.   // -c, tNoOfOpsPerTrans
  203.   ndbout << "  " << tNoOfOpsPerTrans << " operations per transaction " << endl;
  204.   // -p, tNoOfTransInBatch
  205.   ndbout << "  " << tNoOfTransInBatch << " number of transactions in a batch per thread " << endl;
  206.   // -o, tNoOfBatchesInLoop
  207.   ndbout << "  " << tNoOfBatchesInLoop << " number of batches per loop " << endl;
  208.   // -i, tTimeBetweenBatches
  209.   ndbout << "  " << tTimeBetweenBatches << " milli seconds at least between batch starts " << endl;
  210.   // -l, tNoOfLoops
  211.   ndbout << "  " << tNoOfLoops << " loops " << endl;
  212.   // -a, tNoOfAttributes
  213.   ndbout << "  " << tNoOfAttributes << " attributes per table " << endl; 
  214.   // -s, tAttributeSize
  215.   ndbout << "  " << tAttributeSize << " is the number of 32 bit words per attribute "  << endl << endl;
  217.   NdbThread_SetConcurrencyLevel(2 + tNoOfThreads);
  219.   /* print Setting */
  220.   flexTimedAsynchErrorData->printSettings(ndbout);
  222.   setAttrNames();
  223.   setTableNames();
  225.   ndbout << "Waiting for ndb to become ready..." <<endl;
  226.   if (pNdb->waitUntilReady() == 0) {
  227.     tNodeId = pNdb->getNodeId();
  228.     ndbout << "  NdbAPI node with id = " << tNodeId << endl;
  229.     createTables(pNdb);
  231.     /****************************************************************
  232.      * Create NDB objects.                                   *
  233.      ****************************************************************/
  234.     resetThreads();
  235.     for (int i = 0; i < tNoOfThreads ; i++) {
  236.       tabThread[i].ThreadNo = i;
  238.       threadLife[i] = NdbThread_Create(threadLoop,
  239.        (void**)&tabThread[i],
  240.        32768,
  241.        "flexTimedAsynchThread",
  242.                                        NDB_THREAD_PRIO_LOW);
  243.     }
  244.     ndbout << endl <<  "All NDB objects and table created" << endl << endl;
  245.     int noOfTransacts = tNoOfTransInBatch*tNoOfBatchesInLoop*tNoOfThreads;
  246.     
  247.     /****************************************************************
  248.      * Execute program.                                             *
  249.      ****************************************************************/
  252.     for(;;) { 
  254.       int loopCount = tLoops + 1 ;
  255.       ndbout << endl << "Loop # " << loopCount  << endl << endl ;
  257.       /****************************************************************
  258.        * Perform inserts.                                             *
  259.        ****************************************************************/
  260.   
  261.       failed = 0 ; 
  263.       START_TIMER;
  264.       execute(stInsert);
  265.       STOP_TIMER;
  266.       PRINT_TIMER("insert", noOfTransacts, tNoOfOpsPerTrans);
  268.       if (0 < failed) {
  269. ndbout << failed << " of the transactions returned errors!, moving on now..."<<endl ;
  270.       }
  271.       
  272.       /****************************************************************
  273.        * Perform read.                                                *
  274.        ****************************************************************/
  275.       
  276.       failed = 0 ; 
  278.       START_TIMER;
  279.       execute(stRead);
  280.       STOP_TIMER;
  281.       PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  282.      
  283.       if (0 < failed) {
  284. ndbout << failed << " of the transactions returned errors!, moving on now..."<<endl ;
  285.       }
  286.  
  287.       
  289.       /****************************************************************
  290.        * Perform update.                                              *
  291.        ***************************************************************/
  292.       
  293.       failed = 0 ; 
  294.   
  295.       START_TIMER;
  296.       execute(stUpdate);
  297.       STOP_TIMER;
  298.       PRINT_TIMER("update", noOfTransacts, tNoOfOpsPerTrans) ;
  300.       if (0 < failed) {
  301. ndbout << failed << " of the transactions returned errors!, moving on now..."<<endl ;
  302.       }
  304.       /****************************************************************
  305.        * Perform read after update.                                             
  306.        ****************************************************************/
  307.     
  308.       failed = 0 ; 
  309.   
  310.       START_TIMER;
  311.       execute(stRead);
  312.       STOP_TIMER;
  313.       PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  315.       if (0 < failed) {
  316. ndbout << failed << " of the transactions returned errors!, moving on now..."<<endl ;
  317.       }
  318.  
  320.       /****************************************************************
  321.        * Perform delete.                                              *
  322.        ****************************************************************/
  323.       
  324.       failed = 0; 
  325.   
  326.       START_TIMER;
  327.       execute(stDelete);
  328.       STOP_TIMER;
  329.       PRINT_TIMER("delete", noOfTransacts, tNoOfOpsPerTrans);
  331.       if (0 < failed) {
  332. ndbout << failed << " of the transactions returned errors!, moving on now..."<<endl ;
  333.       }
  334.         
  335.       tLoops++;
  336.       ndbout << "--------------------------------------------------" << endl;
  337.    
  338.       if(tNoOfLoops != 0){
  339. if(tNoOfLoops <= tLoops)
  340.   break ;
  341.       }
  342.     }
  344.     ndbout << endl << "Benchmark completed!" << endl;
  345.     returnValue = NDBT_OK;
  347.     execute(stStop);
  348.     void * tmp;
  349.     for(int i = 0; i<tNoOfThreads; i++){
  350.       NdbThread_WaitFor(threadLife[i], &tmp);
  351.       NdbThread_Destroy(&threadLife[i]);
  352.     }
  353.   } else {
  354.     ndbout << "NDB is not ready" << endl;
  355.     ndbout << "Benchmark failed!" << endl;
  356.     returnValue = NDBT_FAILED;
  357.   }
  359.   deleteAttributeSpace();
  360.   delete pNdb;
  362.   //printing errorCounters
  363.   flexTimedAsynchErrorData->printErrorCounters(ndbout);
  365.   return NDBT_ProgramExit(returnValue);
  366. }//main()
  368. ////////////////////////////////////////
  370. void execute(StartType aType)
  371. {
  372.   resetThreads();
  373.   tellThreads(aType);
  374.   waitForThreads();
  375. }
  377. void*
  378. threadLoop(void* ThreadData)
  379. {
  380.   // Do work until signaled to stop.
  382.   Ndb* localNdb;
  383.   StartType tType;
  384.   ThreadNdb* threadInfo = (ThreadNdb*)ThreadData;
  385.   int threadNo = threadInfo->ThreadNo;
  386.   localNdb = new Ndb("TEST_DB");
  387.   localNdb->init(512);
  388.   localNdb->waitUntilReady();
  389.   threadInfo->threadBase = (threadNo * 2000000) + (tNodeId * 260000000);
  391.   for (;;) {
  392.     while (ThreadStart[threadNo] == stIdle) {
  393.       NdbSleep_MilliSleep(10);
  394.     }
  396.     // Check if signal to exit is received
  397.     if (ThreadStart[threadNo] == stStop) {
  398.       break;
  399.     }
  401.     tType = ThreadStart[threadNo];
  402.     ThreadStart[threadNo] = stIdle;
  403.     executeThread(tType, localNdb, threadInfo);
  404.     ThreadReady[threadNo] = 1;
  405.   }
  407.   delete localNdb;
  408.   ThreadReady[threadNo] = 1;
  410.   return NULL; // thread exits
  411. }
  413. void executeThread(StartType aType, Ndb* aNdbObject, ThreadNdb* threadInfo)
  414. {
  415.   // Do all batch job in loop with start specified delay 
  416.   int i, j, k;
  417.   NdbConnection* tConArray[1024];
  418.   unsigned int tBase;
  419.   unsigned int tBase2;
  420.   int threadId = threadInfo->ThreadNo;
  421.   int *getValueRowAddress = NULL;
  423.   NdbTimer timer; 
  424.   timer.doStart();
  425.   
  426.   for (i = 0; i < tNoOfBatchesInLoop; i++) {
  427.     //tBase = threadBase + (i * tNoOfTransInBatch * tNoOfOpsPerTrans);
  428.     tBase = threadInfo->threadBase + (i * tNoOfTransInBatch * tNoOfOpsPerTrans);
  429.     //tCompleted = 0;
  430.     threadInfo->transactionCompleted = 0;
  431.   
  432.     for (j = 0; j < tNoOfTransInBatch; j++) {
  433.       tBase2 = tBase + (j * tNoOfOpsPerTrans);
  434.       tConArray[j] = aNdbObject->startTransaction();
  435.       if ( tConArray[j] == NULL && !error_handler(aNdbObject->getNdbError())) {
  436. ndbout << endl << "Unable to recover! Quiting now" << endl ;
  437. exit (-1) ;
  438. return ;
  439.       }
  441.       for (k = 0; k < tNoOfOpsPerTrans; k++) {
  442. //-------------------------------------------------------
  443. // Define the operation, but do not execute it yet.
  444. //-------------------------------------------------------
  445. if(aType == stRead){
  446.   getValueRowAddress = getAttrValueTable + 
  447.     threadId * tNoOfAttributes * tAttributeSize;
  448. }
  449. defineOperation(tConArray[j], aType, (tBase2 + k), getValueRowAddress);
  450.       }
  452.       tConArray[j]->executeAsynchPrepare(Commit, &executeCallback, threadInfo);
  453.     }
  455.     //-------------------------------------------------------
  456.     // Now we have defined a set of transactions (= batch), it is now time
  457.     // to execute all of them.
  458.     //-------------------------------------------------------
  459.     aNdbObject->sendPollNdb(3000, 0, 0);
  461.     //while (tCompleted < tNoOfTransInBatch) {
  462.     while (threadInfo->transactionCompleted < tNoOfTransInBatch) {
  463.       aNdbObject->pollNdb(3000, 0);
  464.       ndbout << "threadInfo->transactionCompleted = " << 
  465. threadInfo->transactionCompleted << endl;
  466.     }
  468.     for (j = 0 ; j < tNoOfTransInBatch ; j++) {
  469.       aNdbObject->closeTransaction(tConArray[j]);
  470.     }
  472.     // Control the elapsed time since the last batch start.
  473.     // Wait at least tTimeBetweenBatches milli seconds.
  474.     timer.doStop();
  475.     while(timer.elapsedTime() < tTimeBetweenBatches){
  476.       NdbSleep_MilliSleep(1);
  477.       timer.doStop();
  478.     }
  479.     // Ready to start new batch
  480.     timer.doStart();
  481.   }
  482.   return;
  483. }
  485. void
  486. executeCallback(int result, NdbConnection* NdbObject, void* aObject)
  487. {
  488.   //tCompleted++;
  489.   ThreadNdb *threadInfo = (ThreadNdb *)aObject;
  490.   threadInfo->transactionCompleted++;
  492.   if (result == -1) {
  494.               // Add complete error handling here
  496.               int retCode = flexTimedAsynchErrorData->handleErrorCommon(NdbObject->getNdbError());
  497.               if (retCode == 1) {
  498. if (NdbObject->getNdbError().code != 626 && NdbObject->getNdbError().code != 630){
  499.                 ndbout_c("execute: %s", NdbObject->getNdbError().message);
  500.                 ndbout_c("Error code = %d", NdbObject->getNdbError().code);}
  501.               } else if (retCode == 2) {
  502.                 ndbout << "4115 should not happen in flexAsynch" << endl;
  503.               } else if (retCode == 3) {
  504. /* What can we do here? */
  505.                 ndbout_c("execute: %s", NdbObject->getNdbError().message);
  506.                  }//if(retCode == 3)
  508.       //    ndbout << "Error occured in poll:" << NdbObject->getNdbError() << 
  509.       //      " ErrorCode = " << NdbObject->getNdbError() << endl;
  510.     ndbout << "executeCallback threadInfo->transactionCompleted = " << 
  511.       threadInfo->transactionCompleted << endl;  
  512.     failed++ ;
  513.     return;
  514.   }
  515.  return;
  516. }
  518. void
  519. defineOperation(NdbConnection* localNdbConnection, 
  520. StartType aType, 
  521. unsigned int threadBase,
  522. int *pRow )
  523. {
  524.   NdbOperation*  localNdbOperation;
  525.   unsigned int   loopCountAttributes = tNoOfAttributes;
  526.   unsigned int   countAttributes;
  527.   int            attrValue[MAXATTRSIZE];
  529.   //-------------------------------------------------------
  530.   // Set-up the attribute values for this operation.
  531.   //-------------------------------------------------------
  532.   for (int k = 0; k < loopCountAttributes; k++) {
  533.     *(int *)&attrValue[k] = (int)threadBase;
  534.   }
  535.   localNdbOperation = localNdbConnection->getNdbOperation(tableName[0]);
  536.   if (localNdbOperation == NULL) {
  537.     error_handler(localNdbOperation->getNdbError()) ;
  538.   }
  540.   switch (aType) {
  541.   case stInsert: {   // Insert case
  542.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  543.       localNdbOperation->dirtyWrite();
  544.     } else if (theWriteFlag == 1) {
  545.       localNdbOperation->writeTuple();
  546.     } else {
  547.       localNdbOperation->insertTuple();
  548.     }
  549.     break;
  550.   }
  551.   case stRead: {     // Read Case
  552.     if (theSimpleFlag == 1) {
  553.       localNdbOperation->simpleRead();
  554.     } else if (theDirtyFlag == 1) {
  555.       localNdbOperation->dirtyRead();
  556.     } else {
  557.       localNdbOperation->readTuple();
  558.     }
  559.      break;
  560.   }
  561.   case stUpdate: {    // Update Case
  562.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  563.       localNdbOperation->dirtyWrite();
  564.     } else if (theWriteFlag == 1) {
  565.       localNdbOperation->writeTuple();
  566.     } else if (theDirtyFlag == 1) {
  567.       localNdbOperation->dirtyUpdate();
  568.     } else {
  569.       localNdbOperation->updateTuple();
  570.     }
  571.     break;
  572.   }
  573.   case stDelete: {   // Delete Case
  574.     localNdbOperation->deleteTuple();
  575.     break;
  576.   }
  577.   default: {
  578.     error_handler(localNdbOperation->getNdbError());
  579.   }
  580.   }
  582.   localNdbOperation->equal((char*)attrName[0],(char*)&attrValue[0]);
  584.   switch (aType) {
  585.   case stInsert:      // Insert case
  586.   case stUpdate:      // Update Case
  587.     {
  588.       for (countAttributes = 1; countAttributes < loopCountAttributes; countAttributes++) {
  589.         localNdbOperation->setValue( (char*)attrName[countAttributes],(char*)&attrValue[0]);
  590.       }
  591.       break;
  592.     }
  593.   case stRead: {      // Read Case
  594.     for (countAttributes = 1; countAttributes < loopCountAttributes; countAttributes++) {
  595.       //localNdbOperation->getValue((char*)attrName[countAttributes],(char*)&attrValue[0]);
  596.       localNdbOperation->getValue((char*)attrName[countAttributes], 
  597.   (char *) (pRow + countAttributes*tAttributeSize));
  598.     }
  599.     break;
  600.   }
  601.   case stDelete: {    // Delete Case
  602.     break;
  603.   }
  604.   default: {
  605.     error_handler(localNdbOperation->getNdbError());
  606.   }
  607.   }
  608.   return;
  609. }
  611. void readArguments(int argc, const char** argv)
  612. {
  613.   int i = 1;
  614.   while (argc > 1)
  615.     {
  616.       if (strcmp(argv[i], "-t") == 0)
  617. {
  618.   tNoOfThreads = atoi(argv[i+1]);
  619.   //      if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
  620.   if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
  621.     exit(-1);
  622. }
  623.       else if (strcmp(argv[i], "-i") == 0)
  624. {
  625.   tTimeBetweenBatches = atoi(argv[i+1]);
  626.   if (tTimeBetweenBatches < 0)
  627.     exit(-1);
  628. }
  629.       else if (strcmp(argv[i], "-p") == 0)
  630. {
  631.   tNoOfTransInBatch = atoi(argv[i+1]);
  632.   //if ((tNoOfTransInBatch < 1) || (tNoOfTransInBatch > MAXTHREADS))
  633.   if ((tNoOfTransInBatch < 1) || (tNoOfTransInBatch > 10000))
  634.     exit(-1);
  635. }
  636.       else if (strcmp(argv[i], "-c") == 0)
  637. {
  638.   tNoOfOpsPerTrans = atoi(argv[i+1]);
  639.   if (tNoOfOpsPerTrans < 1)
  640.     exit(-1);
  641. }
  642.       else if (strcmp(argv[i], "-o") == 0)
  643. {
  644.   tNoOfBatchesInLoop = atoi(argv[i+1]);
  645.   if (tNoOfBatchesInLoop < 1)
  646.     exit(-1);
  647. }
  648.       else if (strcmp(argv[i], "-a") == 0)
  649. {
  650.   tNoOfAttributes = atoi(argv[i+1]);
  651.   if ((tNoOfAttributes < 2) || (tNoOfAttributes > MAXATTR))
  652.     exit(-1);
  653. }
  654.       else if (strcmp(argv[i], "-n") == 0)
  655. {
  656.   theStdTableNameFlag = 1;
  657.   argc++;
  658.   i--;
  659. }
  660.       else if (strcmp(argv[i], "-l") == 0)
  661. {
  662.   tNoOfLoops = atoi(argv[i+1]);
  663.   if ((tNoOfLoops < 0) || (tNoOfLoops > 100000))
  664.     exit(-1);
  665. }
  666.       else if (strcmp(argv[i], "-s") == 0)
  667. {
  668.   tAttributeSize = atoi(argv[i+1]);
  669.   if ((tAttributeSize < 1) || (tAttributeSize > MAXATTRSIZE))
  670.     exit(-1);
  671. }
  672.       else if (strcmp(argv[i], "-simple") == 0)
  673. {
  674.   theSimpleFlag = 1;
  675.   argc++;
  676.   i--;
  677. }
  678.       else if (strcmp(argv[i], "-write") == 0)
  679. {
  680.   theWriteFlag = 1;
  681.   argc++;
  682.   i--;
  683. }
  684.       else if (strcmp(argv[i], "-dirty") == 0)
  685. {
  686.   theDirtyFlag = 1;
  687.   argc++;
  688.   i--;
  689. }
  690.       else if (strcmp(argv[i], "-test") == 0)
  691. {
  692.   theTestFlag = 1;
  693.   argc++;
  694.   i--;
  695. }
  696.       else if (strcmp(argv[i], "-temp") == 0)
  697. {
  698.   theTempFlag = 0;  // 0 if temporary tables.
  699.   argc++;
  700.   i--;
  701. }
  702.       else if (strcmp(argv[i], "-no_table_create") == 0)
  703. {
  704.   theTableCreateFlag = 1;
  705.   argc++;
  706.   i--;
  707. }
  708.       else
  709. {
  710.   ndbout << "Arguments: " << endl;
  711.   ndbout << "-t Number of threads to start, i.e., number of parallel loops, default 1 " << endl;
  712.   ndbout << "-p Number of transactions in a batch, default 32 " << endl;
  713.   ndbout << "-o Number of batches per loop, default 200 " << endl;
  714.   ndbout << "-i Minimum time between batch starts in milli seconds, default 0 " << endl;
  715.   ndbout << "-l Number of loops to run, default 1, 0=infinite " << endl;
  716.   ndbout << "-a Number of attributes, default 25 " << endl;
  717.   ndbout << "-c Number of operations per transaction, default 1 " << endl;
  718.   ndbout << "-s Size of each attribute in 32 bit word, default 1" 
  719.     "(Primary Key is always of size 1, independent of this value) " << endl;
  720.   ndbout << "-simple           Use simple read to read from database " << endl;
  721.   ndbout << "-dirty            Use dirty read to read from database " << endl;
  722.   ndbout << "-write            Use writeTuple in insert and update " << endl;
  723.   ndbout << "-n                Use standard table names " << endl;
  724.   ndbout << "-no_table_create  Don't create tables in db " << endl;
  725.   ndbout << "-temp             Use temporary tables, no writing to disk. " << endl;
  726.   exit(-1);
  727. }
  729.       argc -= 2;
  730.       i = i + 2;
  731.     }
  732. }
  734. void setAttrNames()
  735. {
  736.   int i;
  738.   for (i = 0; i < MAXATTR ; i++)
  739.     {
  740.       sprintf(attrName[i], "COL%d", i);
  741.     }
  742. }
  745. void setTableNames()
  746. {
  747.   // Note! Uses only uppercase letters in table name's
  748.   // so that we can look at the tables with SQL
  749.   int i;
  750.   for (i = 0; i < MAXTABLES ; i++)
  751.     {
  752.       if (theStdTableNameFlag==1)
  753. {
  754.   sprintf(tableName[i], "TAB%d_%d", tNoOfAttributes, 
  755.   NdbTick_CurrentMillisecond()/1000);
  756. } else {
  757.   sprintf(tableName[i], "TAB%d_%d", tNoOfAttributes, tAttributeSize*4);
  758. }
  759.     }
  760. }
  762. void createTables(Ndb* pMyNdb)
  763. {
  765.   NdbSchemaCon *MySchemaTransaction;
  766.   NdbSchemaOp *MySchemaOp;
  767.   int                   check;
  769.   if (theTableCreateFlag == 0)
  770.     {
  771.       for(int i=0; i < 1 ;i++)
  772. {
  773.   ndbout << "Creating " << tableName[i] << "..." << endl;
  774.   MySchemaTransaction = pMyNdb->startSchemaTransaction();
  775.   
  776.   if( MySchemaTransaction == 
  777.       NULL && (!error_handler(MySchemaTransaction->getNdbError())))
  778.     exit(-1) ;/*goto error_handler; <epaulsa*/
  779.   
  780.   MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  781.   if( MySchemaOp == NULL
  782.       && (!error_handler(MySchemaTransaction->getNdbError())))
  783.     exit(-1) ;
  785.   check = MySchemaOp->createTable( tableName[i],
  786.    8, // Table Size
  787.    TupleKey, // Key Type
  788.    40, // Nr of Pages
  789.    All,         // FragmentType
  790.    6,
  791.    78,
  792.    80,
  793.    1,           // MemoryType
  794.    theTempFlag  // 0 if temporary tables else 1
  795.    );
  797.   if ( check == -1 && (!error_handler(MySchemaTransaction->getNdbError())))
  798.     exit(-1) ; /* epaulsa > goto error_handler; < epaulsa */
  801.   check = MySchemaOp->createAttribute( (char*)attrName[0],
  802.        TupleKey,
  803.        32,
  804.        PKSIZE,
  805.        UnSigned,
  806.        MMBased,
  807.        NotNullAttribute );
  809.   if ( check == -1 &&(!error_handler(MySchemaTransaction->getNdbError()))) 
  810.     exit(-1) ; /* epaulsa > goto error_handler; < epaulsa */
  812.   for (int j = 1; j < tNoOfAttributes ; j++)
  813.     {
  814.       check = MySchemaOp->createAttribute( (char*)attrName[j],
  815.    NoKey,
  816.    32,
  817.    tAttributeSize,
  818.    UnSigned,
  819.    MMBased,
  820.    NotNullAttribute );
  821.       if ( check == -1
  822.    && (!error_handler(MySchemaTransaction->getNdbError())))
  823. exit(-1) ; /* epaulsa > goto error_handler; < epaulsa */
  824.     }
  825.   
  826.   if ( MySchemaTransaction->execute() == -1 
  827.        &&(!error_handler(MySchemaTransaction->getNdbError())))
  828.     exit(-1) ; /* epaulsa > goto error_handler; < epaulsa */
  829.   
  830.   pMyNdb->closeSchemaTransaction(MySchemaTransaction);
  831. }
  832.     }
  834.   return;
  835. }
  837. bool error_handler(const NdbError & err) {
  838. ndbout << err << endl ;
  839. if ( 4008==err.code || 721==err.code || 266==err.code ){
  840. ndbout << endl << "Attempting to recover and continue now..." << endl ;
  841. return true ; // return true to retry
  842. }
  843. return false ; // return false to abort
  844. }
  847. //*******************************************************************************************