Merge ../mysql-5.1-telco-7.1 into mysql-5.5-cluster-7.2

 - Merged with existing related bugfix - Reusing testDict -n GetTabInfoRef - Removed STATIC_CONST macro - Some comment fixes

Author: frazerclement

storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
 
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -452,6 +452,10 @@ void Dbdict::execCONTINUEB(Signal* signal)
  sendSignal(calcDictBlockRef(c_masterNodeId), GSN_GET_TABINFOREQ, signal,
  GetTabInfoReq::SignalLength, JBB);
  break;
+ case ZNEXT_GET_TAB_REQ:
+ jam();
+ startNextGetTabInfoReq(signal);
+ break;
  default :
  ndbrequire(false);
  break;
@@ -493,7 +497,7 @@ void Dbdict::packTableIntoPages(Signal* signal)
  jam();
  sendGET_TABINFOREF(signal, &req_copy,
  GetTabInfoRef::TableNotDefined, __LINE__);
- initRetrieveRecord(0, 0, 0);
+ initRetrieveRecord(signal, 0, 0);
  return;
  }
 
@@ -513,7 +517,7 @@ void Dbdict::packTableIntoPages(Signal* signal)
  // cannot see another uncommitted trans
  sendGET_TABINFOREF(signal, &req_copy,
  (GetTabInfoRef::ErrorCode)err, __LINE__);
- initRetrieveRecord(0, 0, 0);
+ initRetrieveRecord(signal, 0, 0);
  return;
  }
  }
@@ -541,7 +545,7 @@ void Dbdict::packTableIntoPages(Signal* signal)
  jam();
  sendGET_TABINFOREF(signal, &req_copy,
  GetTabInfoRef::TableNotDefined, __LINE__);
- initRetrieveRecord(0, 0, 0);
+ initRetrieveRecord(signal, 0, 0);
  return;
  }
 
@@ -558,7 +562,7 @@ void Dbdict::packTableIntoPages(Signal* signal)
  Uint32 dstRef = c_retrieveRecord.blockRef;
  sendSignal(dstRef, GSN_GET_TABINFOREF, signal,
  GetTabInfoRef::SignalLength, JBB);
- initRetrieveRecord(0,0,0);
+ initRetrieveRecord(signal,0,0);
  return;
  }
  break;
@@ -1984,6 +1988,7 @@ Dbdict::Dbdict(Block_context& ctx):
  c_attributeRecordHash(c_attributeRecordPool),
  c_obj_name_hash(c_obj_pool),
  c_obj_id_hash(c_obj_pool),
+ c_gettabinforeq_q(*this),
  c_schemaOpHash(c_schemaOpPool),
  c_schemaTransHash(c_schemaTransPool),
  c_schemaTransList(c_schemaTransPool),
@@ -2316,14 +2321,34 @@ void Dbdict::initWriteSchemaRecord()
 
 void Dbdict::initRetrieveRecord(Signal* signal, Uint32 i, Uint32 returnCode)
 {
- c_retrieveRecord.busyState = false;
+ jam();
  c_retrieveRecord.blockRef = 0;
  c_retrieveRecord.m_senderData = RNIL;
  c_retrieveRecord.tableId = RNIL;
  c_retrieveRecord.currentSent = 0;
  c_retrieveRecord.retrievedNoOfPages = 0;
  c_retrieveRecord.retrievedNoOfWords = 0;
  c_retrieveRecord.m_useLongSig = false;
+
+ if (!c_gettabinforeq_q.isEmpty())
+ {
+ jam();
+ ndbrequire(signal != NULL);
+
+ /* Take a real-time break now, CONTINUEB will
+ * start processing the next request.
+ * busyState = true will maintain fairness
+ */
+ signal->theData[0] = ZNEXT_GET_TAB_REQ;
+ sendSignal(reference(), GSN_CONTINUEB, signal,
+ 1, JBB);
+ }
+ else
+ {
+ /* Done */
+ c_retrieveRecord.busyState = false;
+ }
+
 }//initRetrieveRecord()
 
 void Dbdict::initSchemaRecord()
@@ -2831,6 +2856,9 @@ void Dbdict::execREAD_CONFIG_REQ(Signal* signal)
  bat[1].bits.q = ZLOG_SIZE_OF_PAGES_IN_WORDS; // 2**13 = 8192 elements
  bat[1].bits.v = 5; // 32 bits per element
 
+ /* Initialize Segment Sub pool in GetTabInfoReq queue */
+ ndbrequire(c_gettabinforeq_q.init(jamBuffer()));
+
  initCommonData();
  initRecords();
 
@@ -4195,8 +4223,10 @@ Dbdict::restart_fromWriteSchemaFile(Signal* signal,
 }
 
 void
-Dbdict::execGET_TABINFOREF(Signal* signal){
+Dbdict::execGET_TABINFOREF(Signal* signal)
+{
  jamEntry();
+
  /** 
  * Make copy of 'ref' such that we can build 'req' without overwriting 
  * source.
@@ -4208,6 +4238,13 @@ Dbdict::execGET_TABINFOREF(Signal* signal){
  {
  jam();
 
+ const Uint32 senderRef = ref_copy.senderRef;
+ ndbout_c("DICT : GET_TABINFOREF(Busy) Retained for upgrade "
+ "compatibility. Sender node : %u block : %u version : %x",
+ refToNode(senderRef),
+ refToMain(senderRef),
+ getNodeInfo(refToNode(senderRef)).m_version);
+
  /**
  * Master is busy. Send delayed CONTINUEB to self to add some delay, then
  * send new GET_TABINFOREQ to master.
@@ -10087,85 +10124,66 @@ void Dbdict::execGET_TABINFOREQ(Signal* signal)
  }
 
  GetTabInfoReq * const req = (GetTabInfoReq *)&signal->theData[0];
- SectionHandle handle(this, signal);
 
- /**
- * If I get a GET_TABINFO_REQ from myself
- * it's is a one from the time queue
- */
- bool fromTimeQueue = (signal->senderBlockRef() == reference());
-
- if (ERROR_INSERTED(6215) && fromTimeQueue == false)
+ if (ERROR_INSERTED(6215) &&
+ (signal->senderBlockRef() != reference()))
  {
  jam();
  // API tries 100 times and (80/100)^100 is quite small..
  if (rand() % 100 >= 20)
  {
  jam();
+ SectionHandle handle(this, signal);
  releaseSections(handle);
  sendGET_TABINFOREF(signal, req, GetTabInfoRef::Busy, __LINE__);
  return;
  }
  // no CLEAR_ERROR_INSERT_VALUE
  }
 
- if (c_retrieveRecord.busyState && fromTimeQueue == true) {
- jam();
-
- sendSignalWithDelay(reference(), GSN_GET_TABINFOREQ, signal, 30,
-signal->length(),
-&handle);
+ const bool testRef = (ERROR_INSERTED(6026) &&
+ refToMain(signal->senderBlockRef()) == DBDICT &&
+ (signal->senderBlockRef() != reference()));
+ if (testRef)
+ {
+ ndbout_c("DICT : ERROR_INSERT(6026) simulating old internal "
+ "GET_TABINFOREF");
+ CLEAR_ERROR_INSERT_VALUE;
+ SectionHandle handle(this, signal);
+ releaseSections(handle);
+ sendGET_TABINFOREF(signal, req, GetTabInfoRef::Busy, __LINE__);
  return;
- }//if
-
- const Uint32 MAX_WAITERS = (MAX_NDB_NODES*3)/2;
+ }
 
- // Test sending GET_TABINFOREF to DICT (Bug#14647210).
- const bool testRef = refToMain(signal->senderBlockRef()) == DBDICT &&
- ERROR_INSERTED_CLEAR(6026);
- 
- if ((c_retrieveRecord.busyState || testRef) && fromTimeQueue == false)
+ if (c_retrieveRecord.busyState)
  {
  jam();
+ NodeInfo sendersNI = getNodeInfo(refToNode(req->senderRef));
+ bool internalReq = (sendersNI.m_type == NodeInfo::DB);
 
- const Uint32 senderVersion = 
- getNodeInfo(refToNode(signal->senderBlockRef())).m_version;
-
- /**
- * DBDICT may possibly generate large numbers of signals if many nodes
- * are started at the same time, so we do not want to queue those using
- * sendSignalWithDelay(). See also Bug#14647210. Signals from other 
- * blocks we do queue localy, since these blocks may not retry on
- * GET_TABINFOREF with error==busy, and since they also should not 
- * generate large bursts of GET_TABINFOREQ.
+ /* Queue request
+ * Will be processed later when current requests + queue are completed
  */
- if (c_retrieveRecord.noOfWaiters < MAX_WAITERS &&
- (refToMain(signal->senderBlockRef()) != DBDICT ||
- !ndbd_dict_get_tabinforef_implemented(senderVersion)))
+ if (!c_gettabinforeq_q.tryEnqReq(internalReq,
+ signal))
  {
  jam();
- c_retrieveRecord.noOfWaiters++;
+ /**
+ * Enqueue failure resulting in Busy signal only allowed for
+ * external requests
+ */
+ ndbrequire(!internalReq);
 
- sendSignalWithDelay(reference(), GSN_GET_TABINFOREQ, signal, 30,
- signal->length(),
- &handle);
- return;
- }
+ SectionHandle handle(this, signal);
+ releaseSections(handle);
 
- if (!c_retrieveRecord.busyState)
- {
- ndbout << "Sending extra TABINFOREF to node"
- << refToNode(signal->senderBlockRef()) << endl;
+ sendGET_TABINFOREF(signal, req, GetTabInfoRef::Busy, __LINE__);
  }
- releaseSections(handle);
- sendGET_TABINFOREF(signal, req, GetTabInfoRef::Busy, __LINE__);
+
  return;
  }
 
- if(fromTimeQueue){
- jam();
- c_retrieveRecord.noOfWaiters--;
- }
+ SectionHandle handle(this, signal);
 
  const bool useLongSig = (req->requestType & GetTabInfoReq::LongSignalConf);
  const bool byName = (req->requestType & GetTabInfoReq::RequestByName);
@@ -29878,3 +29896,30 @@ Dbdict::send_event(Signal* signal,
  signal->theData[4] = refToNode(trans_ptr.p->m_clientRef);
  sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 5, JBB);
 }
+
+void
+Dbdict::startNextGetTabInfoReq(Signal* signal)
+{
+ jam();
+
+ /* Retrieve record should be in busy state to block
+ * queue-jumpers. We can clear it now as we will
+ * execute direct from the head of the queue(s)
+ */
+ ndbrequire(c_retrieveRecord.busyState);
+ ndbrequire(!c_gettabinforeq_q.isEmpty());
+
+ /* Directly start next queued request
+ * Prefer internalQueue, but give externalQueue entries
+ * a proportional share to avoid starvation.
+ */
+ ndbrequire(c_gettabinforeq_q.deqReq(signal));
+
+ c_retrieveRecord.busyState = false;
+
+ /* Execute...using EXECUTE_DIRECT to get signal trace */
+ EXECUTE_DIRECT(number(),
+ GSN_GET_TABINFOREQ,
+ signal,
+ GetTabInfoReq::SignalLength);
+}