faraphel/chrony
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

util: modify UTI_*ToDouble functions to return double directly

Browse source
This commit is contained in:
Miroslav Lichvar 2016-08-18 12:10:09 +02:00
parent 99cc94529d
commit cfe706f032
19 changed files with 67 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
keys.c
View file

@ -113,7 +113,7 @@ determine_hash_delay(uint32_t key_id)
(unsigned char *)&pkt.auth_data, sizeof (pkt.auth_data)); (unsigned char *)&pkt.auth_data, sizeof (pkt.auth_data));
LCL_ReadRawTime(&after); LCL_ReadRawTime(&after);
UTI_DiffTimespecsToDouble(&diff, &after, &before); diff = UTI_DiffTimespecsToDouble(&after, &before);
if (i == 0 || min_diff > diff) if (i == 0 || min_diff > diff)
min_diff = diff; min_diff = diff;

6
manual.c
View file

@ -110,7 +110,7 @@ estimate_and_set_system(struct timespec *now, int offset_provided, double offset
if (n_samples > 1) { if (n_samples > 1) {
for (i=0; i<n_samples; i++) { for (i=0; i<n_samples; i++) {
UTI_DiffTimespecsToDouble(&agos[i], &samples[n_samples - 1].when, &samples[i].when); agos[i] = UTI_DiffTimespecsToDouble(&samples[n_samples - 1].when, &samples[i].when);
offsets[i] = samples[i].offset; offsets[i] = samples[i].offset;
} }
@ -189,12 +189,12 @@ MNL_AcceptTimestamp(struct timespec *ts, long *offset_cs, double *dfreq_ppm, dou
return 0; return 0;
if (n_samples) { if (n_samples) {
UTI_DiffTimespecsToDouble(&diff, &now, &samples[n_samples - 1].when); diff = UTI_DiffTimespecsToDouble(&now, &samples[n_samples - 1].when);
if (diff < MIN_SAMPLE_SEPARATION) if (diff < MIN_SAMPLE_SEPARATION)
return 0; return 0;
} }
UTI_DiffTimespecsToDouble(&offset, &now, ts); offset = UTI_DiffTimespecsToDouble(&now, ts);
/* Check if buffer full up */ /* Check if buffer full up */
if (n_samples == MAX_SAMPLES) { if (n_samples == MAX_SAMPLES) {

4
ntp_core.c
View file

@ -398,7 +398,7 @@ start_initial_timeout(NCR_Instance inst)
the interval between packets at least as long as the current polling the interval between packets at least as long as the current polling
interval */ interval */
SCH_GetLastEventTime(&now, NULL, NULL); SCH_GetLastEventTime(&now, NULL, NULL);
UTI_DiffTimespecsToDouble(&last_tx, &now, &inst->local_tx); last_tx = UTI_DiffTimespecsToDouble(&now, &inst->local_tx);
if (last_tx < 0.0) if (last_tx < 0.0)
last_tx = 0.0; last_tx = 0.0;
delay = get_transmit_delay(inst, 0, 0.0) - last_tx; delay = get_transmit_delay(inst, 0, 0.0) - last_tx;
@ -1346,7 +1346,7 @@ receive_packet(NTP_Packet *message, struct timespec *now, double now_err, NCR_In
/* Calculate offset. Following the NTP definition, this is negative /* Calculate offset. Following the NTP definition, this is negative
if we are fast of the remote source. */ if we are fast of the remote source. */
UTI_DiffTimespecsToDouble(&offset, &remote_average, &local_average); offset = UTI_DiffTimespecsToDouble(&remote_average, &local_average);
/* Apply configured correction */ /* Apply configured correction */
offset += inst->offset_correction; offset += inst->offset_correction;

2
ntp_signd.c
View file

@ -186,7 +186,7 @@ process_response(SignInstance *inst)
} }
SCH_GetLastEventTime(NULL, NULL, &ts); SCH_GetLastEventTime(NULL, NULL, &ts);
UTI_DiffTimespecsToDouble(&delay, &ts, &inst->request_ts); delay = UTI_DiffTimespecsToDouble(&ts, &inst->request_ts);
DEBUG_LOG(LOGF_NtpSignd, "Signing succeeded (delay %f)", delay); DEBUG_LOG(LOGF_NtpSignd, "Signing succeeded (delay %f)", delay);

2
ntp_sources.c
View file

@ -702,7 +702,7 @@ NSR_HandleBadSource(IPAddr *address)
/* Don't resolve names too frequently */ /* Don't resolve names too frequently */
SCH_GetLastEventTime(NULL, NULL, &now); SCH_GetLastEventTime(NULL, NULL, &now);
UTI_DiffTimespecsToDouble(&diff, &now, &last_replacement); diff = UTI_DiffTimespecsToDouble(&now, &last_replacement);
if (fabs(diff) < RESOLVE_INTERVAL_UNIT * (1 << MIN_REPLACEMENT_INTERVAL)) { if (fabs(diff) < RESOLVE_INTERVAL_UNIT * (1 << MIN_REPLACEMENT_INTERVAL)) {
DEBUG_LOG(LOGF_NtpSources, "replacement postponed"); DEBUG_LOG(LOGF_NtpSources, "replacement postponed");
return; return;

6
refclock.c
View file

@ -442,7 +442,7 @@ RCL_AddPulse(RCL_Instance instance, struct timespec *pulse_time, double second)
ref_dispersion += filter_get_avg_sample_dispersion(&lock_refclock->filter); ref_dispersion += filter_get_avg_sample_dispersion(&lock_refclock->filter);
UTI_DiffTimespecsToDouble(&sample_diff, &cooked_time, &ref_sample_time); sample_diff = UTI_DiffTimespecsToDouble(&cooked_time, &ref_sample_time);
if (fabs(sample_diff) >= 2.0 / rate) { if (fabs(sample_diff) >= 2.0 / rate) {
DEBUG_LOG(LOGF_Refclock, "refclock pulse ignored samplediff=%.9f", DEBUG_LOG(LOGF_Refclock, "refclock pulse ignored samplediff=%.9f",
sample_diff); sample_diff);
@ -509,7 +509,7 @@ valid_sample_time(RCL_Instance instance, struct timespec *ts)
double diff; double diff;
LCL_ReadRawTime(&raw_time); LCL_ReadRawTime(&raw_time);
UTI_DiffTimespecsToDouble(&diff, &raw_time, ts); diff = UTI_DiffTimespecsToDouble(&raw_time, ts);
if (diff < 0.0 || diff > UTI_Log2ToDouble(instance->poll + 1)) { if (diff < 0.0 || diff > UTI_Log2ToDouble(instance->poll + 1)) {
DEBUG_LOG(LOGF_Refclock, "%s refclock sample not valid age=%.6f ts=%s", DEBUG_LOG(LOGF_Refclock, "%s refclock sample not valid age=%.6f ts=%s",
UTI_RefidToString(instance->ref_id), diff, UTI_TimespecToString(ts)); UTI_RefidToString(instance->ref_id), diff, UTI_TimespecToString(ts));
@ -838,7 +838,7 @@ filter_get_sample(struct MedianFilter *filter, struct timespec *sample_time, dou
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
s = &filter->samples[filter->selected[i]]; s = &filter->samples[filter->selected[i]];
UTI_DiffTimespecsToDouble(&filter->x_data[i], &s->sample_time, &ls->sample_time); filter->x_data[i] = UTI_DiffTimespecsToDouble(&s->sample_time, &ls->sample_time);
filter->y_data[i] = s->offset; filter->y_data[i] = s->offset;
filter->w_data[i] = s->dispersion; filter->w_data[i] = s->dispersion;
} }

6
refclock_phc.c
View file

@ -157,7 +157,7 @@ static int phc_poll(RCL_Instance instance)
/* Find the fastest reading */ /* Find the fastest reading */
for (i = 0; i < NUM_READINGS; i++) { for (i = 0; i < NUM_READINGS; i++) {
UTI_DiffTimespecsToDouble(&delay, &readings[i].sys_ts2, &readings[i].sys_ts1); delay = UTI_DiffTimespecsToDouble(&readings[i].sys_ts2, &readings[i].sys_ts1);
if (!i || best_delay > delay) { if (!i || best_delay > delay) {
best = i; best = i;
@ -165,8 +165,8 @@ static int phc_poll(RCL_Instance instance)
} }
} }
UTI_DiffTimespecsToDouble(&offset, &readings[best].phc_ts, &readings[best].sys_ts2); offset = UTI_DiffTimespecsToDouble(&readings[best].phc_ts, &readings[best].sys_ts2) +
offset += best_delay / 2.0; best_delay / 2.0;
DEBUG_LOG(LOGF_Refclock, "PHC offset: %+.9f delay: %.9f", offset, best_delay); DEBUG_LOG(LOGF_Refclock, "PHC offset: %+.9f delay: %.9f", offset, best_delay);

2
refclock_shm.c
View file

@ -121,7 +121,7 @@ static int shm_poll(RCL_Instance instance)
UTI_NormaliseTimespec(&clock_ts); UTI_NormaliseTimespec(&clock_ts);
UTI_NormaliseTimespec(&receive_ts); UTI_NormaliseTimespec(&receive_ts);
UTI_DiffTimespecsToDouble(&offset, &clock_ts, &receive_ts); offset = UTI_DiffTimespecsToDouble(&clock_ts, &receive_ts);
return RCL_AddSample(instance, &receive_ts, offset, t.leap); return RCL_AddSample(instance, &receive_ts, offset, t.leap);
} }

8
reference.c
View file

@ -475,7 +475,7 @@ schedule_fb_drift(struct timespec *now)
if (fb_drift_timeout_id) if (fb_drift_timeout_id)
return; /* already scheduled */ return; /* already scheduled */
UTI_DiffTimespecsToDouble(&unsynchronised, now, &last_ref_update); unsynchronised = UTI_DiffTimespecsToDouble(now, &last_ref_update);
for (c = secs = 0, i = fb_drift_min; i <= fb_drift_max; i++) { for (c = secs = 0, i = fb_drift_min; i <= fb_drift_max; i++) {
secs = 1 << i; secs = 1 << i;
@ -936,7 +936,7 @@ REF_SetReference(int stratum,
LCL_GetOffsetCorrection(&raw_now, &uncorrected_offset, NULL); LCL_GetOffsetCorrection(&raw_now, &uncorrected_offset, NULL);
UTI_AddDoubleToTimespec(&raw_now, uncorrected_offset, &now); UTI_AddDoubleToTimespec(&raw_now, uncorrected_offset, &now);
UTI_DiffTimespecsToDouble(&elapsed, &now, ref_time); elapsed = UTI_DiffTimespecsToDouble(&now, ref_time);
our_offset = offset + elapsed * frequency; our_offset = offset + elapsed * frequency;
if (!is_offset_ok(our_offset)) if (!is_offset_ok(our_offset))
@ -954,7 +954,7 @@ REF_SetReference(int stratum,
our_root_dispersion = root_dispersion; our_root_dispersion = root_dispersion;
if (last_ref_update.tv_sec) { if (last_ref_update.tv_sec) {
UTI_DiffTimespecsToDouble(&update_interval, &now, &last_ref_update); update_interval = UTI_DiffTimespecsToDouble(&now, &last_ref_update);
if (update_interval < 0.0) if (update_interval < 0.0)
update_interval = 0.0; update_interval = 0.0;
} else { } else {
@ -1162,7 +1162,7 @@ REF_GetReferenceParams
assert(initialised); assert(initialised);
if (are_we_synchronised) { if (are_we_synchronised) {
UTI_DiffTimespecsToDouble(&elapsed, local_time, &our_ref_time); elapsed = UTI_DiffTimespecsToDouble(local_time, &our_ref_time);
dispersion = our_root_dispersion + dispersion = our_root_dispersion +
(our_skew + fabs(our_residual_freq) + LCL_GetMaxClockError()) * elapsed; (our_skew + fabs(our_residual_freq) + LCL_GetMaxClockError()) * elapsed;
} else { } else {

2
rtc_linux.c
View file

@ -1040,7 +1040,7 @@ RTC_Linux_TimePreInit(time_t driftfile_time)
return 0; return 0;
} }
UTI_DiffTimespecsToDouble(&sys_offset, &old_sys_time, &new_sys_time); sys_offset = UTI_DiffTimespecsToDouble(&old_sys_time, &new_sys_time);
/* Set system time only if the step is larger than 1 second */ /* Set system time only if the step is larger than 1 second */
if (fabs(sys_offset) >= 1.0) { if (fabs(sys_offset) >= 1.0) {

10
sched.c
View file

@ -387,7 +387,7 @@ SCH_AddTimeoutInClass(double min_delay, double separation, double randomness,
new_min_delay = min_delay; new_min_delay = min_delay;
/* Check the separation from the last dispatched timeout */ /* Check the separation from the last dispatched timeout */
UTI_DiffTimespecsToDouble(&diff, &now, &last_class_dispatch[class]); diff = UTI_DiffTimespecsToDouble(&now, &last_class_dispatch[class]);
if (diff < separation && diff >= 0.0 && diff + new_min_delay < separation) { if (diff < separation && diff >= 0.0 && diff + new_min_delay < separation) {
new_min_delay = separation - diff; new_min_delay = separation - diff;
} }
@ -396,7 +396,7 @@ SCH_AddTimeoutInClass(double min_delay, double separation, double randomness,
if necessary to keep at least the separation away */ if necessary to keep at least the separation away */
for (ptr = timer_queue.next; ptr != &timer_queue; ptr = ptr->next) { for (ptr = timer_queue.next; ptr != &timer_queue; ptr = ptr->next) {
if (ptr->class == class) { if (ptr->class == class) {
UTI_DiffTimespecsToDouble(&diff, &ptr->ts, &now); diff = UTI_DiffTimespecsToDouble(&ptr->ts, &now);
if (new_min_delay > diff) { if (new_min_delay > diff) {
if (new_min_delay - diff < separation) { if (new_min_delay - diff < separation) {
new_min_delay = diff + separation; new_min_delay = diff + separation;
@ -410,7 +410,7 @@ SCH_AddTimeoutInClass(double min_delay, double separation, double randomness,
} }
for (ptr = timer_queue.next; ptr != &timer_queue; ptr = ptr->next) { for (ptr = timer_queue.next; ptr != &timer_queue; ptr = ptr->next) {
UTI_DiffTimespecsToDouble(&diff, &ptr->ts, &now); diff = UTI_DiffTimespecsToDouble(&ptr->ts, &now);
if (diff > new_min_delay) { if (diff > new_min_delay) {
break; break;
} }
@ -665,8 +665,8 @@ check_current_time(struct timespec *prev_raw, struct timespec *raw, int timeout,
return 1; return 1;
} }
UTI_DiffTimespecsToDouble(&step, &last_select_ts_raw, raw); step = UTI_DiffTimespecsToDouble(&last_select_ts_raw, raw);
UTI_TimespecToDouble(&elapsed_min, &elapsed); elapsed = UTI_TimespecToDouble(&elapsed_min);
step += elapsed; step += elapsed;
/* Cooked time may no longer be valid after dispatching the handlers */ /* Cooked time may no longer be valid after dispatching the handlers */

4
smooth.c
View file

@ -103,7 +103,7 @@ get_smoothing(struct timespec *now, double *poffset, double *pfreq,
double elapsed, length, offset, freq, wander; double elapsed, length, offset, freq, wander;
int i; int i;
UTI_DiffTimespecsToDouble(&elapsed, now, &last_update); elapsed = UTI_DiffTimespecsToDouble(now, &last_update);
offset = smooth_offset; offset = smooth_offset;
freq = smooth_freq; freq = smooth_freq;
@ -327,7 +327,7 @@ SMT_GetSmoothingReport(RPT_SmoothingReport *report, struct timespec *now)
report->freq_ppm *= -1.0e6; report->freq_ppm *= -1.0e6;
report->wander_ppm *= -1.0e6; report->wander_ppm *= -1.0e6;
UTI_DiffTimespecsToDouble(&elapsed, now, &last_update); elapsed = UTI_DiffTimespecsToDouble(now, &last_update);
if (!locked && elapsed >= 0.0) { if (!locked && elapsed >= 0.0) {
for (i = 0, length = 0.0; i < NUM_STAGES; i++) for (i = 0, length = 0.0; i < NUM_STAGES; i++)
length += stages[i].length; length += stages[i].length;

2
sources.c
View file

@ -564,7 +564,7 @@ combine_sources(int n_sel_sources, struct timespec *ref_time, double *offset,
if (sources[index]->status == SRC_OK) if (sources[index]->status == SRC_OK)
sources[index]->status = SRC_UNSELECTED; sources[index]->status = SRC_UNSELECTED;
UTI_DiffTimespecsToDouble(&elapsed, ref_time, &src_ref_time); elapsed = UTI_DiffTimespecsToDouble(ref_time, &src_ref_time);
src_offset += elapsed * src_frequency; src_offset += elapsed * src_frequency;
offset_weight = 1.0 / sources[index]->sel_info.root_distance; offset_weight = 1.0 / sources[index]->sel_info.root_distance;
frequency_weight = 1.0 / src_skew; frequency_weight = 1.0 / src_skew;

23
sourcestats.c
View file

@ -350,8 +350,7 @@ convert_to_intervals(SST_Stats inst, double *times_back)
ts = &inst->sample_times[inst->last_sample]; ts = &inst->sample_times[inst->last_sample];
for (i = -inst->runs_samples; i < inst->n_samples; i++) { for (i = -inst->runs_samples; i < inst->n_samples; i++) {
/* The entries in times_back[] should end up negative */ /* The entries in times_back[] should end up negative */
UTI_DiffTimespecsToDouble(&times_back[i], times_back[i] = UTI_DiffTimespecsToDouble(&inst->sample_times[get_runsbuf_index(inst, i)], ts);
&inst->sample_times[get_runsbuf_index(inst, i)], ts);
} }
} }
@ -624,7 +623,7 @@ SST_GetSelectionData(SST_Stats inst, struct timespec *now,
*stratum = inst->strata[get_buf_index(inst, inst->n_samples - 1)]; *stratum = inst->strata[get_buf_index(inst, inst->n_samples - 1)];
*variance = inst->variance; *variance = inst->variance;
UTI_DiffTimespecsToDouble(&sample_elapsed, now, &inst->sample_times[i]); sample_elapsed = UTI_DiffTimespecsToDouble(now, &inst->sample_times[i]);
offset = inst->offsets[i] + sample_elapsed * inst->estimated_frequency; offset = inst->offsets[i] + sample_elapsed * inst->estimated_frequency;
*root_distance = 0.5 * inst->root_delays[j] + *root_distance = 0.5 * inst->root_delays[j] +
inst->root_dispersions[j] + sample_elapsed * inst->skew; inst->root_dispersions[j] + sample_elapsed * inst->skew;
@ -636,7 +635,7 @@ SST_GetSelectionData(SST_Stats inst, struct timespec *now,
double average_offset, elapsed; double average_offset, elapsed;
int average_ok; int average_ok;
/* average_ok ignored for now */ /* average_ok ignored for now */
UTI_DiffTimespecsToDouble(&elapsed, now, &(inst->offset_time)); elapsed = UTI_DiffTimespecsToDouble(now, &inst->offset_time);
average_offset = inst->estimated_offset + inst->estimated_frequency * elapsed; average_offset = inst->estimated_offset + inst->estimated_frequency * elapsed;
if (fabs(average_offset - offset) <= if (fabs(average_offset - offset) <=
inst->peer_dispersions[j] + 0.5 * inst->peer_delays[i]) { inst->peer_dispersions[j] + 0.5 * inst->peer_delays[i]) {
@ -647,9 +646,9 @@ SST_GetSelectionData(SST_Stats inst, struct timespec *now,
#endif #endif
i = get_runsbuf_index(inst, 0); i = get_runsbuf_index(inst, 0);
UTI_DiffTimespecsToDouble(first_sample_ago, now, &inst->sample_times[i]); *first_sample_ago = UTI_DiffTimespecsToDouble(now, &inst->sample_times[i]);
i = get_runsbuf_index(inst, inst->n_samples - 1); i = get_runsbuf_index(inst, inst->n_samples - 1);
UTI_DiffTimespecsToDouble(last_sample_ago, now, &inst->sample_times[i]); *last_sample_ago = UTI_DiffTimespecsToDouble(now, &inst->sample_times[i]);
*select_ok = inst->regression_ok; *select_ok = inst->regression_ok;
@ -681,7 +680,7 @@ SST_GetTrackingData(SST_Stats inst, struct timespec *ref_time,
*skew = inst->skew; *skew = inst->skew;
*root_delay = inst->root_delays[j]; *root_delay = inst->root_delays[j];
UTI_DiffTimespecsToDouble(&elapsed_sample, &inst->offset_time, &inst->sample_times[i]); elapsed_sample = UTI_DiffTimespecsToDouble(&inst->offset_time, &inst->sample_times[i]);
*root_dispersion = inst->root_dispersions[j] + inst->skew * elapsed_sample; *root_dispersion = inst->root_dispersions[j] + inst->skew * elapsed_sample;
DEBUG_LOG(LOGF_SourceStats, "n=%d freq=%f (%.3fppm) skew=%f (%.3fppm) avoff=%f offsd=%f disp=%f", DEBUG_LOG(LOGF_SourceStats, "n=%d freq=%f (%.3fppm) skew=%f (%.3fppm) avoff=%f offsd=%f disp=%f",
@ -757,7 +756,7 @@ SST_PredictOffset(SST_Stats inst, struct timespec *when)
return 0.0; return 0.0;
} }
} else { } else {
UTI_DiffTimespecsToDouble(&elapsed, when, &inst->offset_time); elapsed = UTI_DiffTimespecsToDouble(when, &inst->offset_time);
return inst->estimated_offset + elapsed * inst->estimated_frequency; return inst->estimated_offset + elapsed * inst->estimated_frequency;
} }
@ -784,7 +783,7 @@ SST_IsGoodSample(SST_Stats inst, double offset, double delay,
if (inst->n_samples < 3) if (inst->n_samples < 3)
return 1; return 1;
UTI_DiffTimespecsToDouble(&elapsed, when, &inst->offset_time); elapsed = UTI_DiffTimespecsToDouble(when, &inst->offset_time);
/* Require that the ratio of the increase in delay from the minimum to the /* Require that the ratio of the increase in delay from the minimum to the
standard deviation is less than max_delay_dev_ratio. In the allowed standard deviation is less than max_delay_dev_ratio. In the allowed
@ -953,15 +952,15 @@ SST_DoSourcestatsReport(SST_Stats inst, RPT_SourcestatsReport *report, struct ti
if (inst->n_samples > 1) { if (inst->n_samples > 1) {
li = get_runsbuf_index(inst, inst->n_samples - 1); li = get_runsbuf_index(inst, inst->n_samples - 1);
lj = get_buf_index(inst, inst->n_samples - 1); lj = get_buf_index(inst, inst->n_samples - 1);
UTI_DiffTimespecsToDouble(&dspan, &inst->sample_times[li], dspan = UTI_DiffTimespecsToDouble(&inst->sample_times[li],
&inst->sample_times[get_runsbuf_index(inst, 0)]); &inst->sample_times[get_runsbuf_index(inst, 0)]);
report->span_seconds = (unsigned long) (dspan + 0.5); report->span_seconds = (unsigned long) (dspan + 0.5);
if (inst->n_samples > 3) { if (inst->n_samples > 3) {
UTI_DiffTimespecsToDouble(&elapsed, now, &inst->offset_time); elapsed = UTI_DiffTimespecsToDouble(now, &inst->offset_time);
bi = get_runsbuf_index(inst, inst->best_single_sample); bi = get_runsbuf_index(inst, inst->best_single_sample);
bj = get_buf_index(inst, inst->best_single_sample); bj = get_buf_index(inst, inst->best_single_sample);
UTI_DiffTimespecsToDouble(&sample_elapsed, now, &inst->sample_times[bi]); sample_elapsed = UTI_DiffTimespecsToDouble(now, &inst->sample_times[bi]);
report->est_offset = inst->estimated_offset + elapsed * inst->estimated_frequency; report->est_offset = inst->estimated_offset + elapsed * inst->estimated_frequency;
report->est_offset_err = (inst->estimated_offset_sd + report->est_offset_err = (inst->estimated_offset_sd +
sample_elapsed * inst->skew + sample_elapsed * inst->skew +

6
sys_generic.c
View file

@ -178,7 +178,7 @@ update_slew(void)
LCL_ReadRawTime(&now); LCL_ReadRawTime(&now);
/* Adjust the offset register by achieved slew */ /* Adjust the offset register by achieved slew */
UTI_DiffTimespecsToDouble(&duration, &now, &slew_start); duration = UTI_DiffTimespecsToDouble(&now, &slew_start);
offset_register -= slew_freq * duration; offset_register -= slew_freq * duration;
stop_fastslew(&now); stop_fastslew(&now);
@ -299,7 +299,7 @@ offset_convert(struct timespec *raw,
{ {
double duration, fastslew_corr, fastslew_err; double duration, fastslew_corr, fastslew_err;
UTI_DiffTimespecsToDouble(&duration, raw, &slew_start); duration = UTI_DiffTimespecsToDouble(raw, &slew_start);
if (drv_get_offset_correction && fastslew_active) { if (drv_get_offset_correction && fastslew_active) {
drv_get_offset_correction(raw, &fastslew_corr, &fastslew_err); drv_get_offset_correction(raw, &fastslew_corr, &fastslew_err);
@ -338,7 +338,7 @@ apply_step_offset(double offset)
} }
LCL_ReadRawTime(&old_time); LCL_ReadRawTime(&old_time);
UTI_DiffTimespecsToDouble(&err, &old_time, &new_time); err = UTI_DiffTimespecsToDouble(&old_time, &new_time);
lcl_InvokeDispersionNotifyHandlers(fabs(err)); lcl_InvokeDispersionNotifyHandlers(fabs(err));

14
sys_macosx.c
View file

@ -143,10 +143,10 @@ start_adjust(void)
/* Determine the amount of error built up since the last adjustment */ /* Determine the amount of error built up since the last adjustment */
LCL_ReadRawTime(&T1); LCL_ReadRawTime(&T1);
UTI_DiffTimespecsToDouble(&elapsed, &T1, &T0); elapsed = UTI_DiffTimespecsToDouble(&T1, &T0);
accrued_error = elapsed * current_freq; accrued_error = elapsed * current_freq;
UTI_DiffTimespecsToDouble(&drift_removal_elapsed, &T1, &Tdrift); drift_removal_elapsed = UTI_DiffTimespecsToDouble(&T1, &Tdrift);
/* To allow for the clock being stepped either forward or backwards, clamp /* To allow for the clock being stepped either forward or backwards, clamp
the elapsed time to bounds [ 0.0, current_drift_removal_interval ] */ the elapsed time to bounds [ 0.0, current_drift_removal_interval ] */
@ -162,14 +162,14 @@ start_adjust(void)
adjust_required = - (accrued_error + offset_register + predicted_error); adjust_required = - (accrued_error + offset_register + predicted_error);
UTI_DoubleToTimeval(adjust_required, &newadj); UTI_DoubleToTimeval(adjust_required, &newadj);
UTI_TimevalToDouble(&newadj, &adjustment_requested); adjustment_requested = UTI_TimevalToDouble(&newadj);
rounding_error = adjust_required - adjustment_requested; rounding_error = adjust_required - adjustment_requested;
if (PRV_AdjustTime(&newadj, &oldadj) < 0) { if (PRV_AdjustTime(&newadj, &oldadj) < 0) {
LOG_FATAL(LOGF_SysMacOSX, "adjtime() failed"); LOG_FATAL(LOGF_SysMacOSX, "adjtime() failed");
} }
UTI_TimevalToDouble(&oldadj, &old_adjust_remaining); old_adjust_remaining = UTI_TimevalToDouble(&oldadj);
offset_register = rounding_error - old_adjust_remaining - predicted_error; offset_register = rounding_error - old_adjust_remaining - predicted_error;
@ -195,8 +195,8 @@ stop_adjust(void)
LCL_ReadRawTime(&T1); LCL_ReadRawTime(&T1);
UTI_DiffTimespecsToDouble(&elapsed, &T1, &T0); elapsed = UTI_DiffTimespecsToDouble(&T1, &T0);
UTI_TimevalToDouble(&remadj, &adjustment_remaining); adjustment_remaining = UTI_TimevalToDouble(&remadj);
adjustment_achieved = adjustment_requested - adjustment_remaining; adjustment_achieved = adjustment_requested - adjustment_remaining;
elapsed_plus_adjust = elapsed - adjustment_achieved; elapsed_plus_adjust = elapsed - adjustment_achieved;
@ -333,7 +333,7 @@ set_sync_status(int synchronised, double est_error, double max_error)
double rtc_sync_elapsed; double rtc_sync_elapsed;
SCH_GetLastEventTime(NULL, NULL, &now); SCH_GetLastEventTime(NULL, NULL, &now);
UTI_DiffTimespecsToDouble(&rtc_sync_elapsed, &now, &last_rtc_sync); rtc_sync_elapsed = UTI_DiffTimespecsToDouble(&now, &last_rtc_sync);
if (fabs(rtc_sync_elapsed) >= RTC_SYNC_INTERVAL) { if (fabs(rtc_sync_elapsed) >= RTC_SYNC_INTERVAL) {
/* update the RTC by applying a step of 0.0 secs */ /* update the RTC by applying a step of 0.0 secs */
apply_step_offset(0.0); apply_step_offset(0.0);

4
sys_netbsd.c
View file

@ -68,7 +68,7 @@ accrue_offset(double offset, double corr_rate)
LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed"); LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed");
/* Add the old remaining adjustment if not zero */ /* Add the old remaining adjustment if not zero */
UTI_TimevalToDouble(&oldadj, &doldadj); doldadj = UTI_TimevalToDouble(&oldadj);
if (doldadj != 0.0) { if (doldadj != 0.0) {
UTI_DoubleToTimeval(-offset + doldadj, &newadj); UTI_DoubleToTimeval(-offset + doldadj, &newadj);
if (PRV_AdjustTime(&newadj, NULL) < 0) if (PRV_AdjustTime(&newadj, NULL) < 0)
@ -88,7 +88,7 @@ get_offset_correction(struct timespec *raw,
if (PRV_AdjustTime(NULL, &remadj) < 0) if (PRV_AdjustTime(NULL, &remadj) < 0)
LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed"); LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed");
UTI_TimevalToDouble(&remadj, &adjustment_remaining); adjustment_remaining = UTI_TimevalToDouble(&remadj);
*corr = adjustment_remaining; *corr = adjustment_remaining;
if (err) { if (err) {

28
util.c
View file

@ -65,10 +65,10 @@ UTI_TimespecToTimeval(struct timespec *ts, struct timeval *tv)
/* ================================================== */ /* ================================================== */
void double
UTI_TimespecToDouble(struct timespec *ts, double *d) UTI_TimespecToDouble(struct timespec *ts)
{ {
*d = ts->tv_sec + 1.0e-9 * ts->tv_nsec; return ts->tv_sec + 1.0e-9 * ts->tv_nsec;
} }
/* ================================================== */ /* ================================================== */
@ -100,11 +100,10 @@ UTI_NormaliseTimespec(struct timespec *ts)
/* ================================================== */ /* ================================================== */
void double
UTI_TimevalToDouble(struct timeval *a, double *b) UTI_TimevalToDouble(struct timeval *tv)
{ {
*b = (double)(a->tv_sec) + 1.0e-6 * (double)(a->tv_usec); return tv->tv_sec + 1.0e-6 * tv->tv_usec;
} }
/* ================================================== */ /* ================================================== */
@ -170,10 +169,10 @@ UTI_DiffTimespecs(struct timespec *result, struct timespec *a, struct timespec *
/* ================================================== */ /* ================================================== */
/* Calculate result = a - b and return as a double */ /* Calculate result = a - b and return as a double */
void double
UTI_DiffTimespecsToDouble(double *result, struct timespec *a, struct timespec *b) UTI_DiffTimespecsToDouble(struct timespec *a, struct timespec *b)
{ {
*result = (a->tv_sec - b->tv_sec) + 1.0e-9 * (a->tv_nsec - b->tv_nsec); return (a->tv_sec - b->tv_sec) + 1.0e-9 * (a->tv_nsec - b->tv_nsec);
} }
/* ================================================== */ /* ================================================== */
@ -196,7 +195,7 @@ void
UTI_AverageDiffTimespecs(struct timespec *earlier, struct timespec *later, UTI_AverageDiffTimespecs(struct timespec *earlier, struct timespec *later,
struct timespec *average, double *diff) struct timespec *average, double *diff)
{ {
UTI_DiffTimespecsToDouble(diff, later, earlier); *diff = UTI_DiffTimespecsToDouble(later, earlier);
UTI_AddDoubleToTimespec(earlier, *diff / 2.0, average); UTI_AddDoubleToTimespec(earlier, *diff / 2.0, average);
} }
@ -208,7 +207,7 @@ UTI_AddDiffToTimespec(struct timespec *a, struct timespec *b,
{ {
double diff; double diff;
UTI_DiffTimespecsToDouble(&diff, a, b); diff = UTI_DiffTimespecsToDouble(a, b);
UTI_AddDoubleToTimespec(c, diff, result); UTI_AddDoubleToTimespec(c, diff, result);
} }
@ -609,7 +608,7 @@ UTI_AdjustTimespec(struct timespec *old_ts, struct timespec *when, struct timesp
{ {
double elapsed; double elapsed;
UTI_DiffTimespecsToDouble(&elapsed, when, old_ts); elapsed = UTI_DiffTimespecsToDouble(when, old_ts);
*delta_time = elapsed * dfreq - doffset; *delta_time = elapsed * dfreq - doffset;
UTI_AddDoubleToTimespec(old_ts, *delta_time, new_ts); UTI_AddDoubleToTimespec(old_ts, *delta_time, new_ts);
} }
@ -742,8 +741,7 @@ UTI_IsTimeOffsetSane(struct timespec *ts, double offset)
if (!(offset > -MAX_OFFSET && offset < MAX_OFFSET)) if (!(offset > -MAX_OFFSET && offset < MAX_OFFSET))
return 0; return 0;
UTI_TimespecToDouble(ts, &t); t = UTI_TimespecToDouble(ts) + offset;
t += offset;
/* Time before 1970 is not considered valid */ /* Time before 1970 is not considered valid */
if (t < 0.0) if (t < 0.0)

6
util.h
View file

@ -44,7 +44,7 @@ extern void UTI_TimevalToTimespec(struct timeval *tv, struct timespec *ts);
extern void UTI_TimespecToTimeval(struct timespec *ts, struct timeval *tv); extern void UTI_TimespecToTimeval(struct timespec *ts, struct timeval *tv);
/* Convert a timespec into a floating point number of seconds */ /* Convert a timespec into a floating point number of seconds */
extern void UTI_TimespecToDouble(struct timespec *ts, double *d); extern double UTI_TimespecToDouble(struct timespec *ts);
/* Convert a number of seconds expressed in floating point into a /* Convert a number of seconds expressed in floating point into a
timespec */ timespec */
@ -55,7 +55,7 @@ extern void UTI_DoubleToTimespec(double d, struct timespec *ts);
extern void UTI_NormaliseTimespec(struct timespec *ts); extern void UTI_NormaliseTimespec(struct timespec *ts);
/* Convert a timeval into a floating point number of seconds */ /* Convert a timeval into a floating point number of seconds */
extern void UTI_TimevalToDouble(struct timeval *a, double *b); extern double UTI_TimevalToDouble(struct timeval *tv);
/* Convert a number of seconds expressed in floating point into a /* Convert a number of seconds expressed in floating point into a
timeval */ timeval */
@ -73,7 +73,7 @@ extern int UTI_CompareTimespecs(struct timespec *a, struct timespec *b);
extern void UTI_DiffTimespecs(struct timespec *result, struct timespec *a, struct timespec *b); extern void UTI_DiffTimespecs(struct timespec *result, struct timespec *a, struct timespec *b);
/* Calculate result = a - b and return as a double */ /* Calculate result = a - b and return as a double */
extern void UTI_DiffTimespecsToDouble(double *result, struct timespec *a, struct timespec *b); extern double UTI_DiffTimespecsToDouble(struct timespec *a, struct timespec *b);
/* Add a double increment to a timespec to get a new one. 'start' is /* Add a double increment to a timespec to get a new one. 'start' is
the starting time, 'end' is the result that we return. This is the starting time, 'end' is the result that we return. This is