Method calcW

fbclock/daemon/daemon.go:273–332

()

	s.stats.SetCounter("master_offset_ns.60.abs_max", 0)
	s.stats.SetCounter("path_delay_ns.60.abs_max", 0)
	s.stats.SetCounter("freq_adj_ppb.60.abs_max", 0)
	return s, nil
}

func (s *Daemon) calcW() (float64, error) {
	lastN := s.state.takeDataPoint(s.cfg.RingSize)
	params := prepareMathParameters(lastN)
	logSample := &LogSample{
		MasterOffsetNS:          params["offset"][0],
		MasterOffsetMeanNS:      mean(params["offset"]),
		MasterOffsetStddevNS:    stddev(params["offset"]),
		PathDelayNS:             params["delay"][0],
		PathDelayMeanNS:         mean(params["delay"]),
		PathDelayStddevNS:       stddev(params["delay"]),
		FreqAdjustmentPPB:       params["freq"][0],
		FreqAdjustmentMeanPPB:   mean(params["freq"]),
		FreqAdjustmentStddevPPB: stddev(params["freq"]),
		ClockAccuracyMean:       mean(params["clockaccuracy"]),
	}
	mRaw, err := s.cfg.Math.mExpr.Evaluate(mapOfInterface(params))
	if err != nil {
		return 0, err
	}
	m := mRaw.(float64)
	logSample.MeasurementNS = m
	s.stats.SetCounter("m_ns", int64(m))

	// push m to ring buffer
	s.state.pushM(m)

	ms := s.state.takeM(s.cfg.RingSize)
	minN := s.cfg.RingSize
	if s.cfg.GradualWindow {
		// Publish from n=2 (skip n=1: stddev is 0). len(ms) <= RingSize, so flag-off keeps today's gate.
		minN = 2
	}
	if len(ms) < minN {
		return 0, fmt.Errorf("%w getting W: want >= %d, got %d", errNotEnoughData, minN, len(ms))
	}

	n := len(ms)
	// k is the precomputed factor for this sample count: coverageZP (4.0) at the full ring, so steady
	// state and the flag-off path stay byte-identical. n and k are always injected; govaluate ignores
	// vars a formula does not reference.
	parameters := map[string]any{
		"m": ms,
		"n": float64(n),
		"k": s.cfg.gradualFactor(n),
	}
	logSample.MeasurementMeanNS = mean(ms)
	logSample.MeasurementStddevNS = stddev(ms)

	wRaw, err := s.cfg.Math.wExpr.Evaluate(parameters)
	if err != nil {
		return 0, err
	}
	w := wRaw.(float64)
	logSample.WindowNS = w