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

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

MySQL数据库

开发平台：

Visual C++

flexHammer.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.        FLEXHAMMER
  19.        Hammer ndb with read, insert, update and delete transactions. 
  21.        Arguments:
  22.         -t Number of threads to start, default 1
  23.         -o Number of operations per hammering-round, default 500
  24. -l Number of loops to run, default 1, 0=infinite
  25.         -a Number of attributes, default 25
  26.         -c Number of tables, default 1
  27. -s Size of each attribute, default 1
  28. -simple Use simple read to read from database
  29.         -dirty Use dirty read to read from database
  30. -write Use writeTuple to write to db
  31. -r Number of records to Hammer
  32.         -no_table_create Don't create tables in db
  33.         -regulate To be able to regulate the load flexHammer produces.
  34.         -stdtables Use standard table names
  35. -sleep Sleep a number of seconds before running the test, this 
  36.        can be used so that another flexProgram have tome to create tables
  38.        Returns:
  39.         0 - Test passed
  40.        -1 - Test failed
  41.         1 - Invalid arguments
  43. Revision history:
  44.   1.7  020208 epesson: Adapted to use NDBT
  45.   1.10 020222 epesson: Finalised handling of thread results
  46.   1.11 020222 epesson: Bug in checking results during delete fixed
  48.  * *************************************************** */
  50. #include <NdbApi.hpp>
  52. #include <NdbMain.h>
  53. #include <NdbThread.h>
  54. #include <NdbSleep.h>
  55. #include <NdbTick.h>
  56. #include <NdbOut.hpp>
  57. #include <NdbTimer.hpp>
  58. #include <NdbTick.h>
  59. #include <NdbTest.hpp>
  60. #include <NDBT_Error.hpp>
  61. #include <NdbSchemaCon.hpp>
  63. ErrorData * flexHammerErrorData;
  65. #if defined NDB_OSE || defined NDB_SOFTOSE
  66. #include <outfmt.h> 
  67. #endif
  69. #define MAXSTRLEN 16 
  70. #define MAXATTR 64
  71. #define MAXTABLES 64
  72. #define MAXTHREADS 256
  73. #define MAXATTRSIZE 100
  74. // Max number of retries if something fails
  75. #define MaxNoOfAttemptsC 10 
  77. enum StartType {
  78.   stIdle,
  79.   stHammer,
  80.   stStop,
  81.   stLast};
  83. enum MyOpType {
  84.   otInsert,
  85.   otRead,
  86.   otDelete,
  87.   otUpdate,
  88.   otLast};
  90. struct ThreadNdb {
  91.   int threadNo;
  92.   NdbThread* threadLife;
  93.   int threadReady;
  94.   StartType threadStart;
  95.   int threadResult;};
  97. extern "C" void* flexHammerThread(void*);
  98. static int setAttrNames(void);
  99. static int setTableNames(void);
  100. static int readArguments(int, const char**);
  101. static int createTables(Ndb*);
  102. static void sleepBeforeStartingTest(int seconds);
  103. static int checkThreadResults(ThreadNdb *threadArrayP, char* phase);
  105. //enum OperationType {
  106. //  otInsert,
  107. //  otRead,
  108. //  otUpdate,
  109. //  otDelete,
  110. //  otVerifyDelete,
  111. //  otLast };
  113. enum ReadyType {
  114. stReady, 
  115. stRunning
  116. } ;
  117. static int tNoOfThreads;
  118. static int tNoOfAttributes;
  119. static int tNoOfTables;
  120. static int tNoOfBackups;
  121. static int tAttributeSize;
  122. static int tNoOfOperations;
  123. static int tNoOfRecords;
  124. static int tNoOfLoops;
  125. static ReadyType ThreadReady[MAXTHREADS];
  126. static StartType ThreadStart[MAXTHREADS];
  127. static char tableName[MAXTABLES][MAXSTRLEN];
  128. static char attrName[MAXATTR][MAXSTRLEN];
  129. static int theSimpleFlag = 0;
  130. static int theWriteFlag = 0;
  131. static int theDirtyFlag = 0;
  132. static int theTableCreateFlag = 0;
  133. static int theStandardTableNameFlag = 0;
  134. static unsigned int tSleepTime = 0;
  136. #define START_TIMER { NdbTimer timer; timer.doStart();
  137. #define STOP_TIMER timer.doStop();
  138. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); }; 
  141. // Initialise thread data
  142. void 
  143. resetThreads(ThreadNdb *threadArrayP) {
  145.   for (int i = 0; i < tNoOfThreads ; i++)
  146.     {
  147.       threadArrayP[i].threadReady = 0;
  148.       threadArrayP[i].threadResult = 0;
  149.       threadArrayP[i].threadStart = stIdle;
  150.     }
  151. } // resetThreads
  153. void 
  154. waitForThreads(ThreadNdb *threadArrayP)
  155. {
  156.   int cont = 1;
  158.   while (cont) {
  159.     NdbSleep_MilliSleep(100);
  160.     cont = 0;
  161.     for (int i = 0; i < tNoOfThreads ; i++) {
  162.       if (threadArrayP[i].threadReady == 0) {
  163. cont = 1;
  164.       } // if
  165.     } // for
  166.   } // while
  167. } // waitForThreads
  169. void 
  170. tellThreads(ThreadNdb* threadArrayP, const StartType what)
  171. {
  172.   for (int i = 0; i < tNoOfThreads ; i++) 
  173.     {
  174.     threadArrayP[i].threadStart = what;
  175.     } // for
  176. } // tellThreads
  177.  
  178. NDB_COMMAND(flexHammer, "flexHammer", "flexHammer", "flexHammer", 65535)
  179. //main(int argc, const char** argv)
  180. {
  181.   ndb_init();
  182.   ThreadNdb* pThreads = NULL; // Pointer to thread data array
  183.   Ndb* pMyNdb = NULL;       // Pointer to Ndb object
  184.   int tLoops = 0;
  185.   int returnValue = 0;
  186.   int check = 0;
  187.   
  188.   flexHammerErrorData = new ErrorData;
  190.   flexHammerErrorData->resetErrorCounters();
  192.   if (readArguments(argc, argv) != 0) {
  193.     ndbout << "Wrong arguments to flexHammer" << endl;
  194.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  195.   } // if
  197.   /* print Setting */
  198.   flexHammerErrorData->printSettings(ndbout);
  200.   check = setAttrNames();
  201.   if (check == -1) {
  202.     ndbout << "Couldn't set attribute names" << endl;
  203.     return NDBT_ProgramExit(NDBT_FAILED);
  204.   } // if
  205.   check = setTableNames();
  206.   if (check == -1) {
  207.     ndbout << "Couldn't set table names" << endl;
  208.     return NDBT_ProgramExit(NDBT_FAILED);
  209.   } // if
  211.   // Create thread data array
  212.   pThreads = new ThreadNdb[tNoOfThreads];
  213.   // NdbThread_SetConcurrencyLevel(tNoOfThreads + 2);
  215.   // Create and init Ndb object
  216.   pMyNdb = new Ndb("TEST_DB");
  217.   pMyNdb->init();
  219.   // Wait for Ndb to become ready
  220.   if (pMyNdb->waitUntilReady(10000) != 0) {
  221.     ndbout << "NDB is not ready" << endl << "Benchmark failed" << endl;
  222.     returnValue = NDBT_FAILED;
  223.   }
  225.   else {
  226.     check = createTables(pMyNdb);
  227.     if (check != 0) {
  228.       returnValue = NDBT_FAILED;
  229.     } // if
  230.     else {
  231.       sleepBeforeStartingTest(tSleepTime);
  232.       
  233.       // Create threads.                                           *
  234.       resetThreads(pThreads);
  235.       for (int i = 0; i < tNoOfThreads ; i++) {  
  236. pThreads[i].threadNo = i;
  237. pThreads[i].threadLife = NdbThread_Create(flexHammerThread,
  238.   (void**)&pThreads[i],
  239.   65535,
  240.   "flexHammerThread",
  241.                                                   NDB_THREAD_PRIO_LOW);
  242.       } // for
  243.       
  244.       // And wait until they are ready
  245.       waitForThreads(pThreads);
  246.       if (checkThreadResults(pThreads, "init") != 0) {
  247.         returnValue = NDBT_FAILED;
  248.       } // if
  249.       
  250.       
  251.       if (returnValue == NDBT_OK) {
  252. ndbout << endl <<  "All threads started" << endl << endl;
  254. for(;;) {
  255.   
  256.   // Check if it's time to exit program
  257.   if((tNoOfLoops != 0) && (tNoOfLoops <= tLoops))
  258.     break;
  259.   
  260.   // Tell all threads to start hammer
  261.   ndbout << "Hammering..." << endl;
  262.   
  263.   resetThreads(pThreads);
  264.   
  265.   START_TIMER;
  266.   tellThreads(pThreads, stHammer);
  267.   
  268.   waitForThreads(pThreads);
  269.   ndbout << "Threads ready to continue..." << endl;
  270.   STOP_TIMER;
  271.   
  272.   // Check here if anything went wrong
  273.   if (checkThreadResults(pThreads, "hammer") != 0) {
  274.     ndbout << "Thread(s) failed." << endl;
  275.     returnValue = NDBT_FAILED;
  276.   } // if
  277.   
  278.   PRINT_TIMER("hammer", tNoOfOperations*tNoOfThreads, tNoOfTables*6);
  279.   
  280.   ndbout << endl;
  281.   
  282.   tLoops++;
  283.   
  284. } // for
  285.       } // if
  287.       // Signaling threads to stop 
  288.       resetThreads(pThreads);
  289.       tellThreads(pThreads, stStop);
  290.       
  291.       // Wait for threads to stop
  292.       waitForThreads(pThreads);
  293.       
  294.       ndbout << "----------------------------------------------" << endl << endl;
  295.       ndbout << "Benchmark completed" << endl;
  296.     } // else
  297.   } // else
  298.   // Clean up 
  300.   flexHammerErrorData->printErrorCounters(ndbout);
  302.   // Kill them all! 
  303.   void* tmp;
  304.   for(int i = 0; i < tNoOfThreads; i++){
  305.     NdbThread_WaitFor(pThreads[i].threadLife, &tmp);
  306.     NdbThread_Destroy(&pThreads[i].threadLife);
  307.   }
  308.   delete flexHammerErrorData;
  309.   delete [] pThreads;
  310.   delete pMyNdb;
  312.   // Exit via NDBT
  313.   return NDBT_ProgramExit(returnValue);
  314.   
  315. } //main
  317. extern "C"
  318. void*
  319. flexHammerThread(void* pArg)
  320. {
  321.   ThreadNdb* pThreadData = (ThreadNdb*)pArg;
  322.   unsigned int threadNo = pThreadData->threadNo;
  323.   Ndb* pMyNdb = NULL ;
  324.   NdbConnection *pMyTransaction = NULL ;
  325.   //  NdbOperation* pMyOperation[MAXTABLES] = {NULL};
  326.   NdbOperation* pMyOperation[MAXTABLES];
  327.   int check = 0;
  328.   int loop_count_ops = 0;
  329.   int loop_count_tables = 0;
  330.   int loop_count_attributes = 0;
  331.   int count_round = 0;
  332.   int count = 0;
  333.   int count_tables = 0;
  334.   int count_attributes = 0;
  335.   int i = 0;
  336.   int j = 0;
  337.   int tThreadResult = 0;
  338.   MyOpType tMyOpType = otLast;
  339.   int pkValue = 0;
  340.   int readValue[MAXATTR][MAXATTRSIZE] = {0};
  341.   int attrValue[MAXATTRSIZE];
  342.   NdbRecAttr* tTmp = NULL;
  343.   int tNoOfAttempts = 0;
  344.  
  345.   for (i = 0; i < MAXATTRSIZE; i++)
  346.     attrValue[i] = 0; 
  347.   // Ndb object for each thread
  348.   pMyNdb = new Ndb( "TEST_DB" );
  349.   pMyNdb->init();
  350.   if (pMyNdb->waitUntilReady(10000) != 0) {
  351.     // Error, NDB is not ready
  352.     tThreadResult = 99;
  353.     // Go to idle directly
  354.     pThreadData->threadStart = stIdle;
  355.   } // if
  356.   
  357.   for(;;) {
  358.     pThreadData->threadResult = tThreadResult;
  359.     pThreadData->threadReady = 1; // Signalling ready to main
  360.     
  361.     // If Idle just wait to be stopped from main
  362.     while (pThreadData->threadStart == stIdle) {
  363.       NdbSleep_MilliSleep(100);   
  364.     } // while
  365.     
  366.     // Check if signal to exit is received
  367.     if (pThreadData->threadStart == stStop) {
  368.       pThreadData->threadReady = 1;
  369.       // break out of eternal loop
  370.       break;
  371.     } // if
  372.     
  373.     // Set to Idle to prepare for possible error break
  374.     pThreadData->threadStart = stIdle;
  375.     
  376.     // Prepare transaction
  377.     loop_count_ops = tNoOfOperations;
  378.     loop_count_tables = tNoOfTables;
  379.     loop_count_attributes = tNoOfAttributes;
  380.     
  381.     for (count=0 ; count < loop_count_ops ; count++) {
  382.       
  383.       //pkValue = (int)(count + thread_base);
  384.       // This limits the number of records used in this test
  385.       pkValue = count % tNoOfRecords; 
  386.       
  387.       for (count_round = 0; count_round < 5; ) {
  388. switch (count_round) {
  389. case 0:       // Insert
  390.   tMyOpType = otInsert;
  391.   // Increase attrValues
  392.   for (i=0; i < MAXATTRSIZE; i ++) {
  393.     attrValue[i]++;
  394.   }
  395.   break;
  396. case 1: 
  397. case 3:       // Read and verify
  398.   tMyOpType = otRead;
  399.   break;
  400. case 2:       // Update
  401.   // Increase attrValues
  402.   for(i=0; i < MAXATTRSIZE; i ++) {
  403.     attrValue[i]++;
  404.   }
  405.   tMyOpType = otUpdate;
  406.   break;
  407. case 4:       // Delete
  408.   tMyOpType = otDelete;
  409.   break;
  410. default:
  411.   assert(false);
  412.   break;
  413. } // switch
  414.     
  415. // Get transaction object
  416. pMyTransaction = pMyNdb->startTransaction();
  417. if (pMyTransaction == NULL) {
  418.   // Fatal error
  419.   tThreadResult = 1;
  420.   // break out of for count_round loop waiting to be stopped by main
  421.   break;
  422. } // if
  424. for (count_tables = 0; count_tables < loop_count_tables; 
  425.      count_tables++) {
  426.   pMyOperation[count_tables] = 
  427.     pMyTransaction->getNdbOperation(tableName[count_tables]);
  428.   if (pMyOperation[count_tables] == NULL) {
  429.     //Fatal error
  430.     tThreadResult = 2;
  431.     // break out of inner for count_tables loop
  432.     break;
  433.   } // if
  435.   switch (tMyOpType) {
  436.   case otInsert: // Insert case
  437.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  438.       check = pMyOperation[count_tables]->dirtyWrite();
  439.     } else if (theWriteFlag == 1) {
  440.       check = pMyOperation[count_tables]->writeTuple();
  441.     } else {
  442.       check = pMyOperation[count_tables]->insertTuple();
  443.     } // if else
  444.     break;
  445.   case otRead: // Read Case
  446.     if (theSimpleFlag == 1) {
  447.       check = pMyOperation[count_tables]->simpleRead();
  448.     } else if (theDirtyFlag == 1) {
  449.       check = pMyOperation[count_tables]->dirtyRead();
  450.     } else {
  451.       check = pMyOperation[count_tables]->readTuple();
  452.     } // if else
  453.     break;
  454.   case otUpdate: // Update Case
  455.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  456.       check = pMyOperation[count_tables]->dirtyWrite();
  457.     } else if (theWriteFlag == 1) {
  458.       check = pMyOperation[count_tables]->writeTuple();
  459.     } else if (theDirtyFlag == 1) {
  460.       check = pMyOperation[count_tables]->dirtyUpdate();
  461.     } else {
  462.       check = pMyOperation[count_tables]->updateTuple();
  463.     } // if else
  464.     break;
  465.   case otDelete: // Delete Case
  466.     check = pMyOperation[count_tables]->deleteTuple();
  467.     break;
  468.   default:
  469.     assert(false);
  470.     break;
  471.   } // switch
  472.   if (check == -1) {
  473.     // Fatal error
  474.     tThreadResult = 3;
  475.     // break out of inner for count_tables loop
  476.     break;
  477.   } // if
  479.   check = pMyOperation[count_tables]->equal( (char*)attrName[0], 
  480.     (char*)&pkValue );
  482.   if (check == -1) {
  483.     // Fatal error
  484.     tThreadResult = 4;
  485.     ndbout << "pMyOperation equal failed" << endl;
  486.     // break out of inner for count_tables loop
  487.     break;
  488.   } // if
  489.   
  490.   check = -1;
  491.   tTmp = NULL;
  492.   switch (tMyOpType) {
  493.   case otInsert: // Insert case
  494.   case otUpdate: // Update Case
  495.     for (count_attributes = 1; count_attributes < loop_count_attributes;
  496.  count_attributes++) {
  497.       check = 
  498. pMyOperation[count_tables]->setValue((char*)attrName[count_attributes], (char*)&attrValue[0]);
  499.     } // for
  500.     break;
  501.   case otRead: // Read Case
  502.     for (count_attributes = 1; count_attributes < loop_count_attributes; 
  503.  count_attributes++) {
  504.       tTmp = pMyOperation[count_tables]->
  505. getValue( (char*)attrName[count_attributes], 
  506.   (char*)&readValue[count_attributes][0] );
  507.     } // for
  508.     break;
  509.   case otDelete: // Delete Case
  510.     break;
  511.   default:
  512.     assert(false);
  513.     break;
  514.   } // switch
  515.   if (check == -1 && tTmp == NULL && tMyOpType != otDelete) {
  516.     // Fatal error
  517.     tThreadResult = 5;
  518.     break;
  519.   } // if
  520. } // for count_tables
  521.     
  522. // Only execute if everything is OK
  523. if (tThreadResult != 0) {
  524.   // Close transaction (below)
  525.   // and continue with next count_round
  526.   count_round++;
  527.   tNoOfAttempts = 0;
  528. } // if
  529. else {
  530.   check = pMyTransaction->execute(Commit);
  531.   if (check == -1 ) {
  532.     const NdbError & err = pMyTransaction->getNdbError();
  534. // Add complete error handling here
  536.               int retCode = flexHammerErrorData->handleErrorCommon(pMyTransaction->getNdbError());
  537.               if (retCode == 1) {
  538. //if (strcmp(pMyTransaction->getNdbError().message, "Tuple did not exist") != 0 && strcmp(pMyTransaction->getNdbError().message,"Tuple already existed when attempting to insert") != 0) ndbout_c("execute: %s", pMyTransaction->getNdbError().message);
  540. if (pMyTransaction->getNdbError().code != 626 && pMyTransaction->getNdbError().code != 630){
  541.      ndbout_c("Error code = %d", pMyTransaction->getNdbError().code);
  542.      ndbout_c("execute: %s", pMyTransaction->getNdbError().message);}
  544.               } else if (retCode == 2) {
  545.                 ndbout << "4115 should not happen in flexHammer" << endl;
  546.               } else if (retCode == 3) {
  547. // --------------------------------------------------------------------
  548. // We are not certain if the transaction was successful or not.
  549. // We must reexecute but might very well find that the transaction
  550. // actually was updated. Updates and Reads are no problem here. Inserts
  551. // will not cause a problem if error code 630 arrives. Deletes will
  552. // not cause a problem if 626 arrives.
  553. // --------------------------------------------------------------------
  554. /* What can we do here? */
  555. ndbout_c("execute: %s", pMyTransaction->getNdbError().message);
  556.                  }//if(retCode == 3)
  557. // End of adding complete error handling
  559.     switch( err.classification) {
  560.     case NdbError::ConstraintViolation: // Tuple already existed
  561.       count_round++;
  562.       tNoOfAttempts = 0;
  563.       break;
  564.     case NdbError::TimeoutExpired:
  565.     case NdbError::NodeRecoveryError:
  566.     case NdbError::TemporaryResourceError:
  567.     case NdbError::OverloadError:
  568.       if (tNoOfAttempts <= MaxNoOfAttemptsC) {
  569. // Retry
  570. tNoOfAttempts++;
  571.       } else {
  572. // Too many retries, continue with next
  573. count_round++;
  574. tNoOfAttempts = 0;
  575.       } // else if
  576.       break;
  577.       // Fatal, just continue
  578.     default:
  579.       count_round++;
  580.       tNoOfAttempts = 0;
  581.       break;
  582.     } // switch
  583.   } // if
  584.   else {
  585.     // Execute commit was OK
  586.     // This is verifying read values
  587.     //switch (tMyOpType) {
  588.     //case otRead:  // Read case
  589.     //for (j = 0; j < tNoOfAttributes; j++) {
  590.     //for(i = 1; i < tAttributeSize; i++) {
  591.     //if ( readValue[j][i] != attrValue[i]) {
  592.     //ndbout << "pkValue = " << pkValue << endl;
  593.     //ndbout << "readValue != attrValue" << endl;
  594.     //ndbout << readValue[j][i] << " != " << attrValue[i] << endl;
  595.     //} // if
  596.     //  } // for
  597.     //} // for
  598.     //break;
  599.     //} // switch
  600.     count_round++;
  601.     tNoOfAttempts = 0;
  602.   } // else if
  603. } // else if
  604. pMyNdb->closeTransaction(pMyTransaction);
  605.       } // for count_round
  606.     } // for count
  607.   } // for (;;)
  609.   // Clean up
  610.   delete pMyNdb; 
  611.   pMyNdb = NULL;
  613.   flexHammerErrorData->resetErrorCounters();
  615.   return  NULL; // thread exits
  616.   
  617. } // flexHammerThread
  620. int
  621. readArguments (int argc, const char** argv)
  622. {
  623.   int i = 1;
  624.   
  625.   tNoOfThreads = 5; // Default Value
  626.   tNoOfOperations = 500; // Default Value
  627.   tNoOfRecords = 1;             // Default Value
  628.   tNoOfLoops = 1;         // Default Value
  629.   tNoOfAttributes = 25; // Default Value
  630.   tNoOfTables = 1; // Default Value
  631.   tNoOfBackups = 0; // Default Value
  632.   tAttributeSize = 1; // Default Value
  633.   theTableCreateFlag = 0;
  634.   
  635.   while (argc > 1) {
  636.     if (strcmp(argv[i], "-t") == 0) {
  637.       tNoOfThreads = atoi(argv[i+1]);
  638.       if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS))
  639. return(1);
  640.     }
  641.     else if (strcmp(argv[i], "-o") == 0) {
  642.       tNoOfOperations = atoi(argv[i+1]);
  643.       if (tNoOfOperations < 1)
  644. return(1);
  645.     }
  646.     else if (strcmp(argv[i], "-r") == 0) {
  647.       tNoOfRecords = atoi(argv[i+1]);
  648.       if (tNoOfRecords < 1)
  649. return(1);
  650.     }
  651.     else if (strcmp(argv[i], "-a") == 0) {
  652.       tNoOfAttributes = atoi(argv[i+1]);
  653.       if ((tNoOfAttributes < 2) || (tNoOfAttributes > MAXATTR))
  654. return(1);
  655.     }
  656.     else if (strcmp(argv[i], "-c") == 0) {
  657.       tNoOfTables = atoi(argv[i+1]);
  658.       if ((tNoOfTables < 1) || (tNoOfTables > MAXTABLES))
  659. return(1);
  660.     }
  661.     else if (strcmp(argv[i], "-l") == 0) {
  662.       tNoOfLoops = atoi(argv[i+1]);
  663.       if ((tNoOfLoops < 0) || (tNoOfLoops > 100000))
  664. return(1);
  665.     }
  666.     else if (strcmp(argv[i], "-s") == 0) {
  667.       tAttributeSize = atoi(argv[i+1]);
  668.       if ((tAttributeSize < 1) || (tAttributeSize > MAXATTRSIZE))
  669. return(1);
  670.     }
  671.     else if (strcmp(argv[i], "-sleep") == 0) {
  672.       tSleepTime = atoi(argv[i+1]);
  673.       if ((tSleepTime < 1) || (tSleepTime > 3600))
  674. exit(-1);
  675.     }
  676.     else if (strcmp(argv[i], "-simple") == 0) {
  677.       theSimpleFlag = 1;
  678.       argc++;
  679.       i--;
  680.     }
  681.     else if (strcmp(argv[i], "-write") == 0) {
  682.       theWriteFlag = 1;
  683.       argc++;
  684.       i--;
  685.     }
  686.     else if (strcmp(argv[i], "-dirty") == 0) {
  687.       theDirtyFlag = 1;
  688.       argc++;
  689.       i--;
  690.     }
  691.     else if (strcmp(argv[i], "-no_table_create") == 0) {
  692.       theTableCreateFlag = 1;
  693.       argc++;
  694.       i--;
  695.     }
  696.     else if (strcmp(argv[i], "-stdtables") == 0) {
  697.       theStandardTableNameFlag = 1;
  698.       argc++;
  699.       i--;
  700.     } // if
  701.     else {
  702.       return(1);
  703.     }
  704.     
  705.     argc -= 2;
  706.     i = i + 2;
  707.   } // while
  708.   
  709.   ndbout << endl << "FLEXHAMMER - Starting normal mode" << endl;
  710.   ndbout << "Hammer ndb with read, insert, update and delete transactions"<< endl << endl;
  711.   
  712.   ndbout << "  " << tNoOfThreads << " thread(s) " << endl;
  713.   ndbout << "  " << tNoOfLoops << " iterations " << endl;
  714.   ndbout << "  " << tNoOfTables << " table(s) and " << 1 << " operation(s) per transaction " << endl;
  715.   ndbout << "  " << tNoOfRecords << " records to hammer(limit this with the -r option)" << endl;
  716.   ndbout << "  " << tNoOfAttributes << " attributes per table " << endl;
  717.   ndbout << "  " << tNoOfOperations << " transaction(s) per thread and round " << endl;
  718.   ndbout << "  " << tAttributeSize << " is the number of 32 bit words per attribute " << endl << endl;
  719.   return 0;
  720. } // readArguments
  723. void sleepBeforeStartingTest(int seconds)
  724. {
  725.   if (seconds > 0) {
  726.     ndbout << "Sleeping(" << seconds << ")...";
  727.     NdbSleep_SecSleep(seconds);
  728.     ndbout << " done!" << endl;
  729.   } // if
  730. } // sleepBeforeStartingTest
  732. static int
  733. createTables(Ndb* pMyNdb)
  734. {
  735.   int i = 0;
  736.   int j = 0;
  737.   int check = 0;
  738.   NdbSchemaCon *MySchemaTransaction = NULL;
  739.   NdbSchemaOp *MySchemaOp = NULL;
  741.   // Create Table and Attributes.                            
  742.   if (theTableCreateFlag == 0) {
  744.     for (i = 0; i < tNoOfTables; i++) {
  746.       ndbout << "Creating " << tableName[i] << "...";
  747.       // Check if table exists already
  748.       const void * p = pMyNdb->getDictionary()->getTable(tableName[i]);
  749.       if (p != 0) {
  750. ndbout << " already exists." << endl;
  751. // Continue with next table at once
  752. continue;
  753.       } // if
  754.       ndbout << endl;
  755.       
  756.       MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
  757.       if (MySchemaTransaction == NULL) {
  758. return(-1);
  759.       } // if
  760.       
  761.       MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  762.       if (MySchemaOp == NULL) {
  763. // Clean up opened schema transaction
  764. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  765. return(-1);
  766.       } // if
  767.       
  768.       // Create tables, rest of parameters are default right now
  769. #if defined NDB_OSE || defined NDB_SOFTOSE
  770.       check = MySchemaOp->createTable(tableName[i],
  771.       8, // Table Size
  772.       TupleKey, // Key Type
  773.       40, // Nr of Pages
  774.       All, 
  775.       6,
  776.       78,
  777.       80,
  778.       1,
  779.       false);
  781. #else
  782.       check = MySchemaOp->createTable(tableName[i],
  783.       8, // Table Size
  784.       TupleKey, // Key Type
  785.       40); // Nr of Pages
  786. #endif
  787.       if (check == -1) { 
  788. // Clean up opened schema transaction
  789. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  790. return(-1);
  791.       } // if
  792.       
  793.       // Primary key
  794.       //ndbout << "  pk " << (char*)&attrName[0] << "..." << endl;
  795.       check = MySchemaOp->createAttribute( (char*)attrName[0], TupleKey, 32,
  796.    1, UnSigned, MMBased,
  797.    NotNullAttribute );
  798.       if (check == -1) { 
  799. // Clean up opened schema transaction
  800. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  801. return(-1);
  802.       } // if
  804.       // Rest of attributes
  805.       for (j = 1; j < tNoOfAttributes ; j++) {
  806. //ndbout << "    " << (char*)attrName[j] << "..." << endl;
  807. check = MySchemaOp->createAttribute( (char*)attrName[j], NoKey, 32, 
  808.      tAttributeSize, UnSigned, MMBased, 
  809.      NotNullAttribute );
  810. if (check == -1) {
  811.   // Clean up opened schema transaction
  812.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  813.   return(-1);
  814. } // if
  815.       } // for
  816.   
  817.       // Execute creation
  818.       check = MySchemaTransaction->execute();
  819.       if (check == -1) {
  820. // Clean up opened schema transaction
  821. NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  822. return(-1);
  823.       } // if
  824.       
  825.       NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  826.     } // for
  827.   } // if
  829.   return(0);
  831. } // createTables 
  834. static int setAttrNames()
  835. {
  836.   int i = 0;
  837.   int retVal = 0;
  839.   for (i = 0; i < MAXATTR ; i++) {
  840.     retVal = BaseString::snprintf(attrName[i], MAXSTRLEN, "COL%d", i);
  841.     if (retVal < 0) {
  842.       // Error in conversion
  843.       return(-1);
  844.     } // if
  845.   } // for
  847.   return (0);
  848. } // setAttrNames
  850. static int setTableNames()
  851. {
  852.   // Note! Uses only uppercase letters in table name's
  853.   // so that we can look at the tables wits SQL
  854.   int i = 0;
  855.   int retVal = 0;
  857.   for (i = 0; i < MAXTABLES ; i++) {
  858.     if (theStandardTableNameFlag == 0) {
  859.       retVal = BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d_%d", i, 
  860.  NdbTick_CurrentMillisecond()/1000);
  861.     } // if 
  862.     else {
  863.       retVal = BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d", i);
  864.     } // else
  865.     if (retVal < 0) {
  866.       // Error in conversion
  867.       return(-1);
  868.     } // if
  869.   } // for
  871.   return(0);
  872. } // setTableNames
  874. static int checkThreadResults(ThreadNdb *threadArrayP, char* phase)
  875. {
  876.   int i = 0;
  878.   for (i = 0; i < tNoOfThreads; i++) {
  879.     if (threadArrayP[i].threadResult != 0) {
  880.       ndbout << "Thread " << i << " reported fatal error " 
  881.      << threadArrayP[i].threadResult << " during " << phase << endl;
  882.       return(-1);
  883.     } // if
  884.   } // for
  886.   return(0);
  887. }