void NDBT_Context::wait_timeout(int msec){ NdbMutex_Lock(propertyMutexPtr); NdbCondition_WaitTimeout(propertyCondPtr, propertyMutexPtr, msec); NdbMutex_Unlock(propertyMutexPtr); }
void ArbitMgr::threadMain() { ArbitSignal aSignal; aSignal = theInputBuffer; threadStart(aSignal); bool stop = false; while (! stop) { NdbMutex_Lock(theInputMutex); while (! theInputFull) { NdbCondition_WaitTimeout(theInputCond, theInputMutex, theInputTimeout); threadTimeout(); } aSignal = theInputBuffer; theInputFull = false; NdbCondition_Signal(theInputCond); NdbMutex_Unlock(theInputMutex); switch (aSignal.gsn) { case GSN_ARBIT_CHOOSEREQ: threadChoose(aSignal); break; case GSN_ARBIT_STOPORD: stop = true; break; } } threadStop(aSignal); }
inline void NdbWaiter::wait(int waitTime) { assert(!m_poll_owner); NdbCondition_WaitTimeout(m_condition, m_mutex, waitTime); }
Ndb* NdbPool::wait_free_ndb(Uint32 &id) { int res; int time_out = 3500; do { NdbCondition* tmp = input_pool_cond; m_waiting++; m_input_queue++; time_out -= 500; res = NdbCondition_WaitTimeout(input_pool_cond, pool_mutex, time_out); if (tmp == input_pool_cond) { m_input_queue--; } else { m_output_queue--; if (m_output_queue == 0) { switch_condition_queue(); } } m_waiting--; } while (res == 0 && m_first_wait == NULL_POOL); if (res != 0 && m_first_wait == NULL_POOL) { return NULL; } id = m_first_wait; remove_wait_list(); assert(m_waiting != 0 || m_first_wait == NULL_POOL); return m_pool_reference[id].ndb_reference; }
NdbTableImpl * GlobalDictCache::get(const char * name, int *error) { DBUG_ENTER("GlobalDictCache::get"); DBUG_PRINT("enter", ("name: %s", name)); const Uint32 len = strlen(name); Vector<TableVersion> * versions = 0; versions = m_tableHash.getData(name, len); if(versions == 0){ versions = new Vector<TableVersion>(2); if (versions == NULL) { *error = -1; DBUG_RETURN(0); } m_tableHash.insertKey(name, len, 0, versions); } int waitTime = 100; bool retreive = false; while(versions->size() > 0 && !retreive){ TableVersion * ver = & versions->back(); switch(ver->m_status){ case OK: ver->m_refCount++; DBUG_RETURN(ver->m_impl); case DROPPED: retreive = true; // Break loop break; case RETREIVING: NdbCondition_WaitTimeout(m_waitForTableCondition, m_mutex, waitTime); continue; } } /** * Create new... */ TableVersion tmp; tmp.m_version = 0; tmp.m_impl = 0; tmp.m_status = RETREIVING; tmp.m_refCount = 1; // The one retreiving it if (versions->push_back(tmp)) { *error = -1; DBUG_RETURN(0); } DBUG_RETURN(0); }
void ClusterMgr::startThread() { Guard g(clusterMgrThreadMutex); theStop = -1; theClusterMgrThread = NdbThread_Create(runClusterMgr_C, (void**)this, 0, // default stack size "ndb_clustermgr", NDB_THREAD_PRIO_HIGH); Uint32 cnt = 0; while (theStop == -1 && cnt < 60) { NdbCondition_WaitTimeout(waitForHBCond, clusterMgrThreadMutex, 1000); } assert(theStop == 0); }
NdbApiSignal * SignalQueue::waitFor(int gsn, NodeId nodeid, Uint32 timeout) { Guard g(m_mutex); if(m_signalQueueHead == NULL) NdbCondition_WaitTimeout(m_cond, m_mutex, timeout); if(m_signalQueueHead == NULL) return NULL; if(gsn != 0 && m_signalQueueHead->signal->readSignalNumber() != gsn) return NULL; if(nodeid != 0 && refToNode(m_signalQueueHead->signal->theSendersBlockRef) != nodeid) return NULL; return pop(); }
void CPCD::Monitor::run() { while(1) { NdbMutex_Lock(m_changeMutex); NdbCondition_WaitTimeout(m_changeCondition, m_changeMutex, m_pollingInterval * 1000); MutexVector<CPCD::Process *> &proc = *m_cpcd->getProcessList(); proc.lock(); for(size_t i = 0; i < proc.size(); i++) { proc[i]->monitor(); } proc.unlock(); NdbMutex_Unlock(m_changeMutex); } }
void ClusterMgr::startThread() { /** * We use the clusterMgrThreadMutex as a signalling object between this * thread and the main thread of the ClusterMgr. * The clusterMgrThreadMutex also protects the theStop-variable. */ Guard g(clusterMgrThreadMutex); theStop = -1; theClusterMgrThread = NdbThread_Create(runClusterMgr_C, (void**)this, 0, // default stack size "ndb_clustermgr", NDB_THREAD_PRIO_HIGH); Uint32 cnt = 0; while (theStop == -1 && cnt < 60) { NdbCondition_WaitTimeout(waitForHBCond, clusterMgrThreadMutex, 1000); } assert(theStop == 0); }
void ArbitMgr::sendSignalToThread(ArbitSignal& aSignal) { #ifdef DEBUG_ARBIT char buf[17] = ""; ndbout << "arbit recv: "; ndbout << " gsn=" << aSignal.gsn; ndbout << " send=" << aSignal.data.sender; ndbout << " code=" << aSignal.data.code; ndbout << " node=" << aSignal.data.node; ndbout << " ticket=" << aSignal.data.ticket.getText(buf, sizeof(buf)); ndbout << " mask=" << aSignal.data.mask.getText(buf, sizeof(buf)); ndbout << endl; #endif aSignal.setTimestamp(); // signal arrival time NdbMutex_Lock(theInputMutex); while (theInputFull) { NdbCondition_WaitTimeout(theInputCond, theInputMutex, 1000); } theInputBuffer = aSignal; theInputFull = true; NdbCondition_Signal(theInputCond); NdbMutex_Unlock(theInputMutex); }
void ClusterMgr::forceHB() { theFacade.lock_mutex(); if(waitingForHB) { NdbCondition_WaitTimeout(waitForHBCond, theFacade.theMutexPtr, 1000); theFacade.unlock_mutex(); return; } waitingForHB= true; NodeBitmask ndb_nodes; ndb_nodes.clear(); waitForHBFromNodes.clear(); for(Uint32 i = 0; i < MAX_NODES; i++) { if(!theNodes[i].defined) continue; if(theNodes[i].m_info.m_type == NodeInfo::DB) { ndb_nodes.set(i); const ClusterMgr::Node &node= getNodeInfo(i); waitForHBFromNodes.bitOR(node.m_state.m_connected_nodes); } } waitForHBFromNodes.bitAND(ndb_nodes); #ifdef DEBUG_REG char buf[128]; ndbout << "Waiting for HB from " << waitForHBFromNodes.getText(buf) << endl; #endif NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId())); signal.theVerId_signalNumber = GSN_API_REGREQ; signal.theReceiversBlockNumber = QMGR; signal.theTrace = 0; signal.theLength = ApiRegReq::SignalLength; ApiRegReq * req = CAST_PTR(ApiRegReq, signal.getDataPtrSend()); req->ref = numberToRef(API_CLUSTERMGR, theFacade.ownId()); req->version = NDB_VERSION; int nodeId= 0; for(int i=0; (int) NodeBitmask::NotFound != (nodeId= waitForHBFromNodes.find(i)); i= nodeId+1) { #ifdef DEBUG_REG ndbout << "FORCE HB to " << nodeId << endl; #endif theFacade.sendSignalUnCond(&signal, nodeId); } /* Wait for nodes to reply - if any heartbeats was sent */ if (!waitForHBFromNodes.isclear()) NdbCondition_WaitTimeout(waitForHBCond, theFacade.theMutexPtr, 1000); waitingForHB= false; #ifdef DEBUG_REG ndbout << "Still waiting for HB from " << waitForHBFromNodes.getText(buf) << endl; #endif theFacade.unlock_mutex(); }