Архитектура высокопроизводительных вычислительных систем

Требования, предъявляемые к используемым вычислительным системам , постоянно возрастают.

Поэтому повышение быстродействия ЭВМ всегда было и будет актуальнейшей задачей.
Использование конвейера и суперскалярной архитектуры позволило увеличить
производительность примерно в 10 раз. Традиционным способом увеличение быстродействия
является повышение рабочих частот центральных процессоров, но похоже сейчас гонка за
частотой подходит к своему завершению.
Выход - в разработке компьютеров параллельного действия . Параллелизм можно вводить на
разных уровнях. На уровне команд, например, можно использовать вычислительные системы с
процессором VLIW (EPIC, IA64). При другом подходе можно создать вычислительную систему
включающую, например, 1000 процессоров и теоретически обладающую в тысячу раз большим
быстродействием.
В любой системе параллельной обработки процессоры, выполняющие разные части одной
задачи, должны как-то взаимодействовать друг с другом , чтобы обмениваться информацией. Для
организации такого обмена были предложены и реализованы две разработки: мультипроцессоры
и мультикомпьютеры.
В первой разработке все процессоры разделяют общую физическую память. Такая система
называется мультипроцессором или системой с совместно используемой памятью.
Мультипроцессорная модель распространяется и на программное обеспечение. Все процессы ,
работающие вместе на мультипроцессоре, могут разделять одно виртуальное адресное
пространство, отображенное в общую память . Любой процесс может считывать слово из памяти
или записывать слово в память с помощью команд LOAD и STORE. Больше ничего не требуется .
Два процесса могут обмениваться информацией , если один из них будет просто записывать данные в
память, а другой будет считывать эти данные .
Благодаря такой возможности взаимодействия двух и более процессов мультипроцессоры весьма
популярны. Данная модель понятна программистам и приложима к широкому кругу задач.
Рассмотрим программу, которая изучает битовое отображение и составляет список всех его
объектов . Одна копия отображения хранится в памяти. Каждый из 9 процессоров запускает один
процесс, которому приписана для анализа одна из 9 секций. Если процесс обнаруживает , что один из
его объектов переходит через границу секции, этот процесс просто переходит вслед за объектом в
следующую секцию, считывая слова этой секции . В нашем примере некоторые объекты
обрабатываются несколькими процессами, поэтому в конце потребуется их координация,
В качестве примеров мультипроцессоров можно назвать Sun Enterprise 10000 и HP/Convex Exemplar.
 Во втором типе параллельной архитектуры каждый процессор имеет свою
собственную память, доступную только этому процессору. Такая разработка называется
мультикомпьютером или системой с распределенной памятью.

Мультикомпьютеры обычно ( хотя не всегда ) являются системами

со слабой связью . Ключевое отличие мультикомпьютера от
мультипроцессора состоит в том , что каждый процессор в
мультикомпьютере имеет свою собственную локальную память , к
которой этот процессор может обращаться , выполняя команды
LOAD и STORE, но никакой другой процессор не может
получить доступ к этой памяти с помощью тех же команд
LOAD и STORE. Таким образом, мультипроцессоры имеют одно
физическое адресное пространство, разделяемое всеми
процессорами, а мультикомпьютеры содержат отдельное
физическое адресное пространство для каждого центрального
процессора. Поскольку процессоры в мультикомпьютере не могут
взаимодействовать друг с другом просто путем чтения из
общей памяти и записи в общую память , здесь необходим
другой механизм взаимодействия. Они посылают друг другу
сообщения, используя сеть межсоединений. В качестве примеров
мультикомпьютеров можно назвать IBM SP/2, Intel/Sandia Option Red
и Wisconsin COW.
 При отсутствии памяти совместного использования в аппаратном обеспечении
предполагается определенная структура программного обеспечения . В мультикомпьютере
невозможно иметь одно виртуальное адресное пространство, из которого все процессы
могут считывать информацию и в которое все процессы могут записывать информацию
просто путем выполнения команд LOAD и STORE. Например , если процессор 0
обнаруживает, что часть его объекта попадает в другую секцию, относящуюся к процессору
1, он может продолжать считывать информацию из памяти, чтобы получить недостающую.
Однако если процессор 0 обнаруживает это, он не может просто считать информацию
из памяти процессора 1. Для получения необходимых данных ему нужно сделать что-то
другое. В частности, ему нужно как-то определить, какой процессор содержит
необходимые ему данные, и послать этому процессору сообщение с запросом копии
данных . Затем процессор 0 блокируется до получения ответа. Когда процессор 1 получает
сообщение, программное обеспечение должно проанализировать его и отправить назад
необходимые данные. Когда процессор 0 получает ответное сообщение, программное
обеспечение разблокируется и продолжает работу.
В мультикомпьютере для взаимодействия между процессорами часто используются
примитивы send и receive. Поэтому программное обеспечение мультикомпьютера имеет
более сложную структуру, чем программное обеспечение мультипроцессора. При этом
основной проблемой становится правильное разделение данных и разумное их
размещение. В мультипроцессоре размещение частей не влияет на правильность
выполнения задачи , хотя может повлиять на производительность. Таким образом,
мультикомпьютер программировать гораздо сложнее, чем мультипроцессор .
 Зачем вообще создавать мультикомпьютеры, если мультипроцессоры гораздо проще
программировать? Ответ прост: гораздо проще и дешевле построить большой
мультикомпьютер, чем мультипроцессор с таким же количеством процессоров. Реализация
общей памяти, разделяемой несколькими сотнями процессоров, — это весьма сложная
задача, а построить мультикомпьютер, содержащий 10 000 процессоров и более, гораздо проще.
Стали предприниматься попытки создания гибридных систем , которые относительно легко
конструировать и относительно легко программировать . Это привело к осознанию того , что
совместную память можно реализовывать по-разному, и в каждом случае будут какие-то
преимущества и недостатки . Практически все исследования в области архитектур с
параллельной обработкой направлены на создание гибридных форм, которые сочетают в
себе преимущества обеих архитектур . Здесь важно получить такую систему, которая
расширяема, то есть которая будет продолжать исправно работать при добавлении все
новых и новых процессоров.
Мультикомпьютеры и мультипроцессоры очень сходны, поскольку мультипроцессоры часто
содержат несколько модулей памяти, которые также должны быть связаны друг с другом и
с процессорами.
Основная причина сходства коммуникационных связей в мультипроцессоре и
мультикомпьютере заключается в том , что в обоих случаях применяется передача
сообщений . Даже в однопроцессорной машине, когда процессору нужно считать или
записать слово, он устанавливает определенные линии на шине и ждет ответа. Это
действие представляет собой то же самое, что и передача сообщений : инициатор посылает
запрос и ждет ответа .
 В больших мультипроцессорах взаимодействие между процессорами и удаленной памятью
почти всегда состоит в том , что процессор посылает в память сообщение, так называемый
пакет, который запрашивает определенные данные, а память посылает процессору ответный
пакет.
Сети межсоединений могут состоять максимум из пяти компонентов:
1. Центральные процессоры .
2. Модули памяти .
3. Интерфейсы.
4. Каналы связи.
5. Коммутаторы.
Интерфейсы — это устройства, которые вводят и выводят сообщения из центральных
процессоров и модулей памяти. Часто внутри интерфейса содержится программируемый
процессор со своими собственными ОЗУ и ПЗУ , которые принадлежит только этому
процессору . Обычно интерфейс способен считывать и записывать информацию в различные
модули памяти, что позволяет ему перемещать блоки данных.
Каналы связи — это каналы , по которым перемещаются биты. Каналы могут быть
электрическими или оптико -волоконными, последовательными или параллельными. Каждый канал
связи характеризуется максимальной пропускной способностью ( это максимальное число
битов, которое он способен передавать в секунду). Каналы могут быть симплексными
( передавать биты только в одном направлении), полудуплексными (передавать информацию в
обоих направлениях, но не одновременно ) и дуплексными ( передавать биты в обоих
направлениях одновременно ).
 Коммутаторы — это устройства с несколькими входными и несколькими выходными
портами. Когда на входной порт приходит пакет, некоторые биты в этом пакете
используются для выбора выходного порта, в который посылается пакет. Размер пакета
может составлять 2 или 4 байта, но может быть и значительно больше (например, 8 Кбайт).
При разработке и анализе сети межсоединений важно учитывать несколько ключевых
моментов . Во-первых, это топология (то есть способ расположения компонентов). Во-вторых,
это то , как работает система переключения и как осуществляется связь между ресурсами. В-
третьих, какой алгоритм выбора маршрута используется для доставки сообщений в пункт
назначения.
Топология сети межсоединений определяет, как расположены каналы связи и коммутаторы
( это, например, может быть кольцо или решетка). Топологии можно изображать в виде графов,
в которых дуги соответствуют каналам связи, а узлы — коммутаторам . С каждым узлом в сети
( или в соответствующем графе) связан определенный ряд каналов связи. Математики
называют число каналов степенью узла , инженеры — коэффициентом разветвления . Чем
больше степень, тем больше вариантов маршрута и тем выше отказоустойчивость.
Следующее свойство сети межсоединений — это ее диаметр. Если расстоянием между
двумя узлами будем считать число дуг, которые нужно пройти, чтобы попасть из одного узла
в другой, то диаметром графа будет расстояние между двумя узлами, которые расположены
дальше всех друг от друга. Диаметр сети определяет самую большую задержку при
передаче пакетов от одного процессора к другому или от процессора к памяти, поскольку
каждая пересылка через канал связи занимает определенное количество времени. Чем
меньше диаметр, тем выше производительность. Также имеет большое значение среднее
расстояние между двумя узлами , поскольку от него зависит среднее время передачи пакета.
Еще одно важное свойство сети межсоединений — это ее пропускная способность, то
есть количество данных, которое она способна передавать в секунду.
 Примерами топологий служат кольцо — это одномерная топология, поскольку
каждый отправленный пакет может пойти направо или налево . Решетка или сетка —
это двумерная топология. Она отличается регулярностью и применима к системам
большого размера, а её диаметр составляет квадратный корень от числа узлов (то есть при
расширении системы диаметр увеличивается незначительно). Двойной тор является
разновидностью решетки. Это решетка, у которой соединены края. Она характеризуется
большей отказоустойчивостью и меньшим диаметром, чем обычная решетка, поскольку
теперь между двумя противоположными узлами всего два транзитных участка.
Куб — это правильная трехмерная топология. В общем случае он может быть .
KxKxK. Ниже показан четырехмерный куб, полученный из двух трехмерных кубов, которые
связаны между собой.

Кольцо Решетка 4-х мерный куб

 Сеть межсоединений состоит из коммутаторов и линий связи, соединяющих их. Каждый
коммутатор имеет входные и выходных порты. Кроме того, каждый коммутатор содержит
несколько процессоров. Задача коммутатора — принимать пакеты , которые приходят на любой
входной порт, и отправлять пакеты из соответствующих выходных портов. Каждый выходной порт
связан с входным портом другого коммутатора через последовательный или параллельный .
Последовательные каналы передают один бит единовременно. Параллельные каналы могут
передавать несколько битов сразу. Существуют специальные сигналы для управления каналом.
Параллельные каналы характеризуются более высокой производительностью, чем
последовательные каналы с такой же тактовой частотой.
Классификация ЭВМ параллельного действия
Существует множество различных видов параллельных компьютеров, поэтому неоднократно
предпринимались попытки их классификации по тем или иным признакам. Чаще всего
используется классификация Флинна (Flynn), но даже она является достаточно грубым приближением.
В основе классификации лежат два понятия: потоки команд и потоки данных. Поток
команд соответствует счетчику команд. Система с n процессорами имеет n счетчиков команд и,
следовательно , n потоков команд . Потоки команд и данных в какой-то степени независимы , поэтому
существует 4 комбинации:
SISD (Single Instruction stream Single Data stream — один поток команд, один поток данных) — это
классический последовательный компьютер фон Неймана. Он содержит один поток команд и один
поток данных и может выполнять только одно действие в конкретный момент времени.
SIMD ( Single Instruction stream Multiple Data stream — один поток команд, несколько потоков
данных) содержат один блок управления, выдающий по одной команде, но при этом есть
несколько АЛУ, которые могут обрабатывать несколько наборов данных одновременно.
 SISD SIMD
К машинам типа SIMD часто относят векторные процессоры, хотя их
производительность зависит от другой формы параллелизма — конвейерной организации
машины. Многопроцессорные векторные системы состоят из нескольких векторных
процессоров и поэтому могут быть названы MSIMD (Multiple SIMD).
Машины типа SIMD состоят из большого числа идентичных процессорных элементов,
имеющих собственную память. Все процессорные элементы в такой машине выполняют
одну и ту же программу . Подобная машина, составленная из большого числа
процессоров, может обеспечить очень высокую производительность только на тех
задачах, при решении которых все процессоры могут делать одну и ту же работу.
Модель вычислений для машины SIMD очень похожа на модель вычислений для
векторного процессора : одиночная операция выполняется над большим блоком данных.
Такая архитектура с распределенной памятью часто упоминается как архитектура с
параллелизмом данных (data-parallel), так как параллельность достигается при наличии
одиночного потока команд, действующего одновременно на несколько частей данных.
 MISD ( Multiple Instruction stream Single Data stream — несколько потоков команд, один
поток данных) — несколько странная категория . Здесь несколько команд оперируют
одним набором данных . Вычислительных машин такого класса практически нет и трудно
привести пример их успешной реализации. Один из немногих — систолический массив
процессоров, в котором процессоры находятся в узлах регулярной решетки, роль ребер
которой играют межпроцессорные соединения. Все процессорные элементы управляются
общим тактовым генератором. В каждом цикле работы каждый процессорный элемент
получает данные от своих соседей, выполняет одну команду и передает результат
соседям.
 MIMD ( Multiple Instruction stream Multiple Data stream — несколько потоков команд , несколько
потоков данных). Эта категория архитектур вычислительных машин наиболее разнообразна,
если иметь в виду примеры ее успешных реализаций. В нее попадают симметричные
параллельные вычислительные системы, рабочие станции с несколькими процессорами,
кластеры рабочих станций . Уже довольно давно появились компьютеры с несколькими
независимыми процессорами, но вначале на таких компьютерах был реализован только
параллелизм заданий, то есть на разных процессорах одновременно выполнялись разные и
независимые программы .

MIMD компьютер имеет n процессоров, независимо исполняющих n потоков команд и n

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

Машины SIMD состоит из двух групп. В первую подгруппу попадают многочисленные

суперкомпьютеры и другие ЭВМ, оперирующие векторами, выполняя одну и ту же
операцию над каждым элементом вектора. Во вторую подгруппу попадают машины, в
которых главный блок управления посылает команды нескольким независимым АЛУ.
 Категория MIMD разделяются на мультипроцессоры (машины с памятью совместного
использования) и мультикомпьютеры (машины с передачей сообщений). Существует три
типа мультипроцессоров. Они отличаются друг от друга по способу реализации памяти
совместного использования . Их называют UMA (Uniform Memory Access — архитектура с
однородным доступом к памяти), NUMA (NonUniform Memory Access — архитектура с
неоднородным доступом к памяти) и СОМА (Cache Only Memory Access — архитектура с
доступом только к кэш -памяти).
В машинах UMA каждый процессор имеет одно и то же время доступа к любому
модулю памяти, то есть все слова памяти считываются с одинаковой скоростью. Если
это технически невозможно, самые быстрые обращения замедляются, чтобы
соответствовать самым медленным, поэтому программисты не увидят никакой разницы.
Это и значит « однородный». Такая однородность делает производительность
предсказуемой, а этот фактор очень важен для написания эффективной программы.
Мультипроцессор NUMA, напротив , не обладает этим свойством. Обычно есть такой
модуль памяти, который расположен близко к каждому процессору , и доступ к этому
модулю памяти происходит гораздо быстрее, чем к другим. С точки зрения
производительности очень важно , куда помещаются программа и данные. Машины СОМА
тоже являются ЭВМ с неоднородным доступом, но по другой причине.
Во вторую группу машин MIMD попадают мультикомпьютеры, которые в отличие от
мультипроцессоров не имеют памяти совместного использования на архитектурном
уровне, то есть операционная система в процессоре мультикомпьютера не может прямо
получить доступ к памяти, относящейся к другому процессору. Ему приходится
отправлять сообщение и ждать ответа .
 Тем не менее, даже в мультикомпьютере пользовательские программы могут обращаться
к другим модулям памяти с помощью команд LOAD и STORE, что достигается средствами
операционной системы. Разница незначительна, но очень важна. Так как мультикомпьютеры
не имеют прямого доступа к отдаленным модулям памяти, они иногда называются машинами
NORMA (NO Remote Memory Access — без доступа к отдаленным модулям памяти).
Мультикомпьютеры можно разделить на две группы. Первая группа содержит
процессоры МРР (Massively Parallel Processors — процессоры с массовым параллелизмом ) —
дорогостоящие суперкомпьютеры, которые состоят из большого количества процессоров,
связанных высокоскоростной коммуникационной сетью. Вторая группа мультикомпьютеров
включает рабочие станции, которые связываются с помощью уже имеющейся технологии
соединения. Эти ЭВМ называются NOW (Network of Workstations — сеть рабочих станций) или
COW (Cluster of Workstattions — кластер рабочих станций).
Компьютеры SIMD
Компьютеры SIMD используются для решения задач с векторами и массивами. Такая машина
содержит один блок управления , который выполняет команды по одной, но каждая
команда оперирует несколькими элементами данных. Два основных типа компьютеров SIMD —
это массивно - параллельные (матричные) процессоры (array processors) и векторные
процессоры (vector processors).
В массивно-параллельном процессоре содержится один блок управления , который
передает сигналы, чтобы запустить несколько обрабатывающих элементов. Каждый
обрабатывающий элемент состоит из процессора или усовершенствованного АЛУ и, как правило,
локальной памяти .
 Хотя все массивно -параллельные процессоры соответствуют этой общей модели , они могут
отличаться друг от друга в некоторых моментах . Первый вопрос — это структура
обрабатывающего элемента . Она может быть различной — от чрезвычайно простой до
чрезвычайно сложной. Самые простые обрабатывающие элементы — 1- битные АЛУ. В такой
машине каждый АЛУ получает два 1-битных операнда из своей локальной памяти плюс бит из
слова состояния программы (например , бит переноса ). Результат операции — 1 бит данных и
несколько флаговых битов. Чтобы совершить сложение двух целых 32- битных чисел, блоку
управления нужно транслировать команду 1-битного сложения 32 раза . Если на одну команду
затрачивается 300 нс , то для сложения целых чисел потребуется 9.6 мкс,. Но при наличии 65
536 обрабатывающих элементов можно получить более трех миллиардов сложений в секунду при
времени сложения 300 пикосекунд. Обрабатывающим элементом может быть 8, 32, 64 битное АЛУ,
или более мощное устройство , способное выполнять операции с плавающей точкой . В какой-то
степени выбор типа обрабатывающего элемента зависит от типа целей машины.
 Второй вопрос — как связываются обрабатывающие элементы друг с другом . Здесь
применимы практически все топологии, рассмотренные выше. Чаще всего используются
прямоугольные решетки, поскольку они подходят для задач с матрицами и отображениями и
хорошо применимы к большим размерам, так как с добавлением новых процессоров
автоматически увеличивается пропускная способность .
Третий вопрос — какую локальную автономию имеют обрабатывающие элементы. Блок
управления сообщает, какую команду нужно выполнить, но во многих массивно -
параллельных процессорах каждый обрабатывающий элемент может выбирать на основе
некоторых локальных данных ( например , на основе битов кода условия), выполнять ему
эту команду или нет. Эта особенность придает процессору значительную гибкость.

Второй тип машины SIMD — векторный процессор.

Обычно подобная ЭВМ на входе получает два n - элементных вектора и обрабатывает
соответствующие элементы параллельно, используя векторное АЛУ, которое может
оперировать элементами одновременно. В результате получается вектор . Входные и
выходные векторы могут сохраняться в памяти или в специальных векторных регистрах.
Суперкомпьютеры обычно содержат несколько АЛУ, каждое из которых предназначено для
выполнения определенной операции, и все они могут работать параллельно.
В качестве примера рассмотрим суперкомпьютер Cray-l. Он больше не используется, но
зато имеет простую архитектуру типа RISC, и к тому же его архитектуру можно
встретить во многих современных векторных суперкомпьютерах
 Машина Сгау -1 регистровая (как RISC), большинство команд 16-битные, состоят из 7-
битного кода операции и трех 3-битных номеров регистров для трех операндов. Имеется
пять типов регистров. Восемь 24- битных регистров А используются для обращения к памяти.
64 24- битных регистра В используются для хранения регистров А, когда они не нужны,
чтобы не записывать их обратно в память . Восемь 64- битных регистров S
предназначены для хранения скалярных величин ( целых чисел и чисел с плавающей
точкой). Значения этих регистров можно использовать в качестве операндов как для
операций с целыми числами, так и для операций над числами с плавающей точкой . 64
64- битных регистра Т — это регистры для хранения регистров S, опять-таки для сокращения
количество операций LOAD и STORE.
Самый интересный набор регистров — это группа из восьми векторных регистров.
Каждый такой регистр может содержать 64- элементный вектор с плавающей точкой . В
одной 16-битной команде можно сложить, вычесть или умножить два вектора. Операция
деления невозможна, но можно вычислить обратную величину. Векторные регистры могут
загружаться из памяти, сохраняться в память, но такие перемещения выполнять очень
невыгодно, поэтому их следует свести к минимуму. Во всех векторных операциях
используются регистровые операнды.
Не всегда в суперкомпьютерах операнды должны находиться в регистрах. Например,
машина CDC Cyber 205 выполняла операции над векторами в памяти. Такой подход
позволял работать с векторами произвольной длины , но это сильно снижало скорость
работы машины.
 Сгау-1 содержит 12 различных функциональных блоков . Два из них предназначены для
арифметических действий с 24-битными адресами. Четыре нужны для операций с 64- битными
целыми числами. Cray-1 не имеет блока для целочисленного умножения ( хотя есть блок для
перемножения чисел с плавающей точкой). Оставшиеся шесть блоков работают над векторами.
Все они конвейеризированы . Блоки сложения, умножения и вычисления обратной величины
работают как над скалярными числами с плавающей точкой, так и над векторами.
 Как и многие другие векторные компьютеры, Сгау -1 допускает операции сцепления.
Например, чтобы вычислить выражение R1= R1 x R2 + R3, где R1, R2, R3 — векторные
регистры, машина выполнит векторное умножение элемент за элементом, сохранит
результат где-нибудь , а затем выполнит векторное сложение. При сцеплении, как только
первые элементы перемножены, произведение сразу направляется в сумматор вместе с
первым элементом регистра R3. Сохранения промежуточного результата не требуется .
Такая технология значительно улучшает производительность.
Компьютеры MIMD
Cистемы MIMD можно разделить на мультипроцессоры и мультикомпьютеры.
Мультипроцессор — это компьютерная система, которая содержит несколько процессоров и
одно адресное пространство, видимое для всех процессоров. Он запускает одну копию
операционной системы с одним набором таблиц, в том числе таблицами, которые следят,
какие страницы памяти заняты, а какие свободны . Когда процесс блокируется, его процессор
сохраняет свое состояние в таблицах операционной системы, а затем просматривает
эти таблицы для нахождения другого процесса , который нужно запустить . Именно
наличие одного отображения и отличает мультипроцессор от мультикомпьютера.
Если все процессоры имеют равный доступ ко всем модулям памяти и всем
устройствам ввода-вывода и каждый процессор взаимозаменим с другими процессорами, то
такая система называется SMP (Symmetric Multiprocessor — симметричный мультипроцессор).
 Несмотря на то, что во всех мультипроцессорах процессорам предоставляется
отображение общего разделенного адресного пространства, часто наряду с этим имеется
множество модулей памяти, каждый из которых содержит какую - либо часть физической
памяти. Процессоры и модули памяти соединяются сложной коммуникационной сетью.
Несколько процессоров могут пытаться считать слово из памяти, а в это же время несколько
других процессоров пытаются записать то же самое слово, и некоторые сообщения могут
быть доставлены не в том порядке, в каком они были отправлены . Добавим к этой
проблеме существование многочисленных копий некоторых блоков памяти (например, в кэш -
памяти), и в результате мы придем к хаосу, если не принять определенные меры. Если
программное обеспечение соглашается следовать определенным правилам, то память
соглашается выдавать определенные результаты. Основная проблема здесь — каковы должны
быть правила. Эти правила называются моделями согласованности. Было предложено и
разработано множество таких правил.
Предположим, что процессор 0 записывает значение 1 в какое-то слово памяти , а немного
позже процессор 1 записывает значение 2 в то же самое слово. Процессор 2 считывает это
слово и получает значение 1. Это зависит от того, что обещано в соглашении .
Самая простая модель — строгая согласованность . В такой модели при любом
считывании из адреса х всегда возвращается значение самой последней записи в х.
Программистам очень нравится эта модель, но ее можно реализовать на практике только
следующим образом: должен быть один модуль памяти , который просто обслуживает все
запросы по мере поступления ( первым поступил — первым обработан), без кэш-памяти и
без дублирования данных. К несчастью, это очень сильно замедляет работу памяти .
 Следующая модель называется согласованностью по последовательности. Здесь при
наличии нескольких запросов на чтение и запись аппаратное обеспечение определяет порядок
всех запросов, но все процессоры наблюдают одну и ту же последовательность запросов.
Процессорная согласованность — более проигрышная модель, но зато ее легче реализовать на
больших мультипроцессорах . Она имеет два свойства :
1. Все процессоры воспринимают записи любого процессора в том порядке, в котором они начинаются .
2. Все процессоры видят записи в любое слово памяти в том же порядке, в котором они происходят.

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

Еще одна возможность — каждый процессор имеет не только кэш -память , но и свою
локальную память. Чтобы оптимально использовать такую конфигурацию, компилятор
должен поместить в локальные модули памяти программу, константы, другие данные ,
предназначенные только для чтения, стеки и локальные переменные. Общая разделенная
память используется только для общих переменных.
 Предположим , что память согласована по последовательности. Что произойдет , если
процессор 1 содержит в своей кэш-памяти строку, а процессор 2 пытается считать слово из
той же строки кэш -памяти ?
При отсутствии специальных правил процессор 2 получит копию этой строки в свою кэш
-память . В принципе помещение одной и той же строки в кэш-память дважды вполне
приемлемо. А теперь предположим , что процессор 1 изменяет строку, и сразу после этого
процессор 2 считывает копию этой строки из своей кэш-памяти. Он получит устаревшие
данные, нарушая контракт между программным обеспечением и памятью. Ни к чему хорошему
это не приведет.
Эта проблема, которую называют непротиворечивостью кэш , очень важна. Если ее не
разрешить, нельзя будет использовать кэш-память, и число мультипроцессоров,
подсоединенных к одной шине, придется сократить до двух - трех. Было предложено
множество различных решений, но все эти алгоритмы, называемые протоколами когерентности
кэширования, различаются в некоторых деталях, и не допускают одновременного появления
разных вариантов одной и той же строки в разных блоках кэш-памяти.
Во всех решениях контроллер кэш -памяти разрабатывается так, чтобы кэш -память
могла перехватывать запросы на шине, контролируя все запросы шины от других
процессоров и других блоков кэш -памяти и предпринимая те или иные действия в
определенных случаях. Эти устройства называются кэш-памятью с отслеживанием (snooping
caches или snoopy caches). Набор правил, которые выполняются кэ -памятью, процессорами и
основной памятью, чтобы предотвратить появление различных вариантов данных в
нескольких блоках кэш-памяти, формируют протокол когерентности кэширования. Единица
передачи и хранения кэш-памяти называется строкой кэш -памяти .
 Самый простой протокол когерентности кэширования называется сквозным
кэшированием. Рассмотрим 4 случая, приведенные в таблице. Если процессор пытается
считать слово, которого нет в кэш-памяти , контроллер кэш -памяти загружает в кэш -
память строку , содержащую это слово. Строку предоставляет основная память, которая
в этом протоколе всегда обновлена. В дальнейшем информация может считываться из
кэш-памяти.
Действие Локальный запрос Удаленный запрос
Промах при чтении Вызов данных из памяти
Попадание при чтении Использование данных из
локальной кэш -памяти
Промах при записи Обновление данных в
памяти
Попадание при записи Обновление основной и Объявление элемента кэш -
кэш -памяти памяти недействительным

В случае промаха кэш -памяти при записи слово, которое было изменено, записывается в
основную память. Строка, содержащая нужное слово, не загружается в кэш -память . В
случае результативного обращения к кэш -памяти при записи кэш обновляется, а слово
плюс ко всему записывается в основную память . Суть протокола состоит в том, что в
результате всех операций записи записываемое слово обязательно проходит через
основную память, чтобы информация в основной памяти всегда обновлялась.
 Рассмотрим все эти действия снова, но теперь с точки зрения кэш -памяти с
отслеживанием. Назовем кэш -память, которая выполняет действия, кэш-1, а кэш с отслеживанием
— кэш -2. Если при считывании произошел промах кэша-1, он запрашивает шину, чтобы
получить нужную строку из основной памяти. Кэш-2 видит это, но ничего не делает. Если
нужная строка уже содержится в кэш -1, запроса шины не происходит , поэтому кэш -2 не знает о
результативных считываниях из кэша-1.
Процесс записи более интересен. Если процессор 1 записывает слово, кэш-1 запрашивает
шину как в случае промаха кэш, так и в случае попадания. Всегда при записи кэш-2 проверяет
наличие у себя записываемого слова. Если данное слово отсутствует, кэш -2 рассматривает это
как промах отдаленной памяти и ничего не делает.
А теперь предположим, что кэш-1 записывает слово, которое присутствует в кэш-2. Если
кэш-2 не произведет никаких действий, он будет содержать устаревшие данные, поэтому элемент
кэш-памяти, содержащий измененное слово, помечается как недействительный. Соответствующая
единица просто удаляется из кэш -памяти. Все кэш отслеживают все запросы шины, и всякий раз,
когда записывается слово, нужно обновить его в кэш-памяти инициатора запроса, обновить его
в основной памяти и удалять его из всех других кэш. Таким образом, неправильные варианты
слова исключаются.
Процессор кэш-памяти-2 вправе прочитать то же самое слово на следующем цикле. В этом
случае кэш-2 считает слово из основной памяти, которая уже обновилась. В этот момент
кэш-1, кэш-2 и основная память содержат идентичные копии этого слова. Если какой-нибудь
процессор произведет запись, то другие кэш будут очищены , а основная память опять обновится.
 Возможны различные вариации этого основного протокола. Например, при успешной записи
отслеживающий кэш обычно объявляет недействительным элемент, содержащий данное слово. С
другой стороны, вместо того чтобы объявлять слово недействительным, можно принять новое
значение и обновить кэш-память . По существу , обновить кэш-память — это то же самое, что
признать слово недействительным, а затем считать нужное слово из основной памяти.
Во всех кэш-протоколах нужно сделать выбор между стратегией обновления и стратегией
с признанием данных недействительными. Эти протоколы работают по разному. Сообщения об
обновлении несут полезную нагрузку, и следовательно, они больше по размеру, чем сообщения
о недействительности, но зато они могут предотвратить дальнейшие промахи кэш-памяти.
Другой вариант — загрузка отслеживающей кэш -памяти при промахах. Такая загрузка никак
не влияет на правильность выполнения алгоритма. Она влияет только на производительность.
Возникает вопрос : какова вероятность, что только что записанное слово вскоре будет записано
снова? Если вероятность высока, то можно говорить в пользу загрузки кэш-памяти при
промахах записи (политика заполнения по записи). Если вероятность мала, лучше не
обновлять кэш-память в случае промаха при записи . Если данное слово скоро будет
считываться, оно все равно будет загружено после промаха при считывании, и нет смысла
загружать его в случае промаха при записи.
Это решение не очень эффективно. Каждая операция записи должна передаваться в
основную память по шине, а при большом количестве процессоров это затруднительно.
Поэтому были разработаны другие протоколы. Все они характеризуются одним общим свойством: не
все записи проходят непосредственно через основную память. Вместо этого при изменении
строки кэш-памяти внутри кэш -памяти устанавливается бит, который указывает, что строка в
кэш -памяти правильная, а в основной памяти — нет. В конечном итоге эту строку нужно будет
записать в основную память , но перед этим в память можно произвести много записей. Такой
тип протокола называется протоколом с обратной записью.
 Один из популярных протоколов с обратной записью называется MESI. В его основе
лежит протокол однократной записи. Протокол MESI используется в Pentium II и других
процессорах для отслеживания шины. Каждый элемент кэш-памяти может находиться в одном
из следующих четырех состояний:
1. Invalid — элемент кэш -памяти содержит недействительные данные .
2. Shared — несколько кэш могут содержать данную строку; основная память обновлена.
3. Exclusive — никакой другой кэш не содержит эту строку; основная память обновлена.
4. Modified — элемент действителен; основная память недействительна; копий элемента
не существует.
При загрузке процессора все элементы кэш -памяти помечаются как недействительные.
При первом считывании из основной памяти нужная строка вызывается в кэш -память
данного процессора и помечается как Е (Exclusive), поскольку это единственная копия в кэш -
памяти
 При последующих считываниях процессор использует эту строку и не использует
шину. Другой процессор может вызвать ту же строку и поместить ее в кэш-память, но
при отслеживании исходный держатель строки (процессор 1) узнает, что он уже не
единственный, и объявляет, что у него есть копия. Обе копии помечаются состоянием S
(Shared). При последующих чтениях кэшированных строк в состоянии S процессор не
использует шину и не меняет состояние элемента.

Посмотрим, что произойдет, если процессор 2 произведет запись в строку кэш -

памяти, находящуюся в состоянии S. Тогда процессор помещает сигнал о
недействительности на шину, который сообщает всем другим процессорам, что нужно
отбросить свои копии. Соответствующая строка переходит в состояние М (Modified) Эта
строка не записывается в основную память. Отметим, что если записываемая строка
находится в состоянии Е, никакого сигнала о недействительности на шину передавать не
следует, поскольку известно, что других копий нет.
 А теперь рассмотрим, что будет, если процессор 3 считывает эту строку . Процессор 2,
который в данный момент содержит строку, знает, что копия в основной памяти
недействительна, поэтому он передает на шину сигнал, чтобы процессор 3 подождал, пока он
запишет строку обратно в память. Как только строка записана в основную память, процессор
3 вызывает из памяти копию этой строки, и в обоих кэш строка помечается как S. Затем
процессор 2 записывает эту строку снова, что делает недействительной копию в кэш-памяти
процессора 3.

Затем процессор 2 записывает эту строку снова, что делает недействительной копию в
кэш-памяти процессора 3 .
 Наконец, процессор 1 производит запись в слово в этой строке. Процессор 2 видит
это и передает на шину сигнал, который сообщает процессору 1, что нужно подождать, пока
строка не будет записана в основную память. Когда это действие закончится, процессор
помечает собственную копию строки как недействительную, поскольку он знает, что
другой процессор собирается изменить ее. Появляется ситуация, в которой процессор
записывает что-либо в некэшированную строку. Если применяется политика write-allocate,
строка будет загружаться в кэш-память и помечаться как М. Если политика write-allocate
не применяется, запись будет производиться непосредственно в основную память, а строка
в кэш-памяти сохранена не будет.

Даже при всех возможных оптимизациях использование только одной шины

ограничивает размер мультипроцессора UMA до 16 или 32 процессоров. Чтобы получить
больший размер, требуется другой тип коммуникационной сети . Самая простая схема
соединения п процессоров с к блоками памяти — координатный коммутатор. Координатные
коммутаторы используются для соединения группы входящих линий с рядом выходящих
линий произвольным образом
В каждом пересечении горизонтальной ( входящей) и вертикальной ( исходящей ) линии
находится соединение (crosspoint), которое можно открыть или закрыть в зависимости от
того, нужно соединять горизонтальную и вертикальную линии или нет. На рисунке мы видим ,
что три узла закрыты, благодаря чему устанавливается связь между парами ( процессор,
память ) (001, 000), (101, 101) и (110, 010) одновременно.
Координатный коммутатор представляет собой неблокируемую сеть . Это значит , что
процессор всегда будет связан с нужным блоком памяти, даже если какая-то линия или
узел уже заняты. Более того, никакого предварительного планирования не требуется .
Даже если уже установлено семь произвольных связей, всегда можно связать оставшийся
процессор с оставшимся блоком памяти.
Примером мультипроцессора UMA, основанного на координатном коммутаторе, является
система Sun Enterprise 10000. Эта система состоит из одного корпуса с 64 процессорами .
Координатный коммутатор представляет собой плату, содержащую 8 гнезд на каждой
стороне. Каждое гнездо вмещает плату процессора , содержащую 4 процессора UltraSPARC
и ОЗУ.
 Недостатком координатного коммутатора является то, что число узлов растет как n2 .
В основе другого подхода лежит небольшой коммутатор 2x2. Этот коммутатор содержит два
входа и два выхода. Сообщения, приходящие на любую из входных линий, могут переключаться
на любую выходную линию. В нашем примере сообщения будут содержать до четырех частей .
Поле Модуль сообщает, какую память использовать. Поле Адрес определяет адрес в этом модуле
памяти . В поле Код операции содержится операция, например READ или WRITE. Наконец,
дополнительное поле Значение может содержать операнд, например 32- битное слово, которое
нужно записать при выполнении операции WRITE. Коммутатор исследует поле Модуль и
использует его для определения , через какую выходную линию нужно отправить сообщение: через
X или через У. Наши коммутаторы 2x2 можно компоновать различными способами и получать
многоступенчатые сети.

Размер мультипроцессоров UMA с одной шиной обычно ограничивается до нескольких десятков

процессоров, а для координатных мультипроцессоров или мультипроцессоров с коммутаторами
требуется дорогое аппаратное обеспечение. Чтобы получить более 100 процессоров, нужно что-то
предпринять. Отметим, что все модули памяти имеют одинаковое время доступа. Это наблюдение
приводит к разработке мультипроцессоров NUMA (NonUniform Memory Access — с неоднородным
доступом к памяти).
Как и мультипроцессоры UMА, они обеспечивают единое адресное пространство для всех
процессоров, но, в отличие от машин UMA, доступ к локальным модулям памяти происходит
быстрее, чем к удаленным. Следовательно, все программы UMA будут работать без изменений на
машинах NUMA, но производительность будет хуже, чем на машине UMA с той же тактовой частотой.
 Машины NUMA имеют три ключевые характеристики, которыми все они обладают и которые в
совокупности отличают их от других мультипроцессоров :
1. Существует одно адресное пространство, видимое для всех процессоров.
2. Доступ к удаленной памяти производится с использованием команд LOAD и STORE.
3. Доступ к удаленной памяти происходит медленнее, чем доступ к локальной памяти .
Если время доступа к удаленной памяти не скрыто (поскольку кэш -память отсутствует), то такая
система называется NC-NUMA (No Caching NUMA — NUMA без кэширования). Если присутствуют
согласованные кэши, то система называется CC-NUMA (Coherent Cache NUMA — NUMA с согласованной кэш
-памятью ).

Когда запрос памяти приходит в блок управления памятью, производится проверка и определяется,
находится ли нужное слово в локальной памяти. Если да, то запрос отправляется по локальной шине.
Если нет, то запрос направляется по системной шине к системе, которая содержит данное слово.
Вторая операция занимает гораздо больше времени, чем первая. Выполнение программы из
удаленной памяти занимает гораздо больше времени, чем выполнение той же программы из локальной
памяти.
 Согласованность памяти гарантирована в машине NC-NUMA, поскольку там
отсутствует кэш -память. Каждое слово памяти находится только в одном месте, поэтому
нет никакой опасности появления копии с устаревшими данными : здесь вообще нет копий.
Имеет большое значение, в какой именно памяти находится та или иная страница, поскольку
от этого зависит производительность. Машины NC-NUMA используют сложное программное
обеспечение для перемещения страниц, чтобы максимально увеличить производительность.
Обычно существует «сторожевой » процесс (демон), так называемый страничный
сканер, который запускается каждые несколько секунд. Он должен следить за статистикой
использования страниц и перемещать их таким образом, чтобы улучшить
производительность. Если страница окажется в неправильном месте, страничный сканер
преобразует ее таким образом, чтобы следующее обращение к ней вызвало ошибку из -
за отсутствия страницы .
Когда происходит такая ошибка, принимается решение о том, куда поместить эту
страницу, возможно, в другую память, из которой она была взята раньше. Для
предотвращения пробуксовки существует следующее правило - если страница была
помещена в то или иное место, она должна оставаться в этом месте на время некоторое
время.
Каждый раз переходить к удаленной памяти, чтобы получить доступ к слову,
которого нет в локальной памяти , очень невыгодно: это сильно снижает
производительность. Однако с добавлением кэш -памяти нужно будет добавить и способ
совместимости кэшей. Для создания мультипроцессоров действительно большого размера
нужен совершенно другой подход .
 Самый популярный подход для построения больших мультипроцессоров CC-NUMA
(Cache Coherent NUMA — NUMA с согласованной кэш -памятью) — мультипроцессор на
основе каталога.
Основная идея состоит в сохранении базы данных, которая сообщает, где именно
находится каждая строка кэш -памяти и каково ее состояние. При обращении к строке
кэш -памяти из базы данных выявляется информация о том, где находится эта строка и
изменялась она или нет. Поскольку обращение к базе данных происходит на каждой
команде, которая обращается к памяти, база данных должна находиться в высокоскоростном
специализированном аппаратном обеспечении, которое способно выдавать ответ на
запрос за долю цикла шины.
Рассмотрим в качестве примера систему из 256 узлов, в которой каждый узел состоит
из одного процессора и 16 Мбайт ОЗУ, связанного с процессором через локальную
шину. Общий объем памяти составляет 232 байтов. Она разделена на 226 строк кэш -памяти
по 64 байта каждая . Память статически распределена по узлам: 0-16 М в узле 0, 16 М-32
М — в узле 1 и т. д. Узлы связаны через сеть ). Сеть может быть в виде решетки,
гиперкуба или другой топологии. Каждый узел содержит элементы каталога для 2 18 64-
байтных строк кэш -памяти , составляя свою 224-байтную память. На данный момент мы
предполагаем, что строка может содержаться максимум в одной кэш -памяти.
 Чтобы понять, как работает каталог, проследим путь команды LOAD из процессора 20,
который обращается к кэшированной строке. Сначала процессор, выдавший команду, передает
ее в блок управления памятью, который переводит ее в физический адрес, например
0x24000108. Блок управления памятью разделяет этот адрес на три части,. В десятичной
системе счисления эти три части — узел 36, строка 4 и смещение 8. Блок управления
памятью видит, то слово памяти, к которому производится обращение, находится в узле 36,
а не узле 20, поэтому он посылает запрос через сеть в узел 36, где находится нужная
строка, и узнает, есть ли строка 4 в кэш -памяти, и если да, то где именно.

36 4
Когда запрос прибывает в узел 36, он направляется в аппаратное обеспечение каталога. Оно
индексирует таблицу их 218 элементов ( один элемент на каждую строку кэш -памяти ) и извлекает
элемент 4.
Видно, что эта строка отсутствует в кэш -памяти , поэтому аппаратное
обеспечение вызывает строку 4 из локального ОЗУ, отправляет ее в узел 20
и обновляет элемент каталога 4, чтобы показать, что эта строка находится в кэш -памяти
в узле 20.
 А теперь рассмотрим второй запрос , на этот раз о строке 2 из узла 36. Видно,
что эта строка находится в кэш -памяти в узле 82. В этот момент аппаратное
обеспечение может обновить элемент каталога 2, чтобы сообщить , что строка находится
теперь в узле 20, а затем может послать сообщение в узел 82, чтобы строка из него была
передана в узел 20, и объявить недействительной его кэш -память.
Очевидным недостатком этой разработки является то, что строка может быть
кэширована только в одном узле. Чтобы строки можно было кэшировать в нескольких
узлах, потребуется какой-то способ их нахождения (например, чтобы объявлять
недействительными или обновлять их при записи ).
Возможны различные варианты. Одна из возможностей — предоставить каждому
элементу каталога к полей для определения других узлов, что позволит сохранять
каждую строку в нескольких блоках кэш -памяти ( допустимо до k различных узлов).
Вторая возможность — заменить номер узла битовым отображением, один бит на
узел. Здесь нет ограничений на количество копий, но существенно растут
непроизводительные затраты. Каталог, содержащий 256 битов для каждой 64- байтной (512-
битной) строки кэш -памяти , подразумевает непроизводительные затраты выше 50%.
Третья возможность — хранить в каждом элементе каталога 8-битное поле и использовать это
поле как заголовок связанного списка, который связывает все копии строки кэш -памяти
вместе. На практике используются все три стратегии.
 Машины NUMA и CC-NUMA имеют один большой недостаток: обращения к удаленной
памяти происходят гораздо медленнее, чем обращения к локальной памяти . В машине
CC-NUMA эта разница в производительности в какой-то степени нейтрализуется благодаря
использованию кэш -памяти. Однако если количество требуемых удаленных данных сильно
превышает вместимость кэш -памяти , промахи будут происходить постоянно и
производительность станет очень низкой.
Существует архитектура в какой то мере свободная от недостатков UMA и NUMA. Она
называется СОМА (Cache Only Memory Access). В ней страницы памяти не имеют
собственных фиксированных машин, как в системах NUMA и CC-NUMA. Вместо этого
физическое адресное пространство делится на строки, которые перемещаются по
системе в случае необходимости.
Блоки памяти не имеют собственных машин. Память , которая привлекает строки по
мере необходимости, называется attraction memory. Использование основной памяти в
качестве большой кэш -памяти увеличивает частоту успешных обращений в кэш -память ,
а следовательно , и производительность.
Однако в системе СОМА появляется две новых проблемы:
1. Как размещаются строки кэш -памяти ?
2. Если строка удаляется из памяти , что произойдет, если это последняя копия?
 Первая проблема связана со следующим фактом. Если блок управления памятью
транслировал виртуальный адрес в физический и если строки нет в аппаратной кэш -
памяти, то очень трудно определить, есть ли вообще эта строка в основной памяти.
Аппаратное обеспечение здесь не поможет, поскольку каждая страница состоит из
большого количества отдельных строк кэш -памяти, которые перемещаются в системе
независимо друг от друга. Даже если известно, что строка отсутствует в основной
памяти , как определить, где она находится? В данном случае нельзя спросить об этом
собственную машину, поскольку таковой машины в системе нет.
Было предложено несколько решений этой проблемы. Можно ввести новое
аппаратное обеспечение, которое будет следить за тегом каждой строки кэш -памяти .
Тогда блок управления памятью может сравнивать тег нужной строки с тегами всех строк
кэш -памяти, пока не обнаружит совпадение.
Другое решение — отображать страницы полностью, но при этом не требовать
присутствия всех строк кэш -памяти. В этом случае аппаратному обеспечению понадобится
битовое отображение для каждой страницы, где один бит для каждой строки указывает на
присутствие или отсутствие этой строки. Если строка присутствует, она должна
находиться в правильной позиции на этой странице . Если она отсутствует, то любая
попытка использовать ее вызовет прерывание, что позволит программному обеспечению найти
нужную строку и ввести ее.
Таким образом, система будет искать только те строки, которые действительно
находятся в удаленной памяти.
 Мультикомпьютеры
Это параллельные компьютеры, в которых каждый процессор имеет свою собственную память,
к которой другие процессоры не могут получить прямой доступ. Программы на разных
процессорах в мультикомпьютере взаимодействуют друг с другом с помощью примитивов
send и receive, которые используются для передачи сообщений ( поскольку они не могут
получить доступ к памяти других процессоров с помощью команд LOAD и STORE). Это
различие полностью меняет модель программирования.
Каждый узел в мультикомпьютере состоит из одного или нескольких процессоров, ОЗУ
( общее для процессоров только данного узла ), диска и(или) других устройств ввода-вывода, а
также процессора передачи данных. Процессоры передачи данных связаны между собой по
высокоскоростной коммуникационной сети. Используется множество различных топологий, схем
коммутации и алгоритмов выбора маршрута. Все мультикомпьютеры сходны в одном: когда
программа выполняет примитив send, процессор передачи данных получает уведомление и
передает блок данных в целевую машину (возможно, после предварительного запроса и получения
разрешения).
 Мультикомпьютеры бывают разных типов и размеров , поэтому очень трудно привести
хорошую классификацию. Тем не менее можно назвать два общих типа : МРР и COW.
МРР — процессоры с массовым параллелизмом.
СгауТЗЕ - использует процессоры DEC Alpha 21164. Это суперскалярный процессор RISC,
способный выдавать 4 команды за цикл. Alpha — это 64- битная машина с 64- битными
регистрами. Размер виртуальных адресов ограничен до 43 битов, а физических — до 40
битов. Таким образом, возможен доступ к 1 Тбайт физической памяти.
Каждый процессор Alpha имеет двухуровневую кэш-память, встроенную в микросхему
процессора. Кэш-память первого уровня содержит 8 Кбайт для команд и 8 Кбайт для
данных. Кэш -память второго уровня — это смежная трех входовая ассоциативная кэш-
память на 96 Кбайт, содержащая и команды и данные вместе . Кэш -память обоих уровней
содержит команды и данные только из локального ОЗУ, а это может быть до 2 Гбайт
на процессор. Поскольку максимальное число процессоров равно 2048, общий объем
памяти может составлять 4 Тбайт.
Каждый процессор Alpha заключен в особую схему, которая называется оболочкой
(shell). Оболочка содержит память, процессор передачи данных и 512 специальных регистров
(так называемых Е-регистров). Эти регистры могут загружаться адресами удаленной памяти
с целью чтения или записи слов из удаленной памяти (или блоков из 8 слов ). Это значит,
что в машине ТЗЕ есть доступ к удаленной памяти , но осуществляется он не с
помощью обычных команд LOAD и STORE. Эта машина представляет собой гибрид
между NC-NUMA и МРР, но все-таки больше похожа на МРР. Непротиворечивость памяти
гарантируется, поскольку слова, считываемые из удаленной памяти , не попадают в кэш -
память .
Узлы в машине ТЗЕ связаны двумя разными способами. Основная топология — дуплексный 3-
мерный тор. Например , система, содержащая 512 узлов, может быть реализована в виде куба
8x8x8. Каждый узел в 3-мерном торе имеет 6 каналов связи с соседними узлами ( по направлению
вперед, назад, вправо, влево, вверх и вниз). Скорость передачи данных в этих каналах связи равна
480 Мбайт/с в любом направлении.
 Узлы также связаны одним или несколькими GigaRings — подсистемами ввода-вывода
с коммутацией пакетов, обладающими высокой пропускной способностью. Узлы используют
эту подсистему для взаимодействия друг с другом, а также с сетями, дисками и другими
периферическими устройствами. Они по ней посылают пакеты . Каждый GigaRing состоит
из пары колец шириной в 32 бита, которые соединяют узлы процессоров со
специальными узлами ввода-вывода. Узлы ввода-вывода содержат гнезда для сетевых
карт, дисков и других устройств.
В системе ТЗЕ может быть до 2048 узлов, поэтому неисправности будут
происходить регулярно. По этой причине в системе на каждые 128 пользовательских узлов
содержится один запасной узел. Испорченные узлы могут быть замещены запасными во
время работы системы без перезагрузки. Кроме пользовательских и запасных узлов есть
узлы, которые предназначены для запуска серверов операционной системы, поскольку
пользовательские узлы запускают не всю систему, а только ядро . В данном случае
используется операционная система UNIX.
Intel/Sandia Option Red
Option Red состоит из 4608 узлов, которые организованы в трехмерную сетку.
Процессоры установлены на платах двух разных типов. Платы kestrel используются в
качестве вычислительных узлов, а платы eagle используются для сервисных , дисковых,
сетевых узлов и узлов загрузки . Машина содержит 4536 вычислительных узлов, 32
сервисных узла , 32 дисковых узла, 6 сетевых узлов и 2 узла загрузки .
 Плата kestrel содержит 2 логических узла , каждый из которых включает 2 процессора
и разделенное ОЗУ на 64 Мбайт. Каждый узел kestrel содержит собственную 64- битную
локальную шину и сетевой адаптер. Платы eagle также содержат процессоры Pentium Pro,
но всего два на каждую плату. Кроме того, они отличаются высокой производительностью
процесса ввода-вывода.

Платы связаны в виде решетки 32x38x2 в виде двух взаимосвязанных плоскостей 32x38
В каждом узле находится маршрутизатор с шестью каналами связи: вперед , назад,
вправо , влево, с другой плоскостью и с платой kerstel или eagle. Каждый канал связи
может передавать информацию одновременно в обоих направлениях.
Применяется пространственная маршрутизация, когда пакеты сначала потенциально
перемещаются в другую плоскость, затем вправо-влево, затем вперед-назад и, наконец, в
нужную плоскость, если они еще не оказались в нужной плоскости.
Два перемещения между плоскостями нужны для повышения отказоустойчивости.
Предположим, что пакет нужно переместить в соседний узел, находящийся впереди
исходного, но канал связи между ними поврежден. Тогда сообщение можно отправить в другую
плоскость, затем на один узел вперед, а затем обратно в первую плоскость, минуя таким
образом поврежденный канал связи.
Систему можно логически разделить на 4 части: сервис, вычисление, ввод -вывод и
система. Сервисные узлы — это машины UNIX общего назначения с разделением времени,
которые позволяют программистам писать и отлаживать свои программы .
Вычислительные узлы запускают большие приложения. Они запускают не всю систему
UNIX, а только микроядро. Узлы ввода-вывода управляют 640 дисками.
Есть два независимых набора узлов ввода-вывода. Узлы первого типа предназначены
для секретной работы, а узлы второго типа — для несекретной работы . Эти два набора
вводятся и удаляются из системы вручную, поэтому в каждый момент времени
подсоединен только один набор узлов, чтобы предотвратить утечку информации с
секретных дисков на несекретные диски. Наконец, системные узлы используются для
загрузки системы.
COW — Clusters of Workstations (кластеры рабочих станций )
Второй тип мультикомпьютеров — это системы COW или NOW (Network of Workstations —
сеть рабочих станций ). Обычно он состоит из нескольких сотен персональных
компьютеров или рабочих станций, соединенных посредством сетевых плат. Различие
между МРР и COW аналогично разнице между большой вычислительной машиной и
персональным компьютером. У обоих есть процессор, ОЗУ, диски, операционная система и т.
д. Но в большой вычислительной машине все это работает гораздо быстрее ( за
исключением, может быть, операционной системы). Однако они применяются и управляются
по-разному.
Исторически система МРР отличалась высокоскоростной сетью. Но с появлением
коммерческих высокоскоростных сетей это отличие начало сглаживаться . Преимущество
системы COW над МРР в том, что COW полностью состоит из доступных компонентов,
которые можно купить. Эти части выпускаются большими партиями. Эти части, кроме того ,
существуют на рынке с жесткой конкуренцией, из -за которой производительность растет , а
цены падают. Вероятно, системы COW постепенно вытеснят ММР, подобно тому, как
персональные компьютеры вытеснили большие вычислительные машины, которые
применяются теперь только в специализированных областях.
Существует множество различных видов COW, но доминируют два из них:
централизованные и децентрализованные. Централизованные системы COW представляют
собой кластер рабочих станций или персональных компьютеров, смонтированных в большой
блок в одной комнате. Иногда они компонуются более компактно, чем обычно, чтобы
сократить физические размеры и длину кабеля. Как правило, эти машины гомогенны и не
имеют никаких периферических устройств, кроме сетевых карт и, возможно, дисков.
 Децентрализованная система COW состоит из рабочих станций или персональных
компьютеров, которые раскиданы по зданию или по территории учреждения. Большинство
из них простаивают много часов в день, особенно ночью . Обычно они связаны через
локальную сеть. Они гетерогенны и имеют полный набор периферийных устройств. Самое
важное, что многие компьютеры имеют своих владельцев.