Разработка библиотеки имитационного моделирования. Система массового обслуживания. Модель комиссионного магазина

 

Содержание

Введение

1. Техническое задание

2. Вариант задания

3. Теоретические сведения

3.1 Понятие СМО

3.1.1 Основные определения СМО

3.1.2 Структура СМО

3.1.3 Классификация СМО

3.1.4 Характеристики СМО

3.1.5 Теоретическое представление задачи

3.2 Q-схемы

3.2.1 Непрерывно-стохастические модели (Q-схемы)

3.2.2 Стохастические сети

3.3 Понятие ООП

3.3.1 Принципы ООП

3.3.2 Преимущества ООП

3.3.3 Основные термины и положения ООП

4. Разработка проекта

4.1 Разработка алгоритма СМО

4.2 Выбор языка программирования

4.3 Программная реализация

5. Проектирование иерархии иммитационного моделирования

5.1 Формирование словаря абстракций предметной области

5.1.1 Выделение общих абстракций

5.1.2 Определение отношений между абстракциями

6. Разработка библиотеки классов иммитационного моделирования

6.1 Разработка структуры библиотеки

Заключение

Библиографический список

Приложения

Введение

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

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

Заявки поступают в СМО обычно не регулярно, а случайно, образуя так называемый случайный поток заявок (требований). Обслуживание заявок также продолжается какое-то случайное время. Случайный характер потока заявок и времени обслуживания приводит к тому, что СМО оказывается загруженной неравномерно: в какие-то периоды времени скапливается очень большое количество заявок (они либо становятся в очередь, либо покидают СМО не обслуженными), в другие же периоды СМО работает с недогрузкой или простаивает.

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

1. Техническое задание

Задание к курсовому проекту заключается в создании библиотеки классов имитационного моделирования и реализации алгоритма имитационного моделирования СМО "Модель комиссионного магазина". Для разработки использовать среду программирования C++.

Основание для разработки

Данный программный продукт разрабатывается как курсовая работа по дисциплине "Технология программирования"

Назначение разработки

Разрабатываемая программа предназначена для моделирования различных систем массового обслуживания.

Требования к программе

Входные данные

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

Выходные данные

на каждом шаге отображать модельное время;

статистика по поступившим, находящимся в системе на обслуживании и обработанным заявкам;

статистика по потокам заявок, очередям и аппаратам обслуживания.

коэффициенты использования каналов обслуживания;

максимальная длина очередей в системе;

время нахождения требований в очередях и каналах обслуживания.

Результирующие компоненты изделия

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

Оценка основных характеристик моделируемой системы:

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

Этапы разработки программы

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

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

разработка основных алгоритмов;

проектирование формата файлов;

программирование алгоритмов и структур данных;

отладка и тестирование программы;

документирование.

Требования к документации

Перечень представляемых документов:

задание на курсовую работу;

техническое задание на разработку;

описание структуры программы;

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

схемы основных алгоритмов;

описание форматов данных и файлов;

контрольные примеры и результаты программы;

листинги основных программных модулей;

краткая эксплуатационная документация.

Все документы оформляются на листах формата A4, на одной стороне листа, и представляются в виде пояснительной записки.

Документы по содержанию должны соответствовать ГОСТ 34.201-89, 34.602-89, 19.701-90.

программирование система массовое обслуживание

2. Вариант задания

Система массового обслуживания. Модель комиссионного магазина.

Концептуальная модель.

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

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

3. Теоретические сведения

3.1 Понятие СМО

3.1.1 Основные определения СМО

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

Первые задачи теории систем массового обслуживания (ТСМО) были рассмотрены сотрудниками Копенгагенской телефонной компании, датским ученым А.К. Эрлангом (1878 г. - 1929 г.) в период между 1908 и 1922 гг.

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

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

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

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

3.1.2 Структура СМО

Все СМО имеют вполне определенную структуру, изображенную на рис.1

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

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

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

.Совокупность очередей и приборов (каналов) обслуживания называется системой обслуживания.

.Каждое требование поступает на свой канал, где подвергается операции обслуживания.

.Каждая СМО имеет правила формирования очереди и правила или дисциплину обслуживания.

3.1.3 Классификация СМО

СМО делятся на системы с отказами и системы без отказов.

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

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

СМО делятся на замкнутые и разомкнутые.

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

СМО делятся на многоканальные и одноканальные системы в зависимости от количества обслуживающих каналов.

В n-канальной CМО одновременно может обслуживаться n заявок. Каналы обслуживания иногда называют обслуживающими аппаратами (ОА).

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

Длительность обслуживания заявки в ОА в общем виде - это случайная величина с законом распределения и математическим ожиданием (средним значением) M.

СМО также делятся по приоритету заявок:

СМО с заявками, имеющими разный приоритет (абсолютный, относительный);

СМО с заявками, имеющими одинаковый приоритет.

3.1.4 Характеристики СМО

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

·среднее время обслуживания;

·среднее время ожидания в очереди;

·среднее время пребывания в СМО;

·средняя длина очереди;

·среднее число заявок в СМО;

·количество каналов обслуживания;

·интенсивность входного потока заявок;

·интенсивность обслуживания;

·интенсивность нагрузки;

·коэффициент нагрузки;

·относительная пропускная способность;

·абсолютная пропускная способность;

·доля времени простоя СМО;

·доля обслуженных заявок;

·доля потерянных заявок;

·среднее число занятых каналов;

·среднее число свободных каналов;

·коэффициент загрузки каналов;

·среднее время простоя каналов.

3.1.5 Теоретическое представление задачи

Интенсивность поступления заявок входного потока - l. Интенсивность обслуживания заявок системой - ?. Поток поступления заявок характеризуется распределением Эрланга с k=2, поток обслуживания заявок характеризуются показательным законом распределения. Тогда интервал времени поступления заявок 1-го потока представляет собой случайную величину с одним и тем же распределением вероятностей F (t).

Аналогично, интервал времени обслуживания заявок представляет собой случайную величину с одним и тем же распределением вероятностей F (t).

3.2 Q-схемы

3.2.1 Непрерывно-стохастические модели (Q-схемы)

К этому классу моделей относятся системы и сети массового обслуживания.

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

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

·потоки поставок продукции некоторому предприятию,

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

·транспортные потоки,

·заявки на обработку информации ЭВМ от удаленных терминалов (информационные потоки),

·обслуживание задач в ВС,

·обслуживание покупателей в магазине.

Акт обслуживания состоит из двух составляющих: ожидание обслуживания заявки и собственно обслуживание заявки. Система массового обслуживания или прибор обслуживания состоит из двух элементов:

1)накопителя, в котором заявки ожидают обслуживания;

2)канала обслуживания, в котором выполняется действие обслуживания заявки.

·ЗАЯВКА - объект, обслуживаемый в приборе (которому выделяются ресурсы (канал)).

·В НАКОПИТЕЛЕ заявки ожидают обслуживания. В нем может находиться сразу несколько заявок.

·КАНАЛ - объект, выполняющий действие обслуживания. В канале может обслуживаться не более одной заявки.

·ПОТОК событий детерминированная или стохастическая последовательность событий, происходящих одно за другим в какие-то моменты времени.

·Поток событий называется ОДНОРОДНЫМ, если он характеризуется только моментами поступления этих событий

{tc}={t1,t2,.,tn. }.

·Однородный поток событий также может быть задан в виде последовательности промежутков времени между n-м и (n-1) - м событиями tn.

·Поток событий называется НЕОДНОРОДНЫМ, если он характеризуется не только моментами наступления событий, но и их параметрами, т.е. {tn, fn}, где tn - вызывающие моменты, fn - набор признаков события.

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

·Поток с ОГРАНИЧЕННЫМ ПОСЛЕДЕЙСТВИЕМ - это поток, в котором интервалы между наступлениями событий dt1, dt2,., dtn являются случайными независимыми величинами.

·Поток называется ОРДИНАРНЫМ, если вероятность Рndt того, что на малый интервал времени dt, примыкающий к моменту t, попадает больше одного события (n>1), пренебрежительно мала по сравнению с вероятностью P1dt того, что на интервал времени dt попадает ровно одно событие P1dt >> Pndt

·СТАЦИОНАРНЫЙ поток событий - поток, для которого вероятность появления того или иного числа событий на интервале времени dT зависит лишь от величины этого интервала и не зависит от того, где на оси времени (0,t) взят этот участок.

·То есть, если dT1 = dT2, то Рndt1 = Рndt2.

·Поток событий называется потоком БЕЗ ПОСЛЕДЕЙСТВИЯ, если для любых двух непересекающихся интервалов времени dt1 и dt2, число событий, попадающих на один из них, не зависит от того, сколько событий попало на другой.

·Поток называется ПРОСТЕЙШИМ (или стационарным пуассоновским), если он является стационарным, ординарным и не имеет последействия одновременно.

·У простейшего потока интервалы времени ? между двумя последовательными заявками - независимые случайные величины с функцией распределения

.

·Такое распределение называется экспоненциальным (показательным) и имеет и имеет плотность

.

·СМО характеризуется СОСТОЯНИЯМИ Zi, которое является совокупностью состояний накопителя ZiH и канала ZiK:

i = (ZiH, ZiK).

·Накопитель может принимать следующие состояния ZiH:

·ZiH = 0 - накопитель пуст;

·ZiH = 1 - в накопителе одна заявка;

·.ZiH = N - в накопителе N заявок, накопитель полон, однако это возможно для конечных накопителей. Для бесконечных ZiH = ¥.

·Канал может принимать следующие состояния ZiK:

·ZiK = 0 - канал свободен, заявки не обслуживаются;

·ZiK = 1 - канал занят обслуживанием заявки.

3.2.2 Стохастические сети

Типы систем массового обслуживания.

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

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

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

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

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

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

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

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

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

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

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

СТОХАСТИЧЕСКАЯ СЕТЬ Совокупность взаимосвязанных СМО, в среде которых циркулируют заявки, - это сети массового обслуживания или стохастические сети. Представление ВС в виде стохастической сети обеспечивает более глубокий уровень стратификации системы, чем ВС в виде отдельной СМО.

Рис 15. Разомкнутая (а) и замкнутая (б) стохастические сети С.

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

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

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

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

3.3 Понятие ООП

3.3.1 Принципы ООП

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

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

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

Другим немаловажным следствием инкапсуляции является легкость обмена объектами, переноса их из одной программы в другую. Можно сказать, что ООП "провоцирует" разработку библиотек объектов, таких как Turbo Vision.

Наследование есть свойство объектов порождать своих потомков. Объект-потомок автоматически наследует от родителя все поля и методы, может дополнять объекты новыми полями и заменять (перекрывать) методы родителя или дополнять их.

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

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

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

3.3.2 Преимущества ООП

ООП хорошо применяется в практике программирования для более лёгкого создания управляемых проектов.

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

Программный код с использованием ООП более читабельный и легче для восприятия. Код с ООП организован лучше потому что в нём понятно какой объект чем обрабатывается.

Таким образом, исходя из изложенного выше, можно вынести преимущества использования ООП:

ООП был создан что бы облегчить жизнь разработчикам. Используя ООП вы можете разбить ваши большие проблемы на маленькие проблемы, которые решать гораздо проще.

Основное требование ООП: всё что вы хотите сделать - делайте объектами. Объекты это отдельная маленькая часть кода которая может объединять данные и свойства вместе. В приложениях все объекты взаимодействуют друг с другом.

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

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

oРефакторинг: Когда вам необходимо в проекте использовать рефакторинг, ООП предоставляем вам максимум преимуществ, так как все объекты это маленькие элементы и содержат свои свойства и методы как часть себя. По этому использовать рефакторинг относительно легко.

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

oПоддержка: объектно-ориентированный код легче поддерживать так как он следует весьма жёстким соглашениям написания кода и пишется в самопоясняющейся форме. К примеру, когда разработчик дополняет, перерабатывает код, или отлаживает его, он может легко найти внутреннюю структуру кода и поддерживать код время от времени.

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

3.3.3 Основные термины и положения ООП

Объектно-ориентированное программирование (ООП) - парадигма программирования, в которой основными концепциями являются понятия объектов и классов (либо, в менее известном варианте языков с прототипированием - прототипов).

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

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

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

Прототип - это объект-образец, по образу и подобию которого создаются другие объекты.

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

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

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

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

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

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

Следовательно, объектно-ориентированный подход является сейчас одним из самых распространенных и эффективных в программировании различных информационных процессов.

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

4. Разработка проекта

4.1 Разработка алгоритма СМО

Рассмотрим алгоритм решения поставленной задачи:

.Рассматриваемая в задаче система представляет собой СМО с многоканальным обслуживанием;

2.Определение времен поступления и обслуживания заявок:

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

·Интенсивности поступления и обслуживания заявок заданы;

.Функционирование рассматриваемой СМО:

·Каждый канал обслуживает в каждый момент времени одну заявку;

·Если в момент поступления новой заявки свободен хотя бы один канал, то пришедшая заявка поступает на обслуживание;

·Если отсутствуют заявки, то система простаивает.

4.Дисциплина обслуживания:

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

·Если к моменту поступления заявки все места в очереди заняты, то заявка получает отказ.

Зная параметры входных потоков заявок промоделировать поведение системы и вычислить её основные характеристики эффективности.

Характеристики эффективности функционирования СМО выделим следующие:

·Вероятность отказа;

·Абсолютная пропускная способность;

·Вероятность простоя;

·Доля обслуженных заявок;

·Среднее количество занятых каналов.

Таким образом, общий алгоритм выглядит так:

·Вводим начальные условия: общее время работы системы, значения интенсивностей потока заявок и потока обслуживания заявок; число реализаций работы системы;

·Генерируем моменты времени, в которые прибывают заявки, время обслуживания каждой заявки;

·Считаем сколько заявок было обслужено, а сколько получило отказ;

·Рассчитываем характеристики эффективности СМО:

4.2 Выбор языка программирования

С++ - это универсальный язык программирования, задуманный так, чтобы сделать программирование более приятным для серьёзного программиста. За исключением второстепенных деталей С++ является надмножеством языка программирования С. Помимо возможностей, которые дает С, С++ предоставляет гибкие и эффективные средства определения новых типов. Используя определения новых типов, точно отвечающих концепциям приложения, программист может разделять разрабатываемую программу на легко поддающиеся контролю части. Такой метод построения программ часто называют абстракцией данных. Информация о типах содержится в некоторых объектах типов, определённых пользователем. Такие объекты просты и надёжны в использовании в тех ситуациях, когда их тип нельзя установить на стадии компиляции. Программирование с применением таких объектов часто называют объектно-ориентированным. При правильном использовании этот метод даёт более короткие, проще понимаемые и легче контролируемые программы.

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

С++ поддерживает указатели не переменные и функции. Указатель на объект программы соответствует машинному адресу этого объекта. Посредством разумного использования указателей можно создавать эффективно-выполняемые программы, так как указатели позволяют ссылаться на объекты тем же самым путём, как это делает машина. С++ поддерживает арифметику указателей, и тем самым позволяет осуществлять непосредственный доступ и манипуляции с адресами памяти.

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

Для реализации курсового проекта выбрана интегрированная среда программирования Borland C++ Builder 6.0, как наиболее мощная реализация языка программирования Object C++ с возможностью написания программ как под DOS так и под операционные системы Windows 95/98/2000 и NT. Расширенный "менеджер" проектов с множественными типами исполняемого кода, компилятор с оптимизацией кода, инкрементальный линкер, мощные средства интегрированной отладки, стройная архитектура распределенных приложений клиент/сервер, новые технологии разработки приложений для сети Интернет - наиболее известные достоинства Borland C++ Builder 6.0.

Интегрированная среда системы (Integrated Development Environment, IDE) обеспечивает ускорение визуального программирования, а также продуктивность повторно используемых компонентов в сочетании с усовершенствованными инструментами IDE и разномасштабными средствами доступа к базам данных.

Открытость среды IDE позволяет настраивать ее с учетом наиболее модных тенденций в области графических интерфейсов, что позволит создать современный и дружественный интерфейс обучающей среды.C++ Builder 6.0 позволяет повысить быстродействие и надежность разрабатываемой подсистемы, придать пользовательскому интерфейсу качество профессионального уровня.

Исходя из вышеизложенного для написания программы, был выбран среда программирования Borland С ++ Builder версии 6.0.

4.3 Программная реализация

Программа была разработана в среде программирования Borland C++ Builder 6.

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

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

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

Проектирование различают:

.логическое проектирование, при котором принимаемые решения практически не зависят от условий эксплуатации (операционной системы и используемого оборудования);

2.физическое проектирование, при котором приходится принимать во внимание указанные факторы.

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

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

Реализация программного комплекса. Это процесс поэтапной реализации и подключения классов к проекту.

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

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

Если состояние системы S=0, то генерируется время поступления заявки в систему, время работы системы увеличивается на данное время, количество обслуженных заявок инкрементируется. Если S=1, то генерируется и время поступления заявки в систему, и время обслуживания заявки системой, время работы системы увеличивается на меньшее значение сгенерированных величин. Если же время обслуживания меньше, то S=0, количество обслуженных заявок инкрементируется, иначе S=1. Если S=2, то генерируется и время поступления заявки в систему, и время обслуживания заявки системой, время работы системы увеличивается на меньшее значение сгенерированных величин. Если же время обслуживания меньше, то S=1, количество обслуженных заявок инкрементируется, иначе S=2. В этом случае заявка получает отказ.

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

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

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

При решении поставленной задачи была разработана программа с применением объектно-ориентированного подхода.

5. Проектирование иерархии иммитационного моделирования

5.1 Формирование словаря абстракций предметной области

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

Все выявленные абстракции сведены вместе с их характеристиками в табл.1:

Таблица 1

№Название абстракцииХарактеристика абстракции1Генератор заявокВходит в структуру Q-схемы Обрабатывает заявки Имеет выходные информационные связи Выдает заявки Задерживает заявки (по времени) Характеризуется законом распределения Не имеет входов Не имеет управляющих выходов2КаналВходит в структуру Q-схемы Обрабатывает заявки Имеет входные информационные связи Имеет выходные информационные связи Принимает заявки Выдает заявки Задерживает заявки (по времени) Характеризуется законом распределения Не имеет управляющих входов Может иметь управляющие выходы3ОчередьВходит в структуру Q-схемы Обрабатывает заявки Имеет входные информационные связи Имеет выходные информационные связи Принимает заявки Выдает заявки Задерживает заявки (по готовности приемника) Характеризуется дисциплиной обслуживания Имеет контейнер заявок Не имеет управляющих входов Может иметь управляющие выходы4КлапанВходит в структуру Q-схемы Обрабатывает заявки Имеет входные информационные связи Имеет входные управляющие связи Имеет выходные информационные связи Принимает заявки Выдает заявки Не задерживает заявки Характеризуется функцией управления Не имеет управляющих выходов5Простой случайный контроллерВходит в структуру Q-схемы Не обрабатывает заявки Имеет хотя бы 2 управляющих выхода Управляет группой клапанов по случайному закону Выбор клапанов по принципу "один из N" Не имеет информационных связей Характеризуется законом распределения Не имеет управляющих входов6Адаптивный случайный контроллерВходит в структуру Q-схемы Не обрабатывает заявки Имеет хотя бы 2 управляющих выхода Управляет группой клапанов по случайному закону Выбор клапанов по принципу "один из N" Адаптирует закон управления по состоянию других элементов Не имеет информационных связей Характеризуется законом распределения Имеет управляющие входы (ассоциации) 7Обобщенный массовый контроллерВходит в структуру Q-схемы Не обрабатывает заявки Имеет хотя бы 2 управляющих выхода Управляет группой клапанов по произвольному закону Выбор клапанов по любому принципу Адаптирует закон управления по состоянию других элементов и другой информации Не имеет информационных связей Имеет управляющие входы (ассоциации) 8ЗаявкаФормируется в генераторе Включает атрибуты (тип, приоритет, время генерации) Уничтожается при выходе из системы9Структура схемыСодержит информационные и управляющие связи для всех пар связанных элементов Для управляющих связей задает состояния управления10Q-схемаОхватывает управление запуском модели, остановом моделирования, организует сбор статистики, имитирует попарную передачу заявок элементами, управляет отслеживанием ошибок11Генератор случайных чиселИспользуется генераторами заявок и каналами для получение временных интервалов выдачи заявок и обслуживания12Дисциплина обслуживанияИспользуется очередями для задания порядка извлечения заявок13Функция управленияИспользуется клапанами для объединения сигналов управления14Менеджер статистикиВспомогательная абстракция, используемая Q-схемой для управления сбором статистики и ведения протокола статистики15Менеджер ошибокВспомогательная абстракция, используемая Q-схемой для управления отслеживанием ошибок16РазветвительОбрабатывает заявки, имеет входную информационную связь, имеет как минимум две выходные информационные связи, не задерживает заявки, создает копию заявки

5.1.1 Выделение общих абстракций

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

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

Таблица 2

№Название абстракцииХарактеристика абстракции1Структурный элемент Q-схемыВходит в структуру Q-схемы Имеет какие-либо связи (характер связей не определен) 2Обработчик заявокВходит в структуру Q-схемы Обрабатывает заявки Имеет информационные связи (входные или выходные, или входные и выходные одновременно) 3Контроллер группы клапановВходит в структуру Q-схемы Не обрабатывает заявок Имеет управляющие связи (характер связей неизвестен) Не имеет информационных связей4ПередатчикВходит в структуру Q-схемы Обрабатывает заявки Имеет выходные информационные связи Выдает заявки (с задержкой либо без нее) 5ПриемникВходит в структуру Q-схемы Обрабатывает заявки Имеет входные информационные связи Принимает заявки6Передатчик с задержкойВходит в структуру Q-схемы Обрабатывает заявки Имеет выходные информационные связи Выдает заявки Задерживает заявки (по времени в соответствии с заданным законом распределения) 7Объект управленияВходит в структуру Q-схемы Обрабатывает заявки Имеет входные управляющие связи Характеризуется функцией управления

5.1.2 Определение отношений между абстракциями

Иерархия классов получается из табл.1 и табл.2 путем последовательного установления отношения "общее - частное" для всех абстракций, а также определения отношения использования и ассоциации. Иерархия показана на рис.1. Прямоугольниками отображены основные элементы Q-схем (которые непосредственно изображаются на схеме), а овалами показаны дополнительные абстракции. Сплошными стрелками изображено отношение открытого наследования, которое представляет в иерархии отношение "общее - частное", а пунктиром показаны ассоциации и отношение использования между абстракциями.

Каждая из абстракций иерархии рис.1 далее представляется в виде сущности одного из трех видов: класса (структуры), шаблонного класса или функции на языке С++. Переход от абстракций к сущностям на С++ осуществляется в следующем разделе. Ниже в табл.3 записано соответствие сущностей С++ выделенным абстракциям и даны имена (идентификаторы) сущностей.

Таблица 3

Наименование абстракцииВид сущностиИдентификатор сущностиСтруктурный элемент Q-схемыклассCGenericElementОбработчик заявокклассCReqAwareElementОбъект управленияклассCObjectOfControlПриемникклассCReceiverПередатчикклассCTransmitterПередатчик с задержкойшаблонCDelayedTransmitterНеуправляемый генератор заявокшаблонCReqGeneratorУправляемый генератор заявокCControlledReqGeneratorКаналшаблонCDeviceКлапанклассCGateАбстрактная очередьшаблонCQueueБесконечная очередьшаблонCUnlimitedQueueКонечная очередьшаблонCLimitedQueueКонтроллер группы клапановклассCMassGateControllerПростой случайный контроллерклассCRndGateControllerАдаптивный случайный контроллерклассCSmartRndGateControllerОбобщенный массовый контроллерклассCCustomMassGateControllerQ-схемакласс (с единственным объектом) CQChartЗаявкаклассCReqСтруктура Q-схемынабор структур-Генератор случайных чиселшаблонОпределяется пользователемДисциплина обслуживанияшаблонОпределяется пользователемФункция управленияcallback-функцияОпределяется пользователемМенеджер статистикикласс (с единственным объектом) CStatManagerМенеджер ошибоккласс (с единственным объектом) CErrorManager

6. Разработка библиотеки классов иммитационного моделирования

6.1 Разработка структуры библиотеки

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

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

Таблица 4

№№Имя модуляНазначение модуля1qchartelements. h qchartelements. cppСодержит определения и реализации классов основных элементов Q-схемы2qchart. h qchart. cppВключает определение и реализацию классов CQChart и CStatManager, а также дополнительных классов для поддержки цикла моделирования3qchartexcept. h qchartexcept. cppСодержит определение и реализацию класса CErrorManager и иерархию классов исключительных ситуаций для представления ошибок4qchartgatectrl. h qchartgatectrl. cppОпределяет ряд стандартных функций для управления клапанами и управляемыми генераторами (например, И, ИЛИ, И-НЕ, ИЛИ-НЕ) 5qchartstdhdr. hСтандартный заголовочный файл, обеспечивающий компоновку проектов и содержащий макросы для упрощения интерфейса библиотеки6qchartcommon. hОписывает общеиспользуемые типы библиотеки7qchartrndgen. hСодержит определения шаблонных классов типовых генераторов случайных чисел (фиксированный, равномерный закон, экспоненциальный) 8qchartqdisc. hОпределяет классы для реализации стандартных дисциплин обслуживания (FIFO, LIFO)

Рисунок 2. Структура библиотеки

Структура библиотеки представлена диаграммой на рис.2

Листинги модулей библиотеки представлены в приложении 2.

Заключение

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

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

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

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

Библиографический список

1.Акоф Р., Сасиени М. Основы исследования операций. Пер. с англ. М.: Мир, 1971.

2.Антони Синтес. Освой самостоятельно объектно-ориентированное программирование за 21 день - М.: "Вильямс", 2002.

.Балашевич В.А., Андронов А.М. Экономико-математическое моделирование производственных систем.: Учеб. Пособие для вузов. Мн.: Унiверсiтэцкае, 1995.

.Гаранин М.В., Журавлев В.И., Кунегин С.В. Системы и сети передачи информации. - М.: Радио и связь, 2001.

.Иан Грэхем Объектно-ориентированные методы. Принципы и практика = Object-Oriented Methods: Principles & Practice. - 3-е изд. - М.: "Вильямс", 2004.

.Павловская Т.А. Программирование на языке высокого уровня. С - Пб.: Питер, 2004.

.Экономико-математические методы и модели. / Уч. пос. для вузов Под ред. Кузнецова. Мн.: БГЭУ, 1999.

.Советов Б.Я. Моделирование систем [Текст]: учебник для студ. вузов. - 3-е изд., переаб. и доп. - М.: Высшая школа, 2001. - 343 с.: ил.

.Шелухин О.И. Моделирвоание информационных систем: учеб. пособие для студ. вузов. - М.: САЙНС - ПРЕСС, 2005. - 367с.

.Молчанов А.А. Моделирование и проектирование сложных систем: учеб. пособие для студ. вузов. - Киев: Вища школа, 1988. - 360 с.

.Бусленко Н.П. Моделирование сложных систем.2-е изд., пераб. - М.: Наука, 1978. - 400 с.

.Лифшиц А.Л. Статистическое моделирование СМО, М., 1978.

.Томашевский В., Жданова E. Имитационное моделирование в среде GPSS. - М.: Бестселлер, 2003. - 416 c.

Приложения

Приложение №1

Q-схема:

Приложение №2

Листинг программы.

class QShema; // предварительное объявление Q-схемы

// глобально уникальный идентификатор заявокunsigned __int64 req_enumerator;structelem

{public:

// конструктор и деструктор

explicit __fastcall structelem(const std::string & name):

_psvyazi(0), __name(name), __id(0)

{

;

}

virtual ~structelem() = 0;

// общая информация об элементе (для класса CQChart::CStatManager)

const std::string & GetName() const { return __name; }

int GetID() const {return __id; }

protected:

SxemaElem_t * _psvyazi;

// указатель на элемент структуры Q-схемы с описанием связей

private:

std::string __name; // символическое имя элемента

int __id; // числовой идентификатор элемента

};obyavZayav: virtual public structelem

{ public: public:

// конструктор и деструктор

explicit __fastcall obyavZayav(const std::string & name):

structelem(name)

virtual ~obyavZayav() { }

// установка признака пометки обработанных заявок

void SetMarksObrZayav() { _marksObrZayav = true; }

// получение состояния

virtual state_t GetState() const = 0;

protected:

class Zayavka { // класс "заявка"

//моделирует ассоциацию элементов с заявками методов вложения

public:

// конструктор

explicit __fastcall Zayavka {

__VremPoyav = __TekVrem = 0;

__obrabot = false;

__psoderg = NULL;

__cntrazmer = 0;

}

Zayavka() {

if ( __psoderg ) free( __psoderg );

}

// информация

size_t TekVrem() const { // время пребывания заявки в системе

return __TekVrem;

}

size_t GetVremPoyav() const { // время появления заявки в системе

return __VremPoyav;

}

bool GetObrabot() const { // признак обработки заявки

return __obrabot;

}

// счет времени пребывания заявки в системе

void __fastcall SetTekVrem(size_t vrem) { __TekVrem = vrem; }

void __fastcall SetVremPoyav(size_t vrem) { __VremPoyav = vrem; }

// пометка обработанной заявки

void SetObrabot() { __Obrabot = true; }

// получение идентификатора текущей заявки

unsigned __int64 GetID() const { return __id; }

// задание идентификатора текущей заявки генератором

void SetID(unsigned __int64 id) { __id = id; }

// получение содержимого заявки

void GetSoderg(void * psoderg, size_t & cntrazmer);

// изменение содержимого заявки

void SetSoderg(const void * psoderg, size_t cntrazmer);

private:

//уникальный идентификатор данной заявки

unsigned __int64 __id;

size_t __VremPoyav; // время появления заявки в системе

size_t __TekVrem; // текущая временная метка

// используется для подсчета времени пребывания заявки в системе

void * __psoderg; // указатель на определенное пользователем

//содержимое заявки

size_t __cntrazmer; // размер содержимого в байтах

};

bool _marksObrZayav; // признак пометки обработанных заявок

private:

// избыточные функции

obyavZayav(const obyavZayav &);

obyavZayav & operator = (const obyavZayav &);

<class uprfunction> class objectupr: virtual public structelem

{ public:

// конструктор и деструктор

explicit __fastcall objectupr

(const std::string & name, ctrlfunc_t pctrlfunc): structelem(name)

{

try {

_UprElemmap = new IDUprElemmap_t();

}

_pfuncupr = pfuncupr;

_ctrlcount = 0;

}

~objectupr() { delete _uprelemmap; }

protected:

// разрешающие управляющие сигналы

IDUprElemmap_t * _UprElemmap;

// первая компонента map - идентификатор управляющего элемента

// вторая - указатель на управляющий элемент + разрешающее состояние этого элемента

// функция формирования общего сигнала управления

funcupr_t * _pfuncupr;

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

size_t _KolichUprElem;

// индикация состояния объекта управления (разрешенное или запрещенное)

bool _Razresh() const;

private:

// добавление разрешающего сигнала

void __DobavRazreshSignal(structelem *, state_t, float,

structelem *, state_t);

// удаление разрешающего сигнала

void __fastcall __UdalitRazreshSignal(structelem * pcontroller);}

priemnik: virtual public obrabotzayavok

{ public:

// конструктор и деструктор

explicit __fastcall priemnik(const std::string & name):

structelem(name), obyavZayav(name)

{

;

}

~priemnik() { }

protected:

virtual void __fastcall _Priem(Zayavka *) = 0; // прием заявки

virtual bool _GotovKPriem() const = 0; // готовность к приему заявки

private:

};

peredatchik: virtual public obrabotzayavok

{ public:

// конструктор и деструктор

explicit __fastcall peredatchik(const std::string & name):

structelem(name), obyavZayav(name)

{

;

}

~ peredatchik() { }

protected:

virtual Zayavka * __fastcall _Peredacha(Zayavka * req = 0) = 0; // выдача заявки

// информация

virtual bool _GotovKPeredache() const = 0; // готовность к выдаче заявки

private:

};

<class randomgenerator> class peredatchikszader: public peredatchik

{ public:

// конструктор и деструктор

explicit __fastcall peredatchikszader(const std::string & name):

structelem(name), obyavZayav(name), peredatchik(name),

_ObrZayav(0), _VremyaVidachi(0), _OprVremyaVidachi(false)

{

;

}

~peredatchikszader()

// информация

virtual state_t GetState() const { // проверка состояния

return _ObrZayav == 0 ? pusto : zanyat;

}

protected:

// поведение

virtual void _VremyaSozdZayav() = 0; // время выхода заявки

Zayavka * _ObrZayav; // заявка, находящаяся на обработке

size_t _VremyaVidachi; // время выдачи заявки

bool _OprVremyaVidachi; // признак определенности времени выдачи

private:

};<class randomgenerator>

class GeneratorZayavok: public peredatchikszader {

// генератор заявок (элемент, который выдает заявки через случайное время)

// конструктор и деструктор

explicit __fastcall GeneratorZayavok(const std::string & name):

structelem(name), obyavZayav(name), peredatchikszader(name)

{

;

}

~GeneratorZayavok() { }

protected:

// поведение

virtual Zayavka * __fastcall _Peredacha(Zayavka *) { // выдача (генерация) заявки

_OprVremyaVidachi = false;

Zayavka * tmObrZayav = _ObrZayav; _ObrZayav = 0;

// задание момента появления заявки

tmObrZayav->SetVremPoyav;

tmObrZayav->SetTekVrem;

}

return tmObrZayav;

}

virtual void _GenerateVremyaVidachi() { // время выхода заявки

try {

_VremyaVidachi = randomgenerator::GetValue();

}

if (_VremyaVidachi < 1) _VremyaVidachi = 1;

_OprVremyaVidachi = true;

try {

__VidachaZayavki();

}

// информация

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return _OprVremyaVidachi && _VremyaVidachi == 0;

}

private:

void __VidachaZayavki() throw(std::bad_alloc);

// избыточные функции

virtual state_t GetState() const { // получение состояния

return zanyat;

}

};<class randomgenerator>

class kanal: public obrabotzayavok

// "канал (устройство)" (принимает, обрабатывает и выдает заявки

// через время, определяемое заданным законом распределения)

public:

// конструктор и деструктор

explicit __fastcall kanal(const std::string & name):

structelem(name), obyavZayav(name), obrabotzayavok(name)

{

__DlinObslujZayav= 0;

}

~kanal() { }

protected:

// поведение

virtual void _GenerateVremyaVidachi() { // время выхода заявки

if(_ObrZayavka != 0) {

try { // контроль средств пользователя

__DlinObslujZayav= _VremyaVidachi = randomgenerator::Poluchznach();

}

}

virtual Zayavka * __fastcall _Peredacha(Zayavka *) { // выдача обслуженной заявки

Zayavka* tmpObrZayavka = _ObrZayavka;

_ObrZayavka = 0;

if (tmpObrZayavka != NULL && this->_marksObrZayav)

tmpObrZayavka->SetObrabot(); // заявка обработана

return tmpObrZayavka;

}

virtual void __fastcall _Priemnik(Zayavka * req) { // прием заявки

_OprVremyaVidachi = false;

if (_ObrZayavka != 0)

_ObrZayavka = req;

}

private:

size_t __DlinObslujZayav; // хранит длительность обслуживания заявки

// для расчета загрузки канала

};<class uprfunction> class klapan: public peredatchik, public priemnik, public objectupr <uprfunction>

{ public:

// конструктор и деструктор

explicit __fastcall klapan(const std::string & name, funcupr_t pfuncupr NachFuncUpr):

structelem(name), objectupr(name, pfuncupr), obyavZayav(name),

priemnik(name), peredatchik(name)

{

__tmpObrZayav = 0;

}

~klapan() { }

protected:

// поведение

virtual void __fastcall _Priem(Zayavka * ObrZayavka) //принять заявку

{__tmpObrZayav = ObrZayav;

}

virtual Zayavka * __fastcall _Peredacha(Zayavka *)//передать заявку

{Zayavka * tmObrZayav = __tmObrZayav; __tmpObrZayav = 0;

if (this->_marksObrZayav) tmObrZayav->SetObrabot();

// клапаны тоже могут помечать заявки как обработанные

return tmObrZayav;

}

// информация

virtual bool _GotovKPriem() const { // готовность к приему заявки

return _Razresh();

}

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return __tmObrZayav != 0;

}

Zayavka * __tmObrZayav; // заявка хранится один такт, пока клапан не выдаст её дальше

private:

virtual state_t GetState() const { // получение состояния

return pusto; // клапан никогда не содержит заявок

};

typedef struct ListZayav_t {

obrabotzayavok::Zayav * ObrZayav; // указатель на заявку

ListZayav_t * SledZayav; // указатель на следующую заявку

ListZayav_t * PredZayav; // указатель на предыдущую заявку

} ListZayav_tag;ochered: public peredatchik, public priemnik

{ public:

// конструктор

explicit __fastcall ochered(const std::string & name):

structelem(name), obyavZayav(name), priemnik(name), peredatchik(name)

{

_dlina = 0; _NachaloListZayav = 0; _KonetsListZayav = 0;

}

// деструктор

~ochered() { ; }

// получение состояния

virtual state_t GetState() const {

return _length != 0 ? zanyat : pusto;

}

// получение текущей длины

size_t GetDlina() const { return _dlina; }

// выдача времени генерации наиболее старой хранимой заявки

bool __fastcall GetMinTekVrem(size_t & TekVrem) const;

protected:

// информация

virtual bool _GotovKPeredache() const { // готовность к выдаче заявки

return _dlina > 0;

}

// готовность к приему зависит от наличия ограничения для длину очереди

size_t _dlina; // текущая длина очереди заявок

ListZayav_t * _NachaloListZayav; // указатель на голову списка заявок

ListZayav_t * _KonetsListZayav; // указатель на хвост списка заявок

private:

};<class obsdiscipl>

class discochered: public ochered {

// абстрактный накопитель заявок с дисциплиной обслуживания

public:

// конструктор

explicit __fastcall discochered(const std::string & name):

structelem(name), obyavZayav(name), ochered(name)

{

;

}

// деструктор

~discochered() { }

protected:

// поведение

// ------------------------------------------------ прием заявки

virtual void __fastcall _Priem(Zayavka * req) {

ListZayav_t * SohrListZayav = _KonetsListZayav;

// создание элемента списка под заявку

try {

_KonetsListZayav = new ListZayav_t;

}

catch (std::bad_alloc &)

THROW_ERROR(ERegisterError, REG_ERROR_ID,

"Description: queue cell object creation failed",

std::string("Details: out of memory while adding a cell to queue ") +

this->GetName())

_KonetsListZayav -> ObrZayav = req;

_KonetsListZayav -> SledZayav = 0;

_dlina++;

if(SohrListZayav == 0) {

// очередь пуста

_KonetsListZayav -> PredZayav = 0;

__NachaloListZayav = _KonetsListZayav;

return;

}

// очередь не пуста

_KonetsListZayav -> PredZayav = SohrListZayav;

ohrListZayav -> SledZayav = _KonetsListZayav;

}

// ------------------------- выдача заявки согласно заданной дисциплине

virtual Zayavka * __fastcall _Peredacha(Zayavka *) {

const ListZayav_t * preqentry;

try { // контроль средств пользователя

preqentry =

obsdiscipl::GetSledZayav(__NachaloListZayav, _KonetsListZayav);

}

Zayavka * preadreq = preqentry -> ObrZayav;

__UdalitElement ( &___NachaloListZayav, &_KonetsListZayav,

const_cast<ListZayav_t*>(preqentry) );

--_dlina;

if (this->_marksObrZayav)

preadreq->SetObrabot(); // заявка считается обработанной

return preadreq;

}

private:

// --------------------------------- удаление элемента очереди

void __fastcall __UdalitElem(ListZayav_t ** NachaloListZayav,

ListZayav_t ** KonetsListZayav, ListZayav_t * udalitzayav)

{

ListZayav_t * tmpliszayav;

if (udalitzayav == *NachaloListZayav) // удаление головы

{

tmpliszayav = *NachaloListZayav;

(*NachaloListZayav) = (*pNachaloListZayav) -> SledZayav;

(*KonetsListZayav) = (*NachaloListZayav) == 0 ? 0 : (*KonetsListZayav);

if (*NachaloListZayav != 0) (*NachaloListZayav) -> PredZayav = 0;

}

else

if (udalitzayav == *KonetsListZayav) // удаление хвоста

{

tmpliszayav = *KonetsListZayav;

(*KonetsListZayav) = (*KonetsListZayav) -> PredZayav;

(*NachaloListZayav) = (*KonetsListZayav) == 0 ? 0 : (*NachaloListZayav);

if (*KonetsListZayav != 0) (*preqKonetsListZayav) -> SledZayav = 0;

}

else

{ // удаление из "середины" очереди

tmpliszayav = udalitzayav;

udalitzayav -> SledZayav -> PredZayav = udalitzayav -> PredZayav;

udalitzayav -> PredZayav -> SledZayav = udalitzayav -> SledZayav;

}

delete tmpliszayav;

}

};<class obsdiscipl> class bezkonochered: public ochered <obsdiscipl>

{ public:

// бесконечный накопитель заявок

explicit __fastcall bezkonochered(const std::string & name):

structelem(name), obyavZayav(name), ochered(name),

peredatchik (name), priemnik(name)

;

}

~bezkonochered() { }

virtual bool _GotovKPriem() const { // готовность к приему заявки

return true;

}

private:

};<class obsdiscipl> class konochered: public ochered <obsdiscipl>

{ public:

// ограниченный накопитель заявок

explicit __fastcall konochered(const std::string & name, size_t maxDlina):

structelem(name), obyavZayav(name), ochered(name),

peredatchik (name), priemnik(name)

_maxDlina(maxDlina > 0 ? maxDlina : 1)

{

;

}

~konochered() { }

// получение состояния

virtual state_t GetState() const {

return _Dlina != 0 ? (_maxDlina > _Dlina ? busy : full) : empty;

}

// максимальная длина

size_t GetMaxDlina() const { return _maxDlina; }

virtual bool _GotovKPriem() const { // aioiaiinou e i?eaio cayaee

return _maxDlina > _Dlina;

}

const size_t _maxDlina; // максимальная длина очереди

private:

};masskontrol: virtual public structelem {:

// карта дескрипторов управляемых клапанов

typedef

map <int, pair< pair<float,int>, pair<structelem *, state_t> > >

klapandescriptormap_t;

{ public:

// конструктор

explicit __fastcall masskontrol(const std::string & name):

structelem(name)

{

__KolichKlapan = 0;

try {

__pklapandescriptormap = new klapandescriptormap_t();

}

// деструктор

~masskontrol() { delete __pklapandescriptormap; }

protected:

size_t __KolichKlapan; // число управляемых клапанов в группе

klapandescriptormap_t * __pklapandescriptormap;

// добавление клапана для случайного управления

virtual void _DobavKlapan(int klapanid, float reserved) { ++__KolichKlapan; }

// удаление управляемого клапана

// (вызывается только из qchart::UnregisterElement/Link)

void __fastcall _UdalitKlapan(const structelem * pklapan);

// определение состояния заданного управляемого клапана

int __fastcall _GetSostUpr(int klapanid) const {

return (__pklapandescriptormap -> operator [] (klapanid)).first.second;

}

// вычисление состояний клапанов в текущем такте

virtual void _VichislSostUprKlapana() = 0;

private:

};prostrandomcontrol: public masskontrol {

// элемент случайного управления клапанами

public:

// конструктор

explicit __fastcall prostrandomcontrol(const std::string & name):

masskontrol(name)

{

;

}

// деструктор

~prostrandomcontrol() { }

protected:

// карта текущего состояния управляемых клапанов наследуется

// добавление клапана для случайного управления (переопределение)

virtual void _DobavKlapan(int klapanid, float veroyatnost);

// вычисление состояний клапанов в текущем такте (реализация)

virtual void _VichislSostUprKlapana();

private:

static const float __proberror; // погрешность расчета вероятностей

// суммирование вероятностей и контроль равенства суммы единице

bool __SummirVeroyat() const;

};adaptcontrol: public prostrandomcontrol {

// элемент случайного управления клапанами, позволяющий динамически

// исключать заблокированные клапаны с соответствующим пересчетом

// вероятностей открытия клапанов

public:

// конструктор

explicit __fastcall adaptcontrol (const std::string & name):

prostrandomcontrol (name)

{

try {

__pustanklapandescriptormap = new klapandescriptormap_t();

}

__srcprobmapsaved = false;

}

// деструктор

~adaptcontrol () { delete __pustanklapandescriptormap; }

protected:

// карта текущего состояния управляемых клапанов наследуется

// добавление ассоциированного элемента для управляемого клапана

void __fastcall

_DobavKlapanAssocCtrl(int klapanid, structelem * passocelem, state_t assocelemstate);

// пересчет вероятностей открытия клапанов

virtual void _PereschetVeroyat();

private:

// исходная карта дескрипторов управляемых клапанов

Klapandescriptormap_t * __pustanklapandescriptormap;

// карта из prostrandomcontrol динамически изменяется и используется для

// расчета состояний клапанов, а эта карта хранит исходные вероятности и

// не пересчитывается

// признак сохранения исходной карты вероятностей

bool __srcprobmapsaved;

// фиксация исходной карты дескрипторов

// вызывается после регистрации всех управляемых клапанов

void __SaveSrcProbMap() {

*__pustanklapandescriptormap = *__pklapandescriptormap;

__srcprobmapsaved = true;

}

// восстановление исходной карты дескрипторов клапанов

void __VosstVeroyatKlapanov() {

*__pklapandescriptormap = *__pustanklapandescriptormap;

}

Polzovatcontrol: public masskontrol{

public:

// вектор ассоциированных контроллеров

typedef vector < const structelem * > assoccontr_t;

// карта состояний управляемых клапанов

typedef map < int, int > klapanstatemap_t;

// компонента 1 - уникальный идентификатор клапана;

// компонента 2 - вычисленное состояние клапана

protected:

// ZakonUpr-функция для реализации пользовательского закона управления

typedef

void (* pcustomfuncupr_t)

(const assoccontr_t & assoccontr, klapanstatemap_t & klapanstatemap);

/*

assoccontr - вектор указателей на ассоциированные контроллеры,

состояние которых можно учитывать при формировании сигналов управления

клапанами;

klapanstatemap - карта состояний (0 или 1) управляемых клапанов,

вычисляемая callback-функцией (ее размер определяется размером вектора)

*/

public:

// конструктор

__fastcall obobmasscontrol(

const std::string & name,

const assoccontr_t & assoccontr,

pcustomfuncupr_t pcustomfuncupr

);

// деструктор

~Polzovatcontrol() { }

protected:

// добавление клапана для случайного управления (реализация)

virtual void _DobavKlapan(int klapanid, float reserved);

// вычисление состояний клапанов в текущем такте

virtual void _VichislSostUprKlapana();

private:

// связь с ассоциированными контроллерами

assoccontr_t __assoccontr;

// указатель на функцию управления пользователя

pcustomfuncupr_t __pcustomfuncupr;};

template<class randomgenerator>class uprgeneratorzayavok: public generatorzayavok<randomgenerator>, public objectupr

{

public:

// конструктор и деструктор

explicit __fastcall uprgeneratorzayavok

(const std::string & name, funcupr_t pfuncupr = NachFuncUpr):

structelem(name), obyavZayav(name),

generatorzayavok<randomgenerator>(name), objectupr(name, pfuncupr)

{

;

}

~uprgeneratorzayavok() { }

protected:

// поведение

// готовность к выдаче заявки

virtual bool _GotovKPeredache() const {

if (!_Razresh())

const_cast< generatorzayavok<randomgenerator> * >(this)->__OprVremyaVidachi = false;

return

__OprVremyaVidachi && this->generatorzayavok<randomgenerator>::_GotovKPeredache();

}

private:

};<class RandomGenerator>

class KanalSPrerObslug: public kanal<RandomGenerator>, public ObjectOfControl

{

// управляемый канал (элемент, который обслуживает заявки случайное время

public:

// конструктор и деструктор

explicit __fastcall KanalSPrerObslug

(const std::string & name, funcupr_t pfuncupr = NachFunсUpr):

structelem(name), ObyavZayav(name),

kanal<RandomGenerator>(name), ObjectOfControl(name, pfuncupr)

~KanalSPrerObslug() { }

protected:

// готовность к выдаче заявки

virtual bool _GotovKPeredache() const {

// при запрещающем управляющем сигнале заявка выдается сразу

if (!_Razresh()) return _ObrZayavka != NULL;

return this-> kanal<RandomGenerator>::_GotovKPeredache();

}

private:

};

razvetvitel: public peredatchik, public priemnik, public objectupr <uprfunction>

public: explicit __fastcall razvetvitel(const std::string & name):

structelem(name), objectupr(name, pfuncupr), obyavZayav(name),

priemnik(name), peredatchik(name) {}

~razvetvitel() {}

private:

};

};

Содержание Введение 1. Техническое задание 2. Вариант задания 3. Теоретические сведения 3.1 Понятие СМО 3.1.1 Основные определения СМО

Больше работ по теме: