/*-----------------------------------*/
double userGetTimeSync(void)
{
static int initialized = 0;
static NDB_TICKS initSecs = 0;
static Uint32 initMicros = 0;
double timeValue = 0;
if ( !initialized ) {
initialized = 1;
NdbTick_CurrentMicrosecond(&initSecs, &initMicros);
timeValue = 0.0;
} else {
NDB_TICKS secs = 0;
Uint32 micros = 0;
NdbTick_CurrentMicrosecond(&secs, µs);
double s = (double)secs - (double)initSecs;
double us = (double)secs - (double)initMicros;
timeValue = s + (us / 1000000.0);
}
return timeValue;
}
inline
void
SimulatedBlock::EXECUTE_DIRECT(Uint32 block,
Uint32 gsn,
Signal* signal,
Uint32 len){
signal->setLength(len);
#ifdef VM_TRACE
if(globalData.testOn){
signal->header.theVerId_signalNumber = gsn;
signal->header.theReceiversBlockNumber = block;
signal->header.theSendersBlockRef = reference();
globalSignalLoggers.executeDirect(signal->header,
0, // in
&signal->theData[0],
globalData.ownId);
}
#endif
SimulatedBlock* b = globalData.getBlock(block);
#ifdef VM_TRACE_TIME
Uint32 us1, us2;
Uint64 ms1, ms2;
NdbTick_CurrentMicrosecond(&ms1, &us1);
Uint32 tGsn = m_currentGsn;
b->m_currentGsn = gsn;
#endif
b->executeFunction(gsn, signal);
#ifdef VM_TRACE_TIME
NdbTick_CurrentMicrosecond(&ms2, &us2);
Uint64 diff = ms2;
diff -= ms1;
diff *= 1000000;
diff += us2;
diff -= us1;
b->addTime(gsn, diff);
m_currentGsn = tGsn;
subTime(tGsn, diff);
#endif
#ifdef VM_TRACE
if(globalData.testOn){
signal->header.theVerId_signalNumber = gsn;
signal->header.theReceiversBlockNumber = block;
signal->header.theSendersBlockRef = reference();
globalSignalLoggers.executeDirect(signal->header,
1, // out
&signal->theData[0],
globalData.ownId);
}
#endif
}
int
NdbTick_getMicroTimer(struct MicroSecondTimer* input_timer)
{
NDB_TICKS secs;
Uint32 mics;
int ret_value;
ret_value = NdbTick_CurrentMicrosecond(&secs, &mics);
input_timer->seconds = secs;
input_timer->micro_seconds = (NDB_TICKS)mics;
return ret_value;
}
NDB_TICKS NdbTick_CurrentMillisecond(void)
{
#ifdef _WIN32
NDB_TICKS secs;
Uint32 micros;
NdbTick_CurrentMicrosecond(&secs, µs);
return secs*1000 + micros/1000;
#else
struct timeval tick_time;
gettimeofday(&tick_time, 0);
return
((NDB_TICKS)tick_time.tv_sec) * ((NDB_TICKS)MILLISEC_PER_SEC) +
((NDB_TICKS)tick_time.tv_usec) / ((NDB_TICKS)MICROSEC_PER_MILLISEC);
#endif
}
NDB_TICKS NdbTick_CurrentNanosecond(void)
{
#ifdef _WIN32
NDB_TICKS secs;
Uint32 micros;
NdbTick_CurrentMicrosecond(&secs, µs);
return secs*NANOSEC_PER_SEC + micros*NANOSEC_PER_MICROSEC;
#else
struct timeval tick_time;
gettimeofday(&tick_time, 0);
return
(((NDB_TICKS)tick_time.tv_sec) * ((NDB_TICKS)NANOSEC_PER_SEC)) +
(((NDB_TICKS)tick_time.tv_usec) * ((NDB_TICKS)NANOSEC_PER_MICROSEC));
#endif
}
//------------------------------------------------------------------------
// sendPacked is executed at the end of the loop.
// To ensure that we don't send any messages before executing all local
// packed signals we do another turn in the loop (unless we have already
// executed too many signals in the loop).
//------------------------------------------------------------------------
void
FastScheduler::doJob()
{
Uint32 loopCount = 0;
Uint32 TminLoops = getBOccupancy() + EXTRA_SIGNALS_PER_DO_JOB;
Uint32 TloopMax = (Uint32)globalData.loopMax;
if (TminLoops < TloopMax) {
TloopMax = TminLoops;
}//if
if (TloopMax < MIN_NUMBER_OF_SIG_PER_DO_JOB) {
TloopMax = MIN_NUMBER_OF_SIG_PER_DO_JOB;
}//if
register Signal* signal = getVMSignals();
register Uint32 tHighPrio= globalData.highestAvailablePrio;
do{
while ((tHighPrio < LEVEL_IDLE) && (loopCount < TloopMax)) {
// signal->garbage_register();
// To ensure we find bugs quickly
register Uint32 gsnbnr = theJobBuffers[tHighPrio].retrieve(signal);
register BlockNumber reg_bnr = gsnbnr & 0xFFF;
register GlobalSignalNumber reg_gsn = gsnbnr >> 16;
globalData.incrementWatchDogCounter(1);
if (reg_bnr > 0) {
Uint32 tJobCounter = globalData.JobCounter;
Uint32 tJobLap = globalData.JobLap;
SimulatedBlock* b = globalData.getBlock(reg_bnr);
theJobPriority[tJobCounter] = (Uint8)tHighPrio;
globalData.JobCounter = (tJobCounter + 1) & 4095;
globalData.JobLap = tJobLap + 1;
#ifdef VM_TRACE_TIME
Uint32 us1, us2;
Uint64 ms1, ms2;
NdbTick_CurrentMicrosecond(&ms1, &us1);
b->m_currentGsn = reg_gsn;
#endif
getSections(signal->header.m_noOfSections, signal->m_sectionPtr);
#ifdef VM_TRACE
{
if (globalData.testOn) {
signal->header.theVerId_signalNumber = reg_gsn;
signal->header.theReceiversBlockNumber = reg_bnr;
globalSignalLoggers.executeSignal(signal->header,
tHighPrio,
&signal->theData[0],
globalData.ownId,
signal->m_sectionPtr,
signal->header.m_noOfSections);
}//if
}
#endif
b->executeFunction(reg_gsn, signal);
releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
signal->header.m_noOfSections = 0;
#ifdef VM_TRACE_TIME
NdbTick_CurrentMicrosecond(&ms2, &us2);
Uint64 diff = ms2;
diff -= ms1;
diff *= 1000000;
diff += us2;
diff -= us1;
b->addTime(reg_gsn, diff);
#endif
tHighPrio = globalData.highestAvailablePrio;
} else {
tHighPrio++;
globalData.highestAvailablePrio = tHighPrio;
}//if
loopCount++;
}//while
sendPacked();
tHighPrio = globalData.highestAvailablePrio;
if(getBOccupancy() > MAX_OCCUPANCY)
{
if(loopCount != TloopMax)
abort();
assert( loopCount == TloopMax );
TloopMax += 512;
}
} while ((getBOccupancy() > MAX_OCCUPANCY) ||
((loopCount < TloopMax) &&
(tHighPrio < LEVEL_IDLE)));
theDoJobCallCounter ++;
theDoJobTotalCounter += loopCount;
if (theDoJobCallCounter == 8192) {
reportDoJobStatistics(theDoJobTotalCounter >> 13);
theDoJobCallCounter = 0;
theDoJobTotalCounter = 0;
}//if