bool
NdbPool::init(Uint32 init_no_objects)
{
bool ret_result = false;
int i;
do {
input_pool_cond = NdbCondition_Create();
output_pool_cond = NdbCondition_Create();
if (input_pool_cond == NULL || output_pool_cond == NULL) {
break;
}
if (init_no_objects > m_max_ndb_objects) {
init_no_objects = m_max_ndb_objects;
}
if (init_no_objects == 0) {
init_no_objects = 1;
}
m_pool_reference = new NdbPool::POOL_STRUCT[m_max_ndb_objects + 1];
m_hash_entry = new Uint8[POOL_HASH_TABLE_SIZE];
if ((m_pool_reference == NULL) || (m_hash_entry == NULL)) {
delete [] m_pool_reference;
delete [] m_hash_entry;
break;
}
for (i = 0; i < m_max_ndb_objects + 1; i++) {
m_pool_reference[i].ndb_reference = NULL;
m_pool_reference[i].in_use = false;
m_pool_reference[i].next_free_object = i+1;
m_pool_reference[i].prev_free_object = i-1;
m_pool_reference[i].next_db_object = NULL_POOL;
m_pool_reference[i].prev_db_object = NULL_POOL;
}
for (i = 0; i < POOL_HASH_TABLE_SIZE; i++) {
m_hash_entry[i] = NULL_HASH;
}
m_pool_reference[m_max_ndb_objects].next_free_object = NULL_POOL;
m_pool_reference[1].prev_free_object = NULL_POOL;
m_first_not_in_use = 1;
m_no_of_objects = init_no_objects;
for (i = init_no_objects; i > 0 ; i--) {
Uint32 fake_id;
if (!allocate_ndb(fake_id, (const char*)NULL, (const char*)NULL)) {
release_all();
break;
}
}
ret_result = true;
break;
} while (1);
return ret_result;
}
/******************************************************************************
* Arbitrator
******************************************************************************/
ArbitMgr::ArbitMgr(ClusterMgr & c)
: m_clusterMgr(c)
{
DBUG_ENTER("ArbitMgr::ArbitMgr");
theThreadMutex = NdbMutex_Create();
theInputCond = NdbCondition_Create();
theInputMutex = NdbMutex_Create();
theRank = 0;
theDelay = 0;
theThread = 0;
theInputTimeout = 0;
theInputFull = false;
memset(&theInputBuffer, 0, sizeof(theInputBuffer));
theState = StateInit;
memset(&theStartReq, 0, sizeof(theStartReq));
memset(&theChooseReq1, 0, sizeof(theChooseReq1));
memset(&theChooseReq2, 0, sizeof(theChooseReq2));
memset(&theStopOrd, 0, sizeof(theStopOrd));
DBUG_VOID_RETURN;
}
ClusterMgr::ClusterMgr(TransporterFacade & _facade):
theStop(0),
m_sent_API_REGREQ_to_myself(false),
theFacade(_facade),
theArbitMgr(NULL),
m_connect_count(0),
m_max_api_reg_req_interval(~0),
noOfAliveNodes(0),
noOfConnectedNodes(0),
noOfConnectedDBNodes(0),
minDbVersion(0),
theClusterMgrThread(NULL),
m_cluster_state(CS_waiting_for_clean_cache),
m_hbFrequency(0)
{
DBUG_ENTER("ClusterMgr::ClusterMgr");
clusterMgrThreadMutex = NdbMutex_Create();
waitForHBCond= NdbCondition_Create();
m_auto_reconnect = -1;
Uint32 ret = this->open(&theFacade, API_CLUSTERMGR);
if (unlikely(ret == 0))
{
ndbout_c("Failed to register ClusterMgr! ret: %d", ret);
abort();
}
DBUG_VOID_RETURN;
}
/******************************************************************************
* Arbitrator
******************************************************************************/
ArbitMgr::ArbitMgr(TransporterFacade & _fac)
: theFacade(_fac)
{
DBUG_ENTER("ArbitMgr::ArbitMgr");
theThreadMutex = NdbMutex_Create();
theInputCond = NdbCondition_Create();
theInputMutex = NdbMutex_Create();
theRank = 0;
theDelay = 0;
theThread = 0;
theInputTimeout = 0;
theInputFull = false;
memset(&theInputFull, 0, sizeof(theInputFull));
theState = StateInit;
memset(&theStartReq, 0, sizeof(theStartReq));
memset(&theChooseReq1, 0, sizeof(theChooseReq1));
memset(&theChooseReq2, 0, sizeof(theChooseReq2));
memset(&theStopOrd, 0, sizeof(theStopOrd));
DBUG_VOID_RETURN;
}
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
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
NDBT_Thread::create(NDBT_ThreadSet* thread_set, int thread_no)
{
m_magic = NDBT_Thread::Magic;
m_state = Wait;
m_thread_set = thread_set;
m_thread_no = thread_no;
m_func = 0;
m_input = 0;
m_output = 0;
m_ndb = 0;
m_err = 0;
m_mutex = NdbMutex_Create();
assert(m_mutex != 0);
m_cond = NdbCondition_Create();
assert(m_cond != 0);
char buf[20];
sprintf(buf, "NDBT_%04u");
const char* name = strdup(buf);
assert(name != 0);
unsigned stacksize = 512 * 1024;
NDB_THREAD_PRIO prio = NDB_THREAD_PRIO_LOW;
m_thread = NdbThread_Create(NDBT_Thread_run,
(void**)this, stacksize, name, prio);
assert(m_thread != 0);
}
NdbWaiter::NdbWaiter() {
m_node = 0;
m_state = NO_WAIT;
m_mutex = 0;
m_poll_owner= false;
m_cond_wait_index= TransporterFacade::MAX_NO_THREADS;
m_condition = NdbCondition_Create();
}
trp_client::trp_client()
: m_blockNo(~Uint32(0)), m_facade(0)
{
m_poll.m_waiting = false;
m_poll.m_locked = false;
m_poll.m_poll_owner = false;
m_poll.m_next = 0;
m_poll.m_prev = 0;
m_poll.m_condition = NdbCondition_Create();
}
NDBT_TestCaseImpl1::NDBT_TestCaseImpl1(NDBT_TestSuite* psuite,
const char* pname,
const char* pcomment) :
NDBT_TestCase(psuite, pname, pcomment){
numStepsOk = 0;
numStepsFail = 0;
numStepsCompleted = 0;
waitThreadsMutexPtr = NdbMutex_Create();
waitThreadsCondPtr = NdbCondition_Create();
}
CPCD::Monitor::Monitor(CPCD *cpcd, int poll) {
m_cpcd = cpcd;
m_pollingInterval = poll;
m_changeCondition = NdbCondition_Create();
m_changeMutex = NdbMutex_Create();
m_monitorThread = NdbThread_Create(monitor_thread_create_wrapper,
(NDB_THREAD_ARG*) this,
0, // default stack size
"ndb_cpcd_monitor",
NDB_THREAD_PRIO_MEAN);
m_monitorThreadQuitFlag = false;
}
NDBT_Context::NDBT_Context(Ndb_cluster_connection& con)
: m_cluster_connection(con)
{
suite = NULL;
testcase = NULL;
ndb = NULL;
records = 1;
loops = 1;
stopped = false;
remote_mgm ="";
propertyMutexPtr = NdbMutex_Create();
propertyCondPtr = NdbCondition_Create();
}
inline
trp_client::PollQueue::PollQueue()
{
m_waiting = PQ_IDLE;
m_locked = false;
m_poll_owner = false;
m_poll_queue = false;
m_next = 0;
m_prev = 0;
m_condition = NdbCondition_Create();
m_locked_cnt = 0;
m_lock_array_size = 0;
m_locked_clients = NULL;
}
NDBT_Context::NDBT_Context(Ndb_cluster_connection& con)
: m_cluster_connection(con)
{
suite = NULL;
testcase = NULL;
ndb = NULL;
records = 1;
loops = 1;
stopped = false;
propertyMutexPtr = NdbMutex_Create();
propertyCondPtr = NdbCondition_Create();
m_env_timeout = 0;
m_test_start_time = NdbTick_CurrentMillisecond();
}
ClusterMgr::ClusterMgr(TransporterFacade & _facade):
theStop(0),
theFacade(_facade)
{
DBUG_ENTER("ClusterMgr::ClusterMgr");
ndbSetOwnVersion();
clusterMgrThreadMutex = NdbMutex_Create();
waitForHBCond= NdbCondition_Create();
waitingForHB= false;
m_max_api_reg_req_interval= 0xFFFFFFFF; // MAX_INT
noOfAliveNodes= 0;
noOfConnectedNodes= 0;
theClusterMgrThread= 0;
m_connect_count = 0;
m_cluster_state = CS_waiting_for_clean_cache;
DBUG_VOID_RETURN;
}
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;
}
SignalQueue::SignalQueue() {
m_mutex = NdbMutex_Create();
m_cond = NdbCondition_Create();
m_signalQueueHead = NULL;
}
/*****************************************************************
* Global cache
*/
GlobalDictCache::GlobalDictCache(){
DBUG_ENTER("GlobalDictCache::GlobalDictCache");
m_tableHash.createHashTable();
m_waitForTableCondition = NdbCondition_Create();
DBUG_VOID_RETURN;
}
NdbWaiter::NdbWaiter(){
m_node = 0;
m_state = NO_WAIT;
m_mutex = 0;
m_condition = NdbCondition_Create();
}
void init() {
mutex = NdbMutex_Create();
cond = NdbCondition_Create();
}
