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

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

MySQL数据库

开发平台：

Visual C++

perf.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. extern "C" {
  21. #include <dba.h>
  22. }
  24. #include <NdbOut.hpp>
  25. #include <NdbSleep.h>
  26. #include <NdbTimer.hpp>
  27. #include <NDBT_Stats.hpp>
  28. #include <NDBT_ReturnCodes.h>
  29. #include <NdbMain.h>
  30. #include <time.h>
  32. #undef min
  33. #undef max
  35. static const int NP_Insert      = 0;
  36. static const int NP_Update      = 1;
  37. static const int NP_WriteUpdate = 2;
  38. static const int NP_WriteInsert = 3;
  39. static const int NP_Delete      = 4;
  40. static const int NP_BulkRead    = 5;
  41. static const int NP_MAX         = 5;
  43. static const char * Operations[] = {
  44.   "Insert  ",
  45.   "Update  ",
  46.   "WriteUpd",
  47.   "WriteIns",
  48.   "Delete  ",
  49.   "BulkRead"
  50. };
  52. /**
  53.  * Configuration variables
  54.  */
  55. static int NoOfTransactions         = 10000;
  56. static int ParallellTransactions    = 1000;
  57. static int OperationsPerTransaction = 10;
  58. static int NoOfColumns              = 20;
  59. static int BytesPerInsert           = 300;
  60. static int BytesPerUpdate           = 200;
  61. static int LoopCount                = 10;
  63. /**
  64.  * Global variables
  65.  */
  66. static char TableName[255];
  67. static DBA_ColumnDesc_t    * ColumnDescriptions;
  68. static DBA_ColumnBinding_t * InsertBindings;
  69. static DBA_ColumnBinding_t * UpdateBindings; static int UpdateBindingColumns;
  70. static DBA_ColumnBinding_t * DeleteBindings;
  72. static char * TestData;
  73. static DBA_Binding_t * InsertB;
  74. static DBA_Binding_t * UpdateB;
  75. static DBA_Binding_t * DeleteB;
  77. /**
  78.  * Function prototypes
  79.  */
  80. static void sequence(int loops);
  82. inline void * getPtr(int rowNo) { return TestData+rowNo*BytesPerInsert;}
  83. inline void   setPK(int rowNo, int pk){ * (int *)getPtr(rowNo) = pk; }
  85. static void SetupTestData();
  86. static void CleanupTestData();
  88. static bool CreateTable();
  89. static bool CleanTable();
  90. static bool CreateBindings();
  92. static void usage();
  94. static
  95. void
  96. usage(){
  97.   int ForceSend, Interval;
  98.   DBA_GetParameter(0, &Interval);
  99.   DBA_GetParameter(3, &ForceSend);
  101.   ndbout << "newtonPerf" << endl
  102.  << "   -n Transactions per loop and operation (" 
  103.  << NoOfTransactions << ")" << endl
  104.  << "   -p parallell transactions (" << ParallellTransactions << ")"
  105.  << endl
  106.  << "   -o operations per transaction (" << OperationsPerTransaction 
  107.  << ")" << endl
  108.  << "   -a no of columns (" << NoOfColumns << ")" << endl
  109.  << "   -b Table size in bytes (" << BytesPerInsert << ")" << endl
  110.  << "   -u Bytes per update (" << BytesPerUpdate << ")" << endl
  111.  << "   -l Loop count (" << LoopCount << ")" << endl
  112.  << "   -i Interval (" << Interval << "ms)" << endl
  113.  << "   -f Force send algorithm (" << ForceSend << ")" << endl
  114.  << "   -h Help" << endl;
  116. }
  118. static
  119. bool
  120. parseArgs(int argc, const char **argv){
  121.   bool a = false, b = false, u = false;
  123.   for(int i = 1; i<argc; i++){
  124.     if(argv[i][0] != '-'){
  125.       ndbout << "Invalid argument: " << argv[i] << endl;
  126.       return false;
  127.     }
  129.     if(argv[i][1] == 'h')
  130.       return false;
  131.     
  132.     if(i == argc-1){
  133.       ndbout << "Expecting argument to " << argv[i] << endl;
  134.       return false;
  135.     }
  136.     
  137.     switch(argv[i][1]){
  138.     case 'n':
  139.       NoOfTransactions = atoi(argv[i+1]);
  140.       break;
  141.     case 'p':
  142.       ParallellTransactions = atoi(argv[i+1]);
  143.       break;
  144.     case 'o':
  145.       OperationsPerTransaction = atoi(argv[i+1]);
  146.       break;
  147.     case 'a':
  148.       NoOfColumns = atoi(argv[i+1]);
  149.       a = true;
  150.       break;
  151.     case 'b':
  152.       BytesPerInsert = atoi(argv[i+1]);
  153.       b = true;
  154.       break;
  155.     case 'u':
  156.       BytesPerUpdate = atoi(argv[i+1]);
  157.       u = true;
  158.       break;
  159.     case 'l':
  160.       LoopCount = atoi(argv[i+1]);
  161.       break;
  162.     case 'f':
  163.       {
  164. const int val = atoi(argv[i+1]);
  165. if(DBA_SetParameter(3, val) != DBA_NO_ERROR){
  166.   ndbout << "Invalid force send algorithm: "  
  167.  << DBA_GetLatestErrorMsg()
  168.  << "(" << DBA_GetLatestError() << ")" << endl;
  169.   return false;
  170. }
  171.       }
  172.       break;
  173.     case 'i':
  174.       {
  175. const int val = atoi(argv[i+1]);
  176. if(DBA_SetParameter(0, val) != DBA_NO_ERROR){
  177.   ndbout << "Invalid NBP interval: " 
  178.  << DBA_GetLatestErrorMsg()
  179.  << "(" << DBA_GetLatestError() << ")" << endl;
  180.   return false;
  181. }
  182.       }
  183.       break;
  184.     default:
  185.       ndbout << "Invalid option: " << argv[i] << endl;
  186.       return false;
  187.     }
  188.     i++;
  189.   }
  190.   if(a && !b) BytesPerInsert = 15 * NoOfColumns;
  191.   if(!a && b) NoOfColumns = ((BytesPerInsert + 14) / 15)+1;
  192.   
  193.   if(!u)
  194.     BytesPerUpdate = (2 * BytesPerInsert) / 3;
  196.   bool t = true;
  197.   if(NoOfColumns < 2) t = false;
  198.   if(BytesPerInsert < 8) t = false;
  199.   if(BytesPerUpdate < 8) t = false;
  200.   
  201.   if(!t){
  202.     ndbout << "Invalid arguments combination of -a -b -u not working out" 
  203.    << endl;
  204.     return false;
  205.   }
  206.   return true;
  207. }
  209. NDB_COMMAND(newton_perf, "newton_perf",
  210.     "newton_perf", "newton_perf", 65535){ 
  211.   
  212.   if(!parseArgs(argc, argv)){
  213.     usage();
  214.     return NDBT_ProgramExit(NDBT_WRONGARGS);
  215.   }
  216.   
  217.   ndbout << "-----------" << endl;
  218.   usage();
  219.   ndbout << endl;
  221.   SetupTestData();
  222.   
  223.   DBA_Open();
  224.   
  225.   if(!CreateTable()){
  226.     DBA_Close();
  227.     CleanupTestData();
  228.     return 0;
  229.   }
  231.   if(!CreateBindings()){
  232.     DBA_Close();
  233.     CleanupTestData();
  234.     return 0;
  235.   }
  237.   CleanTable();
  238.   
  239.   sequence(LoopCount);
  240.   
  241.   DBA_Close();
  242.   CleanupTestData();
  244.   DBA_DestroyBinding(InsertB);
  245.   DBA_DestroyBinding(UpdateB);
  246.   DBA_DestroyBinding(DeleteB);
  247. }
  249. static
  250. void
  251. ErrorMsg(const char * s){
  252.   ndbout << s 
  253.  << ": " << DBA_GetLatestError() << "-" << DBA_GetLatestErrorMsg() 
  254.  << ", " << DBA_GetLatestNdbError()
  255.  << endl;
  256. }
  258. static
  259. int
  260. m4(int i){
  261.   const int j = i - (i & 3);
  262.   return j;
  263. }
  265. static
  266. void
  267. SetupTestData(){
  268.   ndbout << "Creating testdata" << endl;
  270.   ColumnDescriptions = new DBA_ColumnDesc_t[NoOfColumns];
  271.   InsertBindings = new DBA_ColumnBinding_t[NoOfColumns];
  272.   
  273.   const int sz = m4((BytesPerInsert - ((NoOfColumns+1)/2)*4)/(NoOfColumns/2));
  274.   int sum = 0;
  275.   UpdateBindingColumns = 0;
  276.   for(int i = 0; i<NoOfColumns; i++){
  277.     char tmp[16];
  278.     if((i % 2) == 0){
  279.       sprintf(tmp, "I%d", i);
  280.       ColumnDescriptions[i].DataType = DBA_INT;
  281.       ColumnDescriptions[i].Size = 4;
  282.       sum += 4;
  283.     } else {
  284.       sprintf(tmp, "S%d", i);
  285.       ColumnDescriptions[i].DataType = DBA_CHAR;
  286.       ColumnDescriptions[i].Size = sz;
  287.       sum += sz;
  288.     }
  289.     ColumnDescriptions[i].IsKey = 0;
  290.     ColumnDescriptions[i].Name  = strdup(tmp);
  292.     InsertBindings[i].Name     = strdup(tmp);
  293.     InsertBindings[i].DataType = ColumnDescriptions[i].DataType;
  294.     InsertBindings[i].Size     = ColumnDescriptions[i].Size;
  295.     InsertBindings[i].Offset   = sum - ColumnDescriptions[i].Size;
  296.     InsertBindings[i].Ptr      = 0;
  297.     
  298.     if(sum <= BytesPerUpdate)
  299.       UpdateBindingColumns++;
  300.   }
  301.   if(UpdateBindingColumns == 1)
  302.     UpdateBindingColumns++;
  304.   ColumnDescriptions[0].IsKey = 1;
  305.   
  306.   assert(sum <= BytesPerInsert);
  307.   sprintf(TableName, "NEWTON_%d_%d", sum, NoOfColumns);
  308.   
  309.   UpdateBindings = new DBA_ColumnBinding_t[UpdateBindingColumns];
  310.   memcpy(UpdateBindings, InsertBindings, 
  311.  UpdateBindingColumns*sizeof(DBA_ColumnBinding_t));
  312.   
  313.   DeleteBindings = new DBA_ColumnBinding_t[1];
  314.   memcpy(DeleteBindings, InsertBindings, 
  315.  1*sizeof(DBA_ColumnBinding_t));
  316.   
  317.   TestData = (char *)malloc(NoOfTransactions * 
  318.     OperationsPerTransaction * BytesPerInsert);
  319.   
  320.   assert(TestData != 0);
  321.   for(int i = 0; i<NoOfTransactions; i++)
  322.     for(int j = 0; j<OperationsPerTransaction; j++){
  323.       const int pk = i * OperationsPerTransaction + j;
  324.       setPK(pk, pk);
  325.     }
  326. }
  328. static
  329. void
  330. CleanupTestData(){
  331.   free(TestData);
  332.   for(int i = 0; i<NoOfColumns; i++){
  333.     free((char*)ColumnDescriptions[i].Name);
  334.     free((char*)InsertBindings[i].Name);
  335.   }
  336.   delete [] ColumnDescriptions;
  337.   delete [] InsertBindings;
  338.   delete [] UpdateBindings;
  339.   delete [] DeleteBindings;
  340. }
  343. static bool CleanReturnValue = true;
  344. static int  CleanCallbacks = 0;
  345. static int  CleanRows = 0;
  347. extern "C"
  348. void
  349. CleanCallback(DBA_ReqId_t reqId, DBA_Error_t error, DBA_ErrorCode_t ec){
  350.   CleanCallbacks++;
  351.   if(error == DBA_NO_ERROR)
  352.     CleanRows++;
  353. }
  355. static
  356. bool
  357. CleanTable(){
  358.   ndbout << "Cleaning table..." << flush;
  359.   CleanReturnValue = true;
  360.   CleanCallbacks = 0;
  361.   CleanRows = 0;
  362.   for(int i = 0; i<NoOfTransactions * OperationsPerTransaction; i++){
  363.     DBA_ArrayDeleteRows(DeleteB, 
  364. getPtr(i), 1,
  365. CleanCallback);
  366.     while((i-CleanCallbacks)>ParallellTransactions)
  367.       NdbSleep_MilliSleep(100);
  368.   }
  369.   while(CleanCallbacks != (NoOfTransactions * OperationsPerTransaction))
  370.     NdbSleep_SecSleep(1);
  372.   ndbout << CleanRows << " rows deleted" << endl;
  373.   
  374.   return CleanReturnValue;
  375. }
  377. static
  378. bool
  379. CreateBindings(){
  380.   ndbout << "Creating bindings" << endl;
  381.   InsertB = UpdateB = DeleteB = 0;
  382.   
  383.   InsertB = DBA_CreateBinding(TableName, NoOfColumns, 
  384.        InsertBindings, BytesPerInsert);
  385.   if(InsertB == 0){
  386.     ErrorMsg("Failed to create insert bindings");
  387.     return false;
  388.   }
  390.   UpdateB = DBA_CreateBinding(TableName, UpdateBindingColumns,
  391.        UpdateBindings, BytesPerInsert);
  392.   if(UpdateB == 0){
  393.     ErrorMsg("Failed to create update bindings");
  394.     DBA_DestroyBinding(InsertB);
  395.     return false;
  396.   }
  398.   DeleteB = DBA_CreateBinding(TableName, 1, 
  399.        DeleteBindings, BytesPerInsert);
  400.   if(DeleteB == 0){
  401.     ErrorMsg("Failed to create delete bindings");
  402.     DBA_DestroyBinding(InsertB);
  403.     DBA_DestroyBinding(UpdateB);
  404.     return false;
  405.   }
  406.   return true;
  407. }
  409. static
  410. bool
  411. CreateTable(){
  412.   ndbout << "Creating " << TableName << endl;
  413.   return DBA_CreateTable( TableName, 
  414.   NoOfColumns, 
  415.   ColumnDescriptions ) == DBA_NO_ERROR;
  416. }
  418. /**
  419.  * 
  420.  */
  421. static NdbTimer SequenceTimer;
  423. static int CurrentOp    = NP_Insert;
  424. static int SequenceSent = 0;
  425. static int SequenceRecv = 0;
  426. static NDBT_Stats SequenceStats[NP_MAX][4];
  427. static NDBT_Stats SequenceLatency[NP_MAX];
  429. static int           HashMax;
  430. static DBA_ReqId_t * ReqHash;    // ReqId - Latency/Row 
  431. static int         * ReqHashPos; // (row in StartTime)
  433. static int SequenceLatencyPos;
  434. static NDB_TICKS   * StartTime; 
  436. static
  437. inline
  438. int
  439. computeHashMax(int elements){
  440.   HashMax = 1;
  441.   while(HashMax < elements)
  442.     HashMax *= 2;
  443.   
  444.   if(HashMax < 1024)
  445.     HashMax = 1024;
  446.   
  447.   return HashMax;
  448. }
  450. static 
  451. inline
  452. int
  453. hash(DBA_ReqId_t request){
  454.   int r = (request >> 2) & (HashMax-1);
  455.   return r;
  456. }
  457.  
  458. static
  459. inline
  460. void
  461. addRequest(DBA_ReqId_t request, int pos){
  462.   
  463.   int i = hash(request);
  464.   
  465.   while(ReqHash[i] != 0)
  466.     i = ((i + 1) & (HashMax-1));
  467.   
  468.   ReqHash[i] = request;
  469.   ReqHashPos[i] = pos;
  470. }
  471.  
  472. static
  473. inline
  474. int
  475. getRequest(DBA_ReqId_t request){
  476.   
  477.   int i = hash(request);
  478.   
  479.   while(ReqHash[i] != request)
  480.     i = ((i + 1) & (HashMax-1));
  481.   
  482.   ReqHash[i] = 0;
  483.   
  484.   return ReqHashPos[i];
  485. }
  487. extern "C"
  488. void
  489. SequenceCallback(DBA_ReqId_t reqId, DBA_Error_t error, DBA_ErrorCode_t ec){
  490.   int p = getRequest(reqId) - 1;
  491.   
  492.   if(error != DBA_NO_ERROR){
  493.     ndbout << "p = " << p << endl;
  494.     ndbout << "DBA_GetErrorMsg(" << error << ") = " 
  495.    << DBA_GetErrorMsg(error) << endl;
  496.     ndbout << "DBA_GetNdbErrorMsg(" << ec << ") = " 
  497.    << DBA_GetNdbErrorMsg(ec) << endl;
  498.     
  499.     assert(error == DBA_NO_ERROR);
  500.   }
  501.   
  502.   SequenceRecv++;
  503.   if(SequenceRecv == NoOfTransactions){
  504.     SequenceTimer.doStop();
  505.   }
  507.   if((p & 127) == 127){
  508.     NDB_TICKS t = NdbTick_CurrentMillisecond() - StartTime[p];
  509.     SequenceLatency[CurrentOp].addObservation(t);
  510.   }
  511. }
  513. typedef DBA_ReqId_t (* DBA_ArrayFunction)( const DBA_Binding_t* pBindings, 
  514.    const void * pData,
  515.    int NbRows,
  516.    DBA_AsyncCallbackFn_t CbFunc );
  518. inline
  519. int
  520. min(int a, int b){
  521.   return a > b ? b : a;
  522. }
  524. static
  525. void
  526. SequenceOp(DBA_ArrayFunction func, const DBA_Binding_t* pBindings, int op){
  527.   SequenceSent = 0;
  528.   SequenceRecv = 0;
  529.   SequenceLatencyPos = 1;
  530.   CurrentOp = op;
  532.   SequenceTimer.doStart();
  533.   for(int i = 0; i<NoOfTransactions; ){
  534.     const int l1 = ParallellTransactions - (SequenceSent - SequenceRecv);
  535.     const int l2 = min(NoOfTransactions - i, l1);
  536.     for(int j = 0; j<l2; j++){
  537.       const DBA_ReqId_t r = func(pBindings, 
  538.  getPtr(i*OperationsPerTransaction),
  539.  OperationsPerTransaction,
  540.  SequenceCallback);
  541.       assert(r != 0);
  542.       SequenceSent++;
  543.       addRequest(r, i + 1);
  544.       i++;
  545.       
  546.       if((SequenceSent & 127) == 127){
  547. NDB_TICKS t = NdbTick_CurrentMillisecond();
  548. StartTime[i] = t;
  549.       } 
  550.     }
  551.     if(l2 == 0)
  552.       NdbSleep_MilliSleep(10);
  553.   }
  555.   while(SequenceRecv != SequenceSent)
  556.     NdbSleep_SecSleep(1);
  557.   
  558.   ndbout << "Performed " << NoOfTransactions << " " << Operations[op]
  559.  << " in ";
  560.   
  561.   double p = NoOfTransactions * 1000;
  562.   double t = SequenceTimer.elapsedTime();
  563.   double o = p * OperationsPerTransaction;
  564.   
  565.   p /= t;
  566.   o /= t;
  568.   int _p = p;
  569.   int _o = o;
  571.   double b = 0;
  573.   switch(op){
  574.   case NP_Insert:
  575.   case NP_WriteInsert:
  576.   case NP_WriteUpdate:
  577.   case NP_BulkRead:
  578.     b = BytesPerInsert;
  579.     break;
  580.   case NP_Update:
  581.     b = BytesPerUpdate;
  582.     break;
  583.   case NP_Delete:
  584.     b = 4;
  585.     break;
  586.   default:
  587.     b = 0;
  588.   }
  589.   b *= NoOfTransactions * OperationsPerTransaction;
  590.   b /= t;
  591.   int _b = b;
  593.   SequenceStats[op][0].addObservation(t);
  594.   SequenceStats[op][1].addObservation(p);
  595.   SequenceStats[op][2].addObservation(o);
  596.   SequenceStats[op][3].addObservation(b);
  597.   
  598.   int t2 = SequenceStats[op][0].getMean();
  599.   int p2 = SequenceStats[op][1].getMean();
  600.   int o2 = SequenceStats[op][2].getMean();
  601.   int b2 = SequenceStats[op][3].getMean();
  603.   ndbout << SequenceTimer.elapsedTime() << "(" << t2 << ")ms";
  604.   ndbout << " -> " << _p << "(" << p2 << ") T/s - " << _o 
  605.  << "(" << o2 << ") O/s - " << _b << "(" << b2 << ") Kb/s" << endl;
  607.   ndbout << "  Latency (ms) Avg: " << (int)SequenceLatency[op].getMean()
  608.  << " min: " << (int)SequenceLatency[op].getMin() 
  609.  << " max: " << (int)SequenceLatency[op].getMax()
  610.  << " stddev: " << (int)SequenceLatency[op].getStddev() 
  611.  << " n: " << SequenceLatency[op].getCount() << endl;
  612. }
  614. /**
  615.  * Sequence 
  616.  */
  617. static
  618. void
  619. sequence(int loops){
  620.   computeHashMax(ParallellTransactions);
  621.   ReqHash    = new DBA_ReqId_t[HashMax];
  622.   ReqHashPos = new int[HashMax];
  623.   StartTime  = new NDB_TICKS[NoOfTransactions];
  624.   
  625.   for(int i = 0; i<NP_MAX; i++){
  626.     SequenceLatency[i].reset();
  627.     for(int j = 0; j<4; j++)
  628.       SequenceStats[i][j].reset();
  629.   }
  630.   for(int i = 0; i<loops; i++){
  631.     ndbout << "Loop #" << (i+1) << endl;
  632.     SequenceOp(DBA_ArrayInsertRows, InsertB, NP_Insert);
  634.     // BulkRead
  635.     
  636.     SequenceOp(DBA_ArrayUpdateRows, UpdateB, NP_Update);
  637.     SequenceOp(DBA_ArrayWriteRows,  InsertB, NP_WriteUpdate);
  638.     SequenceOp(DBA_ArrayDeleteRows, DeleteB, NP_Delete);
  639.     SequenceOp(DBA_ArrayWriteRows,  InsertB, NP_WriteInsert);
  640.     SequenceOp(DBA_ArrayDeleteRows, DeleteB, NP_Delete);
  641.     ndbout << "-------------------" << endl << endl;
  642.   }
  644.   delete [] ReqHash;
  645.   delete [] ReqHashPos;
  646.   delete [] StartTime;
  647. }