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);
}
void
updateOffset(TimeInternal * send_time, TimeInternal * recv_time,
Filter * ofm_filt, RunTimeOpts * rtOpts, PtpClock * ptpClock, TimeInternal * correctionField)
{
DBGV("UTCOffset: %d | leap 59: %d | leap61: %d\n",
ptpClock->timePropertiesDS.currentUtcOffset,ptpClock->timePropertiesDS.leap59,ptpClock->timePropertiesDS.leap61);
/* updates paused, leap second pending - do nothing */
if(ptpClock->leapSecondInProgress)
return;
DBGV("==> updateOffset\n");
{
//perform basic checks, using only local variables
TimeInternal master_to_slave_delay;
/* calc 'master_to_slave_delay' */
subTime(&master_to_slave_delay, recv_time, send_time);
if (rtOpts->maxDelay) { /* If maxDelay is 0 then it's OFF */
if (master_to_slave_delay.seconds && rtOpts->maxDelay) {
INFO("updateOffset aborted, delay greater than 1"
" second.\n");
/* msgDump(ptpClock); */
return;
}
if (master_to_slave_delay.nanoseconds > rtOpts->maxDelay) {
INFO("updateOffset aborted, delay %d greater than "
"administratively set maximum %d\n",
master_to_slave_delay.nanoseconds,
rtOpts->maxDelay);
/* msgDump(ptpClock); */
return;
}
}
}
// used for stats feedback
ptpClock->char_last_msg='S';
/*
* The packet has passed basic checks, so we'll:
* - update the global delayMS variable
* - calculate a new filtered OFM
*/
#ifdef PTPD_STATISTICS
if (rtOpts->delayMSOutlierFilterEnabled) {
subTime(&ptpClock->rawDelayMS, recv_time, send_time);
if(!isDoublePeircesOutlier(ptpClock->delayMSRawStats, timeInternalToDouble(&ptpClock->rawDelayMS), rtOpts->delayMSOutlierFilterThreshold)) {
ptpClock->delayMSoutlier = FALSE;
ptpClock->delayMS = ptpClock->rawDelayMS;
} else {
ptpClock->delayMSoutlier = TRUE;
ptpClock->counters.delayMSOutliersFound++;
if(!rtOpts->delayMSOutlierFilterDiscard)
ptpClock->delayMS = doubleToTimeInternal(ptpClock->delayMSFiltered->mean);
}
} else {
subTime(&ptpClock->delayMS, recv_time, send_time);
}
#else
/* Used just for End to End mode. */
subTime(&ptpClock->delayMS, recv_time, send_time);
#endif
/* Take care about correctionField */
subTime(&ptpClock->delayMS,
&ptpClock->delayMS, correctionField);
#ifdef PTPD_STATISTICS
#endif
/* update 'offsetFromMaster' */
if (ptpClock->delayMechanism == P2P) {
subTime(&ptpClock->offsetFromMaster,
&ptpClock->delayMS,
&ptpClock->peerMeanPathDelay);
/* (End to End mode or disabled - if disabled, meanpath delay is zero) */
} else if (ptpClock->delayMechanism == E2E ||
ptpClock->delayMechanism == DELAY_DISABLED ) {
subTime(&ptpClock->offsetFromMaster,
&ptpClock->delayMS,
&ptpClock->meanPathDelay);
}
if (ptpClock->offsetFromMaster.seconds) {
/* cannot filter with secs, clear filter */
FilterClear(ofm_filt);
rtOpts->offset_first_updated = TRUE;
return;
}
FilterFeed(ofm_filt, &ptpClock->offsetFromMaster.nanoseconds);
DBGV("offset filter %d\n", ptpClock->offsetFromMaster.nanoseconds);
/* Apply the offset shift */
subTime(&ptpClock->offsetFromMaster, &ptpClock->offsetFromMaster,
&rtOpts->ofmShift);
/*
* Offset must have been computed at least one time before
* computing end to end delay
*/
rtOpts->offset_first_updated = TRUE;
}
/* 2 x fairy dust, 3 x unicorn droppings, 1 x magic beanstalk juice. blend, spray on the affected area twice per day */
static Boolean
outlierFilterFilter(OutlierFilter *filter, double sample)
{
/* true = accepted - this is to tell the user if we advised to throw away the sample */
Boolean ret = TRUE;
/* step change: outlier mean - accepted mean from last sampling period */
double step = 0.0;
if(!filter->config.enabled) {
filter->output = sample;
return TRUE;
}
step = fabs(filter->outlierStats.mean - filter->acceptedStats.bufferedMean);
if(filter->config.autoTune) {
filter->autoTuneSamples++;
}
/* no outlier first - more convenient this way */
if(!isDoublePeircesOutlier(filter->rawStats, sample, filter->threshold) && (filter->delay == 0)) {
filter->lastOutlier = FALSE;
filter->output = sample;
/* filter is about to accept after a blocking period */
if(filter->consecutiveOutliers) {
DBG_LOCAL_ID(filter,"consecutive: %d, mean: %.09fm accepted bmean: %.09f\n", filter->consecutiveOutliers,
filter->outlierStats.mean,filter->acceptedStats.bufferedMean);
/* we are about to open up but the offset has risen above step level, we will block again, but not forever */
if(filter->config.stepDelay &&
(fabs(filter->acceptedStats.bufferedMean) < ((filter->config.stepThreshold + 0.0) / 1E9)) &&
(step > ((filter->config.stepLevel + 0.0) / 1E9))) {
/* if we're to enter blocking, we need 2 * consecutiveOutliers credit */
/* if we're already blocking, we just need enough credit */
/* if we're already blocking, make sure we block no more than maxDelay */
if((filter->blocking && ((filter->config.maxDelay > filter->totalDelay) && (filter->delayCredit >= filter->consecutiveOutliers))) ||
(!filter->blocking && (filter->delayCredit >= filter->consecutiveOutliers * 2 ))) {
if(!filter->blocking) {
INFO_LOCAL_ID(filter,"%.03f us step detected, filter will now block\n", step * 1E6);
}
DBG_LOCAL_ID(filter,"step: %.09f, credit left %d, requesting %d\n",step,
filter->delayCredit, filter->consecutiveOutliers);
filter->delay = filter->consecutiveOutliers;
filter->totalDelay += filter->consecutiveOutliers;
filter->delayCredit -= filter->consecutiveOutliers;
filter->blocking = TRUE;
resetDoublePermanentMean(&filter->outlierStats);
filter->lastOutlier = TRUE;
DBG_LOCAL_ID(filter,"maxdelay: %d, totaldelay: %d\n",filter->config.maxDelay, filter->totalDelay);
return FALSE;
/* much love for the ultra magnetic, cause everybody knows you never got enough credit */
/* we either ran out of credit while blocking, or we did not have enough to start with */
} else {
if(filter->blocking) {
INFO_LOCAL_ID(filter,"blocking time exhausted, filter will stop blocking\n");
} else {
INFO_LOCAL_ID(filter,"%.03f us step detected but filter cannot block\n", step * 1E6);
}
DBG_LOCAL_ID(filter,"credit out (has %d, needed %d)\n", filter->delayCredit, filter->consecutiveOutliers);
}
/* NO STEP */
} else {
if (filter->blocking) {
INFO_LOCAL_ID(filter,"step event over, filter will stop blocking\n");
}
filter->blocking = FALSE;
}
if(filter->totalDelay != 0) {
DBG_LOCAL_ID(filter,"Total waited %d\n", filter->totalDelay);
filter->totalDelay = 0;
}
}
filter->consecutiveOutliers = 0;
resetDoublePermanentMean(&filter->outlierStats);
feedDoublePermanentMean(&filter->acceptedStats, sample);
/* it's an outlier, Sir! */
} else {
filter->lastOutlier = TRUE;
feedDoublePermanentMean(&filter->outlierStats, sample);
if(filter->delay) {
DBG_LOCAL_ID(filter,"delay left: %d\n", filter->delay);
filter->delay--;
return FALSE;
}
filter->autoTuneOutliers++;
filter->consecutiveOutliers++;
if(filter->config.discard) {
ret = FALSE;
} else {
filter->output = filter->filteredStats->mean;
}
DBG_LOCAL_ID(filter,"Outlier: %.09f\n", sample);
/* Allow [weight] * [deviation from mean] to influence std dev in the next outlier checks */
sample = filter->rawStats->meanContainer->mean + filter->config.weight * ( sample - filter->rawStats->meanContainer->mean);
}
/* keep stats containers updated */
feedDoubleMovingStdDev(filter->rawStats, sample);
feedDoubleMovingMean(filter->filteredStats, filter->output);
/* re-tune filter twice per window */
if( (filter->rawStats->meanContainer->counter % ( filter->rawStats->meanContainer->capacity / 2)) == 0) {
outlierFilterTune(filter);
}
/* replenish filter credit once per window */
if( filter->config.stepDelay && ((filter->rawStats->meanContainer->counter % filter->rawStats->meanContainer->capacity) == 0)) {
filter->delayCredit += filter->config.creditIncrement;
if(filter->delayCredit >= filter->config.delayCredit) {
filter->delayCredit = filter->config.delayCredit;
}
DBG_LOCAL_ID(filter,"credit added, now %d\n", filter->delayCredit);
}
return ret;
}
