Приложение А (обязательное) Псевдокод моделирующего алгоритма

структура 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)

конец

Приложение Б (обязательное) Листинг программы