Заключение
Анализ работы системы обработки данных позволяет сделать вывод об неэффективности работы её работы. В буферном устройстве накапливается длинная очередь незаконченных задач. Это связано с тем, что у ЭВМ практичестки нет свободных циклов, чтобы приступить к решению незаконченных задач. Частота поступления заявок в несколько раз превышает вычислительные возможности ЭВМ. Поэтому вероятность отказа в обслуживании очень высока и составляет 65%.
Уменьшение количества незаконченных задач и частоты использования специальной очереди достигается путем увелечения времени, которое предоставляется терминалам. Для ликвидации специальной очереди необходимо увеличить процессорное время до 35 секунд на терминал. Одновременно с этим вероятность отказа в обслуживании увеличится на 2% и составит 67%. Также для ликвидации специальной очереди достаточно увеличить скорость обработки ЭВМ на 20%. При этом вероятность отказа составит 59%.
Единственным способом уменьшения вероятности отказа в обслуживании является увеличения быстродействия ЭВМ. Так для сведения вероятности отказа до 1% необходимо поднять скорость ЭВМ на 200%, т.е. до 30 знаков/с.
Список литературы
Советов Б. Я., Яковлев С. А. Моделирование систем: Учеб. Для вузов 3-е издание, перераб. И доп. – М: Высш. Школа, 2001 г. – 343 с.
Советов Б. Я., Яковлев С. А. Моделирование систем: Курсовое проектирование: Учеб. Пособие по специальности АСУ. – М: Высш. Школа, 1988г. – 135 с.
Приложение А (обязательное) Псевдокод моделирующего алгоритма
структура src
начало
скаляр ntime - целый
скаляр task - целый
конец
структура str
начало
скаляр task - целый
конец
struct proc
начало
скаляр end_proc - целый
скаляр terminal - целый
конец
скаляр gen_time - целый
скаляр lng_time - целый
скаляр gen_task - целый
скаляр lng_task - целый
скаляр proc_speed - целый
скаляр proc_time - целый
скаляр End_time - целый
скаляр count_err - целый
скаляр count_task - целый
скаляр count_task_first - целый
скаляр cycle - целый
Алгоритм GenTask (a,b)
возврат(a + 10*random((b+10)/10))
конец
Алгоритм GenTime (a, b, tsk)
начало
возврат(tsk + a + random(b+1))
конец
Алгоритм IncTerminal ( a)
начало
если(a<2) a=a+1
иначе
начало
a = 0
cycle= cycle+1
конец
возврат a
конец
Алгоритм GetTask (src *s, i)
начало
если(s[i].ntime = t)
начало
s[i].task = GenTask(gen_task,lng_task)
s[i].ntime = GenTime(gen_time,lng_time,t)
возврат 1
конец
иначе возврат 0
конец
Алгоритм BeginParam(src *source,str *store, proc *CPU)
начало
для( i=0 i<3 i++)
начало
source[i].ntime = 0
source[i].task = 0
store[i].task = 0
конец
store[3].task = 0
CPU->terminal = 0
CPU->end_proc = 0
gen_time = StrTo (edGen_time->Text)
lng_time = StrTo (edLng_time->Text)
gen_task = StrTo (edGen_task->Text)
lng_task = StrTo (edLng_task->Text)
proc_speed = StrTo (edProc_speed->Text)
proc_time = StrTo (edProc_time->Text)
End_time = StrTo (edTime->Text)
count_task_first = 0
cycle = 0
count_err = 0
count_task = 0
t = 0
Series1->Clear()
Series2->Clear()
конец
Алгоритм OutParam(str *st)
начало
скаляр temp - вещественное
temp = count_err
Edit3->Text = count_task
Edit4->Text = count_task_first
Edit5->Text = count_task - count_task_first
Edit6->Text = count_err
Edit8->Text = st[3].task
Edit9->Text = cycle
Edit1->Text = temp/(count_err+count_task)
конец
Алгоритм Processing(str *st, proc *CPU)
начало
скаляр i = CPU->terminal - целое
если(st[i].task>0)
начало
если((st[i].task/proc_speed) <= proc_time)
начало
CPU->end_proc = t + st[i].task/proc_speed
count_task_first = count_task_first + 1
st[i].task = 0
count_task= count_task + 1
конец
иначе
начало
st[3].task += st[i].task - proc_speed * proc_time
CPU->end_proc = t + proc_time
st[i].task = 0
count_task = count_task + 1
конец
конец
иначе
начало
если(st[3].task>0)
начало
если((st[3].task/proc_speed) <= proc_time)
начало
CPU->end_proc = t + st[3].task/proc_speed
st[3].task = 0
конец
иначе
начало
st[3].task = st[3].task - proc_speed * proc_time
CPU->end_proc = t + proc_time
конец
конец
конец
CPU->terminal = IncTerminal(CPU->terminal)
Series1->AddXY(t,st[3].task)
Series2->AddXY(t,st[0].task)
конец
//---------------------------------------------------------------------------
Алгоритм ButtonClick
начало
src *source = new src [3]
str *store = new str [4]
proc *CPU = new proc
BeginParam(source,store,CPU)
для(t=0 t<End_time t++)
начало
CGauge1->Progress = t
для( i=0 i<3 i++)
если(GetTask(source,i))
начало
если(store[i].task==0)
начало
store[i].task = source[i].task
source[i].task = 0
конец
иначе count_err++
конец
если(CPU->end_proc<=t) Processing(store,CPU)
конец
OutParam(store)
конец
Приложение Б (обязательное) Листинг программы
Unit1.h
//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>
#include "CGAUGES.h"
#include <Chart.hpp>
#include <ExtCtrls.hpp>
#include <Series.hpp>
#include <TeEngine.hpp>
#include <TeeProcs.hpp>
#include <Menus.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TButton *Button1;
TCGauge *CGauge1;
TGroupBox *GroupBox1;
TLabel *Label1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label4;
TEdit *edGen_time;
TEdit *edLng_time;
TEdit *edGen_task;
TEdit *edLng_task;
TEdit *edProc_speed;
TEdit *edProc_time;
TGroupBox *GroupBox2;
TLabel *Label5;
TLabel *Label6;
TLabel *Label7;
TLabel *Label8;
TLabel *Label9;
TLabel *Label11;
TEdit *Edit3;
TEdit *Edit4;
TEdit *Edit5;
TEdit *Edit6;
TEdit *Edit8;
TEdit *Edit9;
TChart *Chart1;
TLineSeries *Series1;
TEdit *edTime;
TLabel *Label12;
TChart *Chart2;
TPointSeries *Series2;
TLabel *Label10;
TEdit *Edit1;
TMainMenu *MainMenu1;
TMenuItem *N1;
TMenuItem *Q1;
TMenuItem *N2;
void __fastcall Button1Click(TObject *Sender);
void __fastcall Q1Click(TObject *Sender);
void __fastcall N2Click(TObject *Sender);
private: // User declarations
struct src {
int ntime;
int task;
};
struct str {
int task;
};
struct proc {
int end_proc;
int terminal;
};
int gen_time;
int lng_time;
int gen_task;
int lng_task;
int proc_speed;
int proc_time;
int End_time;
int count_err;
int count_task;
int count_task_first;
int cycle;
int GenTask(int,int);
int GenTime(int,int,int);
int GetTask(src*,int);
int Processing(str*,proc*);
int IncTerminal(int);
void BeginParam(src*,str*,proc*);
void OutParam(str*);
public: // User declarations
__fastcall TForm1(TComponent* Owner);
int t;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
Unit1.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
#include "Unit3.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CGAUGES"
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
int TForm1:: GenTask (int a,int b) // генерация размера задачи
{
return(a + 10*random((b+10)/10));
}
int TForm1:: GenTime (int a,int b,int tsk) // генерация времени следующей задачи
{
return(tsk + a + random(b+1));
}
int TForm1:: IncTerminal (int a)
{
if(a<2) a++;
else {a = 0; cycle++;}
return a;
}
int TForm1:: GetTask (src *s,int i) // генерация задачи
{
if(s[i].ntime == t) {
s[i].task = GenTask(gen_task,lng_task);
s[i].ntime = GenTime(gen_time,lng_time,t);
return 1;
}
else return 0;
}
void TForm1:: BeginParam(src *source,str *store, proc *CPU)
{
for(int i=0;i<3;i++) {
source[i].ntime = 0;
source[i].task = 0;
store[i].task = 0;
}
store[3].task = 0;
CPU->terminal = 0;
CPU->end_proc = 0;
gen_time = StrToInt(edGen_time->Text);
lng_time = StrToInt(edLng_time->Text);
gen_task = StrToInt(edGen_task->Text);
lng_task = StrToInt(edLng_task->Text);
proc_speed = StrToInt(edProc_speed->Text);
proc_time = StrToInt(edProc_time->Text);
End_time = StrToInt(edTime->Text);
count_task_first = 0;
cycle = 0;
count_err = 0;
count_task = 0;
t = 0;
Series1->Clear();
Series2->Clear();
}
void TForm1:: OutParam(str *st)
{
float temp= count_err;
Edit3->Text = count_task;
Edit4->Text = count_task_first;
Edit5->Text = count_task - count_task_first;
Edit6->Text = count_err;
Edit8->Text = st[3].task;
Edit9->Text = cycle;
Edit1->Text = temp/(count_err+count_task);
}
int TForm1:: Processing(str *st, proc *CPU)
{
int i = CPU->terminal;
if(st[i].task>0) { // в накопителе терминала имеется заявка
if((st[i].task/proc_speed) <= proc_time) {
CPU->end_proc = t + st[i].task/proc_speed; // напрямую в ЭВМ
count_task_first++;
st[i].task = 0;
count_task++;
}
else {
st[3].task += st[i].task - proc_speed * proc_time;//в ЭВМ и часть в буфер
CPU->end_proc = t + proc_time;
st[i].task = 0;
count_task++;
}
}
else {
if(st[3].task>0) { // решается задача из буфера
if((st[3].task/proc_speed) <= proc_time) {
CPU->end_proc = t + st[3].task/proc_speed;
st[3].task = 0;
}
else {
st[3].task = st[3].task - proc_speed * proc_time;
CPU->end_proc = t + proc_time;
}
}
else return 0;
}
CPU->terminal = IncTerminal(CPU->terminal);
Series1->AddXY(t,st[3].task);
Series2->AddXY(t,st[0].task);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
src *source = new src [3];
str *store = new str [4];
proc *CPU = new proc;
BeginParam(source,store,CPU);
for(t=0;t<End_time;t++)
{
CGauge1->Progress = t;
for(int i=0;i<3;i++) // заполнение терминалов задачами
if(GetTask(source,i)) {
if(store[i].task==0) {
store[i].task = source[i].task;
source[i].task = 0;
}
else count_err++;
}
if(CPU->end_proc<=t) Processing(store,CPU); // Обработка задач
}
OutParam(store);
}
void __fastcall TForm1::Q1Click(TObject *Sender)
{
Form2->ShowModal();
}
void __fastcall TForm1::N2Click(TObject *Sender)
{
Form3->ShowModal();
}