/****************************************************************************** * 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; }
/****************************************************************************** * 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; }
Logger::Logger() : m_pCategory("Logger"), m_pConsoleHandler(NULL), m_pFileHandler(NULL), m_pSyslogHandler(NULL) { m_pHandlerList = new LogHandlerList(); m_mutex= NdbMutex_Create(); m_handler_mutex= NdbMutex_Create(); disable(LL_ALL); enable(LL_ON); enable(LL_INFO); }
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); }
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; }
void ndb_init_internal() { NdbOut_Init(); if (!g_ndb_connection_mutex) g_ndb_connection_mutex = NdbMutex_Create(); if (!g_eventLogger) g_eventLogger = create_event_logger(); if ((g_ndb_connection_mutex == NULL) || (g_eventLogger == NULL)) { { const char* err = "ndb_init() failed - exit\n"; int res = write(2, err, strlen(err)); (void)res; exit(1); } } /* Always turn on monotonic unless on Solaris */ #ifndef __sun g_ndb_init_need_monotonic = 1; #endif NdbTick_Init(g_ndb_init_need_monotonic); NdbCondition_initialize(g_ndb_init_need_monotonic); NdbThread_Init(); }
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); }
WatchDog::WatchDog(Uint32 interval) : m_watchedCount(0) { setCheckInterval(interval); m_mutex = NdbMutex_Create(); theStop = false; theThreadPtr = 0; }
void VerifyBegin(void) { if(!g_pNdbMutexVerify) { g_pNdbMutexVerify = NdbMutex_Create(); } NdbMutex_Lock(g_pNdbMutexVerify); }
void TraceBegin(void) { if(!g_pNdbMutexTrace) { g_pNdbMutexTrace = NdbMutex_Create(); } NdbMutex_Lock(g_pNdbMutexTrace); g_nParamTrace = 0; }
Ndb_cluster_connection_impl::Ndb_cluster_connection_impl(const char * connect_string) : Ndb_cluster_connection(*this), m_optimized_node_selection(1), m_name(0) { DBUG_ENTER("Ndb_cluster_connection"); DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this)); g_eventLogger.createConsoleHandler(); g_eventLogger.setCategory("NdbApi"); g_eventLogger.enable(Logger::LL_ON, Logger::LL_ERROR); m_connect_thread= 0; m_connect_callback= 0; if (ndb_global_event_buffer_mutex == NULL) ndb_global_event_buffer_mutex= NdbMutex_Create(); #ifdef VM_TRACE if (ndb_print_state_mutex == NULL) ndb_print_state_mutex= NdbMutex_Create(); #endif m_config_retriever= new ConfigRetriever(connect_string, NDB_VERSION, NODE_TYPE_API); if (m_config_retriever->hasError()) { printf("Could not connect initialize handle to management server: %s", m_config_retriever->getErrorString()); delete m_config_retriever; m_config_retriever= 0; } if (m_name) { NdbMgmHandle h= m_config_retriever->get_mgmHandle(); ndb_mgm_set_name(h, m_name); } m_transporter_facade= TransporterFacade::theFacadeInstance= new TransporterFacade(); DBUG_VOID_RETURN; }
bool NdbPool::initPoolMutex() { bool ret_result = false; if (pool_mutex == NULL) { pool_mutex = NdbMutex_Create(); ret_result = ((pool_mutex == NULL) ? false : true); } return ret_result; }
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(); }
MultiNdbWakeupHandler::MultiNdbWakeupHandler(Ndb* _wakeNdb) : wakeNdb(_wakeNdb) { localWakeupMutexPtr = NdbMutex_Create(); assert(localWakeupMutexPtr); /* Register the waiter Ndb to receive wakeups for all Ndbs in the group */ PollGuard pg(* wakeNdb->theImpl); woken = false; ignore_wakeups(); bool rc = wakeNdb->theImpl->m_transporter_facade->registerForWakeup(wakeNdb->theImpl); require(rc); wakeNdb->theImpl->wakeHandler = this; }
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(); }
MgmApiSession::MgmApiSession(class MgmtSrvr & mgm, NDB_SOCKET_TYPE sock, Uint64 session_id) : SocketServer::Session(sock), m_mgmsrv(mgm) { DBUG_ENTER("MgmApiSession::MgmApiSession"); m_input = new SocketInputStream(sock, 30000); m_output = new SocketOutputStream(sock, 30000); m_parser = new Parser_t(commands, *m_input, true, true, true); m_allocated_resources= new MgmtSrvr::Allocated_resources(m_mgmsrv); m_stopSelf= 0; m_ctx= NULL; m_session_id= session_id; m_mutex= NdbMutex_Create(); m_errorInsert= 0; DBUG_VOID_RETURN; }
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 NdbCondition* NdbCondition_Create(void) { int result = 0; struct NdbCondition* pNdbCondition = (struct NdbCondition*)malloc(sizeof(struct NdbCondition)); if(!pNdbCondition) return 0; pNdbCondition->nWaiters = 0; pNdbCondition->bWasBroadcast = 0; if(!(pNdbCondition->hSemaphore = CreateSemaphore(0, 0, MAXLONG, 0))) result = -1; else if(!(pNdbCondition->pNdbMutexWaitersLock = NdbMutex_Create())) result = -1; else if(!(pNdbCondition->hEventWaitersDone = CreateEvent(0, 0, 0, 0))) result = -1; assert(!result); return pNdbCondition; }
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 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 init() { mutex = NdbMutex_Create(); cond = NdbCondition_Create(); }
SignalQueue::SignalQueue() { m_mutex = NdbMutex_Create(); m_cond = NdbCondition_Create(); m_signalQueueHead = NULL; }
int main(int argc, char* argv[]) { ndb_init(); int iRes = -1; g_nNumThreads = 0; g_nMaxCallsPerSecond = 0; long nSeed = 0; bool bStoredTable = true; bool bCreateTable = false; g_bWriteTuple = false; g_bReport = false; g_bReportPlus = false; for(int i=1; i<argc; ++i) { if(argv[i][0]=='-' || argv[i][0]=='/') { switch(argv[i][1]) { case 't': g_nNumThreads = atol(argv[i]+2); break; case 's': nSeed = atol(argv[i]+2); break; case 'b': g_nMaxContextIdPerThread = atol(argv[i]+2); break; case 'm': g_nStatusDataSize = atol(argv[i]+2); if(g_nStatusDataSize>sizeof(STATUS_DATA)) { g_nStatusDataSize = sizeof(STATUS_DATA); } break; case 'i': g_bInsertInitial = true; break; case 'v': g_bVerifyInitial = true; break; case 'd': bCreateTable = true; break; case 'f': bStoredTable = false; break; case 'w': g_bWriteTuple = true; break; case 'r': g_bReport = true; if(argv[i][2]=='+') { g_bReportPlus = true; } break; case 'c': g_nMaxCallsPerSecond = atol(argv[i]+2); break; case '?': default: ShowHelp(argv[0]); return -1; } } else { ShowHelp(argv[0]); return -1; } } if(bCreateTable) puts("-d\tcreate the table"); if(g_bInsertInitial) printf("-i\tinsert initial records\n"); if(g_bVerifyInitial) printf("-v\tverify initial records\n"); if(g_nNumThreads>0) printf("-t%ld\tnumber of threads making calls\n", g_nNumThreads); if(g_nNumThreads>0) { printf("-s%ld\toffset for primary key\n", nSeed); printf("-b%ld\tbatch size per thread\n", g_nMaxContextIdPerThread); } if(g_nMaxCallsPerSecond>0) printf("-c%ld\tmax number of calls per second for this process\n", g_nMaxCallsPerSecond); if(!bStoredTable) puts("-f\tno checkpointing and no logging to disk"); if(g_bWriteTuple) puts("-w\tuse writeTuple instead of insertTuple"); if(g_bReport) puts("-r\treport response time statistics"); if(g_bReportPlus) puts("-r+\treport response time distribution"); if(!bCreateTable && g_nNumThreads<=0) { ShowHelp(argv[0]); return -1; } printf("-m%ld\tsize of context data\n", g_nStatusDataSize); g_szTableName = (bStoredTable ? c_szTableNameStored : c_szTableNameTemp); #ifdef NDB_WIN32 SetConsoleCtrlHandler(ConsoleCtrlHandler, true); #else signal(SIGINT, CtrlCHandler); #endif if(g_bReport) { g_plCountMillisecForCall = new long[c_nMaxMillisecForAllCall]; memset(g_plCountMillisecForCall, 0, c_nMaxMillisecForAllCall*sizeof(long)); g_plCountMillisecForTrans = new long[c_nMaxMillisecForAllTrans]; memset(g_plCountMillisecForTrans, 0, c_nMaxMillisecForAllTrans*sizeof(long)); } g_pNdbMutexIncrement = NdbMutex_Create(); g_pNdbMutexPrintf = NdbMutex_Create(); #ifdef NDB_WIN32 hShutdownEvent = CreateEvent(NULL,TRUE,FALSE,NULL); #endif Ndb* pNdb = new Ndb(c_szDatabaseName); if(!pNdb) { printf("could not construct ndb\n"); return 1; } if(pNdb->init(1) || pNdb->waitUntilReady()) { ReportNdbError("could not initialize ndb\n", pNdb->getNdbError()); delete pNdb; return 2; } if(bCreateTable) { printf("Create CallContext table\n"); if (bStoredTable) { if (CreateCallContextTable(pNdb, c_szTableNameStored, true)) { printf("Create table failed\n"); delete pNdb; return 3; } } else { if (CreateCallContextTable(pNdb, c_szTableNameTemp, false)) { printf("Create table failed\n"); delete pNdb; return 3; } } } if(g_nNumThreads>0) { printf("creating %d threads\n", (int)g_nNumThreads); if(g_bInsertInitial) { printf("each thread will insert %ld initial records, total %ld inserts\n", g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread); } if(g_bVerifyInitial) { printf("each thread will verify %ld initial records, total %ld reads\n", g_nMaxContextIdPerThread, g_nNumThreads*g_nMaxContextIdPerThread); } g_nNumberOfInitialInsert = 0; g_nNumberOfInitialVerify = 0; NDB_TICKS tStartTime = NdbTick_CurrentMillisecond(); NdbThread* pThreads[256]; int pnStartingRecordNum[256]; int ij; for(ij=0;ij<g_nNumThreads;ij++) { pnStartingRecordNum[ij] = (ij*g_nMaxContextIdPerThread) + nSeed; } for(ij=0;ij<g_nNumThreads;ij++) { pThreads[ij] = NdbThread_Create(RuntimeCallContext, (void**)(pnStartingRecordNum+ij), 0, "RuntimeCallContext", NDB_THREAD_PRIO_LOW); } //Wait for the threads to finish for(ij=0;ij<g_nNumThreads;ij++) { void* status; NdbThread_WaitFor(pThreads[ij], &status); } NDB_TICKS tEndTime = NdbTick_CurrentMillisecond(); //Print time taken printf("Time Taken for %ld Calls is %ld msec (= %ld calls/sec)\n", g_nNumCallsProcessed, (long)(tEndTime-tStartTime), (long)((1000*g_nNumCallsProcessed)/(tEndTime-tStartTime))); if(g_bInsertInitial) printf("successfully inserted %ld tuples\n", g_nNumberOfInitialInsert); if(g_bVerifyInitial) printf("successfully verified %ld tuples\n", g_nNumberOfInitialVerify); } delete pNdb; #ifdef NDB_WIN32 CloseHandle(hShutdownEvent); #endif NdbMutex_Destroy(g_pNdbMutexIncrement); NdbMutex_Destroy(g_pNdbMutexPrintf); if(g_bReport) { ReportResponseTimeStatistics("Calls", g_plCountMillisecForCall, c_nMaxMillisecForAllCall); ReportResponseTimeStatistics("Transactions", g_plCountMillisecForTrans, c_nMaxMillisecForAllTrans); delete[] g_plCountMillisecForCall; delete[] g_plCountMillisecForTrans; } return 0; }
void ndb_init_internal() { if (!g_ndb_connection_mutex) g_ndb_connection_mutex = NdbMutex_Create(); }
Ndb_cluster_connection_impl::Ndb_cluster_connection_impl(const char * connect_string) : Ndb_cluster_connection(*this), m_optimized_node_selection(1), m_name(0), m_run_connect_thread(0), m_event_add_drop_mutex(0), m_latest_trans_gci(0) { DBUG_ENTER("Ndb_cluster_connection"); DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this)); if (!m_event_add_drop_mutex) m_event_add_drop_mutex= NdbMutex_Create(); g_eventLogger.createConsoleHandler(); g_eventLogger.setCategory("NdbApi"); g_eventLogger.enable(Logger::LL_ON, Logger::LL_ERROR); m_connect_thread= 0; m_connect_callback= 0; #ifdef VM_TRACE if (ndb_print_state_mutex == NULL) ndb_print_state_mutex= NdbMutex_Create(); #endif m_config_retriever= new ConfigRetriever(connect_string, NDB_VERSION, NODE_TYPE_API); if (m_config_retriever->hasError()) { printf("Could not initialize handle to management server: %s\n", m_config_retriever->getErrorString()); delete m_config_retriever; m_config_retriever= 0; } if (m_name) { NdbMgmHandle h= m_config_retriever->get_mgmHandle(); ndb_mgm_set_name(h, m_name); } m_transporter_facade= new TransporterFacade(); NdbMutex_Lock(g_ndb_connection_mutex); if(g_ndb_connection_count++ == 0){ NdbDictionary::Column::FRAGMENT= NdbColumnImpl::create_pseudo("NDB$FRAGMENT"); NdbDictionary::Column::FRAGMENT_FIXED_MEMORY= NdbColumnImpl::create_pseudo("NDB$FRAGMENT_FIXED_MEMORY"); NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY= NdbColumnImpl::create_pseudo("NDB$FRAGMENT_VARSIZED_MEMORY"); NdbDictionary::Column::ROW_COUNT= NdbColumnImpl::create_pseudo("NDB$ROW_COUNT"); NdbDictionary::Column::COMMIT_COUNT= NdbColumnImpl::create_pseudo("NDB$COMMIT_COUNT"); NdbDictionary::Column::ROW_SIZE= NdbColumnImpl::create_pseudo("NDB$ROW_SIZE"); NdbDictionary::Column::RANGE_NO= NdbColumnImpl::create_pseudo("NDB$RANGE_NO"); NdbDictionary::Column::DISK_REF= NdbColumnImpl::create_pseudo("NDB$DISK_REF"); NdbDictionary::Column::RECORDS_IN_RANGE= NdbColumnImpl::create_pseudo("NDB$RECORDS_IN_RANGE"); NdbDictionary::Column::ROWID= NdbColumnImpl::create_pseudo("NDB$ROWID"); NdbDictionary::Column::ROW_GCI= NdbColumnImpl::create_pseudo("NDB$ROW_GCI"); NdbDictionary::Column::ANY_VALUE= NdbColumnImpl::create_pseudo("NDB$ANY_VALUE"); NdbDictionary::Column::COPY_ROWID= NdbColumnImpl::create_pseudo("NDB$COPY_ROWID"); } NdbMutex_Unlock(g_ndb_connection_mutex); DBUG_VOID_RETURN; }
***************************************************************/ /*************************************************************** * L O C A L D A T A S T R U C T U R E S * ***************************************************************/ /*************************************************************** * L O C A L F U N C T I O N S * ***************************************************************/ #ifndef NDB_WIN32 #include <unistd.h> #endif static NdbMutex* startupMutex = NdbMutex_Create(); Ndb* asyncDbConnect(int parallellism){ NdbMutex_Lock(startupMutex); Ndb * pNDB = new Ndb(""); pNDB->init(parallellism + 1); while(pNDB->waitUntilReady() != 0){ } NdbMutex_Unlock(startupMutex); return pNDB; }
Ndb_cluster_connection_impl:: Ndb_cluster_connection_impl(const char * connect_string, Ndb_cluster_connection *main_connection, int force_api_nodeid) : Ndb_cluster_connection(*this), m_main_connection(main_connection), m_optimized_node_selection(1), m_run_connect_thread(0), m_latest_trans_gci(0), m_first_ndb_object(0), m_latest_error_msg(), m_latest_error(0), m_max_trans_id(0), m_multi_wait_group(0) { DBUG_ENTER("Ndb_cluster_connection"); DBUG_PRINT("enter",("Ndb_cluster_connection this=0x%lx", (long) this)); NdbMutex_Lock(g_ndb_connection_mutex); if(g_ndb_connection_count++ == 0) { NdbColumnImpl::create_pseudo_columns(); g_eventLogger->createConsoleHandler(); g_eventLogger->setCategory("NdbApi"); g_eventLogger->enable(Logger::LL_ON, Logger::LL_ERROR); /* Disable repeated message handling as it interfers with mysqld logging, in which case messages come out of order. Same applies for regular ndbapi user. */ g_eventLogger->setRepeatFrequency(0); #ifdef VM_TRACE ndb_print_state_mutex= NdbMutex_Create(); #endif } NdbMutex_Unlock(g_ndb_connection_mutex); m_event_add_drop_mutex= NdbMutex_Create(); m_new_delete_ndb_mutex = NdbMutex_Create(); m_connect_thread= 0; m_connect_callback= 0; /* Clear global stats baseline */ memset(globalApiStatsBaseline, 0, sizeof(globalApiStatsBaseline)); m_config_retriever= new ConfigRetriever(connect_string, force_api_nodeid, NDB_VERSION, NDB_MGM_NODE_TYPE_API); if (m_config_retriever->hasError()) { m_latest_error= 1; m_latest_error_msg.assfmt ("Could not initialize handle to management server: %s", m_config_retriever->getErrorString()); printf("%s\n", get_latest_error_msg()); } if (!m_main_connection) { m_globalDictCache = new GlobalDictCache; m_transporter_facade= new TransporterFacade(m_globalDictCache); } else { assert(m_main_connection->m_impl.m_globalDictCache != NULL); m_globalDictCache = 0; m_transporter_facade= new TransporterFacade(m_main_connection->m_impl.m_globalDictCache); // The secondary connection can't use same nodeid, clear the nodeid // in ConfigRetriver to avoid asking for the same nodeid again m_config_retriever->setNodeId(0); } DBUG_VOID_RETURN; }