moved some Ndb member variables to NdbImpl class

removed theCurrentConnectCounter
optimized the_release_ind by using pos[0] to indicate that there is something there
smaller storage of theDBNodes array by using Uint8
set the_relase_ind array to Uint32 to avoid possible parallell thread usage errors

8 files changed, 76 insertions, 103 deletions

diff --git a/ndb/include/ndbapi/Ndb.hpp b/ndb/include/ndbapi/Ndb.hpp
index 5ec09269695..1c9c2db5d6b 100644
--- a/ndb/include/ndbapi/Ndb.hpp
+++ b/ndb/include/ndbapi/Ndb.hpp
@@ -1586,7 +1586,6 @@ private:
 /******************************************************************************
  *	These are the private variables in this class.	
  *****************************************************************************/
-  NdbObjectIdMap*       theNdbObjectIdMap;
   Ndb_cluster_connection   *m_ndb_cluster_connection;
 
   NdbConnection**       thePreparedTransactionsArray;
@@ -1637,10 +1636,6 @@ private:
   Uint32   theMyRef;        // My block reference  
   Uint32   theNode;         // The node number of our node
   
-  Uint32   theNoOfDBnodes;  // The number of DB nodes  
-  Uint32 * theDBnodes;      // The node number of the DB nodes
-  Uint8    *the_release_ind;// 1 indicates to release all connections to node 
-  
   Uint64               the_last_check_time;
   Uint64               theFirstTransId;
   
@@ -1663,10 +1658,6 @@ private:
     InitConfigError
   } theInitState;
 
-  // Ensure good distribution of connects
-  Uint32		theCurrentConnectIndex;
-  Uint32		theCurrentConnectCounter;
-  
   /**
    * Computes fragement id for primary key
    *
@@ -1692,7 +1683,7 @@ private:
     Uint32 noOfFragments;
     Uint32 * fragment2PrimaryNodeMap;
     
-    void init(Uint32 noOfNodes, Uint32 nodeIds[]);
+    void init(Uint32 noOfNodes, Uint8 nodeIds[]);
     void release();
   } startTransactionNodeSelectionData;
   
diff --git a/ndb/src/ndbapi/Ndb.cpp b/ndb/src/ndbapi/Ndb.cpp
index 75ae539fc8b..ddfe94c1421 100644
--- a/ndb/src/ndbapi/Ndb.cpp
+++ b/ndb/src/ndbapi/Ndb.cpp
@@ -65,37 +65,25 @@ NdbConnection* Ndb::doConnect(Uint32 tConNode)
 // We will connect to any node. Make sure that we have connections to all
 // nodes.
 //****************************************************************************
-  Uint32 tNoOfDbNodes = theNoOfDBnodes;
-  i = theCurrentConnectIndex;
+  Uint32 tNoOfDbNodes= theImpl->theNoOfDBnodes;
+  Uint32 &theCurrentConnectIndex= theImpl->theCurrentConnectIndex;
   UintR Tcount = 0;
   do {
-    if (i >= tNoOfDbNodes) {
-      i = 0;
+    theCurrentConnectIndex++;
+    if (theCurrentConnectIndex >= tNoOfDbNodes) {
+      theCurrentConnectIndex = 0;
     }//if
     Tcount++;
-    tNode = theDBnodes[i];
+    tNode = theImpl->theDBnodes[theCurrentConnectIndex];
     TretCode = NDB_connect(tNode);
     if ((TretCode == 1) || (TretCode == 2)) {
 //****************************************************************************
 // We have connections now to the desired node. Return
 //****************************************************************************
-      if (theCurrentConnectIndex == i) {
-        theCurrentConnectCounter++;
-        if (theCurrentConnectCounter == 8) {
-	  theCurrentConnectCounter = 1;
-	  theCurrentConnectIndex++;
-	}//if
-      } else {
-	// Set to 2 because we have already connected to a node 
-	// when we get here.
-        theCurrentConnectCounter = 2;
-        theCurrentConnectIndex = i;
-      }//if
       return getConnectedNdbConnection(tNode);
     } else if (TretCode != 0) {
       tAnyAlive = 1;
     }//if
-    i++;
   } while (Tcount < tNoOfDbNodes);
 //****************************************************************************
 // We were unable to find a free connection. If no node alive we will report
@@ -211,8 +199,9 @@ Ndb::doDisconnect()
   NdbConnection* tNdbCon;
   CHECK_STATUS_MACRO_VOID;
 
-  DBUG_PRINT("info", ("theNoOfDBnodes=%d", theNoOfDBnodes));
-  Uint32 tNoOfDbNodes = theNoOfDBnodes;
+  Uint32 tNoOfDbNodes = theImpl->theNoOfDBnodes;
+  Uint8 *theDBnodes= theImpl->theDBnodes;
+  DBUG_PRINT("info", ("theNoOfDBnodes=%d", tNoOfDbNodes));
   UintR i;
   for (i = 0; i < tNoOfDbNodes; i++) {
     Uint32 tNode = theDBnodes[i];
@@ -259,8 +248,8 @@ Ndb::waitUntilReady(int timeout)
       unsigned int foundAliveNode = 0;
       TransporterFacade *tp = TransporterFacade::instance();
       tp->lock_mutex();
-      for (unsigned int i = 0; i < theNoOfDBnodes; i++) {
-	const NodeId nodeId = theDBnodes[i];
+      for (unsigned int i = 0; i < theImpl->theNoOfDBnodes; i++) {
+	const NodeId nodeId = theImpl->theDBnodes[i];
 	//************************************************
 	// If any node is answering, ndb is answering
 	//************************************************
@@ -270,7 +259,7 @@ Ndb::waitUntilReady(int timeout)
       }//for
       
       tp->unlock_mutex();
-      if (foundAliveNode == theNoOfDBnodes) {
+      if (foundAliveNode == theImpl->theNoOfDBnodes) {
 	DBUG_RETURN(0);
       }//if
       if (foundAliveNode > 0) {
@@ -1077,7 +1066,7 @@ Ndb::guessPrimaryNode(Uint32 fragmentId){
 
 void
 Ndb::StartTransactionNodeSelectionData::init(Uint32 noOfNodes,
-                                             Uint32 nodeIds[]) {
+                                             Uint8 nodeIds[]) {
   kValue           = 6;
   noOfFragments    = 2 * noOfNodes;
 
diff --git a/ndb/src/ndbapi/NdbConnection.cpp b/ndb/src/ndbapi/NdbConnection.cpp
index f4bb000300a..01012bfda01 100644
--- a/ndb/src/ndbapi/NdbConnection.cpp
+++ b/ndb/src/ndbapi/NdbConnection.cpp
@@ -83,7 +83,7 @@ NdbConnection::NdbConnection( Ndb* aNdb ) :
 {
   theListState = NotInList;
   theError.code = 0;
-  theId = theNdb->theNdbObjectIdMap->map(this);
+  theId = theNdb->theImpl->theNdbObjectIdMap.map(this);
 
 #define CHECK_SZ(mask, sz) assert((sizeof(mask)/sizeof(mask[0])) == sz)
 
@@ -99,7 +99,7 @@ Remark:        Deletes the connection object.
 NdbConnection::~NdbConnection()
 {
   DBUG_ENTER("NdbConnection::~NdbConnection");
-  theNdb->theNdbObjectIdMap->unmap(theId, this);
+  theNdb->theImpl->theNdbObjectIdMap.unmap(theId, this);
   DBUG_VOID_RETURN;
 }//NdbConnection::~NdbConnection()
 
diff --git a/ndb/src/ndbapi/NdbImpl.hpp b/ndb/src/ndbapi/NdbImpl.hpp
index 1fb1969b589..cd1364e15fb 100644
--- a/ndb/src/ndbapi/NdbImpl.hpp
+++ b/ndb/src/ndbapi/NdbImpl.hpp
@@ -17,7 +17,15 @@
 #ifndef NDB_IMPL_HPP
 #define NDB_IMPL_HPP
 
-#include <Vector.hpp>
+#include <Ndb.hpp>
+#include <NdbError.hpp>
+#include <NdbCondition.h>
+#include <NdbReceiver.hpp>
+#include <NdbOperation.hpp>
+#include <kernel/ndb_limits.h>
+
+#include <NdbTick.h>
+
 #include "ObjectMap.hpp"
 
 /**
@@ -25,19 +33,20 @@
  */
 class NdbImpl {
 public:
-  Vector<class NdbTableImpl *> m_invalidTables;
+  NdbImpl();
+  ~NdbImpl();
 
-  void checkErrorCode(Uint32 i);
-  void checkInvalidTable(class NdbDictionaryImpl * dict);
-};
+  // Ensure good distribution of connects
+  Uint32 theCurrentConnectIndex;
 
-#include <Ndb.hpp>
-#include <NdbError.hpp>
-#include <NdbCondition.h>
-#include <NdbReceiver.hpp>
-#include <NdbOperation.hpp>
+  NdbObjectIdMap theNdbObjectIdMap;
 
-#include <NdbTick.h>
+  Uint32 theNoOfDBnodes; // The number of DB nodes  
+  Uint8 theDBnodes[MAX_NDB_NODES]; // The node number of the DB nodes
+
+ // 1 indicates to release all connections to node 
+  Uint32 the_release_ind[MAX_NDB_NODES];
+};
 
 #ifdef VM_TRACE
 #define TRACE_DEBUG(x) ndbout << x << endl;
@@ -57,7 +66,7 @@ public:
 inline
 void *
 Ndb::int2void(Uint32 val){
-  return theNdbObjectIdMap->getObject(val);
+  return theImpl->theNdbObjectIdMap.getObject(val);
 }
 
 inline
diff --git a/ndb/src/ndbapi/NdbReceiver.cpp b/ndb/src/ndbapi/NdbReceiver.cpp
index 14f8d4b8440..cad247512b2 100644
--- a/ndb/src/ndbapi/NdbReceiver.cpp
+++ b/ndb/src/ndbapi/NdbReceiver.cpp
@@ -40,7 +40,7 @@ NdbReceiver::~NdbReceiver()
 {
   DBUG_ENTER("NdbReceiver::~NdbReceiver");
   if (m_id != NdbObjectIdMap::InvalidId) {
-    m_ndb->theNdbObjectIdMap->unmap(m_id, this);
+    m_ndb->theImpl->theNdbObjectIdMap.unmap(m_id, this);
   }
   delete[] m_rows;
   DBUG_VOID_RETURN;
@@ -54,7 +54,7 @@ NdbReceiver::init(ReceiverType type, void* owner)
   m_owner = owner;
   if (m_id == NdbObjectIdMap::InvalidId) {
     if (m_ndb)
-      m_id = m_ndb->theNdbObjectIdMap->map(this);
+      m_id = m_ndb->theImpl->theNdbObjectIdMap.map(this);
   }
 
   theFirstRecAttr = NULL;
diff --git a/ndb/src/ndbapi/Ndbif.cpp b/ndb/src/ndbapi/Ndbif.cpp
index c011c1a6a26..232e55662f0 100644
--- a/ndb/src/ndbapi/Ndbif.cpp
+++ b/ndb/src/ndbapi/Ndbif.cpp
@@ -92,8 +92,8 @@ Ndb::init(int aMaxNoOfTransactions)
   
   theDictionary->setTransporter(this, theFacade);
   
-  aNrOfCon = theNoOfDBnodes;
-  aNrOfOp = 2*theNoOfDBnodes;
+  aNrOfCon = theImpl->theNoOfDBnodes;
+  aNrOfOp = 2*theImpl->theNoOfDBnodes;
   
   // Create connection object in a linked list 
   if((createConIdleList(aNrOfCon)) == -1){
@@ -192,14 +192,14 @@ void Ndb::connected(Uint32 ref)
   }
   
   TransporterFacade * theFacade =  TransporterFacade::instance();
-  int i;
-  theNoOfDBnodes= 0;
+  int i, n= 0;
   for (i = 1; i < MAX_NDB_NODES; i++){
     if (theFacade->getIsDbNode(i)){
-      theDBnodes[theNoOfDBnodes] = i;
-      theNoOfDBnodes++;
+      theImpl->theDBnodes[n] = i;
+      n++;
     }
   }
+  theImpl->theNoOfDBnodes= n;
   theFirstTransId = ((Uint64)tBlockNo << 52)+
     ((Uint64)tmpTheNode << 40);
   theFirstTransId += theFacade->m_max_trans_id;
@@ -207,9 +207,10 @@ void Ndb::connected(Uint32 ref)
   DBUG_PRINT("info",("connected with ref=%x, id=%d, no_db_nodes=%d, first_trans_id=%lx",
 		     theMyRef,
 		     tmpTheNode,
-		     theNoOfDBnodes,
+		     theImpl->theNoOfDBnodes,
 		     theFirstTransId));
-  startTransactionNodeSelectionData.init(theNoOfDBnodes, theDBnodes);
+  startTransactionNodeSelectionData.init(theImpl->theNoOfDBnodes,
+					 theImpl->theDBnodes);
   theCommitAckSignal = new NdbApiSignal(theMyRef);
 
   theDictionary->m_receiver.m_reference= theMyRef;
@@ -247,7 +248,9 @@ Ndb::report_node_failure(Uint32 node_id)
    * 
    * This method is only called by ClusterMgr (via lots of methods)
    */
-  the_release_ind[node_id] = 1;
+  theImpl->the_release_ind[node_id] = 1;
+  // must come after
+  theImpl->the_release_ind[0] = 1;
   theWaiter.nodeFail(node_id);
   return;
 }//Ndb::report_node_failure()
diff --git a/ndb/src/ndbapi/Ndbinit.cpp b/ndb/src/ndbapi/Ndbinit.cpp
index 48e62c36a5f..9754c25ab15 100644
--- a/ndb/src/ndbapi/Ndbinit.cpp
+++ b/ndb/src/ndbapi/Ndbinit.cpp
@@ -82,7 +82,6 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
 {
   DBUG_ENTER("Ndb::setup");
 
-  theNdbObjectIdMap= 0;
   m_ndb_cluster_connection= ndb_cluster_connection;
   thePreparedTransactionsArray= NULL;
   theSentTransactionsArray= NULL;
@@ -110,9 +109,6 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
   theCallList= NULL;
   theScanList= NULL;
   theNdbBlobIdleList= NULL;
-  theNoOfDBnodes= 0;
-  theDBnodes= NULL;
-  the_release_ind= NULL;
   the_last_check_time= 0;
   theFirstTransId= 0;
   theRestartGCI= 0;
@@ -134,19 +130,12 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
 
   theError.code = 0;
 
-  theNdbObjectIdMap  = new NdbObjectIdMap(1024,1024);
   theConnectionArray = new NdbConnection * [MAX_NDB_NODES];
-  theDBnodes         = new Uint32[MAX_NDB_NODES];
-  the_release_ind    = new Uint8[MAX_NDB_NODES];
   theCommitAckSignal = NULL;
   
-  theCurrentConnectCounter = 1;
-  theCurrentConnectIndex = 0;
   int i;
   for (i = 0; i < MAX_NDB_NODES ; i++) {
     theConnectionArray[i] = NULL;
-    the_release_ind[i] = 0;
-    theDBnodes[i] = 0;
   }//forg
   for (i = 0; i < 2048 ; i++) {
     theFirstTupleId[i] = 0;
@@ -213,7 +202,6 @@ Ndb::~Ndb()
   doDisconnect();
 
   delete theDictionary;  
-  delete theImpl;
 
   NdbGlobalEventBuffer_drop(theGlobalEventBufferHandle);
 
@@ -260,15 +248,12 @@ Ndb::~Ndb()
   startTransactionNodeSelectionData.release();
 
   delete []theConnectionArray;
-  delete []theDBnodes;
-  delete []the_release_ind;
   if(theCommitAckSignal != NULL){
     delete theCommitAckSignal; 
     theCommitAckSignal = NULL;
   }
 
-  if(theNdbObjectIdMap != 0)
-    delete theNdbObjectIdMap;
+  delete theImpl;
 
   /** 
    *  This sleep is to make sure that the transporter 
@@ -307,4 +292,17 @@ NdbWaiter::~NdbWaiter(){
   NdbCondition_Destroy(m_condition);
 }
 
+NdbImpl::NdbImpl() : theNdbObjectIdMap(1024,1024),
+		     theCurrentConnectIndex(0),
+		     theNoOfDBnodes(0)
+{
+  int i;
+  for (i = 0; i < MAX_NDB_NODES; i++) {
+    the_release_ind[i] = 0;
+  }
+}
+
+NdbImpl::~NdbImpl()
+{
+}
 
diff --git a/ndb/src/ndbapi/Ndblist.cpp b/ndb/src/ndbapi/Ndblist.cpp
index a5f2a4801d5..5902aa413dc 100644
--- a/ndb/src/ndbapi/Ndblist.cpp
+++ b/ndb/src/ndbapi/Ndblist.cpp
@@ -30,10 +30,18 @@ void
 Ndb::checkFailedNode()
 {
   DBUG_ENTER("Ndb::checkFailedNode");
-  DBUG_PRINT("enter", ("theNoOfDBnodes: %d", theNoOfDBnodes));
+  Uint32 *the_release_ind= theImpl->the_release_ind;
+  if (the_release_ind[0] == 0)
+  {
+    DBUG_VOID_RETURN;
+  }
+  Uint32 tNoOfDbNodes = theImpl->theNoOfDBnodes;
+  Uint8 *theDBnodes= theImpl->theDBnodes;
+
+  DBUG_PRINT("enter", ("theNoOfDBnodes: %d", tNoOfDbNodes));
 
-  DBUG_ASSERT(theNoOfDBnodes < MAX_NDB_NODES);
-  for (Uint32 i = 0; i < theNoOfDBnodes; i++){
+  DBUG_ASSERT(tNoOfDbNodes < MAX_NDB_NODES);
+  for (Uint32 i = 0; i < tNoOfDbNodes; i++){
     const NodeId node_id = theDBnodes[i];
     DBUG_PRINT("info", ("i: %d, node_id: %d", i, node_id));
     
@@ -56,31 +64,6 @@ Ndb::checkFailedNode()
   DBUG_VOID_RETURN;
 }
 
-#if 0
-void
-NdbImpl::checkInvalidTable(NdbDictionaryImpl * dict){
-  Uint32 sz = m_invalidTables.size();
-  for(Int32 i = sz - 1; i >= 0; i--){
-    NdbTableImpl * tab = m_invalidTables[i];
-    m_invalidTables.erase(i);
-    dict->tableDropped(* tab);
-  }
-}
-
-void
-NdbImpl::checkErrorCode(Uint32 i, NdbTableImpl * tab){
-  switch(i){
-  case 241:
-  case 283:
-  case 284:
-  case 285:
-  case 1225:
-  case 1226:
-    
-  }
-}
-#endif
-
 /***************************************************************************
  * int createConIdleList(int aNrOfCon);
  *