1. модель асинхронной автоматной обработки данных

МОСКОВСКИЙ
ЭНЕРГЕТИЧЕСКИЙ ИНСТИТУТ
(ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ)
АВТ
Институт______________________________
ВМСиС
Кафедра_______________________________
230101
Специальность_______________________
ДИПЛОМНЫЙ ПРОЕКТ
Расчетно-пояснительная записка
Тема Разработка программной модели для исследования
временных характеристик систем обработки данных
А-10-03
Дипломник
Первушин А.И.
г р уп п а
Руководитель проекта
доцент
подпись
к.т.н.
должность
звание
подпись
должность
звание
подпись
фамилия, и., о.
Мороховец Ю.Е.
фамилия, и., о.
Консультант
фамилия, и., о.
“Допустить проект к защите”______________________________________________________
м е с я ц , уч е б н ы й г о д
Зав. кафедрой____________________________________________________________________________
звание
Дата
27.01.2009
подпись
фамилия, и., о.
200____
9 г.
Аннотация
Работа посвящена изучению асинхронных автоматных схем, способам
представления с помощью асинхронных автоматных схем системы
непрерывной обработки данных, написанию программного модуля
производящего имитационное моделирование вычислительного процесса
выполняемого на системе непрерывной обработки данных.
Рассматриваются проблемы распределенного решения вычислительной
задачи на нескольких процессорных модулях.
2
Содержание
Определения ....................................................................................................................................... 4
Введение .............................................................................................................................................. 5
1. МОДЕЛЬ АСИНХРОННОЙ АВТОМАТНОЙ ОБРАБОТКИ ДАННЫХ ............................. 7
1.1. Асинхронные автоматные схемы ........................................................................................... 7
1.1.1. Буферы .................................................................................................................................. 7
1.1.2. Автоматные компоненты и их шаблоны ........................................................................... 8
1.1.3. Структура схем .................................................................................................................. 12
1.1.4. Функционирование схем .................................................................................................. 14
1.2. Специальные виды автоматных компонентов .................................................................... 16
1.2.1. Свободные автоматные компоненты............................................................................... 17
1.2.2. Детерминированные автоматные компоненты .............................................................. 18
1.2.3. Регулярные автоматные компоненты .............................................................................. 20
1.2.4. Схемы непрерывной обработки данных ......................................................................... 21
2. АГРЕГИРОВАННЫЕ СХЕМЫ ОБРАБОТКИ ДАННЫХ С РЕГУЛЯРНЫМИ
КОМПОНЕНТАМИ ......................................................................................................................... 22
2.1. Модель обработки данных для случая регулярных компонентов .................................... 22
2.2. Агрегированные автоматные схемы и их временные характеристики ............................ 27
2.3. Задача анализа временных характеристик агрегированных автоматных схем ............... 29
3. ПРЕДСТАВЛЕНИЕ АГРЕГИРОВАННЫХ АВТОМАТНЫХ СХЕМ В ПРОГРАММНОЙ
МОДЕЛИ ........................................................................................................................................... 30
3.1. Дескриптор шаблона .............................................................................................................. 31
3.2. Дескриптор компонента ........................................................................................................ 35
3.3. Дескриптор входа и выхода компонента ............................................................................. 38
3.4.
Дескриптор буфера ............................................................................................................ 40
3.5.
Дескриптор процессора ..................................................................................................... 40
3.6.
Дескриптор коммутатора .................................................................................................. 41
4. ПРОГРАММНЫЙ МОДУЛЬ ДЛЯ АНАЛИЗА ВРЕМЕННЫХ ХАРАКТЕРИСТИК
АГРЕГИРОВАННЫХ АВТОМАТНЫХ СХЕМ ........................................................................... 43
4.1. Класс Imitation ........................................................................................................................ 43
4.2. Описание основных членов класса Imitation. ...................................................................... 45
4.3. Описание вспомогательных членов класса. ........................................................................ 46
4.4. Алгоритм имитации вычислительного процесса ................................................................ 46
4.5.
Алгоритм сохранения трек-файлов .................................................................................. 47
4.6. Алгоритм построения диаграмм Ганта ................................................................................ 49
4.7. Алгоритм подсчета коэффициентов загруженности устройств ........................................ 51
4.8. Алгоритм подсчета времени периода и времени до начала периодической части ......... 51
4.9. Форма ImitationForm .............................................................................................................. 51
5. ПРИМЕР ПРИМЕНЕНИЯ ПРОГРАММНОГО МОДУЛЯ ДЛЯ АНАЛИЗА ВРЕМЕННЫХ
ХАРАКТЕРИСТИК АГРЕГИРОВАННЫХ АВТОМАТНЫХ СХЕМ ........................................ 54
Заключение ....................................................................................................................................... 60
Список используемых источников ................................................................................................. 61
Приложение А. Техническое задание. ........................................................................................... 62
Приложение Б. Исходный код программы. ................................................................................... 63
Определения
В настоящем проекте применяются следующие термины
Ориентированный граф G — это упорядоченная пара G: = (V,A), для которой
выполнены следующие условия:

V это множество вершин или узлов,

A это множество (упорядоченных) пар различных вершин,
называемых дугами или ориентированными рёбрами.
Дуга — это упорядоченная пара вершин (v, w), где вершину v называют
началом, а w — концом дуги. Можно сказать, что дуга v w ведёт от
вершины v к вершине w.
Двудольный ориентированный граф - если вершины графа можно
разбить на два непересекающихся подмножества V1 и V2 так, что всякое
ребро соединяет вершину из V1 с вершиной из V2.
Виртуальная машина (англ. virtual machine) — программная или
аппаратная среда, исполняющая некоторый код (например, байт-код или
машинный код реального процессора), или спецификацию такой системы.
Для запуска программного модуля дипломного проекта использовалась .NET
виртуальная машина.
Система управления версиями (англ. Version Control System или
Revision Control System) — программное обеспечение для облегчения работы
с изменяющейся информацией. Система управления версиями позволяет
хранить несколько версий одного и того же документа, при необходимости,
возвращаться к более ранним версиям, определять, кто и когда сделал то
или иное изменение и многое другое.
4
Введение
Целью дипломного проекта является разработка программного модуля
для исследования временных характеристик агрегированных автоматных
схем. Агрегированная автоматная схема представляет собой модель системы
непрерывной обработки данных. То есть данный программный модуль
служит для моделирования выполнения некоторой вычислительной задачи
на системе обработки данных.
Программный модуль является частью общей инструментальной
программной системы, предназначенной для анализа автоматных схем.
Исходные данные для моделирования автоматной схемы программный
модуль получает от другого программного модуля, входящего в состав
инструментальной программной системы.
Расчетной
частью
проекта
является
анализ
результатов
экспериментов, полученных от разработанного программного модуля.
В качестве языка написания данного программного модуля и всего
проекта выбран C#. В качестве плюсов данного языка – удобное
межъязыковое взаимодействие в едином программном модуле, удобная
библиотека стандартных классов. После компиляции программы на C#
получается платформонезависимый .NET байт-код, а не бинарный файл,
жестко привязанный к архитектуре и платформе, для которой была
произведена компиляция. Полученный байт-код исполняется на .NET
виртуальной машине . Байт-код теоретически должен работать на любой
вычислительной системе , где есть реализация .NET виртуальной машине.
Для коллективной работы над единым программным проектом
используется SVN – система управления версиями. Данная система
позволяет удобно работать коллективно над проектом многим людям
одновременно. На SVN сервере в сети интернет хранятся исходные тексты
программы и другие, необходимые для разработки, использования и
компиляции проекта файлы. У каждого из участников проекта установлен
5
SVN-клиент, который позволяет получать доступ к репозиторию файлов
проекта и гибко с ними работать (использовался клиент TortoiseSVN).
В первом разделе будет рассмотрена теоретические аспекты модели
асинхронной автоматной обработки данных. Во втором части будет
рассмотрена агрегация автоматной схемы и ее временные характеристики. И
будет введен пример, на основе которого в последующих частях будут более
детально объясняться аспекты моделирования. В третьей части подробно
рассмотрены все составные части всех элементов агрегированной
автоматной схемы, необходимые для программной реализации алгоритмов
моделирования. В четвертой части рассмотрены этапы проектирования и
реализации модуля имитационного моделирования. В пятой части
рассказано про использование полученной программной системы для
анализа асинхронных автоматных схем обработки данных на конкретном
примере, который появился в части 2.
6
1.
МОДЕЛЬ АСИНХРОННОЙ АВТОМАТНОЙ ОБРАБОТКИ ДАННЫХ
1.1. Асинхронные автоматные схемы
Обозначим
через
A
множество,
элементы
которого
назовем
асинхронными автоматными схемами. Асинхронную автоматную схему, как
элемент множества A, зададим структурой
a  B, P, xb, yb,
где B – множество буферов; P – множество автоматных компонентов; xb –
соответствие, устанавливающее связь между входами компонентов и
буферами; yb – соответствие, устанавливающее связь между выходами
компонентов и буферами схемы.
1.1.1. Буферы
Множество B – конечное множество, каждый элемент b которого
характеризуется типом хранимых блоков данных и размером. Тип блоков
данных, хранимых в буфере b, равно как и тип самого буфера обозначим
через (b), а его размер, то есть максимальное число блоков, которые могут
одновременно находиться в буфере – через size(b).
Для буфера b типа  положим множество
Q(b) = (D())0(D())1(D())2 ... (D())size(b)
в качестве множества его возможных состояний. Здесь D() – множество
блоков данных типа , а (D())n – множество последовательностей указанных
блоков длины n, 0  n  size(b). Для любого типа  будем считать, что (D())0 =
, где символ «» обозначает пустую последовательность блоков данных.
Каждый элемент множества Q(b) характеризуем длиной. Длину
состояния q(b) = d1, ..., dn обозначим через len(q(b)) и определим ее равной n –
числу блоков данных, находящихся в буфере. Очевидно, что 0  len(q(b)) 
size(b), причем нулевая длина соответствует случаю, когда q(b) = .
Буфер b автоматной схемы назовем пустым, если len(q(b)) = 0,
7
заполненным (не пустым), если 0  len(q(b))  size(b) и переполненным, если
len(q(b)) = size(b). Скажем, что буфер находится в критическом состоянии,
если он пуст или переполнен.
Пусть b – буфер типа , а q – состояние этого буфера. Введем функции
append, head и tail следующим образом:
d, если q = 
append(d,q) 
d, d1, ..., dn, если q = d1, ..., dn и 1  n < size(b)
не определена, если q = d1, ..., dn и n = size(b);
head(q) 
не определена, если q = 
dn, если q = d1, ..., dn и 1  n  size(b);
не определена, если q = 
tail(q) 
, если q = d
d1, ..., dn-1, если q = d1, ..., dn-1, dn и 1 < n  size(b).
Функция append моделирует запись блока данных dD() в буфер b,
находящийся в состоянии q; функции head и tail – чтение блока данных
dD() из буфера b, находящегося в состоянии q.
Заметим, что запись блоков данных в произвольный буфер b и чтение этих
блоков оттуда не зависят друг от друга (перестановочны), до тех пор пока
буфер не находится в критическом состоянии: head(q) = head(append(d,q)),
append(d,tail(q)) = tail(append(d,q)), где 0  len(q)  size(b).
1.1.2. Автоматные компоненты и их шаблоны
Множество
автоматных
компонентов
P
–
конечное
непустое
множество. Каждый элемент p  P характеризуется шаблоном (p)  ,
определяющим его структуру и функционирование. Базис автоматной схемы
 определим как множество структур вида
  SR, RC, X, Y, M, S, F, ,
где SR – множество источников, поставляющих компоненту данные для
8
обработки;
RC – множество приемников, потребляющих результаты
обработки данных, выполненной компонентом; X – множество входов,
обеспечивающих прием данных от компонентов схемы; Y – множество
выходов, обеспечивающих выдачу данных компонентам схемы; M –
множество состояний памяти компонента; S – множество собственных
состояний компонента; F – множество процедур обработки данных,
выполняемых компонентом;  – функция выбора процедур обработки
данных.
Все перечисленные множества являются конечными множествами.
Множества SR, RC, X и Y могут быть пустыми, однако SR и X, равно как RC и Y,
не могут быть пустыми одновременно.
Каждый вход компонента из X характеризуем типом принимаемых
блоков данных. Тип блоков данных, а также тип самого входа обозначим
через (xj), 1  j  nof(X), где nof – функция, возвращающая в качестве
значения число элементов в множестве-аргументе. Аналогично, каждый
выход из Y характеризуем типом выдаваемых блоков данных. Тип блоков
данных, а также тип самого выхода обозначим через (yk), 1  k  nof(Y).
В множествах M и S выделим состояния m0 и s0, которые примем в
качестве
начального
состояния памяти
и
начального
собственного
состояния компонента, соответственно.
Произвольную процедуру обработки данных f  F зададим посредством
структуры
f  , fr, fy, fm, fs,
где  = (1, …, nof(X)) – двоичный вектор маски входов процедуры; fr –
функция внешних воздействий; fy – функция выходов; fm – функция
состояний памяти; fs – функция состояний компонента.
Взаимосвязанные функции fr, fy, fm и fs зададим как соответствия вида
fr: DS(1○D((x1)))…(nof(X)○D((xnof(X))))MS  DR,
fy: DS(1○D((x1)))…(nof(X)○D((xnof(X))))MS 
9
 ({}D((y1)))…({}D((ynof(Y)))),
fm: DS(1○D((x1)))…(nof(X)○D((xnof(X))))MS  M,
fs: DS(1○D((x1)))…(nof(X)○D((xnof(X))))MS  S,
где DS – множество блоков данных, принимаемых от источников; DR –
множество блоков данных, выдаваемых в приемники;  – неопределенный
блок данных. Символ «○» обозначает операцию, которую для двоичной
переменной j и множества D((xj)), 1  j  nof(X) определим следующим
образом:
j ○ D((xj)) =
{}, если j = 0
D((xj)), если j = 1.
Из сказанного следует, что вектор маски входов  = 1,…, nof(X)
процедуры указывает входы компонента, данные c которых используются
при ее выполнении.
Множество U  {0, 1}nof(X) назовем множеством допустимых ситуаций на
входах автоматного компонента. При nof(X) > 0 двоичный вектор ситуации u
= (u1, …, unof(X))  U определяет наличие данных на входах компонента: uj = 1
означает наличие блоков данных на j-м входе, а uj = 0 – отсутствие блоков
данных на указанном входе. При nof(X) = 0 множество ситуаций на входах
автоматного компонента не определено.
Функция выбора процедур обработки данных  имеет вид
: SU  F.
Обозначим через dom(s,) сечение области определения функции
выбора в точке s  S. Множество dom(s,)  U назовем множеством рабочих
ситуаций на входах компонента, обрабатываемых в состоянии s.
Состояние s  S назовем заключительным состоянием в том случае,
если сечение области определения функции выбора  в точке s пусто.
Автоматный компонент, множество состояний которого не содержит
заключительных состояний, назовем компонентом непрерывного действия.
10
Обозначим через val(s,) сечение области изменения функции выбора в
точке s  S. Множество val(s,)  F назовем множеством процедур обработки
данных подчиненных состоянию s.
Множество ситуаций (s,f)  dom(s,), назовем дискриминантом
процедуры f в состоянии s, если и только если для любой ситуации u  (s,f)
f = (s,u).
Функция  должна обеспечивать потенциальную возможность выбора
процедур обработки данных для всех незаключительных состояний
компонента при всех допустимых ситуациях на его входах. Это требование
выполняется при следующих условиях:
– для любого состояния s  S и любой допустимой ситуации u  U
существует рабочая ситуация u  dom(s,) такая, что u  u, где символ «»
обозначает отношение нестрогого включения двоичных векторов, задающее
частичный порядок на множестве {0,1}nof(X);
– дискриминанты, определенные для состояния s  S, образуют
разбиение множества dom(s,) на непересекающиеся подмножества.
Выполнение первого условия гарантирует компоненту, при его
переходе в новое состояние, либо немедленный выбор процедуры обработки
данных, либо возможность такого выбора по мере развития ситуации на
входах. Выполнение второго условия гарантирует однозначность выбора
процедуры компонентом.
Пусть s и f – произвольные состояние и процедура обработки данных,
для которых определен дискриминант (s,f). Равенство f = (s,u) выполнимо
лишь в том случае, если:
– для любой ситуации u  (s,f) маска входов  процедуры f
удовлетворяет условию   u;
– маска входов  процедуры f является наибольшим двоичным
вектором, удовлетворяющим первому условию.
11
Другими словами маска входов  процедуры f и дискриминант (s,f)
должны быть связаны соотношением
 = inf ((s,f)),
где inf – функция, возвращающая инфимум множества-аргумента.
Выполнение этого требования гарантирует наличие данных во
входных буферах компонента, минимально необходимых для выполнения
процедур, задаваемых функцией .
Взаимосвязь элементов множеств S и F, устанавливаемая функциями 
и fs, может быть представлена графически в виде диаграммы переходов
компонента. Диаграмма переходов – двудольный ориентированный граф,
одни вершины которого отображают состояния компонента, а другие –
процедуры обработки данных. Дуги, идущие от состояний к процедурам,
взвешены дискриминантами процедур – непустыми множествами ситуаций
на входах компонента, обрабатываемых в соответствующих состояниях.
Дуги,
идущие
направления
от
процедур
переходов
к
состояниям,
компонента,
показывают
реализуемые
как
возможные
результат
выполнения процедур.
1.1.3. Структура схем
Структурообразующие соответствия xb и yb являются биекциями. Для
определения этих соответствий введем понятия реальных (не шаблонных)
входов и выходов компонентов схемы, а также распространим на них
рассмотренное ранее понятие типа.
Множество реальных, присутствующих в структуре схемы, входов
компонента p  P обозначим через X, считая при этом, что X  p, (p).X. Для
реального входа компонента xj  X определим его тип (xj) = ((p).xj),
1  j  nof(X).
Множество реальных, присутствующих в структуре схемы, выходов
компонента p  P обозначим через Y, считая при этом, что Y  p, (p).Y. Для
12
реального выхода компонента ykY определим его тип (yk) = ((p).yk), 1 k
nof(Y).
Множества реальных входов и выходов всех компонентов асинхронной
автоматной схемы a  A обозначим через XX и YY, соответственно.
Соответствие xb, устанавливающее связь входов компонентов с
буферами схемы, имеет вид:
xb:: XX  B,
причем для любого входа xjXX (xj) = (xb(xj)). Буфер b ассоциирован с j-м
входом компонента p, если xb(xj) = b. Буфер b назовем входным буфером
компонента p, если он ассоциирован с каким-либо из его входов.
Соответствие yb, устанавливающее связь выходов компонентов с
буферами схемы, имеет вид:
yb:: YY  B,
причем для любого выхода ykYY (yk) = (yb(yk)). Буфер b ассоциирован с
k-м выходом компонента p, если yb(yk) = b. Буфер b назовем выходным
буфером компонента p, если он ассоциирован с каким-либо из его выходов.
На рисунке 1.1 показан пример структуры асинхронной автоматной
схемы, где для обозначения буферизированных связей между компонентами
использована композиция соответствий yb и xb–1. Символьные обозначения
буферов, автоматных компонентов, источников и приемников данных,
входов и выходов компонентов схемы соответствуют тем, что были введены
выше по тексту работы. Функционирование автоматного компонента p4
может быть задано шаблоном, рассмотренным ранее в качестве примера.
13
b8
b3
sr1
p1
y1
b1
sr1
p3
x2
y1
p2
p5
rc1
p6
rc1
x1
x3
x1
sr1
y1
y2
x1
b5
y1
b6
y2
b7
p4
x3
x4
y1
x2
b2
x1
y2
y1
b4
b9
Рис. 1.1. Пример структуры асинхронной автоматной схемы
1.1.4. Функционирование схем
Для определения функционирования асинхронной автоматной схемы
рассмотрим функционирование ее произвольного компонента p  P,
имеющего шаблон .
Обозначим через M  p, (p).M множество состояний реальной
памяти, а через S  p, (p).S – множество реальных собственных состояний
компонента. Функцию выбора процедур , а также функции fr, fy, fm, fs
распространим на множества M и S естественным образом.
Пусть s  S текущее состояние компонента, а u  U – ситуация на его
входах. Элементы вектора u формально зададим так:
0, если q(xb(xj)) = 
uj =
1, если q(xb(xj))  ,
где 1  j  nof(X).
Условием
активации
перехода
компонента
p,
находящегося
в
состоянии s, в следующее состояние s является требование
u  dom(s,).
Если условие истинно, компонент выполняет процедуру f = (s,u).
Применяя статически определенную маску входов , согласно указанным
выше выражениям он вычисляет значения функций fr, fy, fm, fs и формирует
маску выходов :
14
0, если fyk(ds,z1,…,znof(X),m,s) = 
k =
1, если fyk(ds,z1,…,znof(X),m,s) = d,
где d  D((yk)), 1  k  nof(Y), и
, если j = 0
zj =
head(q(xb(xj))), если j = 1
для 1  j  nof(X).
В результате выполнения процедуры f компонент p изменяет
состояния своих входных и выходных буферов.
Правило, в соответствии с которым определяется новое состояние
буфера ассоциированного с j-м входом (1  j  nof(X)), имеет вид:
q(xb(xj)), если j = 0
q(xb(xj)) =
tail(q(xb(xj))), если j = 1.
Правило, в соответствии с которым определяется новое состояние
буфера, ассоциированного с k-м выходом (1  k  nof(Y)), имеет вид:
q(yb(yk)), если k = 0
q(yb(yk)) =
append((fyk(ds,z1,…,znof(X),m,s),q(yb(yk))), если k = 1,
Новые состояние памяти компонента и его новое собственное
состояние определяется согласно следующим правилам:
m = fm(ds,z1,…,znof(X),m,s),
s = fs(ds,z1,…,znof(X),m,s).
Из сказанного следует, что выполнение процедуры обработки данных
будет
завершено
лишь
в
том
случае,
если
выходные
буферы,
предназначенные для записи результатов, не окажутся переполненными, то
есть когда len(q(yb(yk))) < size(yb(yk)) для всех k таких, что k = 1.
Функционирование асинхронной автоматной схемы складывается из
независимого (в смысле отсутствия централизованного управления)
15
функционирования ее автоматных компонентов.
1.2. Специальные виды автоматных компонентов
Анализ
функционирования
автоматных
компонентов
позволяет
выделить среди них компоненты трех основных видов – свободные,
детерминированные и регулярные.
На
рисунке
1.2
представлены
схемы,
демонстрирующие
взаимозависимость основных концептов модели асинхронной автоматной
обработки данных, характеризующих функционирование компонентов
перечисленных видов. Нумерованными кружками обозначены концепты
модели, а стрелками показана зависимость между ними. Концептам
присвоены следующие номера:
1 – ситуация на входах;
2 – состояния входных буферов;
3 – текущее состояние компонента;
4 – множество выбранных входов (определяется маской входов );
5 – исходные данные, принимаемые из выбранных входных буферов;
6 – следующее состояние компонента;
7 – множество выбранных выходов (определяется маской выходов );
8 – результаты, выдаваемые в выбранные выходные буферы.
16
а)
3
6
1
4
7
2
5
8
б)
2
3
6
4
7
5
8
в)
2
3
6
4
7
5
8
Рис. 1.2. Концептуальные схемы, характеризующие функционирование
компонентов свободного (а), детерминированного (б) и регулярного (в)
видов
Наличие стрелки, например ведущей от концепта 1 к концепту 4,
означает, что множество выбранных входов зависит от ситуации на входах
свободного компонента.
1.2.1. Свободные автоматные компоненты
Общим случаем автоматных
компонентов являются свободные
компоненты. На рисунке 1.2.а) представлена схема, характеризующая
функционирования
свободных
компонентов.
Следующее
состояние
компонента (6), множество выбранных выходов (7) и результаты,
выдаваемые в выбранные выходные буферы (8), зависят от его текущего
состояния (3) и исходных данных, принимаемых из выбранных входных
буферов (5). Выбор входов (4) и выходов (7), используемых для обмена
информацией в текущем состоянии, может осуществляться компонентом
динамически, на основе анализа ситуации (1), и лишь частично зависит от
состояния.
Компонент назовем свободным компонентом, если для любого его
состояния s  S, не являющегося заключительным состоянием, выполняется
17
условие nof(val(s,))  1. Другими словами, любое состояние свободного
компонента может иметь произвольное конечное число подчиненных
процедур обработки данных.
Пример диаграммы переходов свободного автоматного компонента
представлен на рисунке 1.3.
s0
(s0,f0)
(s1,f0)
(s2,f0)
f0
s1
(s1,f2) (s2,f1)
s2
(s2,f2)
(s1,f1)
f1
f2
Рис. 1.3. Пример диаграммы переходов свободного компонента
1.2.2. Детерминированные автоматные компоненты
Специальным видом свободных автоматных компонентов являются
детерминированные компоненты. На рисунке 1.2.б) представлена схема,
характеризующая функционирование детерминированных компонентов.
Динамический выбор входов, основанный на анализе ситуации, не
осуществляется – множество входов (4), через которые будут приниматься
исходные данные из входных буферов, статически определяется текущим
состоянием компонента (3).
Компонент назовем детерминированным компонентом, если для
любого его состояния s  S, не являющегося заключительным состоянием,
выполняется условие nof(val(s,)) = 1. Состояния детерминированного
компонента могут иметь не более одной подчиненной процедуры обработки
18
данных.
Пример диаграммы переходов детерминированного автоматного
компонента представлен на рисунке 1.4. Детерминированный компонент
назовем компонентом со статически определенными выходами, если маски
выходов его процедур однозначно определяются состояниями, которым эти
процедуры подчинены.
Детерминированный компонент назовем компонентом со статически
определенными переходами, если функции состояний его процедур
устанавливают
однозначную
зависимость
следующего
состояния
компонента от его текущего состояния и при этом любое состояние s  S
достижимо из начального состояния s0. Диаграммы переходов таких
компонентов могут быть представлены в канонической форме – в виде
линейной последовательности состояний и подчиненных им процедур,
заканчивающейся дугой обратной связи, идущей от последней процедуры к
одному из промежуточных состояний компонента.
s0
(s0,f0)
f0
s1
(s1,f1
)
s3
s2
(s3,f2)
(s2,f1
)
f1
s4
(s4,f2)
f2
Рис. 1.4. Пример диаграммы переходов детерминированного компонента
19
1.2.3. Регулярные автоматные компоненты
Специальным видом детерминированных компонентов являются
регулярные
компоненты.
На
рисунке
1.2.в)
представлена
схема,
характеризующая функционирование регулярных компонентов. В этом,
наиболее простом случае, лишь результаты, выдаваемые в выбранные
выходные буферы (8), зависят от исходных данных (5). Следующее
состояние компонента (6), множество выбранных входов (4) и выходов (7)
однозначно определяются текущим состоянием компонента (3).
Детерминированный
компонент,
выходы
и
переходы
которого
статически определенны, назовем регулярным компонентом.
Пример диаграммы переходов регулярного автоматного компонента
представлен на рисунке 1.6.
Процедура f0, показанная на рисунке 1.6, имеет две маски выходов, одна
из которых применяется при ее выполнении в состоянии s0, а вторая – в
состоянии s2. Функция состояний процедуры f0 имеет значения fs0(s0) = s1 и
fs0(s2) = s3. В любом другом случае либо состояние s3, либо состояния s1, s2
окажутся недостижимыми из начального состояния s0.
20
s0
(s2,f0)
(s0,f0)
f0
s2
s3
s1
(s1,f1)
(s3,f2)
f1
f2
Рис. 1.6. Пример диаграммы переходов регулярного компонента
1.2.4. Схемы непрерывной обработки данных
В
множестве
асинхронных
автоматных
схем
выделим
схемы
непрерывной обработки данных, функционирование которых сопряжено с
непрерывным,
не
ограниченным
во
времени
приемом
данных
от
источников, преобразованием данных и выдачей результатов в приемники
данных.
Будем считать, что асинхронная автоматная схема является схемой
непрерывной обработки данных, если она содержит непустое множество
компонентов непрерывного действия.
Как было сказано выше, схемы непрерывной обработки данных
являются адекватным модельным инструментом для описания процессов,
происходящих в специализированных распределенных системах. В связи с
этим именно схемы непрерывной обработки данных являются теми
объектами, рассмотрению свойств и возможностям, агрегации которых
посвящены последующие главы дипломной работы.
21
2.
АГРЕГИРОВАННЫЕ СХЕМЫ ОБРАБОТКИ ДАННЫХ С
РЕГУЛЯРНЫМИ КОМПОНЕНТАМИ
2.1. Модель обработки данных для случая регулярных
компонентов
Ввиду того, что работа схем с регулярными компонентами, а,
следовательно, их реализуемость, не зависят от особенностей используемой
аппаратно-программной платформы, процессов протекающих в метасистеме
и алгоритмов преобразования данных, выполняемых компонентами,
решение рассматриваемой задачи может быть основано на применении
упрощенной поведенческой модели автоматной обработки данных, в
дальнейшем называемой редуцированной моделью. В рамках этой модели
нет необходимости детализировать механизмы приема, преобразования и
выдачи, данных регулярными компонентами, что, в значительной степени,
упрощает представление буферизированных каналов связи, позволяет
заменить буферы счетчиками блоков.
В
редуцированной
модели
множество
схем
с
регулярными
компонентами, обозначим через R. Элемент множества R зададим
структурой
r  B, P, xb, yb,
где B – множество буферов; P – множество компонентов; xb и yb –
соответствия, устанавливающее информационные связи в r-схеме.
Множество буферов B – конечное множество, каждый элемент
которого характеризуется размером. Размер буфера b  B обозначим через
size(b).
Положим множество
Q = {q | 0  q  size(b)},
22
где q – число блоков данных хранящихся в буфере b, в качестве множества
его возможных состояний. Состояние q = 0, означающее отсутствие блоков
данных в буфере, и состояние q = size(b), при котором блоки данных
заполняют все секции буфера, назовем критическими состояниями буфера.
Множество компонентов P – конечное непустое множество. Каждый
элемент p  P характеризуется шаблоном (p)  , определяющим его
структуру и функционирование. Базис схемы  определим как множество
структур вида
  X, Y, S, fs, , ,
где X, Y –
множества входов и выходов, S – множество состояний
компонента,
fs – функция состояний,  – функция выбора входов,  –
функция выбора выходов.
Элемент s0  S примем в качестве начального состояния компонента.
Функция состояний имеет вид
fs(sn) =
sn+1, если 0 ≤ n < nof(S)–1
sm, если n = nof(S)–1.
Из определения функции fs следует, что, начиная с sm, 0 ≤ m ≤ nof(S)–1,
состояния компонента сменяют друг друга циклически, в диапазоне номеров
от m до nof(S)–1 (см. п. 1.2.).
Функции выбора входных и выходных буферов – функции вида
: S  2X и : S  2Y,
где через 2X обозначено множество всех подмножеств множества входов
компонента p, а через 2Y – множество всех подмножеств множества его
выходов.
Общий
вид
диаграммы
переходов
регулярного
компонента
в
редуцированной модели показан на рис.2.1. Последовательность состояний
23
sm, …, snof(S)–1 с подчиненными им переходами (обозначенными стрелками)
образуют рабочий цикл компонента.
(s0
)
(s0
)
s0
sm
(sm
)
(s
m)
snof(S)
–1
(snof(S)–
1)
(snof(S)–
1)
Рис. 2.1. Общий вид диаграммы переходов компонента схемы r  R
Множество реальных, присутствующих в структуре схемы, входов
компонента p  P обозначим через X, считая при этом, что X  p, (p).X.
Множество реальных, присутствующих в структуре схемы, выходов
компонента p  P обозначим через Y, считая при этом, что Y  p, (p).Y.
Множества реальных входов и выходов всех компонентов асинхронной
автоматной схемы a  A обозначим через XX и YY, соответственно.
Соответствия xb и yb, устанавливающие связь входов/выходов
компонентов с буферами схемы, имеют вид:
xb:: XX  B и yb:: YY  B.
Будем
считать,
что
соответствия
xb
и
yb
обеспечивают
информационную связанность схемы: любые два компонента схемы
информационно связаны друг с другом либо непосредственно, либо через
другие компоненты.
Для
определения
функционирования
схемы
рассмотрим
функционирование ее произвольного компонента p  P, имеющего шаблон .
Обозначим через S  p, (p).S – множество реальных собственных состояний
компонента. Функции fs,  и  распространим на множества S, X и Y
естественным образом.
24
Из множества возможных способов уточнения функционирования
компонента в редуцированной модели выделим два способа. В первом
случае речь пойдет о -редуцированных, а втором случае – о редуцированных компонентах.
Функционирование
-редуцированного
компонента
определим
следующим образом. Пусть s – текущее состояние компонента. Условие
перехода компонента из s в следующее состояние s связано с выполнением
двух требований:
(b)  xb((s))  q(b)  0 и (b)  yb((s))  q(b)  size(b)
– компонент может начать переход из s в s, если его входные и выходные
буферы, ассоциированные с выбранными входами и выходами, указанными
функциями  и , не находятся в критических состояниях.
Если условие выполнено, компонент через определенный промежуток
времени срабатывает – изменяет состояния выбранных входных и выходных
буферов, а также свое собственное состояние согласно следующим
правилам:
q(b) = q(b) –1, если b  xb((s)),
q(b) = q(b) +1, если b  yb((s)),
(2.1)
s = fs(s).
Все указанные изменения носят мгновенный характер.
Условие активации перехода -редуцированного компонента связано с
выполнением лишь одного требования:
(b) b  xb((s))  q(b)  0
– компонент может начать переход, если его выбранные входные буферы,
указанные функцией , не находятся в критических состояниях.
Если условие выполнено, компонент начинает переход мгновенным
изменением состояний выбранных входных буферов, а затем, через
25
определенный
промежуток
времени,
проверяет условие
завершения
перехода
(b) b  yb((s))  q(b)  size(b)
– компонент может завершить переход, если его выбранные выходные
буферы, указанные функцией , не находятся в критических состояниях
Если условие выполнено, компонент мгновенно изменяет состояния
выбранных выходных буферов, а также свое собственное состояние согласно
указанным выше правилам (2.1).
В рамках настоящей работы будут рассматриваться лишь схемы с
-редуцированными компонентами. Этот выбор обусловлен тем, что
-редуцированные компоненты предъявляют более жесткие требования к
реализуемости редуцированных схем и, кроме того, они проще.
Как и в общем случае, функционирование схемы r  R складывается из
независимого функционирования ее компонентов.
На Рис 2.2 показан пример автоматной схемы, состоящей из 19
компонентов и 29 буферов. Компоненты изображены окружностями, с
подписанными номерами в центре. Буферы – прямоугольниками и номера
подписаны сбоку и сверху. Стрелками обозначено движение потоков данных
в вычислительном процессе. И в соответствии со стрелками нетрудно
определить для каждого компонента какие буферы для него входные, а
какие выходные
26
0
0
1
1
2
2
26
24
18
17
16
3
5
22
4
7
25
23
3
6
4
27
8
21
10
14
15
5
9
6
28
7
12
20
11
19
8
13
13
18
9
12
16
17
14
15
10
11
Рис. 2.2. Пример автоматной схемы
2.2. Агрегированные автоматные схемы и их временные
характеристики
Выполнение
компонентов
(процессов
некоторой
программы)
происходит на процессорных модулях. На одном процессорном модуле
может выполняться один и более компонентов.
Буферы могут, связывающие компоненты, могут находить внутри
процессорного модуля, так и быть внешними. При взаимодействии двух
компонентов, находящихся в разных процессорных модулях, буфер, который
их
связывает
коммутационные
находиться
модули
в
коммутационным
обеспечивают
27
обмен
модуле.
данными
То
есть
между
процессорными модулями. Когда буфер является внешним по отношению к
процессору, то есть принадлежит коммутационному модулю, то на передачу
данных через него затрачивается определенное время. Время передачи во
внутренний буфер считается нулевым. Так как оно слишком незначительно
по отношению к времени передачи данных между процессорными модулями
и временем, необходимым на вычисления. Каждый коммутационный модуль
может связывать несколько процессорных модулей, то есть содержать
несколько буферов. Заданное распределение компонентов по процессорным
модулям и распределение внешних буферов по коммутационным модулям
является агрегированием автоматной схемы. То есть агрегация – это
наложение модели вычислительной задачи, разбитой по процессам
(компонентам, связующим их буферам и алгоритмам функционирования шаблонам)
на
модели
физических
устройств
для
имитации
вычислительного процесса системы обработки данных.
Исходными
временными
характеристиками
агрегированных
автоматных схем является время передачи данных между процессорными
модулями и времена обработки данных компонентами. Время передачи
данных между процессорными модулями – это время чтения компонента
необходимых ему данных из внешнего буфера. Данные временные
характеристики
необходимы
для
имитационного
моделирования.
Результатом моделирования являются, время от начала моделирования до
начала периодического режима и время периода. Данные выходные временные
характеристики могут сильно зависеть от агрегации компонентов и буферов по
процессорным модулям и коммутационным модулям. То есть при неизменной
автоматной схеме, не меняемых входных временных характеристиках и
числе процессорных модулей и модулей коммутации выходные времена
могут сильно изменяться. Будет меняться загрузка устройств. Меняя
агрегацию схемы можно добиться оптимальной загрузки устройств. И тем
самым достичь наиболее быстрого выполнения заданного задания по
28
обработке данных на текущем доступном оборудовании.
Пример агрегированной автоматной схемы на рис. 2.3. P0…P7 –
процессорные модули, сплошная заливка. S0…S4 – коммутационные модули,
обозначены заштрихованными фигурами. Из рисунка видно, например, что
нулевому процессорному модулю принадлежит только нулевой компонент.
Он (P0) связан с первым процессорным модулем (P1) коммутационным
модулем номер 0(S0). И S0 принадлежат буферы 0-4. А первому
процессорному модулю принадлежат компоненты 1-5 и входные для них
буферы, то есть 0-4.
S0
0
P1
0
1
1
2
2
P4
26
24
18
17
16
3
4
27
8
P2
21
10
14
P7
6
28
15
5
9
S1
7
S3
4
7
25
23
22
3
6
5
12
20
11
19
8
P6
13
13
S4
S2
18
P3
12
9
16
17
14
P5
10
15
11
Рис. 2.3. Пример агрегированной автоматной схемы
2.3. Задача анализа временных характеристик агрегированных
автоматных схем
29
P0
3.
ПРЕДСТАВЛЕНИЕ АГРЕГИРОВАННЫХ АВТОМАТНЫХ СХЕМ В
ПРОГРАММНОЙ МОДЕЛИ
Вычислительный процесс (симуляцию которого выполняет данный
программный модуль) состоит из компонентов (некоторых неделимых
частей программы) и буферов, которые служат, для передачи информации
между компонентами. Компоненты и буферы связаны между собой через
входы и выходы компонентов. Компоненты и буферы распределены
некоторым образом по процессорным модулям и коммутационным модулям.
Исходными данными для модуля имитации вычислительного процесса
является заданные связи между компонентами и буферами, необходимые
для имитации работы атрибуты компонентов и буферов и их распределение
по процессорным модулям и модулям коммутации.
Шаблоны позволяют сделать вычислительный процесс компонентов
более реалистичным и нелинейным.
Компоненты и буферы распределяются по процессорным модулям и
коммутационным узлам.
Результатом работы модуля являются построенные диаграммы Ганта,
сформированный трек-файл с возможностью сохранения для последующего
использования, рассчитанные коэффициенты полезного действия
процессорных модулей и модулей коммутации, посчитанное время периода
и времени до начала периодической части вычислительного процесса.
Далее рассмотрим более подробно все элементы, используемые в
вычислительном процессе.
30
3.1. Дескриптор шаблона
В таблице 1 приведены составные части дескриптора шаблона. Каждый
компонент работает по определенному шаблону, а в каждом шаблоне есть
массив с командами(instr[], Command – класс команды). Эти команды задают
алгоритм функционирования всех компонентов, использующих данный
шаблон. Для представления шаблона внутри программы используется
пользовательский тип – «Templet». В табл. 3.1 составные поля шаблона.
Таблица 3.1
Поля шаблона
Название поля
Тип
Описание
instr[]
Command
Массив команд шаблона
nofx
byte
Число шаблонных входов
nofy
byte
Число шаблонных выходов
Всего 6 типов команд:
1) ATTACH
2) EXEC
3) SETINPUT
4) SETOUTPUT
5) CYCLE
6) JUMP
Команды состоят из массива байт переменной длины. По первому
байту определяется один из 6-ти типов команды. В зависимости от типа
определяется назначение последующих байтов. Рассмотрим более подробно
каждую команду.
31
В табл. 3.2 побайтовое описание команды ATTACH.
Таблица 3.2
Команда ATTACH
Номер байта
1
Назначение
ATTACH
2
3
N - число
1й номер
входов
входа
2+N
Nй номер
…
входа
Команда ATTACH выполняет проверку входных буферов на наличие в
них необходимых данных. В самой команде указываются номера входов
компонента, с которыми связаны буферы в которых проверяется наличие
данных. Второй байт - число входов компонента, на которых нужно
проверить наличие данных, далее идут номера входов, количеством,
указанным во 2м байте команды.
В табл. 3.3 побайтовое описание команды EXEC.
Таблица 3.3
Команда EXEC
Номер байта
1
2
Назначение
EXEC
dt
Команда EXEC имитирует выполнение вычислительной работы
компонента длительностью dt времени.
В табл. 3.4 побайтовое описание команды SETINPUT.
Таблица 3.4
Команда SETINPUT
Номер байта
1
Назначение
SETINPUT
Команда SETINPUT следует за командой ATTACH и выполняет
извлечение из входных буферов, связанных со входами, которые
упоминались в команде ATTACH, данных и передача их в компонент как
входных данных для вычислительного процесса.
32
В табл. 3.5 побайтовое описание команды SETOUTPUT.
Таблица 3.5
Команда SETOUTPUT
Номер байта
1
Назначение
SETOUTPUT
2
3
2+N
N-число
1й номер
выходов
выхода
Nй номер
…
выхода
Команда SETOUTPUT выполняет проверку выходных буферов, через
связанные с ними номера выходов компонента, на наличие свободных мест
для выходных данных вычислительного процесса компонента и выполняет
резервирование места в выходных буферах. Синтаксис аналогичен
SETINPUT.
В табл. 3.6 побайтовое описание команды CYCLE.
Таблица 3.6
Команда CYCLE
Номер байта
1
2-3
4
Назначение
CYCLE
Адрес перехода
Число
повторов
Команда CYCLE служит для выполнения циклов. Происходит перевод
указателя команд на номер, указанный в адресе перехода на указанное число
раз в 4м байте.
В табл. 3.7 побайтовое описание команды JUMP.
Таблица 3.7
Команда JUMP
Номер байта
1
2-3
Назначение
JUMP
Адрес перехода
33
Команда JUMP выполняет перевод указателя команд на номер,
указанный в адресе перехода.
Для представления команд внутри программы используется
пользовательский тип данных (класс) – «Command». Внешний интерфейс
класса Commnd на рис. 3.1
Рис. 3.1. Класс Command
«cmd» – тип команды один из указанных выше 6 типов.
«cmd_args» - аргументы команды.
«Command» - конструктор класса.
«getShortArg()» - метод для получения адреса для команд JUMP и CYCLE.
Массив таких объектов типа «Command» является массивом команд.
Переход происходит не по адресу команды, а по ее номеру. Такая реализация
исключает ошибки, если переход произойдет в середину команды.
34
3.2. Дескриптор компонента
Компонент является некоторым аналогом процесса исполняемого на
процессоре. Каждый компонент работает по заданному шаблону, имеет свои
входы и выходы, связанные с буферами, через которые передаются данные
между компонентами, так же имеет свой счетчик команд. И некоторые
вспомогательные элементы для осуществления имитации вычислительного
процесса(cycleListFix, ready), ссылку на следующий компонент в данном
процессоре. В процессоре компоненты связаны между собой циклическим
односвязным списком. В таблице 3.8 приведены составные части
компонента. Для представления компонента используется
пользовательский тип данных – «component».
Таблица 3.8
Component – дескриптор компонента
Название поля
Тип
Описание
tempNum
byte
Номер шаблона компонента
x[]
inDesc
Массив шаблонных входов
y[]
instr[]
succComp
outDesc
Command
Component
ip
cycleListFix
ushort
CycleElement
ready
bool
Массив шаблонных выходов
Указатель на массив команд в шаблоне
Указатель на следующий дескриптор
компонента в циклическом списке
компонентов, принадлежащих одному
процессору
Указатель команд в instr[]
Указатель на список объектов типа
CycleElement для организации циклов.
Признак готовности компонента к
выполнению
CycleElement – пользовательский тип данных для осуществления
работы циклов. Состав элементов класса показан на рис. 3.2. Используется
список таких объектов. cycleListFix – указатель на начало списка.
35
Рис. 3.2. Класс CycleElement
ip – адрес перехода, на котором встретилась команда перехода.
rpt – число повторений.
succCycleElement – указатель на следующий элемент списка.
На рис. 3.3 и на рис. 3.4 показаны алгоритмы выполнения команд JUMP и
CYCLE соответственно.
Начало
Выборка адреса
перехода из второготретьего байтов
команды
Смена ip на новый
Конец
Рис. 3.3. Алгоритм команды JUMP
36
Начало
Поиск в списке
cycleListFix элемента
по ip
нет
да
Найден?
Выборка количества
повторений
из четвертого байта
команды(rpt)
Запоминание
указателя найденного
элемента
Добавление в конец
списка
Выборка нового адреса
из второго-третьего
байтов команды
Смена Ip На новый
Уменьшение
количества оставшихся
повторений(rpt)
нет
rpt > 0
да
Удаление элемента из
списка
Конец
Рис. 3.4. Алгоритм команды CYCLE
37
Данные схемы алгоритмов являются частью схемы графического
материала 1. Там они вызываются как подпрограммы.
3.3. Дескриптор входа и выхода компонента
Состав дескрипторов входа и выхода в таблицах 3.9 и 3.10.
Дескрипторы входов и выходов представлены пользовательскими типами
данных - inDesc, outDesc, которые в силу большой схожести унаследованы от
базового класса – desc.
Таблица 3.9
inDesc – дескриптор входа компонента
Название поля
Тип
Описание
buf
Buffer
Указатель на связанный со входом буфер
external
bool
Признак внешнего буфера, то есть не
принадлежащего тому же процессору, что и
компонент
ready
bool
Признак готовности входных данных на
данном входе
sw
Switch
Указатель на коммутатор
semRead
int
Семафор чтения, число занятых секций в
буфере buf.
38
Таблица 3.10
outDesc – дескриптор входа компонента
Название поля
Тип
Описание
buf
Buffer
Указатель на связанный с выходом буфер
external
bool
Признак внешнего буфера, то есть не
принадлежащего текущему процессору
ready
bool
Признак готовности выходных буферов к
приему данных
sw
Switch
Указатель на коммутатор
semWrite
int
Семафор записи, число свободных секций в
буфере buf.
Состав элементов классов inDesc, outDesc показан на рис. 3.5. Классы
inDesc и outDesc наследуются от базового класса desc.
Рис. 3.5. Классы desc, inDes, outDesc
inDesc, outDesc – конструкторы.
39
3.4. Дескриптор буфера
Буферы служат для связи компонентов. Если буфер является внешним
(external == true), то доступ к нему происходит через коммутатор. Состав
элементов дескриптора буфера приведен в таблице 3.11.
Таблица 3.11
Buffer – дескриптор буфера
Название поля
Тип
Описание
size
int
Размер буфера (число секций в буфере)
vol
int
Объем секции (число байт в секции)
time
int
Время записи/чтения через коммутатор
x
inDesc
Указатель на дескриптор входа, связанный с
буфером
y
outDesc
Указатель на дескриптор выхода, связанный с
буфером
procNum
int
Номер процессора, в памяти которого
находится буфер
switchNum
int
Номер коммутатора, через который
выполняется запись в буфер / чтение из
буфера
writeProc
Processor
Указатель на дескриптор процессора,
записывающего в буфер
readProc
Processor
Указатель на дескриптор процессора,
читаюцего из буфера
external
bool
Признак того, что буфер внешний
3.5. Дескриптор процессора
По процессорам распределены компоненты. На каждом процессоре
выполняется некоторое число компонентов. Указатель на начало списка
этих компонентов – «compListFix». curComp – выполняемый компонент в
40
текущий момент.
Из-за нехватки данных во входных буферах или из-за занятости
выходных происходит остановка выполнения процессора и выставляется
флаг stop = true. Состав элементов дескриптора процессора приведен в
таблице 3.12.
Таблица 3.12
Processor – дескриптор процессора
Название поля
Тип
Описание
compListFix
component
Указатель на начало циклического списка
компонентов, принадлежащих этому
процессору
succProc
Processor
Указатель на следующий процессор в списке
процессоров, обслуживаемых данным
коммутатором
eventTime
int
Время следующего события
stop
bool
Признак остановки процессора
curComp
component
Указатель на текущий выполняемый
компонент
3.6. Дескриптор коммутатора
Через коммутаторы происходит передача данные между
компонентами, относящимися к разным процессорам. При передаче через
коммутатор фиксируется время передачи через eventTime для избежания
многократного использования коммутатора в один момент времени.
Каждый коммутатор обслуживает некоторое количество процессоров,
список процессоров – procListFix. Состав элементов дескриптора компонента
41
приведен в таблице 3.13.
Таблица 3.13
Switch – дескриптор буфера
Название поля
Тип
Описание
procListFix
Processor
Указатель на начало циклического списка
процессоров, обслуживаемых данным
коммутатором
eventTime
int
Время следующего события
42
4.
ПРОГРАММНЫЙ МОДУЛЬ ДЛЯ АНАЛИЗА ВРЕМЕННЫХ
ХАРАКТЕРИСТИК АГРЕГИРОВАННЫХ АВТОМАТНЫХ СХЕМ
Программный модуль состоит из 2х частей:
1)
класс (Imitation), который выполняет все расчеты, симуляцию.
2)
форма (ImitationForm), которая отображает результаты расчетов
и симуляции и управляет классом Imitation, вызывая необходимые методы, в
зависимости от действий пользователя.
При запуске всей инструментальной программы первым запускается
графический редактор схемы и структуры. Именно он передает входные
данные для имитационного моделирования. Но программный модуль
редактора не входит в рассмотрение в данном дипломном проекте. Именно
Далее более подробно рассмотрим класс и форму с алгоритмами их работы.
4.1. Класс Imitation
На рис. 4 показаны члены класса Imitation. Данный класс является
основным в программном модуле имитации. Именно в этом классе
происходят все вычисления, расчеты и построения.
43
Рис. 4. Класс Imitation
Входными данными для симуляции вычислительного процесса
являются объекты схемы и структуры, пользовательских типов
«model_scheme» и «model_struct» соответственно. На рис. 5 показан состав
класса схемы, на рис. 6 класса структуры.
Рис. 5. Класс model_scheme
44
Рис. 6. Класс model_struct
Класс схемы состоит из массивов компонентов, буферов и шаблонов. А
класс структуры состоит из массивов процессоров и коммутаторов.
Все описанные пользовательские типы данных и их взаимосвязь описаны в
пункте 1.2.
4.2. Описание основных членов класса Imitation.
Класс Imitation является основным для данного программного модуля.
Imitation(model_scheme scheme, model_struct struc, int max_time)
– конструктор, в
котором происходит имитации вычислительного процесса. Входные данные
– схема, структура, максимальное время симуляции, по достижении которого
нужно остановиться.
CalcPeriodTime()
– подсчет времени периода.
CalcAperiodTime()
– подсчет времени непериодичной части.
SaveTrack(string path)
– сохранение трек-файла, входные параметры – путь,
куда сохранить файл.
CalcKoef()
– подсчет коэффициентов загрузки устройств.
DrawDiag(object sender, PaintEventArgs e)
– построение диаграмм Ганта, является
функцией перерисовки формы. входные параметры – объект для которого
происходит перерисовка, дополнительные аргументы для рисования на
обеъкте.
45
4.3. Описание вспомогательных членов класса.
private int cur_time –
private int max_time
текущее время во время имитации.
– предельное время симуляции, инициализируется в
конструкторе.
private model_scheme scheme –
схема компонентов, буферов и шаблонов,
инициализируется в конструкторе.
private model_struct struc –
структура процессоров и коммутаторов,
инициализируется в конструкторе.
private Imit_event events –
трек-файл всех событий процесса, заполняется в
процессе симуляции вычислительного процесса.
private bool isInit = false –
признак корректной инициализации внутренних
полей класса и проведения симуляции, устанавливается в true после
выполнения конструктора - Imitation
get_pointSz(), get_fontSz(), get_prY(int pr), get_swY(int sw), get_endJob(dev_type dev,
int dev_id, event_type ev, int start_time)
– используются для построения
диаграмм на форме.
unStopPr()
– вспомогательная функция для симуляции вычислительного
процесса.
int x0, y0, zoom
– используются для взаимодействия с формой, для
определения положения и приближения диаграмм Ганта, изменяются от
действий мышкой на форме.
4.4. Алгоритм имитации вычислительного процесса
Внешний цикл ведется пока не будет cur_time = max_time.
Далее производится выборка процессора с наименьшим eventTime, и флагом
stop = false. Когда процессор выбран, начинается цикл по всем его
компонентам, пока не будет остановки (из-за нехватки данных в входных
буферах, занятости выходных или после команды EXEC), для каждого
46
компонента производится выборка команды из instr[] по адресу ip, ее
дешифрация и выполнение, если у процессора не было выполнено ни одного
компонента производится остановка данного процессора(stop = true). Если
были выполнены команды SETINPUT/SETOUTPUT производится
пробуждение остановленных процессоров, если были затронуты их буферы.
Результатом имитации является сформированный лог событий работы
системы, на основе которого производятся дальнейшие вычисления и
действия в программном модуле.
4.5. Алгоритм сохранения трек-файлов
Для ведения лога событий системы используется структура
event_struct.
На рис. 7 – показаны ее поля.
Рис. 7. Структура event_struct
dev_id – порядковый номер устройства.
dev_type – тип устройства, используется тип - перечисление dev_type:
Рис. 8. Перечисление dev_type
47
PROCESSOR – соответствует процессору.
SWITCH – соответствует коммутатору.
event_time – время начала события.
event_type – тип события, используется тип – перечисление event_type:
Рис. 9. Перечисление event_type
BEGIN_WORK – начало работы устройства.
END_WORK – конец работы устройства.
BEGIN_WAIT – начало режима ожидания.
END_WAIT – конец режима ожидания.
Расширяемый массив этих структур содержаться в классе Imit_event
Рис. 10. Класс Imit_event
ev_list – массив из структур с событиями event_struct.
Add_event – метод для добавления в массив нового события.
Imit_event – конструктор, который выполняет начальную инициализацию
массива.
48
Заполнение этого массива происходит через метод Add_event в
конструкторе класса Imitation, когда происходит имитация, происходящие
события сразу заносятся в массив. После выполнения Imitation в памяти есть
полный лог событий системы. Для их сохранения используется свойство
языка C# - сериализация объектов. Сериализация — это процесс
преобразования состояния объекта (или набора взаимосвязанных объектов)
в специальное представление (например, в формате XML), которое может
быть помещено в поток (например, для записи в файл). В данном случае
используется сохранение объекта events в файл в формате XML. За счет
формата XML файл является легкочитаемым человеком и с ним удобно
работать программно. Запись и восстановления обеъкта происходит очень
прозрачно в программе.
4.6. Алгоритм построения диаграмм Ганта
Для построения диаграмм используется тот же массив событий, что и
использовался для трек-файлов. Построение происходит в момент
перерисовки формы ImitationForm. Так же зависит от некоторых параметров,
таких как масштаб (задается в процессе просмотра диаграмм поворотом
колесика мышки) и положение диаграмм на форме (задается зажатой левой
кнопкой мышки и перемещением курсора).
На рис. 11 приведен алгоритм построения диаграмм.
49
начало
Построение осей и
подписей к ним для
каждого устройства
Для всего массива
ev_list
Конец цикла
Конец
Выборка структуры
события из массива
нет
Тип события начало события
да
Поиск конца события
для данного
устройства в массиве
ev_list
Рисование
прямоугольника
ограниченного началом
события и концом на
нужной оси данного
устройства
Рис. 11. Алгоритм построение диаграмм
50
4.7. Алгоритм подсчета коэффициентов загруженности устройств
Для каждого устройства считается отношение времени его работы к
общему времени работы системы. Информация, о том, какое устройство
сколько работало, берется из массива событий.
4.8. Алгоритм подсчета времени периода и времени до начала
периодической части
На основе построенных диаграмм Ганта создать некоторый массив из
чисел, каждое число содержит результат некоторой хеш-функции, которая
генерирует уникальное число в зависимости от работы в текущий момент
времени всех устройств. Всю последовательность выполнения
вычислительного процесса можно представить как последовательность
чисел. Каждое число должно характеризовать состояния всех устройств в
текущий момент времени. Произведем преобразование последовательности
состояний всех устройств в каждый момент времени в последовательность
чисел.
После получения массива чисел, будет произведен его анализ на
выявления периода и времени до начала периодической части. Анализ
производится перебором всего массива в 2х вложенных циклах и сравнением
на совпадение элементов: фиксируется первое совпадение (при разных
индексах), далее, если при совпадении всех последующих элементов при
параллельном переборе массивов (при разных индексах этих элементов)
считается длина цикла до встречи с таким же элементом, как и при первом
совпадении. Найденная для полученных индексов начала и конца цикла лего
вычислить временное значение цикла. Время до начала периодической
части будет временем до первого цикла.
4.9. Форма ImitationForm
51
На рис. 12 показан внешний вид формы.
Рис. 12. Форма ImitationForm
Сверху находится горизонтальная полоса главного меню. Доступные
пункты:
File->Save As…
- сохранение трек-файла
File->Close
-выход из программного модуля
Calc->Koef
-подсчет коэффициентов загрузки
При сохранении вызывается стандартный диалог сохранения файла, в
котором предлагается указать имя файла и его путь, рис. 13.
52
Рис. 13. Диалог сохранения
При нажатии подсчета коэффициентов загрузки выводится окно с
подсчитанными процентами загрузки устройств, рис. 14.
53
Рис. 14. Коэффициенты загрузки
Основная область формы служит для построения диаграмм. Статусная
строка внизу для отображения времени периода, времени до начала
периодической части и времени.
При загрузке формы происходит инициализация экземпляра класса
Imiataion для последующего взаимодействия с ним. Происходит подсчет
времен периода и времени до начала периодической части и их отображение
на статусной строке. Происходит привязка к функции перерисовки формы
функции прорисовки диаграмм, которая присутствует в объекте класса
Imitation.
При движении мышкой с зажатой кнопкой происходит изменение
внешних полей x0, y0 экземпляра класса Imitation, и форма помечается
искаженной, что влечет ее перерисовку с измененными координатами
расположения диаграмм.
При прокрутке колесика меняется поле zoom объекта класса Imitation и
форма помечается искаженной, что влечет ее перерисовку с измененным
масштабом диаграмм.
5.
ПРИМЕР ПРИМЕНЕНИЯ ПРОГРАММНОГО МОДУЛЯ ДЛЯ
АНАЛИЗА ВРЕМЕННЫХ ХАРАКТЕРИСТИК АГРЕГИРОВАННЫХ
АВТОМАТНЫХ СХЕМ
После загрузки программной системы вид формы редактора схемы и
структуры модели системы непрерывной обработки данных показан на рис.
15.
54
Рис. 15. Общий вид редактора
В левой части формы располагается дерево с перечисленными
элементами схемы и структуры, рис. 16.
Рис. 16. Дерево с элементами
55
Чтобы добавить новый компонент (Component), буфер (Buffer), шаблон
(Template), процессор (Processor) или коммутатор (Switch) необходимо
выбрать в дереве соответствующее поле и нажать правой кнопкой мышки,
появится меню с полем «Add», нажать на это поле. Пример показан на рис. 17.
Рис. 17. Добавление элемента
Подобным образом можно удалять элементы из дерева, рис. 18.
Рис. 18. Удаление элемента
В каждом элементе можно редактировать его параметры. Путем
56
редактирования параметров каждого элемента, добавлением, удалением
элементов можно полностью задать все параметры схемы и структуры
модели системы непрерывной обработки данных. Пример редактирования
параметров шаблона показан на рис. 19.
Рис. 19. Редактирование параметров шаблона
Далее когда все параметры всех элементов схемы и структуры заданы
нажимается меню Imitation->Run Imitation, рис. 20.
57
Рис. 20. Форма выбора времени моделирования
В форме выбора времени моделирования необходимо указать сколько
времени нужно выполнять имитационное моделирование. Далее до
заданного времени будет произведено имитационное моделирование,
построены диаграммы Ганта, рассчитаны времена периода и времени до
периодичной части. Вся информация будет отображена в форме
ImitationForm на рис. 21. Зеленый цвет на диаграммах означает работу
устройства, серый – ожидание данных.
58
Рис. 21. Форма имитационного моделирования
59
Заключение
Была проделана исследовательская работа по изучению работы
многопроцессорных систем обработки данных, созданы алгоритмы для
имитационного моделирования. Был написан программный модуль
имитационного моделирования системы непрерывной обработки данных,
который выполняет все поставленные задачи и успешно работает в составе
программного инструментария.
60
Список используемых источников
1. Распределенная конвейерная обработка данных: модели, реализация и
применение: отчет о НИР: рук. Ладыгин И. И.; исполн.: Мороховец Ю. Е. – М.,
2007. – 94 с. – МЭИ: № ГР 01200301524.
2. Герберт Шилдт С# для начинающих / Герберт Шилдт; – М.: Вильямс,
2007. – 679 с.
3. Герберт Шилдт Полный справочник по C# / Герберт Шилдт; – М.:
Вильямс, 2008. – 752 с.
61
Приложение А. Техническое задание.
62
Приложение Б. Исходный код программы.
63