Как известно процессоры x86 из нескольких процессов?

Question

Я уверен, что ответ на этот вопрос есть где-то в Интернете (или даже stackoverflow), однако мне сложно сформулировать вопрос, чтобы получить хорошие результаты.

Я изучаю x86 на прошлой неделе и был смущен концепцией процессоров x86, которые «знают» о различных процессах. Например, при работе в защищенном режиме процессор x86 способен ограничить память, в которой процесс может получить доступ. Это заставляет меня полагать, что процессор каким-то образом знает о существовании нескольких процессов.

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

Однако из-за того, что процессор x86 может ограничить доступ к памяти по процессу, CPU каким-то образом осознает, что существует несколько процессов.

Answer 1

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

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

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

Итак, теперь у нас есть все части: код, который процессор выполняет при его включении, - это операционная система, а операционная система динамически управляет выполнением дополнительного кода. Большинство из этих единиц исполнения называются процессов. (Но не весь код такой: например, загружаемые модули ядра в Linux динамически загружаются, но не представляют собой процесс.) То есть процесс представляет собой абстрактную концепцию в операционной системе, которая определяет между собственным кодом ОС и «хостинг» код, который он выполняет по запросу.

В зависимости от типа ОС выполнение процессов может иметь такие необычные функции, как виртуальная память (каждый процесс видит свою собственную, отдельную память) и защиту (никакой процесс не может влиять на работу ОС или других процессов) , ОС реализует такие функции, используя функции ЦП: модуль диспетчера памяти, который обеспечивает преобразование адресов, и защитные кольца, которые ограничивают инструкции, доступные для части выполнения. Однако не все ОС делают это; в DOS, например, каждый процесс имеет полный доступ к физической памяти и, следовательно, к состоянию ОС. Независимо от того, ОС обычно предоставляет API для процессов (например, «системные вызовы»), снова используя аппаратные функции (прерывания или специальные инструкции для системного вызова), а пользовательский код обычно взаимодействует с окружающей средой через этот API, а не напрямую разговаривает с периферийными устройствами. Например, это означает, что аппаратные драйверы реализованы только операционной системой, а код пользователя может делать непрозрачные «выходные сообщения» без необходимости знать детали доступных устройств вывода.

Пример: Может быть, это полезно, чтобы показать, что процессы на популярной операционной системы Linux, работающий на платформе х86: Новый процесс начинается, когда существующий процесс (например, оболочка, или init) вызывает clone системный вызов , путем повышения прерывания 128. Прерывание делает управление передачей ЦП обработчиком прерываний, который был установлен ОС во время загрузки. Когда введен обработчик прерываний, CPU переключается на режим 0, привилегированный. Обработчик прерываний заставляет ядро ​​создать новый процесс, а затем передает управление обратно вызывающему процессу (что подразумевает переход на защитное кольцо 3, непривилегированное; процессы только когда-либо выполняются в кольце 3). Для создания нового процесса ядро ​​создает соответствующие внутренние структуры бухгалтерского учета, настраивает новые таблицы страниц в MMU и затем передает управление точке входа для вызова clone, аналогично тому, как возвращается исходный вызов. (Я задумываюсь о проблемах планирования здесь, только одна передача контроля происходит одновременно, а другие «запланированы» позже.) Тот факт, что новый процесс существует сейчас, просто отражен в внутренних бухгалтерских данных ядра , CPU ничего не знает об этом; все, что он видит, это то, что прерывания увольняются, а таблицы страниц регулярно меняются.

Answer 2

ЦП не знает о планировании процесса, последний может быть реализован по-разному, в то время как первый должен быть чипом общего назначения.

Как это происходит

1. ОС находятся под контролем (читайте: центральный процессор выполняет подпрограмму ОСОВ) и расстановки песочницы A, который будет использоваться для запуска кванта процесса А.
2. процесса А внутри этой песочницы выполняется.
3. Выполняется периодическое прерывание, процедура, которая служит для этого прерывания, относится к ОС, и она находится вне изолированной программной среды.
4. ОС находится в управлении и настраивает песочницу B, которая будет использоваться для запуска кванта процесса B.
5. Процесс B выполняется внутри этой песочницы.

Процесс повторяется.

Защищенный режим позволяет ОС создавать песочницы, в частности, он определяет привилегии (в реальном режиме каждая программа имеет те же привилегии), чтобы Process A и Process B не могли покинуть песочницу (например, отключив прерывания и работая навсегда) ,

ЦП не знает о том, что происходит, он просто видит последовательность инструкций, выполняемых под разными привилегиями и «ограничениями».
Это ОС, которая конфигурирует CPU по-разному перед выполнением другой программы.
Это также помогает объяснить разницу между потоками и процессами: планирование потоков не изменяет песочницу.

Поскольку Шестер помнил меня в комментариях, x86 поддерживает управление задачами.
Однако задача HW не сопоставляет один-к-одному с процессом ОС (IIRC эта функция почти не используется основными ОС).

Чтение Intel Manual 3 поможет вам понять, что процессор способен и где ответственность за безопасные смены ОС от процессора к ядру.

Answer 3

CPU видит ОДИН процесс за раз. ЦП не знает о процессе, если он не выполняет.

Например, при работе в защищенном режиме процессор x86 способен ограничить память, в которой процесс может получить доступ.

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

Структура таблиц страниц определяется процессором. Содержимое этих таблиц устанавливается операционной системой. Таким образом, «предел» в памяти поступает из операционной системы.

Часть процедуры для изменения текущего процесса (вызванного операционной системой) заключается в замене таблиц страниц для нового процесса вместо старых.

Процессоры видят эти «ограничения» доступа к памяти с точки зрения выполняемого в настоящее время процесса и в любой момент времени не имеют никаких знаний об эквивалентных «ограничениях» (таблицах страниц) любого другого процесса.

Однако, из-за того, что процессор x86 может ограничить доступ к памяти процессом, CPU каким-то образом знает, что существует несколько процессов.

ЦП знает только о таблицах страниц текущего процесса. Он знает только «пределы» процесса, который выполняется. Набор текущей таблицы страниц определяет, какую физическую память может получить процесс, и как он может получить к ней доступ (чтение/запись/выполнение + ограничения по режиму).

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

Плюс прерывания, которые являются ключевой частью планирования процесса.