2. HPF и его предшественники

В конце 1980-х и начале 1990-х гг. Fortran все еще оставался доминирующим языком в области технических расчетов, которая, в свою очередь, обеспечивала крупнейший рынок масштабируемых машин. Поэтому было естественно предполагать, что версия языка Fortran с распараллеливанием по данным будет хорошо принята сообществом пользователей, поскольку она могла бы способствовать эффективному использованию огромного количества программ, написанных на этом языке. К числу наиболее важных языков с распараллеливанием по данным, основанных на Fortran и оказавших глубокое воздействие на разработку HPF, относятся два исследовательских языка Fortran D и Vienna Fortran, а также один коммерческий продукт CM Fortran.

В этом разделе рассматриваются основные характеристики каждого из этих языков. Раздел завершается описанием работ, приведших к возникновению процесса стандартизации HPF, и обзором самого этого процесса.

Fortran D. В 1987 г. исследовательская группа в университете Rice, руководимая Кеном Кеннеди, начала сотрудничать с Джеффри Фоксом (Geoffrey Fox) в области поддержки средств высокоуровневого программирования для компьютеров с распределенной памятью. Фокс обратил внимание на то, что основной проблемой при написании приложения для системы с распределенной памятью являлся выбор правильного распределения данных, поскольку после совершения этого выбора реальный параллелизм определялся потребностью минимизации коммуникаций. Таким образом, можно было выполнять вычисления в параллель на процессорах, владеющих данными, которые участвовали в вычислениях. Это привело к той идее, что программы, написанные на некотором языке с моделью совместно используемой памяти и единственного потока управления, можно компилировать в эффективный код для системы с распределенной памятью, если программисты обеспечат информацию о том, как следует распределить данные между процессорами. Фокс и группа университета Rice создали спецификацию нового языка, названного ими Fortran D, в котором поддерживалось средство двухуровневого определения распределения данных, похожее на то, которое позже было включено в HPF. Основная идея состояла в том, что группы массивов выравнивались в соответствии с некоторым абстрактным объектом, называемом шаблоном (template). Затем все эти массивы отображались на процессоры с помощью одного оператора распределения данных, который отображал шаблон на эти процессоры.

В Fortran D поддерживались блочное, циклическое и блочное циклическое (иногда называемое cyclic(k)) распределения шаблонов на процессоры в нескольких измерениях. Для каждого отдельного распределения требовалось определять свой шаблон. Однако этот механизм можно было использовать для гарантированного обеспечения того, чтобы массивы разных размеров, такие как разные сетки в многосеточных вычислениях, отображались на правильные процессоры.

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

Fortran D был ориентирован на использование коммуникационных библиотек, поддерживающих двухсторонние протоколы: чтобы передать данные из одного процессора в другой, процессор, владеющий данными, должен был послать их, а процессор, нуждающийся в данных, – принять данные. Это затрудняло генерацию коммуникационного кода, поскольку компилятор должен был определить, в каких точках программы нужно было выполнить примитивы send и receive на каждом процессоре.

Для решения проблемы разделения вычислений в проекте университета Rice была выработана стратегия «считает владелец» («owner-computes»), в соответствии с которой вычисления распределялись по процессорам поблизости от данных, которые надлежало обрабатывать. В частности, в первом прототипе компилятора Rice использовалась стратегия «считает левосторонний владелец» («left-hand-side owner-computes»), согласно которой каждый оператор компилировался таким образом, чтобы все вычисления выполнялись на процессорах, владеющих результатами предыдущих вычислений. (Строго говоря, компиляторы Fortran D, как большинство других реализаций языков с распараллеливанием по данным, являлись трансляторами исходного текста в исходный текст, генерирующими SPMD-реализацию, такую как Fortran плюс вызовы примитивов передачи сообщений, как «объектного кода». На самом деле, одной из движущих сил (не основной) начала процесса стандартизации MPI являлось стремление обеспечить машинно-независимую цель для компиляторов языков с распараллеливанием по данным.)

Первая статья, описывающая стратегию компиляции Rice, была написана Каллаханом и Кеннеди, представлена в 1988 г. на конференции LCPC (International Workshop on Languages and Compilers for Parallel Computing) в Корнеле и включена в подборку материалов этой конференции, напечатанную в Journal of Supercomputing [18]. (Ранее в том же году Зима (Hans P. Zima), Баст (Heinz-J. Bast) и Гендт (Michael Gerndt) опубликовали статью про средство параллелизации SUPERB [100], в котором также использовался подход распределения данных и вычислений.) Хотя Каллахан и Кеннеди описывали стратегию «считает владелец» в ее начальной форме, оптимизации коммуникаций и вычислений выполнялись локально с использованием преобразований, заимствованных из традиционных методов оптимизации кода. Когда этот подход оказался неэффективным, группа университета Rice переключилась на использование стратегии компиляции целых вложенных циклов, каждого по отдельности. Эта работа описывалась в серии статей, в которых также обсуждалась реализация прототипа, основанного на этом новом подходе [54, 53, 94]. Хотя представленные результаты были получены для довольно небольших программ, эти статьи демонстрировали значительное улучшение производительности, подтверждающее жизнеспособность компиляции на основе распределения данных и вычислений. В центре процесса компиляции находится преобразование из глобального пространства индексов массивов, поддерживаемого в Fortran D, в локальное индексное пространство каждого процессора. Для выполнения этого преобразования компилятору нужно для каждого цикла выявить, для каких итераций не требуются коммуникации, для каких итераций требуется послать данные в другой процессор, и для каких итераций требуется получить данные до выполнения каких-либо вычислений. Краткое изложение этого подхода можно найти в главе 14 книги Алена (Randy Allen) и Кеннеди [4].

Для генерации правильного кода всей программы на языке Fortran D требовалось решить одну важную проблему: как в каждой точке программы определить, какое распределение было ассоциировано с каждым массивом данных? Поскольку распределения сами не являлись объектами данных, их было невозможно явно передавать в подпрограммы; вместо этого они неявно ассоциировались с массивами данных, передаваемыми в качестве параметров. Для генерации кода подпрограммы компилятор должен был следовать одному из трех подходов: (1) на уровне всей программы выполнять некоторый анализ развития распределений, (2) полагаться на описания, обеспечиваемые программистами в интерфейсе каждой процедуры или (3) динамически определять распределения во время выполнения программы на основе дескриптора каждого распределенного массива. Группа Fortran D решила, что динамическое определение распределений слишком замедляло бы работу программы, а рассчитывать на подсказки программистов было бы непрактично, особенно в тех ситуациях, когда библиотеки могли бы создаваться при отсутствии вызывающей программы. В результате в компиляторе Fortran D производился межпроцедурный анализ распространения распределений данных, в результате чего он становился компилятором программы целиком. Это упрощало проблемы межпроцедурных границ, но усложняло структуру компилятора. Позже этот подход был признан неприемлемым группой по стандартизации HPF.

Vienna Fortran. В 1985 г. в германском университете города Бонн группа под руководством Ганса Зимы начала разработку новой системы компиляции SUPERB для языка с распараллеливанием по данным в контексте германского суперкомпьютерного проекта Suprenum [41]. В качестве исходных данных система SUPERB [100] принимала текст программы на языке Fortran 77 и спецификацию обобщенного блочного распределения данных, производя в результате параллельную программу с явной передачей сообщений для архитектуры с распределенной памятью Suprenum с использованием стратегии «считает владелец». Этот подход, который сначала понимался как выполнение вычислений на процессоре, владеющем левой частью оператора присваивания (или, в более общем смысле, целью вычислений), позже был обобщен до стратегии выбора любого процессора с максимизацией локальности вычислений. Позже эта идея стала одной из наиболее важных идей HPF. Диссертация на соискание ученой степени PhD Микаела Герндта [40], завершенная в 1989 г., является первой работой, в которой полностью описаны преобразования программ, требуемые для такой трансляции. Обзор этой технологии компиляции представлен Зимой и Чэпмен (Barbara Chapman) в [101].

Проект SUPERB не был направлен на разработку языка. Он посвящался преобразованиям программ в компиляторах, и для спецификации распределений данных использовалась специально подобранная нотация. Однако после того, как группа Зимы перебралась в Венский университет, они начали в сотрудничестве с Пийушем Меротрой (Piyush Mehrotra) из института ICASE (Institute for Computer Application in Science and Engineering) при NASA работу над полной спецификацией высокоуровневого языка с параллелизмом по данным в контексте Fortran.

Этот новый язык, получивший название Vienna Fortran, обеспечивал программистам возможность определения массивов виртуальных процессоров, а распределения рассматривались как отображения из пространств индексов многомерных массивов в (под)множества пространств процессоров. Особый акцент делался на поддержке нерегулярных и адаптивных программ: в дополнение к регулярным блочным и циклическим блочным классам распределений в языке поддерживались обобщенное блочное и косвенное распределения. При использовании обобщенного блочного распределения, унаследованного от проекта SUPERB, измерение массива разделялось на непрерывные части произвольной длины, которую можно было вычислять во время выполнения программы. Такие распределения, если их использовать совместно с переупорядочиванием, позволяют эффективно представлять нерегулярные сетки. Косвенные распределения представляют собой другой механизм, предназначенный для решения проблем нерегулярности. В этом случае допускается спецификация произвольных отображений между множествами индексов массивов и процессорами. И обобщенное блочное, и косвенное распределения позже были включены в спецификацию HPF 2.0, описываемую в разд. 5. Реализация обоих этих распределений затруднительна, поскольку реальные отображения остаются неизвестными до времени выполнения. Поэтому компилятор должен генерировать код для шага предварительной обработки, иногда называемого инспектором [26, 96], который во время выполнения определяет расписание коммуникаций и балансирует нагрузку между различными процессорами.

Ключевым компонентом спецификации языка Vienna Fortran являлись определяемые пользователями распределения и выравнивания. Хотя эта возможность была реализована только частично, она мотивировала исследования в области распределенных представлений разреженных матриц [96] и обеспечила важные идеи для недавней реализации подобных методов в высокоэффективном языке Chapel [17]. В системе Vienna Fortran Compilation System расширялись функциональные возможности компилятора Vienna Fortran Compilation System, поддерживалась большая часть конструкций языка, хотя основной акцент делался на оптимизации нерегулярных алгоритмов. Обзор технологии компиляции, использовавшейся в этой системе, приведен в статье Бенкнера (Siegfried Benkner) и Зимы [12].

CM Fortran. CM Fortran был первой коммерческой реализацией языка с распараллеливанием по данным. Этот язык разрабатывался группой компании Thinking Machines Corporation (производителя серии Connection Machines) под руководством Гая Стила (Guy Steele) и группой программистов из небольшой софтверной компании COMPASS, Inc. под руководством Дэвида Лавмена (David Loveman) и Роберта Моргана (Robert Morgan). Целью проекта CM Fortran являлась поддержка разработки технических приложений для машины CM-2 с архитектурой SIMD, выпущенной в 1987 г. Исходная модель программирования для машины CM-2 и ее предшественников основывалась на языке *Lisp, поскольку компания изначально ориентировалась на приложения искусственного интеллекта. Однако в 1991 г. с целью привлечения пользователей из областей науки и техники был выпущен компилятор с языка Fortran [91].

В CM Fortran были включены операторы присваивания массивов и арифметические операции над массивами, вошедшие в спецификацию Fortran 90, а также средство, которое в последний момент было удалено из этого стандарта: оператор FORALL, обеспечивающий очень простой способ спецификации присваивания массива в стиле задания цикла. Массивы, используемые в этих операторах, классифицировались как CM-массивы и отображались на множества виртуальных процессоров (virtual processor, VP), по одному элементу массива на каждый процессор. В свою очередь, VP регулярным образом отображались на реальные процессоры CM-2. Это отображение можно было изменить с использованием опциональных директив ALIGN и LAYOUT. В отличие от Fortran D, в CM Fortran для спецификации схемы размещения данных для массивов данных в SIMD-массиве процессоров CM-2 использовались директивы компилятору, вводимые пользователями как комментарии. Каждое присваивание массива компилировалось в последовательность SIMD-инструкций, вычисляющих маски исполнения, перемещающих данные и вызывающих реальные вычисления. Эта простая и эффективная стратегия была дополнена в компиляторе Thinking Machines стратегией секционирования (“slicewise”), позволяющей сократить избыточные пересылки данных и маскирование.

Возможности программирования в среде CM Fortran были развиты благодаря наличию библиотеки общих вычислительных и коммуникационных примитивов CMSSL, разработанной под руководством Леннарта Джонссона (Lennart Johnsson). Кроме мощных вычислительных примитивов, библиотека включала ряд глобальных операций, таких как sum reduction и scatter/gather, которые используются для преобразования данных с нерегулярной структурой в компактные массивы и наоборот. Многие из этих подпрограмм были позднее включены в спецификацию библиотеки HPF.

Когда компания Thinking Machines выпустила в 1993 г. машину CM-5 с архитектурой MIMD, она сохранила для новой архитектуры язык CM Fortran, что показывает популярность и переносимость этой модели.

Процесс стандартизации HPF. В ноябре 1991 г. на конференции Supercomputing ’91 в Альбукерке (Нью-Мехико) к Кеннеди и Фоксу обратились с запросом о возможности стандартизации синтаксиса распараллеливаемых по данным версий языка Fortran. Движущими силами этого процесса являлись коммерческие поставщики, в частности, компания Thinking Machines, производившая масштабируемые параллельные машины с распределенной памятью. В создании кросс-платформы для языка Fortran была также заинтересована компания Digital Equipment Corporation (DEC), которая стремилась включить в нее многие специальные средства, входящие в DEC Fortran.

После начальных обсуждений этой идеи Кеннеди и Фокс организовали встречу с представителями академических и промышленных кругов на сессии birds-of-a-feather. Участники пришли к согласию применить более формальный процесс стандартизации на основе группы, которую стали называть High Performance Fortran Forum (HPFF). Кеннеди согласился возглавить HPFF, а роль исполнительного директора взялся исполнять Чарльз Коулбел (Charles Koelbel). При поддержке Исследовательского центра параллельных вычислений (Center for Parallel Computation Research, CRPC) университета Rice была срочно организована встреча, которая состоялась в январе 1992 г. в г. Хьюстон, Техас. Интерес к процессу стандартизации проявился и в большом числе участников встречи (около 100 человек), и в активных обсуждениях в течение презентаций. В заключение встречи была проведена бизнес-сессия, на которой более 20 компаний взяли на себя обязательства поддерживать процесс подготовки нового стандарта.

По причине высокого уровня интереса и наличия реальной потребности в новом стандарте участники договорились постараться получить результат в течение примерно одного года. Хотя полностью выполнять работу за это время не удалось, это «управленческое» соглашение повлияло на характеристики языка. Наличие жесткого временного графика вынудило участников процесса следовать неформальному правилу, в соответствии с которым в HPF включались только те средства, полезность которых уже была продемонстрирована не менее чем в одном языке и компиляторе (включая компиляторы, созданные в рамках исследовательских проектов). Конечно, этот подход ограничивал набор обсуждаемых средств, в особенности, в области развитых методов распределения данных. Однако следует заметить, что правило «поддержки рассматриваемого средства не менее чем в одном компиляторе» часто нарушалось. В частности, комитет выяснил, что отсутствует какой-либо полностью удовлетворительный механизм описания интерфейсов подпрограмм, продемонстрированный в каком-либо языке, и поэтому был использован ряд дополнительных средств.

Активные участники HPFF (30-40 человек) проводили двухдневные совещания через каждые шесть недель, и эти совещания чаще всего проходили в одном из отелей Далласа, Техас, выбранного по причине удобного воздушного сообщения. (Отчасти умышленно в том же отеле позже организовывались совещания участников Message Passing Interface Forum (MPIF). Один из участников обоих комитетов в шутку говорил, что это единственный в мире отель, в котором он может сказать бармену: «как обычно» и получить правильную выпивку.) Среди постоянных участников совещаний встречалось немало талантливых людей. Кроме Кеннеди и Коулбела, в число редакторов документа стандарта входили Марина Чен (Marina Chen), Боб Найтен (Bob Knighten), Дэвид Лавмен, Роб Шрайбер (Rob Schreiber), Марк Снир (Marc Snir), Гай Стил, Джоэл Вильямсон (Joel Williamson) и Мэри Зоусел (Mary Zosel). В таб. 1 приведен более полный список участников HPFF, упорядоченный по названиям компаний, которые они представляли. Названия компаний включены в список на основании двух соображений: во-первых, у каждой организации (представители которой участвовали не менее чем в двух из последних трех встреч) имелся один голос; во-вторых, перечень организаций иллюстрирует широту кругозора группы. Имелись представители компаний, производящих аппаратуру и программное обеспечение, университетские исследователи, пользователи правительственных и производственных приложений. HPFF не являлся проектом одной организации, это был процесс, в котором формировалось согласованное общее мнение разных сторон.

Таблица 1. Участники (и организации) процесса HPFF, 1992-1993 гг.

David Reese (Alliant)	Jerrold Wagener (Amoco)
Rex Page (Amoco)	John Levesque (APR)
Rony Sawdayi (APR)	Gene Wagenbreth (APR)
Jean-Laurent Philippe (Archipel)	Joel Williamson (Convex Computer)
David Presberg (Cornell Theory Center)	Tom MacDonald (Cray Research)
Andy Meltzer (Cray Research)	David Loveman (Digital)
Siamak Hassanzadeh (Fujitsu America)	Ken Muira (Fujitsu America)
Hidetoshi Iwashita (Fujitsu Laboratories)	Clemens-August Thole (GMD)
Maureen Hoffert (Hewlett Packard)	Tin-Fook Ngai (Hewlett Packard)
Richard Schooler (Hewlett Packard)	Alan Adamson (IBM)
Randy Scarborough (IBM)	Marc Snir (IBM)
Kate Stewart (IBM)	Piyush Mehrotra (ICASE)
Bob Knighten (Intel)	Lev Dyadkin (Lahey Computer)
Richard Fuhler (Lahey Computer)	Thomas Lahey (Lahey Computer)
Matt Snyder (Lahey Computer)	Mary Zosel (Lawrence Livermore)
Ralph Brickner (Los Alamos)	Margaret Simmons (Los Alamos)
J. Ramanujam (Louisiana State)	Richard Swift (MasPar Computer)
James Cownie (Meiko)	Barry Keane (nCUBE)
Venkata Konda (nCUBE)	P. Sadayappan (Ohio State)
Robert Babb II (OGI)	Vince Schuster (Portland Group)
Robert Schreiber (RIACS)	Ken Kennedy (Rice)
Charles Koelbel (Rice)	Peter Highnam (Schlumberger)
Don Heller (Shell)	Min-You Wu (SUNY Buffalo)
Prakash Narayan (Sun)	Douglas Walls (Sun)
Alok Choudhary (Syracuse)	Tom Haupt (Syracuse)
Edwin Paalvast (TNO-TU Delft)	Henk Sips (TNO-TU Delft)
Jim Bailey (Thinking Machines)	Richard Shapiro (Thinking Machines)
Guy Steele (Thinking Machines)	Richard Shapiro (United Technologies)
Uwe Geuder (Stuttgart)	Bernhard Woerner (Stuttgart)
Roland Zink (Stuttgart)	John Merlin (Southampton)
Barbara Chapman (Vienna)	Hans Zima (Vienna)
Marina Chen (Yale)	Aloke Majumdar (Yale)

Эта группа сталкивалась с многочисленными техническими и политическими проблемами. Многие из них возникали из-за противоречий в потребности языковых возможностей высокого уровня и желании добиться простой реализации. С самого начала было понятно, что HPF должен быть достаточно гибким и мощным, чтобы на его основе можно было реализовать широкий набор приложений, демонстрирующих хорошую производительность. Однако у реальных приложений существенно различаются структуры данных и способы их обработки, поэтому для поддержки этих приложений требовались разные методы распределения данных. Для реализации каждого метода распределения данных, встраиваемого в язык, требовалась масса усилий со стороны разработчиков компиляторов. Какого количества методов разделения данных было бы достаточно? Например, рассмотрим циклическое блочное распределение, в котором группы из k строк или столбцов массива назначаются циклическим образом процессорам из массива процессоров. Опыт разработки исследовательских компиляторов показывал, что при реализации этого метода распределения возникали бесспорные сложности. Некоторые члены HPFF выступали против включения соответствующих возможностей в HPF. Однако, в конце концов, они были включены в язык, поскольку такое распределение требовалось для балансировки вычислительной нагрузки между процессорами при выполнении треугольных вычислений типа тех, которые производятся в плотной линейной алгебре (например, LU-разложение квадратной матрицы). Вообще говоря, именно потребность в балансировке нагрузки с целью достижения максимального увеличения быстродействия путем назначения каждому процессору одного и того же объема вычислений мотивирует потребность в развитом наборе методов распределения данных.

Проблемы противоречий между мощностью языка и сложностью реализации усложнялись отсутствием большого опыта разработки компиляторов языков с распараллеливанием по данным. Исследовательские компиляторы, большей частью, являлись академическими прототипами, применявшимися лишь к немногим приложениям обычно небольшого размера. С другой стороны, CM Fortran был относительно новым языком с не такими развитыми возможностями, как у Fortran D и Vienna Fortran. Поэтому многие решения принимались без наличия полного понимания их влияния на сложность компиляторов.

Еще одним сложным решением был выбор между Fortran 77 и Fortran 90 в качестве основы нового языка. В начале процесса стандартизации HPF Fortran 90 являлся новым стандартом. Проблема состояла в том, что у большинства компаний, производивших параллельные машины, имелись компиляторы, которые воспринимали только Fortran 77. Эти компании неохотно брали на себя обязательства реализовать полный стандарт Fortran 90 в качестве первого шага по направлению к HPF. С другой стороны, компании, которые уже ориентировали свои компиляторы на Fortran 90, такие как Thinking Machines, хотели иметь возможность пользоваться преимуществами более развитого языка. В конце концов, пользователи, участвовавшие в процессе стандартизации, склонили общее мнение в пользу Fortran 90. Для этого имелось много оснований. Одним из основных из них было то, что в состав Fortran 90 входили средства, обеспечивающие большую понятность определению языка HPF, в частности средства спецификации интерфейсов подпрограмм. Кроме того, спецификация Fortran 90 включала синтаксис операций над массивами, который согласовывался с понятием глобальных массивов. Такие операции помогали распознавать глобальные операции, которые можно было бы выполнять в параллель. Оглядываясь в прошлое, авторы считают это решение ошибочным, поскольку реализация Fortran 90 усложнила задачу создания компилятора в разумное время. Как отмечается в разд. 4, это привело к замедлению разработки компиляторов HPF и, тем самым, ограничило признание языка.

Еще одна крупная техническая проблема состояла в потребности выработки способа работы с информацией о распределениях в подпрограммах. Разработчики технических приложений на языке Fortran полагались на возможность построения библиотек подпрограмм, широко распространяемых в академических институтах и продаваемых коммерческими компаниями, такими как IMSL и NAG. Для достижения успешности HPF требовалось обеспечить возможность разрабатывать библиотеки, которые работали бы корректно с параметрами-массивами с разными распределениями. Таким образом, требовалось наличие возможности определения внутри подпрограммы, какие распределения данных ассоциированы с массивами, передаваемыми этой подпрограмме.

В проекте Fortran D решение этой проблемы было возложено на межпроцедурный компилятор. Понятно, что поставщики, участвующие в HPFF, не хотели следовать этому подходу, потому что в большинстве коммерческих компиляторов отсутствовали какие-либо возможности межпроцедурного анализа (даже если не затрагивать вопрос о том, пожелали ли бы поставщики библиотек предоставлять свои исходные тексты). Таким образом, при разработке языка требовалось определить способ объявления распределений параметров, чтобы библиотеки подпрограмм HPF можно было использовать с разными распределениями без нанесения серьезного вреда производительности. Основная проблема здесь состояла в том, стоит ли перераспределять массив в пределах подпрограммы, или же следует каким-то образом «унаследовать» распределение от вызывающей программы. Перераспределение данных приводит к расходам на перемещение данных при входе в подпрограмму и выходе из нее, но позволяет подпрограмме использовать то распределение, которое является оптимальным для заложенного в нее алгоритма. Наследование распределения вызывающей программы позволяет избежать расходов на перераспределение, но может повредить производительности из-за того, что полученное распределение не соответствует алгоритму, или из-за расходов на динамическую интерпретацию полученного распределения. Эти проблемы были наиболее сложными в техническом отношении во всем процессе стандартизации, и связанные с ними части стандарта являются наименее понятными.

Этот пример иллюстрирует одну из проблем, с которой сталкивались участники процесса стандартизации HPF, и плотность графика, на котором основывался этот процесс. Хотя с самого начала участники согласились включать в стандарт только те средства, которые были опробованы в некотором исследовательском прототипе или коммерческой реализации, группа временами игнорировала этот принцип и подменяла опыт интуицией.

Результатом этой работы явился новый язык, который был завершен в начале 1993 г. [50, 49] и представлен на Supercomputing Conference осенью того же года. Особенности языка обсуждаются в следующем разделе.

В 1994 г. была проведена дополнительная серия совещаний участников HPFF с целями (1) внести исправления, пояснения и толкования в существующий стандарт и (2) обсудить новые средства, требуемые для расширения функциональных возможностей HPF. В качестве руководителя снова выступал Кен Кеннеди, а Мэри Зоусел взяла на себя роль исполнительного директора. В этих совещаниях в основном участвовали те же люди, что на встречах в 1992-1993 гг. Наиболее заметными новыми участниками были Ян Фостер (Ian Foster, Argonne National Laboratory) и Джоэл Сольц (Joel Saltz, University of Maryland), которые возглавили подгруппы, рассматривающие новые аспекты. Исправления вошли в состав спецификации стандарта High Performance Fortran 1.1, которая являлась немного исправленной версией документа 1993 г. и была представлена в ноябре 1994 г. на конференции Supercomputing’94 в Вашингтоне. В самом документе HPF 1.1 отмечаются некоторые аспекты языка, требующие дальнейшего прояснения (эти аспекты не влияют на примеры, приводимые в следующем разделе). Обсуждавшиеся новые возможности и пояснения, не вошедшие в HPF 1.1, были собраны в HPF Journal of Development и послужили стартовой точкой процесса стандартизации HPF 2, обсуждаемого в разд. 5.