RTLinux

редактировать
RTLinux
Автор (ы) Виктор Йодайкен, Майкл Барабанов
Разработчик (и) FSMLabs, Wind River Systems
Написано наC
Операционной системе Linux
Доступно наанглийском языке
Тип Ядро
Лицензия GPL2

RTLinux - это операционная система жесткого реального времени операционная система реального времени (RTOS) микроядро, которое запускает всю операционную систему Linux как полностью упреждающий процесс. Свойство жесткого реального времени позволяет управлять роботами, системами сбора данных, производственными предприятиями и другими чувствительными ко времени приборами и машинами из приложений RTLinux. Несмотря на похожее название, он не имеет отношения к проекту Real-Time Linux из Linux Foundation.

. RTLinux был разработан Виктором Йодайкеном, Майклом Барабановым, Корт Дуганом и другими на Институт горного дела и технологии Нью-Мексико, а затем в качестве коммерческого продукта в FSMLabs. Wind River Systems приобрела встраиваемую технологию FSMLabs в феврале 2007 года и сделала версию Wind River Real-Time Core для Wind River Linux доступной. В августе 2011 года Wind River прекратила выпуск линейки продуктов Wind River Real-Time Core, фактически прекратив коммерческую поддержку продукта RTLinux.

Содержание

  • 1 Предпосылки
  • 2 Реализация
  • 3 Цель
  • 4 Основные компоненты
  • 5 Функциональность
  • 6 Задачи в реальном времени
  • 7 Потоки
  • 8 См. Также
  • 9 Ссылки
  • 10 Источники
  • 11 Внешние ссылки

Предпосылки

Ключевая цель разработки RTLinux заключалась в добавлении возможностей жесткого реального времени в обычную операционную систему для облегчения разработки сложных программ управления с обе возможности. Например, кто-то может захотеть разработать контроллер двигателя в реальном времени, который использовал бы базу данных товаров и экспортировал веб-интерфейс оператора. Вместо того, чтобы пытаться создать единую операционную систему, которая могла бы поддерживать возможности как в реальном времени, так и не в реальном времени, RTLinux был разработан для совместного использования вычислительного устройства между операционной системой реального и не реального времени, так что (1) Операционная система реального времени никогда не может быть заблокирована от выполнения операционной системой, не работающей в режиме реального времени, и (2) компоненты, работающие в двух разных средах, могут легко обмениваться данными. Как следует из названия, RTLinux изначально был разработан для использования Linux в качестве системы, не работающей в режиме реального времени, но со временем он развился так, что ядро ​​реального времени RTCore могло работать как с Linux, так и с BSD UNIX.

Multi-Environment Real- Time (MERT) был первым примером операционной системы реального времени, сосуществующей с системой UNIX. MERT полагался на традиционные методы виртуализации: ядро ​​реального времени было операционной системой хоста (или гипервизором ), а Bell Systems UNIX была гостевой. RTLinux был попыткой обновить концепцию MERT до эпохи ПК и массового оборудования. Это также была попытка преодолеть ограничения производительности MERT, особенно накладные расходы, связанные с виртуализацией.

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

С точки зрения программиста, RTLinux изначально выглядел как небольшая многопоточная среда для задач реального времени плюс стандартная среда Linux для всего остального. Операционная система реального времени была реализована как загружаемый модуль ядра, который начал с виртуализации управления прерываниями гостя, а затем запустил планировщик реального времени. Задачам назначались статические приоритеты, а планирование изначально основывалось исключительно на приоритетах. Гостевая операционная система была включена как задача с самым низким приоритетом и, по сути, действовала как неактивная задача для системы реального времени. Задачи в реальном времени выполнялись в режиме ядра. Позднее развитие RTLinux приняло интерфейс прикладного программирования POSIX thread (API ), а затем разрешило создание потоков в пользовательском режиме с потоками реального времени, выполняемыми внутри гостевых процессов. В многопроцессорных средах потоки были привязаны к ядрам процессора, и можно было предотвратить запуск гостевого потока на назначенном ядре (эффективно резервируя ядра только для обработки в реальном времени).

Реализация

RTLinux предоставляет возможность запускать специальные задачи в реальном времени и обработчики прерываний на той же машине, что и стандартный Linux. Эти задачи и обработчики выполняются, когда им необходимо выполнить, независимо от того, что делает Linux. Время наихудшего случая между моментом обнаружения аппаратного прерывания процессором и моментом начала выполнения обработчика прерывания составляет менее 15 микросекунд на RTLinux, работающем на стандартной x86 (около 2000 года). Периодическая задача RTLinux выполняется в течение 35 микросекунд от запланированного времени на том же оборудовании. Это время ограничено оборудованием, и по мере улучшения оборудования RTLinux также будет улучшаться. Стандартный Linux имеет превосходную среднюю производительность и может даже обеспечить точность планирования на уровне миллисекунд для задач, использующих возможности программного обеспечения реального времени POSIX. Стандартный Linux, однако, не предназначен для обеспечения субмиллисекундной точности и надежных гарантий синхронизации. RTLinux был основан на облегченной виртуальной машине, где «гостю» Linux были предоставлены виртуализированный контроллер прерываний и таймер, а все остальное оборудование было прямым. С точки зрения «хоста» реального времени ядро ​​Linux представляет собой поток. Прерывания, необходимые для детерминированной обработки, обрабатываются ядром реального времени, тогда как другие прерывания перенаправляются в Linux, который работает с более низким приоритетом, чем потоки реального времени. Драйверы Linux обрабатывали почти все ввода-вывода. Каналы First-In-First-Out (FIFO ) или разделяемая память могут использоваться для обмена данными между операционной системой и RTLinux.

Цель

Ключевая цель дизайна RTLinux - сделать систему прозрачной, модульной и расширяемой. Прозрачность означает, что нет неоткрываемых черных ящиков, и стоимость любой операции должна быть определяемой. Модульность означает, что можно упустить функциональность и расходы на эту функциональность, если она не нужна. А расширяемость означает, что программисты должны иметь возможность добавлять модули и адаптировать систему к своим требованиям. Базовая система RTLinux поддерживает высокоскоростную обработку прерываний и не более того. Он имеет простой планировщик приоритетов, который можно легко заменить на планировщики, более подходящие для нужд конкретного приложения. При разработке RTLinux он был разработан, чтобы максимизировать преимущества, которые мы получаем от наличия Linux и его мощных возможностей.

Основные компоненты

RTLinux структурирован как небольшой базовый компонент и набор дополнительных компонентов. Базовый компонент позволяет устанавливать обработчики прерываний с очень малой задержкой, которые не могут быть отложены или вытеснены самим Linux, а также некоторые процедуры синхронизации и управления прерываниями низкого уровня. Этот базовый компонент был расширен для поддержки SMP, и в то же время он был упрощен за счет удаления некоторых функций, которые могут быть предоставлены вне ядра.

Функциональные возможности

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

  1. rtl sched - планировщик приоритетов, который поддерживает как "облегченный" интерфейс POSIX, описанный ниже, так и исходный V1 RTLinux API.
  2. rtl time - который управляет тактовой частотой процессора и экспортирует абстрактный интерфейс для подключения обработчиков к часам.
  3. rtl posixio - поддерживает интерфейс чтения / записи / открытия в стиле POSIX для драйверов устройств.
  4. rtl fifo - подключает RT-задачи и обработчики прерываний к процессам Linux через уровень устройства чтобы процессы Linux могли читать / писать в компоненты RT.
  5. semaphore - добавленный пакет Джерри Эпплина, который дает RT-задачи, блокирующие семафоры.
  6. Поддержка мьютексов POSIX планируется в следующем обновление второстепенной версии RTLinux.
  7. mbuff - это дополнительный пакет, написанный Томашем Мотылевски для обеспечения общей памяти между компонентами RT и процессами Linux.

Задачи реального времени

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

Threads

RT-Linux реализует POSIX API для управления потоками. Поток создается путем вызова функции pthread_create. Третий параметр pthread_create- это функция, которая содержит код, выполняемый потоком.

Необходимо установить приоритеты потоков в RTLinux. Потоки с более высоким приоритетом могут вытеснять потоки с более низким приоритетом. Например, у нас может быть поток, управляющий шаговым двигателем. Чтобы мотор двигался плавно, необходимо запускать эту нить строго через равные промежутки времени. Это можно гарантировать, назначив этому потоку высокий приоритет. В примере thread2.c устанавливаются разные приоритеты потоков. Установка приоритета потока выполняется с помощью кода, показанного ниже:

int init_module (void) {pthread_attr_t attr; struct sched_param param; pthread_attr_init (attr); param.sched_priority = 1; pthread_attr_setschedparam (attr, ¶m); pthread_create (t1, attr, thread_code, "это поток 1"); rtl_printf ("Поток 1 запущен \ n");...}

Вывод программы следующий.

Тема 1 запущена Тема 2 запущена Тема 3 запущена Сообщение: это поток 1 Сообщение: это поток 2 Сообщение: это поток 2 Сообщение: это поток 2 Сообщение: это поток 1 Сообщение: это поток 1 Сообщение: это поток 3 Сообщение: это поток 3 Сообщение: это поток 3

Поток 2 имеет наивысший приоритет, а поток 3 имеет самый низкий приоритет. Первое сообщение печатается потоком 1 со средним приоритетом, поскольку оно запускается незадолго до потока 2.

См. Также

  • Портал бесплатного программного обеспечения с открытым исходным кодом

Ссылки

Источники

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

Последняя правка сделана 2021-06-03 05:03:59
Содержание доступно по лицензии CC BY-SA 3.0 (если не указано иное).
Обратная связь: support@alphapedia.ru
Соглашение
О проекте