It's pure Perl, you could even copy the rather short code into a module of yours.

If you wanna implement it yourself I'd try reading sliding windows˛ of 4^n kb chunks from the end with seek

• reverse those windows
• read line by line form the string (you can also open from a string)
• reverse the single lines again
• If one window is depleted, read the next one and append it to the last window.

I'd put all the logic into a sub which returns those lines or maybe I'd try to create a new IO class.

I remember a similar question not too long ago, you should try super search °

update

°) like Reading the contents of a file from the bottom up

˛) sliding windows explained

you could even copy the rather short code into a module of yours.

Or better still, use App::FatPacker to create your stand-alone, distributable script. It will do all the hard/dull work so you don't have to.

---

🦛

Thanks for the suggestions Rolf. I think adapting the code from the module sounds like the best bet, though taking a look at the module, I will need to do my homework on what a lot of it means (I only dabble with scripting really), so a good learning exercise!

Cheers,
Cam

Hmm it's offering a "tie filehandle" interface, that's not common and rather deep for a beginner (though a good idea)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

I also have to use what is installed on these machines ... that rules out using File::ReadBackwards.

Not really - it's a pure-Perl module and not that many lines of code. Yes, even you can use CPAN and in the very worst case, you could copy the module's code into your script.

Edit: LanX beat me to it ;-)

XY problem?

Looking at your code it appears you are reading kernel logs for temperature problems, but only after a certain unix time.
It may be possible to use Search::Dict to find the first line in the file on or after a specified time and then read forward to the end.
No backward reading would be required.

It would look something like this:

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11126426
use warnings;
use Search::Dict;
use Date::Parse qw( str2time );
use Time::HiRes qw( time );

my $day = 60 * 60 * 24;

# commented code used to create 209M file;
#my $str = join '', map { localtime( time + $_ * $day) .
# " kernel: log entry\n" } -5e6 .. 5;
#print $str;
#use Path::Tiny; path('d.searchdict')->spew($str);
#print "string length = @{[length $str]}\n";

my $want = time - 1.1 * $day;

my $start = time;
open my $fh, '<', 'd.searchdict' or die;
look $fh, $want, {
  comp => sub { $_[0] <=> $_[1] },
  xfrm => sub { str2time substr shift, 0, 24 },
  };
printf "look took %.3f seconds\n", time - $start;

while( <$fh> ) # now read to end of file
  {
  print;
  }
[download]

On the other hand, maybe a real read backwards would work better, so here's a simple package I threw together:

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11126426
use warnings;

my $str = join '', map '.' x $_ . "this is line $_\n", 1 .. 60;
print $str;
print "string length = ", length $str, "\n";

my $backwards = Tybalt89BackwardsHeReads->new( \$str ) or die;

while( defined( $_ = $backwards->line ) )
  {
  print;
  }

package Tybalt89BackwardsHeReads; ####################################
+###

sub line
  {
  my ($self) = @_;
  if( @{ $self->{lines} } == 0 and $self->{where} )
    {
    my $window = 1024;                   # window size, adjust to suit
    my $pos = $self->{where} - $window;
    $pos < 0 and $pos = 0;
    seek $self->{fh}, $pos, 0;
    read $self->{fh}, my $data, $self->{where} - $pos;
    $pos and $data =~ s/^.*\n// ? ($pos += $+[0]) : die "increase wind
+ow size";
    $self->{lines} = [ split /^/, $data ];
    $self->{where} = $pos;
    }
  return pop @{ $self->{lines} };
  }

sub new
  {
  my ($self, $filename) = @_;
  open my $fh, '<', $filename or die "$! on $filename";
  bless { fh => $fh,
    where => ref $filename ? length $$filename : -s $filename,
    lines => [] }, ref $self || $self;
  }

1; # so if split off, package ends with true
[download]

Use your real filename in the ->new() call instead of the string reference I was using for testing. And you can remove the string generation code also.

You may want to change the package name :)

P.S. I enjoyed writing the read backwards code, thanks for the inspiration!

Hi Tybalt89,

Glad you enjoyed it! I omitted the first bit of the code where I do the timestamps for brevity's sake, but yes, the purpose is to look for the last 24 hours of logs for any thermal throttling messages. Thanks for the code, I think that will be quicker for me to adapt than the original File::ReadBackwards (I'll dig into 'tie filehandle' when I get a chance sometime), and there's some things new to me in your example as well which look interesting.

Cheers,
Cam

Since I haven't played with tied file handles before, here's the previous package with the ability to use it either as an object, or as a tied file handle.

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11126426
use warnings;

tie *BACKWARDS, 'Tybalt89BackwardsHeReads', $0 or die 'tie failed';

while( <BACKWARDS> )
  {
  print;
  }

package Tybalt89BackwardsHeReads; ####################################
+###

BEGIN
  {
  *TIEHANDLE = \&new;
  *READLINE = \&line;
  }

sub line
  {
  my ($self) = @_;
  while( @{ $self->{lines} } == 0 and $self->{where} )
    {
    my $window = 1024;                   # window size, adjust to suit
    my $pos = $self->{where} - $window;
    $pos < 0 and $pos = 0;
    seek $self->{fh}, $pos, 0;
    read $self->{fh}, my $data, $self->{where} - $pos;
    $pos and $data =~ s/^\N*\n(?=.)//s ? ($pos += $+[0]) :
      die "increase window size";
    $self->{lines} = [ split /^/, $data ];
    $self->{where} = $pos;
    }
  return pop @{ $self->{lines} };
  }

sub new
  {
  my ($self, $filename) = @_;
  open my $fh, '<', $filename or die "$! on $filename";
  bless { where => ref $filename ? length $$filename : -s $filename,
    fh => $fh, lines => [] }, ref $self || $self;
  }

1; # so if split off, package ends with true
[download]

Replace the $0 with the name of your file. I was just using it for debugging.

Please use this latest version of "sub line", it solves a problem with the fetching the line from the beginning of the file when the window is too small.

And here's the latest version I've been playing with - an iterator.

#!/usr/bin/perl

use strict;
use warnings;

my $file = $0; # FIXME to your filename

my $backward = tybalt89sreadbackward( $file ); # create iterator
while( defined( $_ = $backward->() ) ) # USAGE: read each line
  {
  print; # NOTE or whatever you want to do
  }

sub tybalt89sreadbackward # iterator version
  {
  my $filename = shift;
  my $size = shift // 4096;
  my ($text, @lines) = '';
  open my $fh, '<', $filename or die "$! opening $filename";
  my $chunk = int +($size - 1 + -s $fh) / $size;
  return sub
    {
    while( @lines == 0 and $chunk-- > 0 )
      {
      seek $fh, $chunk * $size, 0 or die "$! on seek";
      $text = do { local $/ = \$size; <$fh> . $text };
      $text =~ s/(?<=\n).+/ @lines = split '^', $&; '' /es;
      }
    return pop @lines // ($text =~ s/.+//s ? $& : undef);
    }
  }
[download]