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

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

MySQL数据库

开发平台：

Visual C++

AsyncFileTest.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. //#define TESTDEBUG 1
  19. #include <ndb_global.h>
  21. #include <kernel_types.h>
  22. #include <Pool.hpp>
  23. #include "AsyncFile.hpp"
  24. #include "NdbOut.hpp"
  25. #include "NdbTick.h"
  26. #include "NdbThread.h"
  27. #include "NdbMain.h"
  29. // Test and benchmark functionality of AsyncFile
  30. // -n Number of files
  31. // -r Number of simultaneous requests
  32. // -s Filesize, number of pages
  33. // -l Number of iterations
  34. // -remove, remove files after close
  35. // -reverse, write files in reverse order, start with the last page
  37. #define MAXFILES 255
  38. #define DEFAULT_NUM_FILES 1
  39. #define MAXREQUESTS 256
  40. #define DEFAULT_NUM_REQUESTS 1
  41. #define MAXFILESIZE 4096
  42. #define DEFAULT_FILESIZE 2048
  43. #define FVERSION 0x01000000
  44. #define PAGESIZE 8192
  46. #define TIMER_START { Uint64 starttick = NdbTick_CurrentMillisecond()
  47. #define TIMER_PRINT(str, ops) Uint64 stoptick = NdbTick_CurrentMillisecond();
  48.             Uint64 totaltime = (stoptick-starttick);  
  49.             ndbout << ops << " " << str << 
  50.     " total time " << (int)totaltime << "ms" << endl;
  51.             char buf[255];
  52.             sprintf(buf,  "%d %s/secn",(int)((ops*1000)/totaltime), str);
  53.             ndbout <<buf << endl;}
  55. static int numberOfFiles = DEFAULT_NUM_FILES;
  56. static int numberOfRequests = DEFAULT_NUM_REQUESTS;
  57. static int fileSize = DEFAULT_FILESIZE;
  58. static int removeFiles = 0;
  59. static int writeFilesReverse = 0;
  60. static int numberOfIterations = 1;
  61. Uint32 FileNameArray[4];
  63. Pool<AsyncFile>* files;
  64. AsyncFile* openFiles[MAXFILES];
  65. Pool<Request>* theRequestPool;
  66. MemoryChannelMultipleWriter<Request>* theReportChannel;
  68. char WritePages[MAXFILES][PAGESIZE];
  69. char ReadPages[MAXFILES][PAGESIZE];
  71. int readArguments(int argc, const char** argv);
  72. int openFile(int fileNum);
  73. int openFileWait();
  74. int closeFile(int fileNum);
  75. int closeFileWait();
  76. int writeFile( int fileNum, int pagenum);
  77. int writeFileWait();
  78. int writeSyncFile( int fileNum, int pagenum);
  79. int writeSyncFileWait();
  80. int readFile( int fileNum, int pagenum);
  81. int readFileWait();
  84. NDB_COMMAND(aftest, "aftest", "aftest [-n <Number of files>] [-r <Number of simultaneous requests>] [-s <Filesize, number of pages>] [-l <Number of iterations>] [-remove, remove files after close] [-reverse, write files in reverse order, start with the last page]", "Test the AsyncFile class of Ndb", 8192)
  85. {
  86.   int s, numReq, numOps;
  88.   readArguments(argc, argv);
  89.    
  90.   files = new Pool<AsyncFile>(numberOfFiles, 2);
  91.   theRequestPool = new Pool<Request>;
  92.   theReportChannel = new MemoryChannelMultipleWriter<Request>;
  94.   ndbout << "AsyncFileTest starting" << endl;
  95.   ndbout << "  " << numberOfFiles << " files" << endl;
  96.   ndbout << "  " << numberOfRequests << " requests" << endl;
  97.   ndbout << "  " << fileSize << " * 8k files" << endl << endl;
  98.   ndbout << "  " << numberOfIterations << " iterations" << endl << endl;
  100.   NdbThread_SetConcurrencyLevel(numberOfFiles+2);
  102.   // initialize data to write to files
  103.   for (int i = 0; i < MAXFILES; i++) {
  104.     for (int j = 0; j < PAGESIZE; j++){
  105.       WritePages[i][j] = (64+i+j)%256;
  106.     }
  107.       //      memset(&WritePages[i][0], i+64, PAGESIZE);
  108.   }
  110.   // Set file directory and name
  111.   // /T27/F27/NDBFS/S27Pnn.data
  112.   FileNameArray[0] = 27; // T27
  113.   FileNameArray[1] = 27; // F27
  114.   FileNameArray[2] = 27; // S27 
  115.   FileNameArray[3] = FVERSION; // Version
  116.   
  117.   for (int l = 0; l < numberOfIterations; l++)
  118.     {
  120.   ndbout << "Opening files" << endl;
  121.   // Open files
  122.   for (int f = 0; f < numberOfFiles; f++)
  123.   {
  124.       openFile(f);
  125.  
  126.   }
  128.   // Wait for answer
  129.   openFileWait();
  131.   ndbout << "Files opened!" << endl<< endl;
  133.   // Write to files
  134.   ndbout << "Started writing" << endl;
  135.   TIMER_START;
  136.   s = 0;
  137.   numReq = 0;
  138.   numOps = 0;
  139.   while ( s < fileSize)
  140.   {
  141.     for (int r = 0; r < numberOfRequests; r++)
  142.     {
  143.       for (int f = 0; f < numberOfFiles; f++)
  144.       {
  145. writeFile(f, s);
  146. numReq++;
  147. numOps++;
  148.       }
  149.       
  150.       s++;
  151.     }
  152.     
  153.     while (numReq > 0)
  154.       {
  155. writeFileWait();
  156. numReq--;
  157.       }
  159.   }
  161.   TIMER_PRINT("writes", numOps);
  164.   ndbout << "Started reading" << endl;
  165.   TIMER_START;
  167.   // Read from files
  168.   s = 0;
  169.   numReq = 0;
  170.   numOps = 0;
  171.   while ( s < fileSize)
  172.   {
  173.     for (int r = 0; r < numberOfRequests; r++)
  174.     {
  175.       for (int f = 0; f < numberOfFiles; f++)
  176.       {
  177. readFile(f, s);
  178. numReq++;
  179. numOps++;
  180.       }
  181.       
  182.       s++;
  183.       
  184.     }
  185.     
  186.     while (numReq > 0)
  187.       {
  188. readFileWait();
  189. numReq--;
  190.       }
  192.   }
  193.   TIMER_PRINT("reads", numOps);
  195.   ndbout << "Started writing with sync" << endl;
  196.   TIMER_START;
  198.   // Write to files
  199.   s = 0;
  200.   numReq = 0;
  201.   numOps = 0;
  202.   while ( s < fileSize)
  203.   {
  204.     for (int r = 0; r < numberOfRequests; r++)
  205.     {
  206.       for (int f = 0; f < numberOfFiles; f++)
  207.       {
  208. writeSyncFile(f, s);
  209. numReq++;
  210. numOps++;
  211.       }
  212.       
  213.       s++;
  214.     }
  215.     
  216.     while (numReq > 0)
  217.       {
  218. writeSyncFileWait();
  219. numReq--;
  220.       }
  222.   }
  224.   TIMER_PRINT("writeSync", numOps);
  225.   
  226.   // Close files
  227.   ndbout << "Closing files" << endl;
  228.   for (int f = 0; f < numberOfFiles; f++)
  229.   {
  230.       closeFile(f);
  231.  
  232.   }
  234.   // Wait for answer
  235.   closeFileWait();
  237.   ndbout << "Files closed!" << endl<< endl;
  238.     }
  240.   // Deallocate memory
  241.   delete files;
  242.   delete theReportChannel;
  243.   delete theRequestPool;
  245.   return 0;
  247. }
  251. int forward( AsyncFile * file, Request* request )
  252. {
  253.    file->execute(request);
  254.    ERROR_CHECK 0;
  255.    return 1;
  256. }
  258. int openFile( int fileNum)
  259. {
  260.   AsyncFile* file = (AsyncFile *)files->get();
  262.   FileNameArray[3] = fileNum | FVERSION;
  263.   file->fileName().set( NDBFS_REF, &FileNameArray[0] );
  264.   ndbout << "openFile: " << file->fileName().c_str() << endl;
  265.   
  266.   if( ERROR_STATE ) {
  267.      ERROR_RESET;
  268.      files->put( file );
  269.      ndbout <<  "Failed to set filename" << endl;
  270.      return 1;
  271.   }
  272.   file->reportTo(theReportChannel);
  273.           
  274.   Request* request = theRequestPool->get();
  275.   request->action= Request::open;
  276.   request->error= 0;
  277.   request->par.open.flags = 0x302; //O_RDWR | O_CREAT | O_TRUNC ; // 770
  278.   request->set(NDBFS_REF, 0x23456789, fileNum );
  279.   request->file = file;
  280.   
  281.   if (!forward(file,request)) {
  282.      // Something went wrong
  283.      ndbout << "Could not forward open request" << endl;
  284.      theRequestPool->put(request);
  285.      return 1;
  286.   }
  287.   return 0;
  288. }
  290. int closeFile( int fileNum)
  291. {
  293.   AsyncFile* file = openFiles[fileNum];
  294.           
  295.   Request* request = theRequestPool->get();
  296.   if (removeFiles == 1)
  297.     request->action = Request::closeRemove;
  298.   else
  299.     request->action= Request::close;
  301.   request->error= 0;
  302.   request->set(NDBFS_REF, 0x23456789, fileNum );
  303.   request->file = file;
  304.   
  305.   if (!forward(file,request)) {
  306.      // Something went wrong
  307.      ndbout << "Could not forward close request" << endl;
  308.      theRequestPool->put(request);
  309.      return 1;
  310.   }
  311.   return 0;
  312. }
  314. int writeFile( int fileNum, int pagenum)
  315. {
  316.   AsyncFile* file = openFiles[fileNum];
  317. #ifdef TESTDEBUG
  318.   ndbout << "writeFile" << fileNum <<": "<<pagenum<<", " << file->fileName().c_str()<< endl;
  319. #endif
  320.   Request *request = theRequestPool->get();
  321.   request->action = Request::write;
  322.   request->error = 0;
  323.   request->set(NDBFS_REF, pagenum, fileNum);
  324.   request->file = openFiles[fileNum];
  326.   // Write only one page, choose the correct page for each file using fileNum
  327.   request->par.readWrite.pages[0].buf = &WritePages[fileNum][0];
  328.   request->par.readWrite.pages[0].size = PAGESIZE;
  329.   if (writeFilesReverse == 1)
  330.   {
  331.     // write the last page in the files first
  332.     // This is a normal way for the Blocks in Ndb to write to a file
  333.      request->par.readWrite.pages[0].offset = (fileSize - pagenum - 1) * PAGESIZE;
  334.   }
  335.   else
  336.   {
  337.      request->par.readWrite.pages[0].offset = pagenum * PAGESIZE;
  338.   }
  339.   request->par.readWrite.numberOfPages = 1;
  340.   
  341.   if (!forward(file,request)) {
  342.      // Something went wrong
  343.      ndbout << "Could not forward write request" << endl;
  344.      theRequestPool->put(request);
  345.      return 1;
  346.   }
  347.   return 0;
  349. }
  351. int writeSyncFile( int fileNum, int pagenum)
  352. {
  353.   AsyncFile* file = openFiles[fileNum];
  354. #ifdef TESTDEBUG
  355.   ndbout << "writeFile" << fileNum <<": "<<pagenum<<", " << file->fileName().c_str() << endl;
  356. #endif
  357.   Request *request = theRequestPool->get();
  358.   request->action = Request::writeSync;
  359.   request->error = 0;
  360.   request->set(NDBFS_REF, pagenum, fileNum);
  361.   request->file = openFiles[fileNum];
  363.   // Write only one page, choose the correct page for each file using fileNum
  364.   request->par.readWrite.pages[0].buf = &WritePages[fileNum][0];
  365.   request->par.readWrite.pages[0].size = PAGESIZE;
  366.   request->par.readWrite.pages[0].offset = pagenum * PAGESIZE;
  367.   request->par.readWrite.numberOfPages = 1;
  368.   
  369.   if (!forward(file,request)) {
  370.      // Something went wrong
  371.      ndbout << "Could not forward write request" << endl;
  372.      theRequestPool->put(request);
  373.      return 1;
  374.   }
  375.   return 0;
  377. }
  379. int readFile( int fileNum, int pagenum)
  380. {
  381.   AsyncFile* file = openFiles[fileNum];
  382. #ifdef TESTDEBUG
  383.   ndbout << "readFile" << fileNum <<": "<<pagenum<<", " << file->fileName().c_str() << endl;
  384. #endif
  385.   Request *request = theRequestPool->get();
  386.   request->action = Request::read;
  387.   request->error = 0;
  388.   request->set(NDBFS_REF, pagenum, fileNum);
  389.   request->file = openFiles[fileNum];
  391.   // Read only one page, choose the correct page for each file using fileNum
  392.   request->par.readWrite.pages[0].buf = &ReadPages[fileNum][0];
  393.   request->par.readWrite.pages[0].size = PAGESIZE;
  394.   request->par.readWrite.pages[0].offset = pagenum * PAGESIZE;
  395.   request->par.readWrite.numberOfPages = 1;
  396.   
  397.   if (!forward(file,request)) {
  398.      // Something went wrong
  399.      ndbout << "Could not forward read request" << endl;
  400.      theRequestPool->put(request);
  401.      return 1;
  402.   }
  403.   return 0;
  405. }
  407. int openFileWait()
  408. {
  409.   int openedFiles = 0;
  410.   while (openedFiles < numberOfFiles)
  411.     {
  412.       Request* request = theReportChannel->readChannel();
  413.       if (request) 
  414. {
  415.   if (request->action == Request::open)
  416.     {       
  417.       if (request->error ==0)
  418. {
  419. #ifdef TESTDEBUG
  420.              ndbout << "Opened file " << request->file->fileName().c_str() << endl;
  421. #endif
  422.   openFiles[request->theFilePointer] = request->file;
  423. }
  424.       else
  425. {
  426.   ndbout << "error while opening file" << endl;
  427.   exit(1);
  428. }
  429.       theRequestPool->put(request);
  430.       openedFiles++;
  431.     }
  432.   else
  433.     {
  434.       ndbout << "Unexpected request received" << endl;
  435.     }
  436. }
  437.       else
  438. {
  439.   ndbout << "Nothing read from theReportChannel" << endl;
  440. }
  441.     }
  442.   return 0;
  443. }
  445. int closeFileWait()
  446. {
  447.   int closedFiles = 0;
  448.   while (closedFiles < numberOfFiles)
  449.     {
  450.       Request* request = theReportChannel->readChannel();
  451.       if (request) 
  452. {
  453.   if (request->action == Request::close || request->action == Request::closeRemove)
  454.     {       
  455.       if (request->error ==0)
  456. {
  457. #ifdef TESTDEBUG
  458.              ndbout << "Closed file " << request->file->fileName().c_str() << endl;
  459. #endif
  460.   openFiles[request->theFilePointer] = NULL;
  461.   files->put(request->file);
  462. }
  463.       else
  464. {
  465.   ndbout << "error while closing file" << endl;
  466.   exit(1);
  467. }
  468.       theRequestPool->put(request);
  469.       closedFiles++;
  470.     }
  471.   else
  472.     {
  473.       ndbout << "Unexpected request received" << endl;
  474.     }
  475. }
  476.       else
  477. {
  478.   ndbout << "Nothing read from theReportChannel" << endl;
  479. }
  480.     }
  481.   return 0;
  482. }
  484. int writeFileWait()
  485. {
  486.   Request* request = theReportChannel->readChannel();
  487.   if (request) 
  488.     {
  489.       if (request->action == Request::write)
  490. {       
  491.   if (request->error == 0)
  492.     {
  493. #ifdef TESTDEBUG
  494.       ndbout << "writeFileWait"<<request->theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl;
  495. #endif
  497.     }
  498.   else
  499.     {
  500.       ndbout << "error while writing file, error=" << request->error << endl;
  501.       exit(1);
  502.     }
  503.   theRequestPool->put(request);
  504. }
  505.       else
  506. {
  507.   ndbout << "Unexpected request received" << endl;
  508. }
  509.     }
  510.   else
  511.     {
  512.       ndbout << "Nothing read from theReportChannel" << endl;
  513.     }
  514.   return 0;
  515. }
  517. int writeSyncFileWait()
  518. {
  519.   Request* request = theReportChannel->readChannel();
  520.   if (request) 
  521.     {
  522.       if (request->action == Request::writeSync)
  523. {       
  524.   if (request->error == 0)
  525.     {
  526. #ifdef TESTDEBUG
  527.       ndbout << "writeFileWait"<<request->theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl;
  528. #endif
  530.     }
  531.   else
  532.     {
  533.       ndbout << "error while writing file" << endl;
  534.       exit(1);
  535.     }
  536.   theRequestPool->put(request);
  537. }
  538.       else
  539. {
  540.   ndbout << "Unexpected request received" << endl;
  541. }
  542.     }
  543.   else
  544.     {
  545.       ndbout << "Nothing read from theReportChannel" << endl;
  546.     }
  547.   return 0;
  548. }
  550. int readFileWait()
  551. {
  552.   Request* request = theReportChannel->readChannel();
  553.   if (request) 
  554.     {
  555.       if (request->action == Request::read)
  556. {       
  557.   if (request->error == 0)
  558.     {
  559. #ifdef TESTDEBUG
  560.       ndbout << "readFileWait"<<request->theFilePointer<<", " << request->theUserPointer<<" "<< request->file->fileName().c_str() << endl;
  561. #endif
  562.       if (memcmp(&(ReadPages[request->theFilePointer][0]), &(WritePages[request->theFilePointer][0]), PAGESIZE)!=0) 
  563. {
  564.   ndbout <<"Verification error!" << endl;
  565.   for (int i = 0; i < PAGESIZE; i++ ){
  566.     ndbout <<" Compare Page " <<  i << " : " << ReadPages[request->theFilePointer][i] <<", " <<WritePages[request->theFilePointer][i] << endl;;
  567.     if( ReadPages[request->theFilePointer][i] !=WritePages[request->theFilePointer][i])
  569.       exit(1);
  570.        }
  571. }
  573.     }
  574.   else
  575.     {
  576.       ndbout << "error while reading file" << endl;
  577.       exit(1);
  578.     }
  579.   theRequestPool->put(request);
  580. }
  581.       else
  582. {
  583.   ndbout << "Unexpected request received" << endl;
  584. }
  585.     }
  586.   else
  587.     {
  588.       ndbout << "Nothing read from theReportChannel" << endl;
  589.     }
  590.   return 0;
  591. }
  593. int readArguments(int argc, const char** argv)
  594. {
  596.   int i = 1;
  597.   while (argc > 1)
  598.   {
  599.     if (strcmp(argv[i], "-n") == 0)
  600.     {
  601.       numberOfFiles = atoi(argv[i+1]);
  602.       if ((numberOfFiles < 1) || (numberOfFiles > MAXFILES))
  603.       {
  604. ndbout << "Wrong number of files, default = "<<DEFAULT_NUM_FILES << endl;
  605.   numberOfFiles = DEFAULT_NUM_FILES;
  606.       }
  607.     }
  608.     else if (strcmp(argv[i], "-r") == 0)
  609.     {
  610.       numberOfRequests = atoi(argv[i+1]);
  611.       if ((numberOfRequests < 1) || (numberOfRequests > MAXREQUESTS))
  612.       {
  613. ndbout << "Wrong number of requests, default = "<<DEFAULT_NUM_REQUESTS << endl;
  614.   numberOfRequests = DEFAULT_NUM_REQUESTS;
  615.       }
  616.     }
  617.     else if (strcmp(argv[i], "-s") == 0)
  618.     {
  619.       fileSize = atoi(argv[i+1]);
  620.       if ((fileSize < 1) || (fileSize > MAXFILESIZE))
  621.       {
  622. ndbout << "Wrong number of 8k pages, default = "<<DEFAULT_FILESIZE << endl;
  623.   fileSize = DEFAULT_FILESIZE;
  624.       }
  625.     }
  626.     else if (strcmp(argv[i], "-l") == 0)
  627.     {
  628.       numberOfIterations = atoi(argv[i+1]);
  629.       if ((numberOfIterations < 1))
  630.       {
  631. ndbout << "Wrong number of iterations, default = 1" << endl;
  632. numberOfIterations = 1;
  633.       }
  634.     }
  635.     else if (strcmp(argv[i], "-remove") == 0)
  636.     {
  637.       removeFiles = 1;
  638.       argc++;
  639.       i--;
  640.     }
  641.     else if (strcmp(argv[i], "-reverse") == 0)
  642.     {
  643.       ndbout << "Writing files reversed" << endl;
  644.       writeFilesReverse = 1;
  645.       argc++;
  646.       i--;
  647.     }
  649.     argc -= 2;
  650.     i = i + 2;
  651.   }
  652.   
  653.   if ((fileSize % numberOfRequests)!= 0)
  654.     {
  655.     numberOfRequests = numberOfRequests - (fileSize % numberOfRequests);
  656.     ndbout <<"numberOfRequest must be modulo of filesize" << endl;
  657.     ndbout << "New numberOfRequest="<<numberOfRequests<<endl;
  658.     }
  659.   return 0;
  660. }
  663. // Needed for linking...
  665. void ErrorReporter::handleError(ErrorCategory type, int messageID,
  666.                                 const char* problemData, const char* objRef, NdbShutdownType stype)
  667. {
  669.   ndbout << "ErrorReporter::handleError activated" << endl;
  670.   ndbout << "type= " << type << endl; 
  671.   ndbout << "messageID= " << messageID << endl;
  672.   ndbout << "problemData= " << problemData << endl;
  673.   ndbout << "objRef= " << objRef << endl;
  675.   exit(1);
  676. }
  678. void ErrorReporter::handleAssert(const char* message, const char* file, int line)
  679. {
  680.   ndbout << "ErrorReporter::handleAssert activated" << endl;
  681.   ndbout << "message= " << message << endl;
  682.   ndbout << "file= " << file << endl;
  683.   ndbout << "line= " << line << endl;
  684.   exit(1);
  685. }
  688. GlobalData globalData;
  691. Signal::Signal()
  692. {
  694. }