CC BY
53
Том 10. № 1 (55). 2015
А. А. Митраков, магистр кафедры Математического обеспечения вычислительных систем, Пермский государственный национальный исследовательский университет, mitrakov-artem@yandex.ru
Применение знаний для синхронизации агентов в параллельном дискретно-событийном моделировании
Статья посвящена алгоритмам синхронизации логических процессов для систем распределенного агентного моделирования . В работе предложен новый подход, основанный на знаниях об исследуемой модели, который действительно подтвердил свою эффективность на практике . Даны описания предлагаемых алгоритмов, область их применения, практические результаты, а также описан фрагмент онтологии, разработанной в поддержку предлагаемого метода
Ключевые слова: имитационное моделирование, агент, агентное моделирование, распределенное моделирование, алгоритмы синхронизации агентов, оптимистические алгоритмы, онтология, база знаний
введение
Статья посвящена исследованию алгоритмов синхронизации в системах агентного имитационного моделирования. Агентное моделирование является сравнительно новым, но наиболее перспективным и прогрессивным научным направлением в развитии машинной имитации. Этот инструмент позволяет решать весьма сложные трудно формализуемые задачи, такие как моделирование социальных, экономических, политических процессов, задачи, связанные с логистикой, эпидемиологией, цепочками поставок и т. д.
В настоящее время для агентных моделей применяют PDES (Parallel Discrete Event Simulation — параллельное дискретно-событийное моделирование), для которого существует проблема синхронизации логических процессов. Дело в том, что каждый процесс имеет свой локальный календарь событий, а в ходе коммуникации один из процессов может прислать сообщение, временная метка которого окажется меньше локального времени процесса.
Существует немало работ, посвященных распределенному моделированию, преи-
мущественно зарубежных, которые исследуют возможные решения проблемы синхронизации, однако идеального алгоритма до сих пор не было предложено. Под «идеальным» понимают такой протокол синхронизации, который мог бы гарантировать линейный прирост производительности моделирования с ростом количества вычислительных узлов.
Данная работа предлагает алгоритмы синхронизации, которые используют знания об агентной модели, представленные в явном виде, с целью повышения эффективности имитационного моделирования. То есть будет показано, что знания в агентных платформах можно применять не только для интеллектуальной составляющей агентов, но и для повышения скорости параллельного моделирования в целом.
Проблема синхронизации логических процессов — ключевая в области PDES, поскольку именно синхронизация является «узким местом» в производительности имитационного моделирования.
Теоретическая значимость работы заключается в описании методов применения знаний о модели в алгоритмах синхронизации (применяется онтологический подход).
Vi1
Такие алгоритмы ценны тем, что позволяют повысить производительность вычислений в 8-10 раз только за счет применения знаний.
Переход к распределенному моделированию
Последовательное имитационное моделирование
Первоначально имитационное моделирование, зародившись в 50-х годах прошлого столетия, представляло собой последовательный симулятор (все вычисления проводились на одном вычислительном узле). Появлялись новые формы функционирования моделирования (системная динамика, процессное моделирование, дискретно-событийное моделирование), но модель вычислений оставалась прежней — последовательной.
Рассмотрим подробнее схему последовательного симулятора на примере SDES (от англ. Sequential Discrete Event Simulation — последовательное дискретно-событийное моделирование) (рис. 1) [3].
Рис. 1. Схема последовательного симулятора Fig. 1. A serial simulation scheme
В системе имеется совокупность объектов моделирования. Механизм продвижения времени выполняет планировку (диспетчеризацию) событий: у отдельных объ-
ектов просматриваются локальные списки событий (календарь событий) и выбирается событие с наименьшей временно'й меткой. Далее оно обрабатывается, возможно, порождая новые события (рис. 2), и затем этот алгоритм повторяется.
Рис. 2. Генерация новых событий в SDES Fig. 2. Generation of new events in SDES
Остановом моделирования могут служить либо пустые списки событий (все события обработаны), либо специальные условия (окончание времени моделирования, наступление «особого» события и т. п.).
Какие оптимизации данных симуляторов можно предложить? Первая и, пожалуй, единственная практически значимая модификация — совершенствование структур данных, применяемых в списках событий. При этом важно соблюдение 2 условий:
• события должны быть упорядочены по времени (или, по крайней мере, должен быть реализован эффективный поиск минимума, как, например, в Binary-Search-Tree);
• должна быть реализована эффективная вставка в конец (имеется в виду не конечный элемент, а произвольный участок хвоста).
На рис. 3 приведен пример структуры данных для списка событий — дек (хорошее, но не самое эффективное решение).
Новым прорывом послужило появление распределенного моделирования.
Рис. 3. Двухвостая очередь, используемая для списка событий Fig. 3. A deque used for an event list
Распределенное имитационное моделирования
Параллельное имитационное моделирование зародилось в конце 70-х годов прошлого столетия. Мы будем рассматривать распределенное моделирование на примере PDES (parallel discrete event simulation — параллельное дискретно-событийное моделирование) [2, 4, 11].
Общая идея достаточно проста: теперь моделируемые сущности выполняются не на одном вычислительном узле, а на 2 и более. Это могут быть системы с общей памятью (SMP-архитектуры), машины с массовым параллелизмом (MPP-архитектуры), несколько узлов в составе кластера, NUMA-платформы или суперкомпьютеры.
Каждый моделируемый объект сохраняет также локальный календарь событий. Схема функционирования не изменяется — выбирается событие с наименьшей временной меткой, далее оно обрабатывается, порождая новые события. На практике число имеющихся вычислительных узлов бывает много меньше числа моделируемых сущностей, в связи с чем последние объединяются внутри одного логического процесса.
Определение: Логический процесс — независимая обособленная функциональная единица распределенного дискретно-событийного моделирования, выполняющаяся на 1-м вычислительном узле и связанная с другими процессами в единую сеть посредством передачи сообщений.
Проблема локальной каузальности
Основной фундаментальной проблемой распределенного моделирования, к которой данная статья имеет непосредственное отношение, является нарушение локальной каузальности [2, 11].
Определение: Под локальной каузальностью понимается гарантия того, что все события в ходе имитационного прогона будут выполнены по возрастанию (или, строго говоря, неубыванию) временных меток.
Иными словами, обеспечение локальной каузальности гарантирует, что все события будут обработаны в хронологическом порядке. В последовательных машинах такой проблемы не было: симулятор всегда выбирал минимальное событие. В параллельных системах все логические процессы независимы, а значит, возможна ситуация обработки события «из прошлого».
Рис. 4. Пример нарушения локальной каузальности Fig. 4. Sample of a local causality corruption
\ 33
Пример нарушения локальной каузальности показан на рис. 4.
Если локальные часы логического процесса имеют время t1, а в это время поступает сообщение с временно'й меткой t2, то при t2 < t1 нарушается локальная каузальность (поступает событие «из прошлого»).
Выход существует, так как современной науке известно 2 обширных класса алгоритмов синхронизации: консервативные и оптимистические.
Алгоритмы синхронизации логических процессов
Консервативные алгоритмы
Консервативные алгоритмы появились раньше, чем оптимистические. Впервые подобный алгоритм был описан исследователями Chandy, Misra и Bryant в 1977-1979 гг. [8].
Общая идея данного семейства алгоритмов — не позволять логическому процессу продвигать время вперед, пока не будет уверенности, что все его соседи достигли этого времени. Другими словами, процесс блокируется до тех пор, пока точно не будет известно, что выполнение следующего события безопасно.
Пример работы консервативного алгоритма приведен на рис. 5.
кой t = 5, поскольку теоретически возможна такая ситуация, что LPn пришлет событие с меткой t = 4 или меньше. Как только процесс получит сообщение с меткой t > 5, он увеличивает LBTS, а значит, сможет продолжить работу.
Определение: LBTS (от англ. Lower Bound of TimeStamps — нижняя граница временных меток) — время, равное минимуму временных меток среди событий локального календаря и всех входящих очередей сообщений.
Формальная цель данного класса алгоритмов — исключить теоретическую возможность нарушения локальной каузальности.
Проблемы, связанные с реализацией консервативных алгоритмов
Основной проблемой консервативных алгоритмов является возможность взаимных блокировок (deadlocks) [2, 3, 11].
Пример возникновения тупика изображен на рис. 6.
Рис. 5. Схема работы консервативного
алгоритма Fig. 5. A conservative algorithm scheme
Из рисунка видно, что логический процесс не будет выполнять событие с мет-
Рис. 6. Пример возникновения тупика Fig. 6. Sample of a deadlock
Процесс LP1 ждет сообщения от процесса LP2, поскольку не исключено, что его временная метка может оказаться меньше локального времени. Аналогично LP2 ждет LP3, а тот, в свою очередь, ждет LP1.
Простейший способ разрешения тупиковых ситуаций был предложен авторами базового алгоритма [8]. Подход называется Null Messages Algorithm (алгоритм с нулевыми сообщениями). Алгоритм имеет следующие ограничения:
• топология сети фиксирована и известна каждому логическому процессу;
• каждый процесс высылает сообщения с неубывающими временными метками;
• коммуникационная среда гарантирует, что все сообщения придут строго в порядке их отправления.
Суть алгоритма заключается в том, что логические процессы после каждой обработки события высылают всем соседям сообщение специального типа — нулевое сообщение (NullMessage). Их временная метка t = a0 свидетельствует о том, что в будущем процесс гарантированно не пришлет сообщений с меткой t < a0.
Определение: Нулевое сообщение — сообщение, которое (семантически) несет в себе данные только о временной метке.
При получении нулевого сообщения логический процесс увеличивает LBTS, что делает все локальные события с t < LBTS безопасными. Далее он обрабатывает безопасное событие (если таковое имеется) и вновь высылает всем соседям нулевые сообщения.
Пример работы изображен на рис. 7. Логический процесс LPn высылает нулевое сообщение с временной меткой t = 7, тем самым гарантируя, что в будущем он вышлет сообщение с меткой t > 7. В результате процесс LP1 получает возможность безопасно обработать локальное событие с t = 5.
Рис. 7. Консервативный алгоритм с нулевыми сообщениями Fig. 7. The conservative algorithm with Null Messages
Алгоритм оставляет открытым один вопрос: как оценить временную метку нуле-
вого сообщения? Одно из возможных решений — применение lookahead («забегание вперед») [9, 11]. В этом случае после обработки события с меткой t = t0 логический процесс отправит нулевые сообщения с меткой t = t0 + lookahead. В качестве значения lookahead могут использоваться оценки физических задержек устройств, знание нижнего предела в потоке заявок, дискретизация времени и т. д.
Оптимистические алгоритмы
Оптимистические алгоритмы являются вторым классом методов синхронизации. Первый алгоритм Time Warp предложил Jefferson [10] в 1985 г.
Оптимистические алгоритмы, в отличие от консервативных, не блокируют управление логического процесса, а просто продвигают время вперед. В случае нарушения локальной каузальности специальные механизмы выполняют откат текущего состояния модели на прежнее согласованное состояние.
Так, например, в случае отката, вызванного событием с меткой t = t0, алгоритм должен вернуть состояние модели x на время
t' =sup {t 11 (x) < t0; x e X},
где X — множество состояний модели; t (x) — временная метка состояния х.
Иными словами, выбирается состояние, предшествующее по времени сообщению с меткой t0.
Сообщение «из прошлого» в зарубежной литературе называется Straggler Message. Общая схема работы алгоритма изображена на рис. 8. В качестве Straggler-сообщения выступает сообщение C с меткой t = 4. Оптимистический алгоритм вынимает состояния процесса из стека состояний до тех пор, пока не вернет логический процесс к предыдущему согласованному состоянию (т. е. t = 3). Только после этого можно приступать к обработке события С.
В отличие от консервативного алгоритма, Time Warp не накладывает ограничений
\ 35
Vol. 10. No. 1 (55). 2015
Рис. 8. Схема работы оптимистического алгоритма Fig. 8. An optimistic algorithm scheme
ни на структуру и топологию сети, ни на качество коммуникационной среды (доставка должна быть гарантирована, но порядок получения сообщений из канала не обязательно совпадает с порядком их отправления).
Проблемы, связанные с реализацией оптимистических алгоритмов
Одной из проблем такого алгоритма является необходимость восстановления любого предыдущего состояния модели. Основными методами решения могут служить следующие:
• хранение моментальных снимков модели;
• обратные вычисления.
Очевидно, в первом случае алгоритм приводит к значительным издержкам по памяти, а во втором — по процессорному времени. Другой проблемой алгоритма являются сообщения, отправленные непосредственно перед процедурой отката. Пример изображен на рис. 9.
Действительно, если логический процесс отправил сообщение с временно'й меткой t = 5 (событие D) и обработал событие с t = 6 (событие E), а затем получил сообщение «из прошлого» с меткой t = 4 (событие С), то он обязан откатиться назад на время t < 4. Что делать с отправленным сообщением? Jefferson в своей работе [10] предложил идею применения антисообщений (Antimessages).
Рис. 9. Сообщение, отправленное перед процедурой отката
Fig. 9. A message sent before the rollback
Определение: Антисообщение — сообщение, отменяющее ранее высланное сообщение.
Итак, если процесс получает антисообщение, то возникает одна из следующих ситуаций.
1. Если временная метка антисообщения больше текущего времени процесса, то можно заключить, что «позитивное» сообщение еще находится во входящей очереди. В этом случае оба сообщения взаимно уничтожаются.
2. Если временная метка антисообщения меньше или равна текущему времени процесса, то согласно общему правилу возникает откат.
Следует учесть, что в последнем случае откат, вызванный антисообщением, может породить новые антисообщения, вызывающие откаты на других логических процессах.
Том 10. № 1 (55). 2015
Определение: Каскадный откат — откат, порожденный принятым от другого логического процесса антисообщением. Количество таких цепочек откатов называют порядком каскадного отката.
Оптимистические алгоритмы имеют еще один побочный эффект. Дело в том, что механизм мгновенных снимков требует расхода огромного количества памяти, поскольку логический процесс не располагает информацией о том, будет совершен откат или нет. Это приводит к тому, что требуется сохранять снимок модели после каждого обработанного события. Как следствие, память требуется каким-то образом освобождать. Для этих целей существует понятие GVT [2, 11].
Определение: GVT(от англ. Global Virtual Time — глобальное виртуальное время) — нижняя граница временных меток всех событий на всех логических процессах и всех сообщений в системе с учетом всех каскадных откатов.
Таким образом, если локальное время процесса t = 60, а GVT = 15, то все моментальные снимки модели для t < 15 гарантированно не будут востребованы, а значит, их можно удалить. Более того, GVT также служит надежным средством фиксации операций ввода-вывода, которые, очевидно, невозможно «откатить» (так называемые Irrevocable operations).
Вычислив оценку GVT, процесс фиксирует операции ввода-вывода и освобождает память. Данный процесс в западной литературе получил название Fossil Collection (букв. — «сбор ископаемых»).
Сравнение классов алгоритмов
Как правило, выбор алгоритма зависит от конкретной задачи, но в целом оптимистические протоколы показали бо'льшую эффективность.
Консервативные алгоритмы затратны по времени на ожидание — по факту система представляет собой «псевдопараллельный» симулятор. Тем не менее на практике они до сих пор применяются. Это связано в ос-
новном с многочисленными недостатками оптимистических алгоритмов, которые в силу тех или иных причин порой оказываются критичными.
В табл. 1 представлена сравнительная характеристика консервативных и оптимистических алгоритмов синхронизации(сравниваются Null Messages Algorithm и Time Warp — без каких-либо модификаций) [11].
специфика алгоритмов, основанных на знаниях
В статье описывается новое семейство оптимистических алгоритмов, получившее внутреннее наименование KBASA (от англ. Knowledge Based Agent Synchronization Algorithms). Алгоритмы ориентированы на агентные дискретно-событийные модели. Поскольку алгоритм является оптимистическим, для него справедливы утверждения, принятые в классическом Time Warp:
1) топология сети логических процессов может быть произвольной (и может меняться в ходе имитационного прогона);
2) коммуникационная среда должна гарантировать доставку сообщений, но при этом допускается ситуация, когда сообщения приходят не в том порядке, в котором были отосланы.
Условие семантической определенности
Теперь сформулируем основное условие ограничения для предлагаемого семейства алгоритмов.
Утверждение (условие семантической определенности): для корректной работы алгоритмов KBASA требуется выполнение условия
ye: e = e (agens, patiens, f: S ^ S),
где e — событие (e e Events);
agens, patiens — агенты (agens, patiens e
Agents);
S — множество состояний модели; f — предикат, преобразующий модель из одного непротиворечивого состояния s e S в другое.
Vil
Vol. 10. No. 1 (55). 2015
Таблица 1. Сравнительная характеристика алгоритмов синхронизации Table 1. Synchronization algorithms comparison
Признак сравнения Null Messages Algorithm Time Warp Algorithm
Требует пересылки сообщений по неубыванию временных меток Да Нет
Требует фиксированной топологии сети Да Нет
Требует, чтобы коммуникационная среда гарантировала доставку сообщений в порядке их отправления Да Нет
Требует механизма разрешения тупиков Да Нет
Требует наличия служебных сообщений Да (нулевые сообщения) Да (антисообщения)
Дополнительные вычисления LBTS GVT
Требует механизма откатов Нет Да
Уровень параллелизма Низкий Высокий
Требования к памяти Расходы памяти несущественны Расходы памяти существенны
Расход времени процессора Время может быть потрачено на ожидание (простой процессора) Время может быть потрачено на ненужные вычисления (ввиду откатов)
Эффективность вычислений Зависит от времени ожидания Зависит от количества откатов
Сложность реализации Относительно проста Весьма нетривиальна
Иными словами, для каждого события в любой момент времени можно выделить тройку {агенс — пациенс — предикат1}:
• агенс — активный участник коммуникации — агент, который выполняет действие над другим агентом;
• пациенс — участник коммуникации, над которым производится действие;
• предикат — действие, выполняемое па-циенсом по инициативе агенса.
Насколько данное условие сокращает круг моделируемых задач? На самом деле для большинства систем имитационного мо-
1 Термины агенс и пациенс были взяты из лингвистики (раздел «семантическая структура предложения»). В отечественном языкознании чаще применяют термины «агент» и «реципиент», однако в силу перегруженности термина «агент» (агент как интеллектуальная программная сущность и агент как семантическая роль участника ситуации) было принято решение оставить вариант в оригинальной трактовке.
делирования вполне можно выделить тройку {агенс — пациенс — предикат} для каждого события в модели. Более того, в статье рассматриваются агент-ориентированные модели, а для такого рода систем условие семантической определенности вполне естественно.
Гипотеза: Для любой системы агентно-го имитационного моделирования выполняется условие семантической определенности.
Приведенное выше утверждение сформулировано в виде гипотезы,поскольку точного определения агентной системы не существует.
Алгоритм#1
Алгоритм#1 служит простейшей эвристикой по устранению нежелательных откатов. На практике он объединен с Алго-ритмом#3.
Том 10. № 1 (55). 2015
Определение: Сообщение относится к классу stateless, если его пациенс не имеет внутреннего состояния.
Утверждение: Если событие относится к классу stateless, то оно допускается к обработке «в прошлом», поскольку это не приведет к нарушению локальной каузальности.
Доказательство. Парадоксы времени возникают из-за того, что внутреннее состояние агента (логического процесса) на момент прихода сообщения «из прошлого» не соответствует ожидаемому (т. е. состоянию на момент времени, равному временной метке сообщения). Если же агент не имеет внутреннего состояния, то нарушение локальной каузальности теоретически невозможно.
Таким образом, мы получаем, что агент работает как некоторый простой вычислитель функции — на один и тот же вход он выдает один и тот же выход.
Утверждение: Если агент обладает свойством stateless, то он является реактивным.
В обратную сторону утверждение, очевидно, неверно — если агент реактивный, то не обязательно он будет обладать свойством stateless, а значит, будет безопасным в смысле локальной каузальности.
Алгоритм представляет собой всего лишь 1 условный оператор (листинг 1).
Нужно отметить, что предложенный алгоритм будет прекрасно работать во многих простых моделях с реактивными агентами. Но по мере усложнения модели агенты будут развиваться — у них могут появиться память, знания и механизмы вывода на знаниях, а значит, практическая ценность Алго-ритма#1 будет снижаться.
Алгоритм#2
Описание алгоритма
Алгоритм#2 относится к классу эвристических методов, сдерживающих оптимизм. К таким, например, относят алгоритмы Breathing Time Buckets и Moving Time Windows [11]. В основу алгоритма положена идея коммуникации агентов. Если системе известны знания о том, какие формы коммуникации существуют в модели, то эти знания с успехом можно использовать для предотвращения откатов.
Утверждение: Если агенту приходит сообщение с запросом и системе достоверно известно, что оно требует ответа, то разнесение агентов по разным логическим процессам влечет многочисленные откаты.
Существует как минимум два варианта решения проблемы:
• выполнить кластеризацию и разместить тесно связанные агенты на одном логическом процессе(кластеризация и балансировка могут быть выполнены как статически до запуска модели, так и динамически в ходе имитационного прогона [3]);
• при обработке события, инициирующего коммуникацию, блокировать текущий логический процесс до момента прихода ответа от другого участника коммуникации.
Алгоритм был разработан в поддержку 2-го решения, однако на практике рекомендуется интеграция обоих подходов. Перед описанием алгоритма введем несколько определений.
Событие называется блокирующим, если для него выполняются 2 условия:
• событие подлежит отправке на другой логический процесс;
Листинг 1. Обработка события, не имеющего состояния Listing 1. Stateless event handling
if (event.t < currentTime) //needs rollback
if (event isStateless)
handleEvent(event)
else rollback(event)
\ 39
• событие содержит запрос, требующий ответа от другого участника коммуникации.
Событие, содержащее ответ на блокирующее событие, будем называть разблокирующим. Совокупность блокирующего и разблокирующего событий назовем контрарной парой.
При обработке блокирующего события процесс останавливает работу до тех пор, пока он не получит ответа на запрос. Во время блокирования никакие другие события, в том числе запланированные для других агентов, не выполняются.
Знания о том, какие события являются блокирующими, поступают в систему извне в виде некоторой спецификации модели (онтологии).
Проблема взаимной блокировки
Главной проблемой Алгоритма#2 является возможность появления тупиковых ситуаций. Действительно, ввиду стохастического поведения логических процессов возможна такая ситуация, когда оба процесса практически одновременно обрабатывают блокирующие события, отправляют запросы друг другу и ждут друг от друга ответа. В случае 3 или более процессов может образоваться цикл (рис. 10).
Рис. 10. Проблема взаимной блокировки Fig. 10. Deadlock issue
Для разрешения тупиковых ситуаций существует множество методов и механизмов. В описываемой программной системе механизм выглядит следующим образом:
• логический процесс, сталкиваясь с блокирующим событием, обрабатывает его, высылает сообщение, блокируется и от-
сылает еще одно сообщение специального типа (LockRequest) на тот же самый узел;
• любой заблокированный процесс, получивший LockRequest, должен немедленно выслать обратно сообщение специального типа LockResponse. Это говорит о том, что процесс уже заблокирован, а значит, он не сможет выслать разблокирующее событие.
Проблема бесконечного ожидания
Другая проблема при реализации Алго-ритма#2 — возникновение бесконечного ожидания. Общая схема проиллюстрирована на рис. 11.
Поясним схему на конкретном примере. Пусть логический процесс LP1 обработал цепочку событий {А, = 2, В, = 4, Dt = 6, Е, = 8}.
Отсюда локальное время LP1 - , = 8. Пусть событие Е (на процессе LP1) и F (на процессе LP2) образуют контрарную пару. Также положим, что обработка событий D и Е сопровождалась отправкой сообщения на LP2.
Итак, процесс LP1 обрабатывает событие Е, в результате чего он блокируется и высылает LockRequest на процесс LP2. Теперь предположим, что некоторый 3-й процесс LP3 присылает на LP1 сообщение С, = 5, которое, очевидно, вызывает откат процесса LP1 до состояния , = 4. В результате отката формируются антисообщения для событий D и Е, которые отменяют высланные ранее на LP2 сообщения. Предположим, что LP2 не успел обработать событие Е, а значит, оно будет взаимно уничтожено с антисообщением.
Результат: логический процесс LP2 даже не узнает о том, что его сосед ждет разблокирующего события Р. В итоге LP1 заблокирован навсегда.
Существует несколько путей решения:
• отменять блокировку по отсылке антисообщения;
• процессу-получателю блокирующего события заранее просматривать буфер входных сообщений;
• дождаться разблокирования, после чего выполнить откат.
40
Том 10. № 1 (55). 2015
Current Time Pointer
LP2
Рис. 11. Возникновение бесконечного ожидания Fig. 11. Deadlock conditions
На практике первый вариант оказался наиболее удачным, так как он хорошо интегрируется с Алгоритмом#3.
Алгоритм#3
Данный алгоритм также относится к классу эвристических методов, основанных на знаниях о модели, но на сей раз подход основан на причинно-следственной независимости событий.
Введем отношение каузальной зависимости событий.
Определение: Будем говорить, что событие А каузально зависит от события В, если агент, планирующий событие А, может изменить планирование любого другого события в будущем под влиянием события В.
Приведем простой пример. Если автомобиль пересекает железнодорожный переезд на открытый шлагбаум (событие — шлагбаум открыт), то все будущие события не изменятся, т. е. останутся с прежними временными метками. Если же шлагбаум закрыт, то время всех следующих событий однозначно будет изменено.
Необходимое условие каузальной зависимости
Рассмотрим теперь, как можно формально определить каузальную зависимость событий.
Теорема (необходимое условие каузальной зависимости). Для того чтобы события А = {agensA, patiensA, и В = {agensB, patiensB, fB} были каузально зависимы, необходимо, чтобы patiens1 = patiens2.
Прежде чем доказать это утверждение, покажем сначала справедливость леммы.
Лемма: Необходимое условие каузальной зависимости выполняется для любого терминального события А.
Доказательство леммы. Рассмотрим множество всех произвольных подмножеств событий логического процесса, упорядоченное по возрастанию временных меток (в хронологическом порядке). Обозначим tmln — минимум всех временных меток. Пусть на логический процесс приходит терминальное сообщение, содержащее событие А = {agensA, patiensA, причем его временная метка
t = ¿0 ^ ^min-
(*)
Рассмотрим 4 случая.
1. Предположим, существует событие В = {agensB, patiensB, fB}, такое, что agensA = agensB. Такое событие невозможно, поскольку агент, представляющий agensA, располагается на другом логическом процессе, а значит, он не может планировать события на локальном процессе.
2. Пусть существует событие С = {agensC, patiensC, такое, что agensA = patiensC.
Vi1
Это значит, что существует событие С = {agens¿, patiens¿, fС}, такое, что patiens¿ = agensC, причем t (С) < t (С). Иными словами, найдется агент, который спланировал событие С в прошлом. Обработка события А не может повлиять на исход события С, так как они выполняются разными агентами, а patiensA не планирует новых событий в силу терминальности. Значит, события А и С каузально независимы.
3. Пусть существует событие D = {agensD, patiensD, такое, что patiensA = patiensD. Событие А обрабатывает агент patiensA, причем в ходе обработки могло измениться его внутреннее состояние. В силу предположения событие D также обрабатывает агент patiensA, а раз t (А) < t то обработка D, возможно, выполнилась бы иначе (в зависимости от результата обработки события А). Вывод: данный случай действительно допускает возможность каузальной зависимости.
4. Предположим, существует событие Е = {agensE, patiensE, fE}, такое, что patiensA = agensE. Раз локальный процесс не имел информации о событии A, то существует событие Ё = {agensË, patiensË, fË}, такое, что patiensË = agensE, причем t (Ё) < t (Е). То есть найдется агент, который спланировал данное событие Е в прошлом. Заметим, что выполняется равенство
patiensË = agensE = patiensA.
Поэтому при t И) < t получаем случай, аналогичный случаю 3 (если положить DË), а вариант t (A) < t (О) не рассматриваем в силу условия (*).
Таким образом, мы показали, что если события каузально зависимы, то условия 1, 2, 4 не могут иметь место, а значит, справедлив только 3-й случай (пациенсы событий равны). Условие достаточности доказано.
Доказательство утверждения. Пусть теперь событие A не является терминальным. Значит, существует некоторое событие X = {agensX, patiensX, такое, что patiensA = agensX (событие X порождено агентом patiensA при обработке собы-
тия A). Очевидно, X и A каузально зависимы по определению.
Рассмотрим множество событий
Events' = {e е Events 11 (X) < t (e)}.
Иными словами, событие X будем сравнивать только с событиями из будущего. В итоге получаем новое множество
Ve е Events' : t(A) < t(X) < t(e).
Теперь вновь рассмотрим 4 случая, только на этот раз относительно пары событий X и A.
1. Пусть существует событие F = {agensF, patiensF, fF}, такое, что patiensX = patiensF. В ходе доказательства леммы выяснилось, что если пациенсы совпадают, то события каузально зависимы.
2. Пусть существует событие G = {agensG, patiensG, fG}, такое, что agensX = patiensG. Значит, имеет место равенство
patiensA = agensX = patiensG.
По лемме вновь получаем, что пациен-сы равны, а значит, вся тройка событий {A, X, G} каузально зависима.
3. Пусть существует событие H = {agensH, patiensH, fH}, такое, что patiensX = agensH. Значит, существует событие Й = {agens^ patiens й, f^, такое, что patiensЙ = agensH, причем t(Й) < t (H). Легко видеть, что выполняется равенство
patiensf, = agensH = patiensX.
А этот случай полностью аналогичен ситуации, рассмотренной в п. 1 (если положить F = Й).
4. Пусть существует событие I = {agens,, patiens,, f}, такое, что agensX = agens,. Данный случай в лемме не рассматривался, потому что мы имели дело с удаленным агентом. Теперь же агент локальный, поэтому случай следует рассмотреть. Из предположения следует, что существует событие = {agens , patiens , f }, такое, что patiensr = agens,, причем t (Г) < t (I). В итоге
patiensi = agens, = agensX.
Этот случай полностью аналогичен рассмотренному в п. 2 (если положить G = /).
Таким образом, мы показали, что если события каузально зависимы, неважно, терминальные они или нет, то их пациенсы равны. Условие необходимости доказано.
Замечание. Доказанное условие является необходимым, но не является достаточным (обратное не всегда верно: если пациенсы двух событий равны, то из этого не следует, что события каузально зависимы).
Описание алгоритма
Алгоритм#3 основан на принципе учета каузальной зависимости. Основная идея заключается в анализе зависимостей внутри цепочки событий с целью принятия решения о том, следует ли выполнить откат.
Суть оптимистических алгоритмов заключается в том, чтобы при получении сообщения с временной меткой, меньшей текущего времени (straggler message), выполнить откат на прежнее непротиворечивое состояние. Делается это для того, чтобы избежать парадокса времени. А всегда ли подобное сообщение вызывает парадоксы времени?
Итак, общая идея алгоритма: при получении сообщения «из прошлого» логический процесс вместо немедленного отката выполняет анализ всех подлежащих откату событий на предмет каузальной зависимости.
Пусть на логическом процессе LP1 обработана цепочка событий {At = 2, Bt = 4, Dt = 6, Е 0, F,.
Если бы Ct=5 было терминальным, а все события из цепочки отката были от него независимы, то алгоритм завершил бы работу с ответом true (обработка события Ct=5 разрешена, так как она не вызывает парадоксов времени).
Рекурсивная обработка
Если событие не является терминальным, то на этом алгоритм не останавливается, поскольку при обработке события вероятно возникновение необходимости планирования новых событий, которые могут поместиться внутри цепочки отката. Поэтому следующим шагом является так называемая «псевдообработка» события.
На данном этапе событие обрабатывается «виртуальным» симулятором. Единственная его цель — получить на выходе набор новых событий, планируемых агентом. Пусть в нашем примере событие Ct = 5 генерирует цепочку X = 9, Yt=11, Zt=J.
Далее все новые «псевдособытия» следует отфильтровать. Те из них, чьи временные метки больше или равны текущему времени процесса (t=12), исключаем из рассмотрения. В нашем примере остаются {Xt = 9, Yt =11}. Далее алгоритм повторяется рекурсивно для каждого из оставшихся псевдособытий.
Следует отметить, что на каждом шаге рекурсии текущее событие проверяется на каузальную зависимость только с событиями из будущего. То есть Xt=9 следует про-
Gt = 12}. Далее процесс LP2 высы- верять с парой {Ft=10, Gt=12}, а Yt=11 — только
лает событие С{ = 5. Очевидно, классический оптимистический алгоритм выполнит откат до состояния, заданного событием B. Цепочка отката примет следующий вид:
{Dt=6, Et=8, Ft=10, Gt=12}
(1)
В нашем алгоритме выполняется поиск события, каузально зависимого от Ct=5 по всем событиям из цепочки (1). Если хотя бы одно из этих событий каузально зависимо — алгоритм завершает свою работу с ответом false (обработка события Ct=5 запрещена, нужно выполнить откат).
с Gt=12. Если проверка прошла успешно (события независимы), то для Xt = 9 и Yt=11 снова проводится «псевдообработка», и процесс повторяется до тех пор, пока в цепочке отката не останется новых событий.
Последний шаг алгоритма — свертка. Если для события Ct = 5 и для всех его потомков в текущей цепочке отката нет ни одного каузально зависимого события — алгоритм завершает работу с ответом true (обработка события безопасна). В противном случае алгоритм завершает работу с ответом false.
VJ3
Vol. 10. No. 1 (55). 2015
Последнее важное замечание — проверять наличие каузальной зависимости между событиями достаточно сложно и не всегда возможно за приемлемое время. А вот проверять отсутствие этой зависимости уже проще — достаточно воспользоваться необходимым условием каузальной зависимости, которое было доказано выше.
Общий алгоритм обработчика сообщений
Ниже предлагается общий алгоритм цикла обработки принятых сообщений (язык Scala) (листинг 2).
Сначала обработчик выполняет откат, если сообщение пришло «из прошлого». Для антисообщений откат обязателен, для «позитивных» сообщений — только если Алго-ритм#3 посчитает обработку события опасной (и вернет false). Затем сообщение помещается в буфер, если оно «позитивное», либо взаимно уничтожается с одним из су-
ществующих в буфере, если это антисообщение.
Теперь приведем код функции isOK (точкой входа в рекурсию) (листинг 3).
Ниже приводится фрагмент рекурсивной функции isSafe (листинг 4).
Поясним представленный фрагмент. Функция «isStateless» представляет собой Алгоритм#1. Если событие обладает данным свойством, то его обработка априори считается безопасной. Иначе предполагаем, что событие безопасно и начинаем просматривать стек состояния модели.
На каждом шаге алгоритм изымает событие из стека, проверяет, не является ли оно каузально зависимым с текущим событием, и кладет событие во вспомогательное хранилище (storage). Ниже приводится фрагмент функции «correlate», основанной на необходимом условии каузальной зависимости (листинг 5).
Листинг 2. Функция handleMessage Listing 2. The handleMessage function
final def handleMessage(m: BaseMessage) {
// проверка на Rollback
if (getTime > m.t) m match {
case em: EventMessage =>
if (!isOK(em.timeevent)) rollback(m)
case _: AntiMessage => rollback(m) } // постановка во входную очередь
m match {
case _: AntiMessage => inputQueue find {_ == m} map {_ = >
inputQueue -= m } case em: EventMessage =>
inputQueue = (inputQueue += em).sorted
checkUpMessage(em) } }
final def isOK(e: TimeEvent): Boolean = if (isSafe(e)) runPseudoEvent(e) else false
Листинг 3. Функция isOK Listing 3. An isOK function
44
Том 10. № 1 (55). 2015
Листинг 5. Функция correlate Listing 5. A correlate function
Листинг 4. Функция isSafe Listing 4. An isSafe function
private def isSafe(e: TimeEvent): Boolean = {
// если событие "stateless", то оно априори безопасно if (Knowledge isStateless e.event) true else {
// просматриваем стек состояний (в направлении "в прошлое") var result = true
var storage: List[(TimeEvent, Array[Byte])] = Nil var q = stateStack peek() while (result && q != null) q = if (q._1.t < e.t) null else {
if (isLocal(q._1.event) && correlate(e.event, q._1.event))
result = false storage ::= stateStack pop() stateStack peek()
}
// заполняем стек обратно for {a <- storage}
stateStack push a result
}
}
private def correlate(cur: AgentEvent, that: AgentEvent): Boolean = cur.patiens == that.patiens
Если функция «corellate» вернет false, то мы можем быть уверены в том, что события независимы. А значит, алгоритм продолжает работу со стеком состояний. В противном случае функция свидетельствует о теоретической возможности существования каузальной зависимости, а значит, процедуру нужно остановить с ответом false (событие небезопасно).
Работа со стеком состояний заканчивается в одном из трех случаев:
• найдено событие из цепочки отката, такое, что оно каузально зависимо с проверяемым событием (алгоритм возвращает false);
• стек пуст (алгоритм возвращает true);
• пройдена вся цепочка отката, т. е. проверены все события, временная метка которых больше проверяемого события (алгоритм возвращает true).
Перед выходом из функции следует не забыть восстановить стек в предыдущее состояние (по принципу «Ханойской башни»).
Ну и наконец, представим функцию «псевдообработки» события, которая рекурсивно вызывает функцию «isOK» (листинг 6).
Здесь «simulateStep» возвращает список тех событий, которые будут (или могут быть) сгенерированы обработкой текущего события. Список фильтруется в соответствии с условием, что временная метка события меньше текущего времени логического процесса (функция «деТте»).
Далее для каждого события рекурсивно вызывается функция «isOK», и вычисления повторяются с самого начала. Если список, полученный на выходе «simulateStep» и отфильтрованный в соответствии с текущим
Vol. 10. No. 1 (55). 2015
Листинг 6. Функция runPseudoEvent Listing 6. A runPseudoEvent function
private def runPseudoEvent(e TimeEvent : Boolean = {
val lst = for {
event <- simulateStep(e) if event.t < getTime
} yield isOK(event)
lst forall {b => b} }
временем, окажется пустым, то рекурсия останавливается.
Трудности в реализации алгоритма
Алгоритм#3 также имеет проблемы в реализации. Основную трудность привносит «псевдообработка» события. Согласно алгоритму после обработки новые события фильтруются по значению временной метки. Однако в обработчике встречаются генераторы случайных чисел, а это не исключает того, что временные метки событий-потомков в «псевдообработке» могут отличаться от реальной обработки.
Приведем пример. Пусть локальное время процесса t = 20. Событие {А{ = 8} согласно Алгоритму#3 подвергается «псевдообработке», в результате которой генерируется цепочка событий = 10, С{= 18, Dt = 22, Е1 = 26, Ft = 28}. После фильтрации по временной метке остается цепочка ^ = 10, С{ = 18}.
Теперь положим, что алгоритм разрешил обработать событие а, = 8, но в процессе реальной обработки генераторы случайных чисел сработали так, что сгенерировалась цепочка ^ = № С, = 18, Dt = 19, Е = 26, ^ = 28}. Отсюда видно, что событие Dt = 19 не было проверено Алгоритмом#3, а значит, оно может вызвать нарушение локальной каузальности.
Существует несколько вариантов решения данной проблемы. Один из них будет предложен в следующем разделе.
онтологический подход к представлению знаний о модели
Понятие онтологии
Применение знаний в программных системах является ключевым отличием ин-
теллектуальных систем от обычных прикладных программ (такие системы нередко называют СБЗ — системы, базирующиеся на знаниях). Несмотря на то что точного определения систем искусственного интеллекта не существует2, СБЗ применяются во многих сферах для решения многих задач, в том числе для тех, для которых формализация затруднена или невозможна.
Мы имеем дело с агентным моделированием, которое является своего рода муль-тиагентной системой — множество агентов совместно решают задачу имитационного моделирования, оценивая ситуацию, общаясь между собой и принимая некоторые решения. Поэтому в силу своей специфики агентное моделирование немедленно предполагает наличие знаний у агентов.
Данная статья предлагает подход, который использует знания о модели не только для интеллектуальной составляющей агентов, но и с целью повышения эффективности синхронизации времени.
Гипотеза. Применение знаний о модели повышает эффективность оптимистических алгоритмов синхронизации (под эффективностью мы понимаем количество откатов и общее время моделирования).
Знания о предметной области представлены в виде онтологии. Данное понятие будем рассматривать в общепринятом определении [1].
Определение: Онтология предметной области — это тройка {Т, И, Ф},
2 Обычно под системами ИИ понимают такие системы, которые решают задачи, подходящие (ввиду отсутствия формального представления) для решения только человеком.
Том 10. № 1 (55). 2015
где Т — множество понятий из предметной области;
Я — множество связей между понятиями; Ф — множество функций интерпретации понятий из Т посредством связей из Я.
В зависимости от мощности множеств Я и Ф можно выделить различные формы он-тологий: словари, глоссарии, таксономии понятий, тезаурусы и т. д. Основная цель онтологии — специфицировать знания о некоторой предметной области в явном виде.
Предметная онтология и онтология задачи
Согласно одной из классификаций онтологии можно разделить на 3 категории:
• метаонтология;
• предметная онтология;
• онтология задач.
Метаонтология оперирует общими понятиями, которые в целом не зависят от предметной области. Предметная онтология, очевидно, описывает понятия из предметной области. Онтология задач возникает в так называемой проблемной области (когда имеется предметная область и поставленная задача).
В поддержку данной статьи была разработана предметная онтология, которая специфицирует предметную область «Оптимистическая синхронизация в агентном PDES-моделировании». Исследователю тем самым открывается возможность быстро создавать онтологии задач, соединяя понятия из конкретной модели (например, Подрядчик) с понятиями из предметной области (например, Агент).
Общий вид предметной онтологии проиллюстрирован на рис. 12 и 13.
Многослойная структура связана с тем, что главной практической ценностью онтологии является возможность использования ее в качестве основы для создания онтологии задачи. Поскольку онтологию задачи составляет исследователь модели, он должен получить доступ ко всем необходимым концептам из предметной онтологии, и только к ним. Такие понятия, как Сообщение, Антисообщение и др., должны быть скрыты от него.
Фактически исследователь будет использовать понятие Событие, которое несет в себе временную метку (timestamp) и Тип События. Тип события, в свою очередь, определен тройкой Агенс-Пациенс-Преди-
Рис. 12. Предметная онтология. Слой пользователя Fig. 12. The domain-specific ontology. User Layer
Vol. 10. No. 1 (55). 2015
Рис. 13. Предметная онтология. Слой разработчика симулятора и слой алгоритмов синхронизации Fig. 13. The domain-specific ontology. Developer Layer and Synchronization Algorithms Layer
кат, которые, как видно из рис. 12, ссылаются на Агентов и Функции Преобразования.
Следующий слой описывает концепты для разработчика симулятора: ему уже требуются такие знания, как Локальный и Удаленный Агент, а также Сообщение. Нетрудно заметить, что данный слой расширяет предыдущий — здесь агенты классифицируются по принадлежности к локальному процессу. Более того,онтология указывает на тот факт, что удаленные агенты упаковывают события внутрь сообщений.
Наконец, слой алгоритмов синхронизации оперирует наиболее сложными понятиями, которые должны быть скрыты как от исследователя, так и от разработчика симулятора: Откаты, Антисообщения и т. п. (рис. 13).
Практические исследования
Общее описание модели
Тестовая агентная модель «Супермаркет» разрабатывалась специально для прак-
тического анализа алгоритмов синхронизации. Тип модели — СМО (Системы массового обслуживания) [2, 4].
Определение: Система массового обслуживания — математическая модель, описывающая систему, в которой обслуживающие устройства обрабатывают некоторый (дискретный или непрерывный) поток заявок.
Отличительными особенностями данной модели являются:
• относительная простота реализации;
• интенсивная коммуникация между агентами.
Эксперименты проводились на 2 логических процессах, однако сама модель легко масштабируется на множество процессов. Интенсивная коммуникация благоприятствует частому нарушению локальной каузальности и, как следствие, многочисленным откатам.
Итак, модель представляет собой совокупность 5 агентов:
Guard (Охранник супермаркета)
• может открыть/закрыть двери супермаркета;
• может выходить покурить;
• может позвать Кассира2 покурить;
• может отлучиться на технологический перерыв;
• может заподозрить посетителя в краже товара.
Cashier1 (Кассир1)
• обслуживает покупателей;
• может отлучиться на технологический перерыв.
Cashier2 (Кассир2)
• обслуживает покупателей;
• может отлучиться на технологический перерыв;
• может выйти с Охранником покурить.
Purchaser (Покупатель)
• выбирает товары;
• может своровать товар;
• может выбрать кассу для обслуживания;
• может выбрать способ оплаты (наличный/безналичный расчет).
Supermarket (Окружающая среда)
Окружающая среда представляет собой реактивного агента, хранящего общее состояние модели.
Агент покупателя присутствует в модели во множестве экземпляров, остальные агенты — в единственном экземпляре.
Цель модели: получить информацию об эффективности работы персонала (средняя длина очереди и объем похищенного товара).
Наша цель отличается от цели модели — нам требуется сравнить эффективность алгоритма Time Warp и алгоритмов, основанных на знаниях об агентной модели.
Онтология тестовой модели
В данном разделе мы приведем в качестве примера небольшой фрагмент онтологии задачи для модели «Супермаркет» (рис. 14).
В центре схемы изображено событие requestToSmoke. В соответствии с условием семантической определенности для него обязательно должны быть определены агенс, пациенс и предикат. В роли первого выступает агент Охранник (Guard), в роли второго — Кассир2 (Cashier2), в качестве предиката — ссылка на некоторую функцию (обозначена как 5).
Дополнительные связи вводятся для повышения семантической мощности механизмов синхронизации агентов. В нашем случае это отношение waits_for, которое непосредственно использует Алгоритм#2.
Рис. 14. Фрагмент онтологии тестовой модели «Супермаркет» Fig. 14. The Supermarket ontology fragment
\ 49
Vol. 10. No. 1 (55). 2015
Таблица 2. Результаты работы алгоритма Time Warp на тестовой модели Table 2. Time Warp results on the test model
Категория 1 2 3 4 5 6 7 8 9 10 Среднее
EVENTS_HANDLED: 1197 1197 1229 1229 1229 1259 1289 1229 1259 1199 1231,6
MAX_TIME_WINDOW: 10 8 13 17 9 14 19 10 10 9 11,9
RECEIVED_ANTI_MESSAGES: 9 12 8 5 13 6 9 6 8 8 8,4
RECEIVED EVENT MESSAGES: 76 89 91 82 89 80 88 85 92 87 85,9
RECEIVED_MESSAGES: 85 101 99 87 102 86 97 91 100 95 94,3
ROLLBACKS: 61 67 77 73 74 70 74 69 74 73 71,2
ROLLBACKS_DEPTH_1: 12 10 15 11 9 9 7 11 12 13 10,9
ROLLBACKS_DEPTH_2: 5 12 10 14 18 9 9 10 10 10 10,7
ROLLBACKS_DEPTH_3: 11 8 17 9 10 12 8 11 8 15 10,9
ROLLBACKS_DEPTH_4: 12 10 13 6 8 10 12 5 15 11 10,2
ROLLBACKS_DEPTH_5: 3 9 8 10 5 11 9 8 7 10 8,0
ROLLBACKS_DEPTH_6: 6 7 8 5 5 6 7 13 9 6 7,2
ROLLBACKS_DEPTH_7: 4 5 3 6 7 6 8 2 4 3 4,8
ROLLBACKS_DEPTH_MORE: 20 16 18 23 21 16 21 20 21 18 19,4
ROLLBACKS_MAXDEPTH: 21 18 24 24 27 18 32 16 22 16 21,8
SENT_ANTI_MESSAGES: 103 79 115 110 116 105 139 101 122 94 108,4
SENT_EVENT_MESSAGES: 416 386 438 412 433 459 466 424 442 409 428,5
SENT_MESSAGES: 519 465 553 522 549 564 605 525 564 503 536,9
90 80 70 60 50 40 30 20 10 0
123456789 101112131415
Time warp KBASA
160 140 120 100 80 60 40 20 0
Time warp KBASA
123456789 101112131415
Рис. 15. Количество откатов за 300 ед.
модельного времени Fig. 15. Amount of rollbacks by 300 model time ticks
Рис. 16. Отправлено антисообщений за 300 ед. модельного времени Fig. 16. Antimessages sent by 300 model time ticks
50
Том 10. № 1 (55). 2015
Таблица 3. Результаты работы алгоритмов KBASA на тестовой модели Table 3. KBASA results on the test model
Категория 1 2 3 4 5 6 7 8 9 10 Среднее
EVENTS_HANDLED: 735 941 916 859 883 871 820 870 915 947 875,7
MAX_TIME_WINDOW: 2 3 5 8 15 6 14 6 2 7 6,8
RECEIVED_ANTI_MESSAGES: 3 2 0 1 0 1 0 3 1 0 1,1
RECEIVED EVENT MESSAGES: 71 89 73 75 71 80 71 88 83 86 78,7
RECEIVED_MESSAGES: 74 91 73 76 71 81 71 91 84 86 79,8
ROLLBACKS: 1 3 5 4 5 2 7 4 1 6 3,8
ROLLBACKS_DEPTH_1: 0 0 0 0 0 0 0 0 0 0 0,0
ROLLBACKS_DEPTH_2: 0 0 0 0 0 0 0 0 0 0 0,0
ROLLBACKS_DEPTH_3: 0 0 0 0 0 0 0 0 0 1 0,1
ROLLBACKS_DEPTH_4: 0 0 0 0 0 0 0 0 0 0 0,0
ROLLBACKS_DEPTH_5: 0 0 0 0 1 0 0 0 0 0 0,1
ROLLBACKS_DEPTH_6: 0 1 0 0 0 0 0 1 0 0 0,2
ROLLBACKS_DEPTH_7: 1 1 0 0 0 0 0 0 0 0 0,2
ROLLBACKS_DEPTH_MORE: 0 1 5 4 4 2 7 3 1 5 3,2
ROLLBACKS_MAXDEPTH: 7 9 14 25 27 18 36 22 11 20 18,9
SENT_ANTI_MESSAGES: 1 4 17 16 20 8 30 11 2 19 12,8
SENT_EVENT_MESSAGES: 262 353 344 316 337 331 273 324 330 349 321,9
SENT_MESSAGES: 263 357 361 332 357 339 303 335 332 368 334,7
При наличии у события такого атрибута логический процесс при необходимости заблокирует работу.
Отношение produces представляет собой ссылку на список тех событий, которые могут быть сгенерированы при обработке текущего события. Это исключает необходимость «псевдообработки», что автоматически сокращает дополнительные вычисления и устраняет проблемы, связанные с генераторами случайных чисел.
Результаты экспериментов
Моделирование проводилось в кластере на 2 вычислительных узлах. На первом логическом процессе располагались Охранник,
Рис. 17. Число глубоких откатов за 300 ед. модельного времени Fig. 17. Amount of high-depth rollbacks by 300 model time ticks
Vol. 10. No. 1 (55). 2015
Кассир1 и 8 агентов-покупателей. На втором были размещены Кассир2, Супермаркет и 8 других агентов-покупателей.
Модель была выполнена многократно при одних и тех же параметрах. Общая длительность моделирования составляла 300(±15)ед. модельного времени.
Результаты тестирования алгоритма Time Warp представлены ниже в табл. 2. Среднее время имитационного прогона составляет 134,24 с.
А ниже представлены результаты работы алгоритмов, основанных на знаниях (табл. 3). Среднее время имитационного прогона составляет 116,12 с.
Как видим, время моделирования сократилось на 18 секунд. Результат невелик, однако это объясняется простотой модели. На более сложных моделях разница будет более заметна.
А теперь рассмотрим другие показатели.
• Количество откатов сократилось с 71,2 до 3,8 (рис. 15). Это, наряду с общим временем моделирования, подтверждает эффективность новых алгоритмов синхронизации.
• Общее число неглубоких откатов сократилось практически до нуля (в среднем 0,1-0,2 против 7-11). Это в основном демонстрирует работу Алгоритма#3 — чем меньше глубина цепочки отката, тем больше вероятность того, что все события из нее будут каузально независимы.
• Число глубоких откатов также сократилось с 19,4 до 3,2 (рис. 17).
• Количество отправленных антисообщений сократилось с 108,4 до 12,8 (рис. 16). Этот эффект, очевидно, коррелирует с уменьшением числа откатов.
• Общее количество отправленных сообщений также уменьшилось (с 536,9 до 334,7). Результат впечатляющий, даже несмотря на то, что новые алгоритмы требуют отправки дополнительных служебных сообщений (TimeRequest, TimeResponse).
• Общее количество обработанных событий уменьшилось с 1231,6 до 875,7. Это означает, что в среднем алгоритм Time Warp утратил ввиду откатов как минимум 350 событий.
• Общее количество принятых сообщений также сократилось вместе с сокращением отправленных сообщений (с 94,3 до 79,8).
• Максимальная разница «возвращенного назад» времени сократилась практически вдвое: с 11,9 до 6,8.
Итак, мы видим, что алгоритмы синхронизации агентов, основанные на знаниях, действительно подтверждают свою эффективность на практике. Единственный момент: максимальная глубина отката сократилась незначительно (с 21,2 до 18,1). Для решения проблемы можно воспользоваться уже существующими эвристиками, например стратегией Moving Time Windows [11] либо техникой lookback [9].
Заключение
В статье была выдвинута и успешно подтверждена на практике гипотеза о повышении эффективности синхронизации агентов при использовании знаний о модели. Напомним, что под эффективностью оптимистического алгоритма подразумевается время моделирования и общее количество откатов.
Научная область распределенного имитационного моделирования достаточно хорошо исследована: авторы из многих стран предлагают различные решения для синхронизации логических процессов. Тем не менее до сих пор не найдено ни одного способа, который позволил бы решить проблему раз и навсегда. За 40 лет исследований авторы предложили массу идей, от самых элементарных модификаций до весьма сложных моделей, где дополнительно привлекаются методы из смежных областей: теории вероятности, генетических алгоритмов, экспертных систем (как, например, в распределенной системе моделирования «Мера» [6]).
Поэтому в статье не просто предлагаются новые эффективные алгоритмы синхронизации агентных моделей. В ней содержится призыв к научным деятелям продолжать исследования в области синхронизации параллельного дискретно-событийного моде-
Том 10. № 1 (55). 2015
лирования, а в качестве главного инструмента применять знания о модели.
Более того, знания о модели могут успешно применяться в других задачах оптимизации имитационного процесса: управление интеллектуальными агентами, получение новых знаний при сборе статистики, балансировка нагрузки между узлами сети (как, например, в системе моделирования ВС «Triad» [1, 3, 5]).
Список литературы
1. Замятина Е. Б., Миков А. И., Михеев Р. А. Применение онтологий в системе проектирования и моделирования компьютерных сетей TRIAD NS. «IS&IT'11». M.: Физматлит, 2011. Т. 1. С. 253-260.
2. Замятина Е. Б. Современные теории имитационного моделирования: учеб. пособие. URL: http:// window.edu.ru/resource/717/41717 (дата обращения: 06.06.2013).
3. Миков А. И. Автоматизация синтеза микропроцессорных управляющих систем. Иркутск: Изд-во Иркут. ун-та, 1987.
4. Миков А. И., Замятина Е. Б. Распределенные системы и алгоритмы: учеб. пособие. URL: http:// www.intuit.ru/department/algorithms/distrsa/ (дата обращения: 06.06.2013).
5. Замятина Е. Б., Миков А. И. Проблемы повышения эффективности и гибкости систем имитационного моделирования // Проблемы информатики. 2010. № 4. С. 49-64.
6. Окольнишников В. В. Распределенная система имитационного моделирования. Труды Всероссийской научно-практической конференции «Методы и средства обработки информации», МС0-2003. М.: Издательский отдел факультета ВМиК. 2005. С. 468-474.
7. Емельянов А. А., Власова Е. А., Дума Р. В. Имитационное моделирование экономических процессов. Учебное пособие. 2-е изд. М.: Финансы и статистика; Инфра-М, 2009.
8. Chandy K. M, Misra J. Distributed simulation: A case study in design and verification of distributed programs. IEEE Transactions on Software Engineering, SE-5 (5): рp. 440-452, September, 1979.
9. Chen G. G, Szymanski B. K. Parallel queuing network simulation with lookback-based protocols.
Proc. International Mediterranean Modeling Multiconference of European Multi-Simulation Symposium, Barcelona, 2006, pp. 545-551.
10. Jefferson D. R. Virtual Time. ACM Transactions on Programming Languages and Systems, 1985, 7 (3), pp. 404-425.
11. Vee V. Y, Hsu W. J. Parallel Discrete Event Simulation: A Survey. Centre for Advanced Information Systems, SAS, Nanyang Technological University, Singapore, 2002, pp. 639-798.
References
1. Zamjatina E. B., Mikov A. I., Miheev R. A. Primene-nie ontologij v sisteme proektirovanii i modelirovanija komp'juternyh setej TRIAD NS [Applying of an ontology in the TRIAD NS computer network designing and simulation system]. «IS&IT'11». M.: Fizmatlit, 2011, vol. 1, pp. 253-260.
2. Zamjatina E. B. Sovremennye teorii imitacionnogo modelirovanija: ucheb. Posobie [Modern theory of the simulation: guide book]. URL: http://window.edu. ru/resource/717/41717 (accessed: 06.06.2013).
3. Mikov A. I. Avtomatizacija sinteza mikroproces-sornyh upravljajushhih sistem [Microprocessing and managing systems synthesis automatization]. Irkutsk: Izd-vo Irkut. un-ta, 1987.
4. Mikov A. I., Zamjatina E. B. Raspredeljonnye siste-my i algoritmy: ucheb. Posobie [Distributed systems and algorithms: guide book]. URL: http://www.in-tuit.ru/department/algorithms/distrsa/ (accessed: 06.06.2013).
5. Zamjatina E. B., Mikov A. I. Problemy povysh-enija jeffektivnosti i gibkosti sistem imitacionnogo modelirovanija [Issues of increasing efficiency and flexibility of simulation systems]. Problemy in-formatiki — Problems of informatics, 2010, no 4, pp. 49-64.
6. Okol'nishnikov V. V. Raspredeljonnaja sistema imitacionnogo modelirovanija [A distributed simulation system]. Trudy Vserossijskoj nauchno-prakticheskoj konferencii «Metody i sredstva obrabotki informacii» [Proc. Of the Russian academic and training conference «Methods and technics of data processing»], MSO-2003, Moscow, Izdatel'skij otdel fakul'teta VMiK, 2005, pp. 468-474.
7. Emel'janov A. A., Vlasova E. A., Duma R. V. Imita-cionnoe modelirovanie jekonomicheskih process-ov [Economic functions simulation]. Uchebnoe po-
\ 53
Vol. 10. No. 1 (55). 2015
sobie. 2 izd. Moscow, Finansy i statistika, Infra-M, 2009.
8. Chandy K. M, Misra J. Distributed simulation: A case study in design and verification of distributed programs. IEEE Transactions on Software Engineering, SE-5 (5): pp. 440-452, September, 1979.
9. Chen G. G, Szymanski B. K. Parallel queuing network simulation with lookback-based protocols. Proc. International Mediterranean Modeling Multi-
conference of European Multi-Simulation Symposium, Barcelona, 2006, pp. 545-551.
10. Jefferson D. R. Virtual Time. ACM Transactions on Programming Languages and Systems, 1985, 7 (3), pp. 404-425.
11. Vee V. Y, Hsu W. J. Parallel Discrete Event Simulation: A Survey. Centre for Advanced Information Systems, SAS, Nanyang Technological University, Singapore, 2002, pp. 639-798.
A. Mitrakov, Perm State National Research University, Perm, Russia, mitrakov-artem@yandex.ru
Knowledge applications for agent synchronization in the parallel discrete-event simulation
This paper is devoted to synchronization algorithms of agent-based parallel discrete-event simulation. There are a lot of algorithms for such distributed simulation modeling, and most of them are fallen into two groups: conservative and optimistic ones.
However the sphere of the research is simulation of agent-based systems. The agents are known to be «smart»: they have some kind of knowledge that helps them reasoning in different situations. So the idea is that we could use this knowledge base not only for artificial intelligence, but also for synchronization algorithms in parallel simulation.
This paper provides the family of algorithms called KBASA (Knowledge Based Agent Synchronization Algorithms) that result to significant improvement of standard optimistic algorithms. They are designed exclusively on agent-based systems and are not compatible with usual distributed simulation because of lack of knowledge.
Ontology was introduced as a knowledge base of an agent. The specification of the ontology is also provided in the paper.
Eventually KBASA were designed and implemented on Akka (for Scala programming language) and tested on real models. Theoretical description and practical results are also provided as well as comparison with the standard optimistic algorithms on the same model.
Keywords: simulation, agent, agent-based modeling, distributed modeling, agent synchronization algorithms, optimistic algorithms, ontology, knowledge base.
About author:
A. Mitrakov, Master of Computer Science For citation:
Mitrakov A. A. Knowledge applications for agent synchronization in the parallel discrete-event simulation. Prikladnaya informatika — Journal of Applied Informatics, 2015, vol. 10, no. 1 (55), pp. 31— 54 (in Russian).
