Лабораторная работа №3. Имитационное моделирование информационных процессов на языке высокого уровня. Модель через список будущих событий.

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

Методические указания

Рассмотрим процесс моделирования системы на языке С++. Пусть генерируются заявки каждые 5+-2 секунды, которые попадают в очередь. После этого транзакты поступают в ЭВМ и обрабатываются там втечении 8+-3 сек. Далее после обработки они удаляются из системы. Данный процесс показан на рисунке 18.3.

 

 

Рис. 18.3. Q-схема прохождения заявки

В этой задаче необходимо найти:

1. Количество поступивших заявок.

2. Обработанное количество заявок.

3. Текущее количество заявок в очереди.

4. Текущее количество заявок на обработке.

Форма приложения представлена на рисунке 18.4.

Рис. 18.4. Форма приложения

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

Заголовочный файл программы имеет вид:

Model2.h

//-----------------------------------------------

#ifndef model2H

#define model2H

//-----------------------------------------------

#include <Classes.hpp>

#include <Controls.hpp>

#include <StdCtrls.hpp>

#include <Forms.hpp>

 

//-----------------------------------------------

class TForm1: public TForm

{

__published: // IDE-managed Components

TGroupBox *GroupBox1;

TLabel *Label1;

TEdit *Edit1;

TEdit *Edit2;

TLabel *Label2;

TLabel *Label3;

TEdit *Edit3;

TLabel *Label4;

TEdit *Edit4;

TLabel *Label5;

TEdit *Edit5;

TButton *Button1;

TGroupBox *GroupBox2;

TLabel *Label6;

TEdit *Edit6;

TLabel *Label7;

TEdit *Edit7;

TButton *Button2;

TLabel *Label8;

TEdit *Edit8;

TLabel *Label9;

TEdit *Edit9;

void __fastcall Button1Click(TObject *Sender);

void __fastcall Button2Click(TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TForm1(TComponent* Owner);

};

 

//определяем класс Очередь

class IM_Queue{

public:

String Name;//название

int Number;//номер

int Disciplina;//дисциплина обслуживания

int QueueSize;//длина очереди

void __fastcall Queue();//занесение транзакта в очередь

void __fastcall Depart();//удаление транзакта из очереди

};

//определяем класс Устройство

class IM_Device{

public:

String Name;//название

int Number;//номер

boolean Free;//true-свободно, false-занято

void __fastcall Seize();//занятие устройства

void __fastcall Release();//удаление транзакта из устройства

};

//определяем класс Событие

class IM_Event{

public:

String Name;//название события

int Type;//тип события

float Time;//время наступления события

};

//определяем класс Система

class IM_System{

public:

float Sim_Time;//модельное время

int Tranzakt_Value;//количество транзактов, попавших в систему

int Tranzakt_Process;//количество обработанных транзактов

IM_Event Events[2];//список будущих событий

IM_Queue q1;

IM_Device d1;

float tgen1,tgen2;//время генерация заявок

float tend;//время окончания моделирования

float t1evm1,t2evm1;//время обработки на ЭВМ1;

int num_events;//число событий в системе

int next_event_type;//следующий тип события

void __fastcall Init();//инициализация системы

void __fastcall Synhronize();//синхронизация событий

int __fastcall Generate_Interval(int time1,int time2);//планирование интервала time1+-time2

void __fastcall GoIn();//событие поступления заявки

void __fastcall GoOut();//событие ухода заявки

void __fastcall Report();//получение статистических данных

};

//-----------------------------------------------

extern PACKAGE TForm1 *Form1;

//-----------------------------------------------

#endif

 

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

Model2.cpp

//-----------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "model2.h"

//-----------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//-----------------------------------------------

void __fastcall IM_System::Init(){

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

Sim_Time=0.0;

Tranzakt_Value=0;

Tranzakt_Process=0;

q1.Name="Очередь 1";

q1.Number=1;

q1.QueueSize=0;//очередь пуста

d1.Name="Устройство 1";

d1.Number=1;

d1.Free=True;//устройство свободно

//считывание данных с формы

tgen1=StrToInt(Form1->Edit1->Text);

tgen2=StrToInt(Form1->Edit2->Text);

tend=StrToInt(Form1->Edit3->Text);

t1evm1=StrToInt(Form1->Edit4->Text);

t2evm1=StrToInt(Form1->Edit5->Text);

num_events=2;//определяем число событий

//планирование первого события

Events[0].Name="Генерация заявки";

Events[0].Type=0;

Events[0].Time=Sim_Time+Generate_Interval(tgen1,tgen2);

Events[1].Name="Окончание обслуживания заявки";

Events[1].Type=1;

Events[1].Time=1.0e+30;//событие произойдет во времени 10 в 30

}

void __fastcall IM_System::Synhronize(){

float min_time_next_event=1.0e+29;//берем для сравнения большое число

next_event_type=-1;//предполагаем, что событий нет

//открываем цикл, в котором определяем событие с наименьшим временем

for (int i=0;i<num_events;i++){

if (Events[i].Time<min_time_next_event){

min_time_next_event=Events[i].Time;

next_event_type=i;//отыскиваем тип события

}

}

//если событий нет, то завершаем моделирование

if (next_event_type==-1){

ShowMessage("Список событий пуст");

exit(1);

}

//переводим модельные часы на ближайшее событие

Sim_Time=min_time_next_event;

}

int __fastcall IM_System::Generate_Interval(int time1,int time2){

Randomize();

return (time1-time2)+random(2*time2+1);

}

void __fastcall IM_System::GoIn(){

Tranzakt_Value++;//увеличиваем число поступивших транзактов

//планируем время поступления следующей заявки Events[0].Time=Sim_Time+Generate_Interval(tgen1,tgen2);

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

if (d1.Free){

d1.Seize();

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

Events[1].Time=Sim_Time+Generate_Interval(t1evm1,t2evm1);

}

//иначе заносим транзакт в очередь

else{

q1.Queue();

}

}

void __fastcall IM_System::GoOut(){

Tranzakt_Process++;//увеличиваем число обработанных транзактов

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

if (q1.QueueSize==0){

d1.Release();

//исключаем следующее событие обработки заявки

Events[1].Time=1.0e+30;

}

//иначе выбираем из очереди следующий элемент

else{

q1.Depart();

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

Events[1].Time=Sim_Time+Generate_Interval(t1evm1,t2evm1);

}

}

 

void __fastcall IM_System::Report(){

Form1->Edit6->Text=IntToStr(Tranzakt_Value);

Form1->Edit7->Text=IntToStr(Tranzakt_Process);

Form1->Edit8->Text=IntToStr(q1.QueueSize);

if (d1.Free)//если устройство свободно

Form1->Edit9->Text="0";

else

Form1->Edit9->Text="1";

 

}

//-----------------------------------------------

void __fastcall IM_Queue::Queue(){

QueueSize++;//увеличиваем длину очереди

}

void __fastcall IM_Queue::Depart(){

QueueSize--;//уменьшаем длину очереди

}

//-----------------------------------------------

void __fastcall IM_Device::Seize(){

Free=False;//устройство занято

}

void __fastcall IM_Device::Release(){

Free=True;//устройство свободно

}

//-----------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

IM_System System1;//объявление новой системы моделирования

System1.Init();

System1.Synhronize();//синхронизируем события

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

while (System1.Sim_Time<=System1.tend)

{

//выбираем тип события

switch (System1.next_event_type){

case 0:

System1.GoIn();//поступление заявки

break;

case 1:

System1.GoOut();//удаление заявки

break;

}

System1.Synhronize();//синхронизируем события

}

System1.Report();

}

//-----------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

exit(1);

}

//-----------------------------------------------

 

В заголовочном файле model2.h описываются классы: IM_Queue – Очередь, IM_Device – Устройство, IM_Event – Событие, IM_System - Система. Префикс IM образован от словосочетания “Имитационное Моделирование”. Программа сначала считывает исходные данные для моделирования и инициализирует состояние системы. Затем в цикле происходит выборка событий из списка будущих событий. Цикл продолжается до тех пор, пока не истечен заданный период имитации.

Задание на лабораторную работу

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

Варианты:

1. По каналу связи каждые 10+-7 сек. передаются сообщения длиной от 1 до 7 Мбайт. Экспериментально определить требуемую минимальную пропускную способность канала. Рассмотреть возможность и экспериментально определить размер и принцип работы буфера, позволяющего уменьшить пропускную способность на 20%, 30%, 50%.

2. Вычислительная система состоит из двух ЭВМ и общего буфера. Каждые 10+-5 с на обработку приходит задача. Для решения каждой задачи требуется 20+-8 с. Каждая ЭВМ в один момент может решать только одну задачу. Оставшиеся задачи хранятся в буфере. Если какая – либо ЭВМ освобождается, а буфер пуст – она берет на себя половину нагрузки другой ЭВМ. Определить среднюю загруженность буфера при обработке 1000 заданий, время работы каждой ЭВМ и число выполненных заданий.

3. В вычислительную систему каждые 20+-5 с приходят два пакета данных, каждый из которых обрабатывается на отдельной ЭВМ в течение 20+-8 с (для каждого пакета – время свое). После того как пакеты обработаны, происходит их совместный анализ на третьей ЭВМ в течение 25 с. Перед третьей ЭВМ имеется буфер на 10 пакетов. Если пакет приходит в систему, а вторая первая или вторая ЭВМ заняты – пакет теряется. Обработать 1000 пакетов. Оценить количество потерянных пакетов, загрузку буфера, время простоя и работы каждой ЭВМ и всей системы.

4. По цифровому каналу передаются пакеты данных, каждый из которых содержит N = 10…100 блоков. Время передачи Т=5*N. Вероятность того, что при передаче очередного блока произойдет сбой, равна 0,05. Если во время передачи сообщения на каком-либо блоке происходит сбой, то последующие блоки сообщения не передаются. Смоделировать процесс передачи 10000 пакетов. Определить число сбоев. Подсчитать количество потерянных блоков. Исследовать зависимости этих величин от длины пакета и вероятности ошибки.

5. Система передачи данных обеспечивает передачу пакетов данных из пункта А в пункт С через транзитный пункт В. В пункт А пакеты поступают через 10+-5 мс. Здесь они буферизуются в накопителе емкостью 20 пакетов и передаются по любой из двух линий АВ1 за время 18+-3 мс или АВ2 – за время 20мс. В пункте В они снова буферизируются в накопителе емкостью 25 пакетов и далее передаются по линиям ВС1 (за 25+-3мс) и ВС2 (за 25 мс). Причем пакеты из АВ1 поступают в ВС1, а из АВ2 в ВС2.

6. Система обработки информации содержит мультиплексный канал и три миниЭВМ. Сигналы от датчиков поступают на вход канала через интервалы времени 10+-5 мкс. В канале они буферизируются и предварительно обрабатываются в течение 10+-3 мкс. Затем они поступают на обработку в ту миниЭВМ, где имеется наименьшая по длине входная очередь. Емкости входных накопителей всех миниЭВМ рассчитаны на хранение величин 10 сигналов. Время обработки сигнала в любой миниЭВМ равно 33 мкс.

7. Магистраль передачи данных состоит из двух каналов (основного и резервного) и общего накопителя. При нормальной работе сообщения передаются по основному каналу за 7+-3 с. В основном канале происходят сбои через интервалы времени 200+-35 с. Если сбой происходит во время передачи, то за 2 секунды запускается запасной канал, который передает прерванное сообщение с самого начала. Восстановление основного канала занимает 23+-7 с. После восстановления резервный канал выключается и основной канал продолжает работу с очередного сообщения. Сообщения поступают через 9+-4 с и остаются в накопителе до окончания передачи. В случае сбоя передаваемое сообщение передается повторно по запасному каналу.

8. На устройство предварительной обработки информации каждые 5+-1 мин. Поступают пять сообщений с датчиков типа А и каждые 20+-7 мин 20сообщений с датчиков типа В. Устройство имеет два буфера, на 10 сообщений типа А и 10 сообщений типа В. Обработка начинается только при полном заполнении обоих буферов и длится 10 мин.

9. В системе передачи данных осуществляется обмен пакетами данных между пунктами А и В по дуплексному каналу связи. Пакеты поступают в пункты системы от абонентов с интервалами времени между ними 10+-3 мс. Передача пакета занимает 10 мс. В пунктах имеются буферные регистры, которые могут хранить два пакета. В случае прихода пакета в момент занятости регистров пунктам системы предоставляется выход на спутниковую полудуплексную линию связи, которая осуществляет передачу пакетов данных за 10+-5 мс. При занятости спутниковой линии пакет получает отказ.

10. Специализированная вычислительная система состоит из трех процессоров и общей оперативной памяти. Задания, поступающие на обработку через интервалы времени 5+-2 мин, занимают объем оперативной памяти размером в страницу. После трансляции первым процессором в течение 5+-1 мин. их объем увеличивается до двух страниц, и они поступают в оперативную память. Затем, после редактирования во втором процессоре, которое занимает 2,5+-,5 мин. На страницу, объем возрастает до трех страниц. Отредактированные задания через оперативную память поступают в третий процессор на решение, требующее 1,5+-,5 мин на страницу, и покидают систему, минуя оперативную память.

Содержание отчета по лабораторной работе

1. Титульный лист.

2. Тема лабораторной работы.

3. Цель лабораторной работы.

4. Отражение хода лабораторной работы.

5. Вывод.