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

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

MySQL数据库

开发平台：

Visual C++

DbtupDebug.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. #define DBTUP_C
  19. #include "Dbtup.hpp"
  20. #include <RefConvert.hpp>
  21. #include <ndb_limits.h>
  22. #include <pc.hpp>
  23. #include <signaldata/DropTab.hpp>
  24. #include <signaldata/DumpStateOrd.hpp>
  25. #include <signaldata/EventReport.hpp>
  26. #include <Vector.hpp>
  28. #define ljam() { jamLine(30000 + __LINE__); }
  29. #define ljamEntry() { jamEntryLine(30000 + __LINE__); }
  31. /* **************************************************************** */
  32. /* ---------------------------------------------------------------- */
  33. /* ------------------------ DEBUG MODULE -------------------------- */
  34. /* ---------------------------------------------------------------- */
  35. /* **************************************************************** */
  36. void Dbtup::execDEBUG_SIG(Signal* signal) 
  37. {
  38.   PagePtr regPagePtr;
  39.   ljamEntry();
  40.   regPagePtr.i = signal->theData[0];
  41.   ptrCheckGuard(regPagePtr, cnoOfPage, page);
  42. }//Dbtup::execDEBUG_SIG()
  44. #ifdef TEST_MR
  45. #include <time.h>
  47. void startTimer(struct timespec *tp)
  48. {
  49.   clock_gettime(CLOCK_REALTIME, tp);
  50. }//startTimer()
  52. int stopTimer(struct timespec *tp)
  53. {
  54.   double timer_count;
  55.   struct timespec theStopTime;
  56.   clock_gettime(CLOCK_REALTIME, &theStopTime);
  57.   timer_count = (double)(1000000*((double)theStopTime.tv_sec - (double)tp->tv_sec)) + 
  58.                 (double)((double)((double)theStopTime.tv_nsec - (double)tp->tv_nsec)/(double)1000);
  59.   return (int)timer_count;
  60. }//stopTimer()
  62. #endif // end TEST_MR
  64. struct Chunk {
  65.   Uint32 pageId;
  66.   Uint32 pageCount;
  67. };
  69. void
  70. Dbtup::reportMemoryUsage(Signal* signal, int incDec){
  71.   signal->theData[0] = EventReport::MemoryUsage;
  72.   signal->theData[1] = incDec;
  73.   signal->theData[2] = sizeof(Page);
  74.   signal->theData[3] = cnoOfAllocatedPages;
  75.   signal->theData[4] = cnoOfPage;
  76.   signal->theData[5] = DBTUP;
  77.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 6, JBB);
  78. }
  80. void
  81. Dbtup::execDUMP_STATE_ORD(Signal* signal)
  82. {
  83.   Uint32 type = signal->theData[0];
  84.   if(type == DumpStateOrd::DumpPageMemory){
  85.     reportMemoryUsage(signal, 0);
  86.     return;
  87.   }
  88.   DumpStateOrd * const dumpState = (DumpStateOrd *)&signal->theData[0];
  90. #if 0
  91.   if (type == 100) {
  92.     RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend();
  93.     req->primaryTableId = 2;
  94.     req->secondaryTableId = RNIL;
  95.     req->userPtr = 2;
  96.     req->userRef = DBDICT_REF;
  97.     sendSignal(cownref, GSN_REL_TABMEMREQ, signal,
  98.                RelTabMemReq::SignalLength, JBB);
  99.     return;
  100.   }//if
  101.   if (type == 101) {
  102.     RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend();
  103.     req->primaryTableId = 4;
  104.     req->secondaryTableId = 5;
  105.     req->userPtr = 4;
  106.     req->userRef = DBDICT_REF;
  107.     sendSignal(cownref, GSN_REL_TABMEMREQ, signal,
  108.                RelTabMemReq::SignalLength, JBB);
  109.     return;
  110.   }//if
  111.   if (type == 102) {
  112.     RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend();
  113.     req->primaryTableId = 6;
  114.     req->secondaryTableId = 8;
  115.     req->userPtr = 6;
  116.     req->userRef = DBDICT_REF;
  117.     sendSignal(cownref, GSN_REL_TABMEMREQ, signal,
  118.                RelTabMemReq::SignalLength, JBB);
  119.     return;
  120.   }//if
  121.   if (type == 103) {
  122.     DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend();
  123.     req->primaryTableId = 2;
  124.     req->secondaryTableId = RNIL;
  125.     req->userPtr = 2;
  126.     req->userRef = DBDICT_REF;
  127.     sendSignal(cownref, GSN_DROP_TABFILEREQ, signal,
  128.                DropTabFileReq::SignalLength, JBB);
  129.     return;
  130.   }//if
  131.   if (type == 104) {
  132.     DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend();
  133.     req->primaryTableId = 4;
  134.     req->secondaryTableId = 5;
  135.     req->userPtr = 4;
  136.     req->userRef = DBDICT_REF;
  137.     sendSignal(cownref, GSN_DROP_TABFILEREQ, signal,
  138.                DropTabFileReq::SignalLength, JBB);
  139.     return;
  140.   }//if
  141.   if (type == 105) {
  142.     DropTabFileReq * const req = (DropTabFileReq *)signal->getDataPtrSend();
  143.     req->primaryTableId = 6;
  144.     req->secondaryTableId = 8;
  145.     req->userPtr = 6;
  146.     req->userRef = DBDICT_REF;
  147.     sendSignal(cownref, GSN_DROP_TABFILEREQ, signal,
  148.                DropTabFileReq::SignalLength, JBB);
  149.     return;
  150.   }//if
  151. #endif
  152. #ifdef ERROR_INSERT
  153.   if (type == DumpStateOrd::EnableUndoDelayDataWrite) {
  154.     ndbout << "Dbtup:: delay write of datapages for table = " 
  155.    << dumpState->args[1]<< endl;
  156.     c_errorInsert4000TableId = dumpState->args[1];
  157.     SET_ERROR_INSERT_VALUE(4000);
  158.     return;
  159.   }//if
  160. #endif
  161. #ifdef VM_TRACE
  162.   if (type == 1211){
  163.     ndbout_c("Startar modul test av Page Manager");
  165.     Vector<Chunk> chunks;
  166.     const Uint32 LOOPS = 1000;
  167.     for(Uint32 i = 0; i<LOOPS; i++){
  169.       // Case
  170.       Uint32 c = (rand() % 3);
  171.       const Uint32 free = cnoOfPage - cnoOfAllocatedPages;
  172.       
  173.       Uint32 alloc = 0;
  174.       if(free <= 1){
  175. c = 0;
  176. alloc = 1;
  177.       } else 
  178. alloc = 1 + (rand() % (free - 1));
  179.       
  180.       if(chunks.size() == 0 && c == 0){
  181. c = 1 + rand() % 2;
  182.       }
  184.       ndbout_c("loop=%d case=%d free=%d alloc=%d", i, c, free, alloc);
  185.       switch(c){ 
  186.       case 0:{ // Release
  187. const int ch = rand() % chunks.size();
  188. Chunk chunk = chunks[ch];
  189. chunks.erase(ch);
  190. returnCommonArea(chunk.pageId, chunk.pageCount);
  191.       }
  192. break;
  193.       case 2: { // Seize(n) - fail
  194. alloc += free;
  195. // Fall through
  196.       }
  197.       case 1: { // Seize(n) (success)
  199. Chunk chunk;
  200. allocConsPages(alloc, chunk.pageCount, chunk.pageId);
  201. ndbrequire(chunk.pageCount <= alloc);
  202. if(chunk.pageCount != 0){
  203.   chunks.push_back(chunk);
  204.   if(chunk.pageCount != alloc) {
  205.     ndbout_c("  Tried to allocate %d - only allocated %d - free: %d",
  206.      alloc, chunk.pageCount, free);
  207.   }
  208. } else {
  209.   ndbout_c("  Failed to alloc %d pages with %d pages free",
  210.    alloc, free);
  211. }
  213. for(Uint32 i = 0; i<chunk.pageCount; i++){
  214.   PagePtr pagePtr;
  215.   pagePtr.i = chunk.pageId + i;
  216.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  217.   pagePtr.p->pageWord[ZPAGE_STATE_POS] = ~ZFREE_COMMON;
  218. }
  220. if(alloc == 1 && free > 0)
  221.   ndbrequire(chunk.pageCount == alloc);
  222.       }
  223. break;
  224.       }
  225.     }
  226.     while(chunks.size() > 0){
  227.       Chunk chunk = chunks.back();
  228.       returnCommonArea(chunk.pageId, chunk.pageCount);      
  229.       chunks.erase(chunks.size() - 1);
  230.     }
  231.   }
  232. #endif
  233. }//Dbtup::execDUMP_STATE_ORD()
  235. /* ---------------------------------------------------------------- */
  236. /* ---------      MEMORY       CHECK        ----------------------- */
  237. /* ---------------------------------------------------------------- */
  238. void Dbtup::execMEMCHECKREQ(Signal* signal) 
  239. {
  240.   PagePtr regPagePtr;
  241.   DiskBufferSegmentInfoPtr dbsiPtr;
  242.   CheckpointInfoPtr ciPtr;
  243.   UndoPagePtr regUndoPagePtr;
  244.   Uint32* data = &signal->theData[0];
  246.   ljamEntry();
  247.   BlockReference blockref = signal->theData[0];
  248.   Uint32 i;
  249.   for (i = 0; i < 25; i++) {
  250.     ljam();
  251.     data[i] = 0;
  252.   }//for
  253.   for (i = 0; i < 16; i++) {
  254.     regPagePtr.i = cfreepageList[i];
  255.     ljam();
  256.     while (regPagePtr.i != RNIL) {
  257.       ljam();
  258.       ptrCheckGuard(regPagePtr, cnoOfPage, page);
  259.       regPagePtr.i = regPagePtr.p->pageWord[ZPAGE_NEXT_POS];
  260.       data[0]++;
  261.     }//while
  262.   }//for
  263.   regUndoPagePtr.i = cfirstfreeUndoSeg;
  264.   while (regUndoPagePtr.i != RNIL) {
  265.     ljam();
  266.     ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  267.     regUndoPagePtr.i = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS];
  268.     data[1] += ZUB_SEGMENT_SIZE;
  269.   }//while
  270.   ciPtr.i = cfirstfreeLcp;
  271.   while (ciPtr.i != RNIL) {
  272.     ljam();
  273.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  274.     ciPtr.i = ciPtr.p->lcpNextRec;
  275.     data[2]++;
  276.   }//while
  277.   dbsiPtr.i = cfirstfreePdx;
  278.   while (dbsiPtr.i != ZNIL) {
  279.     ljam();
  280.     ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  281.     dbsiPtr.i = dbsiPtr.p->pdxNextRec;
  282.     data[3]++;
  283.   }//while
  284.   sendSignal(blockref, GSN_MEMCHECKCONF, signal, 25, JBB);
  285. }//Dbtup::memCheck()
  287. // ------------------------------------------------------------------------
  288. // Help function to be used when debugging. Prints out a tuple page.
  289. // printLimit is the number of bytes that is printed out from the page. A 
  290. // page is of size 32768 bytes as of March 2003.
  291. // ------------------------------------------------------------------------
  292. void Dbtup::printoutTuplePage(Uint32 fragid, Uint32 pageid, Uint32 printLimit) 
  293. {
  294.   PagePtr tmpPageP;
  295.   FragrecordPtr tmpFragP;
  296.   TablerecPtr tmpTableP;
  297.   Uint32 tmpTupleSize;
  299.   tmpPageP.i = pageid;
  300.   ptrCheckGuard(tmpPageP, cnoOfPage, page);
  302.   tmpFragP.i = fragid;
  303.   ptrCheckGuard(tmpFragP, cnoOfFragrec, fragrecord);
  305.   tmpTableP.i = tmpFragP.p->fragTableId;
  306.   ptrCheckGuard(tmpTableP, cnoOfTablerec, tablerec);
  308.   tmpTupleSize = tmpTableP.p->tupheadsize;
  310.   ndbout << "Fragid: " << fragid << " Pageid: " << pageid << endl
  311.  << "----------------------------------------" << endl;
  313.   ndbout << "PageHead : ";
  314.   for (Uint32 i1 = 0; i1 < ZPAGE_HEADER_SIZE; i1++) {
  315.     if (i1 == 3)
  316.       ndbout << (tmpPageP.p->pageWord[i1] >> 16) << "," << (tmpPageP.p->pageWord[i1] & 0xffff) << " ";
  317.     else if (tmpPageP.p->pageWord[i1] == 4059165169u)
  318.       ndbout <<  "F1F1F1F1 ";
  319.     else if (tmpPageP.p->pageWord[i1] == 268435455u)
  320.       ndbout << "RNIL ";
  321.     else
  322.       ndbout << tmpPageP.p->pageWord[i1] << " ";
  323.   }//for
  324.   ndbout << endl;
  325.   for (Uint32 i = ZPAGE_HEADER_SIZE; i < printLimit; i += tmpTupleSize) {
  326.     ndbout << "pagepos " << i << " : ";
  327.  
  328.     for (Uint32 j = i; j < i + tmpTupleSize; j++) {
  329.       if (tmpPageP.p->pageWord[j] == 4059165169u)
  330. ndbout <<  "F1F1F1F1 ";
  331.       else if (tmpPageP.p->pageWord[j] == 268435455u)
  332. ndbout << "RNIL ";
  333.       else
  334. ndbout << tmpPageP.p->pageWord[j] << " ";
  335.     }//for
  336.     ndbout << endl;
  337.   }//for
  338. }//Dbtup::printoutTuplePage
  340. #ifdef VM_TRACE
  341. NdbOut&
  342. operator<<(NdbOut& out, const Dbtup::Operationrec& op)
  343. {
  344.   out << "[Operationrec " << hex << &op;
  345.   // table
  346.   out << " [tableRef " << dec << op.tableRef << "]";
  347.   out << " [fragId " << dec << op.fragId << "]";
  348.   out << " [fragmentPtr " << hex << op.fragmentPtr << "]";
  349.   // type
  350.   out << " [optype " << dec << op.optype << "]";
  351.   out << " [deleteInsertFlag " << dec << op.deleteInsertFlag << "]";
  352.   out << " [dirtyOp " << dec << op.dirtyOp << "]";
  353.   out << " [interpretedExec " << dec << op.interpretedExec << "]";
  354.   out << " [opSimple " << dec << op.opSimple << "]";
  355.   // state
  356.   out << " [tupleState " << dec << (Uint32) op.tupleState << "]";
  357.   out << " [transstate " << dec << (Uint32) op.transstate << "]";
  358.   out << " [inFragList " << dec << op.inFragList << "]";
  359.   out << " [inActiveOpList " << dec << op.inActiveOpList << "]";
  360.   out << " [undoLogged " << dec << (Uint32) op.undoLogged << "]";
  361.   // links
  362.   out << " [prevActiveOp " << hex << op.prevActiveOp << "]";
  363.   out << " [nextActiveOp " << hex << op.nextActiveOp << "]";
  364.   // tuples
  365.   out << " [tupVersion " << hex << op.tupVersion << "]";
  366.   out << " [fragPageId " << dec << op.fragPageId << "]";
  367.   out << " [pageIndex " << dec << op.pageIndex << "]";
  368.   out << " [realPageId " << hex << op.realPageId << "]";
  369.   out << " [pageOffset " << dec << op.pageOffset << "]";
  370.   out << " [fragPageIdC " << dec << op.fragPageIdC << "]";
  371.   out << " [pageIndexC " << dec << op.pageIndexC << "]";
  372.   out << " [realPageIdC " << hex << op.realPageIdC << "]";
  373.   out << " [pageOffsetC " << dec << op.pageOffsetC << "]";
  374.   // trans
  375.   out << " [transid1 " << hex << op.transid1 << "]";
  376.   out << " [transid2 " << hex << op.transid2 << "]";
  377.   out << "]";
  378.   return out;
  379. }
  381. // uses global tabptr
  382. NdbOut&
  383. operator<<(NdbOut& out, const Dbtup::Th& th)
  384. {
  385.   // ugly
  386.   Dbtup* tup = (Dbtup*)globalData.getBlock(DBTUP);
  387.   const Dbtup::Tablerec& tab = *tup->tabptr.p;
  388.   unsigned i = 0;
  389.   out << "[Th " << hex << &th;
  390.   out << " [op " << hex << th.data[i++] << "]";
  391.   out << " [version " << hex << (Uint16)th.data[i++] << "]";
  392.   if (tab.checksumIndicator)
  393.     out << " [checksum " << hex << th.data[i++] << "]";
  394.   out << " [nullbits";
  395.   for (unsigned j = 0; j < tab.tupNullWords; j++)
  396.     out << " " << hex << th.data[i++];
  397.   out << "]";
  398.   if (tab.GCPIndicator)
  399.     out << " [gcp " << dec << th.data[i++] << "]";
  400.   out << " [data";
  401.   while (i < tab.tupheadsize)
  402.     out << " " << hex << th.data[i++];
  403.   out << "]";
  404.   out << "]";
  405.   return out;
  406. }
  407. #endif
  409. #ifdef VM_TRACE
  410. template class Vector<Chunk>;
  411. #endif