void
EmulatorData::create(){
/*
Global jam() buffer, for non-multithreaded operation.
For multithreaded ndbd, each thread will set a local jam buffer later.
*/
#ifndef NO_EMULATED_JAM
void * jamBuffer = (void *)&theEmulatedJamBuffer;
#else
void * jamBuffer = 0;
#endif
NdbThread_SetTlsKey(NDB_THREAD_TLS_JAM, jamBuffer);
NdbMem_Create();
theConfiguration = new Configuration();
theWatchDog = new WatchDog();
theThreadConfig = new ThreadConfig();
theSimBlockList = new SimBlockList();
m_socket_server = new SocketServer();
m_mem_manager = new Ndbd_mem_manager();
globalData.m_global_page_pool.setMutex();
if (theConfiguration == NULL ||
theWatchDog == NULL ||
theThreadConfig == NULL ||
theSimBlockList == NULL ||
m_socket_server == NULL ||
m_mem_manager == NULL )
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"Failed to create EmulatorData", "");
}
if (!(theShutdownMutex = NdbMutex_Create()))
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"Failed to create shutdown mutex", "");
}
}
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
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();
}
}
void
ndb_mutex_thread_init(struct ndb_mutex_thr_state* p)
{
bzero(p, sizeof(* p));
NdbThread_SetTlsKey(NDB_THREAD_TLS_SELF, p);
}