Document 660097

ЮГО-ЗАПАДНЫЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
На правах рукописи
Борисенко Юлия Васильевна
Метод, алгоритмы и аппаратные средства
оперативного переразмещения программ в
отказоустойчивых мультикомпьютерных системах
Специальность 05.13.05 – Элементы и устройства вычислительной техники и
систем управления
Диссертация на соискание ученой степени
кандидата технических наук
Курск - 2014
2
СОДЕРЖАНИЕ
Введение ................................................................................................................... 4
1 Анализ методов и средств обеспечения отказоустойчивости
мультикомпьютерных систем ................................................................................ 9
1.1 Методы, модели и алгоритмы обеспечения отказоустойчивости в
мультикомпютерных системах ........................................................................................9
1.2
Модели отказоустойчивых мультикомпьютеров .........................................12
1.3
Методы и алгоритмы размещение задач в параллельных системах .....24
1.3.1 Постановка задачи размещения в мультипроцессорных системах
24
1.3.2 Методы и алгоритмы размещения подпрограмм в
мультипроцессорных системах ..................................................................... 28
1.4 Анализ путей аппаратной реализации размещения подпрограмм в
мультикомпьютерных системах....................................................................................35
1.5
Выводы ........................................................................................................................37
2 Метод оперативного переразмещения программ в отказоустойчивых
мультикомпьютерных системах .......................................................................... 39
2.1 Обобщенная постановка задачи переразмещения подпрограмм в
отказоустойчивых мультикомпьютерах.....................................................................39
2.2
Математическая постановка задачи переразмещения подпрограмм в
отказоустойчивых мультикомпьютерах.....................................................................41
2.3
Алгоритмы переразмещения подпрограмм с учётом отказов
процессоров и межпроцессорных связей...................................................................45
2.3.1 Алгоритм замены отказавшего процессора резервным ................. 45
2.3.2 Алгоритм переразмещения с учётом отказа процессора ............... 45
2.4 Выводы ........................................................................................................................49
3 Устройство оперативного переразмещения подпрограмм в
отказоустойчивых мультипроцессорных системах ........................................... 51
3.1 Принцип аппаратной реализации переразмещения подпрограмм в
отказоустойчивых мультикомпьютерах.....................................................................51
3.2
Структурная организация акселератора переразмещения ........................52
3.3
Алгоритмы функционирования акселератора...............................................54
3.4
Устройство замены отказавшего модуля резервным .................................57
3.5
Оценка производительности и быстродействия акселератора ...............63
3
3.6
Устройство поиска кратчайшего пути обхода межпроцессорной связи
67
3.7
Оценка аппаратной и временной сложности устройства поиска
кратчайшего пути обхода отказавшей межпроцессорной связи .......................73
3.8
Выводы ........................................................................................................................79
4 Моделирование алгоритмов оперативного переразмещения в
отказоустойчивых мультипроцессорных системах ........................................... 80
4.1 Программная модель процедур переразмещения с учётом отказа
процессора и/или отказа линка ......................................................................................80
4.2
Результаты исследования эффективности алгоритма планирования
размещения ...........................................................................................................................81
4.3
Результаты исследования эффективности алгоритма переразмещения
с учётом отказа процессора и/или отказа линка .....................................................87
4.4
Выводы ........................................................................................................................89
Заключение ............................................................................................................ 90
БИБЛИОГРАФИЧЕСКИЙ СПИСОК ................................................................. 92
Приложение 1 ...................................................................................................... 101
4
Введение
Актуальность темы. Отказоустойчивые мультикомпьютерные системы
(ОМС) – одно из перспективных направлений развития параллельной вычислительной техники. ОМС способны непрерывно функционировать в условиях отказа отдельных узлов и каналов связи без необходимости проведения
восстановительного ремонта за счет наличия в их архитектуре специальных
аппаратно-алгоритмических средств, позволяющих автоматически обнаруживать отказы, выполнять их изолирование (и замещение резервными ресурсами) и обеспечивать восстановление логической целостности коммуникационной среды. Благодаря этим свойствам ОМС могут успешно применяться в
качестве основы для создания критических важных объектов (критических
систем, а именно: бортовые системы управления, системы управления опасными производствами и технологическими процессами и т.п.).
Теория отказоустойчивой организации мультикомпьютерных систем достаточно хорошо разработана. Большой вклад в эту область внесли работы
отечественных ученых: С.И. Баранова, Вл.В. Воеводина, В.В. Воеводина,
Ю.Ю. Громова, А.В. Каляева, И.А. Каляева, И.И. Левина, В.Г. Хорошевского, И.В. Зотова, а также зарубежных ученых: М. Флинна, К. Ванга, Р. Лонгботтома, Д. Скилликорна и др. Однако вопросы, связанные с распределением
резервных ресурсов в структуре системы, локализации отказов модулей и
связей, а также перераспределения множества выполняемых подпрограмм в
поле работоспособных модулей в этих работах рассмотрены недостаточно.
Отказы процессорных модулей и связей ОМС приводят к появлению неоднородностей в ее физической структуре. В результате уменьшается количество возможных маршрутов передачи данных, при этом возрастает их
средняя длина, что усложняет маршрутизацию данных между работоспособными модулями после реконфигурации системы. Как следствие, увеличивается среднее время межпроцессорного обмена и снижается реальная производительность системы. Одним из путей преодоления указанных послед-
5
ствий отказов является переразмещение выполняемых системой программ на
множестве работоспособных модулей с минимизацией времени межпроцессорного обмена. Переразмещение должно осуществляться за минимально
возможное время с тем, чтобы сохранялась оперативность восстановления
системы после возникновения отказов.
Задача переразмещения имеет высокую вычислительную сложность изза ее комбинаторного характера, поэтому, учитывая жесткие временные
ограничения, целесообразно полностью перенести ее решение на аппаратный
уровень. Аппаратные решения аналогичных комбинаторных задач хорошо
известны, однако они не позволяют минимизировать время межпроцессорного обмена в условиях неоднородности и изменяемости физической структуры
ОМС под воздействием локальных отказов после выполнения реконфигурации с включением резервных модулей.
Таким образом, существует противоречие между объективной необходимостью повышения отказоустойчивости мультикомпьютерных систем и
недостаточными возможностями существующих средств по обеспечению
оперативной реакции на отказ с сохранением высокой реальной производительности системы.
В соответствии с вышеизложенным актуальной является научная задача разработки методов и аппаратных средств оперативного переразмещения
выполняемых системой программ на множестве работоспособных модулей (с
учетом резерва), обеспечивающих минимизацию времени межпроцессорного
обмена данными после ликвидации последствий отказа.
Цель диссертации: снижение времени восстановления структуры мультикомпьютерной системы после возникновения отказов путем разработки
метода и аппаратных средств оперативного переразмещения выполняемых
программ на основе целенаправленной пошаговой минимизации отклонения
времени межпроцессорного обмена данными от теоретической нижней оценки этого времени.
6
Объект исследования: отказоустойчивые мультикомпьютерные системы.
Предмет исследования: методы, алгоритмы и аппаратные средства размещения программ в отказоустойчивых мультикомпьютерных системах.
Работа выполнена по плану инициативных НИР 2009–2013 г.г. кафедры информационных систем и технологий Юго-Западного государственного
университета.
Задачи исследований:
1. Анализ методов и аппаратных средств обеспечения отказоустойчивости мультикомпьютерных систем, реконфигураций структуры ОМС при отказах, размещения программ на множестве процессорных модулей. Обоснование направления исследований.
2. Разработка метода оперативного переразмещения программ в мультикомпьютерных системах, обеспечивающего минимизацию времени межпроцессорного обмена данными с учетом текущего распределения отказовых
неоднородностей физической структуры системы.
3. Создание аппаратно-ориентированного алгоритма оперативного переразмещения программ в ОМП, реализующего разработанный метод, а также программной модели указанного алгоритма, позволяющей исследовать
его функционирование при различных комбинациях отказов.
4. Разработка структурно-функциональной организации специализированного устройства оперативного переразмещения программ после возникновения отказов в ОМС, оценка аппаратной сложности устройства, сравнительный анализ временных затрат на переразмещение программ в ОМС на
аппаратном и программном уровнях.
Результаты, выносимые на защиту, и их научная новизна:
1. Метод оперативного переразмещения программ в отказоустойчивых
мультикомпьютерных системах, основанный на диагональном распределении
множества резервных модулей (скользящего резерва) непосредственно в
7
матрице процессоров, новизна которого заключается в минимизации времени
межпроцессорного обмена данными путем целенаправленного пошагового
снижения отклонения указанного времени от нижней оценки наибольшей
частной коммуникационной задержки, вычисляемой по длине множества
статических маршрутов передачи данных с учетом текущей неоднородности
физической структуры системы.
2. Аппаратно-ориентированный алгоритм оперативного переразмещения программ в отказоустойчивых мультикомпьютерных системах, отличающийся реализацией поиска резервного модуля для замещения отказавшего
процессора на множестве ближайших к отказу резервных модулей.
3. Структурно-функциональная
организация
специализированного
устройства оперативного переразмещения программ в отказоустойчивых
мультикомпьютерных системах, отличающаяся наличием блоков переразмещения отказавших процессорных модулей и поиска кратчайшего маршрута
обхода, позволяющих осуществлять быстрый поиск резервного модуля для
замещения отказавшего процессора и корректировать маршруты обмена данными с учетом распределения отказовых неоднородностей в матрице ОМС.
Достоверность результатов диссертационной работы обеспечивается
корректным и обоснованным применением аппарата математической логики,
положений и методов теории множеств, графов, теории вероятностей и математической статистики, теории параллельных вычислительных систем,
теории надежности, а также подтверждается имитационным моделированием
с использованием зарегистрированных программных средств.
Практическая ценность результатов исследований:
1. Благодаря диагональному распределению множества резервных модулей непосредственно в матрице процессоров ОМС, созданный метод оперативного переразмещения программ позволяет значительно снизить время
замещения отказавших модулей резервными (время перестройки) по сравнению с методами, основанными
на введении
отдельных резервных
8
строк/столбцов (свободный захват, комбинированный захват, диагональный
захват и т.п.). При этом более высокая аппаратная избыточность системы и
несколько сниженный коэффициент использования резерва не являются критическими, поскольку последствия недостаточно оперативной реакции на отказ в системах рассматриваемого класса могут иметь катастрофический характер.
2. Разработанный аппаратно-ориентированный алгоритм оперативного
переразмещения программ в ОМС и устройство на его основе позволяют на
2-3 порядка снизить время поиска нового варианта размещения программ в
системе после возникновения отказа по сравнению с известными аналогами
(реализуемыми программно), что способствует повышению оперативности
реакции на отказ и, как следствие, увеличивает коэффициент готовности
ОМС. При этом созданный алгоритм и аппаратные средства учитывают не
только отказы процессорных модулей ОМС, но и отказы отдельных каналов
связи, что существенно расширяет область их применения.
3. Аппаратная сложность разработанного устройства для всех практически значимых случаев не превышает 106 эквивалентных вентилей (ЭВ), что
позволяет использовать его как в существующих, так и в перспективных
мультикомпьютерных системах, содержащих десятки-сотни тысяч процессорных модулей (Titan Cray XK7, IBM BlueGene/Q и т.п.).
9
1 Анализ методов и средств обеспечения отказоустойчивости
мультикомпьютерных систем
В главе рассмотрена классификация методов обеспечения отказоустойчивости мультикомпьютерных систем, структурные модели отказоустойчивых мультикомпьютеров, проведён анализ методов размещения задач в параллельных системах.
1.1 Методы, модели и алгоритмы обеспечения отказоустойчивости в
мультикомпютерных системах
Применение программируемых логических мультиконтроллеров в
устройствах группового управления критических важных объектов (критических систем), нарушение работоспособности которых в результате отказа вызывает большие материальные издержки, возможно только в том случае, если
будет обеспечиваться непрерывное управление, толерантное к отказам элемента устройства, то есть если устройства будут обладать свойством отказоустойчивости.
В рамках работы [1] под отказоустойчивостью понимается свойство
устройства выполнять возложенные на него функции при отказах его элементов.
Под d-отказоустойчивым устройством понимается устройство, которое
способно противостоять (парировать) отказам d элементов.
В работе [2] для обеспечения отказоустойчивости использовалась
структурная и информационная избыточность.
В результате развития теории надежности были сформулированы три
подхода к построению отказоустойчивых устройств, а именно: подход, основанный на использовании активной отказоустойчивости; подход, основанный
на пассивной отказоустойчивости; подход, учитывающий или сочетающий
активную и пассивную отказоустойчивость. Подход, основанный на активной отказоустойчивости, использует динамическое резервирование с контро-
10
лем функционирования работающих устройств. Пассивная отказоустойчивость обеспечивается пассивным резервированием устройства (например,
мажорированием).
Проведенные исследования, представленные в [3-6] показали эффективность скользящего резервирования со сдвигом для структурной самоорганизации матричных структур. В отличие от общего скользящего резервирования оно упрощает построение коммутаторов и сохраняет однородность
структуры и локальность связей элементов.
Статические методы обеспечения отказоустойчивости малоэффективны для применения в параллельных многопроцессорных архитектурах, поскольку они маскируют отказы и требуют значительной аппаратурной избыточности. Так, для трехканальной мажоритарной структуры требуются дополнительные аппаратурные затраты, превышающие более чем вдвое основное оборудование.
Динамические методы обеспечения отказоустойчивости эффективно
реализуются в однородных структурах при незначительных аппаратных затратах. Скользящее резервирование, являющееся лучшим инструментом повышения надежности устройств из однотипных элементов, дает наибольший
выигрыш в надежности. Введение резервной строки или столбца элементов
позволяет обеспечить более высокую надежность в сравнении с мажоритарными трёхканальными структурами. Исключение отказавших процессорных
элементов и подключение резервных осуществляется с помощью алгоритмов
реконфигурации. Под восстановлением исходной логической структуры связей распределенными средствами управления понимается структурная самоорганизация многопроцессорного устройства. При этом структурная самоорганизация достигается с помощью дополнительного встраиваемого в структуру мультипроцессора коммутатора, обеспечивающего коммутацию каналов
между исправными процессорными элементами логической структуры. При
разработке топологии мультипроцессорной системы этап структурной само-
11
организации сводится к выбору топологии отказоустойчивого устройства с
требуемой отказоустойчивостью, в которой возможно размещение исходной
логической структуры.
Согласно [45] организация хранения и доступ к распределенным программным модулям задач могут быть осуществлены несколькими способами:
хранением программных модулей в общей памяти для устройства и их перемещения в процессоры при смене режима; записью требуемых для выполнения процессором программных модулей задач в его постоянную память, с
последующим обращением к ней при смене режима; вводом буферной оперативной памяти для каждого из процессоров, в которую заранее переписываются программные модули, необходимые для выполнения следующего режима.
В работе [45] приведены основные особенности, на которых базируется
построение отказоустойчивых самоорганизующихся мультиконтроллеров,
которые включают:
1. использование структурной и алгоритмической самоорганизации
для построения отказоустойчивых мультиконтроллеров;
2. применение скользящего резервирования со сдвигом для выполнения структурной самоорганизации, что существенно снижает избыточность;
3. организацию перестройки топологии путём коммутации сообщений,
а не каналов без применения дополнительных встраиваемых коммутаторов,
что обеспечивает сохранение исходных физических связей между элементами;
4. применение распределённого управления для перестройки топологии мультиконтроллера при смене комбинации отказов процессоров и формирования виртуальных адресов с помощью аппаратных средств по состояниям только соседних элементов;
5. использование связности каждого элемента с каждым путем замены
отказавшего элемента соединительным для решетчатой топологии;
12
6. организацию управления средствами коммутации сообщений между
взаимодействующими процессорными элементами в многопроцессорном
устройстве с отказами без применения таблиц соответствия виртуальных и
физических адресов абонентов;
7. использование статического перераспределения задач при отказах в
перестроенном многопроцессорном устройстве для алгоритмической самоорганизации, обеспечивающего быстрый переход к новому плану функционирования;
8. организацию смены режима функционирования при отказах распределенным аппаратным способом, не требующим сложных управляющих таблиц и хранения в каждом из процессоров состояния всех элементов устройства;
9. хранение в каждом из процессорных элементов только ограниченного числа программных модулей, необходимых для выполнения планов реализации задач при допустимых отказовых ситуациях;
10.применение в каждом из процессоров мультиконтроллера многофункционального (многоалгоритмического) динамического автомата (микроконтроллера).
Из множества моделей реакции на отказ в случае использования критически важных объектов (критических систем), таких как системы слежения, наблюдений, контроля и т.д. необходимо выбрать такую, которая позволит оперативно реагировать на отказовую ситуацию и в минимальные временные сроки заменять отказавший (сбойный) модуль резервным и переназначать ранее назначенные задачи (подпрограммы) на новую систему.
С этой целью рассмотрим существующие модели отказоустойчивых
мультикомпьютерных систем.
1.2 Модели отказоустойчивых мультикомпьютеров
Объектом обеспечения отказоустойчивости является мультиконтроллер
(МК), представляющий собой композицию набора микроконтроллеров, реа-
13
лизующих общий логический алгоритм управления (дискретная микроконтроллерная сеть) и коммуникационной сети связи микроконтроллеров.
Задачей коммуникационной сети является организация обмена управляющими сообщениями между микроконтроллерами.
Применение мультиконтроллеров для управления наборами объектов
управления (ОУ), реализующих дискретные технологические и информационные процессы в реальном масштабе времени, допустимо, если отказавшие микроконтроллеры (МК) не приводят к нарушению функционирования
МК и его останову. Остановы при управлении в реальном времени вызывают
необратимые изменения в управляемом процессе и значительные материальные потери. Для обеспечения безостановочного (непрерывного) функционирования мультиконтроллера, он должен строиться как отказоустойчивый, то
есть нечувствительный к отказам отдельных его элементов.
В настоящее время сформулировано три подхода к построению отказоустойчивых устройств.
Представим структурную модель отказоустойчивого мультиконтроллера (рис. 1.1).
ССО
ИМК
Рис. 1.1. Структурная модель отказоустойчивого мультиконтроллера
Ядром отказоустойчивого мультиконтроллера является избыточный
МК (ИМК). Для реализации динамического, статического или комбинированного резервирования используется аппаратурная избыточность – избыточное число микроконтроллеров и модулей памяти МК. Условно будем счи-
14
тать, что в каждом модуле памяти содержится программный модуль (ПМ)
для реализации частного алгоритма управления. Восстановление правильного поведения мультиконтроллера после возникающих отказов обеспечивается самоорганизующей оболочкой (СОО) (рис. 1.1). Под самоорганизацией
будем понимать адаптацию, проводимую путем перестройки структуры и
функций. СОО реализует действия по коррекции отказов в соответствии с
примененным в избыточном мультиконтроллере методом резервирования.
Управляющие воздействия в зависимости от метода поступают с МК, либо из
самоорганизующего слоя.
Выбор метода резервирования зависит не только от предъявляемых
надежностных и временных требований, но и во многом определяется структурой неизбыточного устройства, Мультиконтроллер представляется решеткой микроконтроллеров (рис. 1.2).
11
12
…
1n
21
12
…
1n
…
…
…
…
m1
m2
…
mn
1
Рис. 1.2 Структура мультиконтроллера
Узлам решетки соответствуют микроконтроллеры, координаты, расположения которых соответствуют их физическим номерам. Номера выполняемых программных модулей в микроконтроллерах соответствуют их физическим номерам. Связи между микроконтроллерами соответствуют ребрам решетки.
Для регулярных структур указанные методы могут применяться на
уровне как каждого микроконтроллера (рис. 1.3а), так и всего мультиконтроллера в целом (рис. 1.3б).
15
При охвате каждого микроконтроллера самоорганизующий слой является распределенным и представляет набор мажоритарных органов (МО)
(рис.1.3а), служащий для восстановления результатов выполнения ПМ при
отказах отдельных элементов. При децентрализованном методе самоорганизации обеспечивается минимальное время самоорганизации мультиконтроллера, минимальная сложность самоорганизующий оболочки, простота связей
распределенных элементов самоорганизующего слоя (мажоритарных органов) с микроконтроллерами и высокая гибкость отказоустойчивого мультиконтроллера.
МК
МК
МК
МО
ОММК
ММК
а)
ММК
МО
ММК
ОММК
б)
Рис. 1.3 Уровни резервирования МК при статическом методе: а) для каждого
микроконтроллера; б) для всего микроконтроллера
Под гибкостью (масштабируемостью) мультиконтроллера будем понимать способность к перестройке при изменении размерности решетки МК и
усложнении общего алгоритма управления. В данном случае при наращивании, например, числа МК перестройка сводится к подключению дополнительных микроконтроллеров к соседним МК.
Однако высокие аппаратурные затраты на построение избыточного
МК, а так же отсутствие фиксации функционального отказа мультиконтроллера существенно снижают эффект от маскирования отказов микроконтроллеров.
Мажорирование на уровне мультиконтроллера в сравнении с пассивным резервированием на уровне МК практически не имеет никаких преиму-
16
ществ. Использование меньшего числа мажоритарных элементов при пассивном резервировании на уровне МК несущественно, так как аппаратурные
затраты на указанные элементы несоизмеримы с затратами на микроконтроллеры.
Таким образом, применение пассивной отказоустойчивости приводит к
высоким аппаратурным затратам, более чем вдвое превышающим неизбыточный вариант мультиконтроллера. Кроме того, в МК с пассивной отказоустойчивостью не контролируется наступление функционального отказа.
Под функциональным отказом будем понимать событие, заключающееся в
нарушении правильности функционирования мультиконтроллера.
Эффективным инструментом обеспечения активной отказоустойчивости является скользящее резервирование [45]. Скользящее резервирование
применяется для устройств, состоящих из однотипных элементов, и заключается в замене отказавшего элемента элементом из магазина резерва. В отличие от общего аппаратурного скользящего резервирования магазин резерва
для скользящего резервирования аппаратуры и программ включает магазин
элементов и программных модулей (рис. 1.4).
1
k
K
…
Магазин
элементов
…
1
1
p
k …
P
K…
Магазин программных модулей
Рис. 1.4. Модель общего скользящего аппаратного и программного резервирований
17
На рис. 1.4 кружками обозначены программные модули и прямоугольниками – элементы. Число аппаратурных элементов устройства может быть
произвольным, а число программных модулей должно быть равно числу элементов неизбыточного устройства. Реализация такой модели в устройстве
сопряжена со значительными аппаратурными и временными затратами.
Необходимы значительные средства на подключение каждого элемента резерва вместо каждого основного и на управление перекоммутацией. Кроме
того, необходимы значительные временные затраты на перезагрузку требуемого программного модуля из магазина резерва (памяти программных модулей) в заменяющий отказавший элемент аппаратурного резерва. В итоге отказоустойчивое устройство получается громоздким, с нерегулярной структурой, требующей значительного времени на самоорганизацию.
Снижения времени на самоорганизацию можно добиться, если включить все программные модули в каждый из резервных элементов. Однако негибкая структура отказоустойчивого устройства остается, и сохраняются
прежние недостатки предшествующей структуры. Кроме того, становятся
равнозначными основные элементы и резервные элементы структуры.
Равнозначность элементов сохраняется, если каждый из элементов может выполнять любой из программных модулей и заменять любой из элементов (рис. 1.5).
…
…
F
F
F
1
α
A
Рис. 1.5. Модель взаимного скользящего резервирования элементов и
программ
На рис. 1.5 стрелки F1, …, Fα, …, FA характеризуют настройку каждого
из элементов на соответствующую программу из множества {π1, ..., πk, …,
18
πК}. Представленная на рис. 1.5 модель позволяет эффективным образом
настраивать программные модули, для того чтобы характеристики образовавшейся структуры наименее отличались от исходных. Однако недостаток
применения такой структуры связан с существенными затратами на средства
коммутации, а также на построение самоорганизующий оболочки.
Исключить аппаратурные затраты на средства коммутации в устройствах со скользящим резервированием возможно, если восстанавливать не
физические связи между элементами после отказов, а логические (виртуальные) связи между элементами [45]. В этом случае каждый элемент после восстановления должен иметь данные о новом расположении программных модулей. Указанные данные позволяют передавать сообщение необходимому
программному модулю по физическому номеру элемента, в котором он находится. Для создания таких данных СОО передает сообщение, содержащее
номер элемента устройства и адрес нового исполняемого программного модуля. Время передачи указанных сообщений затягивает процесс самоорганизации, возрастающий с увеличением числа элементов устройства. Организация обхода отказавших элементов, формирование физического адреса сообщения по адресу программного модуля, обеспечение их хранения в элементе
приводит к модификации и существенному усложнению коммуникационного
блока каждого элемента устройства со скользящим резервированием. Выполнение эффективной настройки элементов приводит к сложной структуре
самоорганизующей оболочки устройства.
Отказоустойчивое устройство с взаимным скользящим резервированием элементов и программных модулей [45] можно представить следующей
обобщенной схемой (рис. 1.6).
На рисунке 1.6 блок ОЭ соответствует основным элементам устройства, блок ДЭ – дополнительным, ШН – шине настройки элементов и формирования памяти адресов элементов с соответствующими номерами про-
19
граммных модулей. В блок СОО поступают сигналы отказов основных и дополнительных элементов.
ОЭ
ДЭ
…
…
СОО
Рис. 1.6. Обобщённая схема устройства с взаимным скользящим резервированием элементов и программных модулей
В настоящее время предложен метод скользящего резервирования со
сдвигом, позволяющий с некоторой потерей эффективности при распределении программных модулей, но со значительным снижением аппаратурных
затрат на построение каждого элемента устройства и СОО реализовать отказоустойчивый МК. Структура избыточного МК для построения отказоустойчивого устройства указанным методом представляет исходную решетку элементов, дополненную столбцом и/или строкой дополнительных элементов.
Модель скользящего резервирования со сдвигом заключается в следующем.
Для каждого элемента устройства имеются элементы замены, являющегося
его соседями. Так, элементами замены для каждого основного элемента могут быть элементы, расположенные справа, вверху и по диагонали вправо
(рис. 1.7). Для каждого соседнего элемента аналогичное расположение элементов замены. Граничными элементами замены являются резервные.
При отказе каких-либо элементов устройства в соответствии с правилами самоорганизации [45] выполняется замена и восстановление структуры
(рис. 1.8).
20
Рис. 1.7. Модель скользящего резервирования со сдвигом
Рис. 1.8. Схема организации замены отказавших элементов при скользящем резервировании со сдвигом
На рис. 1.8 окружностями показаны программные модули, выполняемые элементами. Двойными прямоугольниками изображены резервные элементы. Процесс самоорганизации сводится к образованию путей замены от-
21
казавших элементов работоспособными, заканчивающихся в резервном элементе. Так, на рисунке элемент 3.1 заменяется элементом 2.2, 2.2 – 1.3, 1.3 –
1.4, 3.2 -2.3, 2.3 – 2.4, 4.1 – 4.2, 4.2 – 3.3, 3.3 – 3.4, 4.3 – 4.4. Заменившие элементы выполняют программные модули, ранее выполнявшиеся в этих позициях. В результате проводимых замен запас резерва исчерпывается. Для организации скользящего резервирования со сдвигом каждый элемент хранит
не все множество ПМ, а только соседних элементов. Самоорганизующая
оболочка реализует существенно более простой алгоритм, нежели в методе с
взаимным скользящим резервированием. Это объясняется тем, что для каждого заменяемого элемента анализируется возможность «захвата» элемента
для выполнения его ПМ только из множества соседних элементов, а не всех
элементов решетки.
Идентичность правил выбора «захватываемого» элемента для всех элементов устройства позволила построить самоорганизующую оболочку, представляющую распределенную сеть элементов самоорганизации. Указанное
обстоятельство обеспечило возможность существенно повысить гибкость отказоустойчивого устройства, реализующего метод скользящего резервирования со сдвигом.
Анализ известных алгоритмов самоорганизации элемента оболочки показал, что сигнал «захвата» зависит от состояний «работоспособность/отказ»
соседних элементов, а также состояния «захват резерва/отказ от захвата» при
сдвиге заменяемых элементов в горизонтальном направлении. Ситуация отказа от захвата характеризует событие захвата работоспособным элементом
отказавшего на пути замены (1.9).
Рис. 1.9 Схема возникновения отказа от захвата резервного элемента
22
Указанное событие фиксируется в случае появления пары расположенных друг над другом отказавших элементов или захваченного элемента и отказавшего. Сообщение об указанной ситуации передается всем элементам,
расположенным левее такой пары. Для обхода критичной пары отказавший
элемент, расположенный левее, захватывает элемент, находящийся сверху по
вертикали или диагонали в зависимости от состояния «работоспособен/отказ» и приоритетности направления замены.
Выбираемые направления замены обведены на рис. 1.10.
Рис. 1.10 Схема отказоустойчивого мультиконтроллера, реализующий скользящее резервирование со сдвигом
В результате в самоорганизующем слое (рис. 1.10) каждый его элемент
связан с соседним сигналами «захвата», «захвата резерва» (жирные линии).
Каждый элемент самоорганизации анализирует состояние «своего» и соседних микроконтроллеров и посылает сигнал настройки в «свой» МК.
На рисунке 1.10 элементы самоорганизации показаны кружками, микроконтроллеры – прямоугольниками. Массовые параллельные вычисления
настроек МК в сети элементов СОО позволяют минимизировать время самоорганизации.
Недостаток такой структуры – сложность и неоднородность связей самоорганизующий оболочки с микроконтроллерами и элементов самоорганизации между собой.
23
Структура отказоустойчивого мультиконтроллера с самоорганизующим слоем, реализующим эффективный алгоритм замены микроконтроллеров, приведена на рис. 1.11.
Рис. 1.11. Структура отказоустойчивого мультиконтроллера с
самоорганизующим слоем, реализующим эффективный алгоритм замены
микроконтроллеров
Особенностью рассматриваемого метода является его программонезависимостъ, являющаяся неотъемлемым свойством отказоустойчивых систем
с непрерывным функционированием, а значит невозможностью применения
в критических важных объектах (критических системах), где причина и тип
отказа непредсказуемы, а реакция на отказ во времени должна быть как можно меньше.
В случае возникновения сбойной ситуации в рассматриваемых системах необходима оперативная замена отказавшего модуля резервным в соответствии с выбранной отказоустойчивой организацией. Однако будет показано ниже, при возникновении сбоя изменяется топология системы, что неизбежно приведет к сбою ее работы. В этом случае необходимо оперативное
переразмещение ранее назначенных задач (программ, подпрограмм и т.д.) на
новую топологию многопроцессорной системы.
Поэтому на следующем этапе необходимо рассмотреть существующие
виды топологий многопроцессорных систем и существующий методы и ал-
24
горитмы размещения задач (программ, подпрограмм и т.д.) в многопроцессорных системах.
1.3 Методы и алгоритмы размещение задач в параллельных системах
1.3.1 Постановка задачи размещения в мультипроцессорных системах
Планирование оптимального размещения задач по множеству обрабатывающих процессоров – важный этап в процедурах подготовки комплекса
взаимодействующих программ к параллельной обработке в мультикомпьютерах и кластерных системах. Оно выполняется с целью минимизации величин коммуникационных задержек, обусловленных способом обмена данными
между задачами в ходе их обработки путем передачи сообщений между процессорами. Неудачное распределение задач между процессорами может привести к появлению длинных составных и перекрывающихся маршрутов транзитной передачи данных, возрастанию коммуникационных задержек и существенному снижению степени ускорения обработки, ожидаемой от распараллеливания.
Быстрое восстановление правильности функционирования системы путем реконфигурации ее структуры с отключением неисправного процессора
и заменой его резервным, расположенным обычно вне поля обрабатывающих
процессоров, приводит к существенному изменению конфигурации связей
между ними и образованию длинных и перекрывающихся маршрутов передачи данных. Они могут быть уменьшены и разнесены путем оперативного
переразмещения задач. В то же время процедуры планирования размещения
являются комбинаторными, имеют большую вычислительную сложность и
поэтому могут привести к существенному увеличению времени восстановления и снижению коэффициента готовности системы.
Построение параллельных систем (ПС) с распределенной памятью сталкивается с ограниченными возможностями коммуникационной сети в обеспечении быстрых передач данных [12]. Это, в свою очередь означает, что
25
стремление увеличения быстродействия за счёт использования в системах
большого числа процессоров может быть несовместимо в условиях применения конкретного набора задач с возможностями конкретной коммуникационной сети. Это также означает, что любая вычислительная система будет эффективной только на определённом классе алгоритмов и методов.
Стремление эффективно решать задачи в ПС должно сопровождаться
согласованием структуры задач и архитектуры (топологии) вычислительных
систем. В противном случае, необходимая эффективность может быть не достигнута из-за возрастания коммуникационных задержек переда данных. В то
же время, существует множество видов топологических организаций ПС и
методов размещения, дающих множество абсолютно неравнозначных способов решения, из которых необходимо выбрать подходящую с точки зрения
типа решаемых задач.
Поэтому первоначально рассмотрим топологический аспект задачи размещения.
Простейший вариант топологии – цепочечная организация (линейка)
[3,4]. Привлекательной данный вариант является с точки зрения простоты организации и как следствие малой сложности. Более того, цепочка легко расширяется с помощью добавления в нее любого количества процессорных модулей. С другой стороны, процессоров не может слишком много (не более
10-15) из-за присутствия одного канала связи и как следствие увеличения задержки при передаче сигнала через процессоры. Еще один недостаток заключается в присутствии всего одной линии связи и, следовательно, при выходе из строя любого процессорного модуля вся система выходит из строя.
Эти недостатки являются причиной того, что такие топологии практически
не используются. Тем не менее, цепочка важна, например, в матричных системах, так как любую строку или столбец можно рассматривать как линейку
(рис.1.12а-в).
26
Вариантом линейной организации является кольцо, в котором первый и
последний процессоры соединены [3,5-10]. Такой организации свойственны
теже достоинства и недостатки что и у цепочки, а именно: малая сложность,
легкость в наращивании, простота маршрутизации и т.п. Также как и линейку, кольцевую топологию можно рассматривать как часть матрицы. Тем не
менее, как и в линейке в таких системах не может более 10-20 процессорных
модулей, так как также как и в линейке, кольцо обладает низкой надежностью.
Альтернативой ПС с простой топологической организацией является
шинная архитектура. В таких системах единственный тракт передачи информации – единая магистраль, называемая шиной. Преимуществом таких топологий является независимость подключенных процессорных модулей и простота увеличения или уменьшения их количества. Это преимущество одновременно является основным недостатком такой организации, так производительность ограничена пропускной способностью шины как единственного
канала передачи информации. Поэтому такие топологии также как и линейку
и кольцо используется для относительно небольшого количества процессоров (10-20) [3, 11].
В случае использования большего количества процессоров (20-100)
применение топологий, описанных выше невозможно, и находят применение
топологии, представленные на рис. 1.2а-в. Как видно из рисунка маршрутов
передачи информации в таких системах гораздо больше, что позволяет строить более надежные системы, так как в случае отказа одного из процессоров
или межпроцессорной связи система остается работоспособной и сохраняет
возможность передачи информации в необходимый процессорный модуль
[4]. Кроме того, в таких системах возможно использование резервных процессорных модулей для общего повышения надежности.
27
а)
б)
в)
Рис. 1.12. Топологии параллельных матричных систем средних и больших
размеров
На рисунке 1.12а представлена система с матричной двунаправленной
организацией, а на рисунке 1.12б – с однонаправленной организацией. На
рис. 1.12в представлена матричная полносвязная система, в которой каждый
процессорный модуль соединен с каждым из восьми соседних процессоров.
В таких структурах каждому процессорному модулю соответствует номер
строки и столбца. В двунаправленных структурах передача информации
происходит в обоих направлениях (рис.1.12а), либо только в одном
(рис.1.12б). Как отмечалось выше, каждую строку или столбец можно
рассматривать
отдельно
как
кольцо
или
линейку.
Структуры,
представленные на рисунке 1.12в позволяют строить системы повышенной
отказоустойчивости за счет возможности передачи практически в любом
направлении и одновременно минимизировать общий трафик за счет выбор
оптимального маршрута передачи [17].
Базовые многопроцессорные блоки мультикомпютерных критических
систем как правило строятся по матричной топологии различных модификаций [45], так как они позволяют за сравнительно оптимальное время вычислять задачи, требующие минимальное время реакции вычислительной системы. Это в свою очередь позволяет реагировать на отказы и/или сбои межпро-
28
цессорных модулей за время, адекватное для оперативного решения выполняемой задачи.
1.3.2 Методы и алгоритмы размещения подпрограмм в
мультипроцессорных системах
На содержательном уровне задача размещения может быть представлена
как выбор такого варианта распределения задач между модулями ПС,
которому будет соответствовать минимальное время выполнения комплекса
взаимодействующих задач в целом [3, 5-8, 12-14,25,32-40].
При выполнении задачи размещения возникает ряд особенностей, которые необходимо учитывать при постановке задачи размещения. Они состоят
в следующем. Большое значение оказывает внутреннее взаимодействие подзадач (программ, подпрограмм, объема передаваемой информации и т.д.)
друг с другом, которое необходимо минимизировать. В этом случае, очевидно, желательно, чтобы подзадачи, которым свойственно наиболее интенсивное назначались на соседние процессорные модули. Это в свою очередь позволит сократить очереди, снизить время ожидания и в итоге позволит повысить скорость решения всей задачи в целом и повысить общую производительность системы.
С учетом выделенных факторов исходную задачу размещения можно
представить следующим образом. Найти такой способ распределения
подзадач между модулями ПС, который минимизирует [3]
 интенсивности взаимодействия между смежными процессорными
модулями;
 расстояния между подзадачами, которым свойственен наибольший
объем передаваемых данных.
Одним из ключевых вопросов, возникающих при решении задачи
размещения, является выбор адекватной модели представления размещаемой
задачи.
29
Исходную задачу принято представлять графом [5-7]. Традиционно
выделяют граф предшествования задач и граф взаимодействия задач. Граф
взаимодействия задач представляет собой множество вершин, соединенных
дугами. Вершины в данном случае могут означать участки исходной задачи
(программы, подпрограммы, файлы для передачи, объемов данных для передачи и т.п.), а дуги в этом случае показывают связь вершин и обычно означают передачу некоторой информации в зависимости от предназначения
вершины графа. Дуге графа, как правило, ставится в соответствие некоторое
число, которое может означать объем передаваемой информации, количество
бит и т.п. Граф предшествования задач показывает упорядоченность множестве участков.
Граф предшествования задач в отличие от графа взаимодействия задач
проявляется в динамике выполнения задачи и может использоваться, например, для построения расписания выполнения некоторых событий, где следующее событие может произойти только после завершения предыдущего.
Другим важным аспектом разработки субоптимального варианта размещения является выбор метода размещения, подходящего для решаемого
комплекса задач.
Принято различать подходы к размещению по следующим признакам
[7, 16, 17]: 1) по степени точности получаемого результата (методу решения
математических задач размещения); 2) по характеру процесса размещения
(способу формирования решений задач размещения); 3) по степени однородности ПС. Эта классификация представлена на рис. 1.17. В свою очередь
каждая категория подразделяется на отдельные подкатегории. Так, методы по
степени точности делятся на точные и приближенные. В свою очередь, точные методы подразделяются на графо-теоретические, математического программирования и ветвей и границ. Приближенные методы в зависимости от
способа формирования размещения включают: последовательные, параллельно-последовательные и итерационные методы.
30
Работа [18] посвящена «смежному размещению». Повышение пропускной способности системы предложено достичь выделением групп процессоров для заданного набора задач. При этом предложено ввести понятие
«внешней» и «внутренней» фрагментации. Считается что «внешняя» фрагментация присутствует, когда для решения требуется большое количество
процессоров, а «внутренняя» – когда некоторое количество процессоров свободно для решения некоторой задачи, но использование их невозможно. Для
устранения этого противоречия предложено использовать альтернативные
стратегии размещения: случайная, страничная, Multiply Buddy Strategy, методика скольжения структур и метод First fit и Best Fit.
Принято различать методы размещения по следующим признакам: 1)
по характеру процесса размещения 2) по степени однородности 3) по степени
точности.
По характеру процесса размещения подходы бывают динамические и
статические, по однородности – однородные и неоднородные подходы, а по
точности – точные и приближенные.
Например, к точным можно отнести работы, описанные [19-22]. Особенностью таких методов состоит в нахождении оптимальных решений за
счет значительной временной сложности. В связи с этим они применяются
лишь в случаях, когда размер многопроцессорной систем невелик (10-20
процессоров). Кроме того, в точных методах существует классификация методики поиска оптимальных решений: графо–теоретические [20-55]; математическое моделирование [19, 26] и ветвей и границ [23].
Как следует из названия, графо–теоретический метод для вычислений
использует граф и операции связанные с графом. Недостатком таких методов
является высокая сложность вычислений и как следствие длительное время
решения.
В работе [21] выполняется минимизация суммы вычислительных и коммуникационных затрат. При этом используется сетевой потоковый подход
31
Стоуна [24]. Основная идея предложенного подхода заключается в трансформации исходной задачи в двухтерминальную сетевую потоковую задачу,
после чего применяется алгоритм Голдберга-Тажана. Фактически предложенный подход учитывает только интенсивность взаимодействия без учета
длины связей и конкретной исходной топологии, чего нельзя допускать в
критических системах.
Представителем методов математического программирования является
работа [18]. Идея таких методов основана на полном переборе всех возможных вариантов размещения. Основным недостатком таких методов является
большие затраты на время поиска и емкость памяти, необходимой для хранения основных и промежуточных результатов вычислений. В работе [18] вычисления проводятся с учетом требований к емкости памяти и реальному режиму времени. В тоже время не учитываются такие особенности как формирование очередей, приоритеты и старшинство процессоров.
В [19] описана процедура размещения прикладных задач между
процессорами в распределенных компьютерных системах, основанная на
идеях метода ветвей и границ. Метод позволяет обеспечивать: 1) минимум
межпроцессорного взаимодействия, 2) сбалансированное использование
каждого процессора. Рассматривается процедура размещения, основанная на
технике бивалентного программирования и методе ветвей и границ. Для
заданной конфигурации системы ПС и набора ограничений находится
оптимальное решение для комплекса взаимодействующих задач средней
размерности. Для больших комплексов задач размещение выполняется
приближенно. Метод решения математических задач размещения для ПС состоит из следующих этапов: 1) оценка степени межпроцессорного
взаимодействия и затрат на обработку данных; 2) формулировка набора
ограничений,
встречающихся
в
различных
прикладных
задачах;
3)
реализация итерационного алгоритма для нахождения общего решения.
Функция оценки формулируется как сумма затрат на межпроцессорное
32
взаимодействие и вычислительные затраты. Технология метода ветвей и
границ представляет задачу размещения в виде поиска на дереве решений.
Целью приближенных методов [27-30] является поиск решений близких к оптимальному по какому-либо критерию и главное не требующих длительных временных затрат. Такие методы позволяет выполнять размещения
для задач с большим количеством процессорных модулей, но в тоже время
они не могут быть использованы для критических систем или систем реального времени, где решение должно быть как можно более точным и одновременно за как можно более короткое время.
Так же как и точные методы, приближенные подходы делятся на несколько подклассов [27-30], к которым можно отнести: последовательные [27], параллельно-последовательные и итерационные [28]. Коротко опишем каждый из
них.
В основе последовательных алгоритмов лежит пробный последовательный перебор и фиксация вершин и соответствующих им дуг модели. Результатом перебора является вершина для окончательной фиксации. На следующем этапе аналогично происходит пробная попытка фиксации следующей вершины и т.д. Недостатком таких алгоритмов являются решения невысокого качества и следовательно в критических системах они не могут быть
использованы.
Итерационные методы рассмотрены в [28]. В таких методах варианты
решения могут быть различны. Например, это могут быть парные перестановки и/или групповые перестановки. В итоге фиксация происходит на основе сравнения нового решения с ранее полученным и выбором лучшего из
них. По сравнению с последовательными методами итерационные дают более качественные решения, но за счет больших временных затрат.
В эвристическом алгоритме, рассмотренном в [28] для перестановок
используется матрица смежности графа, описывающая исходную задачу. В
результате выходным решением является тоже матрица смежности, соответ-
33
ствующая полученному варианту решения задачи. В матрице выполняются
вероятностные парные перестановки. Если вероятностный переход улучшает
решение, оно принимается и процесс повторяется заново. Недостатком такого подхода является возможность достижения ситуации «тупика», в случае
чего процесс поиска прекращается. Это является недостатком такого подхода.
Размещение для однородных структур рассмотрено в [23, 27, 28, 23], а
для неоднородных – в [21, 31-33].
В [23] предлагается сетевой алгоритм для матричных сетей.
Размещение в матричных сетях выполняется с использованием алгоритма Голдберг-Таржана для каждой задачи. Авторы обосновывают, что однородная сеть может быть представлена из нескольких процессоров с собственной памятью. Исходная задача задается графом взаимодействия, задающего матричную сеть. Далее из этой сеть формируется линейная матричная
сеть, после чего из нее образуется сетевой граф. Этот граф образуется за счет
добавления n вершин, причем каждая соответствует отдельному процессору.
В конечном итоге применяется сетевой алгоритм для каждого сетевого графа,
а множество (n-1) сечений весов определяют итоговый вариант размещения.
Размещение для неоднородных структур рассмотрено в [31]. При этом
для решения приняты ограничения:
– использования неоднородных процессоров;
– межпроцессорные связи в системе неоднородны;
– использование не полносвязной процессорной топологии;
– минимальные требования к синхронизации программ/подпрограмм.
Основная идея предложенного метода и алгоритма заключается в использовании критерия минимакса при размещении.
Анализ описанных методов размещения задач в параллельных системах
позволяет сделать вывод о том, что они приводят к достаточно большим временам поиска. Это препятствует быстрому динамическому переразмещению
34
задач в случае отказа какого-либо процессорного модуля. В связи с этим целесообразно перенести решение задачи размещения на аппаратный уровень и
разработать метод многократного снижения вычислительной сложности процедур планирования размещения задач по процессорам матричных базовых
блоков кластерных критических систем.
Это может быть достигнуто на основе итерационного метода субоптимального размещения [28] за счет допустимого увеличения снижения выигрыша в снижении коммуникационных задержек по сравнению с известными
методами точного оптимального размещения [19-22].
Планирование размещения предшествует маршрутизации сообщений и
должно создавать необходимые качественные предпосылки для прокладки в
топологии ПС наиболее коротких параллельных маршрутов без их перекрытия (наложения) в одном и том же канале связи между смежными процессорными модулями [3].
Из рассмотренных в п. 1.3 алгоритмов размещения можно сделать следующие выводы. Они имеют приемлемые результаты при их программной
реализации. В случае использования критических систем (системы наблюдения, слежения, контроля и т.д.) из-за выхода из строя (сбоя) одного из внутренних модулей, когда время реакции системы должно быть минимальным
применение программных способов замены отказавшего модуля резервным
либо переразмещение задач (программ, подпрограмм и т.д.) на новый вариант топологической организации неприменимо из-за длительного времени
решения. Кроме того, , количество внутренних модулей например в системах
бортовой авиации исчисляется несколькими сотнями. Решением может быть
применение соответствующих специализированных аппаратных средств резервирования и переразмещения. В связи с этим ниже рассмотрим существующие аппаратные средства.
35
1.4 Анализ путей аппаратной реализации размещения подпрограмм в
мультикомпьютерных системах
Как было показано выше, рассмотренные известные методы и алгоритмы требуют больших затрат времени на выполнение перебора значительного
числа вариантов размещения. В мультикомпьютерных критических системах
вариант размещения должен быть получен за минимальное время. В случае
отказа одного из процессоров системы и оперативной замене его резервным,
как было показано в п.п. 1.1.-1.3 изменяется топология, что приводит к необходимости оперативного переразмещения ранее назначенных подпрограмм.
Реализация этого вопроса программным способом приводит к высоким временным издержкам и вызывает необходимость привлечения аппаратных
средств. Рассмотрим варианты реализации этой задачи с помощью аппаратных средств.
В [41] предложено устройство поиска нижней оценки размещения в
матричных системах по критерию минимизации интенсивности взаимодействия процессов и данных.
Идея предложенного критерия заключается в следующем. Согласно теории метода ветвей и границ при поиске нижней оценке дуги исходного графа
задачи назначаются на процессорные модули так, что дуги с наибольшей интенсивностью (объемах информации, количества передаваемых данных и
т.д.) назначаются на соседние процессоры не обращая внимания при этом на
ограничения, которые накладывает исходных граф задачи.
Это предположение было решено использовать при проектировании
устройства, представленное на рисунке 1.13.
36
БО
1.1
&
1.2
&
&
&
1
&
+1
СЧ9.1.1
&
2.1
1.n
&
1
&
+1
…
СЧ9.1
.2
SM
2.n
2.2
ВУУ
…
Сч1
of
+1
DC
…
7
ОС
1.1
1.2
…
of
1 +1
Сч2
2.1
2.2
…
2.n
К1
m.1
m.2
…
Сч3
oe DC
+1 1 …
C
Сч4
+1of DC …
2
oe
1.n
1
ВУУ
… m.n
m.2
m.1
m.n
S
R
MX
1
1
S
R
…
…
1
S
R
of
+1
Сч5
DC …
3
Тр1
&
…
MX
2
Сч7
+1of DC
5 …
oe
G
S
R
&
of DC …
+1 4
Сч6
+1
oe DC
6 …
C
Сч8
Рис. 1.13. Устройство поиска нижней оценки размещения в параллельных системах
В устройстве на рисунке 1.13 исходный граф задачи предложено математически представлять матрицей смежности, которое в устройстве отображает блок ОС, состоящий из множества элементов 1.1,…, m.n, где m  1, n ,
n  1, n . Матрицу процессоров отображает множество блоков 1.1, 1.2,…, m.n,
где m  1, n , n  1, n . Так как исходный граф двунаправленный, то в за нижнюю
и верхнюю ее диагональ в устройстве отвечают два разных блока элементов.
За одну половину отвечают дешифраторы DC 1 и 2, счетчики Сч 3 и 4 мультиплексор MX 1. За вторую половину матрицы смежности отвечают дешифраторы DC 5 и 6, счетчики Сч 7 и 8 и мультиплексор МХ 2. Триггер ТР1 служит для переключения режимов работы устройства, к которым относится
опрос либо верхней либо нижней диоганали матрицы.
37
Работа устройства заключается в следующем. На каждом тактовом
импульсе блок ключей К1 последовательно выбирает очередную строку блока ОС, который через линейку элементов ИЛИ записывает значения строки
матрицы смежности в линейку RS-триггеров. После этого в зависимости от
состояния RS-триггера обрабатывается либо верхняя либо нижняя диагональ
матрицы смежности с помощью соответствующего блока элементов путем
последовательного перебора элементов линейки RS-триггеров, описанных
выше. В итоге обработанные значения обоих блоков устройства суммируется
в сумматоре SM и передаются для обработки во внешнее устройство ВУУ.
Недостатком рассмотренной аппаратной реализаций алгоритма размещения является ограниченные функциональные возможности, а также применительно к критическим системам, выбор критерия при поиске варианта
размещения, недостаточного для критических систем. Здесь размещение
проводилось на основе минимизации суммарной интенсивности взаимодействия между подпрограммами, что как показано в п. 1.4 является недостаточным для критических систем. Для критических систем более подходящим
критерием является минимизация задержек на всех маршрутах взаимодействия, что невозможно гарантировать при минимизации суммы интенсивностей. Недостатком является также сравнительно большое число элементарных вентилей в устройстве. В связи с этим разработка метода переразмещения подпрограмм в отказоустойчивых мультикомпьютерных системах является актуальной научной задачей, а ее важным практическим аспектом является разработка алгоритмов и структурно-функциональной организации соответствующего устройства, позволяющего ускорить составление плана размещения.
1.5 Выводы
1. Важнейшим требованием к мультипроцессорным системам является
обеспечение высокой величины коэффициента готовности, приближающейся
к единице. Однако в случае использования отказоустойчивых систем при
38
возникновении функционального отказа необходимо оперативная реакция
системы на отказ. При этом изменяется топология системы, возрастает коммуникационная задержка и требуется перестройка ее внутренней организации. Это обусловливает необходимость оперативного переразмещения ранее
назначенных подпрограмм.
2. Существующие методы планирования размещения подпрограмм обладают большим временем поиска обусловленного большим числом вариантов перебора и решаются в основном программно, что для мультикомпьютерных критических важных объектов является неприемлемым, а это определяет необходимость разработки метода и средств обеспечивающих многократное ускорение составления плана размещения.
3. Известные аппаратные средства имеют специализированную организацию, ограниченные функциональные возможности и требуют для своей
реализации большое число элементарных вентилей. В связи с этим, целесообразно разработать структурно-функциональную организацию акселератора, которая основана на типовых БИС микропроцессорных систем и в которой увеличение размера топологии системы приводит лишь к увеличению
требуемой емкости модулей оперативной памяти.
4. Высокое быстродействие, достигаемое в известных разработках путем специализации устройств, является необходимым для контроля качества
получаемого варианта размещения, которые могут быть построены на основе
подхода, используемого при разработке известных устройств размещения,
рассмотренных в данном разделе.
39
Метод оперативного переразмещения программ в отказоустойчивых
2
мультикомпьютерных системах
2.1 Обобщенная постановка задачи переразмещения подпрограмм в
отказоустойчивых мультикомпьютерах
Отказоустойчивые логические мультиконтроллеры (ОЛМК) – одно из
перспективных направлений развития многопроцессорных управляющих
систем [48-50]. В случае отказа одного из процессорных модулей ОЛМК
осуществляется
быстрое
восстановление
правильности
его
функционирования путем реконфигурации структуры с отключением
неисправного процессора и заменой его резервным, расположенным обычно
вне
поля
обрабатывающих
процессоров.
Однако
это
приводит
к
существенному изменению конфигурации связей между процессорами и
образованию длинных маршрутов передачи данных. Такие маршруты могут
быть сокращены путем оперативного переразмещения задач [2, 3]. Оценка
времени процедуры размещения являются комбинаторной задачей, имеют
большую вычислительную сложность и могут привести к существенному
увеличению времени восстановления и снижению коэффициента готовности
системы [3,4]. Поэтому необходим поиск путей уменьшения вычислительной
сложности процедур размещения задач в ОЛМК.
Преимущества использования отказоустойчивых вычислительных
систем вытекают из необходимости продолжительной работы системы в
условиях, когда техническое обслуживание (ремонт, замена и т.д.)
невозможны,
труднореализуемы
или
сопряжены
с
большими
экономическими затратами. Поэтому ВС разрабатываются таким образом,
чтобы у системы была устойчивая обратная связь к возникающим отказам в
любых условиях функционирования.
40
При отказе процессорных модулей многопроцессорной системы
можно выделить два основных типа отказов, влияющих на выполнение
назначенной задачи:
- отказ процессора;
- отказ линка - связи между процессорами;
Идентификация отказа какого-либо процессора многопроцессорной
системы классифицируется, как отказ одного из её узлов: он изолируется на
логическом
уровне
и,
при
наличии
соответствующей
поддержки,
отключается.
Идентификация отказа линка (связи) приводит к уменьшению степени
связности узлов сети. Отказавшая связь изолируется на логическом уровне
путем изменения маршрутов передачи сообщений между узлами сети.
Предполагается, что отказы элементов обнаруживаются после их возникновения, и переключение на резерв осуществляется без прерывания работы системы. При переходе на резервный процессор акселератор, разработанный в данной работе, осущесствляет логическую функцию переназначения.
В [49] авторы считают, что при исходной интенсивности отказов
η = 0,00005 1/ч (наработка на отказ составляет 20 000 ч) и интенсивности
восстановления η = 0,25 1/ч (4 ч восстановления) значение Кг = 0,99999992,
где Кг – это коэффициент готовности. Взятая наработка 20 000 ч является
нижней планкой MTBF (MeanTime Before Failure, средняя наработка на отказ) серверных платформ. Обычно для серверов приводятся значения 50–100
тыс. часов и, следовательно, получаются чрезмерно "хорошие" результаты.
В [50] авторы считают, что кластер должен обеспечить надёжность с
99,9999% обслуживаемых запросов. Т.е. сбои составляют на 0,0001% из них.
Авторы в [50] рассмотрели кластер, состоящий из 8 узлов, обслуживающий
33,8×104 запросов в течение 10 минут. Если это экстраполировать на 24-х узловой кластер серверов приложений, то получается из 53,3×10 9 запросов обслуженных за год сбои составляют не более чем 53,3×103. Если использовать
41
перезагрузку JVM это число позволяет получить 23 сбоя на один узел в течение всего года. Если использовать микроперезагрузку – 329 допустимых
сбоя.
Таким образом, из приведенного анализа следует, что для критических
важных объектов решение проблем задачи минимизации отказов является
актуальной и в случае сбоя необходима оперативная реакция со стороны системы. Из анализа, приведенного в первой главе и п. 2.1 данной работы можно сделать вывод, что в случае отказов процессорных модулей и/или процессорных связей в критических важных объектах необходимо применение специализированных аппаратно-ориентированных подходов, так как существующие, как правило, программные подходы, неприемлемы из-за длительного
времени решения. Один из путей решения этой задачи рассмотрим ниже.
2.2 Математическая постановка задачи переразмещения подпрограмм
в отказоустойчивых мультикомпьютерах
В основе созданного метода и алгоритма переразмещения программ [5155] лежат следующие понятия и теоретические построения.
Каждая из реализуемых системой программ представляется множеством
взаимосвязанных подпрограмм. Множество подпрограмм каждой программы
описывается графом взаимодействия задач:
  X,E ,
(2.1)
где X  xi  – множество вершин, которые соответствуют отдельным подпрограммам, E  eij  – множество дуг, отражающих связи между подпрограммами.
AM  mij
Граф
N N

представляется
матрицей
смежности
вершин:
, где N  X . Значение элемента mij определяется числом со-
общений (объемом данных), передаваемых между подпрограммами xi и x j .
Топология мультикомпьютера задается графом H  P1 ,V , где множество
вершин P1 соответствует процессорным модулям, а множество дуг V – меж-
42
модульным связям. Множество P1 разбивается на два непересекающихся
подмножества P1  P  L , где P   pij  – множество основных процессоров,
L  lij 
–
множество
P  L  n 2 , n  2,3,4,
матриц pij
nn
и lij
nn
резервных
процессоров,
причем
фиксируется
. Упорядочим множества процессоров P и L в виде
соответственно. Множество P1 представим объедине-
нием указанных матриц «через столбец» следующим образом (рис. 2.1):
 p1.1 l1.1 p1.2 l1.2
 p2.1 l2.1 p2.2 l2.2

p l p l
 q.1 q.1 q.2 q.2

 pn.1 ln.1 pn.2 ln.2
p1. l1.
p2. l2.
pq. lq.
pn . l n .
p1.n l1.n 
p2.n l2.n 

pq.n lq.n 


pn .n ln .n 
P1.1
(2.2)
l1.1
l1.2
P1.2
l2.1
P2.2
l2.2
Рис. 2.1. Матричная организация мультикомпьютера с резервными модулями
P2.1
Размещение множества взаимосвязанных подпрограмм, описываемого
графом , в мультикомпьютере задается отображением
 : X  P1 ,
(2.3)
которое ставит в соответствие каждой подпрограмме один из процессоров
(основной либо резервный).
Между каждой парой процессоров матрицы (2.2) в общем случае существует множество маршрутов передачи сообщений, которые обеспечивают
разное время доставки данных между соответствующими подпрограммами. В
рамках решаемой задачи интерес представляют кратчайшие маршруты, гарантирующие минимум указанного времени. Для описания множества таких
маршрутов вводится матрица длин LM  dij
N N
, элемент dij которой чис-
43
ленно равен длине кратчайшего маршрута между процессорами, в которых
размещены подпрограммы xi и x j .
Пусть  – множество всевозможных отображений вида (2.3). Тогда задача размещения программ в мультикомпьютере будет заключаться в выборе
такого отображения  s   , которое соответствует следующему критерию:
 s  min
 
 max
i 1, N , j 1, N
d
ij

 mij  ,
(2.4)
где максимум в фигурных скобках представляет собой наибольшую частную
коммуникационную задержку для заданного отображения β.
Сущность созданного метода заключается в двухэтапном решении задачи переразмещения. На первом этапе вычисляется теоретически минимальная наибольшая частная коммуникационная задержка  min из предположения, что граф Ф размещается в мультикомпьютере без учета ограничений
связности подпрограмм (дуги графа Ф «укладываются» наилучшим образом,
т.е. так, что более высоким значениям mij соответствуют меньшие длины
маршрутов dij ). На втором этапе отыскивается вариант размещения  s , который минимизирует отклонение  s   min и, таким образом, дает локальный
минимум наибольшей коммуникационной задержки.
В случае наличия в мультикомпьютере отказавших процессоров [59-65]
размещение вычисления по формуле (2.4) для различных отображений вида
(2.3) проводятся с учетом неоднородности топологической структуры.
Например, при отказе процессора p1.2 выполняется перебор отображений вида (рис. 2.2):
 xs xs ... xs ... xs 
p l
l
 x 1.1 x 1.2 ... x 1. ... x 1.n 
 p1.1 l1.1 p l1.2
s2.1 s2.2
s2.
s2.n


 2.1 2.1 2.2 2.2
 ...

 x x ... x ... x   
sq.
sq.n
 sq.1 sq.1

 pq.1 lq.1 pq.2 lq.2
...



 pn.1 ln.1 pn.2 ln.2
 xsn.1 xsn.2 ... xsn. ... xsn.n 
p1. l1.
p2. l2.
pq. lq.
pn . l n .
p1.n l1.n 
p2.n l2.n 


pq . n l q . n 

pn .n ln .n 
(2.5)
44
В этом случае учитывается, что отказавший процессор замещается резервным, например, процессором l1,2 и изменяется множество допустимых
маршрутов передачи данных.
P1.1
l1.1
P2.1
l2.1
P1.2
P2.2
l2.2
Рис. 2.2. Матричная организация мультикомпьютера с отказавшим модулем Р1,2
Процедура замещения отказавшего процессорного модуля резервным
формализуется следующим образом.
Состояние основных процессоров
Z  zij
nn
Состояние резервных
ij
nn
описывается матрицей
:
zij 

pij  P

1, если pij неисправен;
0, если pij исправен.
процессоров
lij  L
описывается
матрицей
:
 ij 
Матрица K  kij
nn

1, если lij неисправен;
0, если lij исправен.
содержит признаки доступности ближайшего ре-
зервного модуля к процессору pij  P для замены:
kij


1, если lij недоступен;
0, если lij доступен.
45
2.3 Алгоритмы переразмещения подпрограмм с учётом отказов процессоров и межпроцессорных связей
2.3.1 Алгоритм замены отказавшего процессора резервным
С учетом введенных в п. 2.2 обозначений алгоритм замещения отказавшего процессорного модуля резервным будет состоять из следующих шагов:
ЗАГРУЗИТЬ матрицы AM и LM;
УСТАНОВИТЬ zij  ij  kij  0, i  1, n, j  1, n ;
ЦИКЛ по всем процессорам pij  P
ЕСЛИ pij  P : zij  1 , то найти в матрице  элемент  st  0 такой,
что  i  s  1   j  t  1 ;
ЕСЛИ такой  st найден, то принять  st  1 , lst  pij (замещение
успешно), иначе необходим останов системы;
КОНЕЦ ЦИКЛА
Особенностью этого алгоритма является то, что поиск резервного модуля для замещения отказа ограничивается ближайшими соседями (порядок их
перебора не является существенным).
2.3.2 Алгоритм переразмещения с учётом отказа процессора
Важным этапом созданного метода переразмещения является определение теоретической нижней оценки наибольшей частной коммуникационной
задержки min max , относительно которой осуществляется минимизация времени межпроцессорного обмена при выборе варианта размещения программ
согласно постановке задачи (4). Для вычисления указанной оценки разработан следующий алгоритм.
1. Переписать все значения d kl  0 из матрицы LM в вектор LM ' в порядке невозрастания, т.е. соблюдая условие: z1  z2 : d kz1'l '  d kz''2l ''  z1  z2 ,
где z1 , z2 – порядковые номера значений d k l , d k l в векторе LM ' .
46
2. Переписать все значения mij  0 из матрицы AM в вектор AM ' в
порядке неубывания, т.е. соблюдая условие: z1  z2 : miz'1j '  miz''2j ''  z1  z2 ,
где z1 , z2 – порядковые номера значений mi' j' , mi'' j'' в векторе AM ' .
3. По векторам LM ' и AM ' вычислить оценку min max , используя формулу:
min max  max mijz d klz ,
(2.6)
z
где mijz , dklz – элементы векторов AM ' и LM ' , расположенные в одинаковых
позициях.
В
дальнейшем
переразмещение
сводится
к
выполнению
серии
перестановок столбцов и строк матрицы AM с тем, чтобы достичь
наибольшего приближения к оценке min max . После каждой перестановки
вычисляется значение max mij  d ij  . Если найденное значение больше
предыдущего, то перестановки продолжаются от предыдущего варианта,
иначе далее рассматривается текущий вариант.
В качестве примера работы разработанных алгоритмов, рассмотрим
мультипроцессорную систему 2  2 с отказавшим модулем 2 (рис. 2.3) и соответствующую ей ММР (рис. 2.4).
1
1’
2
2’
3’
4
4’
Рис. 2.3. Матричная организация мультикомпьютера с отказавшим модулем 2
3
47
1234
10312
22021
31202
42120
Рис. 2.4. Матрица АМ для мультипроцессорной системы на рис. 2.4
Проводим поиск нижней оценки, просуммировав произведения элементов матрицы смежности и матрицы расстояния:
3 * 6 + 1 * 10 + 2 * 20 + 2 * 8 + 1 * 15 + 2 * 30 = 159.
Сравним полученные результаты, находим максимум в матрице расстояний и минимум в матрице смежности и меняем строки и столбцы местами.
Получим:
Пример матрицы смежности ЛМ
1234
10312
22021
31202
42120
Пример матрицы расстояния МА
1 2 3
1 0 10 6
2 10 0 8
3 6 8 0
4 20 30 15
С учетом вышеизложенного алгоритм
4
20
30
15
0
отказоустойчивого переразмеще-
ния программ в мультикомпьютерных системах будет состоять из следующих шагов:
1. Загрузить матрицы AM и LM;
2. Создать дополнительные матрицы M 1 , M 2 , M 3 размера N  N для
хранения новых вариантов размещения после перестановок строк и столбцов
матрицы AM: M 1 – матрица, где фиксируются проверенные элементы матрицы M 2 , а M 3 – это промежуточные матрицы.
48
3. Сформировать векторы AM ' и LM ' по матрицам AM и LM соответственно.
4. Найти оценку min max по формуле (6).
5. Вычислить коммуникационную задержку 0  max
i 1, N , j 1, N
d
ij
 mij  для
первоначального варианта размещения  0 , определяемого матрицами AM и
LM.
6. Рассчитать отношение 0 
0
min max
, если 0   (где   1 – пороговое
значение, определяющее точность решения задачи), то останов.
7. Принять   0 и M 2  AM .
8. Начать просмотр элементов вектора AM ' , начиная с элемента k  1 .
9. Пусть k-м элементом вектора AM ' является m . Найти элемент m
в матрице M 2 , определяя его положение по индексам  ,  .
10. Найти соответствующую элементу m длину маршрута d  в матрице LM.
11. Если d   1 , то (так как улучшить размещение нельзя) зафиксировать текущий элемент в M 2 как просмотренный, приняв M 2  1 . Принять
k  k  1 и если вектор AM ' не просмотрен до конца, вернуться к п.9, иначе
перейти к п.12.
12. Начать просмотр строки d  матрицы LM, с элемента j  1.
13. Если j  N , строка просмотрена, перейти к п.24.

 

14. Если d j  d  d j  0 , то перейти к п.15, иначе принять j  j  1
и вернуться к п.13.
15. Выполнить парную перестановку столбцов/строк i   в матрице
AM и сформировать новую матрицу M 1 .
49
16. Вычислить по матрице M 1 значение 1  max
i 1, N , j 1, N
d
ij
 mij . Если
1  0 , то перейти к п.17, иначе принять j  j  1 и вернуться к п.12.
17. Рассчитать отношение  
0
и если    , то останов.
1
18. Переписать матрицу M 1 в AM.
19. Принять 0  1 .
20. Зафиксировать текущий элемент m в M 2 как просмотренный:
M 2  1 .
21. Выполнить парную перестановку строк/столбцов i   в M 2 и
сформировать новую матрицу M 3 .
22. Переписать матрицу M 3 в M 2 .
23. Принять k  k  1 и если вектор AM ' не просмотрен до конца, вернуться к п.9, иначе считать, что все элементы проверены (останов).
24. Зафиксировать
текущий
элемент
в
M2
как
просмотренный
( M 2  1 ), принять k  k  1 . Если вектор AM ' не просмотрен до конца, перейти к п.9. Иначе считать, что все элементы проверены (останов).
В случае отказа отдельного канала связи между процессорами нарушаются маршруты транзитной передачи данных и необходимо найти новые
кратчайшие маршруты обхода отказавшего канала. Для этого случая обоснована целесообразность использования известного алгоритма Дейкстры.
2.4 Выводы
1. Разработаны аппаратно–ориентированные алгоритмы замены отказавших процессорных модулей резервными и поиска кратчайшего маршрута обхода отказавшей межпроцессорной связи, допускающие как программную,
так и аппаратную реализацию в зависимости от требований критических
важных объектов.
50
2. Разработан метод оперативного переразмещения программ в мультикомпьютерных системах, обеспечивающий минимизацию времени межпроцессорного обмена данными с учетом текущего распределения отказовых неоднородностей физической структуры системы. Переразмещение основано
на целенаправленных поисковых перестановках строк и столбцов матрицы
смежности, что позволяет в результате устранить заведомо неэффективные
поисковые перестановки, в результате повышает коэффициент готовности
системы.
3. Разработан аппаратно–ориентированный алгоритм отказоустойчивого
переразмещения подпрограмм в мультикомпьютерах, допускающий независимый резидентный контроль за отказами как процессорных модулей, так и
межпроцессорных связей, что в итоге допускает независимую реакцию на
отказовые ситуации в мультикомпьютерной системе.
51
3
Устройство оперативного переразмещения подпрограмм в
отказоустойчивых мультипроцессорных системах
3.1 Принцип аппаратной реализации переразмещения подпрограмм в
отказоустойчивых мультикомпьютерах
Для решения задачи отказоустойчивого переразмещения подпрограмм
в мультикомпьютерах применен параллельный отказоустойчивый акселератор переразмещения подпрограмм.
Ведущая ЭВМ мультипроцессорной системы передает в акселератор
планирования переразмещения подпрограмм (АПРП) матрицы, необходимые
для оперативной реакции системы на либо на отказ процессорного модуля
системы, либо на отказ межпроцессорной связи, а именно матрицу: смежности, расстояний, исправности процессоров, работоспособности и занятости
резервных процессоров, исправности межпроцессорных связей.
Акселератор планирования переразмещения состоит из двух независимых блоков: блока переразмещения отказавших процессорных модулей
(БПОПМ) и блока поиска кратчайшего маршрута (БПКМ) в случае отказа
межпроцессорной связи. Такое разделение акселератора на индивидуальные
блоки позволяет независимо реагировать на различные типы отказов, а именно:
1) отказ внутреннего процессорного модуля;
2) отказ межпроцессорной связи;
АПРП представляет собой аппаратный комплекс, на базе микропроцессорного контроллера и функционирует на основе алгоритмов планирования
переразмещения, описанных в п. 2.
Контроллер акселератора работает в соответствии с описанной в п. 2.4.
программой. Входными данными являются переданные через последовательный сетевой интерфейс файлы, приведённых выше матриц.
52
Результатом работы акселератора планирования размещения задач является файл конечной матрицы смежности, матрицы расстояний и матрицы исправности межпроцессорных связей, соответствующей найденному варианту
размещения и/или кратчайшего маршрута обхода.
Для подключения блока АПРП к контроллеру используется порт параллельного интерфейса типа LPT (Line PrinTer – построчный принтер). С
внешней стороны порт имеет 8-битную шину данных, 5-битную шину сигналов состояния и 4-битную шину управляющих сигналов, выведенные на
разъем-розетку DB-25S [68-69].
С программной стороны контроллера LPT-порт представляет собой
набор регистров, расположенных в пространстве ввода-вывода. Регистры
порта адресуются относительно базового адреса порта, стандартными значениями которого являются 3BCh, 378h и 278h. Порт может использовать линию запроса аппаратного прерывания, обычно IRQ7 или IRQ4. Для управления обменом данными через порт разработаны специальные алгоритмы: передачи данных в АПРП, приема данных от АПРП, передачи данных в контроллер, приема данных от контроллера.
3.2 Структурная организация акселератора переразмещения
Структурная схема акселератора отказоустойчивого переразмещения
подпрограмм с учетом отказа межпроцессорных связей представлена на рисунке 3.1.
53
ОП
КПДП
Ппорт
к управляющей
ЭВМ
МП
Прпорт
контроллер
MUX
УУ
{МО}
{А}
БПОПМ
БПКМ
АПРП
Рис. 3.1. Структурная организация акселератора отказоустойчивого переразмещения
На рисунке 3.1 приняты следующие обозначения блоков и узлов:
АПРП – акселератор планирования переразмещения подпрограмм; МП –
микропроцессор; ОП – оперативная память; КПДП – контроллер прямого доступа в память; Ппорт – последовательный порт; Прпорт – параллельный
порт; УУ – устройство управления; БПОПМ - блока переразмещения отказавших процессорных модулей; БПКМ - блока поиска кратчайшего маршрута; МО – микрооперации; А – адрес.
МП контроллера работает в соответствии с программой, записанной в
ОП и отслеживает работу критической системы. В случае возникновения отказа процессорного модуля мультипроцессорной системы, либо сбоя межпроцессорной связи соответствующие исходные данные передается в один из
блоков.
В случае поступления через последовательный порт с управляющей
ЭВМ сигнала об отказе процессорного модуля либо межпроцессорной связи
соответствующий сигнал подается в контроллер и далее в соответствии с за-
54
писанной в МП программой через параллельный порт поступает в специализированный мультиплексор MUX. MUX в зависимости от отказоустойчивой
ситуации (отказал процессорный модуль либо межпроцессорная связь) передает необходимые для оперативной реакции данные либо в блок БПОПМ либо в БПКМ.
После замены процессорного модуля резервным либо после нахождения кратчайшего пути обхода найденный вариант передается через параллельный порт обратно в контроллер и далее через последовательный порт
обратно в управляющую ЭВМ.
Устройство управления (УУ) необходимо для организации режимов загрузки исходных данных, вычисления и выдачи результатов. Оно выдает
управляющие сигналы, обозначенные как множество микроопераций (МО), а
так же – значения адресов для БПОПМ и БПКМ в режимах загрузки и вычисления. УУ связано непосредственно с параллельным портом, выставляет
высокий или низкий уровень на линиях, связанных с регистром Status, и принимает сигнал с линий, связанных с регистром Control параллельного порта.
3.3 Алгоритмы функционирования акселератора
На основе рассмотренных в главе 2 теоретических положений были
разработаны соответствующие алгоритмы функционирования. Алгоритм переразмещения отказавшего процессора представлен на рис. 3.2.
В этом алгоритме (рис. 3.2) первоначально выполняется инициализация, т.е. получение матриц смежности, исправности процессоров и матрицы
работоспособности и занятости резервных процессоров. После этого происходит ожидание отказа, т.е. фактически бесконечный цикл. В случае возникновения ситуации отказа выполняется поиск ближайшего свободного резервного процессора и переназначения отказавшего процессора на свободный резервный процессор. Далее, так как произошло нарушение топологии системы
выполняется переразмещение подпрограмм на новый вариант топологиче-
55
ской организации мультипроцессорной системы по методу, представленного
на рисунке [64-66].
начало
Ввод
M  mij
N E
Ввод
Z
zij
NN
Ввод
 
N N
Отказ
pij
0
1
ls,t =0
0
 i  s  min  &  j  t  min  ,
i  1, n , j  1, n , s  1, n , t  1, n
1
ls,t  pij
zij  1
 s ,t  1
Выполнить falloc
для p
конец
Рис. 3.2. Блок-схема алгоритма замены процессорного модуля резервным
В случае возникновения отказа межпроцессорной связи, выполняется
поиск кратчайшего пути обхода по алгоритму Дейкстры [59-65], который
представлен на рис. 3.3.
56
начало
Отказ
kij -?
0
i  1, n , j  1, n
1
pq. – начальная точка
pq 1. 1 - конечная точка
 a, b:  mij где i  1, n ,
j  1, n
Ввести k[1,i] и l[1,j] ,
где i  1, E
k[1,i]=0, l[1,j]=0
pq,  pq 1, 1 :
q 1
q  1,
  1,   1:  mij
q ,
d[i]:= pq,  pq 1, 1
a := min{a, b}
a<b
0
q=q+1
1
=+1
l[1,j]  k[1,i] := l[1,j]
0
q &  n
1
конец
Рис. 3.3. Алгоритм поиска кратчайшего пути обхода
Алгоритм поиска кратчайшего пути обхода, представленный на рис. 3.3
функционирует в соответствии с формализованным алгоритмом. Приведенные алгоритмы реализованы в аппаратной части блока АПРП.
57
3.4 Устройство замены отказавшего модуля резервным
Все вышесказанное позволяет спроектировать функциональную схему
устройства переразмещения, функциональная схема которого представлена
на рис. 3.4.
14
j
i
P1
A1
A2
D
1 we
S
R
e
c
O
Rg
“1”
oe Z
A2
A1
D
we
=
O
Rg
“0”
0
1
e i1
+1
s
+1
DC
e i2
-1
s
j1
-1
s of
1
1
e 
A1
A2
O
D
we
=
0
1
j2
+1
s
Рис. 3.4. Функциональная схема устройства оперативной замены отказавшего
процессорного модуля
Назначение элементов и блоков разработанного устройства заключается
в следующем.
Генератор 14 импульсов предназначен для генерации тактовых импульсов устройства.
ОЗУ 15 Р1 необходимо для моделирования мультикомпьютера состоящего из двух непересекающихся подмножеств:   P  L , где P – множество
основных процессоров, а L – множество резервных процессоров. Идентификаторы процессоров множества P упорядочены в виде матрицы P  pij
Множество L представлено в виде матрицы L  lij
NN
.
n n
.
58
ОЗУ 16
Z
служит для определения исправных процессоров. В нем в
ячейке матрицы хранится код единицы, если процессор не исправен и о - если исправен.
ОЗУ 17  показывает наличие резервных процессоров. Аналогично ОЗУ
16 хранит единицу, если резервного процессора ячейке нет и о – если есть.
Регистр 18 необходим для хранения кода нуля, необходимого для сравнения с кодами, полученными из матрицы 16.
Первый 19 элемент сравнения необходим для сравнения очередного кода, полученного из ОЗУ 16 с кодом нуля из регистра 18.
Второй 20 элемент сравнения предназначен для сравнения кода нуля из
регистра 16 с очередным кодом, полученным из ОЗУ 17.
Дешифратор 21 выбора необходим для выбора счетчика, необходимого
для операций с выбором свободного резервного процессора в случае выхода
из строя основного.
Первый 22 счетчик строки необходим для выбора номера строки выше
на одну строки, в которой расположен отказавший процессор.
Второй 23 счетчик строки служит для выбора номера строки ниже на
одну той, в которой расположен отказавший процессор.
Первый 24 счетчик столбца предназначен для выбора столбца резервного процессора на один правее столбца, в котором расположен отказавший
процессор.
Второй 25 счетчик столбца необходим для выбора столбца резервного
процессора на один левее столбца, в котором расположен отказавший процессор.
Счетчик 26 номера предназначен для подсчета номера выбираемого
счетчика 22, 23, 24, 25, необходимого для проведения операций с заменой
основного процессора резервным.
Первый 27 элемент ИЛИ служит для подачи единичного импульса на
вход we разрешения записи ОЗУ Р1.
59
Второй 28 и третий 29 Элементы ИЛИ необходимы для подачи единичных сигналов на адресные входы А1 и А2 ОЗУ 17 , необходимые для выбора и последующей проверки наличия соответствующего резервного процессора.
На вход 30 строки подается из ВУУ номер строки, в который отказал неисправный процессор с последующей подачей на соответствующей адресные
А1 и А2 входы ОЗУ 15 и 16.
На вход 31 столбца подается номер столбца, в котором отказал неисправный процессор с последующей подачей на соответствующей адресные
А1 и А2 входы ОЗУ 15 и 16.
Выход 32 ОЗУ 15 Р1 с соответствующим входом ВУУ устройства.
Вход 33 регистра служит для соединения соответствующего входа со
входом ВУУ устройства.
Выход 34 переполнения счетчика 24 столбца служит для подачи на ВУУ
сигнала переполнения, что одновременно сообщает о завершении работы
устройства.
Регистр 35 единицы предназначен для хранения код числа единица
(«0…01»).
Триггер 36 выбора служит для выбора счетчика, предназначенного для
выбора резервного процессора.
Вход S 37 установки необходим для установки в единицу триггера 36
выбора.
На начальном этапе элементы и блоки устройства находятся в следующем состоянии.
В ОЗУ 15 хранится матрица P1 процессорных модулей и матрица L резервных процессоров, так как показано на рис. 3.5.
p1
l1
p2
l2
p3
l3
p4
l4
Рис. 3.5. Матричная организация мультикомпьютера
60
На рисунке 3.5 буквами p обозначены основные процессорные модули, а
буквами l – резервные процессоры.
В матрице 16
Z
хранятся нулевые коды, свидетельствующие о полной
начальной работоспособности мультикомпьютера. В матрице 17  также
хранятся коды нулей, свидетельствующие о наличие и полной начальной работоспособности резервных процессоров. В регистре 18 хранится код нуля
(«0…00»), в счетчике 26 содержится код нуля («0…00»), а значит, на выходе
дешифратора 21 не появляется единичного импульса. Триггер 36 находится в
высокоимпедансном состоянии.
Работа устройства состоит в следующем. В случае появления на входах j
и i двоичных кодов происходит внештатная ситуация в системе логического
управления (СЛУ), вызванная сбоем процессора. В этом случае, необходима
оперативная реакция системы на отказ, связанная с применением аппаратных
средств, предлагаемых в данной работе. При этом данные коды с входов подаются на адресный вход А1 ОЗУ16 и ОЗУ 15, на установочный s-вход ОЗУ
24 и 23. В результате в счетчике 23 и 24 устанавливается код строки i матрицы процессоров, в которой отказал процессор, в счетчиках 22 и 25 – код
столбца матрицы процессоров, к которой отказал данный процессор. В то же
время на адресный вход А1 ОЗУ 16 поступает код столбца, в которой произошел отказ. Одновременно и со входа 30 код строки j подается на адресный
вход А2. Одновременно с этим эти же коды поступают на установочные sвходы счетчиков 23 и 24, устанавливая в них начальные значения, которые
фактически являются координатами отказавшего процессора, необходимые
для дальнейшего переназначения на резервный процессор. Тем не менее, изменений в ОЗУ 15 не происходит из-за отсутствия единичного импульса на
вход we разрешения записи.
Первый тактовый импульс с выхода генератора 14 импульсов поступает
на вход разрешения выдачи oe ОЗУ 16, а так как на адресных входах А1 и А2
присутствуют соответствующие коды, то значение с выхода ОЗУ 16 подается
61
на первый вход элемента 19 сравнения, на втором входе которого присутствует код нуля с выхода регистра 18. В результате сравнения происходит
определение исправленности процессора. В случае если результат сравнения
положительный, то есть он исправен, процессор должен быть отмечен как
неисправный, поэтому единичный импульс со второго выхода элемента
сравнения 19 подается на вход we разрешения записи ОЗУ 16. Поэтому единица с выхода регистра 34 поступает на вход данных D ОЗУ 16 и заносит туда код единицы, как признак неисправности данного процессора.
Одновременно с этим единичный потенциал с выхода элемента сравнения 19 подается на второй вход элемента 27 ИЛИ и счетный вход счетчика
23. Единица проходит через элемент 27 ИЛИ и поступает на вход we разрешения записи ОЗУ 15, чем разрешает запись нулевого кода с выхода регистра
16, что означает признак неисправности процессора с данным адресом в матрице P1.
Далее необходима замена неисправного процессора резервным, что происходит следующим образом.
Так как потенциальный отказавший процессор окружает минимум 4 резервных процессора, то в предлагаемом устройстве предлагается использовать четыре счетчика: счетчик 23 отвечает за резервный процессор, который
находится справа на один от отказавшего; счетчик 22 – за резервный процессор, располагающийся выше на один от отказавшего; счетчик 25 отвечает за
строку, которая находится ниже на один от отказавшего; счетчик 24 – за
столбец левее на один от отказавшего.
В результате при появлении единичного потенциала на выходе элемента
19 сравнения, он поступает на счетный вход счетчика 24 и увеличивает его
значение по переднему фронту на единицу. Этот код поступает через элемент
29 ИЛИ на адресный вход А2 ОЗУ 17. Соответствующий код с выхода ОЗУ
17 подается на второй вход элемента 20 сравнения для сравнения с кодом нуля, поступающим с выхода регистра 18. В результате сравнения, если резерв-
62
ный процессор не занят, то единичный потенциал со второго выхода элемента 20 сравнения поступает на we вход ОЗУ 17 для единичного кода, означающего его занятость, в результате замены на отказавший процессор.
В тоже время единица с выхода элемента 19 сравнения также подается
на вход е разрешения работы триггера 36. В результате этого, триггер устанавливается в начальное единичное состояние. Это означает, что на прямом
выходе у него устанавливается единичный потенциал, поступающий на разрешающий е вход счетчика 22. На инверсном выходе триггера 36 устанавливается нулевой потенциал, запрещающий работу счетчика 25.
В случае, если результат сравнения в элемента сравнения 20 окажется
отрицательным, то соответствующий потенциал с первого его выхода поступит на счетный вход счетчика 26 и по переднему фронту увеличит его содержимое на единицу до кода один, который поступит на вход дешифратора
21. Этот код возбудит единичный импульс на первом выходе дешифратора
21, который поступит на счетный вход счетчика 22. Так как на входе е разрешения присутствует единичный потенциал, то его содержимое по переднему фронту увеличится на единицу. В результате этого код поступит через
элемент 28 ИЛИ на адресный А1 вход ОЗУ 17. Одновременно единичный потенциал с выхода счетчика 22 поступает на R-вход триггера 36, сбрасывая
его в нулевое состояние. В результате на прямом входе появляется нулевой
потенциал, который запрещает работу счетчика 22, а на инверсном – единичный, разрешающий работу счетчика 25. Значение с выхода ОЗУ 17 поступит
на второй вход элемента 20 сравнения. Далее процесс протекает аналогично.
Если результат сравнения окажется отрицательным (резервный процессор занят), то соответствующий импульс с первого выхода элемента 20 сравнения снова поступит на счетный вход счетчика 26.
Очередной код с выхода счетчика 26 подается на вход дешифратора 21.
В результате код с его второго выхода поступает на вычитающий вход счетчика 25 и по переднему фронту уменьшает его содержимое на единицу. Од-
63
новременно единичный потенциал с выхода счетчика 25 сбрасывает триггер
36 в высокоимпедансное состояние. Далее содержимое счетчика 25 аналогично проходит через элемент 28 ИЛИ и процесс повторяется аналогично
описанному выше принципу.
В случае если результат сравнения в элементе сравнения 20 сравнения
снова окажется отрицательным, соответствующий импульс с первого выхода
заново подается на счетный вход счетчика 26. Третий выход с дешифратора
21 поступает на вход счетчика 24 и далее на адресный А2 вход ОЗУ 17.
В случае повторной неудачи процесс повторяется заново до появления
сигнала переполнения на выходе переполнения счетчика 34, что означает
необходимость полной замены матрицы процессоров.
3.5 Оценка производительности и быстродействия акселератора
Для анализа производительности предложенного акселератора используется серия 1533 интегральных микросхем.
Таблица 3.1
Временные характеристики внутренних вентилей
Тип элемента
tзд.р. , нс
НЕ
11
И
11
ИЛИ
12
Дешифратор
36
Элемент сравнения
18
Мультиплексор
20
RS-триггер
20
Регистр
21
Счетчик
18
ОЗУ
30
64
При этом при подсчете быстродействия и производительности учитывались временные характеристики отдельных внутренних элементов предложенного устройства (таблица 3.1) согласно серии микросхем ТТЛ 1533 [7678].
Количество использованных схемотехнических элементов, использованных в предложенном устройстве (рис. 3.4) сведено в таблице 3.2.
Таблица 3.2
Количество схемотехнических модулей
Счетчик
6
Регистр
2
Триггер
1
Элемент ИЛИ
3
Элемент сравнения
2
Дешифратор
1
ОЗУ
3
Рис. 3.6. Диаграмма зависимости скорости работы устройства от размера
матрицы процессоров
65
В соответствии с данными таблицы 3.1, 3.2 построена диаграмма, представленная на рис. 3.6.
Из анализа приведенной диаграммы можно сделать вывод, что при относительно небольшой размерности матрицы процессоров ( 3  3 – 5  5 ) скорость перестройки матрицы процессоров с учетом времени замены незначительно, а начиная с размерности матрицы 7  7 и выше наблюдается значительный рост временных затрат, что связано с возрастанием возможных вариантов замены отказавшего процессора свободными резервными процессорами. Очевидно, что для критических важных объектов (критических систем,
таких как системы наблюдения, слежения, контроля и т.д.), где размерность
матрицы процессоров исчесляется сотнями применение программных
средств неприемлемо из больших временных затрат.
Для оценки аппаратной сложности разработанного устройства воспользуемся представлением модели в виде эквивалентного вентиля (под эквивалентным вентилем здесь будем понимать логический элемент И) [13–16]. Так
RS-триггер эквивалентен 2 логическим элементам И, счетчик – 17 элементам
И, схема сравнения – 16 И, регистр – 32 И, один разряд сумматора можно
представить с помощью 32-х элементов И, а соответственно 64-х разрядный
сумматор с помощью 544 элементов И. И, наконец, условившись между процессорными модулями на более 1 байта информации и, соответственно, 8
триггеров или 16 элементов И получим, что для хранения в памяти матрицы
процессоров размером 33, а с четом резервных процессоров 36 120 элементов И. для матрицы размером 55 – 3840 и т.д.
В результате можно получить зависимость роста аппаратных затрат от
объема решаемой задачи. При этом будем учитывать, что предложенное
устройство содержит следующее количество элементов (табл. 3.3).
Очевидно, на аппаратную сложность будет влиять размерность хранящейся в ОЗУ информации, а все остальные элементы будут представлять собой постоянное значение, не влияющее на рост аппаратной сложности.
66
Таблица 3.3
Количество внутренних элементов устройства
Тип элемента
Количество
Количество эквивалентных вентилей
ИЛИ
3
1
Дешифратор
1
16
RS-триггер
1
2
Регистр
2
32
Счетчик
5
17
ОЗУ
3
16 на 1 ячейку
Элемент сравнения
2
10
В результате расчетом была получен график зависимость роста аппаратной сложности, представленный на рис. 3.7.
Рис. 3.7. Диаграмма роста аппаратной сложности устройства от размерности
задачи
Из анализа представленного графика можно сделать вывод о том, что
увеличение аппаратных затрат начинается с размерности матрицы процессоров 7  7 , что связано как с необходимостью хранения в памяти матрицы основных и резервных процессоров, а также хранения дополнительных матриц,
необходимых для реализации аппаратного процесса замены. Тем не менее,
67
следует отметить, что 60102 элементарных вентилей для матрицы процессоров размером 10 10 является небольшой аппаратной сложностью. С учетом реальной размеров матриц процессоров в критических важных объектах
(от 100 и выше) и с учетом развития технологий (современный процессор содержит порядка миллиарда транзисторов) полученная аппаратаная сложность
не является большими затратами, а значит говорит о возможности потенциального применения.
3.6 Устройство поиска кратчайшего пути обхода межпроцессорной
связи
Функциональная схема устройства поиска кратчайшего пути представлена на рис. 3.8.
Назначение элементов и блоков устройства состоит в следующем.
Блоки 1-13 относятся к прототипу и поэтому здесь не рассматриваются.
Генератор 14 импульсов предназначен для формирования единичных
тактовых импульсов, необходимых для работы устройства.
Матрицы 15 смежности МС служит для хранения исходной топологии
графа G задачи.
Временная 16 матрица предназначена для хранения временных кодов,
получаемых в процессе применения метода Дийкстры.
В итоговой 17 матрице хранится конечный путь обхода отказавшего
межпроцессорного линка, позволяющий минимально загрузить остальные
каналы мультипроцессорной системы.
Регистр 18 стартовой вершины хранит код нуля, как исходная вершина
при применении алгоритма Дейкстры.
Сумматор 19 промежуточного пути необходим для суммирования временных путей обхода при поиске кратчайшего пути.
Первый 20 вычитатель предназначен для поиска минимального значения, как результат поиска пути обхода на данном шаге.
68
Второй 21 вычитатель служит для принятия решения о маршруте обхода
на данном этапе поиска кратчайшего пути обхода.
Счетчик 22 адреса строки матрицы смежности необходим для подсчета
кода адреса строки в МС.
Счетчик 23 адреса столбца матрицы смежности необходим для подсчета
кода адреса столбца в МС.
Счетчик 24 адреса итоговой 17 матрицы предназначен для сохранения
маршрута пути обхода отказавшей межпроцессорной связи.
Первый 25 и второй 26 счетчик адреса временной 16 матрицы необходим
для подсчета адресов сохраняемых или выводимых временных данных.
Регистр 27 временного минимального кода предназначен для сохранения минимального кода при выборе очередного шага обхода отказавшей
межпроцессорной связи.
Регистр 28 адреса временного минимального кода служит для сохранения адреса в памяти, сохраненного в регистре 27 минимального кода.
Триггер 29 режима служит для выбора режима работы схемы. В исходном нулевом состоянии триггер находится в состоянии нуля, и на прямом его
выход присутствует нулевой потенциал, который запрещает работу временной 16 матрицы. В это время на инверсном выходе триггера присутствует
единичный потенциал, что разрешает работу матрицы 15 смежности.
Элемент 30 ИЛИ служит для объединения кодов, поступающих на адресный А вход временной 16 матрицы.
Вход 31 служит для занесения из ВУУ в регистр 18 стартовой вершины
кода начального значения, необходимого для начала работы алгоритма
Дийкстры.
Выход 32 итоговой 17 матрицы служит для выдачи на ВУУ полученного
пути обхода отказавшей межпроцессорной связи.
29
31
S
R
34
35
14
s i of
+1 22
33
s j
+1 of 23
Rg
ном
18
oe мс
A1
A2
sum
19
O
min
20
rd
25
+1
15
oe temp
21
D
min
30
1
16
O
D
+1
A
A
Rg
e
+1 of
fimal
27
26
Rg
e 28
я
Рис. 3.8. Функциональная схема устройства поиска кратчайшего пути
24
A
A
O
17
32
70
Выход 33 счетчика адреса столбца матрицы смежности предназначен
для подучи на ВУУ сигнала о завершении работы устройства и том, что в
итоговой 17 матрице находится путь обходы отказавшей межпроцессорной
связи.
Входы 34 и 35 предназначены для загрузки из ВУУ адресов в ОЗУ 15 и
соответствующих координат в матрице смежности отказавшей процессорной
связи.
Элемент 36 ИЛИ необходим для объединения сигналов, поступающий на
S-вход триггера 29.
В начальном состоянии в МС 15 хранится матрица смежности исходной
задачи, триггер 29 находится в нулевом состоянии, в матрице 16 хранятся
коды нулей, в регистре 27 хранится код FFFF, как максимально возможное
для данной применяемой разрядности. В регистре 28 хранятся также код нуля, в матрице 17 хранятся коды нулей.
Первый тактовый импульс с выхода генератора 14 импульсов поступает
на счетные входы счетчиков 23 и 26, но так как на разрешающем е-входе
счетчика 26 не присутствует единичного потенциала, увеличение хранящегося в нем кода не происходит. В счетчике 22 и 23 установлен код адреса, хранящийся в ОЗУ 15, что фактически является координатами отказавшей межпроцессорной связи. Поэтому, хранящееся в счетчике 23 значение по переднему фронту увеличивается на единицу.
Так как на адресных А1 и А2 входах присутствуют коды отказавшей
процессорной связи, а на входе ое разрешения выдачи присутствует единичный сигнал, то соответствующий код из ОЗУ 15 поступает на второй вход
сумматора 19 и на второй вход блока нахождения минимума 20. В результате, в сумматоре 19 находится сумма кодов, поступивших значений с выходов
регистра 18 и ОЗУ 15, которая поступает на первый вход блока нахождения
минимума 20. В результате, полученное минимальное значение поступает на
D-вход ОЗУ 16. В это время с разрешающего rd выхода блока нахождения
минимума 20 поступил единичный импульс на счетный вход счетчика 25 и
71
по переднему фронту увеличил его содержимое до кода единицы («0…01»),
который через элемент ИЛИ 30 поступил на адресный А вход ОЗУ 16. В результате, в ОЗУ 16 сохранилось временное значение, которое поступает на
первый вход блока нахождения минимума 21. В это время на втором его входе присутствует код FFFF. В результате сравнения минимальный на данный
момент код заносится во временный регистр 27, который поступает на Dвход ОЗУ 17, но не заносится туда, так как на его адресном входе не присутствует соответствующего адреса.
Следующий тактовый импульс аналогично поступает на счетный вход
счетчика 23 и увеличивает его содержимое по переднему фронту на единицу.
Этот код поступает на адресный А2 вход ОЗУ 15 и в результате выбранное
значение подается на вторые входы сумматора 19 и блока нахождения минимума 20. В результате суммирования результат подается на первый вход блока нахождения минимума 20. В результате появления единичного импульса
на выходе блока с разрешающего rd выхода блока нахождения минимума 20
результат поиска минимума поступает для записи в ОЗУ 16, на адресном А
входе которого присутствует адрес с выхода счетчика 26.
Так продолжается до тех пор, пока на выходе of переполнения счетчика
23 не появится единичный сигнал, что означает, что все столбцы выбранной
строки в ОЗУ 15 проанализированы и следует переходить к следующей строке. В результате, единичный импульс поступает на R-вход сброса триггера
29, в результате чего на прямом выходе появляется единый потенциал, который разрешает работу счетчика 26 и выдачу данных из ОЗУ 16. В тоже время
нулевого потенциала на обратном выходе триггера 29 работа ОЗУ 15 запрещена.
Очередной тактовый импульс поступает на счетный вход счетчика 26 и
по переднему фронту увеличивает его содержимое на единицу до кода единицы («0…01»). Этот код поступает на второй вход элемента 30 ИЛИ и далее
на адресный А вход ОЗУ 16, а также на вход регистра 28 для запоминания
номера адреса, поступившего на адресный А вход ОЗУ 16. Так как OE-
72
выходе ОЗУ 16 присутствует единичный потенциал, то код из первой ячейки
поступает с его выхода на первый вход элемента 21 сравнения, на втором
входе присутствует код с выхода регистра 27. В результате сравнения, если
выбранный из ОЗУ 21 код окажется меньше, то этот код записывается в регистр 28.
Следующий тактовый импульс поступает на счетный вход счетчика 26 и
по переднему фронту увеличивает его содержимое до кода двойки
(«0…010»). Этот код подается на второй вход элемента 30 ИЛИ и далее на
адресный А вход ОЗУ 21, а также на вход регистра 28 для записи. Если результат сравнения в элементе 21 сравнения окажется положительным, то код
с выхода элемента 21 сравнения запишется в регистр 27. Запись в регистр 28
не происходит потому что ОЗУ 15 закрыта из-за отсутствия единичного импульса на его ое-входе.
Так продолжается до тех пор, пока на выходе переполнения счетчика 26
не появится сигнала переполнения, означающий, что первый цикл поиска
кратчайшего пути закончен, и полученный результат необходимо сохранить
в ОЗУ 17, как первое «звено» в искомом кратчайшем пути.
Единичный импульс с выхода переполнения счетчика 26 подается на
счетный вход счетчика 24 и S-вход триггера 29. В результате, по переднему
фронту код в счетчике 24 увеличивается до кода единицы, который с его выхода подается на адресный А вход ОЗУ 17 на D-вход данных которого поступает и записывает значение с выхода регистра 27. Поступивший единичный импульс на S-вход триггера 29, в результате чего работа ОЗУ 16 запрещается из-за присутствия нулевого потенциала на его ое–входе. В тоже время
работа ОЗУ 15 вновь разрешена. Одновременно, на установочный s-вход
ОЗУ 22 подается адрес минимального выбранного на данном шаге значения,
как адреса строки в матрице смежности для следующего шага. Код в счетчике 23 сбрасывается в ноль.
Новый тактовый импульс поступает на счетный вход счетчика 23 и увеличивает его содержимое по переднему фронту до кода единицы как адрес
73
А1 столбца матрицы смежности. Адрес А1 строки поступает из счетчика 22.
Далее работа схемы аналогично описанному выше принципу.
Так продолжается до тех пор, пока на выходе переполнения счетчика 22
не появится единичный импульс, который означает, что все коды в ОЗУ 15
исследованы и в ОЗУ 17 записаны все кратчайшие пути для исходного графа
G. Соответственно, коды длин кратчайших путей могут быть поданы на ВУУ
для анализа через D-выход ОЗУ 17.
Таким образом, в заданном параграфе рассмотрено устройство поиска
кратчайшего пути обхода межпроцессорной связи, позволяющего оперативно
найти кратчайшие пути обхода в случпе отказа в критических системах, где
маршрут должен быть найден как можно более в короткое время.
3.7 Оценка аппаратной и временной сложности устройства поиска
кратчайшего пути обхода отказавшей межпроцессорной связи
Анализ производительности предложенного акселератора проводился на
1533 серии интегральных микросхем. При этом при подсчете быстродействия
и производительности учитывались временные характеристики отдельных
внутренних элементов предложенного устройства (таблица 3.4) согласно серии микросхем ТТЛ 1533 [76-78].
Таблица 3.4
Временные характеристики
Тип элемента
tзд.р. , нс
ИЛИ
12
Сумматор
36
Элемент сравнения
18
RS-триггер
20
Регистр
21
Счетчик
18
ОЗУ
30
74
На основе представленной функциональной схемы можно подсчитать
количество микросхем, используемых в предложенном устройстве поиска
маршрута обхода отказавшей процессорной связи, представленной в табл.
3.5.
На основе данных таблиц 3.4 и 3.5 определены временные характеристики предложенного устройства.
Таблица 3.5.
Количество микросхем
Тип элемента
Количество
ИЛИ
1
Сумматор
1
Элемент сравнения
2
RS-триггер
1
Регистр
2
Счетчик
5
ОЗУ
3
Так для матрицы процессоров размером 2  2 получаем, что для поиска
кратчайшего маршрута необходимо 2 цикла проверки путей. Это в свою очередь означает, время работы устройства в данном случае составит 652 нс. На
основе статистических расчетов можно составить временную диаграмму зависимости скорости роста устройства от размерности задачи (рис. 3.9).
Из анализа представленной диаграммы можно сделать вывод, что при
относительно небольшой размерности матрицы процессоров ( 3  3 – 5  5 )
время работы устройства составляет несколько нс. С ростом размерности
матрицы процессоров количество вариантов обхода матрицы резко увеличивается, что приводит к экспоненциальному росту времени работы устройства. Отсюда с вою очередь можно сделать вывод о необходимости применения предложенного устройства для критических систем, в которых применение программных средств неприемлемо из-за большого времени решения задачи.
75
Рис. 3.9. Зависимость скорости работы устройства от размерности матрицы
процессоров
Для оценки аппаратной сложности разработанного устройства воспользуемся представлением модели в виде эквивалентного вентиля, где под эквивалентным вентилем здесь будем понимать логический элемент И [74–76]
(табл. 3.6).
Таблица 3.6
Количество внутренних элементов устройства
Тип элемента
Количество
Количество эквивалентных вентилей
ИЛИ
1
1
Сумматор
1
16
Элемент сравнения
2
10
RS-триггер
1
2
Регистр
2
32
Счетчик
5
17
ОЗУ
3
16 на 1 ячейку
Очевидно, на аппаратную сложность будет влиять размерность хранящейся в ОЗУ информации, а все остальные элементы будут представлять со-
76
бой константное значение, не влияющее на общий рост аппаратной сложности.
В результате расчетным путём был получен график зависимости роста
аппаратной сложности, представленный на рис. 3.10., от количества использованных эквивалентных вентелей И.
Рис. 3.10. Зависимость роста аппаратной сложности от размерности матрицы
процессоров
Из представленного графика можно сделать вывод об экспоненциальном
росте аппаратной сложности устройства в зависимости от размерности матрицы процессоров. Так при размерности 15  15 необходимо 10988 элементарных вентилей И, что при нынешнем уровне развития технологий не представляет сложности (количество транзисторов современного процессора составляет больше миллиарда).
В работе был сделан сравнительный анализ результатов экспериментальных исследований времени перестройки отказавшего процессорного модуля при временной и аппаратной реализации предложенного алгоритма
(табл. 3.7).
Из анализа данных, представленных в таблице 3.7 можно сделать вывод
о том, что предложенное устройство целесообразно применять на относительно больших размерах топологической организации мультипроцессорных
77
систем, например, от 20  20 и выше, к которым относятся критические системы 7  7 .
Таблица 3.7
Сравнительный анализ времени перестройки при программной и аппаратной реализации
Размеры топологии
tпр, нс
tап, нс
4 4
166
326
5 5
200
358
66
422
374
77
855
390
На основе данных таблицы 3.7 была построена зависимость времени перестройки при программной и аппаратной реализации, представленная на рисунке 3.11.
Рис. 3.11. Зависимости времени переразмещения программ от размерности
матрицы процессоров: 1 – программная реализация; 2 – аппаратная реализация
Данные сравнительного анализа требуемого количества эквивалентных
вентилей (ЭВ), необходимых для реализации предлагаемого устройства и
устройства размещения шагов обхода [80] представлены в таблице 3.8.
78
Таблица 3.8
Сравнительный анализ аппаратной реализации устройства с аналогом
Устройства размещения Устройство переразмеКоличество процессоров
шагов обхода, ЭВ
щения, ЭВ
2
16129
284
3
16774,8
1295
5
17588,41
1388
7
18124,32
2540
9
18524,6
4076
10
18692,41
4988
15
19338,21
10988
Из анализа таблицы 3.8 следует вывод, что разработанное устройство
обладает для реализации меньшим числом ЭВ, чем аналогичное, что подтверждает возможность аппаратной реализации устройства оперативного переразмещения программ в отказоустойчивых мультикомпьютерных системах, предлагаемое в данной раболте.
Анализ зависимостей, приведённых на рис.3, позволяет сделать следующие выводы. Во-первых, время переразмещения программ при использовании разработанного устройства при относительно малых размерностях мультипроцессорной системы (менее 6  6 ) не дает выигрыша по сравнению с
программной реализацией. Во-вторых, экстраполяция полученных зависимостей показывает, что для систем большой размерности ( 50  50 и выше) преимущество имеет аппаратная реализация в связи со значительным увеличением вариантов перебора в матрице процессоров, что указывает на перспективность предложенного подхода для мультикомпьютеров следующих поколений, содержащих от сотен тысяч до миллионов процессорных модулей.
79
3.8 Выводы
1. Разработана структурно-функциональная организация специализированных устройств оперативного переразмещения программ после возникновения отказов в отказоустойчивой мультипроцессорной системе, позволяющая независимо реагировать на отказ как процессорного модуля системы,
так и – межпроцессорной связи.
2. Время переразмещения программ при использовании предложенного устройства при относительно малых размерностях мультипроцессорной
системы (менее 6  6 ) не дает выигрыша по сравнению с программной реализацией. Однако, экстраполяция полученных зависимостей показывает, что
для систем большой размерности ( 50  50 и выше) преимущество имеет аппаратная реализация, что свидетельствует о перспективности предложенного
подхода для мультикомпьютеров следующих поколений, содержащих от сотен тысяч до миллионов процессорных модулей.
3. Анализ времени, необходимого для реализации алгоритмов показал,
что при относительно небольших размерностях матрицы процессоров (менее
6  6 ) преимущество имеет программная реализация предложенных алгорит-
мов (порядка 200 нс). С другой стороны, при увеличении размерности матрицы процессоров увеличивается количество вариантов перебора и, как следствие, растет время программной реализации алгоритма. В тоже время преимущество показывает аппаратная реализация, которая является перспективной при использовании в критических системах.
80
4
Моделирование алгоритмов оперативного переразмещения в
отказоустойчивых мультипроцессорных системах
4.1 Программная модель процедур переразмещения с учётом отказа
процессора и/или отказа линка
Для моделирования и тестирования разработанного метода планирования переразмещения с учётом отказа процессора и/или отказа линка на языке
Си++ была разработана программная система, которая позволяет моделировать алгоритм переразмещения, строить графики зависимостей, характеризующие количество отказов, как процессоров, так и межпроцессорных связей, время переразмещения подпрограмм и поиска пути обхода отказавшей
связи, а также общее время наработки на отказ. Листинг соответствующего
пакета программ представлен в приложении 1 [66, 67].
Главное рабочее окно программной модели представлено на рисунке 4.1.
Рисунок 4.1. Рабочее окно программной модели
81
Программная система обладает следующими функциональными возможностями (рис. 4.1): возможность устанавливать тактовую частоту процессора, возможность установки количества тактов процессора и определения размера матрицы процессоров; дополнительно существует возможность
задания приоритета отказов:
- только связи;
- только процессоры;
- связи чаще процессоров;
- процессоры чаще связей;
- связи и процессоры одинаково.
Кроме этого существует возможность задания матриц: размещения,
смежности, расстояний, путей, достижимости, перестроек и маршрутов.
4.2 Результаты исследования эффективности алгоритма планирования
размещения
При тестировании программы были приняты следующие типовые исходные данные: тактовая частота процессора 450 Мгц; размеры матрицы
процессоров и резервной матрицы 4, количество процессорных тактов на перестройку 5; одинаковый приоритет отказов процессоров и межпроцессорных связей (рис 4.2) получены следующие результаты (рис 4.3).
В случае выхода из строя первой связи время на поиск пути необходимо
11. 11  10
9
сек, найден путь 9334. При втором отказе – составило 10
9
сек,
найден путь 9334 и т.д. В итоге для наступления фатального отказа потребовалось 30 отказов, общее время для перестройки составляет 122.  22   10
9
сек.
При втором тестировании программы были приняты следующие типовые исходные данные: тактовая частота процессора 450 Мгц; размеры матрицы процессоров и резервной матрицы 4, количество процессорных тактов на
82
перестройку 5; отказ только связей (рис 4.4) получены следующие результаты (рис 4.5, 4.6).
Рис 4.2. Параметры для тестирования
83
Рис. 4.3. Результаты моделирования
84
Рис 4.4. Параметры моделирования
Рис 4.5. Результаты моделирования
В представленной работе отказы с №46 по №90 не показаны.
85
Рис 4.6. Результаты моделирования
При выходе из строя первой связи время на поиск пути необходимо
0  10
9
сек, найден путь 8592. При отказе второй связи время на поиск пути
составило 0  10
9
сек, найден путь 8592 и т.д. В итоге для наступления фа-
тального отказа потребовалось 94 отказа, общее время для перестройки составляет 0  10
9
сек.
При следующем тестировании программы были приняты следующие
типовые исходные данные: тактовая частота процессора 450 Мгц; размеры
матрицы процессоров и резервной матрицы 4, количество процессорных тактов на перестройку 5; отказ только процессоров (рис 4.7.) получены следующие результаты (рис 4.8).
86
Рис 4.7. Параметры тестирования
Рис 4.8. Результаты моделирования
В случае выхода из строя первого процессора время на переразмещения
подзадачи составило 11. 11  10
9
сек, найден путь 8097. При отказе второго
87
процессора время на переразмещения подзадачи составило 11. 11  10
9
сек,
найден путь 8097 и т.д. В итоге для наступления фатального отказа потребовалось 14 отказов, общее время для перестройки составляет 155.  5   10 сек.
9
4.3 Результаты исследования эффективности алгоритма
переразмещения с учётом отказа процессора и/или отказа линка
Под эффективностью алгоритма понимается возможность элементарного переноса операторов алгоритма на аппаратную элементную базу, т.к. его
предполагается использовать при соответствующем аппаратном решении.
Поскольку реальный размер СЛУ критических систем значительно
больше исследованной топологии 4  4 , в работе проведен анализ топологии
больших размерностей ( 5  5 , 6  6 , 7  7 ). Полученные результаты представлены в таблице 4.1.
Таблица 4.1
Зависимость времени перестройки от размерности задачи
Размерность многопроцессорной си-
Суммарное время наработки на
стемы
отказ
4 4
67 122, 2  10
5 5
89 266,6  10
66
122 477,8  10
77
178 944,5  10
9
9
9
9
Из анализа таблицы следует вывод о том, что приращение времени замены отказавшего элемента путем перестройки межпроцессорных связей в
случае отказа процессора или межпроцессорной связи подчиняется экспоненциальному закону.
На основе полученных расчетов и анализа данных, представленных в
таблице 3.1 построиен график зависимости роста времени наработки на отказ
от размерности многопроцессорной системы (рис. 4.9).
88
Рис. 4.9. Зависимость времени перестройки от размера матрицы процессоров
На основе анализа графика, приведенного на рис. 3.9 можно сделать
следующие выводы. Рост графика имеет экспоненциальный характер, причем
резкий скачек наблюдается при сильном скачке размеренности матрицы процессоров. Причем увеличение размерности матрицы процессоров всего на
одну величину, например на рис. 3.9 с 6  6 до 7  7 увеличивает время перестройки почти на 450 нс в связи с резким увеличением вариантов перебора
при перестройке.
Кроме того, так как реальная размерность критических важных объектов не менее двух порядков и более ( 20  20 и выше) можно ожидать резкое
увеличение времени перестройки либо поиска кратчайшего пути обхода отказавшей связи. Очевидно, что применение для этих целей программных
средств неприемлемо. В связи с этим, необходимо использование специализированных аппаратных средств для оперативного устранения отказа процессорного модуля многопроцессорной системы или межпроцессорного линка с
последующим переразмещением ранее назначенных подпрограмм видоизмененной топологии системы вследствие изменения топологической организации СЛУ.
89
4.4 Выводы
1. Выполнены программное моделирование и статистические исследования на ЭВМ алгоритма, реализующего разработанный метод отказоустойчивого переразмещения.
2. Для повышения отказоустойчивости критических важных объектов
разработан алгоритм, позволяющий независимо реагировать на внештатные
ситуации отказа либо процессорных модулей, либо на отказы межпроцессорных связей и независимо друг от друга реагировать на эти события.
3. В результате программного моделирования показано, что увеличение размерности матрицы процессоров приводит к существенному возрастанию вариантов переназначения отказавших процессорных модулей на свободные резервные процессорные модули и/или вариантов поиска кратчайших
маршрутов в результате отказа межпроцессорной связи.
4. Разработанные метод ускорения поиска варианта размещения, позволяющий при увеличении размерности матрицы процессоров на одну величину, увеличить время перестройки на 450 нс не смотря на резкое увеличение
вариантов перебора при перестройках и алгоритм отказоустойчивого переразмещения с учетом отказов процессоров и/или межпроцессорных связей
позволяет не только оперативно реагировать на отказ процессора или межпроцессорной связи, но и повысить коэффициент готовности системы.
5. Анализ результатов, полученных в диссертационной работе позволяет сделать вывод о целесообразности применения аппаратных средств в
критических системах и результативности предложенных подходов для перспективных мультикомпютерных систем.
90
Заключение
Диссертационная работа посвящена решению научной задачи, состоящей в разработке методов и аппаратных средств оперативного переразмещения выполняемых системой программ на множестве работоспособных модулей (с учётом резерва), обеспечивающих минимизацию времени межпроцессорного обмена данными после ликвидации последствий отказа.
В ходе решения этой задачи получены следующие основные результаты.
1. Создан метод оперативного переразмещения программ в отказоустойчивых мультикомпьютерных системах, использующий диагональное
распределение скользящего резерва непосредственно в матрице процессоров,
позволяющий минимизировать время межпроцессорного обмена данными
путем целенаправленного пошагового снижения отклонения указанного времени от нижней оценки наибольшей частной коммуникационной задержки,
определяемой исходя из длин заранее формируемых (статических) маршрутов передачи данных в присутствии неоднородностей, обусловленных отказами физической структуры системы.
2. На базе созданного метода разработан аппаратно-ориентированный
алгоритм оперативного переразмещения программ в отказоустойчивых мультикомпьютерных системах, состоящий в поиске резервного модуля для замещения отказавшего процессора на множестве ближайших к отказу резервных модулей и позволяющий снизить время поиска нового варианта размещения программ в системе после возникновения отказа.
3. Разработана структурно-функциональная организация специализированного устройства оперативного переразмещения программ в отказоустойчивых мультикомпьютерных системах, позволяющего осуществлять оперативный поиск резервного модуля для замещения отказавшего процессора,
перераспределять подпрограммы на множестве работоспособных процессоров и корректировать маршруты обмена данными с учетом распределения
91
неоднородностей, обусловленных отказами в матрице ОМС на основе аппаратно реализуемых матричных операций.
4. На основе имитационного моделирования установлено, что разработанный алгоритм оперативного переразмещения программ в ОМС и устройство на его основе позволяют на 2-3 порядка снизить время поиска нового
варианта размещения программ в системе после возникновения отказа по
сравнению с известными программно реализуемыми аналогами, что обеспечивает повышение оперативности реакции на отказ и, как следствие, увеличение коэффициента готовности ОМС.
5. Показано, что аппаратная сложность разработанного устройства для
всех практически значимых случаев не превышает 106 эквивалентных вентилей (ЭВ), что меньше по сравнению с аналогичным устройством примерно на
104 ЭВ, и позволяет использовать его как в существующих, так и в перспективных мультикомпьютерных системах, содержащих от десятка до сотен тысяч процессорных модулей.
92
БИБЛИОГРАФИЧЕСКИЙ СПИСОК
1. Бикташев Р.А., Князьков В.С. Многопроцессорные системы. Архитектура, топология, анализ производительности: Учебное пособие. – Пенза:
Пенз. гос. ун-т, 2003.
2. www.parallel.ru
3. Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. СПб.:
БХВ-Петербург, 2002. 608 с.
4. Воеводин Вл.В., Капитонова А.П. Методы описания и классификации вычислительных систем. М.: Изд. МГУ, 1994. 103 с.
5. Амамия М., Танака Ю. Архитектура ЭВМ и искусственный интеллект. М.: Мир, 1993. 400 с.Корнеев В.В., Киселев А.В. современные микропроцессоры. М.: НОЛИДЖ, 1998.240 с.
6. Корнеев В.В., Киселев А.В. Современные микропроцессоры. М.:
НОЛИДЖ, 1998.240 с.
7. Высокоскоростные вычисления. Архитектура, производительность,
прикладные алгоритмы и программы Супер ЭВМ / Под ред. Ковалика. –М.:
Радио и связь, 1988. – 432 С.
8. Flynn M.J. Some computer organization and their effectivness // IEEETC. – 1972. – vol. C-21, №9. – РР. 296–304.
9. Борзов Д.Б. Модели и методы размещения задач в параллельных системах и устройства для их реализации / Д.Б. Борзов. – канд. дис., Курск,
2002
10.Virginia Lo, Wanqian Liu. Noncontiguous processor allocation algorithms for mesh-connected multicomputers // IEEE Transactions on parallel and
dist. Systems. – 1997. – Vol. 8, №7. – PP. 712–725.
11.Коршунов Ю.М. Математические основы кибернетики. – М.: Энергоатомиздат, 1987. – 496 с.
12.Воеводин В.В. Математические модели и методы в параллельных
процессах. – М.: Наука., 1986. – 296 с.
93
13.Anderson G.A., Jensen L.D. Computer interconnection structures, taxonomy, characteristics and examples // Computing Surveys of AC. – 1975. – Vol. 7,
№4. – РР. 197–213.
14.Jafari H., Lewis T.G., Spragins J.D. Simulation of a class of ring structured networks // IEEE Transactions on Computers. – 1980. – Vol. C–29, №5. –
PP. 385–392.
15.Arden B.W., Lee H. Analysis of chordial ring network // IEEETC. –
1981. –Vol. C–30, №4. – РР. 291–295.
16.Reames C.C., Liu M. T. A loop network simultaneous transmission of
variable length message // In: 2nd ASCA, Houston, Tex. – 1975. – PP. 7–12.
17.Siegel H.J., McMillen R.J., Mueller P.T. A survey of interconnection
methods for reconfigurable parallel processing systems // In: AFIPS Conf. Proc.,
Washington, D.C. – 1979. – Vol. C–29, №2. – РР. 108–115.
18.Зотов И.В. и др. Организация и синтез микропрограммных мультимикроконтроллеров. – Курск.: Изд-во «Курск», 1999. – 368 с.
19.Pfister, G. Sizing Up Parallel Architectures [Text] / G Pfister // DataBase
Programming & Design OnLine. May 1998, Barak and O. La'adan. Performance of
the MOSIX Parallel System for a Cluster of PC's. In Proceedings of HPCN Europe conference, 1997
20.А.В. Гергель, Р.В. Виноградов. Оценка сложности коммуникационных операций в кластерных вычислительных системах / Нижегор. гос. тех.
ун-т им. Н.И. Лобачевского.– С. 73-77
21.Wittie L.D. Communication structures for large networks of microcomputers // IEEE Transactions on Computers. – 1981. – Vol. C–30, №4. – PP. 264–
273.
22.K. Windisc, V.M. Lo, B. Bose. Contiguous and noncontiguous processor
allocation algorithms for k-ary n-cubes // Proc. Int’l Conf. Parallel processing. –
1995.
94
23.Ma P.R., Lee E.Y.S., Tsuchiya M. A task allocation model for distributed
computing systems // IEEE Transactions on Computers. — 1982. — Vol. C–31,
№1. — PP. 4147.
24.Chu W.W., Holloway L.J., Lan M.T., Efe K. Task allocation in distributed data processing // IEEE Computer. — 1980. — №11. — PP. 5769.
25.Lee Ch.H., Lee D., Kim M. Optimal task assignment in linear array
networks // IEEE Transactions on Computers. — 1992. — Vol. 41, №7. —
PP. 877880.
26.G.S. Rao, H.S. Stone, T.C. Hu. Assignment of tasks in a distributed processor system with limited memory // IEEE Trans. Comput. – C–28 (4), – 1979, –
PP. 291 – 299.
27.Jo B.-L. et al. Task assignment in homogeneous linear array networks //
IEICE Trans. – 1991. – Vol. 74, №9. – PP. 2642–2648.
28.H.S. Stone, S.H. Bokhair. Control of distributed processes // Computer. –
1978. – №6. – PP. 97–106.
29.L.M. Ni, K. Hwang. Optimal load balancing strategies for a multiply processor system // Proc. Inernat. Conf. Parallel. Proc. – 1981. – PP. 352 – 357.
30.роGottlieb A., Schawarts J.T. Networks and algorithms for very-largescale parallel computation // Computer. – 1982. – Vol. 15, №1. – РР. 27–36.
31.Шоу А. Логическое проектирование операционных систем. - М.:
Мир, 1981.
32.Bokhari Sh. H. On the mapping problem // IEEE Transactions on Computers. — 1981. — Vol. C–30, №3. — PP. 207214.
33.Sadayappan P., Ercal F. Nearest-neighbor mapping of finite element
graphs onto processor meshes // IEEE Transactions on Computers. — 1987. —
Vol. C–36, №12. — PP. 14081424.
34.K. Efe. Heuristic models for task assignment scheduling in distributed
systems // IEEE Comput. – 1982. – 15(6). – PP. 50–56.
95
35.B.W. Kerninghan, S. Lin. An efficient heuristic procedure for partitioning graph // Bell Syst. Tech J. – 1970. – №2, PP. 291–307.
36.H.S. Stone. Multiprocessor scheduling with the aid of network flow algorithms // IEEE Trans. Software Eng. – 1977. – Vol. SE–3. – PP. 85–93.
37.P. Chuang, N. Tseng. An efficient submesh allocation strategy for mesh
computer systems // Proc. 1991 Int’l Conf. Distributed Computer Systems. – 1991.
– PP. 256–263.
38.Y. Zhu. Efficient processor allocation strategies for mesh-connected parallel computers // Parallel and distributed computers. – 1992. – Vol. 16. – PP. 328–
337.
39.Борзов Д.Б., Зотов И.В., Титов В.С. О субоптимальном размещении
процессов и данных в кольцевых сетях. – Известия вузов. Приборостроение.
– Санкт-Петербург, – 2003, – Т46, №11, С. 48-54.
40.Борзов, Д.Б. Процедура размещения комплексов алгоритмов управления в микроконтроллерных сетях с кольцевой структурой / Д.Б. Борзов,
И.В. Зотов // Сборник материалов 4-ой международной конференции «Распознавание-99». – Курск, 1999. – С. 137–139.
41.Борзов Д.Б. Устройство поиска нижней оценки размещения в матричных системах / Патент РФ №2275681, БИ №12; от 27.04.2006.
42.Борзов Д.Б., Зотов И.В., Титов В.С. Устройство для формирования
субоптимального размещения и его оценки / Патент РФ №2193796, БИ №33,
2002.
43.Борзов Д.Б., Горощенков Д.С. Устройство планирования размещения задач в системах с кольцевой организацией при направленной передаче
информации / Патент РФ №2285289, БИ №28, 2006.
44.Борзов Д.Б. Устройство поиска нижней оценки размещения в матричных системах / Патент РФ №2275681, БИ №12, 2006.
45. Genetic Algorithm Based Parallel Jobs Scheduling / S. Shapovalov, G.
Tarasov // In Proceedings of First Russia and Pacific Conference on Computer
96
Technology and Applications (RPC 2010). - Vladivostok: IACP FEB RAS. - 2010.
- P. 211-216.
46.Борзов Д.Б. Метод снижения коммуникационной задержки путем
субоптимального размещения задач в матричных базовых блоках кластера //
Телекоммуникации. 2008. №4. С. 21-25.
47.Борзов Д.Б., Типикин А.П. Метод ускорения выполнения процедуры
планирования размещения задач в кластерных системах / Материалы девятого международного научно-практического семинара «Практика и перспективы развития партнерства в сфере высшей школы» Книга 1. – Таганрог–
Донецк. 2008. – С. 31-35.
48.Tanenbaum A.S. Distributed Operation Systems // Prentice-Hall Engeneering/Science/Mathematics; 1st edition. – 1994. - PP. 1-648.
49.Куперман М.Б., Аверьянов Д.Е. Резервный центр обработки данных.
Оценка надежности // Электроника НТБ. 2010. №4. – С. 30-38.
50.George Candea, Shinichi Kawamoto, Yuichi Fujiki, Greg Friedman, Armando Fox. Microreboot - A Technique for Cheap Recovery / Conference
«Operating Systems Design and Implementation - OSDI» - Los Angeles. 2004. pp.
31-44.
51.Оре О. Теория графов. — М.: Наука, 1968. — 352 с.
52.Соколова, Ю.В. Переразмещение подпрограмм в отказоустойчивых
мультипроцессорных системах [Текст] / Ю.В. Соколова, Д.Б. Борзов, В.В.
Минайлов // Известия вузов. Приборостроение. – Санкт-Петербург, – 2013, –
№6, С. 39-44.
53.Борисенко, Ю.В. Метод и аппаратно-ориентированный алгоритм
переразмещения подпрограмм в мультикомпьютерах при отказе процессоров
и связей между ними [Текст] / Ю.В. Борисенко, Д.Б. Борзов, А.С. Сизов // Телекоммуникации. – Ежемесячный научно-технический, информационно–
аналитический и учебно-методический журнал. – 2013, – №11. С.45-51.
97
54.Борисенко, Ю.В. Метод оперативного переразмещения подпрограмм в мультиконтроллерах с учетом отказов линков [Текст] / Ю.В. Борисенко, Д.Б. Борзов, А.С. Сизов // Известия ЮЗГУ, – 2012, – №6(45), С. 50-54.
55.Борисенко, Ю.В. Акселератор переразмещения подпрограмм в отказоустойчивых мультикомпьютерах [Текст] / Ю.В. Борисенко // Интернетжурнал «Науковедение», – 2013, – №5, С. 1-9.
56.Патент №2447485 Российская Федерация G06F7/76, G06F17/10.
Устройство поиска нижней оценки размещения в матричных системах при
двунаправленной передачи информации [Текст] / Ю.В. Соколова, Д.Б. Борзов, заявл. 11.09.2009; опубл. 10.04.2012, БИ №10, 2012.
57.Патент №2451334 Российская Федерация G06F17/50. Устройство
для оценки степени загрузки каналов в системах с древовидной топологической организацией при направленной передаче информации [Текст] / Ю.В.
Соколова и др., заявл. 15.03.2011; опубл. 20.05.2012, БИ №14, 2012.
58.Патент №2470357 Российская Федерация. Устройство поиска нижней оценки размещения в полносвязных матричных системах при однонаправленной передаче информации [Текст] / Ю.В. Соколова, Д.Б. Борзов // заявл. 27.12.2010; опубл. 20.12.2012, Бюл. №3.
59.Соколова, Ю.В. Алгоритм переразмещения подпрограмм в отказоустойчивых мультикомпьютерах [Текст] / Ю.В. Соколова, Д.Б. Борзов, И.И.
Масюков // Сборник трудов XVIII Международной научно-технической конференции «Машиностроение и техносфера XXI века. Т1». – Донецк, 2012. –
С. 101-103.
60.Соколова, Ю.В. Методика пеперазмещения подпрограмм в отказоустойчивых мультикомпьютерах [Текст] / Ю.В. Соколова, Д.Б. Борзов //
Сборник трудов XVIII Международной научно-технической конференции
«Машиностроение и техносфера XXI века. Т1». – Донецк, 2011. – С. 86-89.
61.Соколова, Ю.В. Организация акселератора вычисления минимального значения коммуникационной задержки в полносвязных матричных
мультиконтроллерах [Текст] / Ю.В. Соколова, Д.Б. Борзов, В.В. Минайлов,
98
А.А. Родин // Сборник материалов XVII Российской научно-технической
конференции с международным участием «Материалы и упрочняющие технологии-2010». Часть 2 / Курск. гос. тех. ун-т. Курск, 2010. С. 195-199.
62.Соколова, Ю.В. Переразмещение подпрограмм в отказоустойчивых
мультикомпьютерах при отказе связей [Текст] / Ю.В. Соколова, Д.Б. Борзов //
Сборник материалов X Международной конференции «Оптико-электронные
приборы и устройства в системах распознавания образов, обработки изображений и символьной информации». – Курск, 2012.– С. 238-240.
63.Соколова, Ю.В. Подход к обеспечению отказоустойчивости в мультикомпьютерных системах [Текст] / Ю.В. Соколова, Д.Б. Борзов // Інженер.
Студентський науково-технічний журнал. - Донецьк: ДонНТУ, 2012. - № 13. 177 с. - С. 84 - 86.
64.Борисенко, Ю.В. Алгоритм оперативного переразмещения подпрограмм в системах логического управления [Текст] / Ю.В. Борисенко // Сборник материалов XI Международной конференции «Оптико-электронные
приборы и устройства в системах распознавания образов, обработки изображений и символьной информации». – Курск, 2012.– С. 228-230.
65.Соколова, Ю.В. Подход к задаче отказоустойчивого размещения
процессоров в мультипроцессорной системе [Текст] / Ю.В. Соколова // тезисы докладов Научно-технической международной молодёжной конференции
«Системы, методы, техника и технологии обработки медиаконтента». –
Москва, 2011. С. 93.
66.Борисенко, Ю.В. Программа для отказоустойчивого переразмещения подпрограмм в мультикомпьютерах [Текст] / Ю.В. Борисенко, Д.Б. Борзов, А.А. Поляков // Свидетельство о регистрации программы для ЭВМ
№2013612984. заявл. 6.02.2013, опубл. 20.03.2013.
67.Борисенко, Ю.В. Программа для отказоустойчивого переразмещения подпрограмм с учетом отказов межпроцессорных связей [Текст] / Ю.В.
Борисенко, Д.Б. Борзов, А.А. Поляков // Свидетельство о регистрации программы для ЭВМ №2013612985. заявл. 6.02.2013, опубл. 20.03.2013.
99
68.Гук М. Аппаратные интерфейсы ПК. – СПб.: Питер, 2003.– 528 с.
69.Танэнбаум Э. Архитектура компьютера. 4-е издание. – СПб.: Питер,
2003.– 704 с.
70.Борзов, Д.Б. Интерфейсы периферийных устройств [Текст]: учеб.
пособие для вузов / Д.Б. Борзов, И.Е. Чернецкая; Курск гос. тех. ун-т. Курск,
2007. 175 с.
71.Борзов, Д.Б., Аль–Мараят Б.И., Масолов А.С. Метод снижения коммуникационной задержки путем субоптимального размещения задач в матричных базовых блоках кластера / Телекоммуникации. – Ежемесячный научно-технический, информационно–аналитический и учебно-методический
журнал. – 2008, – №4. С. 21-25.
72.Борзов, Д.Б., Аль–Мараят Б.И., Типикин А.П. Акселератор планирования размещения задач в кластерных вычислительных системах высокой готовности / Известия вузов. Приборостроение. – Санкт-Петербург, – 2008, –
№2, С. 29-33.
73.E. W. Dijkstra. A note on two problems in connexion with graphs. //
Numerische Mathematik. V. 1 (1959), P. 269-271
74.А. В. Левитин. Жадные методы: Алгоритм Дейкстры // Алгоритмы:
введение в разработку и анализ = Introduction to The Design and Analysis of
Aigorithms. — М.: «Вильямс», 2006. — С. 189—195.
75.Шило В.Л. Популярные цифровые микросхемы: Справочник. – Металлургия, Челябинск, 1988. – 352 с.
76. Микросхемы и их применение / Батушев В.А., Вениаминов В.Н.,
Ковалев В. – М.: Энергия, 1978. – 248 с.
77.Интегральные микросхемы: Справочник / Тарабрин Б.В., Лунин
Л.Ф., Смирнов Ю.Н.. – М.: Радио и связь, 1984. –528 с.
78.Петровский И.И. и др. Логические ИС КР1533, КР1554: Справочник
в 2–х ч. – М.: ТОО «Бином», 1993.
100
79.Борзов Д.Б., Титов В.С. Параллельные вычислительные системы
(архитектура, принципы размещения задач): Монография. – Курск. гос. техн.
ун-т, 2008. – 156 с.
80.Зотов, И.В. Теоретические основы синтеза схем быстродействующих устройств распределенной децентрализованной координации параллельных микропрограмм в мультиконтроллерах: дис. д-ра техн. наук:
05.13.05: защищена 07.12.2006: утв. 15.03.2007 / Зотов Игорь Валерьевич. –
Курск, 2006. – 383 с.
101
Приложение 1
Пакет программ моделирования процедур планирования размещения
подпрограмм в отказоустойчивых мультипроцессорных системах
unit Main;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls, StdCtrls, ExtCtrls, Spin, ColorGrd, Buttons, ExtDlgs,
TeeProcs, TeEngine, Chart, Series, Grids, Menus;
type
TForm1 = class(TForm)
StatusBar1: TStatusBar;
PopupMenu1: TPopupMenu;
N1: TMenuItem;
N2: TMenuItem;
N3: TMenuItem;
PageControl1: TPageControl;
TS_Setting: TTabSheet;
TS_Diag: TTabSheet;
PageControl2: TPageControl;
TS_Param: TTabSheet;
GroupBox2: TGroupBox;
Label1: TLabel;
Label8: TLabel;
Label9: TLabel;
Label10: TLabel;
SpinEdit1: TSpinEdit;
SpinEdit2: TSpinEdit;
SpinEdit3: TSpinEdit;
GroupBox3: TGroupBox;
Label2: TLabel;
Label3: TLabel;
SpeedButton1: TSpeedButton;
Label4: TLabel;
SpeedButton2: TSpeedButton;
Label5: TLabel;
SpeedButton3: TSpeedButton;
Label6: TLabel;
SpeedButton4: TSpeedButton;
Image2: TImage;
Label7: TLabel;
ComboBox1: TComboBox;
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
TrackBar1: TTrackBar;
GroupBox4: TGroupBox;
Button1: TButton;
TS_MatrW: TTabSheet;
SG_W: TStringGrid;
TS_Stat: TTabSheet;
PageControl3: TPageControl;
TS_View: TTabSheet;
GroupBox8: TGroupBox;
Image1: TImage;
102
TS_MatrX: TTabSheet;
SG_L: TStringGrid;
TS_MatrR: TTabSheet;
SG_R: TStringGrid;
TS_MatrD: TTabSheet;
SG_D: TStringGrid;
TS_MatrS: TTabSheet;
SG_S: TStringGrid;
PageControl4: TPageControl;
TS_Iter: TTabSheet;
Memo1: TMemo;
TS_GraPer: TTabSheet;
Chart1: TChart;
Series1: TLineSeries;
TS_GraM: TTabSheet;
Chart2: TChart;
RadioGroup1: TRadioGroup;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
BitBtn3: TBitBtn;
BitBtn4: TBitBtn;
Panel1: TPanel;
Button2: TButton;
BitBtn5: TBitBtn;
TS_MatrP: TTabSheet;
TS_MatrM: TTabSheet;
SG_P: TStringGrid;
SG_M: TStringGrid;
Series2: TBarSeries;
RadioGroup2: TRadioGroup;
TS_MatrV: TTabSheet;
SG_V: TStringGrid;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure SpinEdit1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure SG_WDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_WClick(Sender: TObject);
procedure SG_WKeyPress(Sender: TObject; var Key: Char);
procedure SG_WKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure N1Click(Sender: TObject);
procedure N3Click(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure SG_DDblClick(Sender: TObject);
procedure RadioGroup1Click(Sender: TObject);
procedure BitBtn1Click(Sender: TObject);
procedure BitBtn2Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure BitBtn5Click(Sender: TObject);
procedure SG_LDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_LClick(Sender: TObject);
procedure SG_DDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_DClick(Sender: TObject);
procedure SG_SDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_SClick(Sender: TObject);
procedure SG_PDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
103
procedure SG_PClick(Sender: TObject);
procedure SG_MDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_MClick(Sender: TObject);
procedure SG_RDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_RClick(Sender: TObject);
procedure BitBtn4Click(Sender: TObject);
procedure BitBtn3Click(Sender: TObject);
procedure SG_VDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure SG_VClick(Sender: TObject);
private
{ Private declarations }
procedure InitNet;
function LinkError: boolean;
function ProcError: boolean;
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
const
MaxN = 10;
type
PProc = ^TProc; // ссылка на процессор
PLink = ^TLink; // ссылка на связь
TProcMode = (pmReserve, pmWarp); // тип процессора: резервный, основной
TProcState = (psGood, psBad, psCapture); // состояние процессора: рабочий, плохой, занят
TLinkState = (lsGood, lsBad); // состояние связи: рабочая, плохая
TWayState = (wsNo, wsYes); // связь задействована в пути или нет
TLink = record // связь (ребро)
Name: string; // имя
State: TLinkState; // состояние
Weight: word; // вес
WayUse: TWayState; // входит в путь
P: PProc; // процессор (вершина)
end;
TProc = record // процессорный элемент
Num: DWORD; // порядковый номер
Mode: TProcMode; // тип
Name: string; // имя
Addr: string; // логический адрес
State: TProcState; // состояние
Row: byte; // индекс строки
Col: byte; // индекс столбца
U: PLink; // связь вверх
D: PLink; // связь вниз
L: PLink; // связь влево
R: PLink; // связь вправо
LU: PLink; // связь влево-вверх
LD: PLink; // связь влево-вниз
104
RU: PLink; // связь вправо-вверх
RD: PLink; // связь вправо-вниз
end;
var
PenWidth: byte; // ширина пера
goodClr: TColor; // цвет - рабочий
badClr: TColor; // цвет - плохой
captureClr: TColor; // цвет - занятый
grdClr: TColor; // цвет фона
isRun: boolean; // флаг активности авто режима
PauseSec: integer;
NumError: integer; // номер отказа
TTT: integer;
ESW: byte;
Prioritet: integer;
Stat: integer;
AllStat: integer;
N: byte; // размерность сети
P: array [1..2*MaxN*MaxN] of PProc; // процессоры (вершины)
W: array [1..MaxN*MaxN*2, 1..MaxN*MaxN*2] of byte; // веса связей (ребер)
Pij: array [1..MaxN, 1..MaxN] of PProc; // адреса основных процессоров
Rij: array [1..MaxN, 1..MaxN] of PProc; // адреса резервных процессоров
Lij: array [1..2*MaxN*MaxN, 1..2*MaxN*MaxN] of PLink; // адреса связей (ребер)
D: array [1..2*MaxN*MaxN, 1..2*MaxN*MaxN] of DWORD;
S: array [1..2*MaxN*MaxN, 1..2*MaxN*MaxN] of byte;
V: array [1..MaxN*MaxN*2, 1..MaxN*MaxN*2] of byte;
Dp: array [1..2*MaxN*MaxN, 1..2*MaxN*MaxN] of DWORD;
Sp: array [1..2*MaxN*MaxN, 1..2*MaxN*MaxN] of byte;
MaxRoad: DWORD;
procedure ReadW(SG: TStringGrid); // заполнение матрицы весов из StringGrid
var
i, j: byte; // индексы
err: integer; // код ошибки преобразования
begin
(* матрица весов *)
// веса ребер
for i:=1 to 2*N*N do // из i-ой вершины
for j:=1 to 2*N*N do // в j-ую
begin
val(SG.Cells[j, i], W[i][j], err); // преобразование из строки в число
if err <> 0 then // если ошибка
W[i][j]:=0; // ребра нет
Lij[i][j]:=nil; // адрес ребра
end;
end;
procedure ReInitLink;
var
i, j: byte; // индексы
begin
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
if Lij[i][j] <> nil then // ребро существует
Lij[i][j]^.State:=lsGood;
end;
procedure ViewLinkProc(SG: TStringGrid);
var
i, j: byte; // индексы
begin
105
for i:=1 to 2*N*N do // из i-ой вершины
for j:=1 to 2*N*N do // в j-ую
if Lij[i][j] = nil then
V[i][j]:=0
else
if Lij[i][j]^.State = lsGood then
V[i][j]:=1
else
V[i][j]:=0;
for i:=1 to N do
for j:=1 to N do
begin
if Pij[i][j]^.State = psBad then
begin
if Pij[i][j]^.U <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+1]:=0;
V[((i-1-1)*N+(j-1+0))*2+1][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.D <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+1]:=0;
V[((i-1+1)*N+(j-1+0))*2+1][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.L <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1-1))*2+2]:=0;
V[((i-1+0)*N+(j-1-1))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.R <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1+0))*2+2]:=0;
V[((i-1+0)*N+(j-1+0))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.LU <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1-1))*2+2]:=0;
V[((i-1-1)*N+(j-1-1))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.LD <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1-1))*2+2]:=0;
V[((i-1+1)*N+(j-1-1))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.RU <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+2]:=0;
V[((i-1-1)*N+(j-1+0))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
if Pij[i][j]^.RD <> nil then
begin
V[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+2]:=0;
V[((i-1+1)*N+(j-1+0))*2+2][((i-1)*N+(j-1))*2+1]:=0;
end;
end;
if Rij[i][j]^.State = psBad then
begin
if Rij[i][j]^.U <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+2]:=0;
V[((i-1-1)*N+(j-1+0))*2+2][((i-1)*N+(j-1))*2+2]:=0;
end;
106
if Rij[i][j]^.D <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+2]:=0;
V[((i-1+1)*N+(j-1+0))*2+2][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.L <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+0))*2+1]:=0;
V[((i-1+0)*N+(j-1+0))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.R <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+1))*2+1]:=0;
V[((i-1+0)*N+(j-1+1))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.LU <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+1]:=0;
V[((i-1-1)*N+(j-1+0))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.LD <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+1]:=0;
V[((i-1+1)*N+(j-1+0))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.RU <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+1))*2+1]:=0;
V[((i-1-1)*N+(j-1+1))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
if Rij[i][j]^.RD <> nil then
begin
V[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+1))*2+1]:=0;
V[((i-1+1)*N+(j-1+1))*2+1][((i-1)*N+(j-1))*2+2]:=0;
end;
end;
end;
for i:=1 to 2*N*N do // из i-ой вершины
for j:=1 to 2*N*N do // в j-ую
SG.Cells[j,i]:=IntToStr(V[i][j]);
end;
procedure ViewLinkState(SG: TStringGrid);
var
i, j: byte; // индексы
begin
for i:=1 to 2*N*N do // из i-ой вершины
for j:=1 to 2*N*N do // в j-ую
if Lij[i][j] = nil then
SG.Cells[j,i]:='0'
else
if Lij[i][j]^.State = lsGood then
SG.Cells[j,i]:='1'
else
SG.Cells[j,i]:='0';
end;
procedure CreateNet; // создание сети
var
i, j, k: byte; // индексы
Address: string; // адрес
begin
107
(* процессоры *)
for i:=1 to N do // строка
for j:=1 to N do // столбец
begin
k:=(i-1)*2*N+j*2; // номер вершины + 1
Address:=IntToStr(i)+IntToStr(j); // адрес
// основной
New(P[k-1]); // выделение памяти
P[k-1]^.Num:=k-1; // порядковый номер
P[k-1]^.Mode:=pmWarp; // основной
P[k-1]^.Name:='ПЭ:'+Address; // имя
P[k-1]^.Addr:=Address; // логический адрес
P[k-1]^.State:=psCapture; // состояние занят
P[k-1]^.Row:=i; // индекс строки
P[k-1]^.Col:=j; // индекс столбца
Pij[i][j]:=P[k-1]; // сохранение адреса в матрице основных процессоров
// резервный
New(P[k]); // выделение памяти
P[k]^.Num:=k; // порядковый номер
P[k]^.Mode:=pmReserve; // резервный
P[k]^.Name:='РЭ:'+Address; // имя
P[k]^.Addr:=''; // логический адрес
P[k]^.State:=psGood; // состояние рабочий
P[k]^.Row:=i; // индекс строки
P[k]^.Col:=j; // индекс столбца
Rij[i][j]:=P[k]; // сохранение адреса в матрице резервных процессоров
end;
// связи
for i:=1 to N do // из i-ой вершины
for j:=1 to N do // в j-ую
begin
(* основной *)
// вверх
if i > 1 then
begin
New(Pij[i][j]^.U); // выделение памяти
Pij[i][j]^.U^.Name:=Pij[i][j]^.Name+'->'+Pij[i-1][j+0]^.Name; // имя связи
Pij[i][j]^.U^.State:=lsGood; // состояние связи
Pij[i][j]^.U^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+1]; // вес
Pij[i][j]^.U^.P:=Pij[i-1][j+0]; // вершина
end
else Pij[i][j]^.U:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+1]:=Pij[i][j]^.U; // ребро
// вниз
if i < N then
begin
New(Pij[i][j]^.D); // выделение памяти
Pij[i][j]^.D^.Name:=Pij[i][j]^.Name+'->'+Pij[i+1][j+0]^.Name; // имя связи
Pij[i][j]^.D^.State:=lsGood; // состояние связи
Pij[i][j]^.D^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+1]; // вес
Pij[i][j]^.D^.P:=Pij[i+1][j+0]; // вершина
end
else Pij[i][j]^.D:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+1]:=Pij[i][j]^.D; // ребро
// вправо
New(Pij[i][j]^.R); // выделение памяти
Pij[i][j]^.R^.Name:=Pij[i][j]^.Name+'->'+Rij[i+0][j+0]^.Name; // имя связи
Pij[i][j]^.R^.State:=lsGood; // состояние связи
Pij[i][j]^.R^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1+0))*2+2]; // вес
Pij[i][j]^.R^.P:=Rij[i+0][j+0]; // вершина
Lij[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1+0))*2+2]:=Pij[i][j]^.R; // ребро
// влево
108
if j > 1 then
begin
New(Pij[i][j]^.L); // выделение памяти
Pij[i][j]^.L^.Name:=Pij[i][j]^.Name+'->'+Rij[i+0][j-1]^.Name; // имя связи
Pij[i][j]^.L^.State:=lsGood; // состояние связи
Pij[i][j]^.L^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1-1))*2+2]; // вес
Pij[i][j]^.L^.P:=Rij[i+0][j-1]; // вершина
end
else Pij[i][j]^.L:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1+0)*N+(j-1-1))*2+2]:=Pij[i][j]^.L; // ребро
// вправо-вверх
if i > 1 then
begin
New(Pij[i][j]^.RU); // выделение памяти
Pij[i][j]^.RU^.Name:=Pij[i][j]^.Name+'->'+Rij[i-1][j+0]^.Name; // имя связи
Pij[i][j]^.RU^.State:=lsGood; // состояние связи
Pij[i][j]^.RU^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+2]; // вес
Pij[i][j]^.RU^.P:=Rij[i-1][j+0]; // вершина
end
else Pij[i][j]^.RU:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1+0))*2+2]:=Pij[i][j]^.RU; // ребро
// влево-вверх
if (i > 1)and(j > 1) then
begin
New(Pij[i][j]^.LU); // выделение памяти
Pij[i][j]^.LU^.Name:=Pij[i][j]^.Name+'->'+Rij[i-1][j-1]^.Name; // имя связи
Pij[i][j]^.LU^.State:=lsGood; // состояние связи
Pij[i][j]^.LU^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1-1))*2+2]; // вес
Pij[i][j]^.LU^.P:=Rij[i-1][j-1]; // вершина
end
else Pij[i][j]^.LU:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1-1)*N+(j-1-1))*2+2]:=Pij[i][j]^.LU; // ребро
// вправо-вниз
if i < N then
begin
New(Pij[i][j]^.RD); // выделение памяти
Pij[i][j]^.RD^.Name:=Pij[i][j]^.Name+'->'+Rij[i+1][j+0]^.Name; // имя связи
Pij[i][j]^.RD^.State:=lsGood; // состояние связи
Pij[i][j]^.RD^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+2]; // вес
Pij[i][j]^.RD^.P:=Rij[i+1][j+0]; // вершина
end
else Pij[i][j]^.RD:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1+0))*2+2]:=Pij[i][j]^.RD; // ребро
// влево-вниз
if (i < N)and(j > 1) then
begin
New(Pij[i][j]^.LD); // выделение памяти
Pij[i][j]^.LD^.Name:=Pij[i][j]^.Name+'->'+Rij[i+1][j-1]^.Name; // имя связи
Pij[i][j]^.LD^.State:=lsGood; // состояние связи
Pij[i][j]^.LD^.Weight:=W[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1-1))*2+2]; // вес
Pij[i][j]^.LD^.P:=Rij[i+1][j-1]; // вершина
end
else Pij[i][j]^.LD:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+1][((i-1+1)*N+(j-1-1))*2+2]:=Pij[i][j]^.LD; // ребро
(* резервный *)
// вверх
if i > 1 then
begin
New(Rij[i][j]^.U); // выделение памяти
Rij[i][j]^.U^.Name:=Rij[i][j]^.Name+'->'+Rij[i-1][j+0]^.Name; // имя связи
Rij[i][j]^.U^.State:=lsGood; // состояние связи
Rij[i][j]^.U^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+2]; // вес
109
Rij[i][j]^.U^.P:=Rij[i-1][j+0]; // вершина
end
else Rij[i][j]^.U:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+2]:=Rij[i][j]^.U; // ребро
// вниз
if i < N then
begin
New(Rij[i][j]^.D); // выделение памяти
Rij[i][j]^.D^.Name:=Rij[i][j]^.Name+'->'+Rij[i+1][j+0]^.Name; // имя связи
Rij[i][j]^.D^.State:=lsGood; // состояние связи
Rij[i][j]^.D^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+2]; // вес
Rij[i][j]^.D^.P:=Rij[i+1][j+0]; // вершина
end
else Rij[i][j]^.D:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+2]:=Rij[i][j]^.D; // ребро
// вправо
if j < N then
begin
New(Rij[i][j]^.R); // выделение памяти
Rij[i][j]^.R^.Name:=Rij[i][j]^.Name+'->'+Pij[i+0][j+1]^.Name; // имя связи
Rij[i][j]^.R^.State:=lsGood; // состояние связи
Rij[i][j]^.R^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+1))*2+1]; // вес
Rij[i][j]^.R^.P:=Pij[i+0][j+1]; // вершина
end
else Rij[i][j]^.R:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+1))*2+1]:=Rij[i][j]^.R; // ребро
// влево
New(Rij[i][j]^.L); // выделение памяти
Rij[i][j]^.L^.Name:=Rij[i][j]^.Name+'->'+Pij[i+0][j+0]^.Name; // имя связи
Rij[i][j]^.L^.State:=lsGood; // состояние связи
Rij[i][j]^.L^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+0))*2+1]; // вес
Rij[i][j]^.L^.P:=Pij[i+0][j+0]; // вершина
Lij[((i-1)*N+(j-1))*2+2][((i-1+0)*N+(j-1+0))*2+1]:=Rij[i][j]^.L; // ребро
// вправо-вверх
if (i > 1)and(j < N) then
begin
New(Rij[i][j]^.RU); // выделение памяти
Rij[i][j]^.RU^.Name:=Rij[i][j]^.Name+'->'+Pij[i-1][j+1]^.Name; // имя связи
Rij[i][j]^.RU^.State:=lsGood; // состояние связи
Rij[i][j]^.RU^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+1))*2+1]; // вес
Rij[i][j]^.RU^.P:=Pij[i-1][j+1]; // вершина
end
else Rij[i][j]^.RU:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+1))*2+1]:=Rij[i][j]^.RU; // ребро
// влево-вверх
if i > 1 then
begin
New(Rij[i][j]^.LU); // выделение памяти
Rij[i][j]^.LU^.Name:=Rij[i][j]^.Name+'->'+Pij[i-1][j+0]^.Name; // имя связи
Rij[i][j]^.LU^.State:=lsGood; // состояние связи
Rij[i][j]^.LU^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+1]; // вес
Rij[i][j]^.LU^.P:=Pij[i-1][j+0]; // вершина
end
else Rij[i][j]^.LU:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1-1)*N+(j-1+0))*2+1]:=Rij[i][j]^.LU; // ребро
// вправо-вниз
if (i < N)and(j < N) then
begin
New(Rij[i][j]^.RD); // выделение памяти
Rij[i][j]^.RD^.Name:=Rij[i][j]^.Name+'->'+Pij[i+1][j+1]^.Name; // имя связи
Rij[i][j]^.RD^.State:=lsGood; // состояние связи
Rij[i][j]^.RD^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+1))*2+1]; // вес
110
Rij[i][j]^.RD^.P:=Pij[i+1][j+1]; // вершина
end
else Rij[i][j]^.RD:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+1))*2+1]:=Rij[i][j]^.RD; // ребро
// влево-вниз
if i < N then
begin
New(Rij[i][j]^.LD); // выделение памяти
Rij[i][j]^.LD^.Name:=Rij[i][j]^.Name+'->'+Pij[i+1][j+0]^.Name; // имя связи
Rij[i][j]^.LD^.State:=lsGood; // состояние связи
Rij[i][j]^.LD^.Weight:=W[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+1]; // вес
Rij[i][j]^.LD^.P:=Pij[i+1][j+0]; // вершина
end
else Rij[i][j]^.LD:=nil; // связь не предусмотрена топологией сети
Lij[((i-1)*N+(j-1))*2+2][((i-1+1)*N+(j-1+0))*2+1]:=Rij[i][j]^.LD; // ребро
end;
end;
procedure DeleteNet; // удаление сети
var
i, j: byte; // индексы
begin
for i:=1 to N do
for j:=1 to N do
begin
Dispose(Pij[i][j]); // освобождение памяти (основные процессоры)
Dispose(Rij[i][j]); // освобождение памяти (резервные процессоры)
end;
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
if Lij[i][j] <> nil then // ребро существует
Dispose(Lij[i][j]); // освобождение памяти (связи)
end;
procedure ClearWay; // очистка маршрутов
var
i, j: byte; // индексы
begin
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
if Lij[i][j] <> nil then // ребро существует
Lij[i][j]^.WayUse:=wsNo; // путь не содержит ребра
end;
procedure DrawNet(cnv: TCanvas); // прорисовка сети
const
dW = 10; // отступ по горизонтали
dH = 10; // отступ по вертикали
R = 16; // радиус элемента
d1 = 2*16; // расстояние по вертикали между элементами
d2 = (2*R+d1)*2; // расстояние по горизонтали между элементами одного типа
d3 = 5; // поправка на закругление
delta = 3; // разность ширины выделенных элементов
cntClr = clBlack; // цвет контура стандартный
var
i, j: byte; // индексы
begin
cnv.Pen.Width:=1; // ширина контура
cnv.Brush.Color:=grdClr; // цвет фона
cnv.Pen.Color:=cntClr; // цвет контура
cnv.Rectangle(cnv.ClipRect); // прорисовка контура
cnv.Pen.Width:=PenWidth; // ширина пера для элементов
111
// связи
for i:=1 to N do
for j:=1 to N do
begin
// вправо-вниз
if j < N then
begin
if Pij[j][i]^.RD^.WayUse = wsYes then // ребро содержится в пути
begin
cnv.Pen.Width:=PenWidth+delta; // ширина пера для выделенных элементов
cnv.Pen.Color:=captureClr; // цвет задействованных элементов
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+2*R+dH-1); // переместить перо
cnv.LineTo((i-1)*d2+d1+2*R+dW+d3, (j-1+1)*2*d1+dH+d3); // нарисовать линию
cnv.Pen.Width:=PenWidth; // ширина пера для элементов
end;
if Pij[j][i]^.RD^.State = lsGood then // связь рабочая
cnv.Pen.Color:=cntClr // цвет связи
else cnv.Pen.Color:=badClr; // цвет отказавшей связи
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+2*R+dH-1); // переместить перо
cnv.LineTo((i-1)*d2+d1+2*R+dW+d3, (j-1+1)*2*d1+dH+d3); // нарисовать линию
end;
// влево-вниз
if (j < N)and(i > 1) then
begin
if Pij[j][i]^.LD^.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+2*R+dH-1);
cnv.LineTo((i-1-1)*d2+d1+4*R+dW-d3-1, (j-1+1)*2*d1+dH+d3);
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i]^.LD^.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+2*R+dH-1);
cnv.LineTo((i-1-1)*d2+d1+4*R+dW-d3-1, (j-1+1)*2*d1+dH+d3);
end;
// вправо-вверх
if j > 1 then
begin
if Pij[j][i].RU.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+dH);
cnv.LineTo((i-1)*d2+d1+2*R+dW+d3, (j-1-1)*2*d1+2*R+dH-d3-1);
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i].RU.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+dH);
cnv.LineTo((i-1)*d2+d1+2*R+dW+d3, (j-1-1)*2*d1+2*R+dH-d3-1);
end;
// влево-вверх
if (j > 1)and(i > 1) then
begin
if Pij[j][i].LU.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+dH);
cnv.LineTo((i-1-1)*d2+d1+4*R+dW-d3-1, (j-1-1)*2*d1+2*R+dH-d3-1);
112
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i].LU.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+dH);
cnv.LineTo((i-1-1)*d2+d1+4*R+dW-d3-1, (j-1-1)*2*d1+2*R+dH-d3-1);
end;
// вправо
if Pij[j][i].R.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+R+dH);
cnv.LineTo((i-1)*d2+d1+2*R+dW, (j-1)*2*d1+R+dH);
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i].R.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+2*R+dW-1, (j-1)*2*d1+R+dH);
cnv.LineTo((i-1)*d2+d1+2*R+dW, (j-1)*2*d1+R+dH);
// влево
if i > 1 then
begin
if Pij[j][i].L.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+R+dH);
cnv.LineTo((i-1-1)*d2+d1+2*R+dW+R, (j-1)*2*d1+R+dH);
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i].L.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+dW, (j-1)*2*d1+R+dH);
cnv.LineTo((i-1-1)*d2+d1+2*R+dW, (j-1)*2*d1+R+dH);
end;
// вниз
if j < N then
begin
if Pij[j][i].D.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+R+dW, (j-1)*2*d1+dH+R);
cnv.LineTo((i-1)*d2+R+dW, (j-1+1)*2*d1+dH);
cnv.Pen.Width:=PenWidth;
end;
if Rij[j][i].D.WayUse = wsYes then
begin
cnv.Pen.Width:=PenWidth+3;
cnv.Pen.Color:=captureClr;
cnv.MoveTo((i-1)*d2+d1+3*R+dW, (j-1)*2*d1+dH+R);
cnv.LineTo((i-1)*d2+d1+3*R+dW, (j-1+1)*2*d1+dH);
cnv.Pen.Width:=PenWidth;
end;
if Pij[j][i].D.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+R+dW, (j-1)*2*d1+dH);
cnv.LineTo((i-1)*d2+R+dW, (j-1+1)*2*d1+dH);
if Rij[j][i].D.State = lsGood then cnv.Pen.Color:=clBlack
else cnv.Pen.Color:=badClr;
cnv.MoveTo((i-1)*d2+d1+3*R+dW, (j-1)*2*d1+dH);
113
cnv.LineTo((i-1)*d2+d1+3*R+dW, (j-1+1)*2*d1+dH);
end;
end;
// элементы
cnv.Pen.Color:=clBlack;
for i:=1 to N do
for j:=1 to N do
begin
// процессоры
if Pij[j][i].State = psCapture then cnv.Brush.Color:=captureClr
else cnv.Brush.Color:=badClr;
cnv.Rectangle((i-1)*d2+dW, (j-1)*2*d1+dH, (i-1)*d2+2*R+dW, (j-1)*2*d1+2*R+dH);
cnv.TextOut((i-1)*d2+R+dW-6, (j-1)*2*d1+R+dH-6, Pij[j][i].Addr);
// резерв
case Rij[j][i].State of
psGood: cnv.Brush.Color:=goodClr;
psBad: cnv.Brush.Color:=badClr;
psCapture: cnv.Brush.Color:=captureClr;
end;
cnv.Ellipse((i-1)*d2+d1+2*R+dW, (j-1)*2*d1+dH,
(i-1)*d2+d1+4*R+dW, (j-1)*2*d1+2*R+dH);
cnv.TextOut((i-1)*d2+d1+3*R+dW-6, (j-1)*2*d1+R+dH-6, Rij[j][i].Addr);
end;
end;
function CalcRoad: DWORD;
var
i, j, k: byte;
MaxD: DWORD;
begin
MaxD:=0;
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
MaxD:=MaxD+V[i][j];
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
begin
if i = j then
begin
Dp[i][j]:=0;
Sp[i][j]:=i;
end
else
begin
if V[i][j] = 0 then
Dp[i][j]:=MaxD
else
Dp[i][j]:=1;
Sp[i][j]:=j;
end;
end;
for k:=1 to 2*N*N do
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
if (k <> i)and(k <> j)and(i <> j) then
if (Dp[i][k] + Dp[k][j]) < Dp[i][j] then
begin
Dp[i][j]:=Dp[i][k]+Dp[k][j];
Sp[i][j]:=k;
end;
Result:=MaxD;
end;
114
function CalcWay: DWORD;
var
i, j, k: byte;
MaxD: DWORD;
begin
MaxD:=0;
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
MaxD:=MaxD+W[i][j];
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
begin
if i = j then
begin
D[i][j]:=0;
S[i][j]:=0;
end
else
begin
if (W[i][j] = 0) then
D[i][j]:=MaxD
else
if Lij[i][j]^.State = lsBad then
D[i][j]:=MaxD
else
D[i][j]:=W[i][j];
S[i][j]:=j;
end;
end;
for k:=1 to 2*N*N do
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
if (k <> i)and(k <> j)and(i <> j) then
if (D[i][k] + D[k][j]) < D[i][j] then
begin
D[i][j]:=D[i][k]+D[k][j];
S[i][j]:=k;
end;
Result:=MaxD;
end;
function NumToCell(k: byte): string;
var
i, j: byte;
begin
if k = 0 then
Result:=''
else
if Odd(k) then
begin
k:=k-1;
k:=k div 2;
i:=(k div N)+1;
j:=(k mod N)+1;
Result:=IntToStr(i)+IntToStr(j);
end
else
begin
k:=k-2;
k:=k div 2;
i:=(k div N)+1;
115
j:=(k mod N)+1;
Result:='.'+IntToStr(i)+IntToStr(j);
end;
end;
procedure ViewRoads(SG_P: TStringGrid; SG_M: TStringGrid);
var
i, j: byte;
begin
MaxRoad:=CalcRoad;
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
begin
if Dp[i][j] = MaxRoad then
begin
SG_P.Cells[j,i]:='*';
end
else
SG_P.Cells[j,i]:=IntToStr(Dp[i][j]);
SG_M.Cells[j,i]:=NumToCell(Sp[i][j]);
end;
end;
function ViewWays(SG_D: TStringGrid; SG_S: TStringGrid): boolean;
var
i, j: byte;
MaxD: DWORD;
begin
Result:=true;
MaxD:=CalcWay;
for i:=1 to 2*N*N do
for j:=1 to 2*N*N do
begin
if D[i][j] = MaxD then
begin
SG_D.Cells[j,i]:='*';
Result:=false;
end
else
SG_D.Cells[j,i]:=IntToStr(D[i][j]);
SG_S.Cells[j,i]:=NumToCell(S[i][j]);
end;
end;
function GetWay(i, j: byte): string;
begin
Result:='';
if S[i][j] = 0 then Exit;
if S[i][j] = j then Exit;
Result:=GetWay(i, S[i][j])+NumToCell(S[i][j])+'->'+GetWay(S[i][j], j);
end;
function GetWayProc(i, j: byte): string;
begin
Result:='';
if Sp[i][j] = 0 then Exit;
if Sp[i][j] = j then Exit;
Result:=GetWayProc(i, Sp[i][j])+NumToCell(Sp[i][j])+'->'+GetWayProc(Sp[i][j], j);
end;
procedure ViewRazm(SG: TStringGrid);
var
116
i, j, x, y: byte;
Address: string;
Flag: boolean;
begin
for i:=1 to N do
for j:=1 to N do
begin
Address:=IntToStr(i)+IntToStr(j);
Flag:=false;
for x:=1 to N do
begin
for y:=1 to N do
begin
if Pij[x][y]^.Addr = Address then
begin
SG.Cells[j,i]:=Pij[x][y]^.Name;
Flag:=true;
break;
end;
if Rij[x][y]^.Addr = Address then
begin
SG.Cells[j,i]:=Rij[x][y]^.Name;
Flag:=true;
break;
end;
end;
if Flag then break;
end;
end;
end;
function GetSumWay: DWORD;
var
i, j: byte;
begin
Result:=0;
for i:=1 to 2*N*N-1 do
for j:=i+1 to 2*N*N do
Result:=Result+D[i][j];
end;
procedure TForm1.InitNet;
var
i, j: byte;
Address: string;
begin
RadioGroup1.Enabled:=not BitBtn2.Enabled;
NumError:=0;
AllStat:=0;
Panel1.Caption:='Номер отказа: '+IntToStr(NumError);
SG_W.RowCount:=N*N*2+1;
SG_W.ColCount:=N*N*2+1;
SG_R.RowCount:=N+1;
SG_R.ColCount:=N+1;
SG_D.RowCount:=N*N*2+1;
SG_D.ColCount:=N*N*2+1;
SG_S.RowCount:=N*N*2+1;
SG_S.ColCount:=N*N*2+1;
SG_L.RowCount:=N*N*2+1;
SG_L.ColCount:=N*N*2+1;
SG_P.RowCount:=N*N*2+1;
SG_P.ColCount:=N*N*2+1;
117
SG_M.RowCount:=N*N*2+1;
SG_M.ColCount:=N*N*2+1;
SG_V.RowCount:=N*N*2+1;
SG_V.ColCount:=N*N*2+1;
for i:=1 to N do
begin
for j:=1 to N do
begin
Address:=IntToStr(i)+IntToStr(j);
SG_W.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_W.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_W.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_W.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_D.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_D.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_D.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_D.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_S.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_S.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_S.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_S.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_L.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_L.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_L.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_L.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_P.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_P.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_P.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_P.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_M.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_M.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_M.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_M.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
SG_V.Cells[0,((i-1)*N+(j-1))*2+1]:=Address;
SG_V.Cells[0,((i-1)*N+(j-1))*2+2]:='.'+Address;
SG_V.Cells[((i-1)*N+(j-1))*2+1,0]:=Address;
SG_V.Cells[((i-1)*N+(j-1))*2+2,0]:='.'+Address;
end;
SG_R.Cells[0,i]:=IntToStr(i);
SG_R.Cells[i,0]:=IntToStr(i);
end;
ReadW(SG_W);
CreateNet;
ClearWay;
PauseSec:=100-TrackBar1.Position*5;
TTT:=SpinEdit3.Value;
ESW:=SpinEdit2.Value;
Prioritet:=RadioGroup2.ItemIndex;
goodClr:=Edit2.Color;
badClr:=Edit3.Color;
captureClr:=Edit4.Color;
grdClr:=Edit1.Color;
PenWidth:=ComboBox1.ItemIndex+1;
DrawNet(Image1.Canvas);
ViewLinkState(SG_L);
ViewLinkProc(SG_V);
if not ViewWays(SG_D, SG_S) then ShowMessage('Критический отказ связи.'+#13+'Нарушена целостность
сети.');
ViewRoads(SG_P, SG_M);
ViewRazm(SG_R);
Memo1.Clear;
Memo1.Lines.Add(#13#10);
118
Series1.Clear;
Series1.Add(0);
Series2.Clear;
Series2.Add(GetSumWay);
BitBtn3.Visible:=true;
BitBtn4.Visible:=true;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
RadioGroup1.ItemIndex:=1;
DeleteNet;
N:=SpinEdit1.Value;
N3.Click;
InitNet;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
Randomize;
isRun:=false;
SG_W.Cells[0,0]:=' W';
SG_R.Cells[0,0]:=' R';
SG_L.Cells[0,0]:=' L';
SG_D.Cells[0,0]:=' D';
SG_S.Cells[0,0]:=' S';
SG_P.Cells[0,0]:=' P';
SG_M.Cells[0,0]:=' M';
SG_V.Cells[0,0]:=' V';
Image2.Canvas.Brush.Color:=clBtnFace;
Image2.Canvas.Rectangle(Image2.Canvas.ClipRect);
Image2.Canvas.Pen.Width:=2;
Image2.Canvas.Rectangle(10, 10, 42, 42);
Image2.Canvas.TextOut(52, 18, '<-- Основной процессорный элемент (ПЭ)');
Image2.Canvas.Ellipse(10, 50, 42, 82);
Image2.Canvas.TextOut(52, 58, '<-- Резервный процессорный элемент (РЭ)');
Image2.Canvas.Pen.Width:=1;
N:=SpinEdit1.Value;
N3.Click;
InitNet;
end;
procedure TForm1.SpinEdit1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key = VK_DELETE then Key:=VK_OEM_CLEAR;
end;
procedure TForm1.SG_WDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
var
Flag: boolean;
begin
Flag:=false;
if ((ACol = 0)and(ARow = SG_W.Row))or((ACol = SG_W.Col)and(ARow = 0)) then
begin
SG_W.Canvas.Brush.Color:=clTeal;
SG_W.Canvas.Pen.Color:=clTeal;
SG_W.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_W.Cells[ACol, ARow]);
Flag:=true;
end
else
119
if (ACol > 0)and(ARow > 0) then
begin
if ACol > ARow then
begin
if ((ARow mod (2*N)) <> 0)and(ACol = (ARow+1)) then Flag:=true;
if ((ARow mod (2*N)) <> 1)and(ACol = (ARow+2*N-1)) then Flag:=true;
if ACol = (ARow+2*N) then Flag:=true;
if ((ARow mod (2*N)) <> 0)and(ACol = (ARow+2*N+1)) then Flag:=true;
end
end
else Flag:=true;
if not Flag then
begin
SG_W.Canvas.Brush.Color:=clBtnFace;
SG_W.Canvas.Pen.Color:=clBtnFace;
SG_W.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_W.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_WClick(Sender: TObject);
var
Flag: boolean;
begin
SG_W.Invalidate;
Flag:=false;
if SG_W.Col > SG_W.Row then
begin
if ((SG_W.Row mod (2*N)) <> 0)and(SG_W.Col = (SG_W.Row+1)) then Flag:=true;
if ((SG_W.Row mod (2*N)) <> 1)and(SG_W.Col = (SG_W.Row+2*N-1)) then Flag:=true;
if SG_W.Col = (SG_W.Row+2*N) then Flag:=true;
if ((SG_W.Row mod (2*N)) <> 0)and(SG_W.Col = (SG_W.Row+2*N+1)) then Flag:=true;
end;
if Flag then
SG_W.Options:=SG_W.Options+[goEditing]
else
SG_W.Options:=SG_W.Options-[goEditing];
end;
procedure TForm1.SG_WKeyPress(Sender: TObject; var Key: Char);
begin
if not(Key in ['0'..'9',#8]) then Key:=#0
else
if (Length(SG_W.Cells[SG_W.Col, SG_W.Row]) > 2)and(Key <> #8) then Key:=#0;
end;
procedure TForm1.SG_WKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if SG_W.Col > SG_W.Row then
SG_W.Cells[SG_W.Row,SG_W.Col]:=SG_W.Cells[SG_W.Col,SG_W.Row];
end;
procedure TForm1.N1Click(Sender: TObject);
var
i, j: integer;
Flag: boolean;
begin
for i:=1 to N*N*2-1 do
for j:=i+1 to N*N*2 do
begin
Flag:=false;
if ((i mod (2*N)) <> 0)and(j = (i+1)) then Flag:=true;
120
if ((i mod (2*N)) <> 1)and(j = (i+2*N-1)) then Flag:=true;
if j = (i+2*N) then Flag:=true;
if ((i mod (2*N)) <> 0)and(j = (i+2*N+1)) then Flag:=true;
if Flag then
begin
SG_W.Cells[j,i]:='1';
SG_W.Cells[i,j]:='1';
end
else
begin
SG_W.Cells[j,i]:='';
SG_W.Cells[i,j]:='';
end;
end;
end;
procedure TForm1.N3Click(Sender: TObject);
var
i, j, k: integer;
Flag: boolean;
begin
for i:=1 to N*N*2-1 do
for j:=i+1 to N*N*2 do
begin
Flag:=false;
if ((i mod (2*N)) <> 0)and(j = (i+1)) then Flag:=true;
if ((i mod (2*N)) <> 1)and(j = (i+2*N-1)) then Flag:=true;
if j = (i+2*N) then Flag:=true;
if ((i mod (2*N)) <> 0)and(j = (i+2*N+1)) then Flag:=true;
if Flag then
begin
k:=Random(20)+1;
SG_W.Cells[j,i]:=IntToStr(k);
SG_W.Cells[i,j]:=IntToStr(k);
end
else
begin
SG_W.Cells[j,i]:='';
SG_W.Cells[i,j]:='';
end;
end;
end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
isRun:=false;
DeleteNet;
end;
procedure TForm1.SG_DDblClick(Sender: TObject);
var
Road: string;
i1, i2, j1, j2, k1, k2: byte;
begin
if isRun then Exit;
ClearWay;
DrawNet(Image1.Canvas);
if SG_D.Cells[SG_D.Col, SG_D.Row] = '*' then
begin
ShowMessage('Путь не существует');
Exit;
end;
121
Road:=NumToCell(SG_D.Row)+'->'+GetWay(SG_D.Row, SG_D.Col)+NumToCell(SG_D.Col);
ShowMessage(Road+#13#13+'Суммарный вес пути: '+SG_D.Cells[SG_D.Col, SG_D.Row]);
if SG_D.Cells[SG_D.Col, SG_D.Row] = '0' then Exit;
while Length(Road) > 3 do
begin
if Road[1] = '.' then k1:=2
else k1:=1;
i1:=StrToInt(Road[k1]);
j1:=StrToInt(Road[k1+1]);
Delete(Road, 1, k1+3);
if Road[1] = '.' then k2:=2
else k2:=1;
i2:=StrToInt(Road[k2]);
j2:=StrToInt(Road[k2+1]);
Lij[((i1-1)*N+(j1-1))*2+k1][((i2-1)*N+(j2-1))*2+k2]^.WayUse:=wsYes;
Lij[((i2-1)*N+(j2-1))*2+k2][((i1-1)*N+(j1-1))*2+k1]^.WayUse:=wsYes;
end;
DrawNet(Image1.Canvas);
end;
procedure TForm1.RadioGroup1Click(Sender: TObject);
begin
if RadioGroup1.ItemIndex = 1 then
begin
BitBtn1.Enabled:=true;
BitBtn2.Enabled:=false;
BitBtn3.Enabled:=false;
BitBtn4.Enabled:=false;
end
else
begin
BitBtn1.Enabled:=false;
BitBtn2.Enabled:=false;
BitBtn3.Enabled:=true;
BitBtn4.Enabled:=true;
end;
end;
function FailNet: boolean;
var
k: integer;
begin
case Prioritet of
0:
begin
Result:=Form1.LinkError;
if not Result then
begin
ShowMessage('Фатальный отказ связи');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end;
1:
begin
Result:=Form1.ProcError;
if not Result then
begin
ShowMessage('Фатальный отказ процессора');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
122
end;
2:
begin
k:=Random(10*N);
if k < 7*N then
begin
Result:=Form1.LinkError;
if not Result then
begin
ShowMessage('Фатальный отказ связи');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end
else
begin
Result:=Form1.ProcError;
if not Result then
begin
ShowMessage('Фатальный отказ процессора');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end;
end;
3:
begin
k:=Random(10*N);
if k > 6*N then
begin
Result:=Form1.LinkError;
if not Result then
begin
ShowMessage('Фатальный отказ связи');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end
else
begin
Result:=Form1.ProcError;
if not Result then
begin
ShowMessage('Фатальный отказ процессора');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end;
end;
4:
begin
k:=Random(10*N);
if k < 5*N then
begin
Result:=Form1.LinkError;
if not Result then
begin
ShowMessage('Фатальный отказ связи');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end
123
else
begin
Result:=Form1.ProcError;
if not Result then
begin
ShowMessage('Фатальный отказ процессора');
Form1.BitBtn2.Enabled:=false;
Form1.RadioGroup1.ItemIndex:=0;
end;
end;
end;
end;
end;
procedure TForm1.BitBtn1Click(Sender: TObject);
var
i: byte;
begin
BitBtn1.Enabled:=false;
RadioGroup1.Enabled:=false;
BitBtn2.Enabled:=true;
isRun:=true;
while isRun do
begin
isRun:=FailNet;
for i:=1 to 10 do
begin
Application.ProcessMessages;
sleep(PauseSec);
end;
end;
end;
procedure TForm1.BitBtn2Click(Sender: TObject);
begin
isRun:=false;
BitBtn2.Enabled:=false;
BitBtn1.Enabled:=true;
RadioGroup1.Enabled:=true;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
DeleteNet;
InitNet;
end;
procedure TForm1.BitBtn5Click(Sender: TObject);
begin
DeleteNet;
InitNet;
end;
procedure TForm1.SG_LDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_L.Row))or((ACol = SG_L.Col)and(ARow = 0)) then
begin
SG_L.Canvas.Brush.Color:=clTeal;
SG_L.Canvas.Pen.Color:=clTeal;
SG_L.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_L.Cells[ACol, ARow]);
124
end;
end;
procedure TForm1.SG_LClick(Sender: TObject);
begin
SG_L.Invalidate;
end;
procedure TForm1.SG_DDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_D.Row))or((ACol = SG_D.Col)and(ARow = 0)) then
begin
SG_D.Canvas.Brush.Color:=clTeal;
SG_D.Canvas.Pen.Color:=clTeal;
SG_D.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_D.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_DClick(Sender: TObject);
begin
SG_D.Invalidate;
end;
procedure TForm1.SG_SDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_S.Row))or((ACol = SG_S.Col)and(ARow = 0)) then
begin
SG_S.Canvas.Brush.Color:=clTeal;
SG_S.Canvas.Pen.Color:=clTeal;
SG_S.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_S.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_SClick(Sender: TObject);
begin
SG_S.Invalidate;
end;
procedure TForm1.SG_PDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_P.Row))or((ACol = SG_P.Col)and(ARow = 0)) then
begin
SG_P.Canvas.Brush.Color:=clTeal;
SG_P.Canvas.Pen.Color:=clTeal;
SG_P.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_P.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_PClick(Sender: TObject);
begin
SG_P.Invalidate;
end;
procedure TForm1.SG_MDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_M.Row))or((ACol = SG_M.Col)and(ARow = 0)) then
begin
SG_M.Canvas.Brush.Color:=clTeal;
125
SG_M.Canvas.Pen.Color:=clTeal;
SG_M.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_M.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_MClick(Sender: TObject);
begin
SG_M.Invalidate;
end;
procedure TForm1.SG_RDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_R.Row))or((ACol = SG_R.Col)and(ARow = 0)) then
begin
SG_R.Canvas.Brush.Color:=clTeal;
SG_R.Canvas.Pen.Color:=clTeal;
SG_R.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_R.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_RClick(Sender: TObject);
begin
SG_R.Invalidate;
end;
procedure ErrLink;
var
i, j: byte;
begin
while true do
begin
i:=Random(2*N*N)+1;
j:=Random(2*N*N)+1;
if Lij[i][j] <> nil then
if Lij[i][j]^.State = lsGood then
begin
Lij[i][j]^.State:=lsBad;
Lij[j][i]^.State:=lsBad;
Lij[i][j]^.WayUse:=wsYes;
Lij[j][i]^.WayUse:=wsYes;
break;
end;
end;
end;
function TForm1.LinkError: boolean;
var
i, j: byte;
count: DWORD;
SumWays: DWORD;
begin
Result:=true;
ClearWay;
NumError:=NumError+1;
ErrLink;
Panel1.Caption:='Номер отказа: '+IntToStr(NumError);
DrawNet(Image1.Canvas);
ViewLinkState(SG_L);
if not ViewWays(SG_D, SG_S) then
Memo1.Lines.Add(#13#10#9+'Критический отказ связи. Нарушена целостность сети.'+#13#10);
ViewRoads(SG_P, SG_M);
126
Series1.Add(0);
SumWays:=GetSumWay;
Series2.Add(SumWays);
Memo1.Lines.Add(#9+'Отказ № '+IntToStr(NumError)+#9+'перестройка:'+#9+FloatToStr(0)+'
сек'+#9#9#9+'[ '+IntToStr(SumWays)+' ]');
count:=0;
for i:=1 to 2*N*N-1 do // из i-ой вершины
for j:=i+1 to 2*N*N do // в j-ую
if Lij[i][j] <> nil then
if Lij[i][j]^.State = lsGood then
count:=count+1;
if count = 0 then
begin
BitBtn4.Visible:=false;
Memo1.Lines.Add(#13#10#9+'Фатальный отказ связи. Связи отсутствуют.');
Memo1.Lines.Add(#9+'Суммарная
перестройка
до
фатального
'+FloatToStr(AllStat*ESW/TTT*1000)+' x 10^-9 сек');
Result:=false;
end
end;
procedure TForm1.BitBtn4Click(Sender: TObject);
begin
if not LinkError then
begin
ShowMessage('Фатальный отказ связи');
RadioGroup1.Enabled:=false;
end;
end;
function ErrProc: byte;
var
i, j: byte;
begin
Result:=0;
while true do
begin
i:=Random(N)+1;
j:=Random(N)+1;
if Pij[i][j]^.State <> psBad then
begin
Result:=Pij[i][j]^.Num;
break;
end
else
if Rij[i][j]^.State <> psBad then
begin
Result:=Rij[i][j]^.Num;
break;
end;
end;
end;
function TuneNet(Num: byte): boolean;
var
MinV: DWORD;
MinP: byte;
i: byte;
Road: string;
i1, i2, j1, j2, k1, k2: byte;
NewAddr: string;
OldAddr: string;
x
10^-9
отказа:
127
begin
Result:=true;
Stat:=0;
if P[Num]^.Addr = '' then Exit;
MinP:=0;
MinV:=MaxRoad;
for i:=1 to N*N do
if P[i*2]^.State = psGood then
if Dp[Num][i*2] < MinV then
begin
MinV:=Dp[Num][i*2];
MinP:=i*2;
end;
if MinP > 0 then
begin
Road:=NumToCell(Num)+'->'+GetWayProc(Num, MinP)+NumToCell(MinP);
Stat:=MinV;
P[MinP]^.State:=psCapture;
OldAddr:=P[Num]^.Addr;
P[Num]^.Addr:='';
while Length(Road) > 3 do
begin
if Road[1] = '.' then k1:=2
else k1:=1;
i1:=StrToInt(Road[k1]);
j1:=StrToInt(Road[k1+1]);
Delete(Road, 1, k1+3);
if Road[1] = '.' then k2:=2
else k2:=1;
i2:=StrToInt(Road[k2]);
j2:=StrToInt(Road[k2+1]);
Lij[((i1-1)*N+(j1-1))*2+k1][((i2-1)*N+(j2-1))*2+k2]^.WayUse:=wsYes;
Lij[((i2-1)*N+(j2-1))*2+k2][((i1-1)*N+(j1-1))*2+k1]^.WayUse:=wsYes;
NewAddr:=P[((i2-1)*N+(j2-1))*2+k2]^.Addr;
P[((i2-1)*N+(j2-1))*2+k2]^.Addr:=OldAddr;
OldAddr:=NewAddr;
end;
end
else Result:=false;
end;
function TForm1.ProcError: boolean;
var
NumProcErr: byte;
SumWays: DWORD;
Flag: boolean;
begin
Result:=true;
ClearWay;
NumError:=NumError+1;
NumProcErr:=ErrProc;
Panel1.Caption:='Номер отказа: '+IntToStr(NumError);
ViewLinkProc(SG_V);
ViewRoads(SG_P, SG_M);
Flag:=TuneNet(NumProcErr);
P[NumProcErr]^.State:=psBad;
ViewLinkProc(SG_V);
ViewRoads(SG_P, SG_M);
ViewRazm(SG_R);
DrawNet(Image1.Canvas);
AllStat:=AllStat+Stat;
Series1.Add(Stat);
128
SumWays:=GetSumWay;
Series2.Add(SumWays);
if Stat = 0 then
Memo1.Lines.Add(#9+'Отказ № '+IntToStr(NumError)+#9+'перестройка:'+#9+FloatToStr(0)+' x 10^-9
сек'+#9#9#9+'[ '+IntToStr(SumWays)+' ]')
else
Memo1.Lines.Add(#9+'Отказ
№
'+IntToStr(NumError)+#9+'перестройка:'+#9+FloatToStr(Stat*ESW/TTT*1000)+'
x
10^-9
сек'+#9+'[
'+IntToStr(SumWays)+' ]');
if not Flag then
begin
BitBtn3.Visible:=false;
Memo1.Lines.Add(#13#10#9+'Фатальный отказ процессора. Перестройка не возможна.');
Memo1.Lines.Add(#9+'Суммарная
перестройка
до
фатального
отказа:
'+FloatToStr(AllStat*ESW/TTT*1000)+' x 10^-9 сек'+#13#10);
Result:=false;
end;
end;
procedure TForm1.BitBtn3Click(Sender: TObject);
begin
if not ProcError then
begin
ShowMessage('Фатальный отказ процессора');
RadioGroup1.Enabled:=false;
end;
end;
procedure TForm1.SG_VDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ((ACol = 0)and(ARow = SG_V.Row))or((ACol = SG_V.Col)and(ARow = 0)) then
begin
SG_V.Canvas.Brush.Color:=clTeal;
SG_V.Canvas.Pen.Color:=clTeal;
SG_V.Canvas.TextRect(Rect, Rect.Left+2, Rect.Top+2, SG_V.Cells[ACol, ARow]);
end;
end;
procedure TForm1.SG_VClick(Sender: TObject);
begin
SG_V.Invalidate;
end;
end.