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

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

MySQL数据库

开发平台：

Visual C++

flexBench.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. FLEXBENCH
  20. Perform benchmark of insert, update and delete transactions
  22. Arguments:
  23.     -t Number of threads to start, default 1
  24.     -o Number of operations per loop, default 500
  25.     -l Number of loops to run, default 1, 0=infinite
  26.     -a Number of attributes, default 25
  27.     -c Number of tables, default 1
  28.     -s Size of each attribute, default 1 (Primary Key is always of size 1,
  29.     independent of this value)
  30.     -lkn Number of long primary keys, default 1
  31.     -lks Size of each long primary key, default 1
  32.     -simple Use simple read to read from database
  33.     -dirty Use dirty read to read from database
  34.     -write Use writeTuple in insert and update
  35.     -stdtables Use standard table names
  36.     -no_table_create Don't create tables in db
  37.     -sleep Sleep a number of seconds before running the test, this 
  38.     can be used so that another flexBench have time to create tables
  39.     -temp Use tables without logging
  40.     -verify Verify inserts, updates and deletes
  41. #ifdef CEBIT_STAT
  42.     -statserv host:port  statistics server to report to
  43.     -statfreq ops        report every ops operations (default 100)
  44. #endif
  45.     Returns:
  46.     0 - Test passed
  47.     1 - Test failed
  48.     2 - Invalid arguments
  50. * *************************************************** */
  52. #include "NdbApi.hpp"
  54. #include <NdbMain.h>
  55. #include <NdbOut.hpp>
  56. #include <NdbSleep.h>
  57. #include <NdbTick.h>
  58. #include <NdbTimer.hpp>
  59. #include <NdbThread.h>
  61. #include <NdbTest.hpp>
  63. #define MAXSTRLEN 16 
  64. #define MAXATTR 64
  65. #define MAXTABLES 128
  66. #define MAXATTRSIZE 1000
  67. #define MAXNOLONGKEY 16 // Max number of long keys.
  68. #define MAXLONGKEYTOTALSIZE 1023 // words = 4092 bytes
  70. extern "C" { static void* flexBenchThread(void*); }
  71. static int readArguments(int argc, const char** argv);
  72. static int createTables(Ndb*);
  73. static void sleepBeforeStartingTest(int seconds);
  74. static void input_error();
  76. enum StartType { 
  77.   stIdle,
  78.   stInsert,
  79.   stVerify,
  80.   stRead,
  81.   stUpdate,
  82.   stDelete,
  83.   stTryDelete,
  84.   stVerifyDelete,
  85.   stStop 
  86. };
  88. struct ThreadData
  89. {
  90.   int threadNo;
  91.   NdbThread* threadLife;
  92.   int threadReady;  
  93.   StartType threadStart;
  94.   int threadResult;
  95. };
  97. static int                  tNodeId = 0 ;
  98. static char                 tableName[MAXTABLES][MAXSTRLEN+1];
  99. static char                 attrName[MAXATTR][MAXSTRLEN+1];
  100. static char**               longKeyAttrName;
  102. // Program Parameters
  103. static int                  tNoOfLoops = 1;
  104. static int                  tAttributeSize = 1;
  105. static unsigned int         tNoOfThreads = 1;
  106. static unsigned int         tNoOfTables = 1;
  107. static unsigned int         tNoOfAttributes = 25;
  108. static unsigned int         tNoOfOperations = 500;
  109. static unsigned int         tSleepTime = 0;
  110. static unsigned int         tNoOfLongPK = 1;
  111. static unsigned int         tSizeOfLongPK = 1;
  113. //Program Flags
  114. static int                  theSimpleFlag = 0;
  115. static int                  theDirtyFlag = 0;
  116. static int                  theWriteFlag = 0;
  117. static int                  theStdTableNameFlag = 0;
  118. static int                  theTableCreateFlag = 0;
  119. static bool                 theTempTable = false;
  120. static bool                 VerifyFlag = true;
  121. static bool                 useLongKeys = false;
  124. static ErrorData theErrorData; // Part of flexBench-program
  126. #define START_TIMER { NdbTimer timer; timer.doStart();
  127. #define STOP_TIMER timer.doStop();
  128. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); };
  130. #include <NdbTCP.h>
  132. #ifdef CEBIT_STAT
  133. #include <NdbMutex.h>
  134. static bool statEnable = false;
  135. static char statHost[100];
  136. static int statFreq = 100;
  137. static int statPort = 0;
  138. static int statSock = -1;
  139. static enum { statError = -1, statClosed, statOpen } statState;
  140. static NdbMutex statMutex = NDB_MUTEX_INITIALIZER;
  141. #endif
  143. //-------------------------------------------------------------------
  144. // Statistical Reporting routines
  145. //-------------------------------------------------------------------
  146. #ifdef CEBIT_STAT
  147. // Experimental client-side statistic for CeBIT
  149. static void
  150. statReport(enum StartType st, int ops)
  151. {
  152.   if (!statEnable)
  153.     return;
  154.   if (NdbMutex_Lock(&statMutex) < 0) {
  155.     if (statState != statError) {
  156.       ndbout_c("stat: lock mutex failed: %s", strerror(errno));
  157.       statState = statError;
  158.     }
  159.     return;
  160.   }
  161.   static int nodeid;
  162.   // open connection
  163.   if (statState != statOpen) {
  164.     char *p = getenv("NDB_NODEID"); // ndbnet sets NDB_NODEID
  165.     nodeid = p == 0 ? 0 : atoi(p);
  166.     if ((statSock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  167.       if (statState != statError) {
  168. ndbout_c("stat: create socket failed: %s", strerror(errno));
  169. statState = statError;
  170.       }
  171.       (void)NdbMutex_Unlock(&statMutex);
  172.       return;
  173.     }
  174.     struct sockaddr_in saddr;
  175.     memset(&saddr, 0, sizeof(saddr));
  176.     saddr.sin_family = AF_INET;
  177.     saddr.sin_port = htons(statPort);
  178.     if (Ndb_getInAddr(&saddr.sin_addr, statHost) < 0) {
  179.       if (statState != statError) {
  180. ndbout_c("stat: host %s not found", statHost);
  181. statState = statError;
  182.       }
  183.       (void)close(statSock);
  184.       (void)NdbMutex_Unlock(&statMutex);
  185.       return;
  186.     }
  187.     if (connect(statSock, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
  188.       if (statState != statError) {
  189. ndbout_c("stat: connect failed: %s", strerror(errno));
  190. statState = statError;
  191.       }
  192.       (void)close(statSock);
  193.       (void)NdbMutex_Unlock(&statMutex);
  194.       return;
  195.     }
  196.     statState = statOpen;
  197.     ndbout_c("stat: connection to %s:%d opened", statHost, (int)statPort);
  198.   }
  199.   const char *text;
  200.   switch (st) {
  201.   case stInsert:
  202.     text = "insert";
  203.     break;
  204.   case stVerify:
  205.     text = "verify";
  206.     break;
  207.   case stRead:
  208.     text = "read";
  209.     break;
  210.   case stUpdate:
  211.     text = "update";
  212.     break;
  213.   case stDelete:
  214.     text = "delete";
  215.     break;
  216.   case stVerifyDelete:
  217.     text = "verifydelete";
  218.     break;
  219.   default:
  220.     text = "unknown";
  221.     break;
  222.   }
  223.   char buf[100];
  224.   sprintf(buf, "%d %s %dn", nodeid, text, ops);
  225.   int len = strlen(buf);
  226.   // assume SIGPIPE already ignored
  227.   if (write(statSock, buf, len) != len) {
  228.     if (statState != statError) {
  229.       ndbout_c("stat: write failed: %s", strerror(errno));
  230.       statState = statError;
  231.     }
  232.     (void)close(statSock);
  233.     (void)NdbMutex_Unlock(&statMutex);
  234.     return;
  235.   }
  236.   (void)NdbMutex_Unlock(&statMutex);
  237. }
  238. #endif // CEBIT_STAT
  240. static void 
  241. resetThreads(ThreadData* pt){
  242.   for (unsigned int i = 0; i < tNoOfThreads; i++){
  243.     pt[i].threadReady = 0;
  244.     pt[i].threadResult = 0;
  245.     pt[i].threadStart = stIdle;
  246.   }
  247. }
  249. static int 
  250. checkThreadResults(ThreadData* pt){
  251.   for (unsigned int i = 0; i < tNoOfThreads; i++){
  252.     if(pt[i].threadResult != 0){
  253.       ndbout_c("Thread%d reported fatal error %d", i, pt[i].threadResult);
  254.       return -1;
  255.     }
  256.   }
  257.   return 0;
  258. }
  260. static
  261. void 
  262. waitForThreads(ThreadData* pt)
  263. {
  264.   int cont = 1;
  265.   while (cont){
  266.     NdbSleep_MilliSleep(100);
  267.     cont = 0;
  268.     for (unsigned int i = 0; i < tNoOfThreads; i++){
  269.       if (pt[i].threadReady == 0) 
  270.     cont = 1;
  271.     }
  272.   }
  273. }
  275. static void 
  276. tellThreads(ThreadData* pt, StartType what)
  277. {
  278.   for (unsigned int i = 0; i < tNoOfThreads; i++) 
  279.     pt[i].threadStart = what;
  280. }
  282. NDB_COMMAND(flexBench, "flexBench", "flexBench", "flexbench", 65535)
  283. {
  284.   ndb_init();
  285.   ThreadData*           pThreadsData;
  286.   int                   tLoops = 0, i;
  287.   int                   returnValue = NDBT_OK;
  288.     
  289.   if (readArguments(argc, argv) != 0){
  290.     input_error();
  291.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  292.   }
  294.   if(useLongKeys){
  295.     longKeyAttrName = (char **) malloc(sizeof(char*) * tNoOfLongPK);
  296.     for (Uint32 i = 0; i < tNoOfLongPK; i++) {
  297.       longKeyAttrName[i] = (char *) malloc(strlen("KEYATTR  ") + 1);
  298.       memset(longKeyAttrName[i], 0, strlen("KEYATTR  ") + 1);
  299.       sprintf(longKeyAttrName[i], "KEYATTR%i", i);
  300.     }
  301.   }
  302.   
  303.   pThreadsData = new ThreadData[tNoOfThreads];
  304.  
  305.   ndbout << endl << "FLEXBENCH - Starting normal mode" << endl;
  306.   ndbout << "Perform benchmark of insert, update and delete transactions"<< endl;
  307.   ndbout << "  " << tNoOfThreads << " thread(s) " << endl;
  308.   ndbout << "  " << tNoOfLoops << " iterations " << endl;
  309.   ndbout << "  " << tNoOfTables << " table(s) and " << 1 << " operation(s) per transaction " <<endl;
  310.   ndbout << "  " << tNoOfAttributes << " attributes per table " << endl;
  311.   ndbout << "  " << tNoOfOperations << " transaction(s) per thread and round " << endl;
  312.   ndbout << "  " << tAttributeSize << " is the number of 32 bit words per attribute "<< endl;
  313.   ndbout << "  " << "Table(s) without logging: " << (Uint32)theTempTable << endl;
  314.   
  315.   if(useLongKeys)
  316.     ndbout << "  " << "Using long keys with " << tNoOfLongPK << " keys a' " << 
  317.       tSizeOfLongPK * 4 << " bytes each." << endl;
  318.   
  319.   ndbout << "  " << "Verification is " ; 
  320.   if(VerifyFlag) {
  321.       ndbout << "enabled" << endl ;
  322.   }else{
  323.       ndbout << "disabled" << endl ;
  324.   }
  325.   theErrorData.printSettings(ndbout);
  326.   
  327.   NdbThread_SetConcurrencyLevel(tNoOfThreads + 2);
  329.   Ndb* pNdb;
  330.   pNdb = new Ndb( "TEST_DB" );  
  331.   pNdb->init();
  333.   tNodeId = pNdb->getNodeId();
  334.   ndbout << "  NdbAPI node with id = " << tNodeId << endl;
  335.   ndbout << endl;
  336.   
  337.   ndbout << "Waiting for ndb to become ready..." <<endl;
  338.   if (pNdb->waitUntilReady(2000) != 0){
  339.     ndbout << "NDB is not ready" << endl;
  340.     ndbout << "Benchmark failed!" << endl;
  341.     returnValue = NDBT_FAILED;
  342.   }
  344.   if(returnValue == NDBT_OK){
  345.     if (createTables(pNdb) != 0){
  346.       returnValue = NDBT_FAILED;
  347.     }
  348.   }
  350.   if(returnValue == NDBT_OK){
  352.     sleepBeforeStartingTest(tSleepTime);
  353.     
  354.     /****************************************************************
  355.      *  Create threads.                                           *
  356.      ****************************************************************/
  357.     resetThreads(pThreadsData);
  358.     
  359.     for (i = 0; i < tNoOfThreads; i++){  
  360.       pThreadsData[i].threadNo = i;
  361.       pThreadsData[i].threadLife = NdbThread_Create(flexBenchThread,
  362.                                                     (void**)&pThreadsData[i],
  363.                                                     32768,
  364.                                                     "flexBenchThread",
  365.                                                     NDB_THREAD_PRIO_LOW);
  366.     }
  367.     
  368.     waitForThreads(pThreadsData);
  369.     
  370.     ndbout << endl <<  "All threads started" << endl << endl;
  371.     
  372.     /****************************************************************
  373.      * Execute program.                                             *
  374.      ****************************************************************/
  375.   
  376.     for(;;){
  378.       int loopCount = tLoops + 1;
  379.       ndbout << endl << "Loop # " << loopCount  << endl << endl;
  380.       
  381.       /****************************************************************
  382.        * Perform inserts.                                             *
  383.        ****************************************************************/
  384.       // Reset and start timer
  385.       START_TIMER;
  386.       // Give insert-command to all threads
  387.       resetThreads(pThreadsData);
  388.       tellThreads(pThreadsData, stInsert);
  389.       waitForThreads(pThreadsData);
  390.       if (checkThreadResults(pThreadsData) != 0){
  391.         ndbout << "Error: Threads failed in performing insert" << endl;
  392.         returnValue = NDBT_FAILED;
  393.         break;
  394.       }        
  395.       // stop timer and print results.
  396.       STOP_TIMER;
  397.       PRINT_TIMER("insert", tNoOfOperations*tNoOfThreads, tNoOfTables);
  398.       /****************************************************************
  399.       * Verify inserts.                                             *
  400.       ****************************************************************/
  401.       if (VerifyFlag) {
  402.       resetThreads(pThreadsData);
  403.       ndbout << "Verifying inserts...t" ;
  404.       tellThreads(pThreadsData, stVerify);
  405.       waitForThreads(pThreadsData);
  406.       if (checkThreadResults(pThreadsData) != 0){
  407.         ndbout << "Error: Threads failed while verifying inserts" << endl;
  408.         returnValue = NDBT_FAILED;
  409.         break;
  410.       }else{
  411.           ndbout << "ttOK" << endl << endl ;
  412.       }
  413.       }
  414.       
  415.       /****************************************************************
  416.        * Perform read.                                                *
  417.        ****************************************************************/
  418.       // Reset and start timer 
  419.       START_TIMER;
  420.       // Give read-command to all threads
  421.       resetThreads(pThreadsData);
  422.       tellThreads(pThreadsData, stRead);
  423.       waitForThreads(pThreadsData);
  424.       if (checkThreadResults(pThreadsData) != 0){
  425.         ndbout << "Error: Threads failed in performing read" << endl;
  426.         returnValue = NDBT_FAILED;
  427.         break;
  428.       }
  429.       // stop timer and print results.
  430.       STOP_TIMER;
  431.       PRINT_TIMER("read", tNoOfOperations*tNoOfThreads, tNoOfTables);
  432.       
  433.       /****************************************************************
  434.        * Perform update.                                              *
  435.        ****************************************************************/
  436.       // Reset and start timer
  437.       START_TIMER;
  438.       // Give insert-command to all threads
  439.       resetThreads(pThreadsData);
  440.       tellThreads(pThreadsData, stUpdate);
  441.       waitForThreads(pThreadsData);
  442.       if (checkThreadResults(pThreadsData) != 0){
  443.         ndbout << "Error: Threads failed in performing update" << endl;
  444.         returnValue = NDBT_FAILED;
  445.         break;
  446.       }
  447.       // stop timer and print results.
  448.       STOP_TIMER;
  449.       PRINT_TIMER("update", tNoOfOperations*tNoOfThreads, tNoOfTables);
  450.       
  451.       /****************************************************************
  452.       * Verify updates.                                             *
  453.       ****************************************************************/
  454.       if (VerifyFlag) {
  455.       resetThreads(pThreadsData);
  456.       ndbout << "Verifying updates...t" ;
  457.       tellThreads(pThreadsData, stVerify);
  458.       waitForThreads(pThreadsData);
  459.       if (checkThreadResults(pThreadsData) != 0){
  460.         ndbout << "Error: Threads failed while verifying updates" << endl;
  461.         returnValue = NDBT_FAILED;
  462.         break;
  463.       }else{
  464.           ndbout << "ttOK" << endl << endl ;
  465.       }
  466.       }
  467.       
  468.       /****************************************************************
  469.        * Perform read.                                             *
  470.        ****************************************************************/
  471.       // Reset and start timer
  472.       START_TIMER;
  473.       // Give insert-command to all threads
  474.       resetThreads(pThreadsData);
  475.       tellThreads(pThreadsData, stRead);
  476.       waitForThreads(pThreadsData);
  477.       if (checkThreadResults(pThreadsData) != 0){
  478.         ndbout << "Error: Threads failed in performing read" << endl;
  479.         returnValue = NDBT_FAILED;
  480.         break;
  481.       }
  482.       // stop timer and print results.
  483.       STOP_TIMER;
  484.       PRINT_TIMER("read", tNoOfOperations*tNoOfThreads, tNoOfTables);
  486.       /****************************************************************
  487.        * Perform delete.                                              *
  488.        ****************************************************************/
  489.       // Reset and start timer
  490.       START_TIMER;
  491.       // Give insert-command to all threads
  492.       resetThreads(pThreadsData);
  493.       tellThreads(pThreadsData, stDelete);
  494.       waitForThreads(pThreadsData);
  495.       if (checkThreadResults(pThreadsData) != 0){
  496.         ndbout << "Error: Threads failed in performing delete" << endl;
  497.         returnValue = NDBT_FAILED;
  498.         break;
  499.       }
  500.       // stop timer and print results.
  501.       STOP_TIMER;
  502.       PRINT_TIMER("delete", tNoOfOperations*tNoOfThreads, tNoOfTables);
  504.       /****************************************************************
  505.       * Verify deletes.                                              *
  506.       ****************************************************************/
  507.       if (VerifyFlag) {
  508.       resetThreads(pThreadsData);
  509.       ndbout << "Verifying tuple deletion..." ;
  510.       tellThreads(pThreadsData, stVerifyDelete);
  511.       waitForThreads(pThreadsData);
  512.       if (checkThreadResults(pThreadsData) != 0){
  513.           ndbout << "Error: Threads failed in verifying deletes" << endl;
  514.           returnValue = NDBT_FAILED;
  515.           break;
  516.       }else{ 
  517.           ndbout << "ttOK" << endl << endl ;
  518.       }
  519.       }
  521.       ndbout << "--------------------------------------------------" << endl;
  523.       tLoops++;
  525.       if ( 0 != tNoOfLoops && tNoOfLoops <= tLoops ) 
  526.         break;
  527.       theErrorData.printErrorCounters();
  528.     }
  529.     
  530.     resetThreads(pThreadsData);
  531.     tellThreads(pThreadsData, stStop);
  532.     waitForThreads(pThreadsData);
  534.     void * tmp;
  535.     for(i = 0; i<tNoOfThreads; i++){
  536.       NdbThread_WaitFor(pThreadsData[i].threadLife, &tmp);
  537.       NdbThread_Destroy(&pThreadsData[i].threadLife);
  538.     }
  539.   }
  541.   if (useLongKeys == true) {
  542.     // Only free these areas if they have been allocated
  543.     // Otherwise cores will happen
  544.     for (i = 0; i < tNoOfLongPK; i++)
  545.       free(longKeyAttrName[i]);
  546.     free(longKeyAttrName);
  547.   } // if
  549.   delete [] pThreadsData;
  550.   delete pNdb;
  551.   theErrorData.printErrorCounters();
  552.   return NDBT_ProgramExit(returnValue);
  553. }
  554. ////////////////////////////////////////
  557. unsigned long get_hash(unsigned long * hash_key, int len)
  558. {
  559.   unsigned long hash_value = 147;
  560.   unsigned h_key;
  561.   int i;
  562.   for (i = 0; i < len; i++)
  563.     {
  564.       h_key = hash_key[i];
  565.       hash_value = (hash_value << 5) + hash_value + (h_key & 255);
  566.       hash_value = (hash_value << 5) + hash_value + ((h_key >> 8) & 255);
  567.       hash_value = (hash_value << 5) + hash_value + ((h_key >> 16) & 255);
  568.       hash_value = (hash_value << 5) + hash_value + ((h_key >> 24) & 255);
  569.     }
  570.   return hash_value;
  571. }
  573. // End of warming up phase
  577. static void* flexBenchThread(void* pArg)
  578. {
  579.   ThreadData*       pThreadData = (ThreadData*)pArg;
  580.   unsigned int      threadNo, threadBase;
  581.   Ndb*              pNdb = NULL ;
  582.   NdbConnection     *pTrans = NULL ;
  583.   NdbOperation**    pOps = NULL ;
  584.   StartType         tType ;
  585.   StartType         tSaveType ;
  586.   NdbRecAttr*       tTmp = NULL ;
  587.   int*              attrValue = NULL ;
  588.   int*              attrRefValue = NULL ;
  589.   int               check = 0 ;
  590.   int               loopCountOps, loopCountTables, loopCountAttributes;
  591.   int               tAttemptNo = 0;
  592.   int               tRetryAttempts = 20;
  593.   int               tResult = 0;
  594.   int               tSpecialTrans = 0;
  595.   int               nRefLocalOpOffset = 0 ;
  596.   int               nReadBuffSize = 
  597.     tNoOfTables * tNoOfAttributes * sizeof(int) * tAttributeSize ;
  598.   int               nRefBuffSize = 
  599.     tNoOfOperations * tNoOfAttributes * sizeof(int) * tAttributeSize ;
  600.   unsigned***           longKeyAttrValue;
  603.   threadNo = pThreadData->threadNo ;
  605.   attrValue = (int*)malloc(nReadBuffSize) ;
  606.   attrRefValue = (int*)malloc(nRefBuffSize) ;
  607.   pOps = (NdbOperation**)malloc(tNoOfTables*sizeof(NdbOperation*)) ;
  608.   pNdb = new Ndb( "TEST_DB" );
  609.   
  610.   if(!attrValue || !attrRefValue || !pOps || !pNdb){
  611.     // Check allocations to make sure we got all the memory we asked for
  612.     ndbout << "One or more memory allocations failed when starting thread #";
  613.     ndbout << threadNo << endl ;
  614.     ndbout << "Thread #" << threadNo << " will now exit" << endl ;
  615.     tResult = 13 ;
  616.     free(attrValue) ;
  617.     free(attrRefValue) ;
  618.     free(pOps) ;
  619.     delete pNdb ;
  620.     return 0; // thread exits
  621.   }
  622.   
  623.   pNdb->init();
  624.   pNdb->waitUntilReady();
  626.   // To make sure that two different threads doesn't operate on the same record
  627.   // Calculate an "unique" number to use as primary key
  628.   threadBase = (threadNo * 2000000) + (tNodeId * 260000000);
  629.   
  630.   if(useLongKeys){
  631.     // Allocate and populate the longkey array.
  632.     longKeyAttrValue = (unsigned ***) malloc(sizeof(unsigned**) * tNoOfOperations );
  633.     Uint32 n;
  634.     for (n = 0; n < tNoOfOperations; n++)
  635.       longKeyAttrValue[n] = (unsigned **) malloc(sizeof(unsigned*) * tNoOfLongPK );
  636.     for (n = 0; n < tNoOfOperations; n++){
  637.       for (Uint32 i = 0; i < tNoOfLongPK ; i++) {
  638. longKeyAttrValue[n][i] = (unsigned *) malloc(sizeof(unsigned) * tSizeOfLongPK);
  639. memset(longKeyAttrValue[n][i], 0, sizeof(unsigned) * tSizeOfLongPK);
  640. for(Uint32 j = 0; j < tSizeOfLongPK; j++) {
  641.   // Repeat the unique value to fill up the long key.
  642.   longKeyAttrValue[n][i][j] = threadBase + n; 
  643. }
  644.       }
  645.     }
  646.   }
  648.   int nRefOpOffset = 0 ;
  649.   //Assign reference attribute values to memory
  650.   for(Uint32 ops = 1 ; ops < tNoOfOperations ; ops++){
  651.     // Calculate offset value before going into the next loop
  652.     nRefOpOffset = tAttributeSize*tNoOfAttributes*(ops-1) ; 
  653.     for(Uint32 a = 0 ; a < tNoOfAttributes ; a++){
  654.       *(int*)&attrRefValue[nRefOpOffset + tAttributeSize*a] = 
  655. (int)(threadBase + ops + a) ;
  656.     }
  657.   }
  659. #ifdef CEBIT_STAT
  660.   // ops not yet reported
  661.   int statOps = 0;
  662. #endif
  663.   for (;;) {
  664.     pThreadData->threadResult = tResult; // Report error to main thread, 
  665.     // normally tResult is set to 0
  666.     pThreadData->threadReady = 1;
  668.     while (pThreadData->threadStart == stIdle){
  669.       NdbSleep_MilliSleep(100);
  670.     }//while
  672.     // Check if signal to exit is received
  673.     if (pThreadData->threadStart == stStop){
  674.       pThreadData->threadReady = 1;
  675.       // ndbout_c("Thread%d is stopping", threadNo);
  676.       // In order to stop this thread, the main thread has signaled
  677.       // stStop, break out of the for loop so that destructors
  678.       // and the proper exit functions are called
  679.       break;
  680.     }//if
  682.     tType = pThreadData->threadStart;
  683.     tSaveType = tType;
  684.     pThreadData->threadStart = stIdle;
  686.     // Start transaction, type of transaction
  687.     // is received in the array ThreadStart
  688.     loopCountOps = tNoOfOperations;
  689.     loopCountTables = tNoOfTables;
  690.     loopCountAttributes = tNoOfAttributes;
  692.     for (int count = 1; count < loopCountOps && tResult == 0;){
  694.       pTrans = pNdb->startTransaction();
  695.       if (pTrans == NULL) {
  696. // This is a fatal error, abort program
  697. ndbout << "Could not start transaction in thread" << threadNo;
  698. ndbout << endl;
  699. ndbout << pNdb->getNdbError() << endl;
  700. tResult = 1; // Indicate fatal error
  701. break; // Break out of for loop
  702.       }
  704.       // Calculate the current operation offset in the reference array
  705.       nRefLocalOpOffset = tAttributeSize*tNoOfAttributes*(count - 1) ;
  707.       for (int countTables = 0;
  708.    countTables < loopCountTables && tResult == 0;
  709.    countTables++) {
  711. pOps[countTables] = pTrans->getNdbOperation(tableName[countTables]);  
  712. if (pOps[countTables] == NULL) {
  713.   // This is a fatal error, abort program
  714.   ndbout << "getNdbOperation: " << pTrans->getNdbError();
  715.   tResult = 2; // Indicate fatal error
  716.   break;
  717. }//if
  719. switch (tType) {
  720. case stInsert:          // Insert case
  721.   if (theWriteFlag == 1 && theDirtyFlag == 1)
  722.     pOps[countTables]->dirtyWrite();
  723.   else if (theWriteFlag == 1)
  724.     pOps[countTables]->writeTuple();
  725.   else
  726.     pOps[countTables]->insertTuple();
  727.   break;
  728. case stRead:            // Read Case
  729.   if (theSimpleFlag == 1)
  730.     pOps[countTables]->simpleRead();
  731.   else if (theDirtyFlag == 1)
  732.     pOps[countTables]->dirtyRead();
  733.   else
  734.     pOps[countTables]->readTuple();
  735.   break;
  736. case stUpdate:          // Update Case
  737.   if (theWriteFlag == 1 && theDirtyFlag == 1)
  738.     pOps[countTables]->dirtyWrite();
  739.   else if (theWriteFlag == 1)
  740.     pOps[countTables]->writeTuple();
  741.   else if (theDirtyFlag == 1)
  742.     pOps[countTables]->dirtyUpdate();
  743.   else
  744.     pOps[countTables]->updateTuple();
  745.   break;
  746. case stDelete:          // Delete Case
  747.   pOps[countTables]->deleteTuple();
  748.   break;
  749. case stVerify:
  750.   pOps[countTables]->readTuple();
  751.   break;
  752. case stVerifyDelete:
  753.   pOps[countTables]->readTuple();
  754.   break;
  755. default:
  756.   assert(false);
  757. }//switch
  760. if(useLongKeys){
  761.   // Loop the equal call so the complete key is send to the kernel.
  762.   for(Uint32 i = 0; i < tNoOfLongPK; i++) 
  763.     pOps[countTables]->equal(longKeyAttrName[i], 
  764.      (char *)longKeyAttrValue[count - 1][i], tSizeOfLongPK*4); 
  765. }
  766. else 
  767.   pOps[countTables]->equal((char*)attrName[0], 
  768.    (char*)&attrRefValue[nRefLocalOpOffset]);
  770. if (tType == stInsert || tType == stUpdate){
  771.   for (int ca = 1; ca < loopCountAttributes; ca++){
  772.     pOps[countTables]->setValue((char*)attrName[ca],
  773. (char*)&attrRefValue[nRefLocalOpOffset + tAttributeSize*ca]);
  774.   }//for
  775. } else if (tType == stRead || stVerify == tType) {
  776.   int nTableOffset = tAttributeSize * 
  777.     loopCountAttributes *
  778.     countTables ;
  779.   for (int ca = 1; ca < loopCountAttributes; ca++) {
  780.     tTmp = pOps[countTables]->getValue((char*)attrName[ca], 
  781.        (char*)&attrValue[nTableOffset + tAttributeSize*ca]);
  782.   }//for
  783. } else if (stVerifyDelete == tType) {
  784.   if(useLongKeys){
  785.     int nTableOffset = tAttributeSize *
  786.       loopCountAttributes *
  787.       countTables ;
  788.     tTmp = pOps[countTables]->getValue(longKeyAttrName[0], 
  789.        (char*)&attrValue[nTableOffset]);
  790.   } else {
  791.     int nTableOffset = tAttributeSize *
  792.       loopCountAttributes *
  793.       countTables ;
  794.     tTmp = pOps[countTables]->getValue((char*)attrName[0], 
  795.        (char*)&attrValue[nTableOffset]);
  796.   }
  797. }//if
  798.       }//for Tables loop
  800.       if (tResult != 0)
  801. break;
  802.       check = pTrans->execute(Commit);
  804.       // Decide what kind of error this is
  805.       if ((tSpecialTrans == 1) &&
  806.   (check == -1)) {
  807. // --------------------------------------------------------------------
  808. // A special transaction have been executed, change to check = 0 in
  809. // certain situations.
  810. // --------------------------------------------------------------------
  811. switch (tType) {
  812. case stInsert:          // Insert case
  813.   if (630 == pTrans->getNdbError().code ) {
  814.     check = 0;
  815.     ndbout << "Insert with 4007 was successful" << endl;
  816.   }//if
  817.   break;
  818. case stDelete:          // Delete Case
  819.   if (626 == pTrans->getNdbError().code ) {
  820.     check = 0;
  821.     ndbout << "Delete with 4007 was successful" << endl;
  822.   }//if
  823.   break;
  824. default:
  825.   assert(false);
  826. }//switch
  827.       }//if
  828.       tSpecialTrans = 0;
  829.       if (check == -1) {
  830. if ((stVerifyDelete == tType) && 
  831.     (626 == pTrans->getNdbError().code)) {
  832.   // ----------------------------------------------
  833.   // It's good news - the deleted tuple is gone, 
  834.   // so reset "check" flag
  835.   // ----------------------------------------------
  836.   check = 0 ;
  837. } else {
  838.   int retCode = 
  839.     theErrorData.handleErrorCommon(pTrans->getNdbError());
  840.   if (retCode == 1) {
  841.     ndbout_c("execute: %d, %d, %s", count, tType, 
  842.      pTrans->getNdbError().message );
  843.     ndbout_c("Error code = %d", pTrans->getNdbError().code );
  844.     tResult = 20;
  845.   } else if (retCode == 2) {
  846.     ndbout << "4115 should not happen in flexBench" << endl;
  847.     tResult = 20;
  848.   } else if (retCode == 3) {
  849.     // --------------------------------------------------------------------
  850.     // We are not certain if the transaction was successful or not.
  851.     // We must reexecute but might very well find that the transaction
  852.     // actually was updated. Updates and Reads are no problem here. Inserts
  853.     // will not cause a problem if error code 630 arrives. Deletes will
  854.     // not cause a problem if 626 arrives.
  855.     // --------------------------------------------------------------------
  856.     if ((tType == stInsert) || (tType == stDelete)) {
  857.       tSpecialTrans = 1;
  858.     }//if
  859.   }//if
  860. }//if
  861.       }//if
  862.       // Check if retries should be made
  863.       if (check == -1 && tResult == 0) {
  864. if (tAttemptNo < tRetryAttempts){
  865.   tAttemptNo++;
  866. } else {
  867.   // --------------------------------------------------------------------
  868.   // Too many retries have been made, report error and break out of loop
  869.   // --------------------------------------------------------------------
  870.   ndbout << "Thread" << threadNo;
  871.   ndbout << ": too many errors reported" << endl;
  872.   tResult = 10;
  873.   break;
  874. }//if            
  875.       }//if
  877.       if (check == 0){
  878. // Go to the next record
  879. count++;
  880. tAttemptNo = 0;
  881. #ifdef CEBIT_STAT
  882. // report successful ops
  883. if (statEnable) {
  884.   statOps += loopCountTables;
  885.   if (statOps >= statFreq) {
  886.     statReport(tType, statOps);
  887.     statOps = 0;
  888.   }//if
  889. }//if
  890. #endif
  891.       }//if
  893.       if (stVerify == tType && 0 == check){
  894. int nTableOffset = 0 ;
  895. for (int a = 1 ; a < loopCountAttributes ; a++){
  896.   for (int tables = 0 ; tables < loopCountTables ; tables++){
  897.     nTableOffset = tables*loopCountAttributes*tAttributeSize ;
  898.     if (*(int*)&attrValue[nTableOffset + tAttributeSize*a] != *(int*)&attrRefValue[nRefLocalOpOffset + tAttributeSize*a]){
  899.       ndbout << "Error in verify:" << endl ;
  900.       ndbout << "attrValue[" << nTableOffset + tAttributeSize*a << "] = " << attrValue[a] << endl ;
  901.       ndbout << "attrRefValue[" << nRefLocalOpOffset + tAttributeSize*a << "]" << attrRefValue[nRefLocalOpOffset + tAttributeSize*a] << endl ;
  902.       tResult = 11 ;
  903.       break ;
  904.     }//if
  905.   }//for
  906. }//for
  907.       }// if(stVerify ... )
  908.       pNdb->closeTransaction(pTrans) ;  
  909.     }// operations loop
  910. #ifdef CEBIT_STAT
  911.     // report remaining successful ops
  912.     if (statEnable) {
  913.       if (statOps > 0) {
  914. statReport(tType, statOps);
  915. statOps = 0;
  916.       }//if
  917.     }//if
  918. #endif
  919.   }
  920.   delete pNdb;
  921.   free(attrValue) ;
  922.   free(attrRefValue) ;
  923.   free(pOps) ;
  925.   if (useLongKeys == true) {
  926.     // Only free these areas if they have been allocated
  927.     // Otherwise cores will occur
  928.     for (Uint32 n = 0; n < tNoOfOperations; n++){
  929.       for (Uint32 i = 0; i < tNoOfLongPK; i++) {
  930. free(longKeyAttrValue[n][i]);
  931.       }
  932.       free(longKeyAttrValue[n]);
  933.     }
  934.     free(longKeyAttrValue);
  935.   } // if
  937.   return NULL; // Thread exits
  938. }
  941. static int readArguments(int argc, const char** argv)
  942. {
  944.   int i = 1;
  945.   while (argc > 1){
  946.     if (strcmp(argv[i], "-t") == 0){
  947.       tNoOfThreads = atoi(argv[i+1]);
  948.       if ((tNoOfThreads < 1)) 
  949.         return -1;
  950.       argc -= 1;
  951.       i++;
  952.     }else if (strcmp(argv[i], "-o") == 0){
  953.       tNoOfOperations = atoi(argv[i+1]);
  954.       if (tNoOfOperations < 1) 
  955.         return -1;;
  956.       argc -= 1;
  957.       i++;
  958.     }else if (strcmp(argv[i], "-a") == 0){
  959.       tNoOfAttributes = atoi(argv[i+1]);
  960.       if ((tNoOfAttributes < 2) || (tNoOfAttributes > MAXATTR)) 
  961.         return -1;
  962.       argc -= 1;
  963.       i++;
  964.     }else if (strcmp(argv[i], "-lkn") == 0){
  965.      tNoOfLongPK = atoi(argv[i+1]);
  966.      useLongKeys = true;
  967.       if ((tNoOfLongPK < 1) || (tNoOfLongPK > MAXNOLONGKEY) || 
  968.   (tNoOfLongPK * tSizeOfLongPK) > MAXLONGKEYTOTALSIZE){
  969.        ndbout << "Argument -lkn is not in the proper range." << endl;  
  970. return -1;
  971.       }
  972.       argc -= 1;
  973.       i++;
  974.     }else if (strcmp(argv[i], "-lks") == 0){
  975.       tSizeOfLongPK = atoi(argv[i+1]);
  976.       useLongKeys = true;
  977.       if ((tSizeOfLongPK < 1) || (tNoOfLongPK * tSizeOfLongPK) > MAXLONGKEYTOTALSIZE){
  978. ndbout << "Argument -lks is not in the proper range 1 to " << 
  979.   MAXLONGKEYTOTALSIZE << endl;
  980.         return -1;
  981.       }
  982.       argc -= 1;
  983.       i++;
  984.     }else if (strcmp(argv[i], "-c") == 0){
  985.       tNoOfTables = atoi(argv[i+1]);
  986.       if ((tNoOfTables < 1) || (tNoOfTables > MAXTABLES)) 
  987.         return -1;
  988.       argc -= 1;
  989.       i++;
  990.     }else if (strcmp(argv[i], "-stdtables") == 0){
  991.       theStdTableNameFlag = 1;
  992.     }else if (strcmp(argv[i], "-l") == 0){
  993.       tNoOfLoops = atoi(argv[i+1]);
  994.       if ((tNoOfLoops < 0) || (tNoOfLoops > 100000)) 
  995.         return -1;
  996.       argc -= 1;
  997.       i++;
  998.     }else if (strcmp(argv[i], "-s") == 0){
  999.       tAttributeSize = atoi(argv[i+1]);
  1000.       if ((tAttributeSize < 1) || (tAttributeSize > MAXATTRSIZE)) 
  1001.         return -1;
  1002.       argc -= 1;
  1003.       i++;
  1004.     }else if (strcmp(argv[i], "-sleep") == 0){
  1005.       tSleepTime = atoi(argv[i+1]);
  1006.       if ((tSleepTime < 1) || (tSleepTime > 3600)) 
  1007.         return -1;
  1008.       argc -= 1;
  1009.       i++;
  1010.     }else if (strcmp(argv[i], "-simple") == 0){
  1011.       theSimpleFlag = 1;
  1012.     }else if (strcmp(argv[i], "-write") == 0){
  1013.       theWriteFlag = 1;
  1014.     }else if (strcmp(argv[i], "-dirty") == 0){
  1015.       theDirtyFlag = 1;
  1016.     }else if (strcmp(argv[i], "-no_table_create") == 0){
  1017.       theTableCreateFlag = 1;
  1018.     }else if (strcmp(argv[i], "-temp") == 0){
  1019.       theTempTable = true;
  1020.     }else if (strcmp(argv[i], "-noverify") == 0){
  1021.       VerifyFlag = false ;
  1022.     }else if (theErrorData.parseCmdLineArg(argv, i) == true){
  1023.       ; //empty, updated in errorArg(..)
  1024.     }else if (strcmp(argv[i], "-verify") == 0){
  1025.       VerifyFlag = true ;
  1026. #ifdef CEBIT_STAT
  1027.     }else if (strcmp(argv[i], "-statserv") == 0){
  1028.       if (! (argc > 2))
  1029. return -1;
  1030.       const char *p = argv[i+1];
  1031.       const char *q = strrchr(p, ':');
  1032.       if (q == 0)
  1033. return -1;
  1034.       BaseString::snprintf(statHost, sizeof(statHost), "%.*s", q-p, p);
  1035.       statPort = atoi(q+1);
  1036.       statEnable = true;
  1037.       argc -= 1;
  1038.       i++;
  1039.     }else if (strcmp(argv[i], "-statfreq") == 0){
  1040.       if (! (argc > 2))
  1041. return -1;
  1042.       statFreq = atoi(argv[i+1]);
  1043.       if (statFreq < 1)
  1044. return -1;
  1045.       argc -= 1;
  1046.       i++;
  1047. #endif
  1048.     }else{       
  1049.       return -1;
  1050.     }
  1051.     argc -= 1;
  1052.     i++;
  1053.   }
  1054.   return 0;
  1055. }
  1057. static void sleepBeforeStartingTest(int seconds){
  1058.   if (seconds > 0){
  1059.       ndbout << "Sleeping(" <<seconds << ")...";
  1060.       NdbSleep_SecSleep(seconds);
  1061.       ndbout << " done!" << endl;
  1062.     }
  1063. }
  1066. static int
  1067. createTables(Ndb* pMyNdb){
  1068.   int i;
  1069.   for (i = 0; i < tNoOfAttributes; i++){
  1070.     BaseString::snprintf(attrName[i], MAXSTRLEN, "COL%d", i);
  1071.   }
  1073.   // Note! Uses only uppercase letters in table name's
  1074.   // so that we can look at the tables with SQL
  1075.   for (i = 0; i < tNoOfTables; i++){
  1076.     if (theStdTableNameFlag == 0){
  1077.       BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d_%d", i, 
  1078.        (int)(NdbTick_CurrentMillisecond() / 1000));
  1079.     } else {
  1080.       BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d", i);
  1081.     }
  1082.   }
  1083.   
  1084.   for(i = 0; i < tNoOfTables; i++){
  1085.     ndbout << "Creating " << tableName[i] << "... ";
  1086.     
  1087.     NdbDictionary::Table tmpTable(tableName[i]);
  1088.     
  1089.     tmpTable.setStoredTable(!theTempTable);
  1090.     
  1091.     if(useLongKeys){
  1092.       for(Uint32 i = 0; i < tNoOfLongPK; i++) {
  1093. NdbDictionary::Column col(longKeyAttrName[i]);
  1094. col.setType(NdbDictionary::Column::Unsigned);
  1095. col.setLength(tSizeOfLongPK);
  1096. col.setPrimaryKey(true);
  1097. tmpTable.addColumn(col);
  1098.       }
  1099.     } else {
  1100.       NdbDictionary::Column col(attrName[0]);
  1101.       col.setType(NdbDictionary::Column::Unsigned);
  1102.       col.setLength(1);
  1103.       col.setPrimaryKey(true);
  1104.       tmpTable.addColumn(col);
  1105.     }
  1106.     
  1107.     
  1108.     NdbDictionary::Column col;
  1109.     col.setType(NdbDictionary::Column::Unsigned);
  1110.     col.setLength(tAttributeSize);
  1111.     for (unsigned j = 1; j < tNoOfAttributes; j++){
  1112.       col.setName(attrName[j]);
  1113.       tmpTable.addColumn(col);
  1114.     }
  1115.     
  1116.     if(pMyNdb->getDictionary()->createTable(tmpTable) == -1){
  1117.       return -1;
  1118.     }
  1119.     ndbout << "done" << endl;
  1120.   }
  1121.   
  1122.   return 0;
  1123. }
  1125.       
  1126. static void input_error(){
  1127.   ndbout << endl << "Invalid argument!" << endl;
  1128.   ndbout << endl << "Arguments:" << endl;
  1129.   ndbout << "   -t Number of threads to start, default 1" << endl;
  1130.   ndbout << "   -o Number of operations per loop, default 500" << endl;
  1131.   ndbout << "   -l Number of loops to run, default 1, 0=infinite" << endl;
  1132.   ndbout << "   -a Number of attributes, default 25" << endl;
  1133.   ndbout << "   -c Number of tables, default 1" << endl;
  1134.   ndbout << "   -s Size of each attribute, default 1 (Primary Key is always of size 1," << endl;
  1135.   ndbout << "      independent of this value)" << endl;
  1136.   ndbout << "   -lkn Number of long primary keys, default 1" << endl;
  1137.   ndbout << "   -lks Size of each long primary key, default 1" << endl;
  1139.   ndbout << "   -simple Use simple read to read from database" << endl;
  1140.   ndbout << "   -dirty Use dirty read to read from database" << endl;
  1141.   ndbout << "   -write Use writeTuple in insert and update" << endl;
  1142.   ndbout << "   -stdtables Use standard table names" << endl;
  1143.   ndbout << "   -no_table_create Don't create tables in db" << endl;
  1144.   ndbout << "   -sleep Sleep a number of seconds before running the test, this" << endl;
  1145.   ndbout << "    can be used so that another flexBench have time to create tables" << endl;
  1146.   ndbout << "   -temp Use tables without logging" << endl;
  1147.   ndbout << "   -verify Verify inserts, updates and deletes" << endl ;
  1148.   theErrorData.printCmdLineArgs(ndbout);
  1149.   ndbout << endl <<"Returns:" << endl;
  1150.   ndbout << "t 0 - Test passed" << endl;
  1151.   ndbout << "t 1 - Test failed" << endl;
  1152.   ndbout << "t 2 - Invalid arguments" << endl << endl;
  1153. }
  1155. // vim: set sw=2: