Commit 41c3dc08 authored by unknown's avatar unknown
Browse files

tux optim 7 - use physical TUP address for index entries

parent 6b099d2c

ndb/include/kernel/signaldata/TuxMaint.hpp

+5 −4
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ public: 
    SearchError = 895,  // add + found or remove + not found

    NoMemError = 827

  };

  STATIC_CONST( SignalLength = 7 );

  STATIC_CONST( SignalLength = 8 );

private:

  /*

   * Error code set by TUX.  Zero means no error.
@@ -52,10 +52,11 @@ private: 
  Uint32 indexId;

  Uint32 fragId;

  /*

   * Tuple version identified by logical address of "original" tuple and

   * version number.

   * Tuple version identified by physical address of "original" tuple

   * and version number.

   */

  Uint32 tupAddr;

  Uint32 pageId;

  Uint32 pageOffset;

  Uint32 tupVersion;

  /*

   * Operation code and flags.

ndb/src/common/debugger/signaldata/TuxMaint.cpp

+4 −4
Original line number Diff line number Diff line
@@ -24,10 +24,10 @@ printTUX_MAINT_REQ(FILE* output, const Uint32* theData, Uint32 len, Uint16 rbn) 
  //const bool inOut = rbn & (1 << 15);

  const TuxMaintReq* const sig = (const TuxMaintReq*)theData;

  fprintf(output, " errorCode=%d\n", sig->errorCode);

  fprintf(output, " table: id=%d", sig->tableId);

  fprintf(output, " index: id=%d", sig->indexId);

  fprintf(output, " fragment: id=%d\n", sig->fragId);

  fprintf(output, " tuple: addr=0x%x version=%d\n", sig->tupAddr, sig->tupVersion);

  fprintf(output, " table: id=%u", sig->tableId);

  fprintf(output, " index: id=%u", sig->indexId);

  fprintf(output, " fragment: id=%u\n", sig->fragId);

  fprintf(output, " tuple: loc=%u.%u version=%u\n", sig->pageId, sig->pageOffset, sig->tupVersion);

  const Uint32 opCode = sig->opInfo & 0xFF;

  const Uint32 opFlag = sig->opInfo >> 8;

  switch (opCode ) {

ndb/src/kernel/blocks/dbtup/Dbtup.hpp

+12 −0
Original line number Diff line number Diff line
@@ -996,6 +996,11 @@ public: 
  Dbtup(const class Configuration &);

  virtual ~Dbtup();



  /*

   * TUX uses logical tuple address when talking to ACC and LQH.

   */

  void tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32& tupAddr);



  /*

   * TUX index in TUP has single Uint32 array attribute which stores an

   * index node.  TUX uses following methods.
@@ -1004,6 +1009,13 @@ public: 
  void tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node);

  void tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node);



  /*

   * TUX reads primary table attributes for 1) index key 2) primary key

   * when returning keyinfo.  TUX uses following methods.

   */

  void tuxReadAttrs();  // under construction

  void tuxReadKeys();   // under construction



private:

  BLOCK_DEFINES(Dbtup);

ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp

+101 −69
Original line number Diff line number Diff line
@@ -30,6 +30,97 @@ 


// methods used by ordered index



void

Dbtup::tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32& tupAddr)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  pagePtr.i = pageId;

  ptrCheckGuard(pagePtr, cnoOfPage, page);

  Uint32 fragPageId = pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS];

  Uint32 tupheadsize = tablePtr.p->tupheadsize;

  ndbrequire(pageOffset >= ZPAGE_HEADER_SIZE);

  Uint32 offset = pageOffset - ZPAGE_HEADER_SIZE;

  ndbrequire(offset % tupheadsize == 0);

  Uint32 pageIndex = (offset / tupheadsize) << 1;

  tupAddr = (fragPageId << MAX_TUPLES_BITS) | pageIndex;

}



int

Dbtup::tuxAllocNode(Signal* signal, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  terrorCode = 0;

  if (! allocTh(fragPtr.p, tablePtr.p, NORMAL_PAGE, signal, pageOffset, pagePtr)) {

    jam();

    ndbrequire(terrorCode != 0);

    return terrorCode;

  }

  pageId = pagePtr.i;

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;

  return 0;

}



void

Dbtup::tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  pagePtr.i = pageId;

  ptrCheckGuard(pagePtr, cnoOfPage, page);

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  ndbrequire(node == &pagePtr.p->pageWord[pageOffset] + attrDataOffset);

  freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, pageOffset);

}



void

Dbtup::tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  pagePtr.i = pageId;

  ptrCheckGuard(pagePtr, cnoOfPage, page);

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;

}



void    // under construction

Dbtup::tuxReadAttrs()

{

}



void    // under construction

Dbtup::tuxReadKeys()

{

}



// deprecated signal interfaces



void

Dbtup::execTUP_READ_ATTRS(Signal* signal)

{
@@ -179,64 +270,6 @@ Dbtup::execTUP_QUERY_TH(Signal* signal) 
  return;

}



int

Dbtup::tuxAllocNode(Signal* signal, Uint32 fragPtrI, Uint32& pageId, Uint32& pageOffset, Uint32*& node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  terrorCode = 0;

  if (! allocTh(fragPtr.p, tablePtr.p, NORMAL_PAGE, signal, pageOffset, pagePtr)) {

    jam();

    ndbrequire(terrorCode != 0);

    return terrorCode;

  }

  pageId = pagePtr.i;

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;

  return 0;

}



void

Dbtup::tuxFreeNode(Signal* signal, Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32* node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  pagePtr.i = pageId;

  ptrCheckGuard(pagePtr, cnoOfPage, page);

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  ndbrequire(node == &pagePtr.p->pageWord[pageOffset] + attrDataOffset);

  freeTh(fragPtr.p, tablePtr.p, signal, pagePtr.p, pageOffset);

}



void

Dbtup::tuxGetNode(Uint32 fragPtrI, Uint32 pageId, Uint32 pageOffset, Uint32*& node)

{

  FragrecordPtr fragPtr;

  fragPtr.i = fragPtrI;

  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);

  TablerecPtr tablePtr;

  tablePtr.i = fragPtr.p->fragTableId;

  ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);

  PagePtr pagePtr;

  pagePtr.i = pageId;

  ptrCheckGuard(pagePtr, cnoOfPage, page);

  Uint32 attrDescIndex = tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);

  Uint32 attrDataOffset = AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);

  node = &pagePtr.p->pageWord[pageOffset] + attrDataOffset;

}



void

Dbtup::execTUP_STORE_TH(Signal* signal)

{
@@ -483,7 +516,8 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) 
      buildPtr.p->m_tupleNo = 0;

      break;

    }

    pagePtr.i = getRealpid(fragPtr.p, buildPtr.p->m_pageId);

    Uint32 realPageId = getRealpid(fragPtr.p, buildPtr.p->m_pageId);

    pagePtr.i = realPageId;

    ptrCheckGuard(pagePtr, cnoOfPage, page);

    const Uint32 pageState = pagePtr.p->pageWord[ZPAGE_STATE_POS];

    if (pageState != ZTH_MM_FREE &&
@@ -497,8 +531,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) 
    }

    // get tuple

    const Uint32 tupheadsize = tablePtr.p->tupheadsize;

    const Uint32 pageOffset = ZPAGE_HEADER_SIZE +

                              buildPtr.p->m_tupleNo * tupheadsize;

    Uint32 pageOffset = ZPAGE_HEADER_SIZE + buildPtr.p->m_tupleNo * tupheadsize;

    if (pageOffset + tupheadsize > ZWORDS_ON_PAGE) {

      ljam();

      buildPtr.p->m_pageId++;
@@ -530,15 +563,14 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) 
      buildPtr.p->m_tupleNo++;

      break;

    }

    Uint32 tupVersion = pagePtr.p->pageWord[pageOffset + 1];

    OperationrecPtr pageOperPtr;

    pageOperPtr.i = pagePtr.p->pageWord[pageOffset];

    Uint32 pageId = buildPtr.p->m_pageId;

    Uint32 pageIndex = buildPtr.p->m_tupleNo << 1;

    if (pageOperPtr.i != RNIL) {

      /*

      If there is an ongoing operation on the tuple then it is either a

      copy tuple or an original tuple with an ongoing transaction. In

      both cases fragPageId and pageIndex refers to the original tuple.

      both cases realPageId and pageOffset refer to the original tuple.

      The tuple address stored in TUX will always be the original tuple

      but with the tuple version of the tuple we found.
@@ -550,10 +582,9 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) 
      */

      jam();

      ptrCheckGuard(pageOperPtr, cnoOfOprec, operationrec);

      pageId = pageOperPtr.p->fragPageId;

      pageIndex = pageOperPtr.p->pageIndex;

      realPageId = pageOperPtr.p->realPageId;

      pageOffset = pageOperPtr.p->pageOffset;

    }//if

    Uint32 tup_version = pagePtr.p->pageWord[pageOffset + 1];

#ifdef TIME_MEASUREMENT

    NdbTick_getMicroTimer(&start);

#endif
@@ -563,8 +594,9 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) 
    req->tableId = tablePtr.i;

    req->indexId = triggerPtr.p->indexId;

    req->fragId = tablePtr.p->fragid[buildPtr.p->m_fragNo];

    req->tupAddr = (pageId << MAX_TUPLES_BITS) | pageIndex;

    req->tupVersion = tup_version;

    req->pageId = realPageId;

    req->pageOffset = pageOffset;

    req->tupVersion = tupVersion;

    req->opInfo = TuxMaintReq::OpAdd;

    EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,

        signal, TuxMaintReq::SignalLength);

ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp

+8 −5
Original line number Diff line number Diff line
@@ -962,7 +962,8 @@ Dbtup::executeTuxInsertTriggers(Signal* signal, 
  // fill in constant part

  req->tableId = regOperPtr->tableRef;

  req->fragId = regOperPtr->fragId;

  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;

  req->pageId = regOperPtr->realPageId;

  req->pageOffset = regOperPtr->pageOffset;

  req->tupVersion = tupVersion;

  req->opInfo = TuxMaintReq::OpAdd;

  // loop over index list
@@ -1000,7 +1001,8 @@ Dbtup::executeTuxUpdateTriggers(Signal* signal, 
  // fill in constant part

  req->tableId = regOperPtr->tableRef;

  req->fragId = regOperPtr->fragId;

  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;

  req->pageId = regOperPtr->realPageId;

  req->pageOffset = regOperPtr->pageOffset;

  req->tupVersion = tupVersion;

  req->opInfo = TuxMaintReq::OpAdd;

  // loop over index list
@@ -1009,7 +1011,6 @@ Dbtup::executeTuxUpdateTriggers(Signal* signal, 
  triggerList.first(triggerPtr);

  while (triggerPtr.i != RNIL) {

    ljam();

    req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;

    req->indexId = triggerPtr.p->indexId;

    req->errorCode = RNIL;

    EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
@@ -1074,7 +1075,8 @@ Dbtup::executeTuxCommitTriggers(Signal* signal, 
  // fill in constant part

  req->tableId = regOperPtr->tableRef;

  req->fragId = regOperPtr->fragId;

  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;

  req->pageId = regOperPtr->realPageId;

  req->pageOffset = regOperPtr->pageOffset;

  req->tupVersion = tupVersion;

  req->opInfo = TuxMaintReq::OpRemove;

  // loop over index list
@@ -1117,7 +1119,8 @@ Dbtup::executeTuxAbortTriggers(Signal* signal, 
  // fill in constant part

  req->tableId = regOperPtr->tableRef;

  req->fragId = regOperPtr->fragId;

  req->tupAddr = (regOperPtr->fragPageId << MAX_TUPLES_BITS) | regOperPtr->pageIndex;

  req->pageId = regOperPtr->realPageId;

  req->pageOffset = regOperPtr->pageOffset;

  req->tupVersion = tupVersion;

  req->opInfo = TuxMaintReq::OpRemove;

  // loop over index list