Comment puis-je définir la taille du tampon de lecture de fichier dans Perl pour l'optimiser pour les fichiers volumineux?

Non, il n'y a pas (à court de recompiler une perl modifiée), mais vous pouvez lire l'ensemble du fichier en mémoire, puis la ligne de travail par ligne à partir de celle-ci: xxx

Notez que Perl avant 5.10 Fait défaut à l'aide des tampons Stdio dans la plupart des endroits (mais trichent souvent et accédant directement aux tampons directement, pas à travers la bibliothèque Stdio), mais dans 5.10 et ultérieure par défaut à son propre système de couche de Perlio. Ce dernier semble utiliser un 4k tampon par défaut, mais écrire un calque permettant de configurer cela devrait être trivial (Une fois que vous avez compris comment écrire un calque: voir Perldoc Perliol ).

AVERTISSEMENT, le code suivant n'a été testé que par la lumière. Le code ci-dessous est un premier coup sur une fonction qui vous permettra de traiter une ligne de fichier par ligne (d'où le nom de la fonction) avec une taille de tampon définissable par l'utilisateur. Il faut jusqu'à quatre arguments:

1. Un fichier ouvert (par défaut est stdin code>) li>
2. une taille de tampon (par défaut est 4K) li>
3. Une référence à une variable pour stocker la ligne dans (par défaut est $ _ code>) li>
4. Un sous-programme anonyme pour appeler le fichier (la valeur par défaut imprime la ligne). LI> OL>

   Les arguments sont positionnels à l'exception de l'exception que le dernier argument peut toujours être le sous-programme anonyme. Les lignes sont auto-châchées. P>

   bugs probables: p>

   • peut ne pas fonctionner sur des systèmes où l'alimentation en ligne est le caractère final de la ligne li>
   • échouera probablement quand combiné avec un _ code> (introduit dans Perl 5.10) li> ul>

     Vous pouvez voir à partir d'un strace code> qu'il lit le fichier avec la taille de la mémoire tampon spécifiée. Si j'aime comment tester le test, vous pouvez voir ceci sur CPAN bientôt. P>

     #!/usr/bin/perl
     
     use strict;
     use warnings;
     use Scalar::Util qw/reftype/;
     use Carp;
     
     sub line_by_line {
         local $_;
         my @args = \(
             my $fh      = \*STDIN,
             my $bufsize = 4*1024,
             my $ref     = \$_,
             my $coderef = sub { print "$_\n" },
         );
         croak "bad number of arguments" if @_ > @args;
     
         for my $arg_val (@_) {
             if (reftype $arg_val eq "CODE") {
                 ${$args[-1]} = $arg_val;
                 last;
             }
             my $arg = shift @args;
             $$arg = $arg_val;
         }
     
         my $buf;
         my $overflow ='';
         OUTER:
         while(sysread $fh, $buf, $bufsize) {
             my @lines = split /(\n)/, $buf;
             while (@lines) {
                 my $line  = $overflow . shift @lines;
                 unless (defined $lines[0]) {
                     $overflow = $line;
                     next OUTER;
                 }
                 $overflow = shift @lines;
                 if ($overflow eq "\n") {
                     $overflow = "";
                 } else {
                     next OUTER;
                 }
                 $$ref = $line;
                 $coderef->();
             }
         }
         if (length $overflow) {
             $$ref = $overflow;
             $coderef->();
         }
     }
     
     my $bufsize = shift;
     
     open my $fh, "<", $0
         or die "could not open $0: $!";
     
     my $count;
     line_by_line $fh, sub {
         $count++ if /lines/;
     }, $bufsize;
     
     print "$count\n";