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 AsyncFile::run() { Request *request; // Create theMemoryChannel in the thread that will wait for it NdbMutex_Lock(theStartMutexPtr); theMemoryChannelPtr = new MemoryChannel<Request>(); theStartFlag = true; // Create write buffer for bigger writes theWriteBufferSize = WRITEBUFFERSIZE; theWriteBufferUnaligned = (char *) ndbd_malloc(theWriteBufferSize + NDB_O_DIRECT_WRITE_ALIGNMENT-1); theWriteBuffer = (char *) (((UintPtr)theWriteBufferUnaligned + NDB_O_DIRECT_WRITE_ALIGNMENT - 1) & ~(UintPtr)(NDB_O_DIRECT_WRITE_ALIGNMENT - 1)); NdbMutex_Unlock(theStartMutexPtr); NdbCondition_Signal(theStartConditionPtr); if (!theWriteBuffer) { DEBUG(ndbout_c("AsyncFile::writeReq, Failed allocating write buffer")); return; }//if while (1) { request = theMemoryChannelPtr->readChannel(); if (!request) { DEBUG(ndbout_c("Nothing read from Memory Channel in AsyncFile")); endReq(); return; }//if m_current_request= request; switch (request->action) { case Request:: open: openReq(request); break; case Request:: close: closeReq(request); break; case Request:: closeRemove: closeReq(request); removeReq(request); break; case Request:: readPartial: case Request:: read: readReq(request); break; case Request:: readv: readvReq(request); break; case Request:: write: writeReq(request); break; case Request:: writev: writevReq(request); break; case Request:: writeSync: writeReq(request); syncReq(request); break; case Request:: writevSync: writevReq(request); syncReq(request); break; case Request:: sync: syncReq(request); break; case Request:: append: appendReq(request); break; case Request:: append_synch: appendReq(request); syncReq(request); break; case Request::rmrf: rmrfReq(request, (char*)theFileName.c_str(), request->par.rmrf.own_directory); break; case Request:: end: if (theFd > 0) closeReq(request); endReq(); return; default: DEBUG(ndbout_c("Invalid Request")); abort(); break; }//switch m_last_request= request; m_current_request= 0; // No need to signal as ndbfs only uses tryRead theReportTo->writeChannelNoSignal(request); }//while }//AsyncFile::run()
void AsyncIoThread::run() { Request *request; // Create theMemoryChannel in the thread that will wait for it NdbMutex_Lock(theStartMutexPtr); theStartFlag = true; NdbMutex_Unlock(theStartMutexPtr); NdbCondition_Signal(theStartConditionPtr); EmulatedJamBuffer jamBuffer; jamBuffer.theEmulatedJamIndex = 0; // This key is needed by jamNoBlock(). NdbThread_SetTlsKey(NDB_THREAD_TLS_JAM, &jamBuffer); while (1) { request = theMemoryChannelPtr->readChannel(); if (!request || request->action == Request::end) { DEBUG(ndbout_c("Nothing read from Memory Channel in AsyncFile")); theStartFlag = false; return; }//if AsyncFile * file = request->file; m_current_request= request; switch (request->action) { case Request::open: file->openReq(request); if (request->error == 0 && request->m_do_bind) attach(file); break; case Request::close: file->closeReq(request); detach(file); break; case Request::closeRemove: file->closeReq(request); file->removeReq(request); detach(file); break; case Request::readPartial: case Request::read: file->readReq(request); break; case Request::readv: file->readvReq(request); break; case Request::write: file->writeReq(request); break; case Request::writev: file->writevReq(request); break; case Request::writeSync: file->writeReq(request); file->syncReq(request); break; case Request::writevSync: file->writevReq(request); file->syncReq(request); break; case Request::sync: file->syncReq(request); break; case Request::append: file->appendReq(request); break; case Request::append_synch: file->appendReq(request); file->syncReq(request); break; case Request::rmrf: file->rmrfReq(request, file->theFileName.c_str(), request->par.rmrf.own_directory); break; case Request::end: theStartFlag = false; return; case Request::allocmem: { allocMemReq(request); break; } case Request::buildindx: buildIndxReq(request); break; case Request::suspend: if (request->par.suspend.milliseconds) { g_eventLogger->debug("Suspend %s %u ms", file->theFileName.c_str(), request->par.suspend.milliseconds); NdbSleep_MilliSleep(request->par.suspend.milliseconds); continue; } else { g_eventLogger->debug("Suspend %s", file->theFileName.c_str()); theStartFlag = false; return; } default: DEBUG(ndbout_c("Invalid Request")); abort(); break; }//switch m_last_request = request; m_current_request = 0; // No need to signal as ndbfs only uses tryRead theReportTo->writeChannelNoSignal(request); m_fs.wakeup(); } }
void signal() { NdbCondition_Signal(m_cond); }
inline void NdbWaiter::cond_signal() { NdbCondition_Signal(m_condition); }
void CPCD::Monitor::signal() { NdbCondition_Signal(m_changeCondition); }
void AsyncIoThread::run() { bool first_flag = true; Request *request; NDB_TICKS last_yield_ticks; // Create theMemoryChannel in the thread that will wait for it NdbMutex_Lock(theStartMutexPtr); theStartFlag = true; NdbMutex_Unlock(theStartMutexPtr); NdbCondition_Signal(theStartConditionPtr); EmulatedJamBuffer jamBuffer; jamBuffer.theEmulatedJamIndex = 0; // This key is needed by jamNoBlock(). NdbThread_SetTlsKey(NDB_THREAD_TLS_JAM, &jamBuffer); while (1) { if (m_real_time) { /** * If we are running in real-time we'll simply insert a break every * so often to ensure that low-prio threads aren't blocked from the * CPU, this is especially important if we're using a compressed * file system where lots of CPU is used by this thread. */ bool yield_flag = false; const NDB_TICKS current_ticks = NdbTick_getCurrentTicks(); if (first_flag) { first_flag = false; yield_flag = true; } else { Uint64 micros_passed = NdbTick_Elapsed(last_yield_ticks, current_ticks).microSec(); if (micros_passed > 10000) { yield_flag = true; } } if (yield_flag) { if (NdbThread_yield_rt(theThreadPtr, TRUE)) { m_real_time = false; } last_yield_ticks = current_ticks; } } request = theMemoryChannelPtr->readChannel(); if (!request || request->action == Request::end) { DEBUG(ndbout_c("Nothing read from Memory Channel in AsyncFile")); theStartFlag = false; return; }//if AsyncFile * file = request->file; m_current_request= request; switch (request->action) { case Request::open: file->openReq(request); if (request->error == 0 && request->m_do_bind) attach(file); break; case Request::close: file->closeReq(request); detach(file); break; case Request::closeRemove: file->closeReq(request); file->removeReq(request); detach(file); break; case Request::readPartial: case Request::read: file->readReq(request); break; case Request::readv: file->readvReq(request); break; case Request::write: file->writeReq(request); break; case Request::writev: file->writevReq(request); break; case Request::writeSync: file->writeReq(request); file->syncReq(request); break; case Request::writevSync: file->writevReq(request); file->syncReq(request); break; case Request::sync: file->syncReq(request); break; case Request::append: file->appendReq(request); break; case Request::append_synch: file->appendReq(request); file->syncReq(request); break; case Request::rmrf: file->rmrfReq(request, file->theFileName.c_str(), request->par.rmrf.own_directory); break; case Request::end: theStartFlag = false; return; case Request::allocmem: { allocMemReq(request); break; } case Request::buildindx: buildIndxReq(request); break; case Request::suspend: if (request->par.suspend.milliseconds) { g_eventLogger->debug("Suspend %s %u ms", file->theFileName.c_str(), request->par.suspend.milliseconds); NdbSleep_MilliSleep(request->par.suspend.milliseconds); continue; } else { g_eventLogger->debug("Suspend %s", file->theFileName.c_str()); theStartFlag = false; return; } default: DEBUG(ndbout_c("Invalid Request")); abort(); break; }//switch m_last_request = request; m_current_request = 0; // No need to signal as ndbfs only uses tryRead theReportTo->writeChannelNoSignal(request); m_fs.wakeup(); } }