/* ================================================== */
/* Structure used to hold info for selecting between sources */
struct SelectInfo {
- int stratum;
int select_ok;
double std_dev;
double root_distance;
struct SelectInfo sel_info;
- /* Latest leap status */
+ /* Current stratum */
+ int stratum;
+
+ /* Current leap status */
NTP_Leap leap;
/* Flag indicating the source has a leap second vote */
instance->distant = 0;
instance->status = SRC_BAD_STATS;
instance->sel_score = 1.0;
+ instance->stratum = 0;
instance->leap = LEAP_Unsynchronised;
instance->leap_vote = 0;
return;
}
+ inst->stratum = sample->stratum;
+
SST_AccumulateSample(inst->stats, sample);
SST_DoNewRegression(inst->stats);
}
}
si = &sources[i]->sel_info;
- SST_GetSelectionData(sources[i]->stats, &now, &si->stratum,
+ SST_GetSelectionData(sources[i]->stats, &now,
&si->lo_limit, &si->hi_limit, &si->root_distance,
&si->std_dev, &first_sample_ago,
&si->last_sample_ago, &si->select_ok);
source can settle down to a state where only one server is serving its
local unsychronised time and others are synchronised to it. */
- if (si->stratum >= orphan_stratum && sources[i]->type == SRC_NTP) {
+ if (sources[i]->stratum >= orphan_stratum && sources[i]->type == SRC_NTP) {
mark_source(sources[i], SRC_ORPHAN);
- if (si->stratum == orphan_stratum && sources[i]->reachability &&
+ if (sources[i]->stratum == orphan_stratum && sources[i]->reachability &&
(orphan_source == INVALID_SOURCE ||
sources[i]->ref_id < sources[orphan_source]->ref_id))
orphan_source = i;
/* Find minimum stratum */
index = sel_sources[0];
- min_stratum = sources[index]->sel_info.stratum;
+ min_stratum = sources[index]->stratum;
for (i = 1; i < n_sel_sources; i++) {
index = sel_sources[i];
- stratum = sources[index]->sel_info.stratum;
+ stratum = sources[index]->stratum;
if (stratum < min_stratum)
min_stratum = stratum;
}
if (selected_source_index != INVALID_SOURCE)
sel_src_distance = sources[selected_source_index]->sel_info.root_distance +
- (sources[selected_source_index]->sel_info.stratum - min_stratum) * stratum_weight;
+ (sources[selected_source_index]->stratum - min_stratum) * stratum_weight;
for (i = 0; i < n_sources; i++) {
/* Reset score for non-selectable sources */
}
distance = sources[i]->sel_info.root_distance +
- (sources[i]->sel_info.stratum - min_stratum) * stratum_weight;
+ (sources[i]->stratum - min_stratum) * stratum_weight;
if (sources[i]->type == SRC_NTP)
distance += reselect_distance;
combined = combine_sources(n_sel_sources, &ref_time, &src_offset, &src_offset_sd,
&src_frequency, &src_frequency_sd, &src_skew);
- REF_SetReference(sources[selected_source_index]->sel_info.stratum,
+ REF_SetReference(sources[selected_source_index]->stratum,
leap_status, combined,
sources[selected_source_index]->ref_id,
sources[selected_source_index]->ip_addr,
report->ip_addr.family = IPADDR_INET4;
}
+ report->stratum = src->stratum;
+
switch (src->status) {
case SRC_FALSETICKER:
report->state = RPT_FALSETICKER;
/* This array contains the root dispersions of each sample at the
time of the measurements */
double root_dispersions[MAX_SAMPLES];
-
- /* The stratum from the last accumulated sample */
- int stratum;
};
/* ================================================== */
inst->peer_dispersions[m] = sample->peer_dispersion;
inst->root_delays[m] = sample->root_delay;
inst->root_dispersions[m] = sample->root_dispersion;
- inst->stratum = sample->stratum;
if (inst->peer_delays[n] < inst->fixed_min_delay)
inst->peer_delays[n] = 2.0 * inst->fixed_min_delay - inst->peer_delays[n];
void
SST_GetSelectionData(SST_Stats inst, struct timespec *now,
- int *stratum,
double *offset_lo_limit,
double *offset_hi_limit,
double *root_distance,
i = get_runsbuf_index(inst, inst->best_single_sample);
j = get_buf_index(inst, inst->best_single_sample);
- *stratum = inst->stratum;
*std_dev = inst->std_dev;
sample_elapsed = fabs(UTI_DiffTimespecsToDouble(now, &inst->sample_times[i]));
inst->root_delays[j],
inst->root_dispersions[j],
1.0, /* used to be inst->weights[i] */
- inst->stratum /* used to be an array */);
+ 0 /* used to be an array of strata */);
}
int i;
char line[1024];
double weight;
+ int stratum;
SST_ResetInstance(inst);
&(inst->root_delays[i]),
&(inst->root_dispersions[i]),
&weight, /* not used anymore */
- &inst->stratum) != 10)) {
+ &stratum /* not used anymore */) != 10)) {
/* This is the branch taken if the read FAILED */
report->orig_latest_meas = inst->orig_offsets[j];
report->latest_meas = inst->offsets[i];
report->latest_meas_err = 0.5*inst->root_delays[j] + inst->root_dispersions[j];
- report->stratum = inst->stratum;
/* Align the sample time to reduce the leak of the receive timestamp */
last_sample_time = inst->sample_times[i];