void
ClusterMgr::doStop( ){
DBUG_ENTER("ClusterMgr::doStop");
{
/* Ensure stop is only executed once */
Guard g(clusterMgrThreadMutex);
if(theStop == 1){
DBUG_VOID_RETURN;
}
theStop = 1;
}
void *status;
if (theClusterMgrThread) {
NdbThread_WaitFor(theClusterMgrThread, &status);
NdbThread_Destroy(&theClusterMgrThread);
}
if (theArbitMgr != NULL)
{
theArbitMgr->doStop(NULL);
}
{
/* Need protection for poll calls in close */
Guard g(clusterMgrThreadMutex);
this->close(); // disconnect from TransporterFacade
}
DBUG_VOID_RETURN;
}
void
ClusterMgr::doStop( ) {
DBUG_ENTER("ClusterMgr::doStop");
{
/* Ensure stop is only executed once */
Guard g(clusterMgrThreadMutex);
if(theStop == 1) {
DBUG_VOID_RETURN;
}
theStop = 1;
}
void *status;
if (theClusterMgrThread) {
NdbThread_WaitFor(theClusterMgrThread, &status);
NdbThread_Destroy(&theClusterMgrThread);
}
if (theArbitMgr != NULL)
{
theArbitMgr->doStop(NULL);
}
{
/**
* Need protection against concurrent execution of do_poll in main
* thread. We cannot rely only on the trp_client lock since it is
* not supposed to be locked when calling close (it is locked as
* part of the close logic.
*/
Guard g(clusterMgrThreadMutex);
this->close(); // disconnect from TransporterFacade
}
DBUG_VOID_RETURN;
}
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();
}
void
WatchDog::doStop(){
void *status;
theStop = true;
if(theThreadPtr){
NdbThread_WaitFor(theThreadPtr, &status);
NdbThread_Destroy(&theThreadPtr);
}
}
AsyncFile::~AsyncFile()
{
void *status;
Request request;
request.action = Request::end;
theMemoryChannelPtr->writeChannel( &request );
NdbThread_WaitFor(theThreadPtr, &status);
NdbThread_Destroy(&theThreadPtr);
delete theMemoryChannelPtr;
}
void
AsyncIoThread::shutdown()
{
void *status;
Request request;
request.action = Request::end;
this->theMemoryChannelPtr->writeChannel( &request );
NdbThread_WaitFor(theThreadPtr, &status);
NdbThread_Destroy(&theThreadPtr);
}
bool
TransporterRegistry::stop_clients()
{
if (m_start_clients_thread) {
m_run_start_clients_thread= false;
void* status;
NdbThread_WaitFor(m_start_clients_thread, &status);
NdbThread_Destroy(&m_start_clients_thread);
}
return true;
}
void
SocketServer::stopServer(){
m_threadLock.lock();
if(m_thread != 0){
m_stopThread = true;
void * res;
NdbThread_WaitFor(m_thread, &res);
NdbThread_Destroy(&m_thread);
m_thread = 0;
}
m_threadLock.unlock();
}
void
ClusterMgr::doStop( ){
DBUG_ENTER("ClusterMgr::doStop");
NdbMutex_Lock(clusterMgrThreadMutex);
if(theStop){
NdbMutex_Unlock(clusterMgrThreadMutex);
DBUG_VOID_RETURN;
}
void *status;
theStop = 1;
if (theClusterMgrThread) {
NdbThread_WaitFor(theClusterMgrThread, &status);
NdbThread_Destroy(&theClusterMgrThread);
}
NdbMutex_Unlock(clusterMgrThreadMutex);
DBUG_VOID_RETURN;
}
void CNdbThreadWorker::DestroyThread()
{
LOG_NDB_FUNCTION();
assert(ETS_Closed == CNdbThreadState::GetState());
if (nullptr == m_pThread)
return;
void* threadStatus = nullptr;
if (0 != NDB_CALL_FUNCTION(NdbThread_WaitFor(m_pThread, &threadStatus)))
{
LogNdbCritical << "FAIL : NdbThread_WaitFor()" << endl;
return;
}
NDB_CALL_FUNCTION(NdbThread_Destroy(&m_pThread));
}
void
ndbd_alloc_touch_mem(void *p, size_t sz, volatile Uint32 * watchCounter)
{
struct NdbThread *thread_ptr[TOUCH_PARALLELISM];
struct AllocTouchMem touch_mem_struct[TOUCH_PARALLELISM];
Uint32 tmp = 0;
if (watchCounter == 0)
{
watchCounter = &tmp;
}
for (Uint32 i = 0; i < TOUCH_PARALLELISM; i++)
{
touch_mem_struct[i].watchCounter = watchCounter;
touch_mem_struct[i].sz = sz;
touch_mem_struct[i].p = p;
touch_mem_struct[i].index = i;
thread_ptr[i] = NULL;
if (sz > MIN_START_THREAD_SIZE)
{
thread_ptr[i] = NdbThread_Create(touch_mem,
(NDB_THREAD_ARG*)&touch_mem_struct[i],
0,
"touch_thread",
NDB_THREAD_PRIO_MEAN);
}
if (thread_ptr[i] == NULL)
{
touch_mem((void*)&touch_mem_struct[i]);
}
}
for (Uint32 i = 0; i < TOUCH_PARALLELISM; i++)
{
void *dummy_status;
if (thread_ptr[i])
{
NdbThread_WaitFor(thread_ptr[i], &dummy_status);
NdbThread_Destroy(&thread_ptr[i]);
}
}
}
void
SocketServer::checkSessionsImpl()
{
for(int i = m_sessions.size() - 1; i >= 0; i--)
{
if(m_sessions[i].m_session->m_stopped)
{
if(m_sessions[i].m_thread != 0)
{
void* ret;
NdbThread_WaitFor(m_sessions[i].m_thread, &ret);
NdbThread_Destroy(&m_sessions[i].m_thread);
}
m_sessions[i].m_session->stopSession();
delete m_sessions[i].m_session;
m_sessions.erase(i);
}
}
}
Ndb_cluster_connection_impl::~Ndb_cluster_connection_impl()
{
DBUG_ENTER("~Ndb_cluster_connection");
TransporterFacade::stop_instance();
if (m_connect_thread)
{
void *status;
g_run_connect_thread= 0;
NdbThread_WaitFor(m_connect_thread, &status);
NdbThread_Destroy(&m_connect_thread);
m_connect_thread= 0;
}
if (m_transporter_facade != 0)
{
delete m_transporter_facade;
if (m_transporter_facade != TransporterFacade::theFacadeInstance)
abort();
TransporterFacade::theFacadeInstance= 0;
}
if (m_config_retriever)
{
delete m_config_retriever;
m_config_retriever= NULL;
}
if (ndb_global_event_buffer_mutex != NULL)
{
NdbMutex_Destroy(ndb_global_event_buffer_mutex);
ndb_global_event_buffer_mutex= NULL;
}
#ifdef VM_TRACE
if (ndb_print_state_mutex != NULL)
{
NdbMutex_Destroy(ndb_print_state_mutex);
ndb_print_state_mutex= NULL;
}
#endif
if (m_name)
free(m_name);
DBUG_VOID_RETURN;
}
// Start arbitrator thread. This is kernel request.
// First stop any previous thread since it is a left-over
// which was never used and which now has wrong ticket.
void
ArbitMgr::doStart(const Uint32* theData)
{
ArbitSignal aSignal;
NdbMutex_Lock(theThreadMutex);
if (theThread != NULL) {
aSignal.init(GSN_ARBIT_STOPORD, NULL);
aSignal.data.code = StopRestart;
sendSignalToThread(aSignal);
void* value;
NdbThread_WaitFor(theThread, &value);
NdbThread_Destroy(&theThread);
theState = StateInit;
theInputFull = false;
}
aSignal.init(GSN_ARBIT_STARTREQ, theData);
sendSignalToThread(aSignal);
theThread = NdbThread_Create(
runArbitMgr_C, (void**)this, 32768, "ndb_arbitmgr",
NDB_THREAD_PRIO_HIGH);
NdbMutex_Unlock(theThreadMutex);
}
// Stop arbitrator thread via stop signal from the kernel
// or when exiting API program.
void
ArbitMgr::doStop(const Uint32* theData)
{
DBUG_ENTER("ArbitMgr::doStop");
ArbitSignal aSignal;
NdbMutex_Lock(theThreadMutex);
if (theThread != NULL) {
aSignal.init(GSN_ARBIT_STOPORD, theData);
if (theData == 0) {
aSignal.data.code = StopExit;
} else {
aSignal.data.code = StopRequest;
}
sendSignalToThread(aSignal);
void* value;
NdbThread_WaitFor(theThread, &value);
NdbThread_Destroy(&theThread);
theState = StateInit;
}
NdbMutex_Unlock(theThreadMutex);
DBUG_VOID_RETURN;
}
Ndb_cluster_connection_impl::~Ndb_cluster_connection_impl()
{
DBUG_ENTER("~Ndb_cluster_connection");
if (m_first_ndb_object != 0)
{
g_eventLogger->warning("Deleting Ndb_cluster_connection with Ndb-object"
" not deleted");
Ndb * p = m_first_ndb_object;
printf("this: %p Ndb-object(s): ", (Ndb_cluster_connection*)this);
while (p)
{
printf("%p ", p);
p = p->theImpl->m_next_ndb_object;
}
printf("\n");
fflush(stdout);
}
if (m_transporter_facade != 0)
{
m_transporter_facade->stop_instance();
}
if (m_globalDictCache)
{
delete m_globalDictCache;
}
if (m_connect_thread)
{
void *status;
m_run_connect_thread= 0;
NdbThread_WaitFor(m_connect_thread, &status);
NdbThread_Destroy(&m_connect_thread);
m_connect_thread= 0;
}
if (m_transporter_facade != 0)
{
delete m_transporter_facade;
m_transporter_facade = 0;
}
if (m_config_retriever)
{
delete m_config_retriever;
m_config_retriever= NULL;
}
NdbMutex_Lock(g_ndb_connection_mutex);
if(--g_ndb_connection_count == 0)
{
NdbColumnImpl::destory_pseudo_columns();
#ifdef VM_TRACE
NdbMutex_Destroy(ndb_print_state_mutex);
ndb_print_state_mutex= NULL;
#endif
}
NdbMutex_Unlock(g_ndb_connection_mutex);
if (m_event_add_drop_mutex)
NdbMutex_Destroy(m_event_add_drop_mutex);
m_event_add_drop_mutex = 0;
if (m_new_delete_ndb_mutex)
NdbMutex_Destroy(m_new_delete_ndb_mutex);
m_new_delete_ndb_mutex = 0;
if(m_multi_wait_group)
delete m_multi_wait_group;
m_multi_wait_group = 0;
DBUG_VOID_RETURN;
}
int
main(int argc, char ** argv)
{
plan(1);
ndb_init();
test.init();
rep.init();
if (argc == 1)
{
printf("No arguments supplied...\n"
"assuming we're being run from MTR or similar.\n"
"decreasing loop counts to ridiculously small values...\n");
cnt_seconds = 10;
cnt_inner_loops = 3000;
cnt_threads = 4;
}
else
{
printf("Arguments supplied...\n");
for (int i = 1; i < argc; i++)
{
if (match(argv[i], "cnt_seconds=", &cnt_seconds))
continue;
else if (match(argv[i], "cnt_threads=", &cnt_threads))
continue;
else if (match(argv[i], "cnt_transporters=", &cnt_transporters))
continue;
else if (match(argv[i], "cnt_inner_loops=", &cnt_inner_loops))
continue;
else if (match(argv[i], "cnt_signals_before_consume=",
&cnt_signals_before_consume))
continue;
else if (match(argv[i], "cnt_signals_per_inner_loop=",
&cnt_signals_per_inner_loop))
continue;
else if (match(argv[i], "pct_force=",
&pct_force))
continue;
else
{
printf("ignoreing unknown argument: %s\n", argv[i]);
}
}
}
printf("%s"
" cnt_seconds=%u"
" cnt_threads=%u"
" cnt_transporters=%u"
" cnt_inner_loops=%u"
" cnt_signals_before_consume=%u"
" cnt_signals_per_inner_loop=%u"
" pct_force=%u"
"\n",
argv[0],
cnt_seconds,
cnt_threads,
cnt_transporters,
cnt_inner_loops,
cnt_signals_before_consume,
cnt_signals_per_inner_loop,
pct_force);
Uint32 loop = 0;
const NDB_TICKS start = NdbTick_getCurrentTicks();
while (NdbTick_Elapsed(start,NdbTick_getCurrentTicks()).seconds() <= cnt_seconds)
{
printf("%u ", loop++); fflush(stdout);
if ((loop < 100 && (loop % 25) == 0) ||
(loop >= 100 && (loop % 20) == 0))
printf("\n");
for (unsigned t = 0; t < cnt_threads; t++)
{
rep.t[t].t.thread = NdbThread_Create(thread_main,
(void**)&rep.t[t].t,
1024*1024,
"execute thread",
NDB_THREAD_PRIO_MEAN);
}
for (unsigned t = 0; t < cnt_threads; t++)
{
void * ret;
NdbThread_WaitFor(rep.t[t].t.thread, &ret);
}
}
printf("\n"); fflush(stdout);
ok(true, "ok");
return 0;
}
void* mapSegment(void * arg) {
ThreadData * threadArgs;
long long start=0;
int total=0;
int id = *(int *)arg;
threadArgs = new ThreadData [1];
Uint32 size=5*1024*1024;
struct NdbThread* unmapthread_var;
void *status = 0;
int run = 1;
int max=0, min =100000000, sum=0;
while(run < 1001) {
start=getMicro();
char * ptr =(char*) mmap(0,
size,
PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS,
0,
0);
total=(int)(getMicro()-start);
ndbout << "T" << id << ": mmap took : " << total << " microsecs. "
<< " Run: " << run ;
ndbout_c(" mapped @ %p \n", ptr);
if(total>max)
max = total;
if(total<min)
min=total;
sum+=total;
if(ptr<0) {
ndbout << "failed to mmap!" << endl;
exit(1);
}
threadArgs[0].mapAddr = (char *)ptr;
threadArgs[0].mapSize = size;
threadArgs[0].chunk = 4096;
threadArgs[0].idx = 0;
for(Uint32 j=0; j<size; j=j+4096)
ptr[j]='1';
unmapthread_var = NdbThread_Create(unmapSegment, // Function
(void**)&threadArgs[0],// Arg
32768, // Stacksize
(char*)"unmapthread", // Thread name
NDB_THREAD_PRIO_MEAN); // Thread prio
if(NdbThread_WaitFor(unmapthread_var, &status) != 0) {
ndbout << "test failed - exitting " << endl;
exit(1);
}
run++;
}
ndbout << "MAX: " << max << " MIN: " << min;
float mean = (float) ((float)sum/(float)run);
ndbout_c(" AVERAGE: %2.5f\n",mean);
}
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;
}
Ndb_cluster_connection_impl::~Ndb_cluster_connection_impl()
{
DBUG_ENTER("~Ndb_cluster_connection");
if (m_transporter_facade != 0)
{
m_transporter_facade->stop_instance();
}
if (m_connect_thread)
{
void *status;
m_run_connect_thread= 0;
NdbThread_WaitFor(m_connect_thread, &status);
NdbThread_Destroy(&m_connect_thread);
m_connect_thread= 0;
}
if (m_transporter_facade != 0)
{
delete m_transporter_facade;
m_transporter_facade = 0;
}
if (m_config_retriever)
{
delete m_config_retriever;
m_config_retriever= NULL;
}
#ifdef VM_TRACE
if (ndb_print_state_mutex != NULL)
{
NdbMutex_Destroy(ndb_print_state_mutex);
ndb_print_state_mutex= NULL;
}
#endif
if (m_name)
free(m_name);
NdbMutex_Lock(g_ndb_connection_mutex);
if(--g_ndb_connection_count == 0){
delete NdbDictionary::Column::FRAGMENT;
delete NdbDictionary::Column::FRAGMENT_FIXED_MEMORY;
delete NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY;
delete NdbDictionary::Column::ROW_COUNT;
delete NdbDictionary::Column::COMMIT_COUNT;
delete NdbDictionary::Column::ROW_SIZE;
delete NdbDictionary::Column::RANGE_NO;
delete NdbDictionary::Column::DISK_REF;
delete NdbDictionary::Column::RECORDS_IN_RANGE;
delete NdbDictionary::Column::ROWID;
delete NdbDictionary::Column::ROW_GCI;
delete NdbDictionary::Column::ANY_VALUE;
NdbDictionary::Column::FRAGMENT= 0;
NdbDictionary::Column::FRAGMENT_FIXED_MEMORY= 0;
NdbDictionary::Column::FRAGMENT_VARSIZED_MEMORY= 0;
NdbDictionary::Column::ROW_COUNT= 0;
NdbDictionary::Column::COMMIT_COUNT= 0;
NdbDictionary::Column::ROW_SIZE= 0;
NdbDictionary::Column::RANGE_NO= 0;
NdbDictionary::Column::DISK_REF= 0;
NdbDictionary::Column::RECORDS_IN_RANGE= 0;
NdbDictionary::Column::ROWID= 0;
NdbDictionary::Column::ROW_GCI= 0;
NdbDictionary::Column::ANY_VALUE= 0;
delete NdbDictionary::Column::COPY_ROWID;
NdbDictionary::Column::COPY_ROWID = 0;
}
NdbMutex_Unlock(g_ndb_connection_mutex);
if (m_event_add_drop_mutex)
NdbMutex_Destroy(m_event_add_drop_mutex);
DBUG_VOID_RETURN;
}
void
NDBT_Thread::join()
{
NdbThread_WaitFor(m_thread, &m_status);
m_thread = 0;
}