¿Qué tan grande es el buffer de la tubería?

Como comentario en , estoy confundido de por qué "| true" en un archivo MAKE tiene el mismo efecto que el usuario "|| true" cjm escribió:

Otra razón para evitar | verdadero es que si el comando produce suficiente salida para llenar el búfer de la tubería, bloqueará la espera de verdadero para leerlo.

¿Tenemos alguna forma de averiguar cuál es el tamaño del búfer de tubería?

La capacidad de un buffer de tubería varía entre sistemas (e incluso puede variar en el mismo sistema). No estoy seguro de que haya una manera rápida, fácil y multiplataforma para buscar la capacidad de una tubería.

Mac OS X, por ejemplo, usa una capacidad de 16384 bytes de manera predeterminada, pero puede cambiar a capacidades de 65336 bytes si se realiza una gran escritura en la tubería, o cambiará a una capacidad de una sola página del sistema si ya hay demasiada memoria del núcleo siendo utilizado por los buffers de tubería (ver xnu/bsd/sys/pipe.h, y xnu/bsd/kern/sys_pipe.c; dado que estos son de FreeBSD, el mismo comportamiento también puede ocurrir allí).

Una página del comando man Linux pipe (7) dice que la capacidad de la tubería es 65536 bytes desde Linux 2.6.11 y una sola página del sistema anterior (por ejemplo, 4096 bytes en sistemas x86 (32 bits)). El código ( include/linux/pipe_fs_i.hy fs/pipe.c) parece usar 16 páginas del sistema (es decir, 64 KiB si una página del sistema es 4 KiB), pero el búfer para cada tubería se puede ajustar a través de un fcntl en la tubería (hasta una capacidad máxima que por defecto es 1048576 bytes, pero se puede cambiar a través de /proc/sys/fs/pipe-max-size)).

Aquí hay una pequeña combinación bash / perl que utilicé para probar la capacidad de la tubería en mi sistema:

#!/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"

Esto es lo que encontré ejecutándolo con varios tamaños de escritura en un sistema Mac OS X 10.6.7 (tenga en cuenta el cambio para escrituras de más de 16 KB):

% /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

El mismo script en 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

Nota: El PIPE_BUFvalor definido en los archivos de encabezado C (y el valor de pathconf para _PC_PIPE_BUF) no especifica la capacidad de las canalizaciones, sino el número máximo de bytes que pueden escribirse atómicamente (consulte POSIX write (2) ).

Cita de 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.  */

esta línea de shell también puede mostrar el tamaño del buffer de tubería:

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

(enviando trozos de 1k a la tubería bloqueada hasta que el buffer esté lleno) ... algunas salidas de prueba:

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

el más corto bash-one-liner usando printf:

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

Aquí hay algunas alternativas adicionales para explorar la capacidad real del búfer de tubería utilizando solo comandos de shell:

# 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

Este es un truco rápido y sucio en 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

Entonces, en mi caja de Linux tengo 8 * 512 = 4096 bytes de tuberías por defecto.

Solaris y muchos otros sistemas tienen una función ulimit similar.

Si necesita el valor en Python> = 3.3, aquí hay un método simple (suponiendo que pueda ejecutar call to 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()))