以精确的时间运行子程序，perl精度为0.1s

Question

Need run a subroutine every 5 seconds, but measured at system clock marks. So, need start it every minute at 0, 5, 10, 15.... 45, 50, 55 second (exactly, with 0.1sec precistion).

Something like:

for(;;) {
    do_sleep(); #time need to sleep to the next 5 second mark
    run_this();
}

The run_this sub can be fast or slow (its runtime between 0.2 - 120 seconds). When it run more than 5 seconds - regardless its runtime, the next run must be at exact 5 second mark.

Eg when the run_this

• ends at 11:11:12.3 need wait 2.7 second to the next run at 11:11:15
• when ends at 11:11:59.2 need wait only 0.8 seconds to the next at 11:12:00, and so on...

The question is: how to write the do_sleep?

Answer 1

For 0.1s precision you need to use Time::HiRes module. Something like:

#!/usr/bin/perl
use 5.014;
use warnings;
use Time::HiRes qw(tv_interval usleep gettimeofday);

for(;;) {
    do_sleep();
    run_this();
}

sub do_sleep {
    my $t = [gettimeofday];
    my $next = (int($t->[0]/5) + 1) * 5;
    my $delta = tv_interval ($t, [$next, 0]);
    usleep($delta * 1_000_000);
    return;
}

sub run_this {
    my $t = [gettimeofday];
    printf "Start is at: %s.%s\n",
        scalar localtime  $t->[0],
        $t->[1];
    usleep( rand 10_000_000 );  #simulating the runtime between 0-10 seconds (in microseconds)
}

Answer 2

This one also works if you have signal handlers. It also handles leap seconds.

use Time::HiRes qw( );

sub uninterruptible_sleep_until {
   my ($until) = @_;
   for (;;) {
      my $length = $until - Time::HiRes::time();
      last if $length <= 0;
      Time::HiRes::sleep($length);
   }
}

sub find_next_start {
   my $time = int(time());
   for (;;) {
      ++$time;
      my $secs = (localtime($time))[0];
      last if $secs % 5 == 0 && $secs != 60;
   }
   return $time;
}

uninterruptible_sleep_until(find_next_start());

Note that the system might not give a time slice when you want it, so you might actually start later than requested.

Answer 3

A very different method would be to use IO::Async for this. You can schedule an event for a specific time in the future.

Answer 4

Use a high precision timer from Time::HiRes to time the loop

http://perldoc.perl.org/Time/HiRes.html

Put your long running job into a background process

my $pid = fork;
die "fork failed" unless defined $pid;
if ($pid == 0) {
    # child process goes here
    run_this();
    exit;
}
# parent process continues here

See also Initiating Non-waiting Background Process in Perl

Answer 5

You could use Time::HiRes and figure how long to wait that way:

use Time::HiRes;
my $t = time();
my $nextCallTime = int($t) / 5 * 5 + 5;
my $timeToWait = $nextCallTime - $t;
sleep($timeToWait);

I did not test the code and there may be some boundary condition when the call finishes at exactly 5 seconds boundary. But I think it gives the right idea.