Прелюдия: Это, по общему признанию, довольно широкий вопрос, касающийся компьютерной архитектуры, но тот, который я слышу от других, и задаюсь вопросом довольно часто о себе. Я также не думаю, что есть прямой или быстрый ответ на это. Тем не менее, я надеялся, что кто-то хорошо разбирающийся в системной архитектуре сможет дать некоторое представление.
Немного предыстории: я в основном разработчик полного стека, занимающийся в основном веб-технологиями и базами данных. У меня есть некоторый опыт работы с языком Си и работа с большим количеством низкоуровневых вещей, но это было очень давно и не было академическим. Таким образом, я никогда не углублялся в архитектуру ОС, и это одна вещь, которая ускользает от меня. Мне известны различные методы и методы выполнения этих задач (особенно на более высоком уровне с технологиями, предназначенными для этой цели), но мне не хватает целостного представления / понимания низкоуровневой логистики о том, как это происходит, особенно на уровне ОС,
Тест старой и новой видеокарты
Общий вопрос: как приложения, работающие внутри «контейнера», фактически взаимодействуют с работающим экземпляром этого контейнера? Под «контейнером» я подразумеваю экземпляр запущенного кода, который уже загружен в память (примерами такого кода могут быть операционная система, интерфейс графического рисования, сервер приложений, драйвер и т. Д.).
Кроме того, этот вопрос относится только к скомпилированному коду и к связи между системами, работающими на одном компьютере.
Например
Допустим, я создаю простую библиотеку, цель которой — нарисовать пиксель на экране. Скажем также, у этой библиотеки есть один метод, drawPixel(int x, int y) ,
Сама библиотека управляет своим собственным контекстом рисования (который может быть чем угодно, от необработанного буфера SVGA до окна рабочего стола). Приложения, использующие этот API, просто динамически связываются с библиотекой и вызывают drawPixel метод, без какой-либо осведомленности о точных действиях библиотеки после вызова.
Под капотом этот drawPixel метод должен рисовать в окне на рабочем столе, создавая его, если он не существует при первом вызове.
Тем не менее, технически, что бы произошло, если бы установка была такой простой и понятной, это то, что каждое вызывающее приложение «вытягивало бы и запускало» весь код в drawPixel и его зависимостей, фактически заставляя каждое работающее приложение иметь свой собственный работающий экземпляр всей цепочки вызовов (и, таким образом, если бы оно вызывалось 5 разными приложениями, вы бы получили 5 разных окон вместо общего контекста для одного окна).). (Я надеюсь, что я объясняю это правильно)
Итак, мой вопрос: как происходит такое «совместное использование» в современных операционных системах?
Будет ли код для drawPixel на самом деле заменить на код IPC? Или это будет обычный графический код, но каким-то образом «загруженный» в ОС таким образом, что существует один общедоступный работающий экземпляр, который другие приложения вызывают по желанию?
Как работает компьютер? Шины адреса, управления и данных. Дешифрация. Взгляд изнутри!
Некоторые случаи, о которых я знаю
Я знаю, что есть много подходов к этой проблеме, и знаю о некоторых из них. Тем не менее, кажется, что все они связаны с конкретными нишами и имеют недостатки; ни один из них не обладает достаточной полнотой для объяснения невероятных возможностей (в отношении взаимосвязанности ОС и служб приложений) современных экосистем приложений.
- В старые (ДОС) дни я верю app OS связь осуществлялась через системные прерывания.
- В мире UNIX это делается через stdin / stdout каналы на консоли и сетевой протокол в X Windows.
- Были платформы IPC, такие как COM+/DCOM/DCOP/DBus для Windows и Linux, но, опять же, они, похоже, предназначены для определенной цели (создание и управление компонентами в масштабе; предшественники современной SOA).
Вопрос
Каковы другие способы облегчения такого общения? Или, более конкретно, как «это делается» в традиционном смысле, особенно когда это касается API-интерфейсов ОС?
Некоторые примеры более конкретных вопросов:
- Как ядро »загружает» драйвер устройства при загрузке, который запускает свой собственный код (в изолированном пространстве?), Но все еще взаимодействует с ядром над ним, которое в данный момент работает в памяти? Как происходит это общение?
- Как взаимодействуют оконные подсистемы (за исключением X и Quartz, которые используют сокеты)? Я думаю, что WIN32 использовал прерывания (возможно, это все еще делает?), Но как работает более новый материал? Я был бы очень удивлен, узнав, что даже в наши дни сложные среды, такие как WPF или Metro, все еще сводятся к вызову прерываний. Я на самом деле не уверен, что API-интерфейсы WIN32 даже используются этими системами.
- Как насчет низкоуровневых графических подсистем, таких как GDI+ и Linux Framebuffer?
Примечание: я думаю, что в случае WIN32 (и, возможно, GDI+), например, вы получаете указатель (дескриптор) на контекст, поэтому концепция фактически является «разделяемой памятью». Но так ли это просто? Было бы довольно небезопасно просто получить необработанный указатель на необработанный ресурс. Это значит, что есть вещи, которые защищают вас от записи произвольных данных в этот указатель, поэтому я думаю, что он более сложный, чем этот.
- (это может быть немного вне контекста, поскольку это специфично для JVM) Как сервлеты, работающие на сервере приложений, взаимодействуют с реальным сервером приложений? Имеется в виду, как они загружают себя «в контексте» текущего запущенного сервера?
- Тот же вопрос для IIS — как точно настроена сантехника, чтобы IIS могла контролировать и взаимодействовать с отдельным процессом, выполняющим приложение ASP.NET?
Примечание: я не уверен, имеет ли этот вопрос много смысла и может ли он быть глупым или плохо сформулированным. Тем не менее, я надеялся, что моя точка зрения натолкнулась на то, что кто-то, имеющий опыт работы с системами, может подключиться к стандартному «образу действий», когда речь заходит об этих сценариях (если таковые имеются).
Изменить: я не прошу исчерпывающий список методов IPC. Есть конкретная концепция, о которой я пытаюсь выяснить, но я не знаком с правильной терминологией и поэтому не могу найти слова, чтобы точно ее определить. Вот почему этот вопрос содержит так много примеров, чтобы «устранить» те части, на которые вопрос не нацелен.
Источник: stackru.com
Архитектура компьютеров: как приложения взаимодействуют с операционной системой?
Прелюдия: Это, по общему признанию, довольно широкий вопрос в отношении компьютерной архитектуры, но тот, который я слышу от других, и довольно часто задаюсь вопросом. Я также не думаю, что есть прямой или быстрый ответ на это. Тем не менее, я надеялся, что кто-то хорошо разбирающийся в архитектуре систем может дать некоторую информацию.
Некоторые предпосылки: я в первую очередь разработчик полного стека, в основном ориентированный на веб-технологии и базы данных. У меня есть некоторый опыт работы на C и возиться с большим количеством низкоуровневых материалов, но это было очень давно и не было академическим. Таким образом, я никогда не очень углублялся в архитектуру ОС, и это одна часть, которая ускользает от меня. Я знаю о различных методах и методах решения этих задач (особенно на более высоком уровне с технологиями, предназначенными для этой цели), но мне не хватает целостной картины/понимания логики низкого уровня, как это происходит – особенно на уровне ОС.
Общий вопрос: как приложения, запущенные внутри “контейнера”, действительно разговаривают с исполняемым экземпляром этого контейнера? Под “контейнером” я подразумеваю экземпляр запущенного кода, который уже загружен в память (примерами такого кода могут быть операционная система, интерфейс графического рисования, сервер приложений, драйвер и т.д.).
Кроме того, этот вопрос относится только к скомпилированному коду и к связи между системами, запущенными на одном компьютере.
Например
Скажем, я создаю простую библиотеку, цель которой – нарисовать пиксель на экране. Пусть также говорят, что эта библиотека имеет один метод, drawPixel(int x, int y) .
Сама библиотека управляет собственным контекстом рисования (который может быть любым из необработанного буфера SVGA в окно рабочего стола). Приложения, использующие этот API, просто динамически связывают динамику с библиотекой и вызывают метод drawPixel , не зная о точном действии библиотеки после вызова.
Под капотом этот метод drawPixel должен нарисовать в окне на рабочем столе, создав его, если он не существует при первом вызове.
Однако технически то, что произойдет, если установка будет простой и простой, заключается в том, что каждое вызывающее приложение будет “вытягивать и запускать” весь код в drawPixel и его зависимостях, что заставляет каждое запущенное приложение иметь свои собственные (и, следовательно, если он был вызван 5 различными приложениями, в итоге вы получите 5 разных окон вместо общего контекста в одно окно). (Надеюсь, я объясню это правильно)
Итак, мой вопрос: как этот “обмен” происходит в современных операционных системах?
Будет ли код для drawPixel действительно заменен кодом IPC? Или это будет обычный графический код, но каким-то образом “загружен” в ОС таким образом, что есть один универсально доступный исполняемый экземпляр, который другие приложения вызовут по-волю?
В некоторых случаях я знаю
Я знаю, что есть много подходов к этой проблеме, и я знаю о некоторых из них. Однако все они, похоже, затрагивают конкретные ниши и имеют недостатки; ни один из них не является достаточно полным, чтобы объяснить невероятные возможности (относительно взаимосвязанности служб ОС и приложений) современных экосистем приложений.
- В старые (DOS) дни я полагаю, что связь app OS была выполнена с помощью системных прерываний.
- В мире UNIX это делается через трубки stdin / stdout на консоли и сетевой протокол в X Windows.
- В Windows и Linux были платформы IPC, такие как COM +/DCOM/DCOP/DBus, но опять же, они, похоже, ориентированы на определенную цель (создание и управление компонентами в масштабе, предшественники современной SOA).
Вопрос
Каковы некоторые другие способы облегчения такого рода общения? Или, более конкретно, как “это делается” в традиционном смысле, особенно когда речь заходит об OS API?
Некоторые примеры более конкретных вопросов:
- Как ядро загружает драйвер устройства при загрузке, который запускает собственный код (в изолированном пространстве?), но все еще разговаривает с ядром над ним, которое в настоящее время работает в памяти? Как происходит это общение?
- Как работают оконные подсистемы (за исключением X и Quartz, которые используют сокеты) с приложениями? Я думаю, что WIN32 использовал прерывания (может быть, он все еще делает?), Но как работает новый материал? Я был бы очень удивлен, узнав, что даже в настоящее время сложные фреймворки, такие как WPF или Metro, все еще сводятся к вызовам прерываний. Я действительно не уверен, что API WIN32 даже используются этими системами.
- Что относительно низкоуровневых графических подсистем, таких как GDI + и Linux Framebuffer?
Примечание. Я думаю, что в случае WIN32 (и, возможно, GDI +), например, вы получаете указатель (дескриптор) для контекста, поэтому концепция эффективно “разделяемая память”. Но так ли это просто? Было бы довольно небезопасно просто получить необработанный указатель на сырьевой ресурс. Значит, есть вещи, которые защищают вас от написания произвольных данных этому указателю, поэтому я думаю, что это сложнее, чем это.
- (это может быть немного вне контекста, поскольку его спецификация JVM) Как сервлеты, запущенные внутри сервера приложений, разговаривают с реальным сервером приложений? Смысл, как они загружаются “внутри контекста” текущего сервера?
- Тот же вопрос для IIS. Как точно устанавливается настройка сантехнического оборудования, чтобы IIS мог контролировать и обмениваться данными с помощью отдельного процесса, использующего приложение ASP.NET?
Примечание. Я не уверен, что этот вопрос имеет смысл и может быть, по общему признанию, глупым или плохо сформулированным. Тем не менее, я надеялся, что мой пункт натолкнулся на ситуацию и что кто-то с системным фоном может перекликаться со стандартным “способом делать вещи”, когда дело доходит до этих сценариев (если есть такая вещь).
Изменить: я не прошу исчерпывающий список методов IPC. Существует определенная концепция, о которой я пытаюсь узнать, но я не знаком с правильной терминологией, и поэтому мне трудно найти слова, чтобы точно определить ее. Вот почему этот вопрос приходит с таким количеством примеров, чтобы “исключить” те части, на которые не задан вопрос.
Лучший ответ:
Слишком широкий вопрос, но некоторые моменты (связанные с Linux, принципы должны быть одинаковыми для Windows, но вам, вероятно, запрещено понимать все):
Элементарный системные вызовы (перечисленные в syscalls (2 )…) вызывается элементарной (например, SYSENTER или SYSCALL ), которая переключает процессор в ядро режим (с номером системного вызова и аргументами, прошедшими через определенные регистры, после ABI). Следовательно, код пользовательского пространства можно рассматривать как запущенный в некоторой виртуальной машине (определяемой инструкциями пользовательского режима + примитивами системного вызова). BTW ядро Linux может загружать модули ядра, например. добавьте в него дополнительный код (например, драйверы устройств), и это делается также через системные вызовы.
взаимодействие между процессами построены над этими системными вызовами (возможно, используются стандартной библиотекой в функциях более высокого уровня, например getaddrinfo (3) может косвенно взаимодействовать с некоторой службой DNS, см. nsswitch.conf(5)). Подробнее читайте Расширенное программирование Linux.
На практике вам понадобятся несколько server программ (и эта идея доведена до предела в microkernel), особенно (в недавнем Linux) systemd. Драйверы и модули ядра загружаются определенными системными вызовами, а затем являются частью ядра, поэтому могут использоваться другими системными вызовами. Играйте с strace (1), чтобы понять фактические системные вызовы, сделанные некоторой программой Linux. Некоторая информация предоставляется ядром через pseudo файловые системы (см. proc (5)…), доступных через системные вызовы.
Каждое сообщение из пользовательской программы в ядро выполняется IPC (реализуется системными вызовами). Иногда ядро делает upcall для кода пользователя (на Linux, сигналы).
Бадбуффер Linux (и физическая клавиатура и мышь) обычно доступен только одному серверу, с которым другие настольные приложения общаются с использованием обычных средств IPC – sockets – этот сервер является X11 или Wayland.
Для Windows, MacOSX, Android, это очень похоже. Однако, поскольку Windows (и т.д.) Является проприетарным программным обеспечением, вы, возможно, не сможете узнать все подробности (и вы не можете разрешить обратный инженер их). Напротив, Linux бесплатное программное обеспечение, поэтому вы можете изучить его исходный код.
Моим советом было бы детально разобраться, как работает Linux (это займет несколько лет) и изучите некоторый соответствующий исходный код (что возможно для бесплатного программного обеспечения). Если вам нужно глубокое понимание Windows, вам может потребоваться купить лицензию на исходный код (возможно, миллионы долларов) и подписать NDA. Я вообще не знаю Windows, но AFAIK определяется только огромным API в C. Слухи говорят, что ядро Windows – это микроядро но Microsoft имеет экономический интерес, чтобы скрыть уродливые детали реализации.
Источник: techarks.ru
Взаимодействие программ и Windows
Во многих операционных системах взаимодействие между системой и программой инициализирует программа. Например, в DOS программа запрашивает разрешение на ввод и вывод данных. Говоря другими словами, не- Windows-программы сами вызывают операционную систему. Обратного процесса не происходит. В Windows все совершенно наоборот: именно система вызывает программу.
Это осуществляется следующим образом: программа ожидает получения сообщения от Windows. Когда это происходит, то выполняется некоторое действие. После его завершения программа ожидает следующего сообщения.
Windows может посылать программе сообщения множества различных типов. Например, каждый раз при щелчке мышью в окне активной программы посылается соответствующее сообщение. Другой тип сообщений посылается, когда необходимо обновить содержимое активного окна. Сообщения посылаются также при нажатии клавиши, если программа ожидает ввода с клавиатуры.
Необходимо запомнить одно: по отношению к программе сообщения появляются случайным образом. Вот почему Windows-программы похожи на программы обработки прерываний: невозможно предсказать, какое сообщение появиться в следующий момент.
Основы программирования под Windows
Поскольку архитектура Windows-программ основана на принципе сообщений, все эти программы содержат некоторые общие компоненты. Обычно их приходится в явном виде включать в исходный код. Но, к счастью, при использовании библиотеки MFC это происходит автоматически; нет необходимости тратить время и усилия на их написание. Тем не менее, чтобы до конца разобраться, как работает Windows-программа, написанная с использованием MFC, и почему она работает именно так, необходимо в общих чертах понять назначение этих компонентов.
Функция WinMain()
Все Windows-программы начинают выполнение с вызова функции WinMain(). При традиционном методе программирования это нужно делать явно. С использованием библиотеки MFC такая необходимость отпадает, но функция все-таки существует.
Понравилась статья? Добавь ее в закладку (CTRL+D) и не забудь поделиться с друзьями:
Источник: studopedia.ru