This code builds an AoA by processing three lines at a time and pushing an anonymous array of chomped lines for each group.

$ perl -Mstrict -Mwarnings -MData::Dumper -e '
sub groupsOf (&$@);

open my $inFH, q{<}, \ <<EOD or die $!;
a
b
c
d
e
f
g
h
EOD

my @arr;
push @arr, groupsOf { chomp @_; [ @_ ] } 3, <$inFH>;

sub groupsOf (&$@)
{
    my $rcToRun  = shift;
    my $groupsOf = shift;

    my $rcDoIt;
    $rcDoIt = sub
       {
           $rcToRun->(
              map shift, 1 .. ( @_ < $groupsOf ? @_ : $groupsOf )
              ),
           @_ ? &$rcDoIt : ();
       };

    &$rcDoIt;
}

print Data::Dumper->Dumpxs( [ \ @arr ], [ qw{ *arr } ] );'
@arr = (
         [
           'a',
           'b',
           'c'
         ],
         [
           'd',
           'e',
           'f'
         ],
         [
           'g',
           'h'
         ]
       );
$
[download]

I hope this is of interest.

Update: Simpler and assigns to three variables rather than constructing an AoA.

$ perl -Mstrict -Mwarnings -E '
> open my $inFH, q{<}, \ <<EOD or die $!;
> a
> b
> c
> d
> e
> f
> g
> h
> EOD
> 
> while ( not eof $inFH )
> {
>     my( $i, $j, $k ) =
>        map { chomp; $_ }
>        map { eof $inFH ? () : scalar <$inFH> }
>        1 .. 3;
>     say
>        q{$i - }, defined $i ? qq{$i; } : q{undef; },
>        q{$j - }, defined $j ? qq{$j; } : q{undef; },
>        q{$k - }, defined $k ? $k : q{undef};
> }'
$i - a; $j - b; $k - c
$i - d; $j - e; $k - f
$i - g; $j - h; $k - undef
$
[download]