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

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

MySQL数据库

开发平台：

Visual C++

flexAsynch.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 */
  19. #include "NdbApi.hpp"
  20. #include <NdbSchemaCon.hpp>
  21. #include <NdbMain.h>
  22. #include <md5_hash.hpp>
  24. #include <NdbThread.h>
  25. #include <NdbSleep.h>
  26. #include <NdbTick.h>
  27. #include <NdbOut.hpp>
  28. #include <NdbTimer.hpp>
  29. #include <NDBT_Error.hpp>
  31. #include <NdbTest.hpp>
  33. #define MAX_PARTS 4 
  34. #define MAX_SEEK 16 
  35. #define MAXSTRLEN 16 
  36. #define MAXATTR 64
  37. #define MAXTABLES 64
  38. #define MAXTHREADS 128
  39. #define MAXPAR 1024
  40. #define MAXATTRSIZE 1000
  41. #define PKSIZE 2
  43. enum StartType { 
  44.   stIdle, 
  45.   stInsert,
  46.   stRead,
  47.   stUpdate,
  48.   stDelete, 
  49.   stStop 
  50. } ;
  52. extern "C" { static void* threadLoop(void*); }
  53. static void setAttrNames(void);
  54. static void setTableNames(void);
  55. static int readArguments(int argc, const char** argv);
  56. static int createTables(Ndb*);
  57. static void defineOperation(NdbConnection* aTransObject, StartType aType, 
  58.                             Uint32 base, Uint32 aIndex);
  59. static void execute(StartType aType);
  60. static bool executeThread(StartType aType, Ndb* aNdbObject, unsigned int);
  61. static void executeCallback(int result, NdbConnection* NdbObject,
  62.                             void* aObject);
  63. static bool error_handler(const NdbError & err);
  64. static Uint32 getKey(Uint32, Uint32) ;
  65. static void input_error();
  68. static int                              retry_opt = 3 ;
  69. static int                              failed = 0 ;
  70.                 
  71. ErrorData * flexAsynchErrorData;                        
  73. struct ThreadNdb
  74. {
  75.   int NoOfOps;
  76.   int ThreadNo;
  77. };
  79. static NdbThread*               threadLife[MAXTHREADS];
  80. static int                              tNodeId;
  81. static int                              ThreadReady[MAXTHREADS];
  82. static StartType                ThreadStart[MAXTHREADS];
  83. static char                             tableName[MAXTABLES][MAXSTRLEN+1];
  84. static char                             attrName[MAXATTR][MAXSTRLEN+1];
  86. // Program Parameters
  87. static bool                             tLocal = false;
  88. static int                              tLocalPart = 0;
  89. static int                              tSendForce = 0;
  90. static int                              tNoOfLoops = 1;
  91. static int                              tAttributeSize = 1;
  92. static unsigned int             tNoOfThreads = 1;
  93. static unsigned int             tNoOfParallelTrans = 32;
  94. static unsigned int             tNoOfAttributes = 25;
  95. static unsigned int             tNoOfTransactions = 500;
  96. static unsigned int             tNoOfOpsPerTrans = 1;
  97. static unsigned int             tLoadFactor = 80;
  98. static bool                     tempTable = false;
  99. static bool                     startTransGuess = true;
  101. //Program Flags
  102. static int                              theTestFlag = 0;
  103. static int                              theSimpleFlag = 0;
  104. static int                              theDirtyFlag = 0;
  105. static int                              theWriteFlag = 0;
  106. static int                              theStdTableNameFlag = 0;
  107. static int                              theTableCreateFlag = 0;
  109. #define START_REAL_TIME
  110. #define STOP_REAL_TIME
  111. #define START_TIMER { NdbTimer timer; timer.doStart();
  112. #define STOP_TIMER timer.doStop();
  113. #define PRINT_TIMER(text, trans, opertrans) timer.printTransactionStatistics(text, trans, opertrans); }; 
  115. static void 
  116. resetThreads(){
  118.   for (int i = 0; i < tNoOfThreads ; i++) {
  119.     ThreadReady[i] = 0;
  120.     ThreadStart[i] = stIdle;
  121.   }//for
  122. }
  124. static void 
  125. waitForThreads(void)
  126. {
  127.   int cont = 0;
  128.   do {
  129.     cont = 0;
  130.     NdbSleep_MilliSleep(20);
  131.     for (int i = 0; i < tNoOfThreads ; i++) {
  132.       if (ThreadReady[i] == 0) {
  133.         cont = 1;
  134.       }//if
  135.     }//for
  136.   } while (cont == 1);
  137. }
  139. static void 
  140. tellThreads(StartType what)
  141. {
  142.   for (int i = 0; i < tNoOfThreads ; i++) 
  143.     ThreadStart[i] = what;
  144. }
  146. NDB_COMMAND(flexAsynch, "flexAsynch", "flexAsynch", "flexAsynch", 65535)
  147. {
  148.   ndb_init();
  149.   ThreadNdb*            pThreadData;
  150.   int                   tLoops=0, i;
  151.   int                   returnValue = NDBT_OK;
  153.   flexAsynchErrorData = new ErrorData;
  154.   flexAsynchErrorData->resetErrorCounters();
  156.   if (readArguments(argc, argv) != 0){
  157.     input_error();
  158.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  159.   }
  161.   pThreadData = new ThreadNdb[MAXTHREADS];
  163.   ndbout << endl << "FLEXASYNCH - Starting normal mode" << endl;
  164.   ndbout << "Perform benchmark of insert, update and delete transactions";
  165.   ndbout << endl;
  166.   ndbout << "  " << tNoOfThreads << " number of concurrent threads " << endl;
  167.   ndbout << "  " << tNoOfParallelTrans;
  168.   ndbout << " number of parallel operation per thread " << endl;
  169.   ndbout << "  " << tNoOfTransactions << " transaction(s) per round " << endl;
  170.   ndbout << "  " << tNoOfLoops << " iterations " << endl;
  171.   ndbout << "  " << "Load Factor is " << tLoadFactor << "%" << endl;
  172.   ndbout << "  " << tNoOfAttributes << " attributes per table " << endl;
  173.   ndbout << "  " << tAttributeSize;
  174.   ndbout << " is the number of 32 bit words per attribute " << endl;
  175.   if (tempTable == true) {
  176.     ndbout << "  Tables are without logging " << endl;
  177.   } else {
  178.     ndbout << "  Tables are with logging " << endl;
  179.   }//if
  180.   if (startTransGuess == true) {
  181.     ndbout << "  Transactions are executed with hint provided" << endl;
  182.   } else {
  183.     ndbout << "  Transactions are executed with round robin scheme" << endl;
  184.   }//if
  185.   if (tSendForce == 0) {
  186.     ndbout << "  No force send is used, adaptive algorithm used" << endl;
  187.   } else if (tSendForce == 1) {
  188.     ndbout << "  Force send used" << endl;
  189.   } else {
  190.     ndbout << "  No force send is used, adaptive algorithm disabled" << endl;
  191.   }//if
  193.   ndbout << endl;
  195.   NdbThread_SetConcurrencyLevel(2 + tNoOfThreads);
  197.   /* print Setting */
  198.   flexAsynchErrorData->printSettings(ndbout);
  200.   setAttrNames();
  201.   setTableNames();
  203.   Ndb * pNdb = new Ndb("TEST_DB");      
  204.   pNdb->init();
  205.   tNodeId = pNdb->getNodeId();
  207.   ndbout << "  NdbAPI node with id = " << pNdb->getNodeId() << endl;
  208.   ndbout << endl;
  209.   
  210.   ndbout << "Waiting for ndb to become ready..." <<endl;
  211.   if (pNdb->waitUntilReady(10000) != 0){
  212.     ndbout << "NDB is not ready" << endl;
  213.     ndbout << "Benchmark failed!" << endl;
  214.     returnValue = NDBT_FAILED;
  215.   }
  217.   if(returnValue == NDBT_OK){
  218.     if (createTables(pNdb) != 0){
  219.       returnValue = NDBT_FAILED;
  220.     }
  221.   }
  223.   if(returnValue == NDBT_OK){
  224.     /****************************************************************
  225.      *  Create NDB objects.                                   *
  226.      ****************************************************************/
  227.     resetThreads();
  228.     for (int i = 0; i < tNoOfThreads ; i++) {
  229.       pThreadData[i].ThreadNo = i
  230. ;
  231.       threadLife[i] = NdbThread_Create(threadLoop,
  232.                                        (void**)&pThreadData[i],
  233.                                        32768,
  234.                                        "flexAsynchThread",
  235.                                        NDB_THREAD_PRIO_LOW);
  236.     }//for
  237.     ndbout << endl <<  "All NDB objects and table created" << endl << endl;
  238.     int noOfTransacts = tNoOfParallelTrans*tNoOfTransactions*tNoOfThreads;
  239.     /****************************************************************
  240.      * Execute program.                                             *
  241.      ****************************************************************/
  243.     for(;;) {
  245.       int loopCount = tLoops + 1 ;
  246.       ndbout << endl << "Loop # " << loopCount  << endl << endl ;
  248.       /****************************************************************
  249.        * Perform inserts.                                             *
  250.        ****************************************************************/
  251.           
  252.       failed = 0 ;
  254.       START_TIMER;
  255.       execute(stInsert);
  256.       STOP_TIMER;
  257.       PRINT_TIMER("insert", noOfTransacts, tNoOfOpsPerTrans);
  259.       if (0 < failed) {
  260.         i = retry_opt ;
  261.         int ci = 1 ;
  262.         while (0 < failed && 0 < i){
  263.           ndbout << failed << " of the transactions returned errors!" 
  264.                  << endl << endl;
  265.           ndbout << "Attempting to redo the failed transactions now..." 
  266.                  << endl ;
  267.           ndbout << "Redo attempt " << ci <<" out of " << retry_opt 
  268.                  << endl << endl;
  269.           failed = 0 ;
  270.           START_TIMER;
  271.           execute(stInsert);
  272.           STOP_TIMER;
  273.           PRINT_TIMER("insert", noOfTransacts, tNoOfOpsPerTrans);
  274.           i-- ;
  275.           ci++;
  276.         }
  277.         if(0 == failed ){
  278.           ndbout << endl <<"Redo attempt succeeded" << endl << endl;
  279.         }else{
  280.           ndbout << endl <<"Redo attempt failed, moving on now..." << endl 
  281.                  << endl;
  282.         }//if
  283.       }//if
  284.           
  285.       /****************************************************************
  286.        * Perform read.                                                *
  287.        ****************************************************************/
  288.       
  289.       failed = 0 ;
  291.       START_TIMER;
  292.       execute(stRead);
  293.       STOP_TIMER;
  294.       PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  296.       if (0 < failed) {
  297.         i = retry_opt ;
  298.         int cr = 1;
  299.         while (0 < failed && 0 < i){
  300.           ndbout << failed << " of the transactions returned errors!"<<endl ;
  301.           ndbout << endl;
  302.           ndbout <<"Attempting to redo the failed transactions now..." << endl;
  303.           ndbout << endl;
  304.           ndbout <<"Redo attempt " << cr <<" out of ";
  305.           ndbout << retry_opt << endl << endl;
  306.           failed = 0 ;
  307.           START_TIMER;
  308.           execute(stRead);
  309.           STOP_TIMER;
  310.           PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  311.           i-- ;
  312.           cr++ ;
  313.         }//while
  314.         if(0 == failed ) {
  315.           ndbout << endl <<"Redo attempt succeeded" << endl << endl ;
  316.         }else{
  317.           ndbout << endl <<"Redo attempt failed, moving on now..." << endl << endl ;
  318.         }//if
  319.       }//if
  320.           
  321.           
  322.       /****************************************************************
  323.        * Perform update.                                              *
  324.        ****************************************************************/
  325.       
  326.       failed = 0 ;
  327.           
  328.       START_TIMER;
  329.       execute(stUpdate);
  330.       STOP_TIMER;
  331.       PRINT_TIMER("update", noOfTransacts, tNoOfOpsPerTrans) ;
  333.       if (0 < failed) {
  334.         i = retry_opt ;
  335.         int cu = 1 ;
  336.         while (0 < failed && 0 < i){
  337.           ndbout << failed << " of the transactions returned errors!"<<endl ;
  338.           ndbout << endl;
  339.           ndbout <<"Attempting to redo the failed transactions now..." << endl;
  340.           ndbout << endl <<"Redo attempt " << cu <<" out of ";
  341.           ndbout << retry_opt << endl << endl;
  342.           failed = 0 ;
  343.           START_TIMER;
  344.           execute(stUpdate);
  345.           STOP_TIMER;
  346.           PRINT_TIMER("update", noOfTransacts, tNoOfOpsPerTrans);
  347.           i-- ;
  348.           cu++ ;
  349.         }//while
  350.         if(0 == failed ){
  351.           ndbout << endl <<"Redo attempt succeeded" << endl << endl;
  352.         } else {
  353.           ndbout << endl;
  354.           ndbout <<"Redo attempt failed, moving on now..." << endl << endl;
  355.         }//if
  356.       }//if
  357.           
  358.       /****************************************************************
  359.        * Perform read.                                             *
  360.        ****************************************************************/
  361.       
  362.       failed = 0 ;
  363.           
  364.       START_TIMER;
  365.       execute(stRead);
  366.       STOP_TIMER;
  367.       PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  369.       if (0 < failed) {
  370.         i = retry_opt ;
  371.         int cr2 = 1 ;
  372.         while (0 < failed && 0 < i){
  373.           ndbout << failed << " of the transactions returned errors!"<<endl ;
  374.           ndbout << endl;
  375.           ndbout <<"Attempting to redo the failed transactions now..." << endl;
  376.           ndbout << endl <<"Redo attempt " << cr2 <<" out of ";
  377.           ndbout << retry_opt << endl << endl;
  378.           failed = 0 ;
  379.           START_TIMER;
  380.           execute(stRead);
  381.           STOP_TIMER;
  382.           PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  383.           i-- ;
  384.           cr2++ ;
  385.         }//while
  386.         if(0 == failed ){
  387.           ndbout << endl <<"Redo attempt succeeded" << endl << endl;
  388.         }else{
  389.           ndbout << endl;
  390.           ndbout << "Redo attempt failed, moving on now..." << endl << endl;
  391.         }//if
  392.       }//if
  393.           
  395.       /****************************************************************
  396.        * Perform delete.                                              *
  397.        ****************************************************************/
  398.       
  399.       failed = 0 ;
  400.           
  401.       START_TIMER;
  402.       execute(stDelete);
  403.       STOP_TIMER;
  404.       PRINT_TIMER("delete", noOfTransacts, tNoOfOpsPerTrans);
  406.       if (0 < failed) {
  407.         i = retry_opt ;
  408.         int cd = 1 ;
  409.         while (0 < failed && 0 < i){
  410.           ndbout << failed << " of the transactions returned errors!"<< endl ;
  411.           ndbout << endl;
  412.           ndbout <<"Attempting to redo the failed transactions now:" << endl ;
  413.           ndbout << endl <<"Redo attempt " << cd <<" out of ";
  414.           ndbout << retry_opt << endl << endl;
  415.           failed = 0 ;
  416.           START_TIMER;
  417.           execute(stDelete);
  418.           STOP_TIMER;
  419.           PRINT_TIMER("read", noOfTransacts, tNoOfOpsPerTrans);
  420.           i-- ;
  421.           cd++ ;
  422.         }//while
  423.         if(0 == failed ){
  424.           ndbout << endl <<"Redo attempt succeeded" << endl << endl ;
  425.         }else{
  426.           ndbout << endl;
  427.           ndbout << "Redo attempt failed, moving on now..." << endl << endl;
  428.         }//if
  429.       }//if
  430.           
  431.       tLoops++;
  432.       ndbout << "--------------------------------------------------" << endl;
  433.     
  434.       if(tNoOfLoops != 0){
  435.         if(tNoOfLoops <= tLoops)
  436.           break ;
  437.       }
  438.     }//for
  439.     
  440.     execute(stStop);
  441.     void * tmp;
  442.     for(i = 0; i<tNoOfThreads; i++){
  443.       NdbThread_WaitFor(threadLife[i], &tmp);
  444.       NdbThread_Destroy(&threadLife[i]);
  445.     }
  446.   } 
  447.   delete [] pThreadData;
  448.   delete pNdb;
  450.   //printing errorCounters
  451.   flexAsynchErrorData->printErrorCounters(ndbout);
  453.   return NDBT_ProgramExit(returnValue);
  454. }//main()
  457. static void execute(StartType aType)
  458. {
  459.   resetThreads();
  460.   tellThreads(aType);
  461.   waitForThreads();
  462. }//execute()
  464. static void*
  465. threadLoop(void* ThreadData)
  466. {
  467.   Ndb* localNdb;
  468.   StartType tType;
  469.   ThreadNdb* tabThread = (ThreadNdb*)ThreadData;
  470.   int threadNo = tabThread->ThreadNo;
  471.   localNdb = new Ndb("TEST_DB");
  472.   localNdb->init(1024);
  473.   localNdb->waitUntilReady(10000);
  474.   unsigned int threadBase = (threadNo << 16) + tNodeId ;
  475.   
  476.   for (;;){
  477.     while (ThreadStart[threadNo] == stIdle) {
  478.       NdbSleep_MilliSleep(10);
  479.     }//while
  481.     // Check if signal to exit is received
  482.     if (ThreadStart[threadNo] == stStop) {
  483.       break;
  484.     }//if
  486.     tType = ThreadStart[threadNo];
  487.     ThreadStart[threadNo] = stIdle;
  488.     if(!executeThread(tType, localNdb, threadBase)){
  489.       break;
  490.     }
  491.     ThreadReady[threadNo] = 1;
  492.   }//for
  494.   delete localNdb;
  495.   ThreadReady[threadNo] = 1;
  497.   return NULL;
  498. }//threadLoop()
  500. static 
  501. bool
  502. executeThread(StartType aType, Ndb* aNdbObject, unsigned int threadBase) {
  503.   int i, j, k;
  504.   NdbConnection* tConArray[1024];
  505.   unsigned int tBase;
  506.   unsigned int tBase2;
  508.   for (i = 0; i < tNoOfTransactions; i++) {
  509.     if (tLocal == false) {
  510.       tBase = i * tNoOfParallelTrans * tNoOfOpsPerTrans;
  511.     } else {
  512.       tBase = i * tNoOfParallelTrans * MAX_SEEK;
  513.     }//if
  514.     START_REAL_TIME;
  515.     for (j = 0; j < tNoOfParallelTrans; j++) {
  516.       if (tLocal == false) {
  517.         tBase2 = tBase + (j * tNoOfOpsPerTrans);
  518.       } else {
  519.         tBase2 = tBase + (j * MAX_SEEK);
  520.         tBase2 = getKey(threadBase, tBase2);
  521.       }//if
  522.       if (startTransGuess == true) {
  523.         Uint64 Tkey64;
  524.         Uint32* Tkey32 = (Uint32*)&Tkey64;
  525.         Tkey32[0] = threadBase;
  526.         Tkey32[1] = tBase2;
  527.         tConArray[j] = aNdbObject->startTransaction((Uint32)0, //Priority
  528.                                          (const char*)&Tkey64, //Main PKey
  529.                                          (Uint32)4);           //Key Length
  530.       } else {
  531.         tConArray[j] = aNdbObject->startTransaction();
  532.       }//if
  533.       if (tConArray[j] == NULL && 
  534.           !error_handler(aNdbObject->getNdbError()) ){
  535.         ndbout << endl << "Unable to recover! Quiting now" << endl ;
  536.         return false;
  537.       }//if
  538.       
  539.       for (k = 0; k < tNoOfOpsPerTrans; k++) {
  540.         //-------------------------------------------------------
  541.         // Define the operation, but do not execute it yet.
  542.         //-------------------------------------------------------
  543.         defineOperation(tConArray[j], aType, threadBase, (tBase2 + k));
  544.       }//for
  545.       
  546.       tConArray[j]->executeAsynchPrepare(Commit, &executeCallback, NULL);
  547.     }//for
  548.     STOP_REAL_TIME;
  549.     //-------------------------------------------------------
  550.     // Now we have defined a set of operations, it is now time
  551.     // to execute all of them.
  552.     //-------------------------------------------------------
  553.     int Tcomp = aNdbObject->sendPollNdb(3000, 0, 0);
  554.     while (Tcomp < tNoOfParallelTrans) {
  555.       int TlocalComp = aNdbObject->pollNdb(3000, 0);
  556.       Tcomp += TlocalComp;
  557.     }//while
  558.     for (j = 0 ; j < tNoOfParallelTrans ; j++) {
  559.       aNdbObject->closeTransaction(tConArray[j]);
  560.     }//for
  561.   }//for
  562.   return true;
  563. }//executeThread()
  565. static 
  566. Uint32
  567. getKey(Uint32 aBase, Uint32 anIndex) {
  568.   Uint32 Tfound = anIndex;
  569.   Uint64 Tkey64;
  570.   Uint32* Tkey32 = (Uint32*)&Tkey64;
  571.   Tkey32[0] = aBase;
  572.   Uint32 hash;
  573.   for (Uint32 i = anIndex; i < (anIndex + MAX_SEEK); i++) {
  574.     Tkey32[1] = (Uint32)i;
  575.     hash = md5_hash((Uint64*)&Tkey64, (Uint32)2);
  576.     hash = (hash >> 6) & (MAX_PARTS - 1);
  577.     if (hash == tLocalPart) {
  578.       Tfound = i;
  579.       break;
  580.     }//if
  581.   }//for
  582.   return Tfound;
  583. }//getKey()
  585. static void
  586. executeCallback(int result, NdbConnection* NdbObject, void* aObject)
  587. {
  588.   if (result == -1) {
  590.               // Add complete error handling here
  592.               int retCode = flexAsynchErrorData->handleErrorCommon(NdbObject->getNdbError());
  593.               if (retCode == 1) {
  594. if (NdbObject->getNdbError().code != 626 && NdbObject->getNdbError().code != 630){
  595.                 ndbout_c("execute: %s", NdbObject->getNdbError().message);
  596.                 ndbout_c("Error code = %d", NdbObject->getNdbError().code);}
  597.               } else if (retCode == 2) {
  598.                 ndbout << "4115 should not happen in flexAsynch" << endl;
  599.               } else if (retCode == 3) {
  600. /* What can we do here? */
  601.                 ndbout_c("execute: %s", NdbObject->getNdbError().message);
  602.                  }//if(retCode == 3)
  604.       //    ndbout << "Error occured in poll:" << endl;
  605.       //    ndbout << NdbObject->getNdbError() << endl;
  606.     failed++ ;
  607.     return;
  608.   }//if
  609.   return;
  610. }//executeCallback()
  614. static void
  615. defineOperation(NdbConnection* localNdbConnection, StartType aType,
  616.                 Uint32 threadBase, Uint32 aIndex)
  617. {
  618.   NdbOperation*  localNdbOperation;
  619.   unsigned int   loopCountAttributes = tNoOfAttributes;
  620.   unsigned int   countAttributes;
  621.   Uint32         attrValue[MAXATTRSIZE];
  623.   //-------------------------------------------------------
  624.   // Set-up the attribute values for this operation.
  625.   //-------------------------------------------------------
  626.   attrValue[0] = threadBase;
  627.   attrValue[1] = aIndex;
  628.   for (int k = 2; k < loopCountAttributes; k++) {
  629.     attrValue[k] = aIndex;
  630.   }//for
  631.   localNdbOperation = localNdbConnection->getNdbOperation(tableName[0]);        
  632.   if (localNdbOperation == NULL) {
  633.     error_handler(localNdbConnection->getNdbError());
  634.   }//if
  635.   switch (aType) {
  636.   case stInsert: {   // Insert case
  637.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  638.       localNdbOperation->dirtyWrite();
  639.     } else if (theWriteFlag == 1) {
  640.       localNdbOperation->writeTuple();
  641.     } else {
  642.       localNdbOperation->insertTuple();
  643.     }//if
  644.     break;
  645.   }//case
  646.   case stRead: {     // Read Case
  647.     if (theSimpleFlag == 1) {
  648.       localNdbOperation->simpleRead();
  649.     } else if (theDirtyFlag == 1) {
  650.       localNdbOperation->dirtyRead();
  651.     } else {
  652.       localNdbOperation->readTuple();
  653.     }//if
  654.     break;
  655.   }//case
  656.   case stUpdate: {    // Update Case
  657.     if (theWriteFlag == 1 && theDirtyFlag == 1) {
  658.       localNdbOperation->dirtyWrite();
  659.     } else if (theWriteFlag == 1) {
  660.       localNdbOperation->writeTuple();
  661.     } else if (theDirtyFlag == 1) {
  662.       localNdbOperation->dirtyUpdate();
  663.     } else {
  664.       localNdbOperation->updateTuple();
  665.     }//if
  666.     break;
  667.   }//case
  668.   case stDelete: {   // Delete Case
  669.     localNdbOperation->deleteTuple();
  670.     break;
  671.   }//case
  672.   default: {
  673.     error_handler(localNdbOperation->getNdbError()); 
  674.   }//default
  675.   }//switch
  676.   localNdbOperation->equal((Uint32)0,(char*)&attrValue[0]);
  677.   switch (aType) {
  678.   case stInsert:      // Insert case
  679.   case stUpdate:      // Update Case
  680.     {
  681.       for (countAttributes = 1;
  682.            countAttributes < loopCountAttributes; countAttributes++) {
  683.         localNdbOperation->setValue(countAttributes, 
  684.                                     (char*)&attrValue[0]);
  685.       }//for
  686.       break;
  687.     }//case
  688.   case stRead: {      // Read Case
  689.     for (countAttributes = 1;
  690.          countAttributes < loopCountAttributes; countAttributes++) {
  691.       localNdbOperation->getValue(countAttributes, 
  692.                                   (char*)&attrValue[0]);
  693.     }//for
  694.     break;
  695.   }//case
  696.   case stDelete: {    // Delete Case
  697.     break;
  698.   }//case
  699.   default: {
  700.     //goto error_handler; < epaulsa
  701.     error_handler(localNdbOperation->getNdbError());
  702.   }//default
  703.   }//switch
  704.   return;
  705. }//defineOperation()
  707. static void setAttrNames()
  708. {
  709.   int i;
  711.   for (i = 0; i < MAXATTR ; i++){
  712.     BaseString::snprintf(attrName[i], MAXSTRLEN, "COL%d", i);
  713.   }
  714. }
  717. static void setTableNames()
  718. {
  719.   // Note! Uses only uppercase letters in table name's
  720.   // so that we can look at the tables wits SQL
  721.   int i;
  722.   for (i = 0; i < MAXTABLES ; i++){
  723.     if (theStdTableNameFlag==0){
  724.       BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d_%d", i, 
  725.                (int)(NdbTick_CurrentMillisecond()/1000));
  726.     } else {
  727.       BaseString::snprintf(tableName[i], MAXSTRLEN, "TAB%d", i);
  728.     }
  729.   }
  730. }
  732. static
  733. int 
  734. createTables(Ndb* pMyNdb){
  736.   NdbSchemaCon          *MySchemaTransaction;
  737.   NdbSchemaOp           *MySchemaOp;
  738.   int                   check;
  740.   if (theTableCreateFlag == 0) {
  741.     for(int i=0; i < 1 ;i++) {
  742.       ndbout << "Creating " << tableName[i] << "..." << endl;
  743.       MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pMyNdb);
  744.       
  745.       if(MySchemaTransaction == NULL && 
  746.          (!error_handler(MySchemaTransaction->getNdbError())))
  747.         return -1;
  748.       
  749.       MySchemaOp = MySchemaTransaction->getNdbSchemaOp();       
  750.       if(MySchemaOp == NULL &&
  751.          (!error_handler(MySchemaTransaction->getNdbError())))
  752.         return -1;
  755.       check = MySchemaOp->createTable( tableName[i]
  756.                                        ,8                       // Table Size
  757.                                        ,TupleKey                // Key Type
  758.                                        ,40                      // Nr of Pages
  759.                                        ,All
  760.                                        ,6
  761.                                        ,(tLoadFactor - 5)
  762.                                        ,(tLoadFactor)
  763.                                        ,1
  764.                                        ,!tempTable
  765.                                        );
  766.       
  767.       if (check == -1 &&
  768.           (!error_handler(MySchemaTransaction->getNdbError())))
  769.         return -1;
  770.       
  771.       check = MySchemaOp->createAttribute( (char*)attrName[0],
  772.                                            TupleKey,
  773.                                            32,
  774.                                            PKSIZE,
  775.                                            UnSigned,
  776.                                            MMBased,
  777.                                            NotNullAttribute );
  778.       
  779.       if (check == -1 &&
  780.           (!error_handler(MySchemaTransaction->getNdbError())))
  781.         return -1;
  782.       for (int j = 1; j < tNoOfAttributes ; j++){
  783.         check = MySchemaOp->createAttribute( (char*)attrName[j],
  784.                                              NoKey,
  785.                                              32,
  786.                                              tAttributeSize,
  787.                                              UnSigned,
  788.                                              MMBased,
  789.                                              NotNullAttribute );
  790.         if (check == -1 &&
  791.             (!error_handler(MySchemaTransaction->getNdbError())))
  792.           return -1;
  793.       }
  794.       
  795.       if (MySchemaTransaction->execute() == -1 &&
  796.           (!error_handler(MySchemaTransaction->getNdbError())))
  797.         return -1;
  798.       
  799.       NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  800.     }
  801.   }
  802.   
  803.   return 0;
  804. }
  806. static
  807. bool error_handler(const NdbError & err){
  808.   ndbout << err << endl ;
  809.   switch(err.classification){
  810.   case NdbError::TemporaryResourceError:
  811.   case NdbError::OverloadError:
  812.   case NdbError::SchemaError:
  813.     ndbout << endl << "Attempting to recover and continue now..." << endl ;
  814.     return true;
  815.   }
  816.   return false ; // return false to abort
  817. }
  818. static
  819. bool error_handler(const char* error_string, int error_int) {
  820.   ndbout << error_string << endl ;
  821.   if ((4008 == error_int) ||
  822.       (721 == error_int) ||
  823.       (266 == error_int)){
  824.     ndbout << endl << "Attempting to recover and continue now..." << endl ;
  825.     return true ; // return true to retry
  826.   }
  827.   return false ; // return false to abort
  828. }
  830. static
  831. int 
  832. readArguments(int argc, const char** argv){
  833.   
  834.   int i = 1;
  835.   while (argc > 1){
  836.     if (strcmp(argv[i], "-t") == 0){
  837.       tNoOfThreads = atoi(argv[i+1]);
  838.       if ((tNoOfThreads < 1) || (tNoOfThreads > MAXTHREADS)){
  839. ndbout_c("Invalid no of threads");
  840.         return -1;
  841.       }
  842.     } else if (strcmp(argv[i], "-p") == 0){
  843.       tNoOfParallelTrans = atoi(argv[i+1]);
  844.       if ((tNoOfParallelTrans < 1) || (tNoOfParallelTrans > MAXPAR)){
  845. ndbout_c("Invalid no of parallell transactions");
  846.         return -1;
  847.       }
  848.     } else if (strcmp(argv[i], "-load_factor") == 0){
  849.       tLoadFactor = atoi(argv[i+1]);
  850.       if ((tLoadFactor < 40) || (tLoadFactor > 99)){
  851. ndbout_c("Invalid load factor");
  852.         return -1;
  853.       }
  854.     } else if (strcmp(argv[i], "-c") == 0) {
  855.       tNoOfOpsPerTrans = atoi(argv[i+1]);
  856.       if (tNoOfOpsPerTrans < 1){
  857. ndbout_c("Invalid no of operations per transaction");
  858.         return -1;
  859.       }
  860.     } else if (strcmp(argv[i], "-o") == 0) {
  861.       tNoOfTransactions = atoi(argv[i+1]);
  862.       if (tNoOfTransactions < 1){
  863. ndbout_c("Invalid no of transactions");
  864.         return -1;
  865.       }
  866.     } else if (strcmp(argv[i], "-a") == 0){
  867.       tNoOfAttributes = atoi(argv[i+1]);
  868.       if ((tNoOfAttributes < 2) || (tNoOfAttributes > MAXATTR)){
  869. ndbout_c("Invalid no of attributes");
  870.         return -1;
  871.       }
  872.     } else if (strcmp(argv[i], "-n") == 0){
  873.       theStdTableNameFlag = 1;
  874.       argc++;
  875.       i--;
  876.     } else if (strcmp(argv[i], "-l") == 0){
  877.       tNoOfLoops = atoi(argv[i+1]);
  878.       if ((tNoOfLoops < 0) || (tNoOfLoops > 100000)){
  879. ndbout_c("Invalid no of loops");
  880.         return -1;
  881.       }
  882.     } else if (strcmp(argv[i], "-s") == 0){
  883.       tAttributeSize = atoi(argv[i+1]);
  884.       if ((tAttributeSize < 1) || (tAttributeSize > MAXATTRSIZE)){
  885. ndbout_c("Invalid attributes size");
  886.         return -1;
  887.       }
  888.     } else if (strcmp(argv[i], "-local") == 0){
  889.       tLocalPart = atoi(argv[i+1]);
  890.       tLocal = true;
  891.       startTransGuess = true;
  892.       if ((tLocalPart < 0) || (tLocalPart > MAX_PARTS)){
  893. ndbout_c("Invalid local part");
  894.         return -1;
  895.       }
  896.     } else if (strcmp(argv[i], "-simple") == 0){
  897.       theSimpleFlag = 1;
  898.       argc++;
  899.       i--;
  900.     } else if (strcmp(argv[i], "-adaptive") == 0){
  901.       tSendForce = 0;
  902.       argc++;
  903.       i--;
  904.     } else if (strcmp(argv[i], "-force") == 0){
  905.       tSendForce = 1;
  906.       argc++;
  907.       i--;
  908.     } else if (strcmp(argv[i], "-non_adaptive") == 0){
  909.       tSendForce = 2;
  910.       argc++;
  911.       i--;
  912.     } else if (strcmp(argv[i], "-write") == 0){
  913.       theWriteFlag = 1;
  914.       argc++;
  915.       i--;
  916.     } else if (strcmp(argv[i], "-dirty") == 0){
  917.       theDirtyFlag = 1;
  918.       argc++;
  919.       i--;
  920.     } else if (strcmp(argv[i], "-test") == 0){
  921.       theTestFlag = 1;
  922.       argc++;
  923.       i--;
  924.     } else if (strcmp(argv[i], "-no_table_create") == 0){
  925.       theTableCreateFlag = 1;
  926.       argc++;
  927.       i--;
  928.     } else if (strcmp(argv[i], "-temp") == 0){
  929.       tempTable = true;
  930.       argc++;
  931.       i--;
  932.     } else if (strcmp(argv[i], "-no_hint") == 0){
  933.       startTransGuess = false;
  934.       argc++;
  935.       i--;
  936.     } else {
  937.       return -1;
  938.     }
  939.     
  940.     argc -= 2;
  941.     i = i + 2;
  942.   }//while
  943.   if (tLocal == true) {
  944.     if (tNoOfOpsPerTrans != 1) {
  945.       ndbout_c("Not valid to have more than one op per trans with local");
  946.     }//if
  947.     if (startTransGuess == false) {
  948.       ndbout_c("Not valid to use no_hint with local");
  949.     }//if
  950.   }//if
  951.   return 0;
  952. }
  954. static
  955. void
  956. input_error(){
  957.   
  958.   ndbout_c("FLEXASYNCH");
  959.   ndbout_c("   Perform benchmark of insert, update and delete transactions");
  960.   ndbout_c("");
  961.   ndbout_c("Arguments:");
  962.   ndbout_c("   -t Number of threads to start, default 1");
  963.   ndbout_c("   -p Number of parallel transactions per thread, default 32");
  964.   ndbout_c("   -o Number of transactions per loop, default 500");
  965.   ndbout_c("   -l Number of loops to run, default 1, 0=infinite");
  966.   ndbout_c("   -load_factor Number Load factor in index in percent (40 -> 99)");
  967.   ndbout_c("   -a Number of attributes, default 25");
  968.   ndbout_c("   -c Number of operations per transaction");
  969.   ndbout_c("   -s Size of each attribute, default 1 ");
  970.   ndbout_c("      (PK is always of size 1, independent of this value)");
  971.   ndbout_c("   -simple Use simple read to read from database");
  972.   ndbout_c("   -dirty Use dirty read to read from database");
  973.   ndbout_c("   -write Use writeTuple in insert and update");
  974.   ndbout_c("   -n Use standard table names");
  975.   ndbout_c("   -no_table_create Don't create tables in db");
  976.   ndbout_c("   -temp Create table(s) without logging");
  977.   ndbout_c("   -no_hint Don't give hint on where to execute transaction coordinator");
  978.   ndbout_c("   -adaptive Use adaptive send algorithm (default)");
  979.   ndbout_c("   -force Force send when communicating");
  980.   ndbout_c("   -non_adaptive Send at a 10 millisecond interval");
  981.   ndbout_c("   -local Number of part, only use keys in one part out of 16");
  982. }
  983.