Главная страница
Навигация по странице:

  • Round Robin ( RR )

  • Задание к практическому занятию

    		•

    Моделирование решения функциональной задачи с заданным значением процессорного времен. Практическое занятие 3. Занятие 3 Моделирование RoundRobin планировщика модульной операционной системы для встраиваемых приложений


    Скачать 217.3 Kb.
    НазваниеЗанятие 3 Моделирование RoundRobin планировщика модульной операционной системы для встраиваемых приложений
    АнкорМоделирование решения функциональной задачи с заданным значением процессорного времен
    Дата08.11.2022
    Размер217.3 Kb.
    Формат файлаdocx
    Имя файлаПрактическое занятие 3.docx
    ТипЗанятие
    #777833


    Практическое занятие №3

    Моделирование Round-Robin планировщика модульной операционной системы для встраиваемых приложений

    (невытесняющий режим)

    Известно, что операционная система упрощает процесс взаимодействия процессора и его периферии.

    Центральным элементом каждой операционной системы является ядро. Ядро встроенной ОС управляет задачами, системной памятью и устройствами ввода / вывода.

    Также существуют особые виды ядер, называемые микроядрами и наноядрами, которые

    чаще всего используются во встроенных системах .

    В концепцию ядра входят платформенно-зависимые и платформенно-независимые части, что приводит к разделению ядра на два слоя (см. рис. 1).

    Разделение ядра таким образом сокращает количество изменений кода в зависимости от аппаратной платформы, что упрощает портирование ОС с одной платформы к другую.

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

    Рис.1. Плаформо-зависимые и платформо-независимые части ядра ОС





    Рис.2. Задачи микроядра ОС





    Рис.3. Управление задачами микроядра ОС

    Управление задачами реализуется с использованием планировщика, который помещает задачи в список ожидания.

    Различают три типа планировщиков, которые отличаются концепцией упорядочивания задач:

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

    • Планировщик приоритетов, который вставляет задачи в список по критерию приоритета.

    • Планировщик с несколькими списками, который перемещает задачи на выполнение на основе приоритетов в конкретный список приоритетов.

    Алгоритмы планирования

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

    First-Come, First-Served (FCFS)

    Простейшим алгоритмом планирования является алгоритм, который принято обозначать аббревиатурой FCFS по первым буквам его английского названия – First-Come, First-Served (первым пришел, первым обслужен). Представим себе, что процессы, находящиеся в состоянии готовность, выстроены в очередь. Когда процесс переходит в состояние готовность, он, а точнее, ссылка на его PCB помещается в конец этой очереди. Выбор нового процесса для исполнения осуществляется из начала очереди с удалением оттуда ссылки на его PCB. Очередь подобного типа имеет в программировании специальное наименование – FIFO, сокращение от First In, First Out (первым вошел, первым вышел).

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

    Таблица 1.

    Процесс
    p0
    p1
    p2

    Продолжительность очередного CPU burst
    13
    4
    1

    Преимуществом алгоритма FCFS является легкость его реализации, но в то же время он имеет и много недостатков. Рассмотрим следующий пример. Пусть в состоянии готовность находятся три процесса p0, p1 и p2, для которых известны времена их очередных CPUburst . Эти времена приведены в таблице 1. в некоторых условных единицах. Для простоты будем полагать, что вся деятельность процессов ограничивается использованием только одного промежутка CPUburst , что процессы не совершают операций ввода-вывода и что время переключения контекста так мало, что им можно пренебречь.

    Если процессы расположены в очереди процессов, готовых к исполнению, в порядке p0, p1, p2, то картина их выполнения выглядит так, как показано на рис. 4. Первым для выполнения выбирается процесс p0, который получает процессор на все время своего CPUburst , т. е. на 13 единиц времени. После его окончания в состояние исполнение переводится процесс p1, он занимает процессор на 4 единицы времени. И, наконец, возможность работать получает процесс p2. Время ожидания для процесса p0 составляет 0 единиц времени, для процесса p1 – 13 единиц, для процесса p2 – 13 + 4 = 17 единиц.

    Таким образом, среднее время ожидания в этом случае – (0 + 13 + 17)/3 = 10 единиц времени. Полное время выполнения для процесса p0 составляет 13 единиц времени, для процесса p1 – 13 + 4 = 17 единиц, для процесса p2 – 13 + 4 + 1 = 18 единиц. Среднее полное время выполнения оказывается равным (13 + 17 + 18)/3 = 16 единицам времени.




    Рис. 4. Выполнение процессов при порядке p0,p1,p2

    Если те же самые процессы расположены в порядке p2, p1, p0, то картина их выполнения будет соответствовать рис.5. Время ожидания для процесса p0 равняется 5 единицам времени, для процесса p1 – 1 единице, для процесса p2 – 0 единиц. Среднее время ожидания составит (5 + 1 + 0)/3 = 2 единицы времени. Это в 5 (!) раз меньше, чем в предыдущем случае. Полное время выполнения для процесса p0 получается равным 18 единицам времени, для процесса p1 – 5 единицам, для процесса p2 – 1 единице. Среднее полное время выполнения составляет (18 + 5 + 1)/3 = 8 единиц времени, что почти в 2 раза меньше, чем при первой расстановке процессов.




    Рис. 5. Выполнение процессов при порядке p2, p1, p0

    Как мы видим, среднее время ожидания и среднее полное время выполнения для этого алгоритма существенно зависят от порядка расположения процессов в очереди. Если у нас есть процесс с длительным CPUburst , то короткие процессы, перешедшие в состояние готовность после длительного процесса, будут очень долго ждать начала выполнения.

    Поэтому алгоритм FCFS практически неприменим для систем разделения времени – слишком большим получается среднее время отклика в интерактивных процессах.

    Round Robin (RR)

    Модификацией алгоритма FCFS является алгоритм, получивший название RoundRobin (RoundRobin – это вид детской карусели в США) или сокращенно RR. По сути дела, это тот же самый алгоритм, только реализованный в режиме вытесняющего планирования. Можно представить себе все множество готовых процессов организованным циклически – процессы сидят на карусели. Карусель вращается так, что каждый процесс находится около процессора небольшой фиксированный квант времени, обычно 10 – 100 миллисекунд (см.рис. 6.). Пока процесс находится рядом с процессором, он получает процессор в свое распоряжение и может исполняться.




    Рис. 6. Процессы на карусели

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

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

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

    Рассмотрим предыдущий пример с порядком процессов p0, p1, p2 и величиной кванта времени равной 4. Выполнение этих процессов иллюстрируется табл. 2. Обозначение "И" используется в ней для процесса, находящегося в состоянии исполнение, обозначение "Г" – для процессов в состоянии готовность, пустые ячейки соответствуют завершившимся процессам. Состояния процессов показаны на протяжении соответствующей единицы времени, т. е. колонка с номером 1 соответствует промежутку времени от 0 до 1.

    Таблица 2.

    Время
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    p0
    И
    И
    И
    И
    Г
    Г
    Г
    Г
    Г
    И
    И
    И
    И
    И
    И
    И
    И
    И

    p1
    Г
    Г
    Г
    Г
    И
    И
    И
    И






























    p2
    Г
    Г
    Г
    Г
    Г
    Г
    Г
    Г
    И



























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

    Процессор выделяется процессу p2. Он завершается до истечения отпущенного ему процессорного времени, и очередные кванты отмеряются процессу p0 – единственному не закончившему к этому моменту свою работу. Время ожидания для процесса p0 (количество символов "Г" в соответствующей строке) составляет 5 единиц времени, для процесса p1 – 4 единицы времени, для процесса p2 – 8 единиц времени. Таким образом, среднее время ожидания для этого алгоритма получается равным (5 + 4 + 8)/3 = 5,6(6) единицы времени. Полное время выполнения для процесса p0 (количество непустых столбцов в соответствующей строке) составляет 18 единиц времени, для процесса p1 – 8 единиц, для процесса p2 – 9 единиц. Среднее полное время выполнения оказывается равным (18 + 8 + 9)/3 = 11,6(6) единицы времени.

    Заметим, что среднее время ожидания и среднее полное время выполнения для обратного порядка процессов не отличаются от соответствующих времен для алгоритма FCFS и составляют 2 и 8 единиц времени соответственно.

    На производительность алгоритма RR сильно влияет величина кванта времени. Рассмотрим тот же самый пример с порядком процессов p0, p1, p2 для величины кванта времени, равной 1 (см. табл. 3.). Время ожидания для процесса p0 составит 5 единиц времени, для процесса p1 – тоже 5 единиц, для процесса p2 – 2 единицы. В этом случае среднее время ожидания получается равным (5 + 5 + 2)/3 = 4 единицам времени. Среднее полное время исполнения составит (18 + 9 + 3)/3 = 10 единиц времени.

    Таблица 3.

    Время
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18

    p0
    И
    Г
    Г
    И
    Г
    И
    Г
    И
    Г
    И
    И
    И
    И
    И
    И
    И
    И
    И

    p1
    Г
    И
    Г
    Г
    И
    Г
    И
    Г
    И



























    p2
    Г
    Г
    И













































    При очень больших величинах кванта времени, когда каждый процесс успевает завершить свой CPUburst до возникновения прерывания по времени, алгоритм RR вырождается в алгоритм FCFS. При очень малых величинах создается иллюзия того, что каждый из n процессов работает на собственном виртуальном процессоре с производительностью 

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

    Задание к практическому занятию

    1. Разработать алгоритм моделирования RR планирования в операционной системе MS Windows

    2. Привести и описать системные функции ОС, необходимые для реализации RR планировщика в невытесняющем режиме

    3. Разработать программное обеспечение RR планировщика в тестовом режиме (без нагрузки) в невытесняющем режиме

    4. Провести тестирование RR планировщика без нагрузки. в невытесняющем режиме

    5. Провести тестирование RR планировщика без нагрузки. в невытесняющем режиме

    6. По результатам тестирования провести анализ временных характеристик RR планирования.

    Отчет по практическому занятию должен содержать

    1. Структурную схему алгоритма RR планирования

    2. Математическое ожидание и дисперсию временных характеристик RR – планирования

    3. Выводы по применению RR – планирования в невытесняющем режиме.

    написать администратору сайта