Beispiel #1
0
void
resetPtpEngineSlaveStats(PtpEngineSlaveStats* stats) {

	resetDoublePermanentStdDev(&stats->ofmStats);
	resetDoublePermanentStdDev(&stats->owdStats);

}
Beispiel #2
0
void
resetPtpEngineSlaveStats(PtpEngineSlaveStats* stats) {

	resetDoublePermanentStdDev(&stats->ofmStats);
	resetDoublePermanentStdDev(&stats->mpdStats);
	resetDoublePermanentMedian(&stats->ofmMedianContainer);
	resetDoublePermanentMedian(&stats->mpdMedianContainer);
	stats->ofmStatsUpdated = FALSE;
	stats->mpdStatsUpdated = FALSE;
}
Beispiel #3
0
void
updatePtpEngineStats (PtpClock* ptpClock, RunTimeOpts* rtOpts)
{

                        DBG("Refreshing slave engine stats counters\n");
                        ptpClock->slaveStats.owdMean = ptpClock->slaveStats.owdStats.meanContainer.mean;
                        ptpClock->slaveStats.owdStdDev = ptpClock->slaveStats.owdStats.stdDev;
                        ptpClock->slaveStats.ofmMean = ptpClock->slaveStats.ofmStats.meanContainer.mean;
                        ptpClock->slaveStats.ofmStdDev = ptpClock->slaveStats.ofmStats.stdDev;
                        ptpClock->slaveStats.statsCalculated = TRUE;
                        ptpClock->servo.driftMean = ptpClock->servo.driftStats.meanContainer.mean;
                        ptpClock->servo.driftStdDev = ptpClock->servo.driftStats.stdDev;
                        ptpClock->servo.statsCalculated = TRUE;
			/* Handle the calibration delay - x periods of stats updates until servo starts */
			if(rtOpts->calibrationDelay) {
				++ptpClock->statsUpdates;
				if(!ptpClock->isCalibrated && ptpClock->statsUpdates >= rtOpts->calibrationDelay) {
				    NOTICE("PTP engine now calibrated - enabling clock control\n");
				    ptpClock->isCalibrated = TRUE;
				    ptpClock->statsUpdates = 0;
				}
			}
	if( (rtOpts->calibrationDelay == 0) || ptpClock->isCalibrated )
	if(rtOpts->servoStabilityDetection) {
                ++ptpClock->servo.updateCount;
                        if ( !ptpClock->servo.runningMaxOutput && (ptpClock->servo.driftStdDev <= ptpClock->servo.stabilityThreshold))  {
                            /* Only update the stable period counter if we received some Sync messages since last update */
                            if(ptpClock->lastSyncCounter > 0) {

                                if((ptpClock->counters.syncMessagesReceived - ptpClock->lastSyncCounter) == 0)
                                    ptpClock->servo.stableCount = 0;
                                else
                                    ++ptpClock->servo.stableCount;
                            } else
                            ++ptpClock->servo.stableCount;
                            ptpClock->lastSyncCounter = ptpClock->counters.syncMessagesReceived;
                        } else
                            ptpClock->servo.stableCount = 0;

                        /* Servo considered stable - drift std dev below threshold for n measurements - saving drift*/
                        if(ptpClock->servo.stableCount >= ptpClock->servo.stabilityPeriod) {
                                if(!ptpClock->servo.isStable) {
                                        NOTICE("Clock servo now stable - took %d seconds\n",
                                                rtOpts->statsUpdateInterval * ptpClock->servo.updateCount);
#ifdef HAVE_SYS_TIMEX_H
                                        saveDrift(ptpClock, rtOpts, FALSE);
#endif /* HAVE_SYS_TIMEX_H */
                                } else {
#ifdef HAVE_SYS_TIMEX_H
                                       saveDrift(ptpClock, rtOpts, TRUE);
#endif /* HAVE_SYS_TIMEX_H */
                                }
                                ptpClock->servo.isStable = TRUE;
                                ptpClock->servo.stableCount = 0;
                                ptpClock->servo.updateCount = 0;
                        } else if(ptpClock->servo.updateCount >= ptpClock->servo.stabilityTimeout) {
                                ptpClock->servo.stableCount = 0;
                                ptpClock->servo.updateCount = 0;
                                if(!ptpClock->servo.isStable) {
                                        if(ptpClock->servo.runningMaxOutput) {
                                        WARNING("Clock servo not stable after %d seconds - running at maximum rate.\n", rtOpts->statsUpdateInterval * ptpClock->servo.stabilityTimeout);
                                        } else {
                                        WARNING("Clock servo not stable after %d seconds since last check. Saving current observed drift.\n", rtOpts->statsUpdateInterval * ptpClock->servo.stabilityTimeout);
#ifdef HAVE_SYS_TIMEX_H
                                        saveDrift(ptpClock, rtOpts, FALSE);
#endif /* HAVE_SYS_TIMEX_H */
                                        }
                                } else {
                                        WARNING("Clock servo no longer stable\n");
                                        ptpClock->servo.isStable = FALSE;
                                }
                        }
			}

                        DBG("servo stablecount: %d\n",ptpClock->servo.stableCount);

                        resetDoublePermanentStdDev(&ptpClock->slaveStats.owdStats);
                        resetDoublePermanentStdDev(&ptpClock->slaveStats.ofmStats);
                        resetDoublePermanentStdDev(&ptpClock->servo.driftStats);

}