Документ представляет собой семинар по языку параллельного программирования Cray Chapel, где рассматриваются модели параллельных вычислений и их предпосылки, а также описание функционала языка. Приведены основные команды и конструкции Chapel, включая поддержку объектно-ориентированного программирования, модули и параллельные массивы. Также указаны примеры кода и инструкции по запуску программ на кластере.

1. Язык параллельного
программирования Cray Chapel
Михаил Курносов 1, 2
1 Сибирский
2 Институт
государственный университет телекоммуникаций и информатики
физики полупроводников им. А.В. Ржанова СО РАН
Email: mkurnosov@gmail.com
WWW: http://www.mkurnosov.net
Семинар “Вычислительные системы”
6 ноября 2013

2. Модели параллельных вычислений
P
P
P
Memory
P
P
P
M
M
M
Shared memory model
Distributed memory model
C++11 Threads, OpenMP,
Intel Cilk Plus, Intel TBB,
NVIDIA CUDA, OpenCL, OpenACC
MPI, PVM, Shmem
Process/thread/task
Message passing
Memory (address space)
Locale memory access
2

3. Предпосылки возникновения модели PGAS

Распространение мультиархитектурной (гибридной) организации
вычислительных систем

Многопроцессорные NUMA-узлы с иерархической памятью
(HyperTransport, Intel QuickPath Interconnect)

Специализированные ускорители: GPU (NVIDIA, ATI), Intel Xeon Phi

Многомерные и
многоуровневые топологии
коммуникационных сетей:
AMD Opteron
Interlagos (16 cores)
2 nodes Cray XK7
 Cray Gemeni
(3D torus)
 Fujitsu Tofu
(6D mesh/torus)
 IBM BG/Q 5D torus
 Fat tree
3

4. Предпосылки возникновения модели PGAS

Разработка эффективных параллельных программ
для мультиархитектурных ВС требует владения стеком технологий
 Internode communications:
MPI, Cray Chapel, IBM X10, Shmem, Unified Parallel C, Coarray Fortran,
Global Arrays
 Multithreading: OpenMP, Intel TBB/Cilk Plus, C11/C++11 Threads
 GPU: NVIDA CUDA, OpenCL,
OpenACC, OpenMP 4.0
AMD Opteron
Interlagos (16 cores)
2 nodes Cray XK7
 Vectorization (SIMD):
SSE/AVX, AltiVec
SSE/AVX
MPI, Cray Chapel, Shmem,
Coarray Fortran, Unified Parallel C
NVIDIA CUDA,
OpenCL, OpenACC
OpenMP, Intel TBB, Cilk,
POSIX Threads
4

5. Предпосылки возникновения модели PGAS
Intel Xeon Phi (MIC)
NVIDIA Kepler GK110
Tilera TILEPro64
NVIDIA Echelon
5

6. Partitioned Global Address Space – PGAS

Partitioned Global Address Space (PGAS) – модель параллельных вычислений
с разделенным глобальным адресным пространством

Память параллельной программы глобально адресуема (global address space)

Адресное пространство логически разбито (partitioned) на блоки локальной
памяти потоков/процессов

Языки семейства PGAS: Cray Chapel, IBM X10, Coarray Fortran, Global Arrays,
Titanium, Unified Parallel C, Sun Fortress (проект закрыт)
P
P
P
Local
memory
Local
memory
Local
memory
Process/thread/task
Memory (address space)
Message passing
Local memory access
Global address space
6

7. Cray Chapel
 Cray Chapel – язык параллельного программирования,
реализующий модель вычислительной системы
с разделенным глобальным адресным пространством
(Partitioned Global Address Space – PGAS)
 Язык создан и развивается Cray Inc.
 Программа DARPA: High Productivity Computing Systems
 BSD License
 ОС: UNIX, GNU/Linux, Mac OS X, Windows (Cygwin)
 2013 – Chapel 1.8
 2012 – Chapel 1.7
 2007 – Chapel 0.5
 2006 – Chapel 0.4
http://chapel.cray.com
7

8. Дизайн Cray Chapel
 ZPL, HPF: data parallelism, index sets, distributed arrays
 CRAY MTA C/Fortran: task parallelism, synchronization
 CLU (Ruby, Python, C#): iterators
 Scala (ML, Matlab, Perl, Python, C#): type inference
 Java, C#: OOP, type safety
 C++: generic programming/templates
 Chapel Language Specification (version 0.94):
http://chapel.cray.com/spec/spec-0.94.pdf
http://chapel.cray.com
8

9. Основные определения
 Locale – абстракция вычислительной единицы, в рамках которой
выполняются задачи (tasks) и реализуется однородный доступ
к памяти
 Locale – абстракция многопроцессорного SMP-узла, NUMA-узла
 Задачи создаются динамически
Сеть InfiniBand (вычислительная сеть)
Ядро
Ядро
Процессор
Ядро
Общая память
Ядро
Процессор
Общая память
Frontend (login node)
Процессор
Ядро
Ядро
Общая память
Процессор
Ядро
Ядро
Compute node 1
Процессор
Ядро
Ядро
Общая память
Процессор
Ядро
Ядро
Compute node 2
Процессор
Ядро
Ядро
Общая память
Процессор
Ядро
Ядро
Compute node 3
Процессор
Ядро
Ядро
Процессор
Ядро
Ядро
Compute node 4
Сеть Gigabit Ethernet (сервисная сеть: NFS, DNS, DHCP, ssh, …)
Locale
Locale
Locale
Locale
9

10. Использование Chray Chapel на кластере Jet
 Добавляем в конец файла ~/.bashrc строку
“source /opt/etc/chapel-vars.sh” (выполняется единожды):
$ cat ~/.bashrc
# .bashrc
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
source /opt/etc/chapel-vars.sh
 Отключаемся от кластера (exit) и заходим снова
$ ssh mkurnosov@jet.cpct.sibsutis.ru
$ which chpl
/opt/chapel-1.8.0/bin/linux64/chpl
10

11. Конфигурация Chray Chapel на кластере Jet
 Конфигурация среды окружения:
$ cat /opt/etc/chapel-vars.sh
export CHPL_HOME=/opt/chapel-1.8.0
export CHPL_HOST_PLATFORM=linux64
export CHPL_TASKS=qthreads
export CHPL_THREADS=none
export CHPL_COMM=gasnet
export CHPL_LAUNCHER=amudprun
export PATH=$PATH:/opt/chapel-1.8.0/bin/linux64:
/opt/chapel-1.8.0/util
export MANPATH=$MANPATH:/opt/chapel-1.8.0/man
11

12. Hello World!
proc main() {
// Write message from each locale
for loc in Locales do {
on loc {
writeln("Hello World from locale ", here.id,
" (", here.name, ")");
}
}
}
 Компилируем программу:
$ chpl -o prog ./prog.chpl
 Компилятор создает два исполняемых файла:
-rwxrwxr-x 1 prog
-rw-rw-r-- 1 prog.chpl
-rwxrwxr-x 1 prog_real
# Стартовый файл (инициализация)
# Код программы
12

13. Hello World!
 Формируем job-файл для системы пакетной обработки
заданий TORQUE
$ cat task.job
#PBS -N MyChapelJob
#PBS -l nodes=4:ppn=8
#PBS -j oe
# Захватываем все ядра узла
cd $PBS_O_WORKDIR
chplrun ./prog
 Ставим задание в очередь системы TORQUE:
$ qsub ./task.job
20890.jet
13

14. AMUDPRUN: GASNet launcher
 Модуль amudprun (GASNet) запускает процессы на узлах
кластера по SSH
 Скрипт chplrun запускает через amudprun программу на узлах
кластера – интегрирует Cray Chapel и TORQUE
$ cat /opt/bin/chplrun
#!/bin/sh
nodes=`cat $PBS_NODEFILE | uniq | tr "n" " "`
nnodes=`echo $nodes | wc -w`
export GASNET_SPAWNFN=S
export SSH_SERVERS="$nodes"
$@ -nl $nnodes
14

15. Возможности Cray Chapel
 Поддержка объектно-ориентированного программирования
(class, record)
 Статическая типизация
 Модули (module) для реализации концепции пространств имен
(namespaces)
 Task parallelism
 Динамическое управление параллельными задачами
(begin, cobegin)
 Примитивы синхронизации (типы sync, single)
 Data parallelism:
 Типы данных для управления распределенными массивами
(range, domain, array, …)
 Конструкции для параллельных операций над распределенными
массивами (forall, coforall, reduce, scan)
15

16. Базовые типы данных (Primitive types)
 Синтаксис определения переменных
var <VariableName>: <DataType>;
 Базовые типы данных (primitive types):
 void
 bool – логический тип данных (значение true или false)
 int – целочисленный тип (целое со знаком, с версии 1.5
занимает 64 бита)
 uint – целочисленный тип (беззнаковое целое число)
 Целочисленный тип с заданным размером
 int(8), int(16), int(32), int(64)
 uint(8), uint(16), uint(32), uint(64)
16

17. Базовые типы данных (Primitive types)
 real – вещественный тип данных (64 бита, IEEE 754)
real(32), real(64)
 complex – комплексный тип
(мнимая и действительная части типа real, 128 бит)
complex(64), complex(128)
 string – строковый тип (ASCII символы)
17

18. Базовые типы данных (Primitive types)
var
var
var
var
var
var
var
i1: int = -4;
i2: uint = 0x3AFFDC;
i3: int(32) = 1000;
r1: real = 3.14;
r2: real = 45E-4;
c: complex = 3.14 + 2.72i;
s: string = "Hello, World";
writeln("i1 = ", i1, " i2 = ", i2, " i3 = ", i3);
writeln("r1 = ", r1, " r2 = ", r2);
writeln("c = ", c, " c.re = ", c.re,
" c.im = ", c.im);
writeln("s = ", s);
i1 = -4 i2 = 3866588 i3 = 1000
r1 = 3.14 r2 = 0.0045
c = 3.14 + 2.72i c.re = 3.14 c.im = 2.72
s = Hello, World
18

19. Константы
 Константы времени компиляции (compile-time constants)
param <ConstName>: <DataType> = <Value>;
 Константы времени выполнения (runtime-time constant)
const <ConstName>: <DataType> = <Value>;
param GridSize: int = 64;
const Cols = f(3);
19

20. Конфигурируемые переменные
 Конфигурируемые переменные (configuration variables) –
переменные, начальные значения которых можно задавать
через аргументы командной строки программы или файл
config const <VarName>: <DataType>;
config const MatrixRows = 100;
config const MatrixCols = 100;
writeln(MatrixRows, " ", MatrixCols);
chpl –o prog ./prog.chpl
./prog --MatrixRows=64 --MatrixCols=32
64 32
20

21. Перечисляемый тип данных (enumerated)
 Перечисляемый тип (Enumerated type) позволяет
задавать множество именованных констант
enum <EnumName> {<const1>, <const2>, ...};
enum NodeColor {Red = 2, Green, Blue};
var e: NodeColor = NodeColor.Green;
var k: int = e;
writeln("e = ", e, ", NodeColor.Green = ",
NodeColor.Green, ", k = ", k);
e = Green, NodeColor.Green = Green, k = 3
21

22. Ветвления (conditional expressions)
 Ветвления if-else подобны ветвлениям в C/C++
var i = 3;
var flag = if (i % 2) then i / 2 + 1 else i / 2;
writeln("flag = ", flag);
if (flag > 100) {
flag = 1;
}
22

23. Ветвления (conditional expressions)
 Ветвления select подобны ветвлениям switch в C/C++
var MsgType: int;
select (MsgType) {
when 1 {
// Process 1
}
when 2 {
// Process 2
}
otherwise {
// Process alternative cases
}
}
23

24. Цикл for
for <index-var-decl> in <iteratable-expr> do
expr
for (i, j) in (1..3, 4..6) do
write(i, " ", j, " ");
1 4 2 5 3 6
24

25. Цикл for
for <index-var-decl> in <iteratable-expr> do expr
for i in -3..2 do {
writeln(i, " ");
}
var A = for i in 0..10 do if i % 2 == 0 then i;
writeln(“A = ”, A);
-3
-2
-1
0
1
2
A = 0 2 4 6 8 10
25

26. Циклы while, do
while (condition) {
// Loop body
}
do {
// Loop body
} while (condition);
26

27. Процедуры
proc FunA {
writeln("In A");
}
proc FunB() {
writeln("In B");
}
proc FunC(x: int = 10, y: int = 20) {
writeln(x);
writeln(y);
}
FunC();
FunC(3)
FunC(y = 4);
/* OUT: 10, 20 */
/* OUT: 3, 20 */
/* OUT: 10, 4 */
27

28. Переменное количество аргументов
proc WriteData(x ...?k) {
for param i in 1..k do
writeln(x(i));
}
proc sum(a: int...3) {
return a(1) + a(2) + a(3);
}
var x = sum(1, 2, 3);
/* x = 6 */
28

29. Модули (Modules)
 Программа на Cray Chapel состоит из одного или
нескольких модулей (module)
 Модули предназначены для управления областью
видимости переменных (namespaces)
 В одном файле может быть описано несколько модулей
(названия модулей не привязаны к именам файлов)
 Если в файле нет явного описания модуля, создается
модуль по умолчанию, имя которого совпадает
с названием файла (без расширения “.chpl”)
29

30. Модули (Modules)
module ModuleA {
var x: string = "Module A";
proc printX() {
writeln(x);
}
}
module ModuleB {
var y: string = "Module B";
proc printY() {
writeln(y);
}
}
30

31. Использование модулей (use)
module ModuleA {
use ModuleB;
var x: int = 2;
proc main() {
ModuleB.x = 4;
ModuleB.printX();
}
}
module ModuleB {
var x: int = 3;
proc printX() {
writeln(“x = ", x);
}
}
31

32. Последовательность запуска программы
 Выполнение программы начинается с инициализации всех
модулей – выполняется код модулей вне функций
 В одном из модулей (главном модуле) вызывается
функция main()
 Все модули, указанные в директивах use главного
модуля обходятся в глубину (depth-first traversal)
и инициализируются в обратном порядке (post order)
32

33. Инициализация модулей
module M1 {
use M2.M3;
use M2;
writeln("In M1’s initializer");
proc main() {
writeln("In main");
}
}
M1
use
use
M3
M2
module M2 {
use M4;
writeln("In M2’s initializer");
module M3 {
writeln("In M3’s initializer");
}
}
module M4 {
writeln("In M4’s initializer");
}
use
M4
Depth-first traversal:
post-order init
33

34. Инициализация модулей
In
In
In
In
In
M4’s
M2’s
M3’s
M1’s
main
initializer
initializer
initializer
initializer
M1
use
use
M3
M2
use
M4
Depth-first traversal:
post-order init
34

35. Массивы
 Массив (array) – это отображение множества индексов
(domain) на набор однотипных элементов
ArrayName [DomainExpression] DataType
 DomainExpression – множество индексов массива, домен
(domain) определяет структуру и размерность индексов
массива
const D: domain(2) = [1..10, 1..10];
var A: [D] real;
// Domain
// Array 10x10
var B: [-1..3] int = (4, 5, 1, 3, 9);
// Anon. domain
var A: [1..2] [1..3] real = [[1.1, 1.2, 1.3],
[2.1, 2.2, 2.3]];
35

36. Домены
 Cray Chapel поддерживает домены различных видов
 Dense (регулярные плотно заполненные массивы)
 Strided (периодически заполненные массивы)
 Sparse (разряженные массивы)
 Unstructured (сетки произвольной структуры)
 Домен может быть распределён по памяти нескольких
локалей
36

37. Доступ к элементам массива
var A: [1..10] real;
A(1) = 1.2;
A[2] = 3.4;
var B: [1..5, 1..5] real;
var ij: 2*int = (1, 1);
B(ij) = 1.1;
B((1, 2)) = 1.2;
B(1, 3) = 1.3;
B[ij] = -1.1;
B[(1, 4)] = 1.4;
B[1, 5] = 1.5;
37

38. Массивы
/* Массив с индексами: 1, 3, 5, 7, 9 */
var X: [1..10 by 2] int;
for i in X.domain do
writeln(i);
 Ссылки на массивы (Array aliases)
/* AA – псевдоним массива A */
var A: [1..5, 1..5] int;
var AA: [0..2, 0..2] => A[2..4, 2..4];
/* AA(1, 1) = A(3, 3) */
38

39. Операции над доменами (Slicing)
var OuterD: domain(2) = {0..n + 1, 0..n + 1};
var InnerD: domain(2) = {1..n, 1..n};
var A, B: [OuterD] real;
// ...
A[InnerD] = B[InnerD];
// slice A[0..n + 1, 0] – first column of A
OuterD
InnerD
39

40. Перебор элементов массива
var A: [1..5, 1..5] real;
for a in A do
writeln(a);
# Перебор значений
for i in A.domain do
writeln(a[i]);
# Перебор индексов
var len: int = 5;
var S: [1..len] string = (“red”, “green”,
“black”, “yellow”,
“blue”);
for s in S do
write(a," ");
40

41. Присваивание массивов
var A: [1..5, 1..5] real;
var B: [1..5, 1..5] real;
A = B;
forall (a, b) in (A, B) do
a = b;
# Parallel loop
41

42. Записи и классы
 Записи и классы – это составные типы данных,
содержащие методы и поля
 При присваивании экземпляра записи (record) другому
её экземпляру выполняется копирование её полей
(аналог присваивания структур в языке C)
 При присваивании экземпляра класса (class) другому
его экземпляру выполняется копирование ссылки на
объект класса
42

43. Классы
class GameObject {
var x, y: real;
var name: string;
proc GameObject(x: real, y: real) {
this.x = x;
this.y = y;
this.name = "Object";
}
proc GameObject(name: string) {
this.x = 0.0;
this.y = 0.0;
this.name = name;
}
}
var obj2 = new GameObject(34.25, 12.56);
var obj3 = new GameObject("Bullet");
writeln(obj3);
{x = 0.0, y = 0.0, name = Bullet}
43

44. Setters & Getters
class Counter {
var count: int;
var x: int;
proc x var {
if setter then {
count += 1;
writeln("Setter is called");
} else {
writeln("Getter is called");
}
return x;
}
 setter = true
в поле записали
новое значение
 setter = false
поле “читают”
}
var c = new Counter();
c.x = 4;
var temp = c.x;
/* setter = true */
/* setter = false */
44

45. Удаление объекта
 В спецификации Cray Chapel подразумевается,
что runtime-система реализует сборку мусора и все
экземпляры классов удаляются автоматически
 Для принудительного удаления объекта следует
использовать конструкцию delete
var obj = new GameObject(34.25, 12.56);
/* Code ... */
delete obj;
45

46. Тип Locale
 Locale – это локальная память и множество параллельных задач,
использующих её (абстрактное представление SMP/NUMA-узла)
 Тип данных locale:
 proc locale.callStackSize: uint(64)
– размер стека задач, выполняющихся в этой локали
 proc locale.id: int
– номер локали (0, 1, …)
 proc locale.name: string
– имя локали
 proc locale.numCores: int
– количество процессорных ядер доступных в локали
46

47. Предопределенные переменные
 config const numLocales: int – количество локалей
 const LocaleSpace: domain(1) = [0..numLocales-1];
 const Locales: [LocaleSpace] locale –
массив локалей программы
 here – ссылка на локаль, в которой выполняется текущая
задача
 Процедура main запускается в локали 0 (Locales[0])
47

48. Ключевое слово On
 Конструкция on задает локаль (locale), в которой следует
выполнять блок инструкций и размещать его данные
on <locale> do <expr>
var x: int = 10;
on Locales(1) {
var y: real = 3.14;
writeln(here.id);
}
Locale 0
 x = 10
// Locale 0
// Locale 1
Locale 1
 y = 3.14
48

49. Ключевое слово On
 Конструкция on задает локаль (locale), в которой следует
выполнять блок инструкций и размещать его данные
on <locale> do <expr>
var a: int = 1;
on Locales(1) {
var b: int = 2;
writeln("Locale 1: a = ", a, " b = ", b);
}
// a = 1, b = 2
on Locales(1) {
// Launch a task on Locale 1 (empty stack)
// ERROR: error: 'b' undeclared
writeln("a = ", a, " b = ", b);
}
49

50. Locale
class C {}
record R {}
on Locales(1) {
var x: int;
var c: C;
var r: R;
// reference
// value
on Locales(2) {
on Locales(3) {
c = new C();
r = new R();
}
writeln(x.locale.id);
writeln(c.locale.id);
writeln(r.locale.id);
}
}
1
3
1
50

51. Скрытые обмены информацией
var x, y: real;
// x and y allocated on loc 0
on Locales(1) {
var z: real;
z = x + y;
// migrate task to loc 1
// z allocated on loc 1
// remote reads of x and y
on Locales(0) do
z = x + y;
on x do
z = x + y;
}
//
//
//
//
//
//
//
migrate back to loc 0
remote write to z
migrate back to loc 1
data migration to loc 0
remote write to z
migrate back to loc 1
migrate back to loc 0
Locale 0
 x
 y
Locale 1
 z
51

52. Task parallelism: конструкция begin
 Конструкция begin порождает новую задачу (task)
и выполняет в ней блок инструкций (в текущей локали)
begin <statement>
 Выполнение родительской задачи не блокируется
for i in 1..3 do {
begin writeln("Task ", i);
}
Task 1
Task 2
Task 3
52

53. Task parallelism: конструкция begin
 Конструкция cobegin порождает новую задачу для каждого оператора
в блоке
cobegin {
statement1();
statement1();
...
statementN();
}
 Выполнение родительской задачи блокируется пока не завершат
работу все дочерние задачи
cobegin {
writeln("Task 1");
writeln("Task 2");
writeln("Task 3");
}
writeln("Main task");
Task
Task
Task
Main
1
2
3
task
53

54. Data parallelism: конструкция forall
 Конструкция forall сообщает компилятору, что все итерации
цикла можно выполнять параллельно
 Создание отдельной задачи для каждой итерации
не гарантируется
 Выполнение продолжается когда все итерации цикла будут
завершены
var sum: int = 0;
forall i in 1..1000000 {
sum += i;
/* Data race */
}
writeln(sum);
forall i in 1..N do
a(i) = b(i);
54

55. Data parallelism: конструкция coforall
 Конструкция coforall создает для каждой итерации цикла
отдельную задачу
 Выполнение продолжается когда все итерации цикла
будут завершены
coforall i in iterator() {
loop_body();
}
config const ntasks = here.numCores;
coforall rank in 0..ntasks - 1 {
writeln("Task ", rank, " of ", ntasks);
}
55

56. Переменные синхронизации
 Переменная синхронизации (synchronization variable) –
это переменная заданного типа имеющая логическое
состояние full (заполнена) или empty (пуста)
 Переменная синхронизации не может быть прочитана
(read) пока она находится в состоянии empty
 Переменная синхронизации не может быть записана
пока она находится в состоянии full
Типы переменных синхронизации (для базовых типов)
Тип переменной
Запись переменной
Чтение переменной
single
Один раз, состояние
меняется на full
Состояние
не меняется (full)
sync
Состояние
меняется на full
Состояние
меняется на empty
56

57. Переменные синхронизации
 Если переменной синхронизации присвоено начальное
значение, то она в состоянии full
 При попытке доступа к переменной (read, write) задачи
ожидают пока, она не перейдет в корректное состояние
var lock$: sync bool;
var sum: int = 0;
forall i in 1..100000 {
lock$ = true;
// Write: lock is full now
sum += i;
lock$;
// Read: lock is empty now
}
writeln(sum);
57

58. Переменные синхронизации
 Если переменной синхронизации присвоено начальное
значение, то она в состоянии full
 При попытке доступа к переменной (read, write) задачи
ожидают пока, она не перейдет в корректное состояние
var count$: sync int = 0;
begin count$ = count$ + 1;
begin count$ = count$ + 1;
begin count$ = count$ + 1;
58

59. Методы переменных синхронизации
readXX, readFE, readFF(), writeEF(), writeFF(),
reset(), isFull()
var x$: sync int;
var y$: single int;
var z: int;
x$ = 5;
y$ = 6;
z = x$ + y$;
// full now
// full now
// x – empty, y - full
x$.writeEF(5);
y$.writeEF(6);
z = x$.readFE() +
y$.readFF();
//
//
/*
/*
Ждет
Ждет
Ждет
Ждет
empty -> записывает -> full
empty -> записывает -> full
full -> читает -> empty */
full -> читает -> full */
59

60. Переменные синхронизации
cobegin {
stmt1();
stmt2();
stmt3();
}
var s1$, s2$, s3$: single bool;
begin { stmt1(); s1$ = true; }
// s1 full
begin { stmt2(); s2$ = true; }
// s2 full
begin { stmt3(); s3$ = true; }
// s3 full
s1$; s2$; s3$;
// wait for full state
60

61. Переменные синхронизации
coforall i in iterator()
loop_body();
var runningCount$: sync int = 1; // full
var finished$: single bool;
for i in iterator() {
runningCount$ += 1; // Number of tasks + 1 for main
begin {
loop_body();
var temp = runningCount$;
runningCount$ = temp - 1;
if temp == 1 then
finished$ = true;
}
}
var temp = runningCount$;
runningCount$ = temp - 1;
if temp == 1 then
finished$ = true;
finished$;
61

62. Числа Фибоначчи (sequential version)
proc fib(n: int): int {
if (n < 2) {
return n;
}
var x, y: int;
x = fib(n - 1);
y = fib(n - 2);
return x + y;
}
writeln("Fib(35) = ", fib(35));
62

63. Числа Фибоначчи (parallel version – single locale)
proc fib(n: int): int {
if (n < 2) {
return n;
}
var x$: sync int;
begin x$ = fib(n - 1);
var y: int = fib(n - 2);
return x$ + y;
// Wait for full x$
}
writeln("Fib(35) = ", fib(35));
63

64. Data parallelism: reductions & scans
var A: [1..10] int;
A = 1;
var sum = + reduce A;
writeln(sum);
var A, B, C: [1..5]
A = 1;
B = + scan A;
B[3] = -B[3];
C = min scan B;
int;
// A:
// B:
// B:
// C:
1
1
1
1
1
2
2
1
1 1 1
3 4 5
-3 4 5
-3 -3 -3
 Поддерживаемые операции:
+, *, &&, ||, &, |, ^, min, max, minloc, maxloc
64

65. Data parallelism: distributions
 Спецификатор dmapped задает алгоритм распределения домена
(массива) между памятью локалей
var D = [1..m];
var A: [D] real;
var D = [1..m] dmapped Block(boundingBox = [1..m]);
var A: [D] real;
Locale 0
Locale 1
Locale 2
Locale 3
65

66. Решение краевой задачи методом Якоби
Граничные
условия
Крестообразный
вычислительный
шаблон
66

67. Решение краевой задачи методом Якоби
config const n = 40;
// Размер сетки
config const eps = 1E-2;
param Pi: real = 3.141592653589793238462643;
const
const
const
const
const
const
BigD: domain(2) = {0..n + 1, 0..n + 1};
D: subdomain(BigD) = {1..n, 1..n}; // Без внешних границ
FirstRow: subdomain(BigD) = D.exterior(-1, 0);
LastRow: subdomain(BigD) = D.exterior(1, 0);
FirstCol: subdomain(BigD) = D.exterior(0, -1);
LastCol: subdomain(BigD) = D.exterior(0, 1);
var grid, newgrid: [BigD] real;
67

68. Решение краевой задачи методом Якоби
proc main() {
// Initial conditions
grid[D] = 0.0;
[(i, j) in FirstRow] grid[i, j] =
sin(Pi * (j: real / (n + 2.0)));
[(i, j) in LastRow] grid[i, j] =
sin(Pi * (j: real / (n + 2.0))) * exp(-Pi);
grid[FirstCol] = 0.0;
grid[LastCol] = 0.0;
Single locale version
(многопоточная)
var iters = 0;
do {
forall (i, j) in D {
newgrid[i, j] = (grid[i - 1, j] + grid[i + 1, j] +
grid[i, j - 1] + grid[i, j + 1]) * 0.25;
}
const maxdiff = max reduce abs(newgrid[D] - grid[D]);
grid[D] = newgrid[D];
iters += 1;
} while (maxdiff > eps);
}
68

69. Транспонирование матрицы (PTRANS)
T[i,
A
use BlockCycDist;
j] = A[j, i]
// Блочно-циклическое распределение массивов
config type eltType = real(64);
config const numrows = 100,
numcols = 100,
rowBlkSize = 8,
colBlkSize = 8,
beta = 1.0;
//
//
//
//
Строк в матрице
Столбцов в матрице
Строк в блоке
Столбцов в блоке
config const epsilon = 2.2e-16;
69

70. Транспонирование матрицы (PTRANS)
//
// initArrays: инициализирует массивы
//
proc initArrays(A, C) {
forall (i, j) in A.domain do
A[i, j] = erf(i) * cos(j);
forall (i, j) in C.domain do
C[i, j] = sin(j) * cbrt(i);
const norm_A = sqrt(+ reduce A**2);
const norm_C = sqrt(+ reduce C**2);
const error_tolerance = (norm_A +
epsilon;
return error_tolerance;
abs(beta) * norm_C) *
}
70

71. Транспонирование матрицы (PTRANS)
proc CPlusATranspose((i, j)) {
return beta * sin(j) * cbrt(i) + erf(j) * cos(i);
}
proc verifyResults(C: [], tolerance) {
const error = max reduce [ij in C.domain]
abs(C(ij) - CPlusATranspose(ij));
writeln("error = ", error);
return (error <= tolerance);
}
71

72. Транспонирование матрицы (PTRANS)
proc main() {
const MatrixDist = new BlockCyclic(startIdx = (1, 1),
blocksize = (rowBlkSize, colBlkSize));
const TransposeDist = new BlockCyclic(startIdx = (1, 1),
blocksize = (colBlkSize, rowBlkSize));
const MatrixDom: domain(2) dmapped new dmap(MatrixDist) =
{1..numrows, 1..numcols};
const TransposeDom: domain(2) dmapped new dmap(TransposeDist) =
{1..numcols, 1..numrows};
// Матрицы распределены по памяти локалей
var A: [MatrixDom] eltType;
var C: [TransposeDom] eltType;
const error_tolerance = initArrays(A, C);
forall (i, j) in TransposeDom do
C[i, j] += A[j, i];
const validAnswer = verifyResults(C, error_tolerance);
}
72

73. Транспонирование матрицы (PTRANS)
const MatrixDist = new BlockCyclic(startIdx = (1, 1), blocksize = (8, 8));
const MatrixDom: domain(2) dmapped new dmap(MatrixDist) = {1..50, 1..50};
var A: [MatrixDom] int;
 Пример
распределения
матрицы по
локалям
 Locales: 8
 Локали
организованы
в массив 2x4
(см. BlockCyclic)
 Каждой локали
выделено
множество
блоков
по 8x8 элементов
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
L0
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
L2
L4
L6
L0
L2
L4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L1
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L3
L5
L7
L1
L3
L5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
L0
L2
L4
L6
L0
L2
L4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L1
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L3
L5
L7
L1
L3
L5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
L0
L2
L4
L6
L0
L2
L4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L1
L3
L5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
L7
L1
L3
L5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
5
5
5
5
5
5
7
7
7
7
7
7
7
7
1
1
1
1
1
1
1
1
3
3
3
3
3
3
3
3
5
5
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
4
4
4
4
4
4
6
6
6
6
6
6
6
6
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
4
4
L0
L2
L4
L6
L0
L2
L4
73

74. Документация и примеры
 Chapel Tutorials // http://chapel.cray.com/tutorials.html
 Chapel Language Definition //
http://chapel.cray.com/language.html
 Chapel Presentations //
http://chapel.cray.com/presentations.html
 /opt/chapel-1.8.0/examples
 /benchmarks – реализация на Cray Chapel тестов
HPL, FFT, PTRANS, STREAM, …
74

75. Открытые задачи
 Развитие методов оптимизирующей компиляции
 Оптимизация скрытых обменов
Обнаружение паттернов последовательного доступа
к удаленной памяти и укрупнение передаваемых блоков между
узлами (аналог векторизации кода, предвыборка, …)
 Совмещение вычислений и обменов
Статический анализ Chapel-программ для обнаружения участков
кода, выполнение которых можно совместить с передачей
информации (overlapping)
 Развитие методов динамического управления легковесными задачами
(task layer scheduling, hierarchical work stealing)
 Развитие методов реализации переменных синхронизации
(software transactional memory?)
 …
75

76. Спасибо за внимание!
76