Реферат Реализация модели распределения памяти перемещаемыми разделами с перемещением в сторону старших
Работа добавлена на сайт bukvasha.net: 2015-10-28Поможем написать учебную работу
Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
от 25%
Подписываем
договор
РОССИЙСКИЙ ГОСУДАРСТВЕННЫЙ СОЦИАЛЬНЫЙ УНИВЕРСИТЕТ
Кафедра Моделирования информационных систем и сетей
Курсовой проект
по дисциплине: Операционные системы.
Тема: Реализация модели распределения памяти перемещаемыми разделами с перемещением в сторону старших адресов со сжатием при каждом завершении задачи
.
Вариант №11
Выполнила:
студентка группы ИСТ-Д-3-1
Пиганова Н.А.
Проверила:
доц. Журавлёва Е.М.
Дата выполнения работы:
Дата защиты работы:
Москва
2007
Содержание
Введение…………………………………………………………….3
1. Распределение памяти перемещаемыми разделами
1.1 Типы адресов…............................................................................5
1.2 Алгоритмы распределения памяти …………………………..14
1.3 Распределение памяти динамическими разделами………….14
1.4 Распределение памяти перемещаемыми разделами…………16
2. Реализация модели распределения памяти перемещаемыми разделами
2.1 Алгоритм реализации модели распределения памяти
перемещаемыми разделами …........................................................18
2.2 Блок-схема программы …….....................................................19
2.3 Программа реализация модели распределения памяти перемещаемыми разделами ……....................................................24
2.4 Тестирование программы реализация модели распределения
памяти перемещаемыми разделами …………………………......27
Заключение…………………………………………………………....30
Список использованной литературы………………………….......32
Введение
Память является важнейшим ресурсом, требующим тщательного управления со стороны мультипрограммной операционной системы. Особая роль памяти объясняется тем, что процессор может выполнять инструкции программы только в том случае, если они находятся в памяти. Память распределяется как между модулями прикладных программ, так и между модулями самой операционной системы.
В ранних ОС управление памятью сводилось просто к загрузке программы и ее данных из некоторого внешнего накопителя (перфоленты, магнитной ленты или магнитного диска) в память. С появлением мультипрограммирования перед ОС были поставлены новые задачи, связанные с распределением имеющейся памяти между несколькими одновременно выполняющимися программами.
Функциями ОС по управлению памятью в мультипрограммной системе являются:
· отслеживание свободной и занятой памяти;
· выделение памяти процессам и освобождение памяти по завершении процессов;
· вытеснение кодов и данных процессов из оперативной памяти на диск (полное или частичное), когда размеры основной памяти не достаточны для размещения в ней всех процессов, и возвращение их в оперативную память, когда в ней освобождается место;
· настройка адресов программы на конкретную область физической памяти.
Помимо первоначального выделения памяти процессам при их создании ОС должна также заниматься динамическим распределением памяти, то есть выполнять запросы приложений на выделение им дополнительной памяти во время выполнения. После того как приложение перестает нуждаться в дополнительной памяти, оно может возвратить ее системе. Выделение памяти случайной длины в случайные моменты времени из общего пула памяти приводит к фрагментации и, вследствие этого, к неэффективному ее использованию. Дефрагментация памяти тоже является функцией операционной системы.
Защита памяти — это еще одна важная задача операционной системы, которая состоит в том, чтобы не позволить выполняемому процессу записывать или читать данные из памяти, назначенной другому процессу. Эта функция, как правило, реализуется программными модулями ОС в тесном взаимодействии с аппаратными средствами.
Цель курсового проекта заключается в разработке модели распределения памяти перемещаемыми разделами с перемещением в сторону старших адресов со сжатием при каждом завершении задачи, демонстрируя один из способов борьбы с фрагментацией.
1. Распределение памяти перемещаемыми разделами
1.1 Типы адресов
Для идентификации переменных и команд на разных этапах жизненного цикла программы используются символьные имена (метки), виртуальные адреса и физические адреса (рис. 1).
· Символьные имена присваивает пользователь при написании программы на алгоритмическом языке или ассемблере.
· Виртуальные адреса, называемые иногда математическими, или логическими адресами, вырабатывает транслятор, переводящий программу на машинный язык. Поскольку во время трансляции в общем случае не известно, в какое место оперативной памяти будет загружена программа, то транслятор присваивает переменным и командам виртуальные (условные) адреса, обычно считая по умолчанию, что начальным адресом программы будет нулевой адрес.
· Физические адреса соответствуют номерам ячеек оперативной памяти, где в действительности расположены или будут расположены переменные и команды.
Совокупность виртуальных адресов процесса называется виртуальным адресным пространством. Диапазон возможных адресов виртуального пространства у всех процессов является одним и тем же. Например, при использовании 32-разрядных виртуальных адресов этот диапазон задается границами 0000000016и FFFFFFFF16. Тем не менее, каждый процесс имеет собственное виртуальное адресное пространство — транслятор присваивает виртуальные адреса переменным и кодам каждой программе независимо (рис. 2).
Рис. 1 Типы адресов
Рис. 2. Виртуальные адресные пространства нескольких программ
Совпадение виртуальных адресов переменных и команд различных процессов не приводит к конфликтам, так как в том случае, когда эти переменные одновременно присутствуют в памяти, операционная система отображает их на разные физические адреса.
В разных операционных системах используются разные способы структуризации виртуального адресного пространства. В одних ОС виртуальное адресное пространство процесса подобно физической памяти представлено в виде непрерывной линейной последовательности виртуальных адресов. Такую структуру адресного пространства называют также плоской (flat). При этом виртуальным адресом является единственное число, представляющее собой смещение относительно начала (обычно это значение 000...000) виртуального адресного пространства (рис. 3а). Адрес такого типа называют линейным виртуальным адресом.
В других ОС виртуальное адресное пространство делится на части, называемые сегментами (или секциями, или областями, или другими терминами). В этом случае помимо линейного адреса может быть использован виртуальный адрес, представляющий собой пору чисел (и, т), где n определяет сегмент, а т — смещение внутри сегмента (рис. 3б).
Существуют и более сложные способы структуризации виртуального адресного пространства, когда виртуальный адрес образуется тремя или даже более числами.
Рис. 3 Типы виртуальных адресных пространств: плоское (а), сегментированное (б)
Задачей операционной системы является отображение индивидуальных виртуальных адресных пространств всех одновременно выполняющихся процессов на общую физическую память. При этом ОС отображает либо все виртуальное адресное пространство, либо только определенную его часть. Процедура преобразования виртуальных адресов в физические должна быть максимально прозрачна для пользователя и программиста.
Существуют два принципиально отличающихся подхода к преобразованию виртуальных адресов в физические.
В первом случае замена виртуальных адресов на физические выполняется один раз для каждого процесса во время начальной загрузки программы в память. Специальная системная программа — перемещающий загрузчик — на основании имеющихся у нее исходных данных о начальном адресе физической памяти, в которую предстоит загружать программу, а также информации, предоставленной транслятором об адресно-зависимых элементах программы, выполняет загрузку программы, совмещая ее с заменой виртуальных адресов физическими.
Второй способ заключается в том, что программа загружается в память в неизмененном виде в виртуальных адресах, то есть операнды инструкций и адреса переходов имеют те значения, которые выработал транслятор. В наиболее простом случае, когда виртуальная и физическая память процесса представляют собой единые непрерывные области адресов, операционная система выполняет преобразование виртуальных адресов в физические по следующей схеме. При загрузке операционная система фиксирует смещение действительного расположения программного кода относительно виртуального адресного пространства. Во время выполнения программы при каждом обращении к оперативной памяти выполняется преобразование виртуального адреса в физический. Схема такого преобразования показана на рис.4. Пусть, например, операционная система использует линейно-структурированное виртуальное адресное пространство и пусть некоторая программа, работающая под управлением этой ОС, загружена в физическую память начиная с физического адреса S. ОС запоминает значение начального смещения S и во время выполнения программы помещает его в специальный регистр процессора. При обращении к памяти виртуальные адреса данной программы преобразуются в физические путем прибавления к ним смещения S. Например, при выполнении инструкции MOV пересылки данных, находящихся по адресу VA, виртуальный адрес VA заменяется физическим адресом VA+S.
Рис.4. Схема динамического преобразования адресов
Последний способ является более гибким: в то время как перемещающий загрузчик жестко привязывает программу к первоначально выделенному ей участку памяти, динамическое преобразование виртуальных адресов позволяет перемещать программный код процесса в течение всего периода его выполнения. Но использование перемещающего загрузчика более экономично, так как в этом случае преобразование каждого виртуального адреса происходит только один раз во время загрузки, а при динамическом преобразовании — при каждом обращении по данному адресу.
Необходимо различать максимально возможное виртуальное адресное пространство процесса и назначенное (выделенное) процессу виртуальное адресное пространство. В первом случае речь идет о максимальном размере виртуального адресного пространства, определяемом архитектурой компьютера, на котором работает ОС, и, в частности, разрядностью его схем адресации (32-битная, 64-битная и т. п.). Например, при работе на компьютерах с 32-разрядными процессорами Intel Pentium операционная система может предоставить каждому процессу виртуальное адресное пространство до 4 Гбайт (232). Однако это значение представляет собой только потенциально возможный размер виртуального адресного пространства, который редко на практике бывает необходим процессу. Процесс использует только часть доступного ему виртуального адресного пространства.
Назначенное виртуальное адресное пространство представляет собой набор виртуальных адресов, действительно нужных процессу для работы. Эти адреса первоначально назначает программе транслятор на основании текста программы, когда создает кодовый (текстовый) сегмент, а также сегмент или сегменты данных, с которыми программа работает. Затем при создании процесса ОС фиксирует назначенное виртуальное адресное пространство в своих системных таблицах. В ходе своего выполнения процесс может увеличить размер первоначального назначенного ему виртуального адресного пространства, запросив у ОС создания дополнительных сегментов или увеличения размера существующих. В любом случае операционная система обычно следит за корректностью использования процессом виртуальных адресов — процессу не разрешается оперировать с виртуальным адресом, выходящим за пределы назначенных ему сегментов.
Максимальный размер виртуального адресного пространства ограничивается только разрядностью адреса, присущей данной архитектуре компьютера, и, как правило, не совпадает с объемом физической памяти, имеющимся в компьютере.
Сегодня для машин универсального назначения типична ситуация, когда объем виртуального адресного пространства превышает доступный объем оперативной памяти. В таком случае операционная система для хранения данных виртуального адресного пространства процесса, не помещающихся в оперативную память, использует внешнюю память, которая в современных компьютерах представлена жесткими дисками (рис. 5а). Именно на этом принципе основана виртуальная память — наиболее совершенный механизм, используемый в операционных системах для управления памятью.
Рис. 5 Соотношение объемов виртуального адресного пространства и физической памяти: виртуальное адресное пространство превосходит объем физической памяти (а), виртуальное адресное пространство меньше объема физической памяти (б)
Однако соотношение объемов виртуальной и физической памяти может быть и обратным. Так, в мини-компьютерах 80-х годов разрядности поля адреса нередко не хватало для того, чтобы охватить всю имеющуюся оперативную память. Несколько процессов могло быть загружено в память одновременно и целиком (рис. 5 б).
Необходимо подчеркнуть, что виртуальное адресное пространство и виртуальная память — это различные механизмы и они не обязательно реализуются в операционной системе одновременно. Можно представить себе ОС, в которой поддерживаются виртуальные адресные пространства для процессов, но отсутствует механизм виртуальной памяти. Это возможно только в том случае, если размер виртуального адресного пространства каждого процесса меньше объема физической памяти.
Содержимое назначенного процессу виртуального адресного пространства, то есть коды команд, исходные и промежуточные данные, а также результаты вычислений, представляет собой образ процесса.
Во время работы процесса постоянно выполняются переходы от прикладных кодов к кодам ОС, которые либо явно вызываются из прикладных процессов как системные функции, либо вызываются как реакция на внешние события или на исключительные ситуации, возникающие при некорректном поведении прикладных кодов. Для того чтобы упростить передачу управления от прикладного кода к коду ОС, а также для легкого доступа модулей ОС к прикладным данным (например, для вывода их на внешнее устройство), в большинстве ОС ее сегменты разделяют виртуальное адресное пространство с прикладными сегментами активного процесса. То есть сегменты ОС и сегменты активного процесса образуют единое виртуальное адресное пространство.
Обычно виртуальное адресное пространство процесса делится на две непрерывные части: системную и пользовательскую. В некоторых ОС (например, Windows NT, OS/2) эти части имеют одинаковый размер — по 2 Гбайт, хотя в принципе деление может быть и другим, например 1 Гбайт — для ОС, и 2 Гбайт — для прикладных программ. Часть виртуального адресного пространства каждого процесса, отводимая под сегменты ОС, является идентичной для всех процессов. Поэтому при смене активного процесса заменяется только вторая часть виртуального адресного пространства, содержащая его индивидуальные сегменты, как правило, — коды и данные прикладной программы (рис. 6). Архитектура современных процессоров отражает эту особенность структуры виртуального адресного пространства, например, в процессорах Intel Pentium существует два типа системных таблиц: одна — для описания сегментов, общих для всех процессов, а другая — для описания индивидуальных сегментов данного процесса.
При смене процесса первая таблица остается неизменной, а вторая заменяется новой.
Рис. 6 Общая и индивидуальные части виртуальных адресных пространств
Описанное выше назначение двух частей виртуального адресного пространства — для сегментов ОС и для сегментов прикладной программы — является типичным, но не абсолютным. Имеются и исключения из общего правила. В некоторых ОС существуют системные процессы, порожденные для решения внутренних задач ОС. В этих процессах отсутствуют сегменты прикладной программы, но они могут расположить некоторые свои сегменты (сегменты ОС) в общей части виртуального адресного пространства, а некоторые — в индивидуальной части, обычно предназначенной для прикладных сегментов. И наоборот, в общей, системной части виртуального адресного пространства размещаются сегменты прикладного кода, предназначенные для совместного использования несколькими прикладными процессами.
1.2 Алгоритмы распределения памяти
Следует ли назначать каждому процессу одну непрерывную область физической памяти или можно выделять память «кусками»? Должны ли сегменты программы, загруженные в память, находиться на одном месте в течение всего периода выполнения процесса или можно ее время от времени сдвигать? Что делать, если сегменты программы не помещаются в имеющуюся память? Разные ОС по-разному отвечают на эти и другие базовые вопросы управления памятью. Обозначим наиболее общие подходы к распределению памяти, которые были характерны для разных периодов развития операционных систем. Некоторые из них сохранили актуальность и широко используются в современных ОС, другие же представляют в основном только познавательный интерес, хотя их и сегодня можно встретить в специализированных системах. На рис.7 все алгоритмы распределения памяти разделены на два класса: алгоритмы, в которых используется перемещение сегментов процессов между оперативной памятью и диском, и алгоритмы, в которых внешняя память не привлекается.
Рис. 7 Классификация методов распределения памяти
1.3 Распределение памяти динамическими разделами
В этом случае память машины не делится заранее на разделы. Сначала вся память, отводимая для приложений, свободна. Каждому вновь поступающему на выполнение приложению на этапе создания процесса выделяется вся необходимая ему память (если достаточный объем памяти отсутствует, то приложение не принимается на выполнение и процесс для него не создается). После завершения процесса память освобождается, и на это место может быть загружен другой процесс. Таким образом, в произвольный момент времени оперативная память представляет собой случайную последовательность занятых и свободных участков (разделов) произвольного размера. На рис.8 показано состояние памяти в различные моменты времени при использовании динамического распределения. Так, в момент t0 в памяти находится только ОС, а к моменту t1 память разделена между 5 процессами, причем процесс П4, завершаясь, покидает память. На освободившееся от процесса П4 место загружается процесс П6, поступивший в момент t3.
Рис. 8. Распределение памяти динамическими разделами
По сравнению с методом распределения памяти фиксированными разделами данный метод обладает гораздо большей гибкостью, но ему присущ очень серьезный недостаток — фрагментация памяти. Фрагментация — это наличие большого числа несмежных участков свободной памяти очень маленького размера (фрагментов). Настолько маленького, что ни одна из вновь поступающих программ не может поместиться ни в одном из участков, хотя суммарный объем фрагментов может составить значительную величину, намного превышающую требуемый объем памяти.
Распределение памяти динамическими разделами лежит в основе подсистем управления памятью многих мультипрограммных операционных системах 60-70-х годов, в частности такой популярной операционной системы, как OS/360.
1.4 Распределение памяти перемещаемыми разделами.
Одним из методов борьбы с фрагментацией является перемещение всех занятых участков в сторону старших или младших адресов, так, чтобы вся свободная память образовала единую свободную область (рис. 9). В дополнение к функциям, которые выполняет ОС при распределении памяти динамическими разделами в данном случае она должна еще время от времени копировать содержимое разделов из одного места памяти в другое, корректируя таблицы свободных и занятых областей. Эта процедура называется сжатием. Сжатие может выполняться либо при каждом завершении процесса, либо только тогда, когда для вновь создаваемого процесса нет свободного раздела достаточного размера. В первом случае требуется меньше вычислительной работы при корректировке таблиц свободных и занятых областей, а во втором — реже выполняется процедура сжатия.
Рис. 9 Распределение памяти перемещаемыми разделами
Так как программы перемещаются по оперативной памяти в ходе своего выполнения, то в данном случае невозможно выполнить настройку адресов с помощью перемещающего загрузчика. Здесь более подходящим оказывается динамическое преобразование адресов.
Хотя процедура сжатия и приводит к более эффективному использованию памяти, она может потребовать значительного времени, что часто перевешивает преимущества данного метода.
Концепция сжатия применяется и при использовании других методов распределения памяти, когда отдельному процессу выделяется не одна сплошная область памяти, а несколько несмежных участков памяти произвольного размера (сегментов). Такой подход был использован в ранних версиях OS/2, в которых память распределялась сегментами, а возникавшая при этом фрагментация устранялась путем периодического перемещения сегментов.
2. Реализация модели распределения памяти перемещаемыми разделами
2.1 Алгоритм реализации модели распределения памяти перемещаемыми разделами
Для демонстрации модели распределения памяти перемещаемыми разделами с перемещением в сторону старших адресов со сжатием при каждом завершении задачи реализуем следующий алгоритм:
Пусть массив А, состоящий из десяти ячеек – вся свободная память операционной системы, тогда пусть каждая ячейка массива имеет 256 Мб свободной памяти (таким образом вся память составляет 2560 Мб).
Перед началом непосредственной загрузки процессов выведем на экран сообщение 'pameat polnosteu svobodna' и массив, представляющий свободную память ( A[i] ).
Затем при помощи команды языка паскаль случайным образом будем загружать процессы , размером от 0 Mб до 512 Mб в любые свободные ячейки массива. Запись будем производиться таким образом, что если для загрузки приходит процесс, больший чем максимальный размер ячейки(256), то ячейка куда он пришёл обнуляется , а из соседней с ней ячейки массива вычитается недостающая память( то есть, если например во вторую ячейку приходит процесс 260Мб, то эта ячейка обнуляет значение свободной памяти, а в соседнюю с ней ячейку записывается новое значение свободной памяти 252Мб).А если для загрузки приходит процесс, меньший чем максимальный размер ячейки(256), то из ячейки ,куда он пришёл вычитается размер данного процесса. Каждая загрузка сопровождается соответствующим сообщением, содержащим размер занимаемой памяти процесса, и выводом массива А[i] с загруженным процессом.
После каждой загрузки процесса производится процедура сдвига и сжатия.
Условно будем считать, что старшие адреса процессов расположены вверху нашего массива. Сдвиг ячеек при первой загрузки организуется таким образом, что ячейки , полностью заполненные процессом становятся на первую позицию, а ячейки , которые заполнились на какую то часть следом на ним, при загрузки второго процесса возможны несколько ситуаций: если второй процесс записался в ячейку и при этом она не заполнилась полностью,то при сдвиге и сжатии ( при условии, что в предшествующей процедуре сдвинутая ячейка имеет необходимый объем памяти для вычитания из нее памяти , которую занимает второй процесс) происходит перераспределение занятой памяти( т.е. кроме сдвига всех полностью и частично занятых ячеек происходит сжатие маленьких участков памяти), если второй процесс занял одну ячейку полностью , а соседнюю с ней частично,то пустая ячейка сдвигается вверх и встает следом за пустой ячейкой, куда загрузился первый процесс, а память частично загруженной ячейки второго процесс суммируется с памятью частично загруженной ячейки первого.
Массив, преобразованный в ходе сдвига и сжатия, на экран выводится после сообщения 'posle sdviga i sgatiea'. После этого на экране появляется сообщение 'zagruzit eshe proces y/n', которое подразумевает нажатие двух символов: либо «y», что означает загрузку нового процесса и соответствующую процедуру сдвига и сжатия, либо «n», после чего происходит автоматический выход из программы.
Процесс загрузки будет продолжаться до тех пор, пока для вновь пришедшего процесса будет хватать свободного места в ячейках, в противном случае на экране появится сообщение о постановки процесса в очередь: 'Mesta dlea zagruzki ne dostatochno process postavlen v ochered' .
2.2
Блок-схема программы
На рис.10 представлена блок-схема программы реализации модели распределения памяти перемещаемыми разделами с перемещением в сторону старших адресов со сжатием при каждом завершении задачи .
|
Продолжение1 рис. 10 Блок-схема программы
Продолжение2 рис. 10 Блок-схема программы
2.3 Программа реализация модели распределения памяти перемещаемыми разделами
Таблица данных для программы реализации модели распределения памяти перемещаемыми разделами
| Имя и тип переменной | Смысл | Структура | Диапазон значений |
| A:array of integer | Одномерный массив из 10-ти элементов | - | От 0 до 256 |
| y:string | Строковая переменная, ответственная за введение(не введение) нового процесса. | Простая переменная | y/n |
| i:integer | Текущий номер элемента в массиве и счетчик числа итераций | Простая переменная | 0т 1 до 10 |
| j:integer | Память, занимаемая процессом( в Мб) | Простая переменная | От 0 до 512 |
| k:integer | Текущий номер элемента, элемент в массиве и счетчик числа итераций. | Простая переменная | От 0 до 10 От 0 до 256 От 0 до 10 |
| g:integer | Текущий номер элемента, элемент в массиве и счетчик числа итераций | Простая переменная | От 0 до 10 От 0 до 256 От 0 до 10 |
| sum:integer | Сумма свободной памяти | Простая переменная | От 0 до 2560 |
| w:integer | Счетчик числа итераций | Простая переменная | От 1 до 2 |
| x:integer | Счетчик числа полностью занятых ячеек. | Простая переменная | От 1 до 10 |
Program Model_raspredelenia_pameati;
uses crt;
const n=10;
type massiv=array[1..n] of integer;
Label L1,L2,L3;
Var A:massiv; y:string; i,j,k,g,sum,w,x :integer;
begin
clrscr; randomize; {включение генератора случайных чисел }
writeln('pameat polnosteu svobodna'); {вывод на экран сообщения'pameat
polnosteu
svobodna
'}
for i:=1 to n do
begin
A[i]:=256; {присваивание каждому элементу массива А 256 Мб свободной памяти}
writeln(A[i]); {вывод на экран массива А}
end
; readln(y);
L1: sum:=0; {присваивание сумме свободной памяти значение о}
for i:= 1 to n do
sum:=sum+A[i];
j:=round(random*512); {загрузка процесса со случайным размером от 0 до 512Мб в память, j
присваиваются значения памяти, занимаемой процессом }
if j>sum then goto L2; {если j
>
sum
то выводится сообщение: '
Mesta
dlea
zagruzki
ne
dostatochno
process
postavlen
v
ochered
'}
x:=1;
for i:= 1 to n do
begin
if A[i]=0 then x:=x+1; end;
k:=round(random(n-1-x))+x; {k
присваивается произвольный номер массива, куда записывается процесс при условии ,что процесс не может записаться в ячейку, следующую сразу после полностью заполненной}
writeln('process obemom ', j , 'Mb'); {вывод
сообщения
- 'process obemom ', j , 'Mb' }
if k=0 then k:=1;
if (j>256) and (k=n) {если размер пришедшего в ячейку памяти процесса больше, чем ее максимальный объем (т.е 256Мб), то выполняются идущие ниже действия}
then k:=n-1;
A[k]:=A[k]-j; {присваиваем ячейке, куда пришел процесс значение оставшейся свободной памяти в ячейки после вычета из нее занимаемой процессом памяти}
while A[k]<0 do {пока свободная память в занимаемой ячейки массива будет иметь отрицательное значение выполняются идущие ниже действия}
begin
g:=A[k]; {g
присваивается значение свободной памяти в ячейке , куда загрузился процесс}
A[k]:=0; {ячейке, в которую пришел процесс присваивается значение равное о }
k:=k+1;
A[k]:=A[k]+g; {к памяти соседней ячейки с ячейкой, в которую загрузился процесс, прибавляется оставшееся отрицательное значение памяти процесса}
end;
writeln('zagruzka novogo processa'); {вывод
текстового
сообщения
'zagruzka novogo processa'}
for i:=1 to n do
begin
writeln(A[i]); {вывод массива А с загруженным процессом }
end;
for w:=1 to 2 do
begin
i:=1;
while i <> n do {пока текущий номер элемента массива не равен последнему выполняются идущие ниже действия }
begin
if (A[i] <> 256) then {если текущий элемент массива является тем , в который уже загрузился процесс (частично или полностью), то выполняются идущие ниже действия}
begin
g:=i;
while g <> 1 do {пока текущий номер элемента в массиве не будет равен первому выполняются идущие ниже действия}
begin
if A[g-1] <> 256 then do {если значение соседнего элемента, с элементом куда загружался процесс не равно 256 , то выполняются идущие ниже действия}
begin
if A[g-1] > 256 - A[g] then {если памяти соседней ячейки хватает, чтобы записать процесс, то выполняются идущие ниже действия}
begin
k:=A[g-1] {k
- присваиваем значение свободной памяти соседней ячейки}
A[g-1]:=k - 256 + A[g]; {сдвигаем ячейки , куда загрузился процесс,сжимая при этом процессы , с оставшейся от вычитания свободной памятью}
A[g]:=A[g+1];
end
else begin
k:=A[g]; {k
- присваиваем значение свободной памяти ячейки, куда загрузился процесс}
A[g]:=k + A[g-1]; {сдвигаем ячейки , куда загрузился процесс,сжимая при этом процессы , с оставшейся от вычитания свободной памятью}
A[g-1]:=0;
end;
end
else
begin
A[g-1]:=A[g]; ]; {сдвигаем ячейки , куда загрузился процесс,сжимая при этом процессы , с оставшейся от вычитания свободной памятью}
A[g]:=A[g+1];
A[g+1]:=A[g+2];
end;
g:=g-1;
end;
end;
i:=i+1;
end;
end;
Writeln('posle sdviga i sgatiea'); ); {вывод
текстового
сообщения
'posle sdviga i sgatiea'}
for i:=1 to n do
begin
writeln(A[i]); {вывод массива А после сдвига и сжатия его элементов}
end;
Writeln('zagruzit eshe proces y/n'); ); {вывод текстового с предложением загрузить новый процесс}
readln(y); {ввод строки символов}
if y='y' then {если вводимый символ является '
y
', то выполняется метка1( т.е ввод нового процесса , сдвиг и сжатие), иначе осуществляется выход из программы}
begin
goto L1
end
else
begin
goto L3;
end;
L2: writeln('process obemom ', j , 'Mb') ;
writeln('Mesta dlea zagruzki ne dostatochno process postavlen v ochered');
L3: readln;
end.
2.4 Тестирование программы реализация модели распределения памяти перемещаемыми разделами
В результате работы программы был получен следующий результат:
На экране появляется первый массив, представляющий пустую память (Тест 1)
pameat polnosteu svobodna
256
256
256
256
256
256
256
256
256
256
Тест1 Пустая память
В пустую память загружается первый процесс, объемом 297Мб, организуется сдвиг и сжатие (Тест2).
Тест2 Загрузка первого процесса, сдвиг и сжатие
При нажатии клавиши «у» происходит загрузка следующего процесса, при нажатии «n» происходит выход из программы (Тест3)
Тест3 Загрузка второго процесса
Загрузка процессов, сдвиг и сжатие происходит до того момента пока для этого достаточно памяти, в противном случае выводится сообщение о постановки процесса в очередь и при нажатии любой клавиши происходит автоматический выход из программы (Тест4)
Тест4 Загрузка последнего процесса.
Заключение
Оперативная память компьютера играет особую роль. Это обусловлено тем, что программа может выполняться только в том случае, если она находится в памяти. Операционная система способна осуществлять много функций для рационального управления памятью.
Выделим несколько основных функций операционной системы по управлению памятью в рамках исследуемого вопроса:
· Перемещение всех занятых участков в сторону старших адресов при каждом завершении задачи.
· Коррекция таблиц свободных и занятых областей
· Изменение адресов команд и данных, к которым обращаются процессы при их перемещении в памяти за счет использования относительной адресации.
· Аппаратная поддержка процесса динамического преобразования относительных адресов в абсолютные адреса основной памяти.
· Защита памяти, выделяемой процессу от взаимного влияния других процессов.
При помощи программных средств Турбо Паскаля была успешно реализована модель распределения памяти перемещаемыми разделами с перемещением в сторону старших адресов со сжатием при каждом завершении задачи . Распределение памяти таким образом является хорошим способом борьбы с фрагментацией, то есть с наличием большого числа несмежных участков свободной памяти настолько маленького размера, что ни одна из вновь поступающих программ не может поместиться ни в одном из участков, хотя суммарный объем фрагментов может составить значительную величину, намного превышающую требуемый объем памяти.
В курсовом проекте была реализована модель распределения памяти без использования внешней памяти – распределение перемещаемыми разделами.
Модель работает таким образом, что все занятые участки памяти перемещаются в сторону старших адресов, так, чтобы вся свободная память образовывала единую свободную область, содержимое разделов время от времени копируется из одного места памяти в другое, корректируются таблицы свободных и занятых областей.
Можно сказать, что достоинством распределения памяти перемещаемыми разделами является эффективное использование оперативной памяти, предусматривающее четкую организацию всего процесса распределения, исключение внутренней и внешней фрагментации, но существует и недостаток - дополнительные накладные расходы операционной системы.
Список использованной литературы и источников:
1) Н. А. Олифер, В. Г. Олифер Сетевые операционные системы: изд. Питер,2001.
2) Робачевский А.М. Операционная система UNIX.- СПб.: БХВ -Санкт-Петербург, 2000.
3) Таненбаум Э. Современные операционные системы. 2-ое изд. - СПб.:Питер, 2002.
4) Немнюгин С. Turbo Paskal. Программирование на языке высокого уровня: изд. Питер,2003.
5) Робачевский А.М. Операционная система UNIX. - СПб.: BHV - Санкт-Петербург, 1997.
6) Дейтел Г. Введение в операционные системы: в 2-х т. Т1. -М.: Мир,1987. – 359 с., Т2. -М.: Мир,1987. – 398 с.
7) Павлов И.О., Писаренко Н.Д., Лемешкин А.В. Сетевые операционные системы: учеб. пособие. Воронеж, 2004. – 196 с.
8) Турбо Паскаль7.0 Самоучитель. -СПб.: Питер;К.: Издательская группа ВHV, 2003.-416 с.:ил.
9) Окулов С. Основы программирования Турбо Паскаль:изд. Бином. Лаборатория знаний, 2006.- , 440 с.
10) Журавлева Е.М. Лекции по курсу операционные системы.
11) Гордеев А. В. Операционные системы. : Учебник для вузов 2-е изд: Питер, 2007.- 416 с.
12) http://ruos.ru/os22/ (иллюстрированный самоучитель по Турбо Паскалю)
13) http://www.dstu.edu.ru/povtas/stud/books/net_os/glava7.html (на сайте рассматриваются различные методы распределения памяти)
14) http://aab46.by.ru/html/lekd28/l-4.htm (А.А. Безбогов. Операционные системы -Лекция 4)
15) http://coc.land.ru/chapter5.htm (управление памятью)
