void HeapStatistics::exitWithFailure()
{
ASSERT(Options::logHeapStatisticsAtExit());
s_endTime = WTF::monotonicallyIncreasingTime();
logStatistics();
exit(-1);
}
void OpenCLMemory::free() {
OpenCLDevice& current_device =
OpenCLManager::CurrentPlatform()->CurrentDevice();
cl_int err;
if (this->ptr_device_mem_ != NULL) {
if (this->hasEvent()) {
CL_CHECK(
clWaitForEvents(
1,
&this->memoryEvent));
this->resetEvent();
}
err = clReleaseMemObject(
this->ptr_device_mem_);
if (err != CL_SUCCESS) {
std::ostringstream oss;
oss << current_device.name() << "> failed to call clReleaseMemObject("
<< this->ptr_device_mem << ").";
LOG(ERROR)<< oss.str().c_str();
throw OpenCLMemoryException(
oss.str());
}
this->ptr_device_mem_ = NULL;
DLOG(INFO)<< current_device.name() << "> clReleaseMemObject("
<< this->ptr_device_mem << ") succeeded.";
numCallsFree++;
logStatistics();
}
}
void
signalHandler()
{
m_logger.shutdownLogger();
face_.shutdown();
ioService_.reset();
logStatistics();
exit(1);
}
void DashPlayerStats::logFpsSummary() {
if (mFileOut) {
logStatistics();
logSyncLoss();
{
Mutex::Autolock autoLock(mStatsLock);
fprintf(mFileOut, "=========================================================\n");
fprintf(mFileOut, "Average Frames Per Second: %.4f\n", mFPSSumUs/((double)mStatisticsFrames));
fprintf(mFileOut, "Total Frames (rendered) / Total Time: %.4f\n", ((double)(mTotalRenderingFrames-1)*1E6)/((double)mTotalTime));
fprintf(mFileOut, "========================================================\n");
}
}
}
//---------------------------------------------------------------------------------
void MeshAndBspLoadContext::load(const DataStreamExPtr& _dataStream)
{
clear();
mDataStream = _dataStream;
Progress& progress = Progress::getSingleton();
progress.setRange(0, 100);
// Read version and size of entire MeshAndBsp.
readMeshAndBspHeader();
// Read mesh
MshFileLoadContext::load(_dataStream);
progress.setPosition(5);
// Read BSP
bool finish = false;
while(!finish)
{
Chunk chunk(mDataStream);
switch(chunk.getID())
{
case 0xC000: readBspInfo(chunk); break;
case 0xC010: readPolygonIndices(chunk); break;
case 0xC040: readBspNodes(chunk); break;
case 0xC045: readLights(chunk); break;
case 0xC050: readSectors(chunk); break;
case 0xC0FF: finish = true; break;
}
}
progress.setPosition(10);
// Remove excess polygons
countPolygonUsesInLod0();
removePolygonsNotUsedInLod0();
// Log statistics
logStatistics();
}
void HeapStatistics::reportSuccess()
{
ASSERT(Options::logHeapStatisticsAtExit());
s_endTime = WTF::monotonicallyIncreasingTime();
logStatistics();
}
void
updateClock(RunTimeOpts * rtOpts, PtpClock * ptpClock)
{
/* updates paused, leap second pending - do nothing */
if(ptpClock->leapSecondInProgress)
return;
DBGV("==> updateClock\n");
if(ptpClock->panicMode) {
DBG("Panic mode - skipping updateClock");
}
/*
if(rtOpts->delayMSOutlierFilterEnabled && rtOpts->delayMSOutlierFilterDiscard && ptpClock->delayMSoutlier)
goto display;
*/
if (rtOpts->maxReset) { /* If maxReset is 0 then it's OFF */
if (ptpClock->offsetFromMaster.seconds && rtOpts->maxReset) {
INFO("updateClock aborted, offset greater than 1"
" second.");
if (rtOpts->displayPackets)
msgDump(ptpClock);
goto display;
}
if (ptpClock->offsetFromMaster.nanoseconds > rtOpts->maxReset) {
INFO("updateClock aborted, offset %d greater than "
"administratively set maximum %d\n",
ptpClock->offsetFromMaster.nanoseconds,
rtOpts->maxReset);
if (rtOpts->displayPackets)
msgDump(ptpClock);
goto display;
}
}
if (ptpClock->offsetFromMaster.seconds) {
/* if secs, reset clock or set freq adjustment to max */
/*
if offset from master seconds is non-zero, then this is a "big jump:
in time. Check Run Time options to see if we will reset the clock or
set frequency adjustment to max to adjust the time
*/
/*
* noAdjust = cannot do any change to clock
* noResetClock = if can change the clock, can we also step it?
*/
if (!rtOpts->noAdjust) {
if(rtOpts->enablePanicMode && !ptpClock->panicOver) {
if(ptpClock->panicMode)
goto display;
if(ptpClock->panicOver) {
ptpClock->panicMode = FALSE;
ptpClock->panicOver = FALSE;
#ifdef PTPD_STATISTICS
ptpClock->isCalibrated = FALSE;
#endif /* PTPD_STATISTICS */
goto display;
}
CRITICAL("Offset above 1 second - entering panic mode\n");
ptpClock->panicMode = TRUE;
ptpClock->panicModeTimeLeft = 2 * rtOpts->panicModeDuration;
timerStart(PANIC_MODE_TIMER, 30, ptpClock->itimer);
#ifdef PTPD_NTPDC
/* Trigger NTP failover as part of panic mode */
if(rtOpts->ntpOptions.enableEngine && rtOpts->panicModeNtp) {
/* Make sure we log ntp control errors now */
ptpClock->ntpControl.requestFailed = FALSE;
/* We have a timeout defined */
if(rtOpts->ntpOptions.failoverTimeout) {
DBG("NTP failover timer started - panic mode\n");
timerStart(NTPD_FAILOVER_TIMER,
rtOpts->ntpOptions.failoverTimeout,
ptpClock->itimer);
/* Fail over to NTP straight away */
} else {
DBG("Initiating NTP failover\n");
ptpClock->ntpControl.isRequired = TRUE;
ptpClock->ntpControl.isFailOver = TRUE;
if(!ntpdControl(&rtOpts->ntpOptions, &ptpClock->ntpControl, FALSE))
DBG("PANIC MODE instant NTP failover - could not fail over\n");
}
}
#endif /* PTPD_NTPDC */
goto display;
}
if(rtOpts->enablePanicMode) {
if(ptpClock->panicOver)
CRITICAL("Panic mode timeout - accepting current offset. Clock will jump\n");
ptpClock->panicOver = FALSE;
timerStop(PANIC_MODE_TIMER, ptpClock->itimer);
#ifdef PTPD_NTPDC
/* Exiting ntp failover - getting out of panic mode */
if(rtOpts->ntpOptions.enableEngine && rtOpts->panicModeNtp) {
timerStop(NTPD_FAILOVER_TIMER, ptpClock->itimer);
ptpClock->ntpControl.isRequired = FALSE;
ptpClock->ntpControl.isFailOver = FALSE;
if(!ntpdControl(&rtOpts->ntpOptions, &ptpClock->ntpControl, FALSE))
DBG("NTPdcontrol - could not return from NTP panic mode\n");
}
#endif /* PTPD_NTPDC */
}
if (!rtOpts->noResetClock) {
servo_perform_clock_step(rtOpts, ptpClock);
} else {
#ifdef HAVE_SYS_TIMEX_H
if(ptpClock->offsetFromMaster.nanoseconds > 0)
ptpClock->servo.observedDrift = rtOpts->servoMaxPpb;
else
ptpClock->servo.observedDrift = -rtOpts->servoMaxPpb;
warn_operator_slow_slewing(rtOpts, ptpClock);
adjFreq_wrapper(rtOpts, ptpClock, -ptpClock->servo.observedDrift);
/* its not clear how the APPLE case works for large jumps */
#endif /* HAVE_SYS_TIMEX_H */
}
}
} else {
/* If we're in panic mode, either exit if no threshold configured, or exit if we're outside the exit threshold */
if(rtOpts->enablePanicMode &&
((ptpClock->panicMode && ( rtOpts->panicModeExitThreshold == 0 || ((rtOpts->panicModeExitThreshold > 0) && ((ptpClock->offsetFromMaster.seconds == 0) && (ptpClock->offsetFromMaster.nanoseconds < rtOpts->panicModeExitThreshold)))) ) || ptpClock->panicOver)) {
ptpClock->panicMode = FALSE;
ptpClock->panicOver = FALSE;
timerStop(PANIC_MODE_TIMER, ptpClock->itimer);
NOTICE("Offset below 1 second again: exiting panic mode\n");
#ifdef PTPD_NTPDC
/* exiting ntp failover - panic mode over */
if(rtOpts->ntpOptions.enableEngine && rtOpts->panicModeNtp) {
timerStop(NTPD_FAILOVER_TIMER, ptpClock->itimer);
ptpClock->ntpControl.isRequired = FALSE;
ptpClock->ntpControl.isFailOver = FALSE;
if(!ntpdControl(&rtOpts->ntpOptions, &ptpClock->ntpControl, FALSE))
DBG("NTPdcontrol - could not return from NTP panic mode\n");
}
#endif /* PTPD_NTPDC */
}
/* Servo dT is the log sync interval */
/* TODO: if logsyincinterval is 127 [unicast], switch to measured */
if(rtOpts->servoDtMethod == DT_CONSTANT)
ptpClock->servo.logdT = ptpClock->logSyncInterval;
/* If the last delayMS was an outlier and filter action is discard, skip servo run */
#ifdef PTPD_STATISTICS
if(rtOpts->delayMSOutlierFilterEnabled && rtOpts->delayMSOutlierFilterDiscard && ptpClock->delayMSoutlier)
goto statistics;
#endif /* PTPD_STATISTICS */
#ifndef HAVE_SYS_TIMEX_H
adjTime(ptpClock->offsetFromMaster.nanoseconds);
#else
#ifdef PTPD_STATISTICS
/* if statistics are enabled, only run the servo if we are calibrted - if calibration delay configured */
if(!rtOpts->calibrationDelay || ptpClock->isCalibrated)
#endif /*PTPD_STATISTICS */
/* Adjust the clock first -> the PI controller runs here */
adjFreq_wrapper(rtOpts, ptpClock, runPIservo(&ptpClock->servo, ptpClock->offsetFromMaster.nanoseconds));
/* Unset STA_UNSYNC */
unsetTimexFlags(STA_UNSYNC, TRUE);
/* "Tell" the clock about maxerror, esterror etc. */
informClockSource(ptpClock);
#endif /* HAVE_SYS_TIMEX_H */
}
/* Update relevant statistics containers, feed outlier filter thresholds etc. */
#ifdef PTPD_STATISTICS
statistics:
if (rtOpts->delayMSOutlierFilterEnabled) {
double dDelayMS = timeInternalToDouble(&ptpClock->rawDelayMS);
if(ptpClock->delayMSoutlier) {
/* Allow [weight] * [deviation from mean] to influence std dev in the next outlier checks */
DBG("DelayMS Outlier: %.09f\n", dDelayMS);
dDelayMS = ptpClock->delayMSRawStats->meanContainer->mean +
rtOpts->delayMSOutlierWeight * ( dDelayMS - ptpClock->delayMSRawStats->meanContainer->mean);
}
feedDoubleMovingStdDev(ptpClock->delayMSRawStats, dDelayMS);
feedDoubleMovingMean(ptpClock->delayMSFiltered, timeInternalToDouble(&ptpClock->delayMS));
}
feedDoublePermanentStdDev(&ptpClock->slaveStats.ofmStats, timeInternalToDouble(&ptpClock->offsetFromMaster));
feedDoublePermanentStdDev(&ptpClock->servo.driftStats, ptpClock->servo.observedDrift);
#endif /* PTPD_STATISTICS */
display:
logStatistics(rtOpts, ptpClock);
DBGV("\n--Offset Correction-- \n");
DBGV("Raw offset from master: %10ds %11dns\n",
ptpClock->delayMS.seconds,
ptpClock->delayMS.nanoseconds);
DBGV("\n--Offset and Delay filtered-- \n");
if (ptpClock->delayMechanism == P2P) {
DBGV("one-way delay averaged (P2P): %10ds %11dns\n",
ptpClock->peerMeanPathDelay.seconds,
ptpClock->peerMeanPathDelay.nanoseconds);
} else if (ptpClock->delayMechanism == E2E) {
DBGV("one-way delay averaged (E2E): %10ds %11dns\n",
ptpClock->meanPathDelay.seconds,
ptpClock->meanPathDelay.nanoseconds);
}
DBGV("offset from master: %10ds %11dns\n",
ptpClock->offsetFromMaster.seconds,
ptpClock->offsetFromMaster.nanoseconds);
DBGV("observed drift: %10d\n", ptpClock->servo.observedDrift);
}
void
updatePeerDelay(Filter * owd_filt, RunTimeOpts * rtOpts, PtpClock * ptpClock, TimeInternal * correctionField, Boolean twoStep)
{
/* updates paused, leap second pending - do nothing */
if(ptpClock->leapSecondInProgress)
return;
DBGV("updatePeerDelay\n");
ptpClock->char_last_msg = 'P';
if (twoStep) {
/* calc 'slave_to_master_delay' */
subTime(&ptpClock->pdelayMS,
&ptpClock->pdelay_resp_receive_time,
&ptpClock->pdelay_resp_send_time);
subTime(&ptpClock->pdelaySM,
&ptpClock->pdelay_req_receive_time,
&ptpClock->pdelay_req_send_time);
/* update 'one_way_delay' */
addTime(&ptpClock->peerMeanPathDelay,
&ptpClock->pdelayMS,
&ptpClock->pdelaySM);
/* Substract correctionField */
subTime(&ptpClock->peerMeanPathDelay,
&ptpClock->peerMeanPathDelay, correctionField);
/* Compute one-way delay */
div2Time(&ptpClock->peerMeanPathDelay);
} else {
/* One step clock */
subTime(&ptpClock->peerMeanPathDelay,
&ptpClock->pdelay_resp_receive_time,
&ptpClock->pdelay_req_send_time);
/* Substract correctionField */
subTime(&ptpClock->peerMeanPathDelay,
&ptpClock->peerMeanPathDelay, correctionField);
/* Compute one-way delay */
div2Time(&ptpClock->peerMeanPathDelay);
}
if (ptpClock->peerMeanPathDelay.seconds) {
/* cannot filter with secs, clear filter */
FilterClear(owd_filt);
return;
}
{
// TODO: remove hack
char s_text[32];
sprintf(s_text, "%d", rtOpts->s);
FilterConfigure(owd_filt, "stiffness", s_text);
}
FilterFeed(owd_filt, &ptpClock->peerMeanPathDelay.nanoseconds);
DBGV("delay filter %d\n", ptpClock->peerMeanPathDelay.nanoseconds);
//display:
if(ptpClock->portState == PTP_SLAVE)
logStatistics(rtOpts, ptpClock);
}
void
updateDelay(Filter * owd_filt, RunTimeOpts * rtOpts, PtpClock * ptpClock, TimeInternal * correctionField)
{
/* updates paused, leap second pending - do nothing */
if(ptpClock->leapSecondInProgress)
return;
DBGV("updateDelay\n");
/* todo: do all intermediate calculations on temp vars */
TimeInternal prev_meanPathDelay = ptpClock->meanPathDelay;
ptpClock->char_last_msg = 'D';
{
//perform basic checks, using local variables only
TimeInternal slave_to_master_delay;
/* calc 'slave_to_master_delay' */
subTime(&slave_to_master_delay, &ptpClock->delay_req_receive_time,
&ptpClock->delay_req_send_time);
if (rtOpts->maxDelay && /* If maxDelay is 0 then it's OFF */
rtOpts->offset_first_updated) {
if ((slave_to_master_delay.nanoseconds < 0) &&
(abs(slave_to_master_delay.nanoseconds) > rtOpts->maxDelay)) {
INFO("updateDelay aborted, "
"delay (sec: %d ns: %d) is negative\n",
slave_to_master_delay.seconds,
slave_to_master_delay.nanoseconds);
INFO("send (sec: %d ns: %d)\n",
ptpClock->delay_req_send_time.seconds,
ptpClock->delay_req_send_time.nanoseconds);
INFO("recv (sec: %d n s: %d)\n",
ptpClock->delay_req_receive_time.seconds,
ptpClock->delay_req_receive_time.nanoseconds);
goto display;
}
if (slave_to_master_delay.seconds && rtOpts->maxDelay) {
INFO("updateDelay aborted, delay %d.%d greater than 1 second\n",
slave_to_master_delay.seconds,
slave_to_master_delay.nanoseconds);
if (rtOpts->displayPackets)
msgDump(ptpClock);
goto display;
}
if (slave_to_master_delay.nanoseconds > rtOpts->maxDelay) {
INFO("updateDelay aborted, delay %d greater than "
"administratively set maximum %d\n",
slave_to_master_delay.nanoseconds,
rtOpts->maxDelay);
if (rtOpts->displayPackets)
msgDump(ptpClock);
goto display;
}
}
}
/*
* The packet has passed basic checks, so we'll:
* - update the global delaySM variable
* - calculate a new filtered MPD
*/
if (rtOpts->offset_first_updated) {
/*
* calc 'slave_to_master_delay' (Master to Slave delay is
* already computed in updateOffset )
*/
DBG("==> UpdateDelay(): %s\n",
dump_TimeInternal2("Req_RECV:", &ptpClock->delay_req_receive_time,
"Req_SENT:", &ptpClock->delay_req_send_time));
#ifdef PTPD_STATISTICS
if (rtOpts->delaySMOutlierFilterEnabled) {
subTime(&ptpClock->rawDelaySM, &ptpClock->delay_req_receive_time,
&ptpClock->delay_req_send_time);
if(!isDoublePeircesOutlier(ptpClock->delaySMRawStats, timeInternalToDouble(&ptpClock->rawDelaySM), rtOpts->delaySMOutlierFilterThreshold)) {
ptpClock->delaySM = ptpClock->rawDelaySM;
ptpClock->delaySMoutlier = FALSE;
} else {
ptpClock->delaySMoutlier = TRUE;
ptpClock->counters.delaySMOutliersFound++;
if (!rtOpts->delaySMOutlierFilterDiscard) {
ptpClock->delaySM = doubleToTimeInternal(ptpClock->delaySMFiltered->mean);
} else {
goto statistics;
}
}
} else {
subTime(&ptpClock->delaySM, &ptpClock->delay_req_receive_time,
&ptpClock->delay_req_send_time);
}
#else
subTime(&ptpClock->delaySM, &ptpClock->delay_req_receive_time,
&ptpClock->delay_req_send_time);
#endif
/* update 'one_way_delay' */
addTime(&ptpClock->meanPathDelay, &ptpClock->delaySM,
&ptpClock->delayMS);
/* Substract correctionField */
subTime(&ptpClock->meanPathDelay, &ptpClock->meanPathDelay,
correctionField);
/* Compute one-way delay */
div2Time(&ptpClock->meanPathDelay);
if (ptpClock->meanPathDelay.seconds) {
DBG("update delay: cannot filter with large OFM, "
"clearing filter\n");
INFO("Servo: Ignoring delayResp because of large OFM\n");
FilterClear(owd_filt);
/* revert back to previous value */
ptpClock->meanPathDelay = prev_meanPathDelay;
goto display;
}
if(ptpClock->meanPathDelay.nanoseconds < 0){
DBG("update delay: found negative value for OWD, "
"so ignoring this value: %d\n",
ptpClock->meanPathDelay.nanoseconds);
/* revert back to previous value */
ptpClock->meanPathDelay = prev_meanPathDelay;
#ifdef PTPD_STATISTICS
goto statistics;
#else
goto display;
#endif /* PTPD_STATISTICS */
}
{
// TODO: remove hack
char s_text[32];
sprintf(s_text, "%d", rtOpts->s);
FilterConfigure(owd_filt, "stiffness", s_text);
}
FilterFeed(owd_filt, &ptpClock->meanPathDelay.nanoseconds);
/* Update relevant statistics containers, feed outlier filter thresholds etc. */
#ifdef PTPD_STATISTICS
statistics:
if (rtOpts->delaySMOutlierFilterEnabled) {
double dDelaySM = timeInternalToDouble(&ptpClock->rawDelaySM);
/* If this is an outlier, bring it by a factor closer to mean before allowing to influence stdDev */
if(ptpClock->delaySMoutlier) {
/* Allow [weight] * [deviation from mean] to influence std dev in the next outlier checks */
DBG("DelaySM outlier: %.09f\n", dDelaySM);
if((rtOpts->calibrationDelay<1) || ptpClock->isCalibrated)
dDelaySM = ptpClock->delaySMRawStats->meanContainer->mean + rtOpts->delaySMOutlierWeight * ( dDelaySM - ptpClock->delaySMRawStats->meanContainer->mean);
}
feedDoubleMovingStdDev(ptpClock->delaySMRawStats, dDelaySM);
feedDoubleMovingMean(ptpClock->delaySMFiltered, timeInternalToDouble(&ptpClock->delaySM));
}
feedDoublePermanentStdDev(&ptpClock->slaveStats.owdStats, timeInternalToDouble(&ptpClock->meanPathDelay));
#endif
DBGV("delay filter %d\n", ptpClock->meanPathDelay.nanoseconds);
} else {
INFO("Ignoring delayResp because we didn't receive any sync yet\n");
}
display:
logStatistics(rtOpts, ptpClock);
}
OpenCLMemory::OpenCLMemory(size_t size) {
OpenCLDevice& current_device =
OpenCLManager::CurrentPlatform()->CurrentDevice();
cl_context context = current_device.getContext();
cl_command_queue* queue = current_device.getQueue();
if (!context) {
std::ostringstream oss;
oss << current_device.name() << "> failed to get OpenCL context.";
LOG(FATAL)<< oss;
}
double allocSizeMB = size / (1024.0 * 1024.0);
cl_int err;
this->ptr_device_mem_ = clCreateBuffer(
context,
CL_MEM_READ_WRITE,
size,
NULL,
&err);
if (err != CL_SUCCESS) {
std::ostringstream oss;
oss << current_device.name()
<< "> failed to create CL_MEM_READ_WRITE buffer of " << allocSizeMB
<< " MByte";
LOG(FATAL)<< oss.str();
}
/*
err = clEnqueueMigrateMemObjects(*queue, 1, &(this->ptr_device_mem_), CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED, 0, 0, 0);
if ( err != CL_SUCCESS ) {
std::ostringstream oss;
oss << current_device.name() << "> failed to call clEnqueueMigrateMemObjects() " << allocSizeMB << " MByte";
LOG(FATAL) << oss.str();
}
*/
size_t bytesUsed = current_device.getMemoryUsage();
double deviceMemUsedMB = bytesUsed;
deviceMemUsedMB /= 1024.0;
deviceMemUsedMB /= 1024.0;
this->ptr_device_mem = (const void*) this->ptr_device_mem_;
this->size = size;
this->ptr_virtual_bgn = ptr_offset;
this->ptr_virtual_end = static_cast<void*>(reinterpret_cast<char*>(ptr_offset)
+ size - 1);
this->ptr_offset = static_cast<void*>(reinterpret_cast<char*>(ptr_offset)
+ size);
this->memoryEvent = NULL;
std::ostringstream oss;
oss << "GPU@" << this->ptr_device_mem << "(" << this->size << ") MEM"
<< this->count;
this->tag = oss.str();
DLOG(INFO)<< current_device.name()
<< "> create CL_MEM_READ_WRITE buffer of "
<< allocSizeMB << " MByte at " << getTag().c_str()
<< " total mem utilization = " << deviceMemUsedMB << " MByte";
DLOG(INFO)<< "new memory " << this->tag.c_str();
this->count++;
numCallsMalloc++;
logStatistics();
}