Язык параллельного программирования Cray Chapel

Язык параллельного программирования Cray Chapel

Михаил Курносов 1, 2

Email: [email protected]

WWW: http://www.mkurnosov.net

Семинар “Вычислительные системы”

6 ноября 2013

1 Сибирский государственный университет телекоммуникаций и информатики

2 Институт физики полупроводников им. А.В. Ржанова СО РАН

Модели параллельных вычислений

2

P

M

P

M

P

M

P

Memory

P P

Shared memory model Distributed memory model

Process/thread/task

Memory (address space)

Message passing

Locale memory access

C++11 Threads, OpenMP, Intel Cilk Plus, Intel TBB,

NVIDIA CUDA, OpenCL, OpenACC

MPI, PVM, Shmem

Предпосылки возникновения модели PGAS

Распространение мультиархитектурной (гибридной) организации

вычислительных систем

Многопроцессорные NUMA-узлы с иерархической памятью

(HyperTransport, Intel QuickPath Interconnect)

Специализированные ускорители: GPU (NVIDIA, ATI), Intel Xeon Phi

3

Многомерные и

многоуровневые топологии

коммуникационных сетей:

Cray Gemeni

(3D torus)

Fujitsu Tofu

(6D mesh/torus)

IBM BG/Q 5D torus

Fat tree3

2 nodes Cray XK7

AMD Opteron Interlagos (16 cores)


Разработка эффективных параллельных программ для мультиархитектурных ВС требует владения стеком технологий

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

4

GPU: NVIDA CUDA, OpenCL, OpenACC, OpenMP 4.0

Vectorization (SIMD): SSE/AVX, AltiVec

2 nodes Cray XK7

NVIDIA CUDA, OpenCL, OpenACC

OpenMP, Intel TBB, Cilk, POSIX Threads

AMD Opteron Interlagos (16 cores)

SSE/AVX

MPI, Cray Chapel, Shmem, Coarray Fortran, Unified Parallel C


5

Intel Xeon Phi (MIC)

NVIDIA Kepler GK110

NVIDIA EchelonTilera TILEPro64

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 (проект закрыт)

6

P P P

Process/thread/task

Memory (address space)

Message passing

Local memory access

Local memory

Local memory

Local memory

Global address space

Cray Chapel

7

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

http://chapel.cray.com/

Дизайн Cray Chapel

8

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

http://chapel.cray.com

Chapel Language Specification (version 0.94):

http://chapel.cray.com/spec/spec-0.94.pdf

http://chapel.cray.com/

http://chapel.cray.com/spec/spec-0.94.pdf

Основные определения

9

Locale – абстракция вычислительной единицы, в рамках которой

выполняются задачи (tasks) и реализуется однородный доступ

к памяти

Locale – абстракция многопроцессорного SMP-узла, NUMA-узла

Задачи создаются динамически

Сеть InfiniBand (вычислительная сеть)

Общая память

Ядро

Процессор

Ядро Ядро

Процессор

Ядро


Ядро

Процессор

Ядро Ядро

Процессор

Ядро


Ядро

Процессор

Ядро Ядро

Процессор

Ядро


Ядро

Процессор

Ядро Ядро

Процессор

Ядро

Compute node 1 Compute node 2 Compute node 3 Compute node 4


Ядро

Процессор

Ядро Ядро

Процессор

Ядро

Frontend (login node)

Сеть Gigabit Ethernet (сервисная сеть: NFS, DNS, DHCP, ssh, …)

Locale Locale Locale Locale

Использование Chray Chapel на кластере Jet

10

Добавляем в конец файла ~/.bashrc строку

“source /opt/etc/chapel-vars.sh” (выполняется единожды):

$ cat ~/.bashrc# .bashrc

# Source global definitionsif [ -f /etc/bashrc ]; then

. /etc/bashrcfi

source /opt/etc/chapel-vars.sh

Отключаемся от кластера (exit) и заходим снова

$ ssh [email protected]$ which chpl/opt/chapel-1.8.0/bin/linux64/chpl

Конфигурация Chray Chapel на кластере Jet

11

Конфигурация среды окружения:

$ 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

Hello World!

12

proc main() {// Write message from each localefor 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 # Код программы

Hello World!

13

$ cat task.job#PBS -N MyChapelJob#PBS -l nodes=4:ppn=8 # Захватываем все ядра узла#PBS -j oe

cd $PBS_O_WORKDIR

chplrun ./prog

Формируем job-файл для системы пакетной обработки

заданий TORQUE

$ qsub ./task.job

20890.jet

Ставим задание в очередь системы TORQUE:

AMUDPRUN: GASNet launcher

14

$ cat /opt/bin/chplrun#!/bin/sh

nodes=`cat $PBS_NODEFILE | uniq | tr "\n" " "`nnodes=`echo $nodes | wc -w`

export GASNET_SPAWNFN=Sexport SSH_SERVERS="$nodes"

$@ -nl $nnodes

Модуль amudprun (GASNet) запускает процессы на узлах

кластера по SSH

Скрипт chplrun запускает через amudprun программу на узлах

кластера – интегрирует Cray Chapel и TORQUE

Возможности Cray Chapel

15

Поддержка объектно-ориентированного программирования(class, record)

Статическая типизация

Модули (module) для реализации концепции пространств имен (namespaces)

Task parallelism

Динамическое управление параллельными задачами (begin, cobegin)

Примитивы синхронизации (типы sync, single)

Data parallelism:

Типы данных для управления распределенными массивами (range, domain, array, …)

Конструкции для параллельных операций над распределенными массивами (forall, coforall, reduce, scan)

Синтаксис определения переменных

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) 1616

Базовые типы данных (Primitive types)

real – вещественный тип данных (64 бита, IEEE 754)

real(32), real(64)

complex – комплексный тип

(мнимая и действительная части типа real, 128 бит)

complex(64), complex(128)

string – строковый тип (ASCII символы)

1717


1818


var i1: int = -4;var i2: uint = 0x3AFFDC;var i3: int(32) = 1000;var r1: real = 3.14;var r2: real = 45E-4;var c: complex = 3.14 + 2.72i;var 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 = 1000r1 = 3.14 r2 = 0.0045c = 3.14 + 2.72i c.re = 3.14 c.im = 2.72s = Hello, World

1919

Константы

Константы времени компиляции (compile-time constants)

param <ConstName>: <DataType> = <Value>;

Константы времени выполнения (runtime-time constant)

const <ConstName>: <DataType> = <Value>;

param GridSize: int = 64;const Cols = f(3);

2020

Конфигурируемые переменные

Конфигурируемые переменные (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

2121

Перечисляемый тип данных (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

2222

Ветвления (conditional expressions)

var i = 3;

var flag = if (i % 2) then i / 2 + 1 else i / 2;writeln("flag = ", flag);

if (flag > 100) {flag = 1;

}

Ветвления if-else подобны ветвлениям в C/C++

2323

Ветвления (conditional expressions)

var MsgType: int;

select (MsgType) {when 1 {

// Process 1}when 2 {

// Process 2}otherwise {

// Process alternative cases}

}

Ветвления select подобны ветвлениям switch в C/C++

2424

Цикл for

for <index-var-decl> in <iteratable-expr> do expr

for (i, j) in (1..3, 4..6) dowrite(i, " ", j, " ");

1 4 2 5 3 6

2525

Цикл 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

2626

Циклы while, do

while (condition) {// Loop body

}

do {// Loop body

} while (condition);

2727

Процедуры

proc FunA { writeln("In A");

}

proc FunB() { writeln("In B");

}

proc FunC(x: int = 10, y: int = 20) { writeln(x); writeln(y);

}

FunC(); /* OUT: 10, 20 */FunC(3) /* OUT: 3, 20 */FunC(y = 4); /* OUT: 10, 4 */

2828

Переменное количество аргументов

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 */

2929

Модули (Modules)

Программа на Cray Chapel состоит из одного или

нескольких модулей (module)

Модули предназначены для управления областью

видимости переменных (namespaces)

В одном файле может быть описано несколько модулей

(названия модулей не привязаны к именам файлов)

Если в файле нет явного описания модуля, создается

модуль по умолчанию, имя которого совпадает

с названием файла (без расширения “.chpl”)

3030

Модули (Modules)

module ModuleA {var x: string = "Module A";

proc printX() {writeln(x);

}}

module ModuleB {var y: string = "Module B";

proc printY() {writeln(y);

}}

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);

}}

3131

Использование модулей (use)

3232

Последовательность запуска программы

Выполнение программы начинается с инициализации всех

модулей – выполняется код модулей вне функций

В одном из модулей (главном модуле) вызывается

функция main()

Все модули, указанные в директивах use главного

модуля обходятся в глубину (depth-first traversal)

и инициализируются в обратном порядке (post order)

3333

Инициализация модулей

module M1 {use M2.M3;use M2;writeln("In M1’s initializer");proc main() {

writeln("In main");}

}

module M2 {use M4;writeln("In M2’s initializer");

module M3 {writeln("In M3’s initializer");

}}

module M4 {writeln("In M4’s initializer");

}

M1

M3 M2

M4

use use

use

Depth-first traversal:post-order init

In M4’s initializerIn M2’s initializerIn M3’s initializerIn M1’s initializerIn main

3434

Инициализация модулей

M1

M3 M2

M4

use use

use

Depth-first traversal:post-order init

const D: domain(2) = [1..10, 1..10]; // Domainvar A: [D] real; // Array 10x10

var B: [-1..3] int = (4, 5, 1, 3, 9); // Anon. domainvar A: [1..2] [1..3] real = [[1.1, 1.2, 1.3],

[2.1, 2.2, 2.3]];

3535

Массивы

Массив (array) – это отображение множества индексов

(domain) на набор однотипных элементов

ArrayName [DomainExpression] DataType

DomainExpression – множество индексов массива, домен

(domain) определяет структуру и размерность индексов

массива

3636

Домены

Cray Chapel поддерживает домены различных видов

Dense (регулярные плотно заполненные массивы)

Strided (периодически заполненные массивы)

Sparse (разряженные массивы)

Unstructured (сетки произвольной структуры)

Домен может быть распределён по памяти нескольких локалей

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;

3737

Доступ к элементам массива

3838

Массивы

/* Массив с индексами: 1, 3, 5, 7, 9 */var X: [1..10 by 2] int;

for i in X.domain dowriteln(i);

/* 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) */

Ссылки на массивы (Array aliases)

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

3939

Операции над доменами (Slicing)

OuterD

InnerD

4040

Перебор элементов массива

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 dowrite(a," ");

4141

Присваивание массивов

var A: [1..5, 1..5] real;

var B: [1..5, 1..5] real;

A = B;

forall (a, b) in (A, B) do # Parallel loopa = b;

4242

Записи и классы

Записи и классы – это составные типы данных,

содержащие методы и поля

При присваивании экземпляра записи (record) другому

её экземпляру выполняется копирование её полей

(аналог присваивания структур в языке C)

При присваивании экземпляра класса (class) другому

его экземпляру выполняется копирование ссылки на

объект класса

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);4343

Классы

{x = 0.0, y = 0.0, name = Bullet}

4444

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;

}}

var c = new Counter();c.x = 4; /* setter = true */var temp = c.x; /* setter = false */

setter = true в поле записали новое значение

setter = falseполе “читают”

4545

Удаление объекта

В спецификации Cray Chapel подразумевается,

что runtime-система реализует сборку мусора и все

экземпляры классов удаляются автоматически

Для принудительного удаления объекта следует

использовать конструкцию delete

var obj = new GameObject(34.25, 12.56);

/* Code ... */

delete obj;

4646

Тип Locale

Locale – это локальная память и множество параллельных задач,

использующих её (абстрактное представление SMP/NUMA-узла)

Тип данных locale:

proc locale.callStackSize: uint(64)

– размер стека задач, выполняющихся в этой локали

proc locale.id: int

– номер локали (0, 1, …)

proc locale.name: string

– имя локали

proc locale.numCores: int

– количество процессорных ядер доступных в локали

4747

Предопределенные переменные

config const numLocales: int – количество локалей

const LocaleSpace: domain(1) = [0..numLocales-1];

const Locales: [LocaleSpace] locale –массив локалей программы

here – ссылка на локаль, в которой выполняется текущая задача

Процедура main запускается в локали 0 (Locales[0])

4848

Ключевое слово On

Конструкция on задает локаль (locale), в которой следует выполнять блок инструкций и размещать его данные

on <locale> do <expr>

var x: int = 10; // Locale 0

on Locales(1) {

var y: real = 3.14; // Locale 1

writeln(here.id);

}

Locale 0

x = 10

Locale 1

y = 3.14

4949

Ключевое слово 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);

}

5050

Locale

class C {}

record R {}

on Locales(1) {

var x: int;

var c: C; // reference

var r: R; // 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);

}

}

131

5151

Скрытые обмены информацией

var x, y: real; // x and y allocated on loc 0

on Locales(1) { // migrate task to loc 1

var z: real; // z allocated on loc 1

z = x + y; // remote reads of x and y

on Locales(0) do // migrate back to loc 0

z = x + y; // remote write to z

// migrate back to loc 1

on x do // data migration to loc 0

z = x + y; // remote write to z

// migrate back to loc 1

} // migrate back to loc 0

Locale 0

x y

Locale 1

z

5252

Task parallelism: конструкция begin

Конструкция begin порождает новую задачу (task)и выполняет в ней блок инструкций (в текущей локали)

begin <statement>

Выполнение родительской задачи не блокируется

for i in 1..3 do {

begin writeln("Task ", i);

}

Task 1Task 2Task 3

5353

Task parallelism: конструкция begin

Конструкция cobegin порождает новую задачу для каждого оператора в блоке

cobegin {statement1();statement1();...statementN();

}

Выполнение родительской задачи блокируется пока не завершат работу все дочерние задачи

cobegin {

writeln("Task 1");

writeln("Task 2");

writeln("Task 3");

}

writeln("Main task");

Task 1Task 2Task 3Main task

5454

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);

5555

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);}

5656

Переменные синхронизации

Переменная синхронизации (synchronization variable) –это переменная заданного типа имеющая логическое состояние full (заполнена) или empty (пуста)

Переменная синхронизации не может быть прочитана (read) пока она находится в состоянии empty

Переменная синхронизации не может быть записана пока она находится в состоянии full

Типы переменных синхронизации (для базовых типов)

Тип переменной Запись переменной Чтение переменной

singleОдин раз, состояние

меняется на fullСостояние

не меняется (full)

syncСостояние

меняется на fullСостояние

меняется на empty

5757


Если переменной синхронизации присвоено начальное значение, то она в состоянии full

При попытке доступа к переменной (read, write) задачи ожидают пока, она не перейдет в корректное состояние

var lock$: sync bool;var sum: int = 0;

forall i in 1..100000 {lock$ = true; // Write: lock is full nowsum += i;lock$; // Read: lock is empty now

}writeln(sum);

5858


Если переменной синхронизации присвоено начальное значение, то она в состоянии full

При попытке доступа к переменной (read, write) задачи ожидают пока, она не перейдет в корректное состояние

var count$: sync int = 0;

begin count$ = count$ + 1;



5959

Методы переменных синхронизации

var x$: sync int;

var y$: single int;

var z: int;

x$ = 5; // full now

y$ = 6; // full now

z = x$ + y$; // x – empty, y - full

x$.writeEF(5); // Ждет empty -> записывает -> full

y$.writeEF(6); // Ждет empty -> записывает -> full

z = x$.readFE() + /* Ждет full -> читает -> empty */

y$.readFF(); /* Ждет full -> читает -> full */

readXX, readFE, readFF(), writeEF(), writeFF(),

reset(), isFull()

6060


cobegin {

stmt1();

stmt2();

stmt3();

}

var s1$, s2$, s3$: single bool;

begin { stmt1(); s1$ = true; } // s1 full



s1$; s2$; s3$; // wait for full state

var runningCount$: sync int = 1; // fullvar finished$: single bool;for i in iterator() {

runningCount$ += 1; // Number of tasks + 1 for mainbegin {

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$; 6161


coforall i in iterator()

loop_body();

6262

Числа Фибоначчи (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));

6363

Числа Фибоначчи (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));

6464

Data parallelism: reductions & scans

var A: [1..10] int;

A = 1;

var sum = + reduce A;

writeln(sum);

var A, B, C: [1..5] int;

A = 1; // A: 1 1 1 1 1

B = + scan A; // B: 1 2 3 4 5

B[3] = -B[3]; // B: 1 2 -3 4 5

C = min scan B; // C: 1 1 -3 -3 -3

Поддерживаемые операции:

+, *, &&, ||, &, |, ^, min, max, minloc, maxloc

6565

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

6666

Решение краевой задачи методом Якоби

Граничные условия

Крестообразный вычислительный шаблон

6767


config const n = 40; // Размер сетки

config const eps = 1E-2;

param Pi: real = 3.141592653589793238462643;

const BigD: domain(2) = {0..n + 1, 0..n + 1};

const D: subdomain(BigD) = {1..n, 1..n}; // Без внешних границ

const FirstRow: subdomain(BigD) = D.exterior(-1, 0);

const LastRow: subdomain(BigD) = D.exterior(1, 0);

const FirstCol: subdomain(BigD) = D.exterior(0, -1);

const LastCol: subdomain(BigD) = D.exterior(0, 1);

var grid, newgrid: [BigD] real;

proc main() {// Initial conditionsgrid[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;

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);}

6868


Single locale version (многопоточная)

6969

Транспонирование матрицы (PTRANS)

use BlockCycDist; // Блочно-циклическое распределение массивов

config type eltType = real(64);

config const numrows = 100, // Строк в матрицеnumcols = 100, // Столбцов в матрицеrowBlkSize = 8, // Строк в блокеcolBlkSize = 8, // Столбцов в блокеbeta = 1.0;

config const epsilon = 2.2e-16;

AT[i, j] = A[j, i]

7070


// // initArrays: инициализирует массивы//proc initArrays(A, C) {

forall (i, j) in A.domain doA[i, j] = erf(i) * cos(j);

forall (i, j) in C.domain doC[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 + abs(beta) * norm_C) * epsilon;

return error_tolerance;}

7171


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);

}

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);

}7272


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;

7373


Пример распределения матрицы по локалям

Locales: 8

Локалиорганизованы в массив 2x4 (см. BlockCyclic)

Каждой локаливыделено множество блоков по 8x8 элементов

0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 02 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 24 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 46 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 66 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 6 60 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 00 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 02 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 22 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 2 24 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 44 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 4 4

L0 L1 L0

L0

L0

L0

L0L1 L1

L1 L1 L1

L2 L2 L2

L2 L2 L2

L3 L3 L3

L3 L3 L3

L0

L2

L0

L2

L4 L4 L4 L4

L4L4 L4 L4

L5 L5 L5

L5 L5 L5

L6 L6 L6 L6L7 L7 L7

Документация и примеры

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

http://chapel.cray.com/tutorials.html

http://chapel.cray.com/language.html

http://chapel.cray.com/presentations.html

Открытые задачи

Развитие методов оптимизирующей компиляции

Оптимизация скрытых обменовОбнаружение паттернов последовательного доступа к удаленной памяти и укрупнение передаваемых блоков между узлами (аналог векторизации кода, предвыборка, …)

Совмещение вычислений и обменовСтатический анализ Chapel-программ для обнаружения участков кода, выполнение которых можно совместить с передачей информации (overlapping)

Развитие методов динамического управления легковесными задачами (task layer scheduling, hierarchical work stealing)

Развитие методов реализации переменных синхронизации (software transactional memory?)

…75

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

76

Technology

Язык параллельного программирования Cray Chapel