Wie groß ist der Pipe Buffer?

Als Kommentar in Ich bin verwirrt, warum "| true" in einem Makefile den gleichen Effekt wie "|| true" hat. Benutzer cjm schrieb:

Ein weiterer Grund, | zu vermeiden true ist, dass wenn der Befehl genügend Ausgabe erzeugt, um den Pipe-Puffer zu füllen, das Warten auf true zum Lesen blockiert wird.

Können wir irgendwie herausfinden, wie groß der Pipe-Puffer ist?

Die Kapazität eines Pipe-Puffers variiert je nach System (und kann sogar auf demselben System variieren). Ich bin nicht sicher, ob es eine schnelle, einfache und plattformübergreifende Möglichkeit gibt, die Kapazität eines Rohrs zu ermitteln.

Mac OS X verwendet beispielsweise standardmäßig eine Kapazität von 16384 Byte, kann jedoch auf 65336 Byte umschalten, wenn große Schreibvorgänge in die Pipe ausgeführt werden, oder auf die Kapazität einer einzelnen Systemseite, wenn bereits zu viel Kernelspeicher vorhanden ist Wird von Pipe-Puffern verwendet (siehe xnu/bsd/sys/pipe.hund xnu/bsd/kern/sys_pipe.c; da diese von FreeBSD stammen, kann das gleiche Verhalten auch dort auftreten).

Eine Manpage zu Linux Pipe (7) besagt, dass die Pipe-Kapazität seit Linux 2.6.11 65536 Byte und eine einzelne Systemseite davor beträgt (z. B. 4096 Byte auf (32-Bit) x86-Systemen). Der Code ( include/linux/pipe_fs_i.h, und fs/pipe.c) scheint 16 System-Seiten zu verwenden (dh 64 KB, wenn eine System-Seite 4 KB groß ist), aber der Puffer für jede Pipe kann über eine Fcntl in der Pipe angepasst werden (bis zu einer maximalen Kapazität, die standardmäßig 1048576 beträgt) Bytes, kann aber über /proc/sys/fs/pipe-max-size)) geändert werden .

Hier ist eine kleine Bash / Perl- Kombination, mit der ich die Pipe-Kapazität auf meinem System getestet habe:

#!/bin/bash
test $# -ge 1 || { echo "usage: $0 write-size [wait-time]"; exit 1; }
test $# -ge 2 || set -- "$@" 1
bytes_written=$(
{
    exec 3>&1
    {
        perl -e '
            $size = $ARGV[0];
            $block = q(a) x $size;
            $num_written = 0;
            sub report { print STDERR $num_written * $size, qq(\n); }
            report; while (defined syswrite STDOUT, $block) {
                $num_written++; report;
            }
        ' "$1" 2>&3
    } | (sleep "$2"; exec 0<&-);
} | tail -1
)
printf "write size: %10d; bytes successfully before error: %d\n" \
    "$1" "$bytes_written"

Ich habe festgestellt, dass es auf einem Mac OS X 10.6.7-System mit verschiedenen Schreibgrößen ausgeführt wird (beachten Sie die Änderung für Schreibvorgänge, die größer als 16 KB sind):

% /bin/bash -c 'for p in {0..18}; do /tmp/ts.sh $((2 ** $p)) 0.5; done'
write size:          1; bytes successfully before error: 16384
write size:          2; bytes successfully before error: 16384
write size:          4; bytes successfully before error: 16384
write size:          8; bytes successfully before error: 16384
write size:         16; bytes successfully before error: 16384
write size:         32; bytes successfully before error: 16384
write size:         64; bytes successfully before error: 16384
write size:        128; bytes successfully before error: 16384
write size:        256; bytes successfully before error: 16384
write size:        512; bytes successfully before error: 16384
write size:       1024; bytes successfully before error: 16384
write size:       2048; bytes successfully before error: 16384
write size:       4096; bytes successfully before error: 16384
write size:       8192; bytes successfully before error: 16384
write size:      16384; bytes successfully before error: 16384
write size:      32768; bytes successfully before error: 65536
write size:      65536; bytes successfully before error: 65536
write size:     131072; bytes successfully before error: 0
write size:     262144; bytes successfully before error: 0

Dasselbe Skript unter Linux 3.19:

/bin/bash -c 'for p in {0..18}; do /tmp/ts.sh $((2 ** $p)) 0.5; done'
write size:          1; bytes successfully before error: 65536
write size:          2; bytes successfully before error: 65536
write size:          4; bytes successfully before error: 65536
write size:          8; bytes successfully before error: 65536
write size:         16; bytes successfully before error: 65536
write size:         32; bytes successfully before error: 65536
write size:         64; bytes successfully before error: 65536
write size:        128; bytes successfully before error: 65536
write size:        256; bytes successfully before error: 65536
write size:        512; bytes successfully before error: 65536
write size:       1024; bytes successfully before error: 65536
write size:       2048; bytes successfully before error: 65536
write size:       4096; bytes successfully before error: 65536
write size:       8192; bytes successfully before error: 65536
write size:      16384; bytes successfully before error: 65536
write size:      32768; bytes successfully before error: 65536
write size:      65536; bytes successfully before error: 65536
write size:     131072; bytes successfully before error: 0
write size:     262144; bytes successfully before error: 0

Hinweis: Der PIPE_BUFin den C-Header-Dateien definierte Wert (und der Pfadkonfigurationswert für _PC_PIPE_BUF) gibt nicht die Kapazität der Pipes an, sondern die maximale Anzahl von Bytes, die atomar geschrieben werden können (siehe POSIX- Schreibzugriff (2) ).

Zitat aus include/linux/pipe_fs_i.h:

/* Differs from PIPE_BUF in that PIPE_SIZE is the length of the actual
   memory allocation, whereas PIPE_BUF makes atomicity guarantees.  */

Diese Shell-Linie kann auch die Größe des Pipe-Puffers anzeigen:

M=0; while true; do dd if=/dev/zero bs=1k count=1 2>/dev/null; \
       M=$(($M+1)); echo -en "\r$M KB" 1>&2; done | sleep 999

(Senden von 1k Stücken an die blockierte Leitung, bis der Puffer voll ist) ... einige Testausgaben:

64K (intel-debian), 32K (aix-ppc), 64K (jslinux bellard.org)      ...Ctrl+C.

kürzester Bash-One-Liner mit printf:

M=0; while printf A; do >&2 printf "\r$((++M)) B"; done | sleep 999

Hier sind einige weitere Alternativen, um die tatsächliche Pipe-Pufferkapazität nur mit Shell-Befehlen zu ermitteln:

# get pipe buffer size using Bash
yes produce_this_string_as_output | tee >(sleep 1) | wc -c

# portable version
( (sleep 1; exec yes produce_this_string_as_output) & echo $! ) | 
     (pid=$(head -1); sleep 2; kill "$pid"; wc -c </dev/stdin)

# get buffer size of named pipe
sh -c '
  rm -f fifo
  mkfifo fifo
  yes produce_this_string_as_output | tee fifo | wc -c &
  exec 3<&- 3<fifo
  sleep 1
  exec 3<&-
  rm -f fifo
'

# Mac OS X
#getconf PIPE_BUF /
#open -e /usr/include/limits.h /usr/include/sys/pipe.h
# PIPE_SIZE
# BIG_PIPE_SIZE
# SMALL_PIPE_SIZE
# PIPE_MINDIRECT

Dies ist ein schneller und schmutziger Hack auf Ubuntu 12.04, YMMV

cat >pipesize.c

#include <unistd.h>
#include <errno.h>
#include </usr/include/linux/fcntl.h>
#include <stdio.h>

void main( int argc, char *argv[] ){
  int fd ;
  long pipesize ;

  if( argc>1 ){
  // if command line arg, associate a file descriptor with it
    fprintf( stderr, "sizing %s ... ", argv[1] );
    fd = open( argv[1], O_RDONLY|O_NONBLOCK );
  }else{
  // else use STDIN as the file descriptor
    fprintf( stderr, "sizing STDIN ... " );
    fd = 0 ;
  }

  fprintf( stderr, "%ld bytes\n", (long)fcntl( fd, F_GETPIPE_SZ ));
  if( errno )fprintf( stderr, "Uh oh, errno is %d\n", errno );
  if( fd )close( fd );
}

gcc -o pipesize pipesize.c

mkfifo /tmp/foo

./pipesize /tmp/foo

>sizing /tmp/foo ... 65536 bytes

date | ./pipesize

>sizing STDIN ... 65536 bytes

$ ulimit -a | grep pipe
pipe size            (512 bytes, -p) 8

Also habe ich auf meiner Linux-Box standardmäßig 8 * 512 = 4096-Byte-Pipes.

Solaris und viele andere Systeme haben eine ähnliche ulimit-Funktion.

Wenn Sie den Wert in Python> = 3.3 benötigen, ist dies eine einfache Methode (vorausgesetzt, Sie können call out to ausführen dd):

from subprocess import Popen, PIPE, TimeoutExpired
p = Popen(["dd", "if=/dev/zero", "bs=1"], stdin=PIPE, stdout=PIPE)
try: 
    p.wait(timeout=1)
except TimeoutExpired: 
    p.kill()
    print(len(p.stdout.read()))