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(); }