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);
}
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);
}
int Ndb_cluster_connection::start_connect_thread(int (*connect_callback)(void))
{
int r;
DBUG_ENTER("Ndb_cluster_connection::start_connect_thread");
m_impl.m_connect_callback= connect_callback;
if ((r = connect(0,0,0)) == 1)
{
DBUG_PRINT("info",("starting thread"));
m_impl.m_connect_thread=
NdbThread_Create(run_ndb_cluster_connection_connect_thread,
(void**)&m_impl,
0, // default stack size
"ndb_cluster_connection",
NDB_THREAD_PRIO_LOW);
}
else if (r < 0)
{
DBUG_RETURN(-1);
}
else if (m_impl.m_connect_callback)
{
(*m_impl.m_connect_callback)();
}
DBUG_RETURN(0);
}
void
SocketServer::startSession(SessionInstance & si){
si.m_thread = NdbThread_Create(sessionThread_C,
(void**)si.m_session,
0, // default stack size
"NdbSock_Session",
NDB_THREAD_PRIO_LOW);
}
void
SocketServer::startSession(SessionInstance & si){
si.m_thread = NdbThread_Create(sessionThread_C,
(void**)si.m_session,
32768,
"NdbSock_Session",
NDB_THREAD_PRIO_LOW);
}
void
WatchDog::doStart(){
theStop = false;
theThreadPtr = NdbThread_Create(runWatchDog,
(void**)this,
32768,
"ndb_watchdog",
NDB_THREAD_PRIO_HIGH);
}
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;
}
void
SocketServer::startServer(){
m_threadLock.lock();
if(m_thread == 0 && m_stopThread == false){
m_thread = NdbThread_Create(socketServerThread_C,
(void**)this,
32768,
"NdbSockServ",
NDB_THREAD_PRIO_LOW);
}
m_threadLock.unlock();
}
void NDBT_TestCaseImpl1::startStepInThread(int stepNo, NDBT_Context* ctx){
NDBT_Step* pStep = steps[stepNo];
pStep->setContext(ctx);
char buf[16];
BaseString::snprintf(buf, sizeof(buf), "step_%d", stepNo);
NdbThread* pThread = NdbThread_Create(runStep_C,
(void**)pStep,
65535,
buf,
NDB_THREAD_PRIO_LOW);
threads.push_back(pThread);
}
struct NdbThread*
WatchDog::doStart()
{
theStop = false;
theThreadPtr = NdbThread_Create(runWatchDog,
(void**)this,
0, // default stack size
"ndb_watchdog",
NDB_THREAD_PRIO_HIGH);
return theThreadPtr;
}
void
ClusterMgr::startThread() {
NdbMutex_Lock(clusterMgrThreadMutex);
theStop = 0;
theClusterMgrThread = NdbThread_Create(runClusterMgr_C,
(void**)this,
32768,
"ndb_clustermgr",
NDB_THREAD_PRIO_LOW);
NdbMutex_Unlock(clusterMgrThreadMutex);
}
struct NdbThread*
SocketServer::startServer()
{
m_threadLock.lock();
if(m_thread == 0 && m_stopThread == false)
{
m_thread = NdbThread_Create(socketServerThread_C,
(void**)this,
0, // default stack size
"NdbSockServ",
NDB_THREAD_PRIO_LOW);
}
m_threadLock.unlock();
return m_thread;
}
void NDBT_TestCaseImpl1::startStepInThread(int stepNo, NDBT_Context* ctx){
NDBT_Step* pStep = steps[stepNo];
pStep->setContext(ctx);
char buf[16];
BaseString::snprintf(buf, sizeof(buf), "step_%d", stepNo);
Uint32 stackSize = ctx->getProperty(NDBT_TestCase::getStepThreadStackSizePropName(),
Uint32(512 * 1024));
NdbThread* pThread = NdbThread_Create(runStep_C,
(void**)pStep,
stackSize,
buf,
NDB_THREAD_PRIO_LOW);
threads.push_back(pThread);
}
bool
TransporterRegistry::start_clients()
{
m_run_start_clients_thread= true;
m_start_clients_thread= NdbThread_Create(run_start_clients_C,
(void**)this,
32768,
"ndb_start_clients",
NDB_THREAD_PRIO_LOW);
if (m_start_clients_thread == 0) {
m_run_start_clients_thread= false;
return false;
}
return true;
}
static void
start()
{
NdbThread_SetConcurrencyLevel(3 * Conn::proxycount + 2);
for (unsigned i = 0; i < Conn::count; i++) {
Conn& conn = Conn::list[i];
if (! conn.proxy)
continue;
conn.thread = NdbThread_Create(connrun_C, (void**)&conn,
8192, "connrun", NDB_THREAD_PRIO_LOW);
if (conn.thread == 0) {
fatal("create thread %d failed errno=%d", i, errno);
}
}
sleep(3600);
}
void
ClusterMgr::startThread() {
Guard g(clusterMgrThreadMutex);
theStop = -1;
theClusterMgrThread = NdbThread_Create(runClusterMgr_C,
(void**)this,
0, // default stack size
"ndb_clustermgr",
NDB_THREAD_PRIO_HIGH);
Uint32 cnt = 0;
while (theStop == -1 && cnt < 60)
{
NdbCondition_WaitTimeout(waitForHBCond, clusterMgrThreadMutex, 1000);
}
assert(theStop == 0);
}
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]);
}
}
}
bool CNdbThreadWorker::CreateThread()
{
LOG_NDB_FUNCTION();
assert(ETS_Invalid == CNdbThreadState::GetState());
assert(nullptr == m_pThread);
CNdbThreadState::TransitInvalidToCreate();
m_pThread = NDB_CALL_FUNCTION(NdbThread_Create(
StaticMain, reinterpret_cast<NDB_THREAD_ARG*>(this),
32768, "ThreadWorker", NDB_THREAD_PRIO_LOW));
if (nullptr == m_pThread)
{
LogNdbCritical << "FAIL : NdbThread_Create()" << endl;
return false;
}
return true;
}
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
Conn::run()
{
debug("%s: start", info);
conn1();
conn0();
const unsigned siz = 32 * 1024;
for (int i = 0; i < 2; i++) {
Copy& copy = this->copy[i];
copy.rfd = sockfd[i];
copy.wfd = sockfd[1-i];
copy.buf = new unsigned char[siz];
copy.bufsiz = siz;
sprintf(copy.info, "copy %d-%d", this->node[i]->id, this->node[1-i]->id);
copy.thread = NdbThread_Create(copyrun_C, (void**)©,
8192, "copyrun", NDB_THREAD_PRIO_LOW);
if (copy.thread == 0) {
fatal("%s: create thread %d failed errno=%d", i, errno);
}
}
debug("%s: stop", info);
}
// 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);
}
void
ClusterMgr::startThread()
{
/**
* We use the clusterMgrThreadMutex as a signalling object between this
* thread and the main thread of the ClusterMgr.
* The clusterMgrThreadMutex also protects the theStop-variable.
*/
Guard g(clusterMgrThreadMutex);
theStop = -1;
theClusterMgrThread = NdbThread_Create(runClusterMgr_C,
(void**)this,
0, // default stack size
"ndb_clustermgr",
NDB_THREAD_PRIO_HIGH);
Uint32 cnt = 0;
while (theStop == -1 && cnt < 60)
{
NdbCondition_WaitTimeout(waitForHBCond, clusterMgrThreadMutex, 1000);
}
assert(theStop == 0);
}
NDB_COMMAND(mctest, "mctest", "mctest", "Test the memory channel used in Ndb", 32768)
{
ndbout << "==== testing MemoryChannel ====" << endl;
theMemoryChannel = new MemoryChannel<int>;
theMemoryChannel2 = new MemoryChannelMultipleWriter<ArgStruct>;
NdbThread* consumerThread;
NdbThread* producerThread;
NdbThread_SetConcurrencyLevel(2);
int numItems = 100;
producerThread = NdbThread_Create(runProducer,
(void**)&numItems,
4096,
(char*)"producer");
consumerThread = NdbThread_Create(runConsumer,
(void**)&numItems,
4096,
(char*)"consumer");
void *status;
NdbThread_WaitFor(consumerThread, &status);
NdbThread_WaitFor(producerThread, &status);
ndbout << "==== testing MemoryChannelMultipleWriter ====" << endl;
#define NUM_THREADS2 5
NdbThread_SetConcurrencyLevel(NUM_THREADS2+2);
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;
}
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);
}
