Re^4: The most precise second (timer)

I think you led me to the right direction: nanosecond.

I used the following script and compared the results with the original code. When averaging differences of 100 seconds (each script), the original comes out a bit better, but when averaging diffs of 300 seconds, the new script is better.

use strict;
use warnings;
use Math::BigFloat;
use Time::HiRes qw(gettimeofday sleep nanosleep);

...

sub old_script {
    my $max = $_[0];
    my @time_test;
    my $start = time();
    for (my $i = 0; $i < $max; $i++) {
        $start += 1;
        sleep $start - time();
        $time_test[$i] = Math::BigFloat->new(sprintf("%d.%06d", gettim
+eofday));
    }
    return @time_test;
}

sub new_script {
    my $max = $_[0];
    my @time_test;
    for (my $i = 0; $i < $max; $i++) {
        nanosleep (1000000000);
        $time_test[$i] = Math::BigFloat->new(sprintf("%d.%06d", gettim
+eofday));
    }
    return @time_test;
}
[download]

The averages:

# 100 s each script
old_script_values_avg : 1.000479131313131313131313131313131313131
new_script_values_avg : 1.001016101010101010101010101010101010101

# 300 s each script
old_script_values_avg : 0.9974391538461538461538461538461538461538
new_script_values_avg : 1.000457983277591973244147157190635451505
[download]

I believe I cannot get better results without atomic clock. Correct me if I’m wrong.

Anyway, thanks for the help and your time!

Comment on Re^4: The most precise second (timer) Select or Download Code

Replies are listed 'Best First'.
Re^5: The most precise second (timer) by haukex (Archbishop) on Nov 27, 2019 at 23:29 UTC
`nanosleep (1000000000);` I think that with a fixed time like that, you'll probably still see a cumulative error if you run it for a longer time, I don't think 5 minutes is enough. However, I only now realized that I overlooked a solution that should have been staring me in the face: clock_nanosleep(2), which is also provided by Time::HiRes. Try running the following over a longer time (several hours): `use warnings; use strict; use Time::HiRes qw/ clock_gettime clock_nanosleep CLOCK_REALTIME TIMER_ABSTIME /; die "Don't have nanosleep" unless Time::HiRes::d_nanosleep(); my $run = 1; $SIG{INT} = sub { $run = 0 }; while ($run) { my $now_s = int(clock_gettime(CLOCK_REALTIME)); clock_nanosleep(CLOCK_REALTIME, ($now_s+1)*1e9, TIMER_ABSTIME); last unless $run; print clock_gettime(CLOCK_REALTIME), "\n"; }` [download]	[reply] [d/l] [select]
Re^6: The most precise second (timer) by tukusejssirs (Beadle) on Nov 28, 2019 at 11:33 UTC
Okay, I your point with the fixed times. I like the way you made the `clock_nanosleep(CLOCK_REALTIME, ($now_s+1)1e9, TIMER_ABSTIME);`. In short tests (like for 10-20 s), the average diff is always `1.00000000000000000000`, at least with the 5 decimal places the `clock_gettime(CLOCK_REALTIME)` outputs. Anyway, I am in the middle of 5 h run of the script; I’ll report the results when it is finished. Again, thanks for your time! Update:* I have found out (using `printf`) that ~~`0001511573791503906250`~~ `printf ("%.40f\n\n", clock_gettime(CLOCK_REALTIME));` outputs floats with 21 to 22 decimal places, therefore I’ll print the time out using `printf ("%.22f\n", clock_gettime(CLOCK_REALTIME));`. This might slow the execution of the script and thus the measurement won’t be that accurate. Or even worse: the extra time (decimal places) are only the time required to execute the extra stuff, I don’t know. Update 2: I have the results of the 5-hour run of your script. I have calculated the difference as follows, but my calculations might be wrong, therefore here is the list of 18,000 time values. Note that the machine was not running only this script, because the timer (periodic runner) won’t be run as the only program on the server in production. `average diff between times : +0.999999998888827179577276638156035915 +0171 average diff from second : +0.000000001111172842935718417798556472 +2552` [download] This is quite nice. I has already surpassed my assumptions. I’ve read the Time::HiRes readme, so I do not expect `clock_nanosleep()` to be exact down to one nanosecond, but the average results above tells me that that it is as least _nearly_ that accurate (at least on my system and its configuration). hawkex, I can’t thank you enough! You’re great!	[reply] [d/l] [select]


Keep It Simple, Stupid
	PerlMonks