bk commit into 5.1 tree (jonas:1.2155)

[jonas]

Below is the list of changes that have just been committed into a local
5.1 repository of jonas. When jonas does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-06-25 10:48:42+02:00, jonas@stripped +3 -0
  ndb - Add new dump 2407 - providing detailed memory information from ACC

  storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp@stripped, 2007-06-25 10:48:40+02:00,
jonas@stripped +1 -0
    Add new dump providing detailed memory information from ACC

  storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp@stripped, 2007-06-25 10:48:40+02:00,
jonas@stripped +5 -3
    Add new dump providing detailed memory information from ACC

  storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp@stripped, 2007-06-25 10:48:40+02:00,
jonas@stripped +151 -29
    Add new dump providing detailed memory information from ACC

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	jonas
# Host:	perch.ndb.mysql.com
# Root:	/home/jonas/src/drop5

--- 1.10/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp	2007-06-25 10:48:45 +02:00
+++ 1.11/storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp	2007-06-25 10:48:45 +02:00
@@ -89,6 +89,7 @@
     AccDumpNumOpRecs = 2404,
     AccDumpFreeOpRecs = 2405,
     AccDumpNotFreeOpRecs = 2406,
+    AccDumpFragMemory = 2407,
     DumpPageMemory = 1000, // Acc & TUP
     TcDumpAllScanFragRec = 2500,
     TcDumpOneScanFragRec = 2501,

--- 1.24/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp	2007-06-25 10:48:45 +02:00
+++ 1.25/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp	2007-06-25 10:48:45 +02:00
@@ -486,6 +486,7 @@
   Uint32 lcpMaxOverDirIndex;
   Uint32 noStoredPages;
   Uint32 noOfStoredOverPages;
+  Uint32 m_noOfAllocatedPages;
 
 //-----------------------------------------------------------------------------
 // We have a list of overflow pages with free areas. We have a special record,
@@ -702,7 +703,6 @@
   Uint32 hashvaluePart;
   Uint32 hashValue;
   Uint32 insertDeleteLen;
-  Uint32 keyinfoPage;
   Uint32 nextLockOwnerOp;
   Uint32 nextOp;
   Uint32 nextParallelQue;
@@ -1054,7 +1054,7 @@
   void releaseOpRec(Signal* signal);
   void releaseOverflowRec(Signal* signal);
   void releaseOverpage(Signal* signal);
-  void releasePage(Signal* signal);
+  void releasePage(Signal* signal, Fragmentrec * fragP);
   void releaseLcpPage(Signal* signal);
   void releaseSrRec(Signal* signal);
   void releaseLogicalPage(Fragmentrec * fragP, Uint32 logicalPageId);
@@ -1066,7 +1066,7 @@
   void seizeLcpConnectRec(Signal* signal);
   void seizeOpRec(Signal* signal);
   void seizeOverRec(Signal* signal);
-  void seizePage(Signal* signal);
+  void seizePage(Signal* signal, Fragmentrec * fragP);
   void seizeLcpPage(Page8Ptr&);
   void seizeRootfragrec(Signal* signal);
   void seizeScanRec(Signal* signal);
@@ -1131,6 +1131,8 @@
   // Initialisation
   void initData();
   void initRecords();
+
+  void dump_frag_mem(Signal*, Uint32 tab, Uint32 frag);
 
   // Variables
 /* --------------------------------------------------------------------------------- */

--- 1.61/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2007-06-25 10:48:45 +02:00
+++ 1.62/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp	2007-06-25 10:48:45 +02:00
@@ -935,9 +935,11 @@
   /*       WE SET UP A LINKED LIST OF PAGES FOR EXCLUSIVE USE BY LOCAL CHECKPOINTS.    */
   /* --------------------------------------------------------------------------------- */
   cfirstfreeLcpPage = RNIL;
-  for (tilpIndex = 0; tilpIndex < cnoLcpPages; tilpIndex++) {
+  Uint32 tmp = cnoLcpPages;
+  cnoLcpPages = 0;
+  for (tilpIndex = 0; tilpIndex < tmp; tilpIndex++) {
     jam();
-    seizePage(signal);
+    seizePage(signal, 0);
     rlpPageptr = spPageptr;
     releaseLcpPage(signal);
   }//for
@@ -1110,7 +1112,7 @@
       addFragRefuse(signal, tresult);
       return;
     }//if
-    seizePage(signal);
+    seizePage(signal, fragrecptr.p);
     if (tresult > ZLIMIT_OF_ERROR) {
       jam();
       addFragRefuse(signal, tresult);
@@ -1312,13 +1314,18 @@
   DirectoryarrayPtr regDirPtr;
   regDirPtr.i = directoryIndex;
   ptrCheckGuard(regDirPtr, cdirarraysize, directoryarray);
+
+  FragmentrecPtr regFragPtr;
+  regFragPtr.i = fragIndex;
+  ptrCheckGuard(regFragPtr, cfragmentsize, fragmentrec);
+
   for (Uint32 i = 0; i < 256; i++) {
     jam();
     if (regDirPtr.p->pagep[i] != RNIL) {
       jam();
       rpPageptr.i = regDirPtr.p->pagep[i];
       ptrCheckGuard(rpPageptr, cpagesize, page8);
-      releasePage(signal);
+      releasePage(signal, regFragPtr.p);
       regDirPtr.p->pagep[i] = RNIL;
     }//if
   }//for
@@ -1555,7 +1562,6 @@
   operationRecPtr.p->nextSerialQue = RNIL;
   operationRecPtr.p->prevSerialQue = RNIL;
   operationRecPtr.p->elementPage = RNIL;
-  operationRecPtr.p->keyinfoPage = RNIL;
   operationRecPtr.p->lockOwner = ZFALSE;
   operationRecPtr.p->insertIsDone = ZFALSE;
   operationRecPtr.p->elementIsDisappeared = ZFALSE;
@@ -2219,13 +2225,6 @@
 /* ------------------------------------------------------------------------- */
 void Dbacc::acckeyref1Lab(Signal* signal, Uint32 result_code) 
 {
-  if (operationRecPtr.p->keyinfoPage != RNIL) {
-    jam();
-    rpPageptr.i = operationRecPtr.p->keyinfoPage;
-    ptrCheckGuard(rpPageptr, cpagesize, page8);
-    releasePage(signal);
-    operationRecPtr.p->keyinfoPage = RNIL;
-  }//if
   operationRecPtr.p->transactionstate = WAIT_COMMIT_ABORT;
   /* ************************<< */
   /* ACCKEYREF                  */
@@ -4954,7 +4953,7 @@
     aopDirRangePtr.p->dirArray[taopTmp2] = sdDirptr.i;
   }//if
   aopOverflowDirptr.i = aopDirRangePtr.p->dirArray[taopTmp2];
-  seizePage(signal);
+  seizePage(signal, fragrecptr.p);
   ndbrequire(tresult <= ZLIMIT_OF_ERROR);
   ptrCheckGuard(aopOverflowDirptr, cdirarraysize, directoryarray);
   aopOverflowDirptr.p->pagep[taopTmp3] = spPageptr.i;
@@ -5191,7 +5190,7 @@
   expPageptr.i = expDirptr.p->pagep[texpDirPageIndex];
   if (expPageptr.i == RNIL) {
     jam();
-    seizePage(signal);
+    seizePage(signal, fragrecptr.p);
     if (tresult > ZLIMIT_OF_ERROR) {
       jam();
       if (newDirptr.i != RNIL) {
@@ -5920,7 +5919,7 @@
       jam();
       rpPageptr.i = fragrecptr.p->expSenderPageptr;
       ptrCheckGuard(rpPageptr, cpagesize, page8);
-      releasePage(signal);
+      releasePage(signal, fragrecptr.p);
       expDirptr.i = fragrecptr.p->expSenderDirptr;
       ptrCheckGuard(expDirptr, cdirarraysize, directoryarray);
       expDirptr.p->pagep[fragrecptr.p->expSenderDirIndex & 0xff] = RNIL;
@@ -7845,6 +7844,9 @@
                         Uint32 rootIndex,
                         FragmentrecPtr regFragPtr) 
 {
+  Uint32 saveFid = regFragPtr.p->myfid;
+  Uint32 saveTab = regFragPtr.p->myTableId;
+
   const AccFragReq * const req = (AccFragReq*)&signal->theData[0];  
   Uint32 lhFragBits = req->lhFragBits + 1;
   Uint32 minLoadFactor = (req->minLoadFactor * ZBUF_SIZE) / 100;
@@ -7892,7 +7894,13 @@
 
   Uint32 hasCharAttr = g_key_descriptor_pool.getPtr(req->tableId)->hasCharAttr;
   regFragPtr.p->hasCharAttr = hasCharAttr;
-
+  if (regFragPtr.p->m_noOfAllocatedPages)
+  {
+    warningEvent("Found %d pages @ tab: %u frag: %u",
+                 regFragPtr.p->m_noOfAllocatedPages,
+                 saveTab, saveFid);
+  }
+  ndbrequire(regFragPtr.p->m_noOfAllocatedPages == 0);
 }//Dbacc::initFragAdd()
 
 void Dbacc::initFragGeneral(FragmentrecPtr regFragPtr)
@@ -7924,6 +7932,7 @@
   for (Uint32 j = 0; j < 4; j++) {
     regFragPtr.p->longKeyPageArray[j] = RNIL;
   }//for
+  regFragPtr.p->m_noOfAllocatedPages = 0;
 }//Dbacc::initFragGeneral()
 
 void Dbacc::initFragSr(FragmentrecPtr regFragPtr, Page8Ptr regPagePtr) 
@@ -7951,6 +7960,7 @@
   regFragPtr.p->slackCheck =          regPagePtr.p->word32[ZPAGEZERO_SLACK_CHECK];
 
   regFragPtr.p->loadingFlag = ZTRUE;
+  regFragPtr.p->m_noOfAllocatedPages = 0;
 
 }//Dbacc::initFragSr()
 
@@ -8096,8 +8106,8 @@
   
   rpPageptr.i = physicalPageId;
   ptrCheckGuard(rpPageptr, cpagesize, page8);
-  releasePage(0);
-
+  releasePage(0, fragP);
+  
   dirArrPtr.p->pagep[lp2] = RNIL;
 }
 
@@ -8145,7 +8155,7 @@
       /*       CHECKPOINT.                                                             
*/
       /*       ALLOCATE THE PAGE AND INITIALISE IT. THEN WE INSERT A REAL-TIME BREAK.  
*/
      
/*--------------------------------------------------------------------------------*/
-      seizePage(signal);
+      seizePage(signal, fragrecptr.p);
       ndbrequire(tresult <= ZLIMIT_OF_ERROR);
       tipPageId = fragrecptr.p->nextAllocPage;
       inpPageptr.i = spPageptr.i;
@@ -8170,7 +8180,7 @@
   ndbrequire(limitLoop <= 8);
   for (Uint32 i = 0; i < limitLoop; i++) {
     jam();
-    seizePage(signal);
+    seizePage(signal, fragrecptr.p);
     ndbrequireErr(tresult <= ZLIMIT_OF_ERROR, NDBD_EXIT_SR_OUT_OF_INDEXMEMORY);
     fragrecptr.p->datapages[i] = spPageptr.i;
     signal->theData[i + 6] = spPageptr.i;
@@ -8318,7 +8328,7 @@
   ndbrequire(limitLoop <= 8);
   for (Uint32 i = 0; i < limitLoop; i++) {
     jam();
-    seizePage(signal);
+    seizePage(signal, fragrecptr.p);
     ndbrequire(tresult <= ZLIMIT_OF_ERROR);
     fragrecptr.p->datapages[i] = spPageptr.i;
     signal->theData[i + 6] = spPageptr.i;
@@ -8844,7 +8854,6 @@
     operationRecPtr.p->nextSerialQue = RNIL;
     operationRecPtr.p->prevSerialQue = RNIL;
     operationRecPtr.p->elementPage = RNIL;
-    operationRecPtr.p->keyinfoPage = RNIL;
     operationRecPtr.p->insertIsDone = ZFALSE;
     operationRecPtr.p->lockOwner = ZFALSE;
     operationRecPtr.p->elementIsDisappeared = ZFALSE;
@@ -9911,7 +9920,6 @@
   operationRecPtr.p->prevSerialQue = RNIL;
   operationRecPtr.p->prevQueOp = RNIL;
   operationRecPtr.p->nextQueOp = RNIL;
-  operationRecPtr.p->keyinfoPage = RNIL; // Safety precaution 
   operationRecPtr.p->transId1 = scanPtr.p->scanTrid1;
   operationRecPtr.p->transId2 = scanPtr.p->scanTrid2;
   operationRecPtr.p->lockOwner = ZFALSE;
@@ -10983,7 +10991,7 @@
   ptrCheckGuard(ropOverflowDirptr, cdirarraysize, directoryarray);
   ropOverflowDirptr.p->pagep[tropTmp2] = RNIL;
   rpPageptr = ropPageptr;
-  releasePage(signal);
+  releasePage(signal, fragrecptr.p);
   if (ropOverflowRecPtr.p->dirindex != (fragrecptr.p->lastOverIndex - 1)) {
     jam();
     return;
@@ -11035,7 +11043,7 @@
 /* --------------------------------------------------------------------------------- */
 /* RELEASE_PAGE                                                                      */
 /* --------------------------------------------------------------------------------- */
-void Dbacc::releasePage(Signal* signal) 
+void Dbacc::releasePage(Signal* signal, Fragmentrec * fragP) 
 {
 #ifdef VM_TRACE
   bool inList = false;
@@ -11057,6 +11065,12 @@
   rpPageptr.p->word32[0] = cfirstfreepage;
   cfirstfreepage = rpPageptr.i;
   cnoOfAllocatedPages--;
+
+  if (fragP)
+  {
+    jam();
+    fragP->m_noOfAllocatedPages--;
+  }
 }//Dbacc::releasePage()
 
 /* --------------------------------------------------------------------------------- */
@@ -11066,6 +11080,7 @@
 {
   rlpPageptr.p->word32[0] = cfirstfreeLcpPage;
   cfirstfreeLcpPage = rlpPageptr.i;
+  cnoLcpPages++;
 }//Dbacc::releaseLcpPage()
 
 /* --------------------------------------------------------------------------------- */
@@ -11215,7 +11230,7 @@
 /* --------------------------------------------------------------------------------- */
 /* SEIZE_PAGE                                                                        */
 /* --------------------------------------------------------------------------------- */
-void Dbacc::seizePage(Signal* signal) 
+void Dbacc::seizePage(Signal* signal, Fragmentrec * fragP) 
 {
   tresult = 0;
   if (cfirstfreepage == RNIL) {
@@ -11225,6 +11240,11 @@
       ptrCheckGuard(spPageptr, cpagesize, page8);
       cfreepage++;
       cnoOfAllocatedPages++;
+      if (fragP)
+      {
+        jam();
+        fragP->m_noOfAllocatedPages++;
+      }
     } else {
       jam();
       zpagesize_error("Dbacc::seizePage");
@@ -11236,6 +11256,11 @@
     ptrCheckGuard(spPageptr, cpagesize, page8);
     cfirstfreepage = spPageptr.p->word32[0];
     cnoOfAllocatedPages++;
+    if (fragP)
+    {
+      jam();
+      fragP->m_noOfAllocatedPages++;
+    }
   }//if
 }//Dbacc::seizePage()
 
@@ -11247,6 +11272,7 @@
   regPagePtr.i = cfirstfreeLcpPage;
   ptrCheckGuard(regPagePtr, cpagesize, page8);
   cfirstfreeLcpPage = regPagePtr.p->word32[0];
+  cnoLcpPages--;
 }//Dbacc::seizeLcpPage()
 
 /* --------------------------------------------------------------------------------- */
@@ -11492,9 +11518,8 @@
     infoEvent("fid=%d, fragptr=%d, hashvaluePart=%d ",
 	      tmpOpPtr.p->fid, tmpOpPtr.p->fragptr, 
 	      tmpOpPtr.p->hashvaluePart);
-    infoEvent("hashValue=%d, insertDeleteLen=%d, keyinfoPage=%d ",
-	      tmpOpPtr.p->hashValue, tmpOpPtr.p->insertDeleteLen, 
-	      tmpOpPtr.p->keyinfoPage);
+    infoEvent("hashValue=%d, insertDeleteLen=%d",
+	      tmpOpPtr.p->hashValue, tmpOpPtr.p->insertDeleteLen);
     infoEvent("nextLockOwnerOp=%d, nextOp=%d, nextParallelQue=%d ",
 	      tmpOpPtr.p->nextLockOwnerOp, tmpOpPtr.p->nextOp, 
 	      tmpOpPtr.p->nextParallelQue);
@@ -11585,6 +11610,60 @@
     return;
   }
 
+  if (dumpState->args[0] == DumpStateOrd::AccDumpFragMemory &&
+      signal->getLength() == 1)
+  {
+    jam();
+    infoEvent("ACC: pages: %u allocated: %u cnoLcpPages: %u", 
+              cpagesize, 
+              cnoOfAllocatedPages,
+              cnoLcpPages);
+    signal->theData[0] = DumpStateOrd::AccDumpFragMemory;
+    signal->theData[1] = 0; // Tab 0
+    signal->theData[2] = 0; // Frag 0
+    signal->theData[3] = 1; // All frags
+    sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 4, JBB);
+    return;
+  }
+  
+  if (dumpState->args[0] == DumpStateOrd::AccDumpFragMemory &&
+      signal->getLength() >= 3)
+  {
+    jam();
+    Uint32 tab = signal->theData[1];
+    Uint32 frag = signal->theData[2];
+    Uint32 all = signal->getLength() > 3 ? signal->theData[3] : 0;
+    
+    dump_frag_mem(signal, tab, frag);
+
+    /**
+     * Next
+     */
+    if (all)
+    {
+      jam();
+      frag++;
+      if (frag == MAX_FRAG_PER_NODE)
+      {
+        jam();
+        tab++;
+        frag = 0;
+        if (tab == ctablesize)
+        {
+          jam();
+          return;
+        }
+      }
+      signal->theData[0] = DumpStateOrd::AccDumpFragMemory;
+      signal->theData[1] = tab;
+      signal->theData[2] = frag;
+      signal->theData[3] = all;
+      sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 4, JBB);
+      return;
+    }
+    return;
+  }
+
 #if 0
   if (type == 100) {
     RelTabMemReq * const req = (RelTabMemReq *)signal->getDataPtrSend();
@@ -11704,3 +11783,46 @@
   //  signal->theData[1] = src[1];
 }
 
+void
+Dbacc::dump_frag_mem(Signal* signal, Uint32 tab, Uint32 frag)
+{
+  Ptr<Tabrec> tabPtr;
+  Ptr<Rootfragmentrec> rootPtr;
+  Ptr<Fragmentrec> fragPtr;
+  
+  tabPtr.i = tab;
+  ptrCheckGuard(tabPtr, ctablesize, tabrec); 
+
+  Uint32 fragId = tabPtr.p->fragholder[frag];
+  rootPtr.i = tabPtr.p->fragptrholder[frag];
+  
+  if (rootPtr.i != RNIL)
+  {
+    jam();
+    ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec);
+
+    infoEvent("ACC: tab: %u frag: %u rows: %u",
+              tab, frag, rootPtr.p->noOfElements);
+    for (Uint32 i = 0; i<2; i++)
+    {
+      jam();
+      FragmentrecPtr fragPtr;
+      fragPtr.i = rootPtr.p->fragmentptr[i];
+      if (fragPtr.i != RNIL)
+      {
+        jam();
+        ptrCheckGuard(fragPtr, cfragmentsize, fragmentrec);
+        infoEvent("ACC tab %u fid %u-%u: %u dir %u %u #exp %u sl %u %u expf %u p %u %u",
+                  tab, frag, i, 
+                  fragPtr.p->m_noOfAllocatedPages,
+                  fragPtr.p->dirsize, fragPtr.p->lastOverIndex,
+                  fragPtr.p->expandCounter,
+                  fragPtr.p->slack,
+                  fragPtr.p->slackCheck,
+                  (Uint32)fragPtr.p->expandFlag,
+                  fragPtr.p->p,
+                  fragPtr.p->maxp);
+      }
+    }
+  }
+}