පයිප්ප බෆරය කොතරම් විශාලද?

තුළ ප්රතිචාරයක් ලෙස | මම ඇයි ව්යාකුල කරනවා "සත්යය" එය makefile දී "|| සැබෑ" ලෙස එම බලපෑමක් ඇති කොට ඇත පරිශීලක cjm : ලියා

වළක්වා ගත හැකි තවත් හේතුවක් | trueනම්, විධානය මඟින් පයිප්ප බෆරය පිරවීම සඳහා ප්‍රමාණවත් ප්‍රතිදානයක් ලබා දෙන්නේ නම්, එය සත්‍ය ලෙස කියවීම බලා සිටීම අවහිර කරනු ඇත.

පයිප්ප බෆරයේ ප්‍රමාණය කුමක්දැයි සොයා ගැනීමට අපට ක්‍රමයක් තිබේද?

පයිප්ප බෆරයක ධාරිතාව පද්ධති හරහා වෙනස් වේ (එකම පද්ධතියක පවා වෙනස් විය හැකිය). පයිප්පයක ධාරිතාවය සොයා බැලීමට ඉක්මන්, පහසු සහ හරස් වේදිකා ක්‍රමයක් ඇති බව මට විශ්වාස නැත.

උදාහරණයක් ලෙස මැක් ඕඑස් එක්ස් බයිට් 16384 ක ධාරිතාවක් පෙරනිමියෙන් භාවිතා කරයි, නමුත් පයිප්පයට විශාල ලිවීමක් කළහොත් බයිට් 65336 ධාරිතාවයට මාරු විය හැකිය, නැතහොත් දැනටමත් කර්නල් මතකය ඕනෑවට වඩා තිබේ නම් තනි පද්ධති පිටුවක ධාරිතාවයට මාරු වේ. පයිප්ප බෆර මගින් භාවිතා කරනු ලැබේ (බලන්න xnu/bsd/sys/pipe.h, සහ xnu/bsd/kern/sys_pipe.c; මේවා ෆ්‍රීබීඑස්ඩී වෙතින් වන බැවින්, එම හැසිරීම ද එහි සිදුවිය හැකිය).

එක් ලිනක්ස් පයිප්ප (7) මෑන් පිටුවක් පවසන්නේ ලිනක්ස් 2.6.11 සිට පයිප්ප ධාරිතාව බයිට් 65536 ක් වන අතර ඊට පෙර තනි පද්ධති පිටුවක් (උදා: (32-බිට්) x86 පද්ධති මත බයිට් 4096). කේතය ( include/linux/pipe_fs_i.h, සහ fs/pipe.c) පද්ධති පිටු 16 ක් භාවිතා කරන බව පෙනේ (එනම් 64 කිබී පද්ධති පිටුවක් 4 කිබී නම්), නමුත් එක් එක් පයිප්පයේ බෆරය පයිප්පයේ fcntl හරහා සකස් කළ හැකිය (උපරිම ධාරිතාව 1048576 දක්වා පෙරනිමිය බයිට්, නමුත් වෙනස් කළ හැකිය /proc/sys/fs/pipe-max-size)).

මගේ පද්ධතියේ නල ධාරිතාව පරීක්ෂා කිරීම සඳහා මා භාවිතා කළ කුඩා බෑෂ් / පර්ල් සංයෝජනයක් මෙන්න :

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

මැක් ඕඑස් එක්ස් 10.6.7 පද්ධතියක් මත විවිධ ලිවීම් ප්‍රමාණවලින් එය ක්‍රියාත්මක වන බව මට පෙනී ගියේය (16KiB ට වඩා විශාල ලිවීම් සඳහා වෙනස සැලකිල්ලට ගන්න):

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

ලිනක්ස් 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

සටහන: PIPE_BUFසී ශීර්ෂ ලිපිගොනු වල අර්ථ දක්වා ඇති අගය (සහ සඳහා වන pathconf අගය _PC_PIPE_BUF), පයිප්පවල ධාරිතාව නියම නොකරයි, නමුත් පරමාණුකව ලිවිය හැකි උපරිම බයිට් ගණන ( POSIX write (2) බලන්න ).

උපුටා ගැනීම 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.  */

මෙම කවච රේඛාවට පයිප්ප බෆරයේ ප්‍රමාණයද පෙන්විය හැකිය:

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

(බෆරය පිරෙන තුරු අවහිර කළ පයිප්පයට කුට්ටි 1k යැවීම) ... සමහර පරීක්ෂණ ප්‍රතිදානයන්:

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

printf භාවිතා කරන කෙටිම බාෂ්-වන්-ලයිනර්:

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

ෂෙල් විධාන පමණක් භාවිතා කරමින් සත්‍ය නල බෆර් ධාරිතාව ගවේෂණය කිරීම සඳහා තවත් විකල්ප කිහිපයක් මෙන්න:

# 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

මෙය උබුන්ටු 12.04, වයිඑම්එම්වී හි ඉක්මන් හා අපිරිසිදු හැක් කිරීමකි

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

ඔබට පයිතන්> = 3.3 හි අගය අවශ්‍ය නම්, මෙන්න සරල ක්‍රමයක් (ඔබට ඇමතුමක් ලබා ගත හැකි යැයි උපකල්පනය කර 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()))

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

ඉතින් මගේ ලිනක්ස් පෙට්ටියේ පෙරනිමියෙන් 8 * 512 = 4096 බයිට් පයිප්ප තිබේ.

සොලාරිස් සහ තවත් බොහෝ පද්ධති වලට සමාන ulimit ශ්‍රිතයක් ඇත.