Что такое конвейер команд в теории ос
Перейти к содержимому

Что такое конвейер команд в теории ос

  • автор:

PersCom — Компьютерная ЭнциклопедияКомпьютерная Энциклопедия

Вы здесь: Главная Процессор Конвейер команд Конвейер команд. Конвейеризация — способ обеспечения параллельности выполнения команд

Архитектура ЭВМ

  • Базовая организация ЭВМ
  • Процессор
  • Память. Нижний уровень
  • Память. Верхний уровень
  • Ввод-вывод
  • Кодирование символов

Компоненты ПК

  • Устройства вывода информации
  • Процессоры
  • Системные платы
  • BIOS: базовая система ввода-вывода
  • Оперативная память
  • Накопители на жёстких дисках
  • Видеоадаптеры
  • Устройства оптического хранения данных
  • Аудиоустройства

Интерфейсы

Мини блог

  • Операционные системы
  • IT
  • Сетевые технологии

Самое читаемое

  • Арифметико логическое устройство (АЛУ)
  • Страничный механизм в процессорах 386+. Механизм трансляции страниц
  • Организация разделов на диске
  • Диск Picture CD
  • White Book/Super Video CD
  • Прямой доступ к памяти, эмуляция ISA DMA (PC/PCI, DDMA)
  • Карты PCMCIA: интерфейсы PC Card, CardBus
  • Таблица дескрипторов прерываний
  • Разъемы процессоров
  • Интерфейс Slot A

Процессор

Конвейер команд. Конвейеризация — способ обеспечения параллельности выполнения команд

Подробности Родительская категория: Процессор Категория: Конвейер команд

Первым шагом на пути обеспечения параллельности уровня команд явилось создание конвейера команд. Идея конвейера команд была предложена в 1956 году С.А. Лебедевым. Команда подразделяется на несколько этапов, каждый из которых выполняется своей частью аппаратуры, причем, эти части могут работать параллельно. Если на выполнение каждого этапа расходуется одинаковое время (один такт), то на выходе процессора в каждый такт появляется результат очередной команды. Производительность при этом возрастает благодаря тому, что одновременно на различных ступенях конвейера выполняется несколько команд. Конвейерная обработка такого рода широко применяется во всех современных быстродействующих процессорах. Количество этапов, на которые конструкторы разбивают выполнение процессорной команды, может быть различным (в разных моделях процессоров х86 колеблется от 2 i8088 до 20 Pentium IV).

Конвейеризация — способ обеспечения параллельности выполнения команд

Выполнение типичной команды можно разделить на следующие этапы:

  • выборка команды — IF (по адресу, заданному счетчиком команд, из памяти извлекается команда);
  • декодирование команды / выборка операндов из регистров — ID;
  • выполнение операции / вычисление эффективного адреса памяти — EX;
  • обращение к памяти — MEM;
  • запоминание результата — WB.

В зависимости от типа команды и способа адресации, время выполнения команды сильно варьируется. Дольше всего выполняются этапы, связанные с обращением к памяти. На рисунках показаны блоки и конвейер команд гипотетического процессора, имеющего пять блоков исполнения команд и соответственно пять этапов (ступеней). Изображены выполняемые команды, номера тактов и этапы выполнения команд. На первом такте считывается первая команда. На втором, пока декодируется первая команда, считывается вторая. На пятом такте в процессоре одновременно находятся пять команд, каждая в своем узле.

Блоки прохождения команды в процессоре

Пятиступенчатая схема конвейера

Конвейеризация увеличивает пропускную способность процессора (количество команд, завершающихся в единицу времени), но она не сокращает время выполнения отдельной команды. Имеются некоторые накладные расходы на конвейеризацию, возникающие в результате несбалансированности задержки на каждой его ступени. Частота синхронизации (такт синхронизации) не может быть выше, чем время, необходимое для работы наиболее медленной ступени конвейера. Конвейер не всегда представляет собой линейную цепочку этапов. В ряде ситуаций оказывается выгодным, когда функциональные блоки соединены между собой не последовательно, а в соответствии с логикой обработки. Отдельные блоки в цепочке могут пропускаться, а другие — образовывать циклические процедуры. Это позволяет с помощью одного конвейера вычислять более одной функции.

Поток команд — естественная последовательность команд, проходящая по конвейеру процессора. Процессор может поддерживать несколько потоков команд (суперпроцессоры 5 и 6 поколения), если для каждого потока и каждого этапа есть исполнительные элементы.

Суперконвейер команд — разбиение каждой ступени на подступени при одновременном увеличении тактовой частоты внутри конвейера; включение в состав процессора многих конвейеров, работающих с перекрытием. Дробление ступеней позволяет поднять тактовые частоты процессора. К суперконвейерным относятся процессоры, в которых число ступеней больше шести (см. таблицу).

Суперконвейер

Cуперконвейер ведет не только к увеличению скорости вычислений, но и к возникновению дополнительных сложностей. Возрастает вероятность конфликтов. Дороже встает ошибка предсказания перехода — приходится сбрасывать весь длинный конвейер, на что требуется дополнительное время. Усложняется логика взаимодействия ступеней. Однако за счет использования новых архитектур удается справиться с большинством проблем. При рассмотрении современных процессоров будут описаны новые идеи: исполнения команд с изменением последовательности, переименования регистров, спекулятивного исполнения и другие.

Конвейер (Unix) — Pipeline (Unix)

В Unix-подобных компьютерных операционных системах конвейер представляет собой механизм межпроцессного взаимодействия с использованием передачи сообщений. Конвейер — это набор процессов, объединенных в цепочку своими стандартными потоками, так что выходной текст каждого процесса (stdout ) передается непосредственно как вход (stdin ) к следующему. Второй процесс запускается, поскольку первый процесс все еще выполняется, и они выполняются одновременно. Идею конвейеров отстаивал Дуглас Макилрой на прародине Unix, в Bell Labs, во время разработки Unix, формируя его философию инструментария.. Он назван по аналогии с физическим конвейером . Ключевой особенностью этих конвейеров является «сокрытие внутренних компонентов» (Ritchie Thompson, 1974). Это, в свою очередь, обеспечивает большую ясность и простоту системы.

Эта статья посвящена анонимным каналам, где данные, записанные одним процессом, буферизуются операционной системой до тех пор, пока они не будут прочитаны следующим процессом, и этот однонаправленный канал исчезает, когда процессы завершены. Это отличается от именованных каналов, где сообщения передаются в канал или из канала, которому присвоено имя в виде файла, и остаются после завершения процессов. Стандартный синтаксис оболочки оболочки для анонимных каналов состоит в том, чтобы перечислить несколько команд, разделенных вертикальными чертами («каналы» в обычном слове Unix):

process1 | process2 | process3

Например, чтобы вывести список файлов в текущем каталоге (ls ), оставьте только строки вывода ls, содержащие строку «key» (grep ) и просмотрите результат на прокручиваемой странице (меньше ), пользователь вводит следующее в командной строке терминала:

ls -l | ключ grep | less

» ls -l «создает процесс, вывод (stdout) которого передается по конвейеру на ввод (stdin) процесса для» grep key «, а также для процесса для» less «. Каждый процесс принимает входные данные от предыдущего процесса и производит выходные данные для следующего процесса через стандартные потоки. Каждый « | » сообщает оболочке, что нужно подключить стандартный выход команда слева к стандартному вводу команды справа с помощью механизма межпроцессного взаимодействия, который называется (анонимный) канал, реализованный в операционной системе. Каналы являются однонаправленными; данные проходят по конвейеру слева направо.

  • 1 Конвейеры в интерфейсах командной строки
    • 1.1 Поток ошибок
    • 1.2 Pipemill
    • 3.1 Сетевые каналы
    • 4.1 Другие операционные системы

    Конвейеры в интерфейсах командной строки

    Все широко используемые оболочки Unix ls имеет специальную синтаксическую конструкцию для создания конвейеров. При любом использовании команды записываются последовательно, разделенные символом ASCII вертикальной черты « | » (который по этой причине часто называют «трубкой персонаж»). Оболочка запускает процессы и устанавливает необходимые соединения между их стандартными потоками (включая некоторый объем памяти buffer ).

    Поток ошибок

    По умолчанию стандартные потоки ошибок («stderr ») процессов в конвейере не передаются через труба; вместо этого они объединяются и направляются в консоль. Однако многие оболочки имеют дополнительный синтаксис для изменения этого поведения. Например, в оболочке csh использование « | » вместо « | » означает, что стандартный поток ошибок также должен быть объединен со стандартным выводом и переданы в следующий процесс. Bourne Shell также может объединять стандартную ошибку с | начиная с bash 4.0 или с помощью 2>1 , а также перенаправлять ее в другой файл.

    Pipemill

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

    Однако оболочка может выполнять обработку напрямую, используя так называемые mill или pipemill (поскольку команда при используется для «измельчения» результатов начальной команды). Эта конструкция обычно выглядит примерно так:

    команда | пока читаем -r var1 var2. ; do # обрабатывать каждую строку, используя переменные, проанализированные в var1, var2 и т. д. # (обратите внимание, что это может быть подоболочка: var1, var2 и т. д. будут недоступны # после завершения цикла while; некоторые оболочки, такие как zsh и более новые # версии оболочки Korn обрабатывают команды слева от оператора pipe # в подоболочке) done

    Такая конвейерная обработка может не работать должным образом, если тело цикла включает команды, такие как cat и ssh , который читает из stdin : на первой итерации цикла такая программа (назовем ее стоком) будет читать оставшийся вывод из команда , и цикл завершится (с результатами в зависимости от специфики слива). Есть несколько способов избежать такого поведения. Во-первых, некоторые стоки поддерживают возможность отключения чтения из stdin (например, ssh -n ). В качестве альтернативы, если стоку не нужно читать какой-либо ввод из stdin , чтобы сделать что-то полезное, ему можно передать в качестве ввода.

    Поскольку все компоненты конвейера выполняются параллельно, оболочка обычно формирует подпроцесс (подоболочку) для обработки своего содержимого, что делает невозможным распространение изменений переменных во внешнюю среду оболочки. Чтобы решить эту проблему, вместо этого «конвейер» может быть загружен из здесь документа, содержащего подстановку команды, которая ожидает завершения работы конвейера перед тем, как просмотреть содержимое. В качестве альтернативы для параллельного выполнения можно использовать именованный канал или процесс подстановки. GNU bash также имеет параметр lastpipe для отключения разветвления для последнего компонента конвейера.

    Создание конвейеров программным способом

    Конвейеры могут быть созданы под управлением программы. Системный вызов Unix pipe() просит операционную систему создать новый объект анонимный канал. Это приводит к появлению двух новых открытых файловых дескрипторов в процессе: конец канала только для чтения и конец только для записи. Концы каналов выглядят как обычные анонимные файловые дескрипторы, за исключением того, что у них нет возможности поиска.

    Чтобы избежать взаимоблокировки и использовать параллелизм, процесс Unix с одним или несколькими новыми каналами обычно вызывает fork() для создавать новые процессы. Затем каждый процесс закроет конец (и) канала, который он не будет использовать, прежде чем производить или потреблять какие-либо данные. В качестве альтернативы процесс может создавать новые потоки и использовать канал для связи между ними.

    Именованные каналы также могут быть созданы с помощью mkfifo () или mknod () , а затем представлены как входной или выходной файл для программ как они вызываются. Они позволяют создавать многопутевые каналы и особенно эффективны в сочетании со стандартным перенаправлением ошибок или с tee .

    Реализация

    В большинстве Unix-подобных систем все процессы конвейер запускается одновременно с их потоками, соответствующим образом подключенными, и управляется планировщиком вместе со всеми другими процессами, запущенными на машине. Важным аспектом этого, отличающим каналы Unix от других реализаций каналов, является концепция буферизации : например, программа-отправитель может производить 5000 байтов за секунду, и принимающая программа может принимать только 100 байтов в секунду, но данные не теряются. Вместо этого вывод программы-отправителя сохраняется в буфере. Когда принимающая программа готова к чтению данных, следующая программа в конвейере читает из буфера. В Linux размер буфера составляет 65 536 байт (64 КБ). Доступен сторонний фильтр с открытым исходным кодом под названием bfr для предоставления при необходимости буферов большего размера.

    Сетевые каналы

    Такие инструменты, как netcat и socat, могут подключать каналы к сокетам TCP / IP .

    История

    Концепция конвейера была изобретена Дугласом Макилроем и впервые описана на страницах руководства в Версия 3 Unix. Макилрой заметил, что большую часть времени командные оболочки передают выходной файл из одной программы в качестве входных данных в другую.

    Его идеи были реализованы в 1973 году, когда («в одну лихорадочную ночь», — писал Макилрой) Кен Томпсон добавил системный вызов pipe () и каналы в оболочку и несколько утилит в версии 3 Unix. «На следующий день, — продолжил Макилрой, — произошла незабываемая оргия шуток, когда все присоединились к азарту сантехники». Макилрой также приписывает Томпсону обозначение | , которое значительно упростило описание синтаксиса конвейера в версии 4.

    Несмотря на то, что конвейеры Unix были разработаны независимо, они связаны с «связью» и предшествовали ей. files ‘, разработанный Кеном Лохнером в 1960-х годах для Дартмутской системы разделения времени.

    . В Тони Хоаре последовательные процессы обмена (CSP) получили дальнейшее развитие трубки Макилроя.

    Робот на значке Apple Automator, который также использует концепцию конвейера для связывания повторяющихся команд вместе, держит конвейер в знак уважения к исходной концепции Unix.

    Другие операционные системы

    Эта функция Unix была заимствована другими операционными системами, такими как Taos и MS-DOS, и в конечном итоге стало шаблоном проектирования конвейеров и фильтров разработки программного обеспечения.

    См. также

    • Все является файлом — описывает одну из определяющих особенностей Unix; конвейеры воздействуют на «файлы» в смысле Unix
    • Анонимный конвейер — структура FIFO, используемая для межпроцессного взаимодействия
    • GStreamer — основанная на конвейере мультимедийная структура
    • Конвейеры CMS
    • Iteratee
    • Именованный канал — постоянные каналы, используемые для межпроцессного взаимодействия
    • Замена процесса — синтаксис оболочки для подключения нескольких каналов к процессу
    • GNU parallel
    • конвейер (вычисления) — другой компьютер связанные конвейеры
    • Перенаправление (вычисление)
    • Тройник (команда) — общая команда для извлечения данных из конвейера
    • конвейер XML — для обработки файлов XML
    • xargs

    Ссылки

    Внешние ссылки

    • История нотации каналов в Unix
      • Первоначальная записка Дуга Макилроя 1964 года, в которой впервые предлагается концепция канала

      Использование потоков, конвейеров и перенаправлений в Linux

      img

      Операционные системы Unix традиционно используют такие понятия, как стандартный ввод, вывод и вывод ошибки. Чаще всего ввод — это клавиатура, а вывод это на кран. Но конечно же мы можем выводить исполнение какой-то команды в файл и передавать другой команде, потому что работая в Linux, создается такая последовательность из команд, т.е результат предыдущей мы отправляем следующей и т.д

      Целью данной статьи является рассмотреть:

      • Перенаправление стандартных ввода, вывода и ошибок;
      • Передача вывода одной команды в качестве аргументов другой;
      • Получение выходных данных в файл и на стандартный вывод;
      • Stdin (0) – ввод
      • Stdout(1) – вывод
      • Stderr (2) – вывод ошибки
      • > — передать в
      • >> — дописать в
      • — взять из
      • | — отправить следующей команде
      • Tee — отправить в файл и на стандартный вывод
      • Xargs – построчно передать на ввод команде

      Для начала воспользуемся командой wc которая посчитает, количество слов, символов и строк в файле wc test.txt .

      wc test.txt

      Мы можем указать данной команде другой input . Мы можем ей сказать взять информацию из файла, т.е. записать вот таким образом wc т.е. данной команде передать информацию из этого файла. И данная команда отработав посчитает в принципе то же самое. В таком варианте команда не знает с каким файлом она работает ей просто поступает вывод из файла. Файл выводит свой результат этой команде. Такая стрелочка редко используется, чаще используется стрелка в другую сторону. Например, мы можем список файлов вывести командой ls . А можем сказать, чтобы данная команда отправила результат не на наш стандартный вывод т.к. результат всех наших команд по умолчанию выводится в консоль, а например в файл ls > list.txt . По сути означает выполнить команду, а результат передать в файл. Фал можно посмотреть командой cat list.txt .

      cat list.txt

      И мы можем убедится, что в данном файле находится перечень, всего что находилось в данной папке. Если мы выполним еще раз команду ls > list.txt , то данный файл каждый раз будет перезаписываться. Если же мы хотим, чтобы наш файл не перезаписывался, а дописывался, используем другую стрелочку ls >> list.txt .

      cat list.txt

      И теперь вы можете видеть, что файл стал больше. Т.е. у нас записалось, то что было, а затем еще раз добавилось. Если опять выполнить команду со стрелочками >> , то опять допишется информация в файл. Вот таким образом работают “стрелочки”.

      Стандартный вывод ошибок.

      Мы можем, например, сказать машине, выведи нам содержимое папки bob , которая не существует ls bob > result.txt , естественно мы получим ошибку которую система вывела на экран. Экран является стандартным выводом ошибок. В нашем случае нет папки bob и нет файла resut.txt . Если мы хотим отправить ошибку в файл, так же как результат выполнения команды, то ls bob 2> result.txt , вспоминаем основные понятия, в которых было указанно, что 2 – это стандартный вывод ошибки.

      cat result.txt

      Следовательно, на экране мы уже не видим ошибки, потому что она отправилась в указанный файл.

      Кстати мы можем объединить стандартный вывод команды и стандартный вывод ошибки. Например: ls bob > result.txt 2> error.txt . Выведи содержимое папки bob в файл result.txt , а если возникнет ошибка внеси в файл error.txt .

      В таком случае и команда выполнится и что-то будет в файле и если ошибка возникнет, то она будет записана в файл error.txt . Это можно применять на практике, когда мы что-то делаем и предполагаем, что в процессе выполнения возникнут ошибки, то используя данную конструкцию данные ошибки мы все можем отправить в отдельный файл.

      Конвейер

      Конвейер умеет передавать выходные данные из одной программы, как входные данные для другой. Т.е. выполняется команда, мы получаем результат и передаем эти данные далее на обработку другой программе.

      Например, выполнить команду ls и далее мы могли стрелочкой отправлять результаты выполнения команды в файл, т.е. мы меняли только стандартный вывод, а не передавали другой программе. А можем выполнить ls | grep r , т.е. получить содержимое и передать по конвейеру команде сортировки и сказать отсортировать по наличию буквы r , а если перенаправить еще вывод в файл, то cat имя файла , мы сможем увидеть информацию в файле.

      cat имя файла

      Но есть другая команда tee которая позволяет работать немного удобнее. Например: ls | tee output.txt . Те данная команда выводит информацию сразу на экран и в указанный файл. Что достаточно удобно с точки зрения работы с выводами.

      И еще одна команда xargs – она построчно работает с выводами. Если у нас есть какая-то команда, которая выдает нам вывод в виде нескольких строк ответа, то мы можем эти строки построчно передавать этой команде, т.е. не одной кашей, а построчно. Например find . –name “*.txt” найти все файлы в текущем каталоге с расширением txt . И если бы мы захотели удалить все эти файлы нам бы пришлось построчно их удалять, но мы можем сказать, чтобы выходные данные были переданы по конвейеру xargs и удалить.

      find . –name “*.txt” | xargs rm -f

      ind . –name “*.txt” | xargs rm -f

      Как видите после данной конструкции команд файлов не осталось. Т.е. данные построчно передались на команду удаления, которая построчно каждый файл с ключом –f (принудительно) их и удалила.

      Конвейер (Unix)

      Эта статья посвящена оригинальной реализации оболочек. Общие сведения о программных конвейерах см. В разделе « Конвейер (программное обеспечение)» .

      Конвейер из трех программных процессов, выполняемых на текстовом терминале

      В Unix-подобных компьютерных операционных системах , A трубопровод представляет собой механизм для связи между процессами с помощью передачи сообщений. Конвейер — это набор процессов, объединенных в цепочку своими стандартными потоками , так что выходной текст каждого процесса ( stdout ) передается непосредственно как вход ( stdin ) следующему. Второй процесс запускается, поскольку первый процесс все еще выполняется, и они выполняются одновременно . Концепция конвейеров была отстаивалась Дугласом Макилроем в прародине Unix в Bell Labs.во время разработки Unix, формируя его философию инструментария . [1] [2] Он назван по аналогии с физическим конвейером . Ключевой особенностью этих конвейеров является «сокрытие внутренних компонентов» (Ritchie & Thompson, 1974). Это, в свою очередь, обеспечивает большую ясность и простоту системы.

      Эта статья посвящена анонимным каналам , в которых данные, записанные одним процессом, буферизуются операционной системой до тех пор, пока они не будут прочитаны следующим процессом, и этот однонаправленный канал исчезает, когда процессы завершаются. Это отличается от именованных каналов , где сообщения передаются в канал или из канала, которому присвоено имя путем преобразования его в файл, и остаются после завершения процессов. Стандартный синтаксис оболочки для анонимных каналов состоит в том, чтобы перечислить несколько команд, разделенных вертикальными чертами («каналы» в обычном слове Unix):

      process1 | process2 | процесс3
      ls -l | ключ grep | меньше

      » ls -l » создает процесс, вывод (stdout) которого передается по конвейеру на ввод (stdin) процесса для «grep key»; и то же самое для процесса «меньше». Каждый процесс принимает входные данные из предыдущего процесса и производит выходные данные для следующего процесса через стандартные потоки . Каждый » | » указывает оболочке соединить стандартный вывод команды слева со стандартным вводом команды справа с помощью механизма межпроцессного взаимодействия , называемого (анонимным) конвейером , реализованного в операционной системе. Трубы однонаправленные; данные проходят по конвейеру слева направо.

      • 1 Конвейеры в интерфейсах командной строки
        • 1.1 Поток ошибок
        • 1.2 Трубоперерабатывающий завод
        • 3.1 Сетевые трубы
        • 4.1 Другие операционные системы

        Конвейеры в интерфейсах командной строки [ править ]

        Все широко используемые оболочки Unix имеют специальную синтаксическую конструкцию для создания конвейеров. При любом использовании команды записываются последовательно, разделенные вертикальной чертой ASCII » » (которая по этой причине часто называется » вертикальной чертой | «). Оболочка запускает процессы и устанавливает необходимые соединения между их стандартными потоками (включая некоторый объем буферной памяти).

        Поток ошибок [ править ]

        По умолчанию стандартные потоки ошибок (» stderr «) процессов в конвейере не передаются по конвейеру; вместо этого они объединяются и направляются на консоль . Однако многие оболочки имеют дополнительный синтаксис для изменения этого поведения. Например, в оболочке csh использование » |& » вместо » | » означает, что стандартный поток ошибок также должен быть объединен со стандартным выводом и передан следующему процессу. Bourne Shell может также слить стандартную ошибку с |& так Баш 4.0 [3] или с использованием 2>&1 , а также перенаправить его в другой файл.

        Трубопровод [ править ]

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

        Тем не менее, это возможно для оболочки для выполнения обработки непосредственно, используя так называемую мельницу или pipemill (так как while команда используется для «мельницы» над результатами начальной команды). Эта конструкция обычно выглядит примерно так:

        команда | пока читаем -r var1 var2 . ; do # обрабатывать каждую строку, используя переменные, проанализированные в var1, var2 и т.д. # (обратите внимание, что это может быть подоболочка: var1, var2 и т. д. будут недоступны # после завершения цикла while; некоторые оболочки, такие как zsh и новее # версии оболочки Korn обработайте команды слева от оператора pipe # в подоболочке) выполнено

        Такая конвейерная обработка может работать не так, как задумано, если тело цикла включает в себя команды, такие как cat и ssh , которые читаются из stdin : [4] на первой итерации цикла, такая программа (назовем ее стоком ) будет читать оставшийся вывод из command , и затем цикл завершится (с результатами в зависимости от специфики слива). Есть несколько способов избежать такого поведения. Во-первых, некоторые стоки поддерживают возможность отключения чтения из stdin (например ssh -n ). В качестве альтернативы, если стоку не нужно читать какие-либо данные, stdin чтобы сделать что-то полезное, его можно использовать < /dev/null как ввод.

        Поскольку все компоненты конвейера выполняются параллельно, оболочка обычно создает подпроцесс (подоболочку) для обработки своего содержимого, что делает невозможным распространение изменений переменных во внешнюю среду оболочки. Чтобы решить эту проблему, вместо этого «конвейер» может быть загружен из документа здесь, содержащего подстановку команд , которая ожидает, пока конвейер завершит работу, прежде чем прорезать содержимое. В качестве альтернативы для параллельного выполнения можно использовать именованный канал или подстановку процесса . В GNU bash также есть lastpipe возможность отключить разветвление для последнего компонента канала. [5]

        Программное создание конвейеров [ править ]

        Конвейеры можно создавать под управлением программы. pipe() Системный вызов Unix просит операционную систему создать новый объект анонимного канала . Это приводит к появлению двух новых открытых файловых дескрипторов в процессе: конец канала, доступный только для чтения, и конец, доступный только для записи. Концы каналов выглядят как обычные анонимные файловые дескрипторы , за исключением того, что они не имеют возможности поиска.

        Чтобы избежать взаимоблокировки и использовать параллелизм, процесс Unix с одним или несколькими новыми каналами обычно вызывает fork() создание новых процессов. Затем каждый процесс закроет конец (и) канала, который он не будет использовать, прежде чем производить или потреблять какие-либо данные. В качестве альтернативы процесс может создавать новые потоки и использовать канал для связи между ними.

        Именованные каналы также могут быть созданы с использованием mkfifo() или, mknod() а затем представлены в качестве входного или выходного файла программам по мере их вызова. Они позволяют создавать многопутевые каналы и особенно эффективны в сочетании со стандартным перенаправлением ошибок или с tee .

        Реализация [ править ]

        В большинстве Unix-подобных систем все процессы конвейера запускаются одновременно, их потоки соответствующим образом связаны и управляются планировщиком вместе со всеми другими процессами, запущенными на машине. Важным аспектом этого, отличающим каналы Unix от других реализаций каналов, является концепция буферизации : например, программа-отправитель может производить 5000 байт в секунду., и принимающая программа может принимать только 100 байтов в секунду, но данные не теряются. Вместо этого вывод программы-отправителя сохраняется в буфере. Когда принимающая программа готова к чтению данных, следующая программа в конвейере читает из буфера. В Linux размер буфера составляет 65 536 байт (64 КБ). Доступен сторонний фильтр с открытым исходным кодом, называемый bfr, для предоставления при необходимости больших буферов.

        Сетевые трубы [ править ]

        Такие инструменты , как Netcat и SOCAT можно подключить трубы к TCP / IP сокетов .

        История [ править ]

        Концепция конвейера была изобретена Дугласом Макилроем [6] и впервые описана на страницах руководства версии 3 Unix . [7] Макилрой заметил, что большую часть времени командные оболочки передают выходной файл из одной программы в качестве входных данных в другую.

        Его идеи были реализованы в 1973 году, когда («в одну лихорадочную ночь», писал Макилрой) Кен Томпсон добавил pipe() системный вызов и каналы в оболочку и несколько утилит в версии 3 Unix. «На следующий день, — продолжил Макилрой, — произошла незабываемая оргия шуток, когда все присоединились к азарту сантехники». Макилрой также приписывает Томпсону | обозначение, которое значительно упростило описание синтаксиса конвейера в Версии 4 . [8] [7]

        Несмотря на независимость разработки, конвейеры Unix связаны с «коммуникационными файлами», разработанными Кеном Лохнером [9] в 1960-х годах для Дартмутской системы разделения времени , и предшествовали им . [10]

        В коммуникационных последовательных процессах (CSP) Тони Хора трубки Макилроя получили дальнейшее развитие. [11]

        Робот в пиктограмме от Apple «S Automator , который также использует концепцию конвейера для повторяющихся команд цепи вместе, держит трубу в честь оригинальной концепции Unix.

        Другие операционные системы [ править ]

        Основная статья: Pipeline (программное обеспечение)

        Эта особенность Unix была заимствована другими операционными системами, такие как MS-DOS и CMS трубопроводы пакет на VM / CMS и MVS , и в конце концов стала назначила трубу и фильтры шаблон дизайна из программной инженерии .

        См. Также [ править ]

        • Все является файлом — описывает одну из определяющих особенностей Unix; конвейеры воздействуют на «файлы» в смысле Unix
        • Анонимный канал — структура FIFO, используемая для межпроцессного взаимодействия
        • GStreamer — мультимедийный фреймворк на основе конвейера
        • Конвейеры CMS
        • Итеративная
        • Именованный канал — постоянные каналы, используемые для межпроцессного взаимодействия
        • Подстановка процесса — синтаксис оболочки для подключения нескольких каналов к процессу
        • GNU parallel
        • Конвейер (вычисления) — другие связанные с компьютером конвейеры
        • Перенаправление (вычисления)
        • Тройник (команда) — общая команда для извлечения данных из конвейера
        • XML pipeline — для обработки файлов XML
        • xargs

        Ссылки [ править ]

        1. ^ Махони, Майкл С. «Проект устной истории Unix: Выпуск.0, Начало» . Макилрой: Это было одно из немногих мест, где я почти осуществил управленческий контроль над Unix, настаивал на этом, да.
        2. ^ http://cm.bell-labs.com/cm/cs/who/dmr/mdmpipe.html [ постоянная мертвая ссылка ]
        3. ^ «Примечания к выпуску Bash» . tiswww.case.edu . Проверено 14 июня 2017 .
        4. ^ «Взаимодействие цикла оболочки с SSH» . 6 марта 2012 года Архивировано из оригинала 6 марта 2012 года.
        5. ^ John1024. «Как я могу сохранить результаты команды« найти »в виде массива в Bash» . Переполнение стека .
        6. ^ «Создание операционной системы UNIX» . Bell Labs. Архивировано из оригинального 14 сентября 2004 года.
        7. ^ а б Макилрой, доктор медицины (1987). Читатель Research Unix: аннотированные выдержки из Руководства программиста, 1971–1986 (PDF) (технический отчет). CSTR. Bell Labs. 139.
        8. ^ http://www.linfo.org/pipe.html Pipes: краткое введение от Linux Information Project (LINFO)
        9. ^ http://www.cs.rit.edu/~swm/history/DTSS.doc
        10. ^ http://cm.bell-labs.com/who/dmr/hist.html [ постоянная мертвая ссылка ]
        11. ^ https://swtch.com/~rsc/thread/ Bell Labs и потоки CSP (Расс Кокс)
        • Сал Согоян в эпизоде ​​3 MacBreak «Enter the Automatrix»

        Внешние ссылки [ править ]

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *