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

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

MySQL数据库

开发平台：

Visual C++

flexTT.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. #include <ndb_global.h>
  20. #include <NdbApi.hpp>
  21. #include <NdbSchemaCon.hpp>
  22. #include <NdbMain.h>
  23. #include <md5_hash.hpp>
  25. #include <NdbThread.h>
  26. #include <NdbSleep.h>
  27. #include <NdbTick.h>
  28. #include <NdbOut.hpp>
  29. #include <NdbTimer.hpp>
  31. #include <NdbTest.hpp>
  32. #include <NDBT_Error.hpp>
  34. #define MAX_PARTS 4 
  35. #define MAX_SEEK 16 
  36. #define MAXSTRLEN 16 
  37. #define MAXATTR 64
  38. #define MAXTABLES 64
  39. #define MAXTHREADS 128
  40. #define MAXPAR 1024
  41. #define MAXATTRSIZE 1000
  42. #define PKSIZE 1
  45. #ifdef NDB_WIN32
  46. inline long lrand48(void) { return rand(); };
  47. #endif
  50. enum StartType { 
  51.   stIdle, 
  52.   stInsert,
  53.   stRead,
  54.   stUpdate,
  55.   stDelete, 
  56.   stStop 
  57. } ;
  59. struct ThreadNdb
  60. {
  61.   int threadNo;
  62.   Ndb* threadNdb;
  63.   Uint32 threadBase;
  64.   Uint32 threadLoopCounter;
  65.   Uint32 threadNextStart;
  66.   Uint32 threadStop;
  67.   Uint32 threadLoopStop;
  68.   Uint32 threadIncrement;
  69.   Uint32 threadNoCompleted;
  70.   bool   threadCompleted;
  71.   StartType threadStartType;
  72. };
  74. struct TransNdb
  75. {
  76.   char transRecord[128];
  77.   Ndb* transNdb;
  78.   StartType  transStartType;
  79.   Uint32     vpn_number;
  80.   Uint32     vpn_identity;
  81.   Uint32     transErrorCount;
  82.   NdbOperation* transOperation;
  83.   ThreadNdb* transThread;
  84. };
  86. extern "C" { static void* threadLoop(void*); }
  87. static void setAttrNames(void);
  88. static void setTableNames(void);
  89. static int readArguments(int argc, const char** argv);
  90. static int createTables(Ndb*);
  91. static bool defineOperation(NdbConnection* aTransObject, TransNdb*,
  92.                             Uint32 vpn_nb, Uint32 vpn_id);
  93. static bool executeTransaction(TransNdb* transNdbRef);
  94. static StartType random_choice();
  95. static void execute(StartType aType);
  96. static bool executeThread(ThreadNdb*, TransNdb*);
  97. static void executeCallback(int result, NdbConnection* NdbObject,
  98.                             void* aObject);
  99. static bool error_handler(const NdbError & err) ;
  100. static Uint32 getKey(Uint32, Uint32) ;
  101. static void input_error();
  102.                                       
  103. ErrorData * flexTTErrorData;
  105. static NdbThread*                       threadLife[MAXTHREADS];
  106. static int                              tNodeId;
  107. static int                              ThreadReady[MAXTHREADS];
  108. static StartType                        ThreadStart[MAXTHREADS];
  109. static char                             tableName[1][MAXSTRLEN+1];
  110. static char                             attrName[5][MAXSTRLEN+1];
  112. // Program Parameters
  113. static bool                             tInsert = false;
  114. static bool                             tDelete = false;
  115. static bool                             tReadUpdate = true;
  116. static int                              tUpdateFreq = 20;
  117. static bool                             tLocal = false;
  118. static int                              tLocalPart = 0;
  119. static int                              tMinEvents = 0;
  120. static int                              tSendForce = 0;
  121. static int                              tNoOfLoops = 1;
  122. static Uint32                           tNoOfThreads = 1;
  123. static Uint32                           tNoOfParallelTrans = 32;
  124. static Uint32                           tNoOfTransactions = 500;
  125. static Uint32                           tLoadFactor = 80;
  126. static bool                             tempTable = false;
  127. static bool                             startTransGuess = true;
  129. //Program Flags
  130. static int                              theSimpleFlag = 0;
  131. static int                              theDirtyFlag = 0;
  132. static int                              theWriteFlag = 0;
  133. static int                              theTableCreateFlag = 1;
  135. #define START_REAL_TIME
  136. #define STOP_REAL_TIME
  137. #define START_TIMER { NdbTimer timer; timer.doStart();
  138. #define STOP_TIMER timer.doStop();
  139. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); }; 
  141. static void 
  142. resetThreads(){
  144.   for (int i = 0; i < tNoOfThreads ; i++) {
  145.     ThreadReady[i] = 0;
  146.     ThreadStart[i] = stIdle;
  147.   }//for
  148. }
  150. static void 
  151. waitForThreads(void)
  152. {
  153.   int cont = 0;
  154.   do {
  155.     cont = 0;
  156.     NdbSleep_MilliSleep(20);
  157.     for (int i = 0; i < tNoOfThreads ; i++) {
  158.       if (ThreadReady[i] == 0) {
  159.         cont = 1;
  160.       }//if
  161.     }//for
  162.   } while (cont == 1);
  163. }
  165. static void 
  166. tellThreads(StartType what)
  167. {
  168.   for (int i = 0; i < tNoOfThreads ; i++) 
  169.     ThreadStart[i] = what;
  170. }
  172. NDB_COMMAND(flexTT, "flexTT", "flexTT", "flexTT", 65535)
  173. {
  174.   ndb_init();
  175.   ThreadNdb*            pThreadData;
  176.   int                   returnValue = NDBT_OK;
  177.   int i;
  178.   flexTTErrorData = new ErrorData;
  179.   flexTTErrorData->resetErrorCounters();
  181.   if (readArguments(argc, argv) != 0){
  182.     input_error();
  183.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  184.   }
  186.   pThreadData = new ThreadNdb[MAXTHREADS];
  188.   ndbout << endl << "FLEXTT - Starting normal mode" << endl;
  189.   ndbout << "Perform TimesTen benchmark" << endl;
  190.   ndbout << "  " << tNoOfThreads << " number of concurrent threads " << endl;
  191.   ndbout << "  " << tNoOfParallelTrans;
  192.   ndbout << " number of parallel transaction per thread " << endl;
  193.   ndbout << "  " << tNoOfTransactions << " transaction(s) per round " << endl;
  194.   ndbout << "  " << tNoOfLoops << " iterations " << endl;
  195.   ndbout << "  " << "Update Frequency is " << tUpdateFreq << "%" << endl;
  196.   ndbout << "  " << "Load Factor is " << tLoadFactor << "%" << endl;
  197.   if (tLocal == true) {
  198.     ndbout << "  " << "We only use Local Part = ";
  199.     ndbout << tLocalPart << endl;
  200.   }//if
  201.   if (tempTable == true) {
  202.     ndbout << "  Tables are without logging " << endl;
  203.   } else {
  204.     ndbout << "  Tables are with logging " << endl;
  205.   }//if
  206.   if (startTransGuess == true) {
  207.     ndbout << "  Transactions are executed with hint provided" << endl;
  208.   } else {
  209.     ndbout << "  Transactions are executed with round robin scheme" << endl;
  210.   }//if
  211.   if (tSendForce == 0) {
  212.     ndbout << "  No force send is used, adaptive algorithm used" << endl;
  213.   } else if (tSendForce == 1) {
  214.     ndbout << "  Force send used" << endl;
  215.   } else {
  216.     ndbout << "  No force send is used, adaptive algorithm disabled" << endl;
  217.   }//if
  219.   ndbout << endl;
  221.   /* print Setting */
  222.   flexTTErrorData->printSettings(ndbout);
  224.   NdbThread_SetConcurrencyLevel(2 + tNoOfThreads);
  226.   setAttrNames();
  227.   setTableNames();
  229.   Ndb * pNdb = new Ndb("TEST_DB");      
  230.   pNdb->init();
  231.   tNodeId = pNdb->getNodeId();
  233.   ndbout << "  NdbAPI node with id = " << pNdb->getNodeId() << endl;
  234.   ndbout << endl;
  235.   
  236.   ndbout << "Waiting for ndb to become ready..." <<endl;
  237.   if (pNdb->waitUntilReady(2000) != 0){
  238.     ndbout << "NDB is not ready" << endl;
  239.     ndbout << "Benchmark failed!" << endl;
  240.     returnValue = NDBT_FAILED;
  241.   }
  243.   if(returnValue == NDBT_OK){
  244.     if (createTables(pNdb) != 0){
  245.       returnValue = NDBT_FAILED;
  246.     }
  247.   }
  249.   if(returnValue == NDBT_OK){
  250.     /****************************************************************
  251.      *  Create NDB objects.                                   *
  252.      ****************************************************************/
  253.     resetThreads();
  254.     for (i = 0; i < tNoOfThreads ; i++) {
  255.       pThreadData[i].threadNo = i;
  256.       threadLife[i] = NdbThread_Create(threadLoop,
  257.                                        (void**)&pThreadData[i],
  258.                                        32768,
  259.                                        "flexAsynchThread",
  260.                                        NDB_THREAD_PRIO_LOW);
  261.     }//for
  262.     ndbout << endl <<  "All NDB objects and table created" << endl << endl;
  263.     int noOfTransacts = tNoOfParallelTrans * tNoOfTransactions *
  264.                         tNoOfThreads * tNoOfLoops;
  265.     /****************************************************************
  266.      * Execute program.                                             *
  267.      ****************************************************************/
  268.     /****************************************************************
  269.      * Perform inserts.                                             *
  270.      ****************************************************************/
  271.           
  272.     if (tInsert == true) {
  273.       tInsert = false;
  274.       tReadUpdate = false;
  275.       START_TIMER;
  276.       execute(stInsert);
  277.       STOP_TIMER;
  278.       PRINT_TIMER("insert", noOfTransacts, 1);
  279.     }//if
  280.     /****************************************************************
  281.      * Perform read + updates.                                      *
  282.      ****************************************************************/
  283.       
  284.     if (tReadUpdate == true) {
  285.       START_TIMER;
  286.       execute(stRead);
  287.       STOP_TIMER;
  288.       PRINT_TIMER("update + read", noOfTransacts, 1);
  289.     }//if  
  290.     /****************************************************************
  291.      * Perform delete.                                              *
  292.      ****************************************************************/
  293.                 
  294.     if (tDelete == true) {
  295.       tDelete = false;
  296.       START_TIMER;
  297.       execute(stDelete);
  298.       STOP_TIMER;
  299.       PRINT_TIMER("delete", noOfTransacts, 1);
  300.     }//if
  301.     ndbout << "--------------------------------------------------" << endl;
  302.         
  303.     execute(stStop);
  304.     void * tmp;
  305.     for(i = 0; i<tNoOfThreads; i++){
  306.       NdbThread_WaitFor(threadLife[i], &tmp);
  307.       NdbThread_Destroy(&threadLife[i]);
  308.     }
  309.   } 
  310.   delete [] pThreadData;
  311.   delete pNdb;
  313.   //printing errorCounters
  314.   flexTTErrorData->printErrorCounters(ndbout);
  316.   return NDBT_ProgramExit(returnValue);
  317. }//main()
  320. static void execute(StartType aType)
  321. {
  322.   resetThreads();
  323.   tellThreads(aType);
  324.   waitForThreads();
  325. }//execute()
  327. static void*
  328. threadLoop(void* ThreadData)
  329. {
  330.   Ndb* localNdb;
  331.   ThreadNdb* tabThread = (ThreadNdb*)ThreadData;
  332.   int loc_threadNo = tabThread->threadNo;
  334.   void * mem = malloc(sizeof(TransNdb)*tNoOfParallelTrans);
  335.   TransNdb* pTransData = (TransNdb*)mem;
  337.   localNdb = new Ndb("TEST_DB");
  338.   localNdb->init(1024);
  339.   localNdb->waitUntilReady();
  341.   if (tLocal == false) {
  342.     tabThread->threadIncrement = 1;
  343.   } else {
  344.     tabThread->threadIncrement = MAX_SEEK;
  345.   }//if
  346.   tabThread->threadBase = (loc_threadNo << 16) + tNodeId;
  347.   tabThread->threadNdb = localNdb;
  348.   tabThread->threadStop = tNoOfParallelTrans * tNoOfTransactions;
  349.   tabThread->threadStop *= tabThread->threadIncrement;
  350.   tabThread->threadLoopStop = tNoOfLoops;
  351.   Uint32 i, j;
  352.   for (i = 0; i < tNoOfParallelTrans; i++) {
  353.     pTransData[i].transNdb = localNdb;    
  354.     pTransData[i].transThread = tabThread;    
  355.     pTransData[i].transOperation = NULL;    
  356.     pTransData[i].transStartType = stIdle;    
  357.     pTransData[i].vpn_number = tabThread->threadBase;    
  358.     pTransData[i].vpn_identity = 0;
  359.     pTransData[i].transErrorCount = 0;
  360.     for (j = 0; j < 128; j++) {
  361.       pTransData[i].transRecord[j] = 0x30;
  362.     }//for
  363.   }//for
  365.   for (;;){
  366.     while (ThreadStart[loc_threadNo] == stIdle) {
  367.       NdbSleep_MilliSleep(10);
  368.     }//while
  370.     // Check if signal to exit is received
  371.     if (ThreadStart[loc_threadNo] == stStop) {
  372.       break;
  373.     }//if
  375.     tabThread->threadStartType = ThreadStart[loc_threadNo];  
  376.     tabThread->threadLoopCounter = 0;
  377.     tabThread->threadCompleted = false;  
  378.     tabThread->threadNoCompleted = 0;
  379.     tabThread->threadNextStart = 0;
  381.     ThreadStart[loc_threadNo] = stIdle;
  382.     if(!executeThread(tabThread, pTransData)){
  383.       break;
  384.     }
  385.     ThreadReady[loc_threadNo] = 1;
  386.   }//for
  388.   free(mem);
  389.   delete localNdb;
  390.   ThreadReady[loc_threadNo] = 1;
  392.   return NULL; // Thread exits
  393. }//threadLoop()
  395. static 
  396. bool
  397. executeThread(ThreadNdb* tabThread, TransNdb* atransDataArrayPtr) {
  398.   Uint32 i;
  399.   for (i = 0; i < tNoOfParallelTrans; i++) {
  400.     TransNdb* transNdbPtr = &atransDataArrayPtr[i];
  401.     transNdbPtr->vpn_identity = i * tabThread->threadIncrement;
  402.     transNdbPtr->transStartType = tabThread->threadStartType;
  403.     if (executeTransaction(transNdbPtr) == false) {
  404.       return false;
  405.     }//if
  406.   }//for
  407.   tabThread->threadNextStart = tNoOfParallelTrans * tabThread->threadIncrement;
  408.   do {
  409.     tabThread->threadNdb->sendPollNdb(3000, tMinEvents, tSendForce);
  410.   } while (tabThread->threadCompleted == false);
  411.   return true;
  412. }//executeThread()
  414. static
  415. bool executeTransaction(TransNdb* transNdbRef)
  416. {
  417.   NdbConnection* MyTrans;
  418.   ThreadNdb* tabThread = transNdbRef->transThread;
  419.   Ndb* aNdbObject = transNdbRef->transNdb;
  420.   Uint32 threadBase = tabThread->threadBase;
  421.   Uint32 startKey = transNdbRef->vpn_identity;
  422.   if (tLocal == true) {
  423.     startKey = getKey(startKey, threadBase);
  424.   }//if
  425.   if (startTransGuess == true) {
  426.     Uint32 tKey[2];
  427.     tKey[0] = startKey;
  428.     tKey[1] = threadBase;
  429.     MyTrans = aNdbObject->startTransaction((Uint32)0, //Priority
  430.                                          (const char*)&tKey[0],   //Main PKey
  431.                                          (Uint32)8);           //Key Length
  432.   } else {
  433.    MyTrans = aNdbObject->startTransaction();
  434.   }//if
  435.   if (MyTrans == NULL) {
  436.     error_handler(aNdbObject->getNdbError());
  437.     ndbout << endl << "Unable to recover! Quiting now" << endl ;
  438.     return false;
  439.   }//if
  440.   //-------------------------------------------------------
  441.   // Define the operation, but do not execute it yet.
  442.   //-------------------------------------------------------
  443.   if (!defineOperation(MyTrans, transNdbRef, startKey, threadBase))
  444.     return false;
  446.   return true;
  447. }//executeTransaction()
  450. static 
  451. Uint32
  452. getKey(Uint32 aBase, Uint32 aThreadBase) {
  453.   Uint32 Tfound = aBase;
  454.   Uint32 hash;
  455.   Uint64 Tkey64;
  456.   Uint32* tKey32 = (Uint32*)&Tkey64;
  457.   tKey32[0] = aThreadBase;
  458.   for (int i = aBase; i < (aBase + MAX_SEEK); i++) {
  459.     tKey32[1] = (Uint32)i;
  460.     hash = md5_hash((Uint64*)&Tkey64, (Uint32)2);
  461.     hash = (hash >> 6) & (MAX_PARTS - 1);
  462.     if (hash == tLocalPart) {
  463.       Tfound = i;
  464.       break;
  465.     }//if
  466.   }//for
  467.   return Tfound;
  468. }//getKey()
  470. static void
  471. executeCallback(int result, NdbConnection* NdbObject, void* aObject)
  472. {
  473.   TransNdb* transNdbRef = (TransNdb*)aObject;
  474.   ThreadNdb* tabThread = transNdbRef->transThread;
  475.   Ndb* tNdb = transNdbRef->transNdb;
  476.   Uint32 vpn_id = transNdbRef->vpn_identity;
  477.   Uint32 vpn_nb = tabThread->threadBase;
  479.   if (result == -1) {
  480. // Add complete error handling here
  481.     int retCode = flexTTErrorData->handleErrorCommon(NdbObject->getNdbError());
  482.     if (retCode == 1) {
  483.       if (NdbObject->getNdbError().code != 626 &&
  484.           NdbObject->getNdbError().code != 630) {
  485.         ndbout_c("execute: %s", NdbObject->getNdbError().message);
  486.         ndbout_c("Error code = %d", NdbObject->getNdbError().code);
  487.       }
  488.     } else if (retCode == 2) {
  489.       ndbout << "4115 should not happen in flexTT" << endl;
  490.     } else if (retCode == 3) {
  491.       /* What can we do here? */
  492.       ndbout_c("execute: %s", NdbObject->getNdbError().message);
  493.     }//if(retCode == 3)
  494.     transNdbRef->transErrorCount++;
  495.     const NdbError & err = NdbObject->getNdbError();
  496.     switch (err.classification) {
  497.     case NdbError::NoDataFound:
  498.     case NdbError::ConstraintViolation:
  499.       ndbout << "Error with vpn_id = " << vpn_id << " and vpn_nb = ";
  500.       ndbout << vpn_nb << endl;
  501.       ndbout << err << endl;
  502.       goto checkCompleted;
  503.     case NdbError::OverloadError:
  504.       NdbSleep_MilliSleep(10);
  505.     case NdbError::NodeRecoveryError:
  506.     case NdbError::UnknownResultError:
  507.     case NdbError::TimeoutExpired:
  508.       break;
  509.     default:
  510.       goto checkCompleted;
  511.     }//if
  512.     if ((transNdbRef->transErrorCount > 10) ||
  513.         (tabThread->threadNoCompleted > 0)) {
  514.       goto checkCompleted;
  515.     }//if
  516.   } else {
  517.     if (tabThread->threadNoCompleted == 0) {
  518.       transNdbRef->transErrorCount = 0;
  519.       transNdbRef->vpn_identity = tabThread->threadNextStart;
  520.       if (tabThread->threadNextStart == tabThread->threadStop) {
  521.         tabThread->threadLoopCounter++;
  522.         transNdbRef->vpn_identity = 0;
  523.         tabThread->threadNextStart = 0;
  524.         if (tabThread->threadLoopCounter == tNoOfLoops) {
  525.           goto checkCompleted;
  526.         }//if
  527.       }//if
  528.       tabThread->threadNextStart += tabThread->threadIncrement;
  529.     } else {
  530.       goto checkCompleted;
  531.     }//if
  532.   }//if
  533.   tNdb->closeTransaction(NdbObject);
  534.   executeTransaction(transNdbRef);
  535.   return;
  537. checkCompleted:
  538.   tNdb->closeTransaction(NdbObject);
  539.   tabThread->threadNoCompleted++;
  540.   if (tabThread->threadNoCompleted == tNoOfParallelTrans) {
  541.     tabThread->threadCompleted = true;
  542.   }//if
  543.   return;      
  544. }//executeCallback()
  546. static
  547. StartType
  548. random_choice()
  549. {
  550. //----------------------------------------------------
  551. // Generate a random key between 0 and tNoOfRecords - 1
  552. //----------------------------------------------------
  553.    UintR random_number = lrand48() % 100;
  554.    if (random_number < tUpdateFreq)
  555.     return stUpdate;
  556.   else
  557.     return stRead;
  558. }//random_choice()
  560. static bool
  561. defineOperation(NdbConnection* localNdbConnection, TransNdb* transNdbRef,
  562.                 unsigned int vpn_id, unsigned int vpn_nb)
  563. {
  564.   NdbOperation*  localNdbOperation;
  565.   StartType      TType = transNdbRef->transStartType;
  567.   //-------------------------------------------------------
  568.   // Set-up the attribute values for this operation.
  569.   //-------------------------------------------------------
  570.   localNdbOperation = localNdbConnection->getNdbOperation(tableName[0]);        
  571.   if (localNdbOperation == NULL) {
  572.     error_handler(localNdbConnection->getNdbError());
  573.     return false;
  574.   }//if
  575.   switch (TType) {
  576.   case stInsert:   // Insert case
  577.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  578.       localNdbOperation->dirtyWrite();
  579.     } else if (theWriteFlag == 1) {
  580.       localNdbOperation->writeTuple();
  581.     } else {
  582.       localNdbOperation->insertTuple();
  583.     }//if
  584.     break;
  585.   case stRead:     // Read Case
  586.     TType = random_choice();
  587.     if (TType == stRead) {
  588.       if (theSimpleFlag == 1) {
  589.         localNdbOperation->simpleRead();
  590.       } else if (theDirtyFlag == 1) {
  591.         localNdbOperation->dirtyRead();
  592.       } else {
  593.         localNdbOperation->readTuple();
  594.       }//if
  595.     } else {
  596.       if (theWriteFlag == 1 && theDirtyFlag == 1) {
  597.         localNdbOperation->dirtyWrite();
  598.       } else if (theWriteFlag == 1) {
  599.         localNdbOperation->writeTuple();
  600.       } else if (theDirtyFlag == 1) {
  601.         localNdbOperation->dirtyUpdate();
  602.       } else {
  603.         localNdbOperation->updateTuple();
  604.       }//if
  605.     }//if
  606.     break;
  607.   case stDelete:  // Delete Case
  608.     localNdbOperation->deleteTuple();
  609.     break;
  610.   default:
  611.     error_handler(localNdbOperation->getNdbError());
  612.   }//switch
  613.   localNdbOperation->equal((Uint32)0,vpn_id);
  614.   localNdbOperation->equal((Uint32)1,vpn_nb);
  615.   char* attrValue = &transNdbRef->transRecord[0];
  616.   switch (TType) {
  617.   case stInsert:      // Insert case
  618.     localNdbOperation->setValue((Uint32)2, attrValue);
  619.     localNdbOperation->setValue((Uint32)3, attrValue);
  620.     localNdbOperation->setValue((Uint32)4, attrValue);
  621.     break;
  622.   case stUpdate:      // Update Case
  623.     localNdbOperation->setValue((Uint32)3, attrValue);
  624.     break;
  625.   case stRead:    // Read Case
  626.     localNdbOperation->getValue((Uint32)2, attrValue);
  627.     localNdbOperation->getValue((Uint32)3, attrValue);
  628.     localNdbOperation->getValue((Uint32)4, attrValue);
  629.     break;
  630.   case stDelete:  // Delete Case
  631.     break;
  632.   default:
  633.     error_handler(localNdbOperation->getNdbError());
  634.   }//switch
  635.   localNdbConnection->executeAsynchPrepare(Commit, &executeCallback, 
  636.                                            (void*)transNdbRef);
  637.   return true;
  638. }//defineOperation()
  641. static void setAttrNames()
  642. {
  643.   BaseString::snprintf(attrName[0], MAXSTRLEN, "VPN_ID");
  644.   BaseString::snprintf(attrName[1], MAXSTRLEN, "VPN_NB");
  645.   BaseString::snprintf(attrName[2], MAXSTRLEN, "DIRECTORY_NB");
  646.   BaseString::snprintf(attrName[3], MAXSTRLEN, "LAST_CALL_PARTY");
  647.   BaseString::snprintf(attrName[4], MAXSTRLEN, "DESCR");
  648. }
  651. static void setTableNames()
  652. {
  653.   BaseString::snprintf(tableName[0], MAXSTRLEN, "VPN_USERS");
  654. }
  656. static
  657. int 
  658. createTables(Ndb* pMyNdb){
  660.   NdbSchemaCon          *MySchemaTransaction;
  661.   NdbSchemaOp           *MySchemaOp;
  662.   int                   check;
  664.   if (theTableCreateFlag == 0) {
  665.     ndbout << "Creating Table: vpn_users " << "..." << endl;
  666.     MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
  667.       
  668.     if(MySchemaTransaction == NULL && 
  669.        (!error_handler(MySchemaTransaction->getNdbError())))
  670.       return -1;
  671.       
  672.     MySchemaOp = MySchemaTransaction->getNdbSchemaOp();       
  673.     if(MySchemaOp == NULL &&
  674.        (!error_handler(MySchemaTransaction->getNdbError())))
  675.       return -1;
  676.       
  677.     check = MySchemaOp->createTable( tableName[0]
  678.                                        ,8                       // Table Size
  679.                                        ,TupleKey                // Key Type
  680.                                        ,40                      // Nr of Pages
  681.                                        ,All
  682.                                        ,6
  683.                                        ,(tLoadFactor - 5)
  684.                                        ,tLoadFactor
  685.                                        ,1
  686.                                        ,!tempTable
  687.                                        );
  688.       
  689.     if (check == -1 &&
  690.         (!error_handler(MySchemaTransaction->getNdbError())))
  691.       return -1;
  692.       
  693.     check = MySchemaOp->createAttribute( (char*)attrName[0],
  694.                                          TupleKey,
  695.                                          32,
  696.                                          1,
  697.                                          UnSigned,
  698.                                          MMBased,
  699.                                          NotNullAttribute );
  700.       
  701.     if (check == -1 &&
  702.         (!error_handler(MySchemaTransaction->getNdbError())))
  703.       return -1;
  704.     check = MySchemaOp->createAttribute( (char*)attrName[1],
  705.                                          TupleKey,
  706.                                          32,
  707.                                          1,
  708.                                          UnSigned,
  709.                                          MMBased,
  710.                                          NotNullAttribute );
  711.       
  712.     if (check == -1 &&
  713.         (!error_handler(MySchemaTransaction->getNdbError())))
  714.       return -1;
  715.     check = MySchemaOp->createAttribute( (char*)attrName[2],
  716.                                              NoKey,
  717.                                              8,
  718.                                              10,
  719.                                              UnSigned,
  720.                                              MMBased,
  721.                                              NotNullAttribute );
  722.     if (check == -1 &&
  723.         (!error_handler(MySchemaTransaction->getNdbError())))
  724.       return -1;
  725.       
  726.     check = MySchemaOp->createAttribute( (char*)attrName[3],
  727.                                              NoKey,
  728.                                              8,
  729.                                              10,
  730.                                              UnSigned,
  731.                                              MMBased,
  732.                                              NotNullAttribute );
  733.     if (check == -1 &&
  734.         (!error_handler(MySchemaTransaction->getNdbError())))
  735.       return -1;
  736.       
  737.     check = MySchemaOp->createAttribute( (char*)attrName[4],
  738.                                              NoKey,
  739.                                              8,
  740.                                              100,
  741.                                              UnSigned,
  742.                                              MMBased,
  743.                                              NotNullAttribute );
  744.     if (check == -1 &&
  745.         (!error_handler(MySchemaTransaction->getNdbError())))
  746.       return -1;
  747.       
  748.     if (MySchemaTransaction->execute() == -1 &&
  749.         (!error_handler(MySchemaTransaction->getNdbError())))
  750.       return -1;
  751.       
  752.     NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  753.   }//if
  754.   
  755.   return 0;
  756. }
  758. bool error_handler(const NdbError& err){
  759.   ndbout << err << endl ;
  760.   switch(err.classification){
  761.   case NdbError::NodeRecoveryError:
  762.   case NdbError::SchemaError:
  763.   case NdbError::TimeoutExpired:
  764.     ndbout << endl << "Attempting to recover and continue now..." << endl ;
  765.     return true ; // return true to retry
  766.   }
  767.   return false;
  768. }
  769. #if 0
  770. bool error_handler(const char* error_string, int error_int) {
  771.   ndbout << error_string << endl ;
  772.   if ((4008 == error_int) ||
  773.       (677 == error_int) ||
  774.       (891 == error_int) ||
  775.       (1221 == error_int) ||
  776.       (721 == error_int) ||
  777.       (266 == error_int)) {
  778.     ndbout << endl << "Attempting to recover and continue now..." << endl ;
  779.     return true ; // return true to retry
  780.   }
  781.   return false ; // return false to abort
  782. }
  783. #endif
  785. static
  786. int 
  787. readArguments(int argc, const char** argv){
  788.   
  789.   int i = 1;
  790.   while (argc > 1){
  791.     if (strcmp(argv[i], "-t") == 0){
  792.       tNoOfThreads = atoi(argv[i+1]);
  793.       if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)){
  794. ndbout_c("Invalid no of threads");
  795.         return -1;
  796.       }
  797.     } else if (strcmp(argv[i], "-p") == 0){
  798.       tNoOfParallelTrans = atoi(argv[i+1]);
  799.       if ((tNoOfParallelTrans < 1) || (tNoOfParallelTrans > MAXPAR)){
  800. ndbout_c("Invalid no of parallell transactions");
  801.         return -1;
  802.       }
  803.     } else if (strcmp(argv[i], "-o") == 0) {
  804.       tNoOfTransactions = atoi(argv[i+1]);
  805.       if (tNoOfTransactions < 1){
  806. ndbout_c("Invalid no of transactions");
  807.         return -1;
  808.       }
  809.     } else if (strcmp(argv[i], "-l") == 0){
  810.       tNoOfLoops = atoi(argv[i+1]);
  811.       if (tNoOfLoops < 1) {
  812. ndbout_c("Invalid no of loops");
  813.         return -1;
  814.       }
  815.     } else if (strcmp(argv[i], "-e") == 0){
  816.       tMinEvents = atoi(argv[i+1]);
  817.       if ((tMinEvents < 1) || (tMinEvents > tNoOfParallelTrans)) {
  818. ndbout_c("Invalid no of loops");
  819.         return -1;
  820.       }
  821.     } else if (strcmp(argv[i], "-local") == 0){
  822.       tLocalPart = atoi(argv[i+1]);
  823.       tLocal = true;
  824.       startTransGuess = true;
  825.       if ((tLocalPart < 0) || (tLocalPart > MAX_PARTS)){
  826. ndbout_c("Invalid local part");
  827.         return -1;
  828.       }
  829.     } else if (strcmp(argv[i], "-ufreq") == 0){
  830.       tUpdateFreq = atoi(argv[i+1]);
  831.       if ((tUpdateFreq < 0) || (tUpdateFreq > 100)){
  832. ndbout_c("Invalid Update Frequency");
  833.         return -1;
  834.       }
  835.     } else if (strcmp(argv[i], "-load_factor") == 0){
  836.       tLoadFactor = atoi(argv[i+1]);
  837.       if ((tLoadFactor < 40) || (tLoadFactor >= 100)){
  838. ndbout_c("Invalid LoadFactor");
  839.         return -1;
  840.       }
  841.     } else if (strcmp(argv[i], "-d") == 0){
  842.       tDelete = true;
  843.       argc++;
  844.       i--;
  845.     } else if (strcmp(argv[i], "-i") == 0){
  846.       tInsert = true;
  847.       argc++;
  848.       i--;
  849.     } else if (strcmp(argv[i], "-simple") == 0){
  850.       theSimpleFlag = 1;
  851.       argc++;
  852.       i--;
  853.     } else if (strcmp(argv[i], "-adaptive") == 0){
  854.       tSendForce = 0;
  855.       argc++;
  856.       i--;
  857.     } else if (strcmp(argv[i], "-force") == 0){
  858.       tSendForce = 1;
  859.       argc++;
  860.       i--;
  861.     } else if (strcmp(argv[i], "-non_adaptive") == 0){
  862.       tSendForce = 2;
  863.       argc++;
  864.       i--;
  865.     } else if (strcmp(argv[i], "-write") == 0){
  866.       theWriteFlag = 1;
  867.       argc++;
  868.       i--;
  869.     } else if (strcmp(argv[i], "-dirty") == 0){
  870.       theDirtyFlag = 1;
  871.       argc++;
  872.       i--;
  873.     } else if (strcmp(argv[i], "-table_create") == 0){
  874.       theTableCreateFlag = 0;
  875.       tInsert = true;
  876.       argc++;
  877.       i--;
  878.     } else if (strcmp(argv[i], "-temp") == 0){
  879.       tempTable = true;
  880.       argc++;
  881.       i--;
  882.     } else if (strcmp(argv[i], "-no_hint") == 0){
  883.       startTransGuess = false;
  884.       argc++;
  885.       i--;
  886.     } else {
  887.       return -1;
  888.     }
  889.     
  890.     argc -= 2;
  891.     i = i + 2;
  892.   }//while
  893.   if (tLocal == true) {
  894.     if (startTransGuess == false) {
  895.       ndbout_c("Not valid to use no_hint with local");
  896.     }//if
  897.   }//if
  898.   return 0;
  899. }
  901. static
  902. void
  903. input_error(){
  904.   
  905.   ndbout_c("FLEXTT");
  906.   ndbout_c("   Perform benchmark of insert, update and delete transactions");
  907.   ndbout_c("");
  908.   ndbout_c("Arguments:");
  909.   ndbout_c("   -t Number of threads to start, default 1");
  910.   ndbout_c("   -p Number of parallel transactions per thread, default 32");
  911.   ndbout_c("   -o Number of transactions per loop, default 500");
  912.   ndbout_c("   -ufreq Number Update Frequency in percent (0 -> 100), rest is read");
  913.   ndbout_c("   -load_factor Number Fill level in index in percent (40 -> 99)");
  914.   ndbout_c("   -l Number of loops to run, default 1, 0=infinite");
  915.   ndbout_c("   -i Start by inserting all records");
  916.   ndbout_c("   -d End by deleting all records (only one loop)");
  917.   ndbout_c("   -simple Use simple read to read from database");
  918.   ndbout_c("   -dirty Use dirty read to read from database");
  919.   ndbout_c("   -write Use writeTuple in insert and update");
  920.   ndbout_c("   -n Use standard table names");
  921.   ndbout_c("   -table_create Create tables in db");
  922.   ndbout_c("   -temp Create table(s) without logging");
  923.   ndbout_c("   -no_hint Don't give hint on where to execute transaction coordinator");
  924.   ndbout_c("   -adaptive Use adaptive send algorithm (default)");
  925.   ndbout_c("   -force Force send when communicating");
  926.   ndbout_c("   -non_adaptive Send at a 10 millisecond interval");
  927.   ndbout_c("   -local Number of part, only use keys in one part out of 16");
  928. }