Моделирование схемы сегментной структуризации

1.Общесистемная часть

1.1Понятие операционной системы

1.2Организация доступа к ресурсу оперативной памяти

1.3Стратегии размещения информации в памяти

1.4Понятие «процесс» в рамках операционной системы

1.5Свойства и классификация процессов

1.6Различные виды структуризации памяти

2.Специальная часть

2.1Постановка задачи

2.2Использование методов имитационного моделирования для решения поставленной задачи

2.3Разработка имитационной модели

2.4 Описание программной реализации имитационной модели

2.5 Разработка приложения

2.6 Описание функционирования имитационной модели

Заключение

Листинг

1. Общесистемная часть имитационное моделирование структуризация сегментная

1.1 Понятие операционной системы Операционная система — это комплекс системных обрабатывающих и управляющих программ, предназначенных для наиболее эффективного использования всех вычислительных ресурсов и удобства работы с ЭВМ.

При этом хорошая операционная система (ОС) должна обладать следующими свойствами:

Развиваемость — загрузка и запуск программ.

Посредничество — между аппаратурой и приложениями.

Настраиваемость — распознавание дополнительной новой аппаратуры.

Дружественность — простота, удобство, надежность, возможность получения дополнительных и вспомогательных сведений.

«Прозрачность» — наличие минимума необходимой информации о работе системы.

Поддерживаемость программными приложениями.

Многозадачность — одновременная работа с несколькими программами.

Надежность — страховка от непоправимых ошибок, возможность безболезненного выхода из аварийных ситуаций.

Безопасность — наличие средств защиты информации от повреждения.

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

1.2 Организация доступа к ресурсу оперативной памяти Ресурсом называется средство вычислительной системы, которое может быть выделено процессу на определенный интервал времени. Все ресурсы вычислительной системы (ВС) можно разделить на физические и виртуальные. Физические ресурсы — реально существующие ресурсы, обладающие всеми физическими свойствами при распределении между процессами. Виртуальный ресурс является некоторой моделью физического и не существует реально в том виде, в котором предоставляется процессу. Примерами виртуальных ресурсов могут служить виртуальная память, виртуальные регистры, виртуальные CD-ROM приводы и пр.

Размер оперативной памяти (как правило, значительно уступающий размерам виртуальной памяти, выделяемой процессам в системе) может накладывать существенные ограничения на количество одновременно находящихся в системе процессов и скорость их исполнения, что связано с невозможностью предоставления каждому процессу участка соответствующего размера в ОП и, неизбежным в связи с этим, перемещения процессов с ВЗУ в ОП и наоборот. Поэтому схема функционирования оперативной и виртуальной памяти во многом определяет работу операционной системы в целом и ее отдельных приложений в частности.

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

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

1.3 Стратегии размещения информации в памяти Стратегии размещения ставят своей целью определить, в какое место основной памяти следует помещать поступающую программу. Известно три стратегии размещения:

«первый подходящий»;

«наиболее подходящий»;

«наименее подходящий».

Выбор первого подходящего свободного участка предусматривает помещение программы в первый найденный свободный участок, который достаточно велик для ее размещения.

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

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

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

1.4 Понятие «процесс» в рамках операционной системы Процесс — это некоторая деятельность ОС, связанная с исполнением программы на одном или нескольких процессорах, т. е. это система действий, реализующих определенную функцию вычислительных систем.

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

При исполнении любой программы необходимо различать несколько состояний процесса:

Порождение процесса — подготовка условий для первого исполнения на ЦП;

Активное состояние — программа непосредственно исполняется на ЦП;

Ожидание процессора — программа не выполняется по причине занятости какого-либо ресурса;

Готовность — программа не выполняется, но для ее выполнения предоставлены все необходимые ресурсы, кроме ЦП;

Завершение процесса — нормальное/аварийное завершение процесса. После этого ресурсы этому процессу не предоставляются.

Граф процесса выглядит следующим образом:

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

Для ОС процесс в такой трактовке рассматривается как объект, в отношении которого требуется обеспечить реализацию каждого из допустимых состояний, а также допустимые переходы из состояния в состояние в ответ на события, которые могут явиться причиной таких переходов. Такие события могут инициироваться и самими процессами, которые способны затребовать процессор или какой-либо другой ресурс, необходимый для исполнения программы.

1.5 Свойства и классификация процессов Для построения средств и механизмов, реализующих совместно систему управления процессами в составе ОС, требуется определить свойства процессов и провести классификацию процессов в соответствии с этими свойствами.

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

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

В любой ОС по требованию существующего или существовавшего процесса проводится работа по порождению процессов. Процесс, задающий данное требование, называют порождающим, а создаваемый по требованию—порожденным. Если порожденный процесс на интервале своего существования в свою очередь выдает требование на порождение другого процесса, то он одновременно становится и порождающим.

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

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

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

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

Программные процессы принято делить на системные и пользовательские. При развитии системного процесса исполняется программа из состава операционной системы. При развитии пользовательского процесса исполняется пользовательская (прикладная) программа.

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

Управление взаимосвязанными процессами в составе ОС основано на контроле и удовлетворении определенных ограничений, которые накладываются на порядок выполнения таких процессов. Данные ограничения определяют виды отношений, которые допустимы между процессами, и составляют в совокупности синхронизирующие правила.

Отношение предшествования. Для двух процессов это отношение означает, что первый процесс должен переходить в активное состояние всегда раньше второго.

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

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

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

1.6 Различные виды структуризации памяти Для более эффективного функционирования ЭВМ используется динамический метод распределения памяти. Это значит, что процесс распределения памяти осуществляется непосредственно в ходе решения задачи с учетом предыдущего состояния машины и описания массивов данных. Например, процесс компиляции с языков высокого уровня отводит определённую область памяти под каждую переменную, массив, структуру. Уже достаточно давно пользователи столкнулись с проблемой размещения в памяти программ, размер которых превышал имеющуюся в наличии свободную память. Решением было разбиение программы на части, называемые оверлеями. 0-ой оверлей начинал выполняться первым. Когда он заканчивал свое выполнение, он вызывал другой оверлей. Все оверлеи хранились на диске и перемещались между памятью и диском средствами операционной системы. Однако разбиение программы на части и планирование их загрузки в оперативную память должен был осуществлять программист.

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

Таким образом, виртуальная память — это совокупность программно-аппаратных средств, позволяющих пользователям писать программы, размер которых превосходит имеющуюся оперативную память; для этого виртуальная память решает следующие задачи:

размещает данные в запоминающих устройствах разного типа, например, часть программы в оперативной памяти, а часть на диске;

перемещает по мере необходимости данные между запоминающими устройствами разного типа, например, подгружает нужную часть программы с диска в оперативную память;

преобразует виртуальные адреса в физические.

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

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

При сегментно-страничной организации памяти пользовательские программы разбиваются на отдельные массивы. Эти массивы — независимые участки — называются сегментами. Сегмент представляет собой единый логический объект, содержащий какую-либо процедуру, массив или набор данных. Как правило, информация, содержащаяся в сегменте, однородная, то есть в одном сегменте могут находиться только служебные коды программы, другой может являться сегментом стека, третий содержать коды связи с объектными файлами и т. д.

Сегменты, как и любая структура памяти, могут размещаться как в ОП, так и во внешней памяти (магнитных носителях). Если требующийся на данный момент сегмент отсутствует в оперативной памяти, то при надобности работы с ним, он предварительно перемещается в ОП.

Сегментная схема структуризации оперативной памяти.

На исходном этапе адресное пространство представляет собой непрерывную возрастающую последовательность целых чисел, каждое из которых является адресом или ячейкой хранения (от 0 до N-1). Далее, в два этапа осуществляется структуризация а.п. (адресного пространства):

На первом этапе происходит объединение всех адресов исходного а.п. в некоторые группы (сегменты).. Каждый сегмент получает номер S — идентификатор сегмента. При этом обеспечивается только уникальность идентификаторов.

На втором этапе каждому сегменту устанавливается базовый адрес. В результате появляется двухмерное адресное пространство: (S,). В каждом сегменте производится перенумерация адресов от 0, появляющееся смещение R приводит к трехмерному а.п. ().

Проводимая структуризация проиллюстрирована рис. 1.1.

На практике используется система координат (S, R). При данной схеме структуризации возможен переход от структурированному а.п. к непрерывному. Переход осуществляется следующим образом: сегменту S ставится в соответствие базовый адрес (т.н. операция установления соответствия). Абсолютный адрес находят как. Назначение базовых адресов производится на этапе структуризации а.п. и на этапе выполнения программы.

Преобразование адресов для сегментной организации адресного пространства Для каждого сегмента известен адрес. Абсолютный адрес — это сумма = адреса базового + смещение внутри сегмента — короткая схема преобразования адресов. Текст программы (программный код) состоит из нескольких модулей, каждый модуль представляет собой сегмент в общем адресном пространстве. Код может находится в оперативной памяти и в архивной среде хранения. Каждый сегмент размещается в своем пространстве физических адресов.

Задачи:

Необходимость учета сегментов в ОП и в архивной среде хранения.

При передачи управления от одного сегмента другому требуется перенастройка короткой схемы преобразования адресов ,

где — базовый адрес и — смещение внутри сегмента

Учетная информация о загруженных сегментах или модулях структурируется. Чаще всего используется табличная форма хранения.

Преобразование адресов для сегментной организации адресного пространства в рамках одного процесса.

Задачи:

Базовые адреса модулей или сегментов размещения в ОП.

Базовые и абсолютные адреса в составе архивной среды хранения.

Для данной схемы характерно появления словарей сегментов. Словарь сегментов относится к одному сегменту. При обращении к новому сегменту в рамках одного процесса происходит следующее:

где — абсолютный адрес нового сегмента

— абсолютный адрес словаря нового сегмента

— номер нового сегмента Тогда для обращения к элементу сегмента будет использоваться выражение:

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

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

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

где — абсолютный адрес словаря сегмента, где — абсолютный адрес сегмента

2. Специальная часть

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

Использование методов имитационного моделирования

для решения поставленной задачи.

Понятие и основные причины моделирования.

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

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

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

Для исследования характеристик процесса функционирования любой системы математическими методами, включая и машинные, должна быть произведена формализация этого процесса, т. е. построена математическая модель. При имитационном моделировании реализующий модель алгоритм воспроизводит процесс функционирования системы во времени, причем имитируются элементарные явления, составляющие процесс, с сохранением им логической структуры и последовательности протекания во времени, что позволяет по исходным данным получить сведения о состояниях процесса в определенные моменты времени, дающие возможность оценить характеристики системы. Комбинированное (аналитико-имитационное) моделирование при анализе и синтезе систем позволяет объединить достоинства аналитического и имитационного моделирования.

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

Специфика исследовательской работы предопределяет следующие этапы моделирования сложных систем:

Постановка конкретной задачи в терминах, которыми описывают процессы в рассматриваемой системе.

Формализация задачи — построение математической модели рассматриваемой системы на основании сформулированной прикладным специалистом постановки задачи.

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

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

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

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

Имитационную модель сложной системы для решения задач рекомендуется использовать в следующих случаях:

Если не существует законченной постановки задачи исследования и идет процесс познания объекта моделирования. Имитационная модель служит средством изучения явления.

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

Когда кроме оценки влияния параметров СС желательно осуществить наблюдение за поведением компонент СС в течении определенного периода.

Когда имитационное моделирование оказывается единственным способом исследования сложной системы из-за невозможности наблюдения явлений в реальных условиях.

Когда необходимо контролировать протекание процессов в СС путем замедления или ускорения явлений в ходе имитации.

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

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

возможность описания поведения компонент СС на высоком уровне детализации;

отсутствие ограничений на вид зависимостей между параметрами ИМ и состоянием внешней среды СС;

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

Эти достоинства обеспечивают имитационному методу широкое распространение.

Основы имитационного моделирования.

Для создания имитационных комплексов первоначально разрабатывались вопросы воспроизведения на ЭВМ случайных величин и случайных процессов, т. е. для того, чтобы разработать математическую модель, необходимо уметь моделировать случайные величины. Затем разрабатываются программные вопросы: способы формирования моделирующих алгоритмов, методы организации квазипараллелизма, вопросы развития языковых средств (языки моделирования) и вопросы создания систем машинного моделирования. Реальные сложные системы можно моделировать с помощью двух типов математических моделей: аналитических и имитационных. В аналитических моделях поведения сложных систем описывается некоторым функционалом или совокупностью логических условий. Для построения математических моделей используется мощный математический аппарат. В этом случае получается прямое значение функционала в результате расчета математической модели. Когда явления достаточно сложны, или объекты нужно исследовать в динамике в ускоренном или замедленном масштабе времени, то применяют имитационное моделирование. Моделирующие алгоритмы позволяют по исходным данным, содержащим сведения о начальном состоянии сложной системы, фактическим значением параметров отобразить реальные процессы и поведение сложной системы для конкретной ситуации с учетом координатных и параметрических возмущений.

Использование имитационного моделирования рекомендуется в следующих случаях:

Нет законченной постановки задачи и идет процесс познания объекта моделирования;

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

Желательно получить характеристики всех входных координат, компонент, составляющих сложную систему;

Необходимо произвести моделирование в ускоренном или замедленном масштабе времени.

Сущность имитационного моделирования.

Фактически все расчеты на ЭВМ являются моделями реальных процессов, чтобы отличать модели друг от друга исследователи ввели дополнительные названия. Термин имитационное моделирование означает, что мы имеем дело с такими математическими моделями, результат функционирования которых нельзя вычислить заранее, а можно получить только в процессе расчета с модельным временем на заданном интервале времени. Программную имитационную модель необходимо вначале отладить и испытать. Поэтому под процессом имитации на ЭВМ понимается процесс конструирования модели, испытания модели, применение модели для исследования поведения реального объекта в различных условиях.

Понятие о существующих моделях.

Каждая модель представляет собой комбинацию таких составляющих, как:

Компонент — составные части, которые при объединении образуют систему.

Переменные — описывают входы и выходы компоненты. В тех случаях, когда переменные изменяют состояние компоненты, их называют переменные состояния.

Параметры — значения характеризующие состояние компоненты.

Функциональные зависимости — определяют поведение переменных в пределах компоненты.

Ограничения — представляют собой устанавливаемые пределы изменения переменных.

Целевые функции — характеризируют динамические свойства или иные свойства системы.

Понятие о модельном времени.

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

При реализации ИМ используются обычно три представления времени:

TR — реальное время системы, работа которой имитируется на данной ИМ;

Т0 — модельное время, по которому организуется синхронизация событий в системе;

ТЭ — машинное время имитации, отражающее затраты ресурса времени ЭВМ на организацию имитации.

2.2 Исследование свойств имитационной модели После того, как завершена верификация ИМ и достигнута адекватность модели реальному объекту, необходимо исследовать свойства ИМ. Исследователь должен ясно представлять возможности построенной ИМ. Наиболее существенными являются следующие процедуры исследования модели: оценка погрешности имитации, обусловленной наличием в ИМ неидеальных генераторов псевдослучайных чисел; определение длительности переходного режима в работе ИМ; оценка устойчивости результатов имитации исследуемых процессов.

В любой вероятностной ИМ сложной системы применяются генераторы псевдослучайных чисел. Как правило, система автоматизации моделирования предоставляет в распоряжение исследователя несколько различных генераторов псевдослучайных чисел. Каждый из них использует базовый генератор, числа с выхода которого затем преобразуются для получения псевдослучайных величин с заданными законами распределения. Оказывается, что такой генератор является источником погрешности имитации. В силу особенностей алгоритма работы генераторов псевдослучайных чисел, результаты нескольких прогонов ИМ при одних и тех же значениях параметров и переменных будут отличаться друг от друга.

2.3 Разработка имитационной модели Так как разрабатываемая модель не рассчитывает на полное описание функционирования операционной системы, то ее параметры и функции ограничены демонстрацией только некоторых возможностей ОС.

Для реализации всего механизма взаимодействия операционной системы с другими компонентами создаются: модель оперативной памяти, модель процесса и модель сегмента.

Модель оперативной памяти характеризуется следующими параметрами:

Размер оперативной памяти;

Список загруженных сегментов;

Индекс сегмента. Каждый сегмент имеет свой уникальный номер, по которому ведется поиск данных, относящихся к сегменту, в списке сегментов;

Адрес доступа к сегменту.

Модель ОП имеет следующие процедуры:

Получить размер ОП;

Установить размер ОП;

Добавить сегмент;

Получить доступ к сегменту.

Модель процесса имеет следующие параметры:

Список сегментов;

Индекс сегмента;

Адрес доступа к сегменту.

Модель процесса имеет следующие процедуры:

Добавить сегмент;

Получить количество сегментов;

Получить доступ к сегменту.

Модель сегмента характеризуется следующими параметрами:

Адрес сегмента;

Размер сегмента. Каждый сегмент имеет свою длину, которая играет роль при его размещении и перемещении;

Имя сегмента;

Тип сегмента;

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

Модель сегмента имеет следующие процедуры:

Получить размер сегмента;

Установить размер сегмента;

Получить адрес сегмента;

Установить адрес сегмента;

Получить тип сегмента;

Установить тип сегмента;

Получить адрес сегмента в ОП;

Установить адрес сегмента в ОП.

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

Так как все перечисленные модели можно охарактеризовать, как объекты какой-то системы, то для их реализации необходим объектно-ориентированный язык программирования. Сегодня, при наличии широкого диапазона таких языков, сделать окончательный выбор не так уж и сложно. Все представленные модели реализованы в среде Borland C++ Builder 6.0 в виде классов с соответствующими параметрами, процедурами и функциями. Так как данная среда позволяет построение диалогового приложения, причем, для этого уже имеются стандартные объекты и функции, их описывающие. Это позволяет сузить круг проблем, решение которых необходимо для решения поставленной задачи до минимума: программирование разработанных моделей и дизайн приложения.

2.5 Описание программной реализации имитационной модели Описание классов

class Memory — представляет собой класс оперативной памяти Данные:

TList * SList — список сегментов

int Size — размер оперативной памяти

int iSeg — индекс сегмента

int accAdr — адрес доступа Методы:

void AddSeg (Segment *pSeg) — добавить сегмент

void SetSize (int val) — установить размер ОП

int GetSize () — получить размер ОП

void Access (int iS, int adr) — функция доступа к сегменту

class Process — представляет собой класс процесса Данные:

TList* SList — список сегментов

int iSeg — индекс сегмента

int accAdr — адрес доступа Методы:

void AddSeg (Segment * pSeg) — добавить сегмент

int GetNSegm () — получить количество сегментов

int Access (int iS) — функция доступа

class Segment — представляет собой класс сегмента Данные:

int Adres — адрес сегмента

int Size — размер сегмента

AnsiString Name — имя сегмента

int Type — тип сегмента (код/данные)

int AdresOP — адрес сегмента в ОП Методы:

int GetSize () — получить размер сегмента

void SetSize (int val) — установить размер сегмента

int GetAdr () — получить адрес сегмента

void SetAdr (int val) — установить адрес сегмента

int GetType () — получить тип сегмента

void SetType (int val) — установить тип сегмента

int GetAdrOP () — получить адрес сегмента в ОП

void SetAdrOP (int val) — установить адрес сегмента в ОП

2.7 Разработка приложения Внешний вид главной формы:

Приложение состоит из компонентов следующих типов: TButton (кнопки «Применить», «Добавить», «Начать», «Остановить» и «Завершить работу»), TCSpinEdit (установка размера (в условных единицах) оперативной пямяти и сегмента), TComboBox (выбор типа сегмента (код или данные)), TPaintBox (графическое представление процесса и оперативной памяти), TTimer (реализация механизма адресации), TLabel, TGroupBox.

2.8 Описание функционирования имитационной модели Внешний вид приложения:

При помощи соответствующих элементов управления

можно менять размер модели ОП:

А также размер и тип (Код/Данные) сегментов:

При нажатии на кнопку «Добавить» происходит добавление

сегментов в процесс и в оперативную память:

Добавлено 5 сегментов: 3 сегмента с данными и 2 сегмента с кодами.

Как видно из рисунка, сегменты расположены в ОП случайно,

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

Заключение

В данном курсовом проекте была поставлена задача провести моделирование сегментной схемы структуризации.

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

Листинг программы Файл Unit1. h

//—————————————————————————————————————;

#ifndef Unit1H

#define Unit1H

//—————————————————————————————————————;

#include

#include

#include

#include

#include «CSPIN.h»

#include

//—————————————————————————————————————;

#include «Process.h»

#include «Memory.h»

class TForm1: public TForm

{

__published:// IDE-managed Components

TPaintBox *PaintBox1;

TPaintBox *PaintBox2;

TGroupBox *GroupBox1;

TGroupBox *GroupBox2;

TLabel *Label1;

TCSpinEdit *CSpinEdit1;

TLabel *Label2;

TComboBox *ComboBox1;

TButton *Button1;

TLabel *Label3;

TCSpinEdit *CSpinEdit2;

TButton *Button2;

TGroupBox *GroupBox3;

TButton *Button3;

TTimer *Timer1;

TLabel *Label4;

TLabel *Label5;

void __fastcall FormDestroy (TObject *Sender);

void __fastcall Button1Click (TObject *Sender);

void __fastcall FormPaint (TObject *Sender);

void __fastcall Button2Click (TObject *Sender);

void __fastcall Button5Click (TObject *Sender);

void __fastcall Button3Click (TObject *Sender);

void __fastcall Button4Click (TObject *Sender);

void __fastcall Timer1Timer (TObject *Sender);

private:// User declarations

Process *pProc;

Memory *pMem;

public:// User declarations

__fastcall TForm1(TComponent* Owner);

};

//—————————————————————————————————————;

extern PACKAGE TForm1 *Form1;

//—————————————————————————————————————;

#endif

Файл Unit1. cpp

//—————————————————————————————————————;

#include

#pragma hdrstop

#include «Unit1.h»

#include «Segment.h»

#pragma package (smart_init)

#pragma link «CSPIN»

#pragma resource «*.dfm»

TForm1 *Form1;

//—————————————————————————————————————;

__fastcall TForm1: TForm1(TComponent* Owner)

: TForm (Owner)

{

pProc = new Process;

pMem = new Memory;

}

//—————————————————————————————————————;

void __fastcall TForm1: FormDestroy (TObject *Sender)

{

delete pProc;

delete pMem;

}

//—————————————————————————————————————;

void __fastcall TForm1: Button1Click (TObject *Sender)

{

Segment *pSeg = new Segment;

pSeg->SetSize (CSpinEdit1->Value);

pSeg->SetType (ComboBox1->ItemIndex);

pProc->AddSeg (pSeg);

pMem->AddSeg (pSeg);

FormPaint (Sender);

}

//—————————————————————————————————————;

void __fastcall TForm1: FormPaint (TObject *Sender)

{

pProc->Paint (PaintBox1);

pMem->Paint (PaintBox2);

}

//—————————————————————————————————————;

void __fastcall TForm1: Button2Click (TObject *Sender)

{

pMem->SetSize (CSpinEdit2->Value);

pMem->Paint (PaintBox2);

}

//—————————————————————————————————————;

void __fastcall TForm1: Button5Click (TObject *Sender)

{

Close ();

}

//—————————————————————————————————————;

void __fastcall TForm1: Button3Click (TObject *Sender)

{

Timer1->Enabled = true;

}

//—————————————————————————————————————;

void __fastcall TForm1: Button4Click (TObject *Sender)

{

Timer1->Enabled = false;

}

//—————————————————————————————————————;

Файл Memory. h

//—————————————————————————————————————;

#ifndef MemoryH

#define MemoryH

//—————————————————————————————————————;

#include

#include

#include «Segment.h»

class Memory

{

private:

TList * SList;

int Size;

int iSeg;

int accAdr;

public:

Memory ();

~Memory ();

void Paint (TPaintBox * pBox);

void AddSeg (Segment *pSeg);

void SetSize (int val);

int GetSize ();

void Access (int iS, int adr);

};

#endif

Файл Memory. cpp

//—————————————————————————————————————;

#pragma hdrstop

#include «Memory.h»

#include «Process.h»

//—————————————————————————————————————;

#pragma package (smart_init)

Memory:Memory ()

{

SList = new TList;

Size = 640;

}

Memory:~Memory ()

{

delete SList;

}

void Memory: Paint (TPaintBox * pBox)

{

pBox->Width = Size;

pBox->Canvas->Brush->Color = clWhite;

pBox->Canvas->FillRect (pBox->ClientRect);

float mx = 1;

for (int i=0; iCount; i++)

{

Segment *p = (Segment *) SList->Items[i];

int x = p->GetAdrOP ();

if (p->GetType () == 0)

{

pBox->Canvas->Pen->Width=2.5;

pBox->Canvas->Pen->Color = clRed;

}

else

{

pBox->Canvas->Pen->Width=1;

pBox->Canvas->Pen->Color = clBlue;

}

pBox->Canvas->Rectangle (x+1, 0, x+mx*p->GetSize ()-1, pBox->Height);

if (i == iSeg)

{

int xacc = x + accAdr;

int yacc = xacc % pBox->Height;

pBox->Canvas->Rectangle (xacc-2, yacc-2, xacc+2, yacc+2);

}

}

}

void Memory: AddSeg (Segment * pSeg)

{

int i, adr;

while (1)

{

adr = random (Size — pSeg->GetSize ());

for (i=0; i < SList->Count; i++)

// !!!

adr < adr_kon) // !!!

break;

if (i == SList->Count)

break;

}

pSeg->SetAdrOP (adr);

SList->Add (pSeg);

}

void Memory: SetSize (int val)

{

Size = val;

}

int Memory: GetSize ()

{

return Size;

}

void Memory: Access (int iS, int adr)

{

iSeg = iS;

accAdr = adr;

}

Файл Process. h

//—————————————————————————————————————;

#ifndef ProcessH

#define ProcessH

//—————————————————————————————————————;

#include

#include

#include «Segment.h»

class Process

{

public:

Process ();

~Process ();

void AddSeg (Segment * pSeg);

void Paint (TPaintBox * pBox);

int GetNSegm ();

int Access (int iS);

private:

TList* SList;

int iSeg;

int accAdr;

};

#endif

Файл Process. cpp

//—————————————————————————————————————;

#pragma hdrstop

#include «Process.h»

//—————————————————————————————————————;

#pragma package (smart_init)

Process:Process ()

{

SList = new TList;

}

Process:~Process ()

{

delete SList;

}

void Process: AddSeg (Segment * pSeg)

{

int sumSize = 0;

for (int i=0; iCount; i++)

{

Segment *p = (Segment *) SList->Items[i];

sumSize += p->GetSize ();

}

pSeg->SetAdr (sumSize);

SList->Add (pSeg);

}

void Process: Paint (TPaintBox * pBox)

{

pBox->Canvas->Brush->Color = clWhite;

pBox->Canvas->FillRect (pBox->ClientRect);

float mx = 1;

for (int i=0; iCount; i++)

{

Segment *p = (Segment *) SList->Items[i];

int x = p->GetAdr ();

if (p->GetType () == 0)

{

pBox->Canvas->Pen->Width=2.5;

pBox->Canvas->Pen->Color = clRed;

}

else

{

pBox->Canvas->Pen->Width=1;

pBox->Canvas->Pen->Color = clBlue;

}

pBox->Canvas->Rectangle (x+1, 0, x+mx*p->GetSize ()-1, pBox->Height);

if (i == iSeg)

{

int xacc = x + accAdr;

int yacc = xacc % pBox->Height;

pBox->Canvas->Rectangle (xacc-2, yacc-2, xacc+2, yacc+2);

}

}

}

int Process: GetNSegm ()

{

return SList->Count;

}

int Process: Access (int iS)

{

iSeg = iS;

Segment *pSeg = (Segment *) SList->Items[iS];

accAdr = random (pSeg->GetSize ());

return accAdr;

}

Файл Segment. h

//—————————————————————————————————————;

#ifndef SegmentH

#define SegmentH

//—————————————————————————————————————;

#include

class Segment

{

public:

Segment ();

~Segment ();

void SetSize (int val);

void SetAdr (int val);

int GetSize ();

int GetAdr ();

int GetType ();

void SetType (int val);

void SetAdrOP (int val);

int GetAdrOP ();

private:

int Adres;

int Size;

AnsiString Name;

int Type;

int AdresOP;

};

#endif

Файл Segment. cpp

//—————————————————————————————————————;

#pragma hdrstop

#include «Segment.h»

//—————————————————————————————————————;

#pragma package (smart_init)

Segment:Segment ()

{

Adres = 0;

AdresOP = 0;

Size = 0;

}

void Segment: SetSize (int val)

{

Size = val;

}

void Segment: SetAdr (int val)

{

Adres = val;

}

int Segment: GetSize ()

{

return Size;

}

int Segment: GetAdr ()

{

return Adres;

}

int Segment: GetType ()

{

return Type;

}

void Segment: SetType (int val)

{

Type = val;

}

void Segment: SetAdrOP (int val)

{

AdresOP = val;

}

int Segment: GetAdrOP ()

{

return AdresOP;

}