Ресурсные и информационные конфликты в конвейерных системах

МОСКОВСКИЙ АВИАЦИОННЫЙ ИНСТИТУТ

(НАЦИОНАЛЬНЫЙ ИССЛЕДОВАТЕЛЬСКИЙ  УНИВЕРСИТЕТ)

 

 

 

 

 

 

 

 

 

КУРСОВАЯ РАБОТА

по дисциплине

«Моделирование ЭВМ»

тема

«Ресурсные и информационные конфликты в конвейерных системах»

 

 

 

 

 

 

 

Выполнила

Студентка

гр. 03-419

Фурсенко В.В.

Работу приняла

Звонарева Г. А.

 

 

 

 

 

 

 

 

 

 

 

 

Москва, 2012

 

Оглавление

 

Теоретический материал 4

Конвейерная организация 4

Информационные и ресурсные конфликты 7

Организация памяти 10

Признаковый обмен и сквозная запись 13

Блоки GENERATE и TERMINATE 14

Блок ADVANCE 15

Блоки SEIZE и RELEASE 16

Блок TRANSFER 16

Блок LOGIC 17

Блок GATE 18

Задание для лабораторной работы 18

Пример выполнения задания 22

Описание используемых в модели обозначений 22

Описание модели 23

Блок-схема модели конвейерной ВС 25

Текст программы-модели конвейерной ВС 28

Выбор времени моделирования 30

Отладка модели 31

Тест 1 31

Тест 2 35

Тест 3 45

Тест 4 54

Анализ результатов моделирования 68

Анализ  влияния длины I-очереди на производительность модели 68

Анализ  влияния количества РАО и РДО  на производительность модели 69

Анализ влияния ширины выборки из кэш-памяти на производительность модели 70

Анализ  влияния формата команд на производительность модели 72

Анализ простоя логики декодирования при загруженной I-очереди 73

Варианты заданий для студентов 75

Вариант 1 75

Вариант 2 75

Вариант 3 75

Вариант 4 75

Вариант 5 76

Вариант 6 76

Вариант 7 76

Вариант 8 76

Вариант 9 77

Вариант 10 77

Список используемой литературы 77

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Теоретический материал

Конвейерная организация

 

Конвейерная обработка основана на разделении исполняемой команды на сегменты, и выделении для каждой из них отдельного блока аппаратуры^[1]. Сегментами конвейера могут быть оперативная память, арифметическое устройство, логическое устройство и др. Так же важную роль в конвейере играет организация передачи данных от одного сегмента к следующему. Конвейерную обработку можно использовать для совмещения этапов выполнения разных команд. Производительность при этом возрастает в разы, так как на различных тактах конвейера может выполняться несколько команд.

Конвейеры можно классифицировать по двум типам: линейность и статичность^[1]. Если при выполнении одной команды каждый сегмент конвейера используется один раз, то такой конвейер линейный. В противном случае, если в процессе выполнения команды есть повторение работы сегмента, то конвейер является не линейным. В конвейере порядок прохождения сегментов может отличаться, в зависимости от той команды, которая поступила на обработку. Такой конвейер будет динамическим. Если же для всех команд один порядок, то конвейер статический.

Помимо  этого можно разделить конвейеры  по времени обработки информации на каждом сегменте конвейера^[1]. В таком случае их разделяют на те, где время одинаково и где оно разное.

Использование ресурсов конвейера на каждом шаге задается с помощью таблицы занятости  ресурсов^[1]. Она представляет собой таблицу, где по вертикали идут номера сегментов, а по горизонтали такты работы конвейера.

Используя таблицу занятости можно по-другому  определить классификацию конвейера по статичности. Так, статичный конвейер – это конвейер, у которого все команды имеют одинаковую таблицу занятости^[1]. Если же, конвейер выполняет команды с различными таблицами занятости, то он динамический.

 

 

 

 

 

Допустим, что в конвейер  загружена команда  типа «B», и требуется понять, в каком такте можно будет загружать в конвейер такую же команду.

 

  Чтобы это сделать используется  начальный вектор столкновений (НВС). Он характеризует конфликтность  2х команд, которые могли бы  быть введены в конвейер. Это двоичный вектор и он строится путем наложения одной команды на другую. Если во время наложения где-то произошло совпадение требуемых ресурсов, значит, вводит новую команду в этот такт нельзя, и в вектор ставиться 1 на месте соответствующем текущему такту. После этого таблица вводимой команды смещается на один такт и заново проверяется возможность её ввода в конвейер^[1].

 

Чтобы просчитать, когда можно будет  вводить третью и последующие команды используют граф состояний. Это объединение НВС. Рассмотрим пример на команде «B»:

Так же существует модифицированный граф состояний, который формируется  только из тех состояний, в которых происходит ввод команды:

Ключевым  параметром к определению производительности конвейера является латентность  – число единиц времени, разделяющее  команды одной или нескольких таблиц занятости^[2].

Из  модифицированного графа состояний  наглядно видно, что следующую команду  можно вводить двумя циклами:

• 3,8,3,8…
• 4,4,4,4…

Исходя из этого, можно просчитать среднюю задержку (латентность) конвейера:

• T_ср =
• T_ср =

Начальный вектор столкновений используется только в  статических конвейерах.

Так как в динамическом конвейере  фигурирует две или больше команды, то НВС становиться бесполезным. Вместо него используют матрицу столкновений. Рассмотрим на примере команды двух типов «А» и «B»:

 

Информационные  и ресурсные конфликты

 

Конфликтом  при конвейеризации команд называют ситуацию, которая препятствует выполнению очередной команды из потока команд в предназначенном для нее  такте^[2].

Структурные или ресурсные конфликты возникают  в результате того, что аппаратные средства не могут поддерживать все  комбинации команд в режиме их одновременного выполнения с совмещением на конвейере. Это происходит в случае, если какие-то устройства в процессоре не конвейеризованы, либо – присутствуют в единственном экземпляре (не распараллелены). Например, могут возникать конфликты при  обращении к общей кэш-памяти: одну команду необходимо извлечь  из памяти (на первом этапе выполнения), а другая пытается записать результат  в память на заключительном этапе. Для  борьбы с ресурсными конфликтами  в основном применяют три способа^[2]:

1. приостановка конвейера до разрешения конфликта (до завершения первой конфликтующей команды);
2. дублирование аппаратных средств, вызывающих конфликт, например, разделение кэш-памяти на кэш команд и кэш данных;
3. ускорение или конвейеризация проблемного устройства, что позволяет снизить затраты времени на приостановку.

Решение об увеличении аппаратных затрат в  последних двух случаях принимают, если конфликт возникает часто, так  как дополнительные затраты могут  быть существеннее, чем потери производительности от приостановки конвейера, если она  происходит редко.

В неконвейерной машинной структуре все операции, связанные с исполнением отдельной команды, завершаются до запуска следующей команды. Таким образом, очередность соответствует логической очередности. При конвейеризации исполнения команд перекрываются, так что некоторые операции, нужные для команд i+1, i+2,…, могут запускаться и быть выполненными до завершения i-ой команды. Если команды i+1, i+2,… зависят от результатов i-ой команды, то получаются помехи, которые должны быть разрешены. Чаще всего методом разрешения помех служит блокировка^[2].

Помеха  возникает, когда к объекту данных (регистру, ячейке памяти) обращаются или  модифицируют его две различные  команды близко расположенные в  программе. Из-за этого при конвейеризации их исполнение перекрывается. Имеется  три класса таких помех^[1]:

1. Чтение после записи (RAW)
2. Запись после чтения (WAR)
3. Запись после записи (WAW)

 

 

 

 

 

 

Для примера рассмотрим фрагмент программы:

Чтение  после записи между командами  i и j (команда j следует после команды i) возникает, когда команда j пытается читать объект модифицируемый командой i. Если операция в команде i не завершится к тому моменту как команда j обратиться к изменяемому i-ой командой объекту, то команда j получит неправильное значение^[2]. В виде программы это можно записать как:

Запись  после чтения происходит, если команда  j хочет модифицировать некоторый объект, который читается командой i. Если j успевает изменить объект до того как команда i прочтет из него информацию, то i получит неправильное значение^[2]. Этой помехе соответствует фрагмент программы:

Помеха  записи после записи существует, когда  обе команды i и j пытаются обновить данный в одном и том же объекте, но i-ая команда может выполниться после     j-ой. Тогда в результате, после выполнения обоих команд значение ячейки памяти или регистра будет равно значению от команды i^[2]. На примере это выглядит так:

Чтобы разобраться и решить данные помехи вводят два определения:

1. Область определения команды i (D(i)) – это множество всех объектов, содержимое которых влияет на исполнение этой команды.
2. Множество значений команды i (R(i)) – это множество всех объектов, содержимое которых может быть изменено во время выполнения команды i.

Таким образом, D(i) – это множество всех объектов, читаемых командой i, а R(i) – это множество всех объектов, которое изменяется командой i^[2]. Исходя из этих двух определений, можно записать условия возникновения помех:

1. RAW – R(i) ∩ D(j) ≠ Ω
2. WAR – D(i) ∩ R(j) ≠ Ω
3. WAW – R(i) ∩ R(j) ≠ Ω

Здесь ∩ - пересечение двух множеств, а  Ω – пустое множество.

Также эти условия можно представить  в графической форме:

 

 

 

Существует  множество способов и приемов  для обнаружения и устранение помех без нарушения работы машины. В большинстве случаев случаи обнаружение помех можно разделить  на два типа^[2]:

1. Централизация обнаружения помех на одной ступени, обычно на фазе выборки, и сравнение на этой ступени области определения и множества значений команды с соответствующими областями определения и множествами команд, уже находящихся в конвейере.
2. Команда продвигается по конвейеру до тех пор, пока она не достигнет точки, в которой требуется тот или иной элемент либо из области определения, либо из множества значений. Тогда осуществляется проверка того, нет ли потенциальной помехи от другой команды, находящейся в конвейере.

Второй  подход более гибкий, однако, объём  аппаратуры, необходимой для выполнения сравнений может расти как  квадрат числа ступеней.

Также существуют два подхода к устранению помехи, если она обнаружена^[2]:

1. Остановить конвейер, если найдена помеха. Если обнаружена команда j, находящаяся в состоянии помехи с ранее инициированной командой i, то все последующие инициации команд j, j+1, j+2,… останавливаются до тех пор, пока команда i не пройдёт через точку конфликта.
2. Остановить команду j, командам j+1, j+2,… разрешается продвигаться по конвейеру. Это даёт возможность командам j+1, j+2,… обогнать команду j в конвейере. Аналогично при проверках на наличие помех для этих команд нужно предусматривать и сравнения с задержанной командой j. Если здесь обнаруживается помеха, то выполнение этих команд также должно быть отложено до тех пор, пока исходная помеха для команды j не будет устранена, и пока этой команде j не будет разрешено продолжаться.

Второй  подход ускоряет устранение помех типа RAW. Команда чтения обращается к ячейке памяти, содержимое которой изменяется предыдущей командой записи. Прямое решение состоит в задержании команды чтения до тех пор, пока команда записи не завершит модификацию. Последующая выборка из той же ячейки памяти позволит запустить дальнейшее исполнение команды чтения.

Есть  более быстрое решение – короткое замыкание. При нем копия данных, подлежащих записи, непосредственно  передаётся ожидающей команде чтения, избавляя её от необходимости ждать  завершения команды записи и затем  выполнять ещё одно чтение.

Обобщение этого процесса, называемое опережающей  засылкой, можно использовать для  ускорения устранения всех помех  типа RAW. В каждой точке конвейера, в которой должно происходить обращение к данным, вводимым в некоторую функцию, помещается множество фиксаторов ступени для приёма этих данных.

Если  данные для некоторой команды, проходящей через некоторую ступень, находятся  в состоянии помехи типа RAW с какой-либо из более ранних команд, один из фиксаторов этой ступени загружается не данными, которых всё ещё нет, а индексом или тегом, указывающим на ту ступень, которая их выработает. Затем команда, ожидающая эти данные, задерживается на этой ступени до их поступления. Фиксаторы на входе в ступень позволяют другим командам проходить через неё, пока команда, зависящая от RAW, задержана. Когда ступень заканчивает вычисление, она проверяет все остальные фиксаторы ступеней на предмет того, нет ли в каком-нибудь из них тега, совпадающего с её идентификатором. Если такой тег имеется, то соответствующая ступень получает копию данных. Это позволяет возобновить выполнение задержанных команд и продолжить их продвижение по конвейеру^[2].

Организация памяти

 

Машины  проектируются с целью достижения минимальной латентности. Простая  структура памяти быстро становится фактором, ограничивающим достижимую производительность. Чтобы избежать нарушения в работе конвейера, обычно используется комбинация различных  методов. Простейшим является физическое разбиение памяти на две половины, доступ к которым может быть осуществлен  одновременно. Помещение всех команд в одну половину, а всех данных - в  другую увеличивает среднюю скорость доступа к памяти почти вдвое. При таком разделении памяти требуется  внимание со стороны программиста при  загрузке программ.

Следующий метод – расслоение памяти. Хотя время доступа к одной команде  не уменьшается, но увеличивается число  доступов, находящихся в процессе их выполнения одновременно, и тем  самым увеличивается эффективная  скорость доступа к памяти.

Хотя  расслоение памяти может быть достаточно эффективным методом, оно всё  же приводит к некоторым потенциальным  трудностям. Во-первых, при простом  расслоении всякий раз, когда ЦП запрашивает  какой-то элемент, он получает не только этот элемент, но и окружающие его  копии слов памяти. Единственный эффективный  способ использования состоит в  том, что ЦП должен сохранять эти  дополнительные слова, и всякий раз, когда ему потребуется обратиться к памяти, проверять, не является ли какое-либо из них тем, что ему нужно. Вторая проблема возникает и при простой, и при сложной структуре расслоения, поскольку расслоение не убыстряет доступа к отдельному слову. Это означает, что механизм выборки команд в ЦП должен делать запросы задолго до того, как команда должна исполняться основной частью конвейера. В некоторых случаях, например, переходы, такое не всегда возможно.

Типичным  решением обеих проблем является введение между основной памятью  и конвейером ЦП быстродействующей  локальной памяти, которая в достаточной  степени отвечает требованиям обоих  устройств. Она называется кэш-памятью. При использовании этой концепции  общая скорость системы приближается к скорости самого быстрого ее уровня, а общей границы памяти – к  наиболее медленному т обычно наиболее дешевому уровню.

В любой момент времени кэш-память содержит копии слов памяти, включая  разряды и фрагменты программ и данных. Доступ к этим копиям осуществляется в 3-10 раз быстрее, чем для основной памяти. Когда ЦП нужно сделать  запрос к памяти, он генерирует адрес  желаемого слова и затем ищет в кэш-памяти желаемую величину. Если эта величина находится в ней, то это попадание и копия нужного объекта передается ЦП без выполнения запроса к ОП и за значительно меньшее время. Если же желаемый объект не находится в кэш-памяти, то это промах (отсутствие нужных данных в КЭШ). Тогда адрес должен быть передан ОП для организации доступа к ней. Кроме того в кэш-памяти должно быть найдено место для запоминания копии желаемого слова и копии любых дополнительных слов, которые выдаются в силу расслоенной структуры памяти. Когда эти данные поступают, их копии запоминаются в кэш-памяти, а желаемый объект передается ЦП.

Существует  набор формальных терминов для определения  вариантов структур кэш-памяти. Первым является определение термина строка как базовой единицы информации, которая перемещается между основной памятью и кэш-памятью. В расслоенных структурах памяти строкой часто является произведение числа слов, получаемых при одном запросе от одного модуля памяти, на кратность расслоения. Таким образом, память выглядит как состоящая из большого числа строк с последовательными адресами. Точно так же кэш-память содержит множество строк, но не обязательно в правильном порядке. В любой момент времени строки в кэш-памяти представляют собой копии строк из некоторого их набора в основной памяти. Когда ЦП хочет получить доступ к элементу данных, он обращается к кэш-памяти, чтобы посмотреть, нет ли в ней строки, содержащие эти данные. Этот поиск зачастую является по своей природе ассоциативным, каждая строка (или набор строк) в кэш-памяти имеет связанный с ней адресный тег, указывающий, какую строку в основной памяти данная строка представляет. Эти тэги обычно одновременно сравниваются с выработанными центральным процессором адресом строки. Совпадение указывает на попадание.

Если  же возникает промах, то в кэш-памяти нужно выбрать строку для приема новой строки из ОП. Обычно этот выбор осуществляется специальной аппаратурой, содержащей информацию о замене строк. Это может быть организовано в виде тегов состояния, связанных с каждой строкой, в виде очередей использования строк кэш-памяти или в виде счетчиков.

Важной  характеристикой такой кэш-памяти является отображение, связывающее  строки основной кэш-памяти. На протяжении определенного периода времени  каждая строка памяти может находиться в одной из нескольких различных строках кэш-памяти. Будем считать, что 2^N является числом строк основной памяти, а 2ⁿ – числом строк кэш-памяти.

Наиболее  общий, но и наиболее дорогой метод  отображения называется полностью ассоциативным. Любая строка памяти может находиться в любой строке кэш-памяти и входить при этом в любые комбинации. Каждая строка имеет свой компаратор. Если ЦП нужна строка, то он будет искать её среди 2ⁿ строк. Это может оказаться более дорогостоящим, если 2ⁿ имеет порядок сотен или тысяч. Далее, если имеется нехватка информации в кэш-памяти, то любая из её строк может быть загружена новой информацией.

Другой  крайний случай представляет структура  кэш-памяти с прямым отображением. Каждая строка кэш-памяти может содержать строку только из определенного подмножества строк ОП, а подмножества, соответствующие различным строкам кэш-памяти обычно не пересекаются. Поиск в этом случае состоит в определении, в какое из подмножеств попадает адрес строки, выработанный ЦП, затем в обращении к единственно существующей строке кэш-памяти и в единственном сравнении, устанавливающем, является ли эта строка желаемой. Поскольку реализация кэш-памяти является здесь простой, типичное прямое отображение использует разрядное отображение для выбора подмножеств памяти. Например, если в адресе строки памяти содержится N разрядов, то младшие n из них выбирают, в какую строку кэш-памяти она может копироваться. Таким образом, все строки памяти, имеющие одинаковые n разрядов в своей памяти копируются в одно и то же подмножество и могут появляться в одной строке кэш-памяти. Основным недостатком этого подхода является ограниченное число комбинаций строк, которые могут находиться в кэш-памяти.

Более общий метод, который включает в  себя как частные случаи, прямой и полностью ассоциативный методы, называется группо-ассоциативным. Здесь кэш-память делится на непересекающиеся подмножества строк. Каждая строка основной памяти может попадать в любую строку определенного подмножества строк кэш-памяти. Для поиска в кэш-памяти при прямом отображении используется адрес строки, выработанный центральным процессором для выбора подмножества строк кэш-памяти. Затем в результате полностью ассоциативного поиска внутри выбранного подмножества определяется, находится ли нужная строка в кэш-памяти. Как и раньше, прямое отображение реализуется обычно с помощью разрядного отображения. Если в кэш-памяти имеется 2ⁿ строк, разбитых на 2^s множеств, то  младшие s разрядов адреса строки, выработанного центральным процессором, показывают, в каком из подмножеств кэш-памяти должен вестись поиск. Старшие N-s разрядов этого адреса строки сравниваются затем с адресными тегами всех строк этого подмножества. На рисунке показан случай, когда s=1, т.е. когда в кэш-памяти имеются два подмножества.

Если  в кэш-памяти имеется только одно подмножество (s=0), этот метод в точности сводится к полностью ассоциативному. Если в каждом подмножестве имеется только строка (n=s), то он сводится в точности к методу прямого отображения. Для промежуточных значений s он представляет собой комбинацию обоих методов, давая разработчику возможность выбирать между малой сложностью прямого отображения и большим числом комбинаций (значит, потенциально более высокой долей попаданий) полностью ассоциативного. Здесь, по сравнению с другими подходами, каждое подмножество из 2^n-s строк может содержать любую комбинацию из 2^N-s строк основной памяти, которые могут находиться в этом подмножестве. В целом имеется:

2^N-s !/ (2^N-s -2^n-s )!

комбинаций на подмножество или приблизительно ^{комбинаций по всем} 2^s подмножествам^[2].

 

Рис. 10 Группо-ассоциативное отображение кэш-памяти при n=2 и N=4.

Признаковый обмен и сквозная запись

 

Рассмотрим  дисциплину признакового обмена. Для  блока, подлежащего вытеснению, проверяется  бит изменения. В том случае, если бит изменения равен 1, т.е. это  означает, что содержимое блока было изменено, блок переписывается в ОП, а бит изменения сбрасывается в 0.

После этого на место вытесняемого блока  из ОП записывается адресуемый блок, а  в адресную часть блока заносится  номер адресуемого сегмента. В  том случае, если для вытесняемого блока бит изменения был равен 0, то на место этого блока сразу  из ОП перезаписывается адресуемый блок, а в адресную часть заносится  номер адресуемого сегмента. Дальнейшая работа с буфером осуществляется по схеме, рассмотренной выше.

В группо-ассоциативном буфере, кроме признакового обмена, могут использоваться другие обменные дисциплины. При использовании сквозной записи данные в БП и ОП записываются параллельно. В связи с этим в группо-ассоциативном буфере не используются биты изменения. При сквозной записи в случае отсутствия адресуемого блока на место вытесняемого блока сразу же записывается адресуемый блок, а в адресную часть блока заносится номер адресуемого сегмента^[4].

Блоки GENERATE и TERMINATE

Блок GENERATE используется в программах в качестве источника транзактов, поступающих на вход следующего за ним блока. Операнды блока определяют режим работы генератора и атрибуты создаваемых транзактов. В полях А и В этого блока задается интервал системного времени между соседними моментами создания транзактов (интерпретация этих полей в блоках ADVANCE и GENERATE аналогична; к примеру, постоянный интервал времени между генерацией транзактов указывается в поле А, при этом поле В оставляется пустым), в поле С - момент выхода первого транзакта, и в поле D - число транзактов, которые должны быть созданы блоком. Если D - пусто, то блок генерирует транзакты до тех пор, пока не будет остановлено моделирование. Поля E, F, G служат для задания атрибутов генерируемых транзактов. Интерпретация полей указана в таблице 1.

 

Таблица 1. Интерпретация полей блока GENERATE

И Н Т Е Р П Р Е Т А Ц И Я
ПОЛЕ	ПОЛЕ   ЗАДАНО	ПОЛЕ   ОПУЩЕНО
Е	приоритет транзактов 0 - 127	0
F	число параметров (0 - 100)	12
G	Формат  параметров  F - слово,  Н – полуслово	Н

 

Пример:

                     A,B,C,   D,  E, F, G

      ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­

       GENERATE     10,,150,10000,64,25,H

     

Данный  блок генерирует транзакты каждые 10 единиц времени, начиная с момента 150.  Всего будет создано 10000 транзактов, каждый из которых имеет приоритет 64 и 25 параметров формата в полуслово.

Замечания:

      1. После  создания  транзакта   все параметры имеют нулевое  значение. Обозначение параметров P1, P2, Р3 и т.д.

      2. Каждый  транзакт  имеет стандартный числовой атрибут - "отметка времени",  в которой блок GENERATE заносит время входа транзакта в систему.

      3. Момент появления следующего  транзакта вычисляется после  выхода предыдущего из блока  GENERATE. Выходом транзакта считается  его вход в следующий блок.  Если он по какой-либо причине  невозможен,  то  транзакт не считается вышедшим из блока GENERATE, что может приводить к искажению временных характеристик потока транзактов.

      Для обеспечения выхода транзакта  из блока GENERATE за  ним помещают  блок ADVANCE 0 (пример 1). В этом случае  все транзакты при невозможности перемещаться далее по модели скапливаются в этом блоке. Кроме блока ADVANCE 0 возможно использование некоторых других блоков.

      Пример 1.

             . . .

            GENERATE  23,7

            ADVANCE   0

            SEIZE     WERK1

             . . .

 

Блок TERMINATE служит для удаления из модели попадающих на него транзактов. Если в поле А этого блока указано какое-либо число, то интерпретатор уменьшает на это число значение глобального "счетчика завершений", служащего для определения конца моделирования (пример 2). Моделирование прекращается, когда его значение станет равным 0. Начальное значение этого счетчика определяется операндом А блока START.

Пример 2.

. . .

GENERATE 4000

TERMINATE 1

START 1

 

Моделирование будет завершено по истечении 4000 тактов модельного времени. Блоком GENERATE в 4000-м такте сгенерируется транзакт, который далее поступит на блок TERMINATE с операндом А равным 1. В результате транзакт будет выведен из модели, а из счетчика завершений будет вычтена единица. Начальное значение счетчика завершений равно 1, т.к. операнд А блока START равен 1. После вычитания из него значения операнда А блока TERMINATE счетчик завершений примет нулевое значение и моделирование завершится.