tux optim 1 - use physical fragment addresses

9 files changed, 103 insertions, 16 deletions

diff --git a/ndb/include/kernel/signaldata/TupFrag.hpp b/ndb/include/kernel/signaldata/TupFrag.hpp
index ffde2217893..fc88dacd48f 100644
--- a/ndb/include/kernel/signaldata/TupFrag.hpp
+++ b/ndb/include/kernel/signaldata/TupFrag.hpp
@@ -69,7 +69,7 @@ class TuxFragReq {
   friend class Dblqh;
   friend class Dbtux;
 public:
-  STATIC_CONST( SignalLength = 9 );
+  STATIC_CONST( SignalLength = 14 );
 private:
   Uint32 userPtr;
   Uint32 userRef;
@@ -80,6 +80,9 @@ private:
   Uint32 fragOff;
   Uint32 tableType;
   Uint32 primaryTableId;
+  Uint32 tupIndexFragPtrI;
+  Uint32 tupTableFragPtrI[2];
+  Uint32 accTableFragPtrI[2];
 };
 
 class TuxFragConf {
diff --git a/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
index 02474f6bee0..933ee2cf8e1 100644
--- a/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
+++ b/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp
@@ -2432,6 +2432,7 @@ void Dbacc::execACC_LOCKREQ(Signal* signal)
     }
     fragrecptr.i = req->fragPtrI;
     ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec);
+    ndbrequire(req->fragId == fragrecptr.p->myfid);
     // caller must be explicit here
     ndbrequire(req->accOpPtr == RNIL);
     // seize operation to hold the lock
diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
index 613f9ccea11..1abf4b3a7e9 100644
--- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
+++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp
@@ -1225,6 +1225,18 @@ Dblqh::sendAddFragReq(Signal* signal)
       tuxreq->fragOff = addfragptr.p->lh3DistrBits;
       tuxreq->tableType = addfragptr.p->tableType;
       tuxreq->primaryTableId = addfragptr.p->primaryTableId;
+      // pointer to index fragment in TUP
+      tuxreq->tupIndexFragPtrI =
+        addfragptr.p->addfragStatus == AddFragRecord::WAIT_TWO_TUX ?
+        fragptr.p->tupFragptr[0] : fragptr.p->tupFragptr[1];
+      // pointers to table fragments in TUP and ACC
+      FragrecordPtr tFragPtr;
+      tFragPtr.i = fragptr.p->tableFragptr;
+      ptrCheckGuard(tFragPtr, cfragrecFileSize, fragrecord);
+      tuxreq->tupTableFragPtrI[0] = tFragPtr.p->tupFragptr[0];
+      tuxreq->tupTableFragPtrI[1] = tFragPtr.p->tupFragptr[1];
+      tuxreq->accTableFragPtrI[0] = tFragPtr.p->accFragptr[0];
+      tuxreq->accTableFragPtrI[1] = tFragPtr.p->accFragptr[1];
       sendSignal(fragptr.p->tuxBlockref, GSN_TUXFRAGREQ,
           signal, TuxFragReq::SignalLength, JBB);
       return;
diff --git a/ndb/src/kernel/blocks/dbtux/Dbtux.hpp b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
index e871fc86dea..214396981f9 100644
--- a/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
+++ b/ndb/src/kernel/blocks/dbtux/Dbtux.hpp
@@ -446,6 +446,9 @@ private:
     Uint32 m_nodeList;          // node cache of current operation
     Uint32 m_nodeFree;          // one node pre-allocated for insert
     DLList<ScanOp> m_scanList;  // current scans on this fragment
+    Uint32 m_tupIndexFragPtrI;
+    Uint32 m_tupTableFragPtrI[2];
+    Uint32 m_accTableFragPtrI[2];
     union {
     Uint32 nextPool;
     };
@@ -981,8 +984,13 @@ Dbtux::Frag::Frag(ArrayPool<ScanOp>& scanOpPool) :
   m_tree(),
   m_nodeList(RNIL),
   m_nodeFree(RNIL),
-  m_scanList(scanOpPool)
+  m_scanList(scanOpPool),
+  m_tupIndexFragPtrI(RNIL)
 {
+  m_tupTableFragPtrI[0] = RNIL;
+  m_tupTableFragPtrI[1] = RNIL;
+  m_accTableFragPtrI[0] = RNIL;
+  m_accTableFragPtrI[1] = RNIL;
 }
 
 inline
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
index a6b2485067c..e69882766d6 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxMaint.cpp
@@ -199,7 +199,7 @@ Dbtux::tupReadAttrs(Signal* signal, const Frag& frag, ReadPar& readPar)
   req->requestInfo = 0;
   req->tableId = frag.m_tableId;
   req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
-  req->fragPtrI = RNIL;
+  req->fragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
   req->tupAddr = ent.m_tupAddr;
   req->tupVersion = ent.m_tupVersion;
   req->pageId = RNIL;
@@ -246,7 +246,7 @@ Dbtux::tupReadKeys(Signal* signal, const Frag& frag, ReadPar& readPar)
   req->requestInfo = TupReadAttrs::ReadKeys;
   req->tableId = frag.m_tableId;
   req->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
-  req->fragPtrI = RNIL;
+  req->fragPtrI = frag.m_tupTableFragPtrI[ent.m_fragBit];
   req->tupAddr = ent.m_tupAddr;
   req->tupVersion = RNIL; // not used
   req->pageId = RNIL;
@@ -284,7 +284,7 @@ Dbtux::tupStoreTh(Signal* signal, const Frag& frag, NodeHandlePtr nodePtr, Store
   req->errorCode = RNIL;
   req->tableId = frag.m_indexId;
   req->fragId = frag.m_fragId;
-  req->fragPtrI = RNIL;
+  req->fragPtrI = frag.m_tupIndexFragPtrI;
   req->tupAddr = nodePtr.p->m_addr;
   req->tupVersion = 0;
   req->pageId = nodePtr.p->m_loc.m_pageId;
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
index 2ffd599429c..fe7777a2ee7 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxMeta.cpp
@@ -85,6 +85,11 @@ Dbtux::execTUXFRAGREQ(Signal* signal)
     fragPtr.p->m_fragOff = req->fragOff;
     fragPtr.p->m_fragId = req->fragId;
     fragPtr.p->m_numAttrs = req->noOfAttr;
+    fragPtr.p->m_tupIndexFragPtrI = req->tupIndexFragPtrI;
+    fragPtr.p->m_tupTableFragPtrI[0] = req->tupTableFragPtrI[0];
+    fragPtr.p->m_tupTableFragPtrI[1] = req->tupTableFragPtrI[1];
+    fragPtr.p->m_accTableFragPtrI[0] = req->accTableFragPtrI[0];
+    fragPtr.p->m_accTableFragPtrI[1] = req->accTableFragPtrI[1];
     // add the fragment to the index
     indexPtr.p->m_fragId[indexPtr.p->m_numFrags] = req->fragId;
     indexPtr.p->m_fragPtrI[indexPtr.p->m_numFrags] = fragPtr.i;
diff --git a/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
index eaa539d9cfc..c7ddca09517 100644
--- a/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
+++ b/ndb/src/kernel/blocks/dbtux/DbtuxScan.cpp
@@ -407,8 +407,7 @@ Dbtux::execACC_CHECK_SCAN(Signal* signal)
       lockReq->userRef = reference();
       lockReq->tableId = scan.m_tableId;
       lockReq->fragId = frag.m_fragId | (ent.m_fragBit << frag.m_fragOff);
-      // should cache this at fragment create
-      lockReq->fragPtrI = RNIL;
+      lockReq->fragPtrI = frag.m_accTableFragPtrI[ent.m_fragBit];
       const Uint32* const buf32 = static_cast<Uint32*>(keyPar.m_data);
       const Uint64* const buf64 = reinterpret_cast<const Uint64*>(buf32);
       lockReq->hashValue = md5_hash(buf64, keyPar.m_size);
diff --git a/ndb/src/kernel/blocks/dbtux/Times.txt b/ndb/src/kernel/blocks/dbtux/Times.txt
new file mode 100644
index 00000000000..efed1f75657
--- /dev/null
+++ b/ndb/src/kernel/blocks/dbtux/Times.txt
@@ -0,0 +1,18 @@
+"mc02" 2x1700 MHz linux-2.4.9 gcc-2.96 -O3 one db-node
+
+case a: index on Unsigned
+testOIBasic -case u -table 1 -index 1 -fragtype small -threads 10 -rows 100000 -subloop 1 -nologging
+
+case b: index on Varchar(5) + Varchar(5) + Varchar(20) + Unsigned
+testOIBasic -case u -table 2 -index 4 -fragtype small -threads 10 -rows 100000 -subloop 1 -nologging
+
+update without index, update with index
+shows ms / 1000 for each and pct overhead
+
+040616          mc02/a  40 ms   87 ms   114 pct
+                mc02/b  51 ms  128 ms   148 pct
+
+optim 1         mc02/a  38 ms   85 ms   124 pct
+                mc02/b  51 ms  123 ms   140 pct
+
+vim: set et:
diff --git a/ndb/test/ndbapi/testOIBasic.cpp b/ndb/test/ndbapi/testOIBasic.cpp
index a47d9d2099e..0338966ed31 100644
--- a/ndb/test/ndbapi/testOIBasic.cpp
+++ b/ndb/test/ndbapi/testOIBasic.cpp
@@ -39,6 +39,7 @@ struct Opt {
   NdbDictionary::Object::FragmentType m_fragtype;
   const char* m_index;
   unsigned m_loop;
+  bool m_nologging;
   unsigned m_rows;
   unsigned m_scanrd;
   unsigned m_scanex;
@@ -54,6 +55,7 @@ struct Opt {
     m_fragtype(NdbDictionary::Object::FragUndefined),
     m_index(0),
     m_loop(1),
+    m_nologging(false),
     m_rows(1000),
     m_scanrd(240),
     m_scanex(240),
@@ -82,6 +84,7 @@ printhelp()
     << "  -fragtype T   fragment type single/small/medium/large" << endl
     << "  -index xyz    only given index numbers (digits 1-9)" << endl
     << "  -loop N       loop count full suite forever=0 [" << d.m_loop << "]" << endl
+    << "  -nologging    create tables in no-logging mode" << endl
     << "  -rows N       rows per thread [" << d.m_rows << "]" << endl
     << "  -scanrd N     scan read parallelism [" << d.m_scanrd << "]" << endl
     << "  -scanex N     scan exclusive parallelism [" << d.m_scanex << "]" << endl
@@ -476,7 +479,7 @@ tt1 = {
   "TT1", 5, tt1col, 4, tt1itab
 };
 
-// tt2 + tt2x1 tt2x2 tt2x3
+// tt2 + tt2x1 tt2x2 tt2x3 tt2x4
 
 static const Col
 tt2col[] = {
@@ -505,6 +508,14 @@ tt2x3col[] = {
   { 1, tt2col[4] }
 };
 
+static const ICol
+tt2x4col[] = {
+  { 0, tt2col[4] },
+  { 1, tt2col[3] },
+  { 2, tt2col[2] },
+  { 3, tt2col[1] }
+};
+
 static const ITab
 tt2x1 = {
   "TT2X1", 2, tt2x1col
@@ -521,15 +532,21 @@ tt2x3 = {
 };
 
 static const ITab
+tt2x4 = {
+  "TT2X4", 4, tt2x4col
+};
+
+static const ITab
 tt2itab[] = {
   tt2x1,
   tt2x2,
-  tt2x3
+  tt2x3,
+  tt2x4
 };
 
 static const Tab
 tt2 = {
-  "TT2", 5, tt2col, 3, tt2itab
+  "TT2", 5, tt2col, 4, tt2itab
 };
 
 // all tables
@@ -823,6 +840,9 @@ createtable(Par par)
   if (par.m_fragtype != NdbDictionary::Object::FragUndefined) {
     t.setFragmentType(par.m_fragtype);
   }
+  if (par.m_nologging) {
+    t.setLogging(false);
+  }
   for (unsigned k = 0; k < tab.m_cols; k++) {
     const Col& col = tab.m_col[k];
     NdbDictionary::Column c(col.m_name);
@@ -2500,9 +2520,28 @@ tbusybuild(Par par)
 }
 
 static int
-ttiming(Par par)
+ttimebuild(Par par)
 {
-  Tmr t0, t1, t2;
+  Tmr t1;
+  RUNSTEP(par, droptable, ST);
+  RUNSTEP(par, createtable, ST);
+  RUNSTEP(par, invalidatetable, MT);
+  for (unsigned i = 0; i < par.m_subloop; i++) {
+    RUNSTEP(par, pkinsert, MT);
+    t1.on();
+    RUNSTEP(par, createindex, ST);
+    t1.off(par.m_totrows);
+    RUNSTEP(par, invalidateindex, MT);
+    RUNSTEP(par, dropindex, ST);
+  }
+  LL1("build index - " << t1.time());
+  return 0;
+}
+
+static int
+ttimemaint(Par par)
+{
+  Tmr t1, t2;
   RUNSTEP(par, droptable, ST);
   RUNSTEP(par, createtable, ST);
   RUNSTEP(par, invalidatetable, MT);
@@ -2511,16 +2550,13 @@ ttiming(Par par)
     t1.on();
     RUNSTEP(par, pkupdate, MT);
     t1.off(par.m_totrows);
-    t0.on();
     RUNSTEP(par, createindex, ST);
     RUNSTEP(par, invalidateindex, MT);
-    t0.off(par.m_totrows);
     t2.on();
     RUNSTEP(par, pkupdate, MT);
     t2.off(par.m_totrows);
     RUNSTEP(par, dropindex, ST);
   }
-  LL1("build index - " << t0.time());
   LL1("update - " << t1.time());
   LL1("update indexed - " << t2.time());
   LL1("overhead - " << t2.over(t1));
@@ -2551,7 +2587,8 @@ tcaselist[] = {
   TCase("b", tpkops, "pk operations and scan reads"),
   TCase("c", tmixedops, "pk operations and scan operations"),
   TCase("d", tbusybuild, "pk operations and index build"),
-  TCase("t", ttiming, "time index build and maintenance"),
+  TCase("t", ttimebuild, "time index build"),
+  TCase("u", ttimemaint, "time index maintenance"),
   TCase("z", tdrop, "drop test tables")
 };
 
@@ -2689,6 +2726,10 @@ NDB_COMMAND(testOIBasic, "testOIBasic", "testOIBasic", "testOIBasic", 65535)
         continue;
       }
     }
+    if (strcmp(arg, "-nologging") == 0) {
+      g_opt.m_nologging = true;
+      continue;
+    }
     if (strcmp(arg, "-rows") == 0) {
       if (++argv, --argc > 0) {
         g_opt.m_rows = atoi(argv[0]);