Отключить буферизацию в трубе

У меня есть скрипт, который вызывает две команды:

long_running_command | print_progress

В long_running_commandпечатает прогресс , но я несчастна с ним. Я использую, print_progressчтобы сделать его более приятным (а именно, я печатаю прогресс в одной строке).

Проблема: подключение канала к stdout также активирует буфер 4K, к хорошей программе печати ничего не получается ... ничего ... ничего ... много ... :)

Как я могу отключить 4K буфер для long_running_command(нет, у меня нет источника)?

Вы можете использовать unbufferкоманду (которая входит в состав expectпакета), например:

unbuffer long_running_command | print_progress

unbufferподключается long_running_commandчерез псевдотерминал (pty), что заставляет систему рассматривать его как интерактивный процесс, поэтому не использует буферизацию в 4 КБ в конвейере, которая является вероятной причиной задержки.

Для более длинных конвейеров вам, возможно, придется снять буфер каждой команды (кроме последней), например

unbuffer x | unbuffer -p y | z

Еще один способ избавиться от этой кошки - использовать stdbufпрограмму, которая является частью GNU Coreutils (FreeBSD также имеет свою собственную).

stdbuf -i0 -o0 -e0 command

Это полностью отключает буферизацию для ввода, вывода и ошибок. Для некоторых приложений линейная буферизация может быть более подходящей по причинам производительности:

stdbuf -oL -eL command

_{Обратите внимание, что он работает только для stdioбуферизации ( printf(), fputs()...) для динамически связанных приложений и только в том случае, если это приложение самостоятельно не регулирует буферизацию своих стандартных потоков, хотя это должно охватывать большинство приложений.}

Еще один способ включить режим вывода с буферизацией строки long_running_command- использовать scriptкоманду, которая запускает ваш long_running_commandпсевдотерминал (pty).

script -q /dev/null long_running_command | print_progress      # FreeBSD, Mac OS X
script -c "long_running_command" /dev/null | print_progress    # Linux

Для grep, sedи awkвы можете заставить вывод быть буферизованным. Вы можете использовать:

grep --line-buffered

Принудительно выводить данные в линейную буферизацию. По умолчанию выход является линейной буферизацией, когда стандартный вывод является терминалом, а блок буферизован иначе.

sed -u

Сделать строку вывода буферизованной.

Смотрите эту страницу для получения дополнительной информации: http://www.perkin.org.uk/posts/how-to-fix-stdio-buffering.html

Если проблема в том, что libc изменяет свою буферизацию / сброс, когда вывод не идет на терминал, вы должны попробовать socat . Вы можете создать двунаправленный поток между практически любым механизмом ввода / вывода. Одним из них является разветвленная программа, говорящая с псевдотермием.

 socat EXEC:long_running_command,pty,ctty STDIO 

Что это делает

• создать псевдо Tty
• fork long_running_command с ведомой стороной pty как stdin / stdout
• установить двунаправленный поток между главной стороной pty и вторым адресом (здесь это STDIO)

Если это дает тот же результат, что long_running_commandи тогда, вы можете продолжить с конвейера.

Редактировать: Ух ты не видел небуферный ответ! Ну, в общем, socat - отличный инструмент, так что я мог бы просто оставить этот ответ

Вы можете использовать

long_running_command 1>&2 |& print_progress

Проблема в том, что libc будет выполнять линейный буфер при выводе stdout на экран, и полный буфер при выводе stdout в файл. Но нет буфера для stderr.

Я не думаю, что это проблема с буфером буфера, все дело в политике буфера libc.

Раньше так и было, и, вероятно, так и есть, когда стандартный вывод записывается в терминал, он по умолчанию буферизует строку - когда пишется новая строка, строка записывается в терминал. Когда стандартный вывод отправляется в канал, он полностью буферизуется, поэтому данные отправляются следующему процессу в конвейере только после заполнения стандартного буфера ввода / вывода.

Это источник неприятностей. Я не уверен, есть ли что-то, что вы можете сделать, чтобы исправить это, не изменяя запись программы в трубу. Вы можете использовать setvbuf()функцию с _IOLBFфлагом, чтобы безоговорочно перевести ее stdoutв режим буферизации строки. Но я не вижу простого способа применить это в программе. Или программа может делать fflush()в соответствующих точках (после каждой строки вывода), но тот же комментарий применяется.

Я предполагаю, что если вы замените канал псевдотерминалом, то стандартная библиотека ввода / вывода будет думать, что вывод является терминалом (потому что это тип терминала) и будет автоматически выполнять линейный буфер. Хотя это сложный способ иметь дело с вещами.

Я знаю, что это старый вопрос и уже было много ответов, но если вы хотите избежать проблемы с буфером, просто попробуйте что-то вроде:

stdbuf -oL tail -f /var/log/messages | tee -a /home/your_user_here/logs.txt

Это выведет журналы в реальном времени, а также сохранит их в logs.txtфайл, и буфер больше не будет влиять на tail -fкоманду.

Я не думаю, что проблема с трубкой. Похоже, ваш длительный процесс недостаточно часто очищает свой буфер. Изменение размера буфера канала было бы хаком, чтобы обойти его, но я не думаю, что это возможно без перестройки ядра - что-то, что вы не хотели бы делать как хак, так как это, вероятно, затрагивает многие другие процессы.

Согласно этому посту , вы можете попытаться уменьшить ulimit канала до одного 512-байтового блока. Это, конечно, не отключит буферизацию, но хорошо, 512 байт - это меньше, чем 4K: 3

Аналогично ответу Чада , вы можете написать небольшой скрипт, подобный этому:

# save as ~/bin/scriptee, or so
script -q /dev/null sh -c 'exec cat > /dev/null'

Затем используйте эту scripteeкоманду в качестве замены tee.

my-long-running-command | scriptee

Увы, я не могу заставить такую ​​версию идеально работать в Linux, поэтому кажется, что она ограничена юниксами в стиле BSD.

В Linux это близко, но вы не получите свое приглашение после его завершения (пока вы не нажмете ввод и т. Д.) ...

script -q -c 'cat > /proc/self/fd/1' /dev/null

Я нашел это умное решение: (echo -e "cmd 1\ncmd 2" && cat) | ./shell_executable

Это делает трюк. catпрочтет дополнительный ввод (до EOF) и передаст его каналу после того, echoкак аргументы вошли в поток ввода shell_executable.

В соответствии с этим размер буфера канала, по-видимому, установлен в ядре и потребует от вас перекомпиляции ядра для изменения.