void
AsyncFile::doStart()
{
// Stacksize for filesystem threads
#if !defined(DBUG_OFF) && defined (__hpux)
// Empirical evidence indicates at least 32k
const NDB_THREAD_STACKSIZE stackSize = 32768;
#else
// Otherwise an 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
#endif
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
if (theThreadPtr == 0)
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC, "","Could not allocate file system thread");
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
void
AsyncFile::doStart(Uint32 nodeId,
const char * filesystemPath,
const char * backup_path) {
theFileName.init(nodeId, filesystemPath, backup_path);
// Stacksize for filesystem threads
// An 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
void NDBT_TestCaseImpl1::waitSteps(){
NdbMutex_Lock(waitThreadsMutexPtr);
while(numStepsCompleted != steps.size())
NdbCondition_Wait(waitThreadsCondPtr,
waitThreadsMutexPtr);
unsigned completedSteps = 0;
unsigned i;
for(i=0; i<steps.size(); i++){
if (results[i] != NORESULT){
completedSteps++;
if (results[i] == NDBT_OK)
numStepsOk++;
else
numStepsFail++;
}
}
require(completedSteps == steps.size());
require(completedSteps == numStepsCompleted);
NdbMutex_Unlock(waitThreadsMutexPtr);
void *status;
for(i=0; i<steps.size();i++){
NdbThread_WaitFor(threads[i], &status);
NdbThread_Destroy(&threads[i]);
}
threads.clear();
}
const char* NDBT_Context::getPropertyWait(const char* _name, const char* _waitVal){
const char* val;
NdbMutex_Lock(propertyMutexPtr);
while(!props.get(_name, &val) && (strcmp(val, _waitVal)==0))
NdbCondition_Wait(propertyCondPtr,
propertyMutexPtr);
NdbMutex_Unlock(propertyMutexPtr);
return val;
}
bool NDBT_Context::getPropertyWait(const char* _name, Uint32 _waitVal){
bool result;
NdbMutex_Lock(propertyMutexPtr);
Uint32 val =! _waitVal;
while((!props.get(_name, &val) || (props.get(_name, &val) && val != _waitVal)) &&
!stopped)
NdbCondition_Wait(propertyCondPtr,
propertyMutexPtr);
result = (val == _waitVal);
NdbMutex_Unlock(propertyMutexPtr);
return stopped;
}
void
Test::wait_started()
{
NdbMutex_Lock(mutex);
if (waiting_start + 1 == cnt_threads)
{
waiting_stop = 0;
}
waiting_start++;
assert(waiting_start <= cnt_threads);
while (waiting_start < cnt_threads)
NdbCondition_Wait(cond, mutex);
NdbCondition_Broadcast(cond);
NdbMutex_Unlock(mutex);
}
void
Test::wait_completed()
{
NdbMutex_Lock(mutex);
if (waiting_stop + 1 == cnt_threads)
{
rep.validate();
waiting_start = 0;
}
waiting_stop++;
assert(waiting_stop <= cnt_threads);
while (waiting_stop < cnt_threads)
NdbCondition_Wait(cond, mutex);
NdbCondition_Broadcast(cond);
NdbMutex_Unlock(mutex);
}
struct NdbThread*
AsyncIoThread::doStart()
{
// Stacksize for filesystem threads
const NDB_THREAD_STACKSIZE stackSize = 128*1024;
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncIoThread%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncIoThread,
(void**)this,
stackSize,
buf,
NDB_THREAD_PRIO_MEAN);
if (theThreadPtr == 0)
{
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC,
"","Could not allocate file system thread");
}
do
{
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
}
while (theStartFlag == false);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
return theThreadPtr;
}
void NDBT_Context::wait(){
NdbMutex_Lock(propertyMutexPtr);
NdbCondition_Wait(propertyCondPtr,
propertyMutexPtr);
NdbMutex_Unlock(propertyMutexPtr);
}
void wait() {
NdbCondition_Wait(m_cond, m_mutex);
}