Инструкция по работе — Платформа "HybriLIT"

Обучающее видео «Запуск задач»
Программно-аппаратная среда платформы HybriLIT
Начало работы: удаленный вход на платформу
Планировщик задач SLURM
5 основных шагов для проведения расчетов на платформе
Компиляция и запуск OpenMP-приложений
Компиляция и запуск MPI-приложений
Компиляция и запуск CUDA-приложений
Компиляция и запуск гибридных приложений OpenMP+CUDA
Компиляция и запуск гибридных приложений MPI+CUDA
Компиляция и запуск гибридных приложений MPI+OpenMP
Компиляция и запуск OpenCL-приложений
Основные команды Linux
Инструкция по установке MobaXterm
Инструкция по использованию программы GNUPlot
Инструкция использования MATLAB в среде JupyterHub в рамках экосистемы ML/DL/HPC
Запуск Matlab скриптов в параллельном режиме (CPU) в среде JupyterHub

Обучающее видео «Запуск задач»

Полезные ссылки:

Рассказывает Максим Зуев, главный аналитик группы по гетерогенным вычислениям, ЛИТ ОИЯИ

Видеоматериалы подготовлены А.С. Воронцовым

Программно-аппаратная среда платформы HybriLIT

Гетерогенная вычислительная платформа HybriLIT состоит из Учебно-тестового полигона и суперкомпьютера «Говорун», работающих в единой программно-информационной среде.

Учебно-тестовый полигон содержит вычислительные узлы с многоядерными процессорами Intel, графическими процессорами Nvidia и сопроцессорами Intel Xeon Phi (Подробные характеристики в разделе «Аппаратное обеспечение«).

Типы основных вычислительных узлов:

Узлы с многоядерными CPU и сопроцессорами Intel Xeon Phi
Узлы с многоядерными CPU и 3 графическими ускорителями Nvidia Tesla K40
Узлы с многоядерными CPU и 2 (4) графическими ускорителями Nvidia Tesla K80
Mix-узел с многоядерными CPU и сопроцессорами Intel Xeon Phi и графическим ускорителем Nvidia Tesla K20

Гетерогенная платформа находится под управлением операционной системы Scientific Linux 7.9 , с планировщиком задач SLURM и установленным программным обеспечением: компиляторами и пакетами для разработки, отладки и профилировки параллельных приложений, а также пакетом Modules.

Пакет Modules

Для динамического изменения переменных окружения на платформе установлен пакет Modules 3.2.10. Данный пакет позволяет пользователю изменять список компиляторов для сборки приложений с поддержкой основных языков программирования (C/C++, FORTRAN, Java), технологий параллельного программирования (OpenMP, MPI, OpenCL, CUDA) и использовать установленные на платформе пакеты программ. Перед компиляцией приложения пользователю необходимо загрузить модули, необходимые для работы.

Основные команды для работы с модулями:

module avail - просмотреть список активных модулей;
module add [ИМЯ_МОДУЛЯ] - добавить модуль в список подключенных;
module list - просмотреть список подключенных модулей;
module rm [ИМЯ_МОДУЛЯ] - выгрузить модуль из списка подключенных;
module show [ИМЯ_МОДУЛЯ] - описание изменений, вносимых модулем.

module avail - просмотреть список активных модулей;

module add [ИМЯ_МОДУЛЯ] - добавить модуль в список подключенных;

module list - просмотреть список подключенных модулей;

module rm [ИМЯ_МОДУЛЯ] - выгрузить модуль из списка подключенных;

module show [ИМЯ_МОДУЛЯ] - описание изменений, вносимых модулем.

Загруженные модули не сохраняются между сессиями, если Вам нужно всегда использовать один набор модулей, допишите команду:

module add [ИМЯ_МОДУЛЯ] в файл ~/.bashrc.

1	module add [ИМЯ_МОДУЛЯ] в файл ~/.bashrc.

Также Вы можете подключить версии компиляторов и пакеты, которые установлены в системе cvmfs (CernVM File System).

CernVM File System

Добавление системы CernVM-FS к установленному списку программных пакетов позволяет получить доступ к установленному программному обеспечению CERN.
Список доступных пакетов можно посмотреть, выполнив команду:

ls /cvmfs/sft.cern.ch/lcg/releases

1	ls /cvmfs/sft.cern.ch/lcg/releases

Стоит отметить, что директория /cvmfs/sft.cern.ch/ монтируется динамически при обращении к ее содержимому и спустя некоторое время бездействия может исчезнуть из списка доступных директорий. Заново смонтировать ее можно, повторно выполнив команду

ls /cvmfs/sft.cern.ch/lcg/releases

1	ls /cvmfs/sft.cern.ch/lcg/releases

Для использования компиляторов и программных пакетов необходимо выполнить команду:

source [ПУТЬ_ДО_ФАЙЛА_С_ПЕРЕМЕННЫМИ_ОКРУЖЕНИЯ]

1	source [ПУТЬ_ДО_ФАЙЛА_С_ПЕРЕМЕННЫМИ_ОКРУЖЕНИЯ]

Директории в cvmfs имеют определенную структуру. Рассмотрим ее на примере пакета ROOT. Полный путь до директории будет выглядеть следующим образом:

/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.07.02-f644e/x86_64-slc6-gcc49-opt/

1	/cvmfs/sft.cern.ch/lcg/releases/ROOT/6.07.02-f644e/x86_64-slc6-gcc49-opt/

где /6.07.02-f644e – версия пакета ROOT, в названии директории /x86_64-slc6-gcc49-opt: x86_64 указывает на поддержку 64-битности пакета, slc6 – то, что компиляция пакета из исходного кода проводилась под Scientific Linux 6, gcc49 – пакет компилировался с применением gcc 4.9.9.
Файлы с переменными окружения могут иметь одно из двух имен:

setup.sh

Например, команда для использования компилятора gcc 4.9.3 будет выглядеть следующим образом

source /cvmfs/sft.cern.ch/lcg/releases/gcc/4.9.3/x86_64-slc6/setup.sh

1	source /cvmfs/sft.cern.ch/lcg/releases/gcc/4.9.3/x86_64-slc6/setup.sh

[ИМЯ_ПАКЕТА]-env.sh

Например, для пакета ROOT 6.18.00 команда будет выглядеть следующим образом

source /cvmfs/sft.cern.ch/lcg/releases/ROOT/6.07.02-f644e/x86_64-slc6-gcc49-opt/ROOT-env.sh

1	source /cvmfs/sft.cern.ch/lcg/releases/ROOT/6.07.02-f644e/x86_64-slc6-gcc49-opt/ROOT-env.sh

Начало работы: удаленный вход на платформу

Удаленный доступ к гетерогенной вычислительной платформе HybriLIT открыт только по протоколу SSH.
DNS адрес гетерогенной платформы:hydra.jinr.ru
Более подробная инструкция для подключения к платформе для различных операционных систем приведена ниже.

Для пользователей OS Linux

Запустите терминал и введите:

$ ssh USERNAME@hydra.jinr.ru

1	$ ssh USERNAME@hydra.jinr.ru

где USERNAME – логин, который Вы получили при регистрации, hydra.jinr.ru – адрес сервера. После требования системы ввести пароль — введите его. В случае успешной авторизации на платформе Вы увидите командную строчку на экране:

[USERNAME@hydra ~] $

1	[USERNAME@hydra ~] $

Это означает, что Вы подключились к платформе и находитесь в своем домашнем каталоге.
При первой попытке доступа появится уведомление о незнакомом IP-адресе, к которому Вы пытаетесь подключиться. Наберите yes, нажмите Enter, и этот адрес будет добавлен в список известных адресов.

Для запуска с поддержкой графического интерфейса введите в терминале

$ ssh -X USERNAME@hydra.jinr.ru
[USERNAME@hydra ~] $ ssh -X space31

1 2	$ ssh -X USERNAME@hydra.jinr.ru [USERNAME@hydra ~] $ ssh -X space31

Для пользователей OS Windows

Для подключения к платформе пользователей Windows необходимо использовать специальную программу – SSH-клиент, например, PuTTY.

Установка для программы PuTTY не требуется. Нужно просто скачать файл putty.exe по ссылке http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe в удобное место на компьютере и запустить его.

Ниже описана пошаговая процедура настройки PuTTY для доступа к платформе.

В поле Host Name (or IP address) введите адрес сервера: hydra.jinr.ru
В поле Saved Sessions введите предпочтительное имя для текущего подключения (например, hydra.jinr.ru).

Для подключения удаленного графического интерфейса X11 переходим на вкладку Connection SSH>X11 и выделяем поле Enable X11 forwarding

Проверяем, что на вкладке Connection > SSH > Tunnels выделено поле Local ports accept connections from other hosts

После этого возвращаемся во вкладку Session и нажимаем Save, чтобы сохранить все наши изменения.
Нажимаем Open для подключения к платформе HybriLIT и вводим логин и пароль, которые Вы получили при регистрации.

В случае успешной авторизации на платформе Вы увидите командную строчку на экране:

[USERNAME@hydra ~] $

1	[USERNAME@hydra ~] $

Это означает, что Вы подключились к платформе и находитесь в своем домашнем каталоге.
При первой попытке доступа появится уведомление о незнакомом IP-адресе, к которому Вы пытаетесь подключиться. Наберите yes , нажмите Enter, и этот адрес будет добавлен в список известных адресов.

Для запуска с поддержкой графического интерфейса введите

[USERNAME@hydra ~] $ ssh -X space3

1	[USERNAME@hydra ~] $ ssh -X space3

Планировщик задач SLURM

SLURM – это высоко масштабируемый отказоустойчивый менеджер кластеров и планировщик заданий с открытым кодом, который обеспечивает три основные функции:

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

1. Основные команды

К основным командам планировщика SLURM относятся: sbatch, scancel, sinfo, squeue, scontrol.

sbatch — команда для запуска приложения в режиме очереди

После запуска приложению присваивается персональный номер jobid, по которому его можно найти в списке запущенных приложений (squeue). Результат записывается в файл с именем slurm-jobid.out.
Пример использования sbatch:

[user@hydra] sbatch runscript.sh
Submitted batch job 141980

1 2	[user@hydra] sbatch runscript.sh Submitted batch job 141980

squeue — команда для просмотра списка запущенных приложений в очереди;

Одним из основных параметров списка является состояние приложений. Запущенное приложение может иметь одно из следующих состояний:

RUNNING (R) – выполняется;
PENDING (PD) – в очереди;
COMPLETING (CG) – завершается. (в этом состоянии, возможно, может понадобиться помощь системного администратора для удаления приложения из очереди).

Пример использования squeue:

[user@hydra] squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST
28727 cpu sb_12945 dmridu R 8-00:12:12 1 blade01
29512 gpu smd5a ygorshko R 2-04:13:11 1 blade04

[user@hydra] squeue

JOBID PARTITION NAME USER ST TIME NODES NODELIST

28727 cpu sb_12945 dmridu R 8-00:12:12 1 blade01

29512 gpu smd5a ygorshko R 2-04:13:11 1 blade04

sinfo — команда для просмотра состояния вычислительных узлов и очередей. Вычислительные узлы могут быть в одном из следующих состояний:

idle – узел свободен;
alloc – узел используется процессом;
mix – узел частично занят, частично свободен;
down, drain, drng – узел заблокирован.

Пример использования sinfo:

[user@hydra] sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
interactive* up 1-00:00:00 1 idle blade02
cpu up 1-00:00:00 2 mix blade[04-05]
cpu up 1-00:00:00 1 comp blade06
cpu up 1-00:00:00 1 mix blade07
cpu up 1-00:00:00 3 idle blade[01-03]
gpu up 1-00:00:00 1 comp blade06
gpu up 1-00:00:00 2 mix blade[07,10]
gpu up 1-00:00:00 1 idle blade08
tut up 1-00:00:00 1 mix blade09
long up 14-00:00:0 2 mix blade[04-05]

[user@hydra] sinfo

PARTITION AVAIL TIMELIMIT NODES STATE NODELIST

interactive* up 1-00:00:00 1 idle blade02

cpu up 1-00:00:00 2 mix blade[04-05]

cpu up 1-00:00:00 1 comp blade06

cpu up 1-00:00:00 1 mix blade07

cpu up 1-00:00:00 3 idle blade[01-03]

gpu up 1-00:00:00 1 comp blade06

gpu up 1-00:00:00 2 mix blade[07,10]

gpu up 1-00:00:00 1 idle blade08

tut up 1-00:00:00 1 mix blade09

long up 14-00:00:0 2 mix blade[04-05]

scancel — команда для удаления приложения из очереди.

Пример использования scancel для удаления из очереди приложения с jobid 141980:

[user@hydra] scancel 141980

1	[user@hydra] scancel 141980

scontrol — используется для просмотра или изменения состояния SLURM, включающего: задачи, узла и очереди. Многие из управляющих команд могут выполняться только суперпользователем.

Пример использования scontrol для просмотра характеристик запущенного приложения:

[user@hydra] scontrol show job 141980
JobId=141980 JobName=test
UserId=user(11111) GroupId=hybrilit(10001)
JobState=RUNNING Reason=None Dependency=(null)

[user@hydra] scontrol show job 141980

JobId=141980 JobName=test

UserId=user(11111) GroupId=hybrilit(10001)

JobState=RUNNING Reason=None Dependency=(null)

Список характеристик содержит такие параметры, как:

параметр	функция
UserId	имя пользователя
JobState	состояние приложения
RunTime	текущее время расчетов
Partition	используемая очередь
NodeList	используемые узлы
NumNodes	число используемых узлов
NumCPUs	число используемых ядер процессора
Gres	число используемых графических ускорителей или сопроцессоров
MinMemoryCPU	количество используемой оперативной памяти
Command	расположение файла для запуска приложения
StdErr	расположение файла с ошибками
StdOut	расположение файла с выходными данными

Пример использования scontrol для просмотра характеристик узлов:

[user@hydra] scontrol show nodes
[user@hydra] scontrol show node blade01

1 2	[user@hydra] scontrol show nodes [user@hydra] scontrol show node blade01

Список характеристик содержит такие параметры, как:
NodeName – hostname вычислительного узла;
CPUAlloc – количество загруженных вычислительных ядер;
CPUTot – общее число вычислительных ядер на узле;
CPULoad – загрузка вычислительных ядер;
Gres – число доступных для расчетов графических уcкорителей и сопроцессоров;
RealMemory – общее количество оперативной памяти на узле;
AllocMem – количество загруженной оперативной памяти;
State – состояние узла.

2. Очереди

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

На текущий момент HybriLIT содержит 6 очередей:

interactive* — включает 1 вычислительный узел с 2 Intel Xeon E5-2695 v2 12-cores, 1 NVIDIA Tesla K20X, 1 Intel Xeon Coprocessor 5110P (* означает, что очередь используется по умолчанию). Очередь подойдет для запуска тестовых программ. Время расчетов для этой очереди ограничено и составляет 1 день;
cpu — включает 7 вычислительных узла с 2 Intel Xeon E5-2695 v2 12-cores на каждом. Очередь подойдет для запуска приложений, использующих центральные процессоры для расчетов;
gpu — очередь включает 6 вычислительных узла: 3 NVIDIA Tesla K40 (Atlas) на каждом, 3 вычислительных узла с 2 NVIDIA Tesla K80 на каждом. Очередь подойдет для запуска приложений, использующих графические ускорители для расчетов;
long — очередь включает 2 вычислительных узла с NVIDIA Tesla. Очередь подойдет для запуска приложений, требующих длительных (до 14 дней) вычислений;

3. Описание и примеры script-файлов

Для запуска приложения с помощью команды sbatch требуется использовать script-файл. В общем случае, script-файл – это обычный bash файл, удовлетворяющий следующим правилам:

Первая строка содержит #!/bin/sh (или #!/bin/bash) , что позволяет скрипту быть запущенным как bash-script;
Строки, начинающиеся с # — это комментарии;
строки, начинающиеся с #SBATCH , устанавливают параметры для планировщика SLURM;
Все параметры планировщика SLURM должны быть установлены до непосредственного запуска приложения;
Script-файл содержит команду для запуска приложений.

SLURM имеет большое количество различных параметров (https://computing.llnl.gov/linux/slurm/sbatch.html). Ниже приведены параметры обязательные или рекомендованные для использования на платформе HybriLIT:

-p — используемая очередь. В случае отсутствия данного параметра задача будет поставлена в интерактивную очередь, время выполнения в которой ограничено 1 часом. В зависимости от типа используемых ресурсов приложение может быть запущено в одной из существующих очередей: cpu, phi, gpu, gpuK80;
-n — число используемых процессов;
-t — резервируемое время расчетов. Это обязательный параметр. Доступны следующие форматы: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
--gres — число резервируемых графических ускорителей NVIDIA или сопроцессоров Intel Xeon Phi. Это обязательный параметр для задач, использующих gpu или сопроцессоры Intel Xeon Phi;
--mem — резервируемая оперативная память, в мегабайтах. Это необязательный параметр, но если ваше приложение использует большое количество оперативной памяти, рекомендуется задать данный параметр;
-N – число используемых узлов. Этот параметр следует устанавливать только в том случае, если количество ресурсов на 1 узле недостаточно для выполнения вашего расчета;
-o – имя выходного файла. По умолчанию результат записывается в файл с именем slurm-jobid.out.

Ниже приведены примеры скриптов, использующие различные ресурсы платформы HybriLIT.

Для расчетов на CPU:

#!/bin/sh
#SBATCH -p cpu
#SBATCH -t 60
./a.out

#!/bin/sh

#SBATCH -p cpu

#SBATCH -t 60

./a.out

Для расчетов с использованием GPU:

#!/bin/sh
#SBATCH -p gpu
#SBATCH -t 60
#SBATCH -gres=gpu:2
./a.out

#!/bin/sh

#SBATCH -p gpu

#SBATCH -t 60

#SBATCH -gres=gpu:2

./a.out

Примеры script-файлов для различных технологий программирования будут приведены ниже в соответствующих разделах.

5 основных шагов для проведения расчетов на платформе

Для проведения расчетов на HybriLIT можно выделить 5 основных шагов:

Компиляция и запуск OpenMP-приложений

УЧЕБНОЕ ПОСОБИЕ «Основы технологии OpenMP на кластере HybriLIT».

OpenMP (Open Multi-Processing) — открытый стандарт для разработки многопоточных программ на языках С, С++ и Fortran. Содержит набор директив компилятора, библиотечных процедур и переменных окружения, которые предназначены для разработки многопоточных приложений на многопроцессорных системах с общей памятью. Программная модель — Fork-Join Model, которая заключается в следующем (Рис.1.):

Любая программа начинает работу в нулевом потоке (Master thread), далее нулевой поток создает (с помощью директив компилятора) группу потоков — FORK, которые выполняются параллельно, затем, по завершении работы порожденных потоков в параллельной области, происходит синхронизация — JOIN, и программа продолжает работу в основном потоке.

drawit-diagram-19

Рис.1. Программная модель Fork-Join.

Компиляция

Используются стандартные компиляторы с ключами поддержки OpenMP. Доступны компиляторы GNU и Intel. Доступны компиляторы GNU версии 4.8.5 (установлен по умолчанию), 4.9.3-1, 5.3.0-1, 6.2.0-2, 7.2.0-1, 8.2.0-1, 8.3.0, 9.1.0-1, 9.4.0, 10.2.0 и 11.2.0 с поддержкой OpenMP. Перед компиляцией с использованием Intel — компиляторов необходимо загрузить соответствующий модуль:

$ module add intel/v2018.1.163-9

1	$ module add intel/v2018.1.163-9

Ниже представлены команды для компиляции программ, написанных на С, С++ или Fortran для различных компиляторов:

	Intel	GNU	PGI
C	icc -qopenmp hello.c	gcc -fopenmp hello.c	pgcc -mp hello.c
C++	icpc -qopenmp hello.cpp	g++ -fopenmp hello.cpp	pgc++ -mp hello.cpp
Fortran	ifort -openmp hello.f	gfortran -fopenmp hello.f	pgfortran -mp hello.f

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

$ icc -qopenmp hello.c -o hello

1	$ icc -qopenmp hello.c -o hello

имя бинарного файла будет hello.

Запуск

Запуск OpenMP-приложений осуществляться с помощью script-файла, содержащего следующую информацию:

#!/bin/sh # используемый shell
#SBATCH -p cpu # выбор типа используемой очереди
#SBATCH -c 5 # установка числа вычислительных потоков
#SBATCH -t 60 # установка времени расчета
./test    # запуск приложения

#!/bin/sh # используемый shell

#SBATCH -p cpu # выбор типа используемой очереди

#SBATCH -c 5 # установка числа вычислительных потоков

#SBATCH -t 60 # установка времени расчета

./test # запуск приложения

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

$ export OMP_PLACES=cores

1	$ export OMP_PLACES=cores

Число OMP-нитей (потоков) может быть задано с помощью переменной окружения OMP_NUM_THREADS до выполнения программы в командной строке:

$ export OMP_NUM_THREADS=threads

1	$ export OMP_NUM_THREADS=threads

где threads — количество OMP-нитей.

Таким образом, рекомендуемый script-файл для OpenMP-приложений, например, с 5-ю потоками имеет вид:

#!/bin/sh
#SBATCH -p cpu
#SBATCH -c 5
#SBATCH -t 60
export OMP_NUM_THREADS=5
export OMP_PLACES=cores
./a.out

#!/bin/sh

#SBATCH -p cpu

#SBATCH -c 5

#SBATCH -t 60

export OMP_NUM_THREADS=5

export OMP_PLACES=cores

./a.out

Для запуска приложения используется следующая команда:

$ sbatch omp_script

1	$ sbatch omp_script

Компиляция и запуск MPI-приложений

Message Passing Interface (MPI, интерфейс для передачи сообщений) — программный интерфейс (API) для передачи информации, который позволяет обмениваться сообщениями между процессами, выполняющими одну задачу.

Для работы с MPI доступны компиляторы GNU и Intel.

*Опубликовано учебное пособие Практическое введение в технологию MPI на платформе HybriLIT (скачать файл).

Компиляторы GNU

MPI-программы могут компилироваться GNU-компиляторами с библиотекой OpenMPI. GNU-компиляторы устанавливаются на HybriLIT по умолчанию. Для доступа к OpenMPI-библиотекам нужно добавить подходящий модуль 1.8.8, 2.1.2, 3.1.2 или 3.1.3:

$ module add openmpi/v1.8.8-1

1	$ module add openmpi/v1.8.8-1

$ module add openmpi/v2.1.2-1

1	$ module add openmpi/v2.1.2-1

$ module add openmpi/v3.1.2-1

1	$ module add openmpi/v3.1.2-1

$ module add openmpi/v3.1.3-1

1	$ module add openmpi/v3.1.3-1

или

$ module add openmpi/v4.1.1

1	$ module add openmpi/v4.1.1

Компиляция

Ниже представлены команды для компиляции программ, написанных на С, С++ или Fortran для GNU-компилятора:

Язык программирования	Команды вызова компилятора
C	mpicc
C++	mpiCC / mpic++ / mpicxx
Fortran 77	mpif77 / mpifort (*)
Fortran 90	mpif90 / mpifort (*)

(*) Рекомендуется использовать команду mpifort вместо mpif77 или mpif90, которые считаются устаревшими. С помощью mpifort можно компилировать любые Fortran-программы, использующие в качестве интерфейса « mpif.h » или « use mpi «.

Пример компиляции программы на языке С:

$ mpicc example.c

1	$ mpicc example.c

Если не задавать имя исполняемого файла, получаемого после успешной компиляции, ему по умолчанию присваивается имя a.out .

Для запуска программы с использованием модулей OpenMPI используется script:

#!/bin/sh
# Пример скрипта для использования OpenMPI:
# Выбор очереди, в которую будет отправлена задача
#SBATCH -p cpu
# Запуск MPI задачи на 2 узла, по 3 MPI-процесса на узел
#SBATCH --nodes=2
# Количество узлов
#SBATCH --ntasks-per-node=3  # количество MPI-процессов на узел
#
# Установка времени работы программы в формате:
# минуты
# минуты:секунды
# дни-часы
# дни-часы:минуты:секунды
#SBATCH -t 60
# время выполнения программы в минутах
#
# запуск программы на счет:
mpirun ./a.out

#!/bin/sh

# Пример скрипта для использования OpenMPI:

# Выбор очереди, в которую будет отправлена задача

#SBATCH -p cpu

# Запуск MPI задачи на 2 узла, по 3 MPI-процесса на узел

#SBATCH --nodes=2

# Количество узлов

#SBATCH --ntasks-per-node=3 # количество MPI-процессов на узел

# Установка времени работы программы в формате:

# минуты

# минуты:секунды

# дни-часы

# дни-часы:минуты:секунды

#SBATCH -t 60

# время выполнения программы в минутах

# запуск программы на счет:

mpirun ./a.out

Intel-компилятор

Для использования MPI с Intel-компилятором нужно добавить модуль

$ module add intel/v2018.1.163-9

1	$ module add intel/v2018.1.163-9

MPI-библиотека входит в состав этого модуля.

Компиляция

Ниже представлены команды для компиляции программ, написанных на С, С++ или Fortran для Intel-компилятора:

Язык программирования	Команды вызова компилятора
C	mpiicc
C++	mpiicpc
Fortran	mpiifort

Пример компиляции программы на языке Fortran:

$ mpiifort example.f

1	$ mpiifort example.f

Опции оптимизации компиляторов:

Опция	Назначение
-O0	*без оптимизации; используется по умолчанию для GNU-компилятора*
-O2	*используется по умолчанию для Intel-компилятора*
-O3	может быть эффективна для определенного класса программ
-march=native -march=core2	*настройка на архитектуру процессоров (использование дополнительных возможностей процессоров Intel)*

Запуск задачи на счет

В счетном режиме запуск задачи на счет осуществляется планировщиком SLURM командой:

$ sbatch script_mpi

1	$ sbatch script_mpi

где script_mpi – имя заранее заготовленного script-файла, содержащего «паспорт задачи».

Пример script-файла для запуска MPI-приложений на двух вычислительных узлах

Далее приведены два способа распределения MPI процессов по вычислительным узлам.

Пример использования комбинации ключей --tasks-per-node и -n : задается 10 процессов ( -n 10 ) по 5 процессов на один вычислительный узел ( --tasks-per-node=5). Таким образом, вычислительная работа распределяется по 2 вычислительным узлам:

#!/bin/sh
#задание входной очереди задач для MPI-программ:
#SBATCH -p cpu
#выделение нужного числа процессоров (ядер),
#равного числу параллельных процессов:
#SBATCH -n 10
#задание количества процессов на узел:
#SBATCH --tasks-per-node=5
#установка ограничения на время выполнения расчета:
#Доступны следующие форматы: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#задание своего имени файла для листинга задачи:
#SBATCH -o output.txt
#запуск на счет:
mpirun ./a.out

#!/bin/sh

#задание входной очереди задач для MPI-программ:

#SBATCH -p cpu

#выделение нужного числа процессоров (ядер),

#равного числу параллельных процессов:

#SBATCH -n 10

#задание количества процессов на узел:

#SBATCH --tasks-per-node=5

#установка ограничения на время выполнения расчета:

#Доступны следующие форматы: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#задание своего имени файла для листинга задачи:

#SBATCH -o output.txt

#запуск на счет:

mpirun ./a.out

Пример использования комбинации ключей --tasks-per-node и -N: задается по 5 процессов на один вычислительный узел ( --tasks-per-node=5 ) и количество узлов ( -N 2 ). Таким образом, создается 10 процессов и вычислительная работа распределяется по 2 узлам:

#!/bin/sh
#задание входной очереди задач для MPI-программ:
#SBATCH -p cpu
#выделение нужного числа процессоров (ядер),
#равного числу параллельных процессов на узел:
#SBATCH --tasks-per-node=5
#запуск процессов на 2 вычислительных узлах (**):
#SBATCH -N 2
#установка ограничения на время выполнения расчета:
#Доступны следующие форматы: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#задание своего имени файла для output-файла:
#SBATCH -o output.txt
#запуск на счет:
mpirun ./a.out

#!/bin/sh

#задание входной очереди задач для MPI-программ:

#SBATCH -p cpu

#выделение нужного числа процессоров (ядер),

#равного числу параллельных процессов на узел:

#SBATCH --tasks-per-node=5

#запуск процессов на 2 вычислительных узлах (**):

#SBATCH -N 2

#установка ограничения на время выполнения расчета:

#Доступны следующие форматы: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#задание своего имени файла для output-файла:

#SBATCH -o output.txt

#запуск на счет:

mpirun ./a.out

Дополнительные узлы (**) имеет смысл заказывать, если для решения задачи требуется большое число параллельных процессов (больше 24).

Пример простейшего script-файла, в котором из множества возможных SLURM-директив фигурируют только самые необходимые:

#!/bin/sh
#SBATCH -p cpu
#SBATCH -n 7
#SBATCH -t 60
mpirun ./a.out

#!/bin/sh

#SBATCH -p cpu

#SBATCH -n 7

#SBATCH -t 60

mpirun ./a.out

Здесь исполняемый файл a.out, изготовленный компилятором, отправляется во входную очередь задач, предназначенных для счета на cpu-подмножестве платформы HybriLIT. Задача требует 7 ядер. Задача получит уникальный номер во входной очереди. Пусть это будет 1234. Тогда листинг задачи будет оформлен как файл slurm-1234.out в той же директории, где находился ее исполняемый файл a.out.

В программе на языке Fortan для подключения MPI-процедур обычно используется оператор Include ‘mpif.h’ , который можно заменить на более функциональный вариант – модуль mpi.mod, подключаемый командой Use mpi.

При запуске задачи на счет

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

Компиляция и запуск CUDA-приложений

CUDA (Compute Unified Device Architecture) — программно-аппаратная архитектура параллельных вычислений, которая позволяет существенно увеличить вычислительную производительность благодаря использованию графических процессоров фирмы NVIDIA (GPU).

Доступные версии CUDA

Наиболее эффективной технологией, позволяющей использовать графические процессоры NVIDIA, является платформа параллельных вычислений Compute Unified Device Architecture (CUDA), обеспечивающая набор расширений для языков C/С++ , Fortran.

Для разработки параллельных приложений (отладки, профилирования и компиляции), использующих графические процессоры NVIDIA Telsa на платформе HybriLIT, доступны два компилятора с поддержкой CUDA:

Реализация CUDA для языка C/C++ компании NVIDIA, основанная на компиляторе с открытым исходным кодом Open64: компилятор nvcc.
Реализация CUDA для Fortran c закрытой лицензией от компании Portland Group Inc. (PGI): pgfortran

Компиляция CUDA C/C++ приложений

На платформе доступны следующие версии CUDA, подключаемые через соответствующие модули пакета MODULES:

Версия CUDA	Подключаемый модуль
8.0	$ module add cuda/v8.0-1
9.2	$ module add cuda/v9.2
10.0	$ module add cuda/v10.0-1
10.1	$ module add cuda/v10.1-1
11.4	$ module add cuda/v11.4

Для проведения расчетов с использованием графических ускорителей доступны три представителя семейства графических ускорителей NVIDIA Tesla: Tesla K20X, Tesla K40, Tesla K80. Согласно принятой NVIDIA системе наименования архитектур, графические процессоры именуют как sm_xy , где х обозначает число GPU-поколения, у — версии в этом поколении. Графические процессоры Tesla K20 и Tesla K40 имеют архитектуру sm_35 , а процессоры Tesla K80 — sm_37 .

CUDA 8.0, 9.2, 10.0, 10.1, 11.4, 12.1

Для компиляции CUDA-приложений, поддерживающей все имеющиеся на платформе архитектуры, можно использовать одну команду для компиляции (для CUDA версий, начиная с 8.0):

$ nvcc app.cu  --gpu-architecture=compute_35 --gpu-code=sm_35,sm_37

1	$ nvcc app.cu --gpu-architecture=compute_35 --gpu-code=sm_35,sm_37

Компиляция приложений с использованием библиотек CUDA

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

библиотека для матрично-векторных операций cuBLAS – реализация библиотеки BLAS (Basic Linear Algebra Subprograms);
библиотека CUFFT, реализация быстрого преобразования Фурье (FFT), которая состоит из двух отдельных библиотек: CUFFT и cuFFTW;
библиотека cuRAND, предоставляющая средства для эффективной генерации высококачественных псевдослучайных и квазислучайных чисел;
библиотека cuSPARSE, предназначенная для операций с разряженными матрицами, например, для решения систем линейных алгебраических уравнений с матрицей системы, имеющей ленточную структуру.

Более подробная информация доступна по ссылке: http://docs.nvidia.com/cuda/

Ниже представлен пример компиляции приложений с функциями из библиотеки cuBLAS и cuFFT:

$ nvcc app.cu -lcublas -lcufft --gpu-architecture=compute_35 --gpu-code=sm_35

1	$ nvcc app.cu -lcublas -lcufft --gpu-architecture=compute_35 --gpu-code=sm_35

Как видно из этой строки компиляции, необходимо только добавить ключи -lcublas -lcufft.

Запуск GPU-приложений на платформе в системе SLURM

Для запуска приложений, использующих графические ускорители, в пакетном режиме в системе SLURM необходимо указать в запускаемом script-файле следующие обязательные параметры/опции:

имя соответствующей очереди, в зависимости от типа GPU (см. п.1.3.2). Например, для использования в расчетах графических ускорителей NVIDIA Tesla K80 , в script-файл надо добавить строку:

#SBATCH -p gpuK80

1	#SBATCH -p gpuK80

количество требуемых графических процессоров (GPU), которое задается опцией

--gres (Generic сonsumable RESources) в виде:

--gres=gpu <кол-во GPU на одном узле>

1	--gres=gpu <кол-во GPU на одном узле>

Например, для использования 3GPU на одном узле, в script-файл надо добавить строку:

#SBATCH --gres=gpu:3

1	#SBATCH --gres=gpu:3

Для использования в расчетах большего количества GPU, чем на одном узле, в script-файл надо добавить две строки:

#SBATCH --nodes=2
#SBATCH --gres=gpu:3

1 2	#SBATCH --nodes=2 #SBATCH --gres=gpu:3

В этом случае будет задействовано 2 вычислительных узла с 3 графическими процессорами на каждом, суммарно 6GPU.

Особенности вычислений с использованием ускорителя NVIDIA K80.

Графический ускоритель Tesla K80 является двухпроцессорным устройством (два графических процессора в одном устройстве) и обладает почти в два раза более высокой производительностью и вдвое более широкой полосой пропускания памяти по сравнению с предшественником — Tesla K40.

Для задействования 2 процессоров ускорителя Tesla K80 в script-файле необходимо указать параметр --gres=gpu:2 .

Приложения, использующие один графический процессор

Ниже представлены общие script-файлы для запуска приложений с использованием графического ускорителя NVIDIA Tesla K40:

#!/bin/sh
# Example for one-GPU applications
#
# Set the partition where the job will run:
#SBATCH -p gpu
#
#Set the number of GPUs per node
#SBATCH --gres=gpu:1
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Submit a job for execution:
./testK40
#
# End of submit file

#!/bin/sh

# Example for one-GPU applications

# Set the partition where the job will run:

#SBATCH -p gpu

#Set the number of GPUs per node

#SBATCH --gres=gpu:1

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Submit a job for execution:

./testK40

# End of submit file

и одного процессора ускорителя Tesla K80 в пакетном режиме в системе SLURM:

#!/bin/sh
# Example  for one-GPU applications
#
# Set the partition where the job will run:
#SBATCH -p gpuK80
#
#Set the number of GPUs per node
#SBATCH --gres=gpu:1
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Submit a job for execution:
./testK80
#
# End of submit file

#!/bin/sh

# Example for one-GPU applications

# Set the partition where the job will run:

#SBATCH -p gpuK80

#Set the number of GPUs per node

#SBATCH --gres=gpu:1

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Submit a job for execution:

./testK80

# End of submit file

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

несколько GPU на одном вычислительном узле;
несколько вычислительных узлов с графическими процессорами.

Для эффективного использования нескольких графических ускорителей разрабатываются гибридные приложения, например, OpenMP+CUDA, MPI+CUDA, MPI+OpenMP+CUDA и т.п. Более подробную информацию можно найти в проекте GitLab “Parallel features”: https://gitlab-hybrilit.jinr.ru/

Компиляция и запуск гибридных приложений OpenMP+CUDA

В данном разделе представлен пример запуска приложения, использующего несколько графических процессоров (multi-GPU application) на одном узле. Например, такое приложение может быть написано с использованием двух технологий параллельного программирования OpenMP+CUDA, в котором каждому потоку/нити (OpenMP-thread) ставится в соответствие один графический процессор.

При использовании в расчетах ускорителей NVIDIA Tesla K40:

#!/bin/sh
# Example for multi-GPU applications,
# job running on a single node
#
# Set the partition where the job will run:
#SBATCH -p gpu
#
#Set the number of GPUs per node
# (maximum 3 ):
#SBATCH --gres=gpu:3
#
#Set number of cores per task
#SBATCH -c 3
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Set OMP_NUM_THREADS to the same
# value as -c
if [ -n "$SLURM_CPUS_PER_TASK" ]; then
omp_threads=$SLURM_CPUS_PER_TASK
else
omp_threads=1
fi
export OMP_NUM_THREADS=$omp_threads
#
#Submit a job for execution:
srun ./testK40
#
# End of submit file

#!/bin/sh

# Example for multi-GPU applications,

# job running on a single node

# Set the partition where the job will run:

#SBATCH -p gpu

#Set the number of GPUs per node

# (maximum 3 ):

#SBATCH --gres=gpu:3

#Set number of cores per task

#SBATCH -c 3

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Set OMP_NUM_THREADS to the same

# value as -c

if [ -n "$SLURM_CPUS_PER_TASK" ]; then

omp_threads=$SLURM_CPUS_PER_TASK

else

omp_threads=1

export OMP_NUM_THREADS=$omp_threads

#Submit a job for execution:

srun ./testK40

# End of submit file

При использовании в расчетах ускорителей NVIDIA Tesla K80:

#!/bin/sh
# Example for multi-GPU applications,
# job running on a single node
#
# Set the partition where the job will run:
#SBATCH -p gpuK80
#
#Set the number of GPUs per node
# (maximum 4 - K80=2 x K40):
#SBATCH --gres=gpu:4
#
#Set number of cores per task
#SBATCH -c 4
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Set OMP_NUM_THREADS to the same
# value as -c
if [ -n "$SLURM_CPUS_PER_TASK" ]; then
omp_threads=$SLURM_CPUS_PER_TASK
else
omp_threads=1
fi
export OMP_NUM_THREADS=$omp_threads
#
#Submit a job for execution:
srun ./ testK80
#
# End of submit file

#!/bin/sh

# Example for multi-GPU applications,

# job running on a single node

# Set the partition where the job will run:

#SBATCH -p gpuK80

#Set the number of GPUs per node

# (maximum 4 - K80=2 x K40):

#SBATCH --gres=gpu:4

#Set number of cores per task

#SBATCH -c 4

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Set OMP_NUM_THREADS to the same

# value as -c

if [ -n "$SLURM_CPUS_PER_TASK" ]; then

omp_threads=$SLURM_CPUS_PER_TASK

else

omp_threads=1

export OMP_NUM_THREADS=$omp_threads

#Submit a job for execution:

srun ./ testK80

# End of submit file

Компиляция и запуск гибридных приложений MPI+CUDA

В данном разделе представлен пример запуска приложения, использующего несколько графических процессоров (multi-GPU application) на нескольких вычислительных узлах. Например, такое приложение может быть написано с использованием двух технологий параллельного программирования MPI+CUDA, в котором каждому процессу ставится в соответствие один графический процессор, при этом явно указано количество процессов на узел.

При использовании в расчетах ускорителей NVIDIA Tesla K40:

#!/bin/sh
# Example for GPU applications
#
# Set the partition where the job will run:
#SBATCH -p gpu
#
# Set the number of nodes (maximum 4):
#SBATCH --nodes=2
#
#Specifies the number of GPU per node
# (maximum 3 ):
#SBATCH --gres=gpu:3
#
# Set number of MPI tasks
#SBATCH -n 6
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Submit a job for execution:
mpirun ./testK40mpiCuda
#
# End of submit file

#!/bin/sh

# Example for GPU applications

# Set the partition where the job will run:

#SBATCH -p gpu

# Set the number of nodes (maximum 4):

#SBATCH --nodes=2

#Specifies the number of GPU per node

# (maximum 3 ):

#SBATCH --gres=gpu:3

# Set number of MPI tasks

#SBATCH -n 6

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Submit a job for execution:

mpirun ./testK40mpiCuda

# End of submit file

При использовании в расчетах ускорителей NVIDIA Tesla K80:

#!/bin/sh
# Example  for GPU applications
#
# Set the partition where the job will run:
#SBATCH -p gpuK80
#
# Set the number of nodes (maximum 2):
#SBATCH --nodes=2
#
#Specifies the number of GPU per node
# (maximum 4  - K80=2 x K40):
#SBATCH --gres=gpu:4
#
# Set number of MPI tasks
#SBATCH -n 8
#
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
#
#Submit a job for execution:
mpirun ./testK80mpiCuda
#
# End of submit file

#!/bin/sh

# Example for GPU applications

# Set the partition where the job will run:

#SBATCH -p gpuK80

# Set the number of nodes (maximum 2):

#SBATCH --nodes=2

#Specifies the number of GPU per node

# (maximum 4 - K80=2 x K40):

#SBATCH --gres=gpu:4

# Set number of MPI tasks

#SBATCH -n 8

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

#Submit a job for execution:

mpirun ./testK80mpiCuda

# End of submit file

Компиляция и запуск гибридных приложений MPI+OpenMP

Пожалуй, наиболее эффективным средством разработки гибридных алгоритмов является комбинация технологий MPI и OpenMP. Рассмотрим пример компиляции и запуска MPI+OpenMP программы на архитектурах SkyLake и KNL.

Для этого добавим mpi-модуль:

$ module add openmpi/v*.*

1	$ module add openmpi/v.

или

$ module add intel/v*.*

1	$ module add intel/v.

где *.* — номер версии.

Для компиляции можно воспользоваться компиляторами mpic++:

$ mpic++ HelloWorld_MpiOmp.cpp -fopenmp

1	$ mpic++ HelloWorld_MpiOmp.cpp -fopenmp

или mpiicpc:

$ mpiicpc HelloWorld_MpiOmp.cpp -fopenmp

1	$ mpiicpc HelloWorld_MpiOmp.cpp -fopenmp

Запуск MPI+OpenMP-приложения на архитектуре SkyLake воспользоваться следующим скриптом:

#!/bin/sh
#SBATCH -p skylake # Partition name
#SBATCH --nodes=2 # Number of nodes
#SBATCH --ntasks-per-node=2 # Number of tasks per node
#SBATCH --cpus-per-task=2 # Number of OpenMP threads for each MPI process
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
mpirun ./a.out

#!/bin/sh

#SBATCH -p skylake # Partition name

#SBATCH --nodes=2 # Number of nodes

#SBATCH --ntasks-per-node=2 # Number of tasks per node

#SBATCH --cpus-per-task=2 # Number of OpenMP threads for each MPI process

export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

mpirun ./a.out

В данном скрипте запрашивается запуск программы на двух узлах по два MPI-процесса каждый и по две OpneMP-нити на каждый MPI-процесс. После запуска приложения

$ sbatch script_sl.sh

1	$ sbatch script_sl.sh

получим в выходном файле следующие сообщения:

Hello from thread 0 out of 2 from process 0 out of 4 on SkyLake (node n02p001.gvr.local)
Hello from thread 1 out of 2 from process 0 out of 4 on SkyLake (node n02p001.gvr.local)
Hello from thread 0 out of 2 from process 1 out of 4 on SkyLake (node n02p001.gvr.local)
Hello from thread 1 out of 2 from process 1 out of 4 on SkyLake (node n02p001.gvr.local)
Hello from thread 0 out of 2 from process 2 out of 4 on SkyLake (node n02p002.gvr.local)
Hello from thread 1 out of 2 from process 2 out of 4 on SkyLake (node n02p002.gvr.local)
Hello from thread 0 out of 2 from process 3 out of 4 on SkyLake (node n02p002.gvr.local)
Hello from thread 1 out of 2 from process 3 out of 4 on SkyLake (node n02p002.gvr.local)

Hello from thread 0 out of 2 from process 0 out of 4 on SkyLake (node n02p001.gvr.local)

Hello from thread 1 out of 2 from process 0 out of 4 on SkyLake (node n02p001.gvr.local)

Hello from thread 0 out of 2 from process 1 out of 4 on SkyLake (node n02p001.gvr.local)

Hello from thread 1 out of 2 from process 1 out of 4 on SkyLake (node n02p001.gvr.local)

Hello from thread 0 out of 2 from process 2 out of 4 on SkyLake (node n02p002.gvr.local)

Hello from thread 1 out of 2 from process 2 out of 4 on SkyLake (node n02p002.gvr.local)

Hello from thread 0 out of 2 from process 3 out of 4 on SkyLake (node n02p002.gvr.local)

Hello from thread 1 out of 2 from process 3 out of 4 on SkyLake (node n02p002.gvr.local)

Видно, что как OpenMP-нити приветствуют мир представляются своим идентификационным номеров внутри MPI-процесса и сообщают на каком узле они родились.

Проведем запуск приложения на архитектуре KNL со следующим скриптом:

#!/bin/sh
#SBATCH -p knl # Partition name
#SBATCH --nodes=1 # Number of nodes
#SBATCH --ntasks-per-node=2 # Number of tasks per node
#SBATCH --cpus-per-task=3 # Number of OpenMP threads for each MPI process
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
mpirun ./a.out

#!/bin/sh

#SBATCH -p knl # Partition name

#SBATCH --nodes=1 # Number of nodes

#SBATCH --ntasks-per-node=2 # Number of tasks per node

#SBATCH --cpus-per-task=3 # Number of OpenMP threads for each MPI process

export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

mpirun ./a.out

В SLURM-скрипте запрашивается запуск в очереди KNL на одном узле с двумя MPI-процессами и тремя OpenMP-нитями на каждый MPI-процесс.

После запуска приложения

$ sbatch script_knl.sh

1	$ sbatch script_knl.sh

увидим следующее сообщение в выходном файле:

Hello from thread 1 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)
Hello from thread 0 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)
Hello from thread 2 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)
Hello from thread 0 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)
Hello from thread 1 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)
Hello from thread 2 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 1 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 0 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 2 out of 3 from process 0 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 0 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 1 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)

Hello from thread 2 out of 3 from process 1 out of 2 on KNL (node n01p005.gvr.local)

Видно как OpenMP-нити приветствуют мир, заметим, что они все выполнялись на одном узле.

Скачать программу и ознакомиться с ней можно по адресу: https://gitlab-hlit.jinr.ru/ayriyan/mpiomp

Компиляция и запуск OpenCL-приложений

Open Computing Language (OpenCL) — язык программирования высокого уровня, основанный на стандарте C99, для разработки параллельных программ, использующих различные вычислительные устройства: графические процессоры, центральные процессоры и другие. При этом параллелизм обеспечивается как на уровне инструкций, так и на уровне данных.

OpenCL является открытым стандартом и поддерживается консорциумом Khronos Group, в который входят крупнейшие IT-компании, включая Intel, NVIDIA и многие другие. Таким образом, программы, написанные на языке OpenCL, могут выполняться практически на всех вычислительных устройствах.

Компиляция приложений, написанных на языке OpenCL

Приложения, написанные на языке OpenCL, могут быть скомпилированы и запущены на различных платформах. Рассмотрим для нашего случая платформу NVIDIA. Для этого необходимо подключить одну из доступных на платформе версий CUDA, используя пакетный модуль MODULES:

$ module add hlit/cuda/*.*

1	$ module add hlit/cuda/.

где *.* — номер версии от 8.0 и выше.

Для компиляции можно воспользоваться различными компиляторами, например, компилятором GCC:

$ gcc helloWorld.c -lOpenCL

1	$ gcc helloWorld.c -lOpenCL

При компиляции необходимо добавлять опцию -lOpenCL .

После завершения компиляции в текущей директории появится исполняемый файл с именем a.out по умолчанию. Для задания другого имени исполняемому файлу нужно использовать команду:

$ gcc helloWorld.c -o helloWorld.out -lOpenCL

1	$ gcc helloWorld.c -o helloWorld.out -lOpenCL

Тогда исполняемый файл получит название helloWorld.out .

Запуск OpenCL-приложений

Для запуска приложений необходимо воспользоваться следующим скриптом:

#File name script_gpu
# Example for one-GPU applications
#!/bin/sh
# Set the partition where the job will run:
#SBATCH -p gpu
# Set the number of GPUs per node
#SBATCH --gres=gpu:1
# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;
#SBATCH -t 60
# Submit a job for execution:
srun ./helloWorld.out
# End script

#File name script_gpu

# Example for one-GPU applications

#!/bin/sh

# Set the partition where the job will run:

#SBATCH -p gpu

# Set the number of GPUs per node

#SBATCH --gres=gpu:1

# Set time of work: Avaliable following formats: minutes, minutes:seconds, hours:minutes:seconds, days-hours, days-hours:minutes, days-hours:minutes:seconds;

#SBATCH -t 60

# Submit a job for execution:

srun ./helloWorld.out

# End script

Приложения запускается командой:

$ sbatch script_gpu

1	$ sbatch script_gpu

После запуска задача получит номер:

Submitted batch job XXXXX

1	Submitted batch job XXXXX

После завершения расчетов в текущей директории будет создан файл slurm-XXXXX.out (где XXXXX — номер задачи), который будет содержать выходные данные программы.

Основные команды Linux

Команда	Описание
man <имя_команды>	после вводе этой команды на экране появляется информация о команде
man -k <ключевое_слово>	получить список команд, к которым относится данное <ключевое слово>
Простейшие действия:
ls	получить список файлов в текущем каталоге
ls -la	получить подробный список, включая скрытые файлы
cd <каталог>	сменить текущий каталог. Если имя каталога не указывается, то текущим становится домашний каталог пользователя
cp <что_копировать> <куда_копировать>	копировать файлы
mv <что_перемещать> <куда_перемещать>	переместить или переименовать файл
ln -s <на_что_сделать_ссылку> <имя_ссылки>	создать символьную ссылку
rm <файл(ы)>	удалить файл(ы)
rm -r <директория>	удалить директорию, с параметорм <-r> — рекурсивно
cat <имя_файла>	вывод содержимого файла на стандартный вывод (по умолчанию — на экран)
more <имя_файла>	вывод содержимого файла на стандартный вывод (по умолчанию — на экран)
less <имя_файла>	просмотр содержимого текстового файла с возможностью вернуться к предыдущим страницам. Нажатие q означает выход из программы
find <каталог> -name <имя_файла>	найти файл <имя_файла> в <каталоге> и отобразить результат на экране
tar -zxvf <файл>	распаковать архив tgz или tar.gz
nano <имя_файла>	редактировать текстовый файл с помощью текстового редактора nano
vim <имя_файла>	редактировать текстовый файл с помощью текстового редактора vim
pico <имя_файла>	редактировать текстовый файл с помощью текстового редактора pico
mc	запустить программу управления файлами MidnightCommander
manmc	вывести описание опций MidnightCommander
Стандартные команды:
pwd	вывести имя текущего каталога
whoami	вывести имя, под которым Вы зарегистрированы
date	вывести текущие дату и время
time <имя программы>	выполнить программу и получить информацию о времени, нужном для ее выполнения
ps -a	вывести список текущих процессов в текущем сеансе работы
chmod <права доступа><файл>	изменить права доступа к файлу, владельцем которого Вы являетесь
*Есть три способа доступа к файлу:
-чтение	—read
-запись	— write
-исполнение	— execute
Отсутствие права доступа показывается как	«-«
и три типа пользователей:
— владелец файла	(u)
— члены группы владельца	(g)
— все остальные	(o)
Пример:
chmod a+r zara	Эта команда позволит Вам установить права доступа на чтение для файла zara для всех (all=user+group+others)
chmod o-x zara	Эта команда отнимет право доступа на исполнение файла у всех, кроме пользователя и группы
chown <новый_владелец> <файлы>	изменить владельца файлов
chgrp <новая_группа> <файлы>	изменить группу принадлежности для файлов
ls -l <имя_файла>	проверить текущие права доступа если файл доступен всем пользователям, то напротив имени файла будет следующая комбинация букв: rwxrwxrwx*
Контроль процессов:
<имя_файла> \| grep < фрагмент>	поиск <фрагмента> текста в файле <имя_файла>
man grep	справка о команде
ps axu \| grep <Ваше_имя_пользователя>	отобразить все процессы, запущенные в системе от Вашего_имени_пользователя
kill <номер процесса>	принудительно завершить («убить») процесс с заданным номером
killall <имя_программы>	«убить» все процессы по имени программы

Инструкция по установке MobaXterm

1. По ссылке http://mobaxterm.mobatek.net/download-home-edition.html можно на выбор скачать портативную версию программы, не требующую установки (синяя кнопка), и версию с установщиком. Далее рассмотрим версию с установкой.

2. После скачивания установщика на компьютер, открыть файл MobaXterm_Setup_XX.exe и следовать стандартным шагам установки программы.

3. По завершению установки на рабочем столе появится ярлык для запуска программы.

4. Запустите ее и в верхнем меню в разделе Sessions выберите New session

5. Введите в поле Remote host адрес сервера hydra.jinr.ru и нажмите OK

6. Откроется новая вкладка, где Вам надо будет ввести логин и пароль для доступа на платформу. И в случае успешной авторизации на платформе Вы увидите командную строчку на экране:

[USERNAME@hydra ~] $

Инструкция по использованию программы GNUPlot

GNUPlot имеет собственную систему команд, может работать интерактивно (в режиме командной строки) и выполнять скрипты, читаемые из файлов.
Также используется в качестве системы вывода изображений в различных математических пакетах: GNU Octave, Maxima, Reduce и других.

Запуск GNUPlot осуществляется с виртуальной машины space31, для подключения к виртуальной машине ипользуйте команду ssh space31.

После подключения к виртуальной машине, чтобы запустить GNUPlot введите команду:

gnuplot44

gnuplot44

Для построения графика необходимо ввести команду:

plot

plot

и указать функцию которую вы хотите напечатать. Ниже приведен список наиболее популярных функций.

abs(x) модуль x, |x|
acos(x) арккосинус x
asin(x) арксинус x
atan(x) арктангенс x
cos(x) косинус x, x в радианах.
cosh(x) гиперболический косинус x, x в радианах
erf(x) функция ошибки x
exp(x) экспоненциальная функция x, от e
inverf(x) обратная функция ошибок x
invnorm(x) обратное нормальное распределение x
log(x) log x, от e
log10(x) log x, от 10
norm(x) нормальное распределение Гаусса
rand(x) псевдослучайный генератор чисел
sgn(x) 1 если x > 0, -1 если x < 0, 0 если x=0
sin(x) синус x, x в радианах
sinh(x) гиперболический синус x, x в радианах
sqrt(x) квадратный корень x
tan(x) тангенс x, x в радианах
tanh(x) гиперболический тангенс x, x в радианах

abs(x) модуль x, |x|

acos(x) арккосинус x

asin(x) арксинус x

atan(x) арктангенс x

cos(x) косинус x, x в радианах.

cosh(x) гиперболический косинус x, x в радианах

erf(x) функция ошибки x

exp(x) экспоненциальная функция x, от e

inverf(x) обратная функция ошибок x

invnorm(x) обратное нормальное распределение x

log(x) log x, от e

log10(x) log x, от 10

norm(x) нормальное распределение Гаусса

rand(x) псевдослучайный генератор чисел

sgn(x) 1 если x > 0, -1 если x < 0, 0 если x=0

sin(x) синус x, x в радианах

sinh(x) гиперболический синус x, x в радианах

sqrt(x) квадратный корень x

tan(x) тангенс x, x в радианах

tanh(x) гиперболический тангенс x, x в радианах

Программа так же поддерживает построение графиков на основе файлов с данными. Ниже приведен пример тестового файла с данными (testdata.dat):

# This test file is called testdata.dat
# a b c
0.000 0 0
0.001 104 51
0.002 202 101
0.003 298 148
0.0031 290 149
0.004 289 201
0.0041 291 209
0.005 310 250
0.010 311 260
0.020 280 240

# This test file is called testdata.dat

# a b c

0.000 0 0

0.001 104 51

0.002 202 101

0.003 298 148

0.0031 290 149

0.004 289 201

0.0041 291 209

0.005 310 250

0.010 311 260

0.020 280 240

Для печати графика необходимо выполнить команду:

gnuplot> plot "testdata.dat" using 1:2 title 'B', \
"testdata.dat" using 1:3 title 'C'

1 2	gnuplot> plot "testdata.dat" using 1:2 title 'B', \ "testdata.dat" using 1:3 title 'C'

Для печати графика необходимо выполнить команду:

gnuplot> plot "fileA.dat" using 1:2 title 'data A', \
"fileB.dat" using 1:3 title 'data B'

1 2	gnuplot> plot "fileA.dat" using 1:2 title 'data A', \ "fileB.dat" using 1:3 title 'data B'

Настройка графика осуществляется следующими командами:

Добавить подпись: > set title "Force-Deflection Data"
Добавить название оси x: > set xlabel "Deflection (meters)"
Добавить название оси y: > set ylabel "Force (kN)"
Изменить диапазон оси x: > set xrange [0.001:0.005]
Изменить диапазон оси y: > set yrange [20:500]
Автоматическое определение диапазона: > set autoscale
Добавить метку на график: > set label "yield point" at 0.003, 260
Убрать метки: > unset label
Использовать лог оси: > set logscale
Использовать лог ось на y: > unset logscale; set logscale y
Для печати так же удобно пользоваться скриптом, пример скрипта приведен ниже:
# Gnuplot script file for plotting data in file "testdata.dat"
# This file is called testscript.p
set autoscale # scale axes automatically
unset log # remove any log-scaling
unset label # remove any previous labels
set xtic auto # set xtics automatically
set ytic auto # set ytics automatically
set title "Test Plot"
set xlabel "meters"
set ylabel "kN"
set key 0.01,100
set label "Yield Point" at 0.003,260
set arrow from 0.0028,250 to 0.003,280
set xr [0.0:0.022]
set yr [0:325]
plot "testdata.dat" using 1:2 title 'B' with linespoints , \
"testdata.dat" using 1:3 title 'C' with points

Добавить подпись: > set title "Force-Deflection Data"

Добавить название оси x: > set xlabel "Deflection (meters)"

Добавить название оси y: > set ylabel "Force (kN)"

Изменить диапазон оси x: > set xrange [0.001:0.005]

Изменить диапазон оси y: > set yrange [20:500]

Автоматическое определение диапазона: > set autoscale

Добавить метку на график: > set label "yield point" at 0.003, 260

Убрать метки: > unset label

Использовать лог оси: > set logscale

Использовать лог ось на y: > unset logscale; set logscale y

Для печати так же удобно пользоваться скриптом, пример скрипта приведен ниже:

# Gnuplot script file for plotting data in file "testdata.dat"

# This file is called testscript.p

set autoscale # scale axes automatically

unset log # remove any log-scaling

unset label # remove any previous labels

set xtic auto # set xtics automatically

set ytic auto # set ytics automatically

set title "Test Plot"

set xlabel "meters"

set ylabel "kN"

set key 0.01,100

set label "Yield Point" at 0.003,260

set arrow from 0.0028,250 to 0.003,280

set xr [0.0:0.022]

set yr [0:325]

plot "testdata.dat" using 1:2 title 'B' with linespoints , \

"testdata.dat" using 1:3 title 'C' with points

Для того чтобы запустить скрипт воспользуйтесь командой:

gnuplot> load ' testscript.p'

1	gnuplot> load ' testscript.p'

Более подробную информацию о возможностях программы вы можете прочитать на сайте: http://www.gnuplot.info/

Maple 2020.2

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

Подключение переменных окружения пакета
Введите в консоли команду

$ module add Maple/v2020.2-1

1	$ module add Maple/v2020.2-1

Запуск пакета

$ xmaple

$ xmaple

– запуск с графическим интерфейсом. Откроется окно программы и вы можете начать работать в нем. Для выхода необходимо выбрать пункт Exit в выпадающем меню.

$ maple

$ maple

– запуск в терминальном режиме. В этом случае все команды необходимо вводить в текущей консоли и результаты вычислений будут выводиться в нее же. Для выхода из программы в данном режиме наберите команду

$ quit

$ quit

В этом случае расчеты будут проводиться на Вашей ВМ. Для запуска расчетов непосредственно на ресурсах кластера HybriLIT необходимо запускать расчеты через следующий скрипт-файл

#!/bin/bash
#SBATCH -p cpu                 # задает очередь, в которой будет запущен расчет
#SBATCH --job-name=maple       # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)
#SBATCH --output=maple.out     # задает имя выходного файла (по умолчанию slurm-XXX.out)
#SBATCH -t 60
#SBATCH -n 1                   # задает количество процессоров для расчетов
module add Maple/v2020.2-1
maple < maple.mpl           # maple.mpl – имя файла с листингом программы

#!/bin/bash

#SBATCH -p cpu # задает очередь, в которой будет запущен расчет

#SBATCH --job-name=maple # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)

#SBATCH --output=maple.out # задает имя выходного файла (по умолчанию slurm-XXX.out)

#SBATCH -t 60

#SBATCH -n 1 # задает количество процессоров для расчетов

module add Maple/v2020.2-1

maple < maple.mpl # maple.mpl – имя файла с листингом программы

При добавлении опции

-q

-q

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

maple —q < maple.mpl

1	maple —q < maple.mpl

Информацию по работе и описание основных команд Maple Вы можете посмотреть по ссылкам:
web-страница, pdf-документ.

Mathematica 11.2-1

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

Подключение переменных окружения пакета
Введите в консоли команду

$ module add Mathematica/v11.2-1

1	$ module add Mathematica/v11.2-1

Запуск пакета
$ mathematica – запуск с графическим интерфейсом. Откроется окно программы, и вы можете начать работать в нем. Для выхода необходимо выбрать пункт Exit в выпадающем меню.
$ math – запуск в терминальном режиме. В этом случае все команды необходимо вводить в текущей консоли и результаты вычислений будут выводиться в нее же. Для выхода из программы в данном режиме наберите команду
$ Quit
В этом случае расчеты будут проводиться на Вашей ВМ. Для запуска расчетов непосредственно на ресурсах кластера HybriLIT необходимо запускать расчеты через следующий скрипт-

#!/bin/bash
#SBATCH -p cpu                  # задает очередь, в которой будет запущен расчет
#SBATCH --job-name=math         # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)
#SBATCH --output=math.out       # задает имя выходного файла (по умолчанию slurm-XXX.out)
#SBATCH -t 60
#SBATCH -n 1                    # задает количество процессоров для расчетов
module add Mathematica/v11.2-1
math -run < math.m           # math.m – имя файла с листингом программы

#!/bin/bash

#SBATCH -p cpu # задает очередь, в которой будет запущен расчет

#SBATCH --job-name=math # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)

#SBATCH --output=math.out # задает имя выходного файла (по умолчанию slurm-XXX.out)

#SBATCH -t 60

#SBATCH -n 1 # задает количество процессоров для расчетов

module add Mathematica/v11.2-1

math -run < math.m # math.m – имя файла с листингом программы

При добавлении опции

-noprompt

-noprompt

math -noprompt -run < math.m

1	math -noprompt -run < math.m

Документацию по работе в Mathematica и описание основных команд Вы можете посмотреть перейдя по ссылке.

MATLAB R2020b, R2022b

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

Подключение переменных окружения пакета
Введите в консоли команду

$ module add Matlab/R2020b

1	$ module add Matlab/R2020b

или

$ module add Matlab/R2022b

1	$ module add Matlab/R2022b

Запуск пакета

$ matlab

$ matlab

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

$ matlab -nojvm -nodisplay -nosplash

1	$ matlab -nojvm -nodisplay -nosplash

– запуск программы в режиме терминала. Для выхода из программы в данном режиме наберите команду

$ quit

$ quit

#!/bin/bash<br />#SBATCH -p cpu                            # задает очередь, в которой будет запущен расчет
#SBATCH --mem-per-cpu=4G                  #задает объем памяти для каждого ядра
#SBATCH --job-name=math                   # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)
#SBATCH --output=matlab.out               # задает имя выходного файла (по умолчанию slurm-XXX.out)
#SBATCH -t 60<br />#SBATCH -с 1                              # задает количество процессоров для расчетов
module add Matlab/R2022b<br />matlab -nodisplay -nosplash < matlab.m    # matlab.m – имя файла с листингом программы

#!/bin/bash<br />#SBATCH -p cpu # задает очередь, в которой будет запущен расчет

#SBATCH --mem-per-cpu=4G #задает объем памяти для каждого ядра

#SBATCH --job-name=math # задает имя задачи в очереди (по умолчанию совпадает с названием запускаемого скрипта)

#SBATCH --output=matlab.out # задает имя выходного файла (по умолчанию slurm-XXX.out)

#SBATCH -t 60<br />#SBATCH -с 1 # задает количество процессоров для расчетов

module add Matlab/R2022b<br />matlab -nodisplay -nosplash < matlab.m # matlab.m – имя файла с листингом программы

Документацию по работе в Matlab и описание основных команд Вы можете посмотреть перейдя по ссылке.

Инструкция использования MATLAB в среде JupyterHub в рамках экосистемы ML/DL/HPC

Перейти по адресу https://jhub2.jinr.ru
Авторизоваться через GitLab
Выбрать Matlab
Выбрать на вкладке Network License Manager и ввести адрес (последующие разы это вводить будет не нужно, сохранится в конфигурационном файле): 25815@lm-hlit.jinr.ru
Первый старт ядра может быть очень долгим — около 2-3 минут. Однако, после этого к нему можно возвращаться практически мгновенно (Jupyter-сервер продолжит работать в фоновом режиме в течении одного часа, если в нем не совершается никаких действий. Даже если закрыть вкладку браузера, вы сможете вернутся в то состояние Matlab, в котором были до этого). Стоит учесть, что загруженность системы хранения данных (далее СХД), в которой хранятся домашние директории, тоже влияет на отзывчивость Matlab.
Когда интерфейс прогрузился отобразился путь до домашней директории и появился список файлов в домашней директории можно начинать работать с Matlab
Для создания интерактивного скрипта Matlab (аналог Jupyter IPython Notebook) нажмите New LiveScript
Вставить в ячейку код:

x = linspace(-2,2,20); y = x'; z = x .* exp(-x.^2 - y.^2); surf(x,y,z) view([-119.307 28.266])

1
2
3
4
5

x = linspace(-2,2,20);
y = x';
z = x .* exp(-x.^2 - y.^2);
surf(x,y,z)
view([-119.307 28.266])

И нажать Сtrl+Enter
По завершению работы с Matlab просьба закрыть сессию, чтобы не занимать выделенную лицензию. Сделать это можно с помощью Matlab Integration settings
На данный момент доступно 6 лицензий MATLAB. При исчерпании данного лимита будет отображаться окно с предупреждением

Запуск MATLAB скриптов в параллельном режиме (CPU) в среде JupyterHub

Создать вычислительный скрипт, содержащий параллельные конструкции.

В качестве примера можно рассмотреть вычисления ряда Тейлора. Данный пример не показывает ускорения вычисления ввиду своей простоты, и используется только для демонстрации конструкций необходимых для запуска в параллельном режиме.

N=10000;
e=0;
tic
for i=0:N
   e=e+1.0/factorial(i);
end
toc
e

N=10000;

e=0;

tic

for i=0:N

e=e+1.0/factorial(i);

end

toc

Для того чтобы данный скрипт считался в параллельном режиме нужно всего лишь заменить цикл for на parfor.

N=10000;
e=0;
tic
parfor i=0:N
   e=e+1.0/factorial(i);
end
toc
e

N=10000;

e=0;

tic

parfor i=0:N

e=e+1.0/factorial(i);

end

toc

Запустить скрипт как обычно при помощи кнопки Run или консоли.

Когда программа дойдет до строки, содержащей параллельную команду, автоматически активируется параллельной кластер (статус активации кластера можно увидеть в нижней левой части экрана), который создаст параллельных «работников» и с их помощью будет выполнять соответствующий код.

Количество работников по умолчанию равно количеству физических ядер процессора. Если нужно указать количество «работников» вручную в код скрипта добавляется следующие команды:

% удаляет предыдущий объект parcluster если таковой имеется
delete(gcp('nocreate'))
% создание объекта parcluster
c=parcluster;
% указание количества работников для объекта parcluster
p=c.parpool(2);

% удаляет предыдущий объект parcluster если таковой имеется

delete(gcp('nocreate'))

% создание объекта parcluster

c=parcluster;

% указание количества работников для объекта parcluster

p=c.parpool(2);

Полный текст скрипта:

N=10000;
e=0;
delete(gcp('nocreate'))
c=parcluster;
c.parpool(2);
tic
parfor i=0:N
   e=e+1.0/factorial(i);
end
toc
e

N=10000;

e=0;

delete(gcp('nocreate'))

c=parcluster;

c.parpool(2);

tic

parfor i=0:N

e=e+1.0/factorial(i);

end

toc

Запуск Matlab скриптов в параллельном режиме (CPU) через batch

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

В код скрипта, содержащего параллельные конструкции, нужно добавить следующий фрагмент кода:

% создание объекта parcluster
c = parcluster;
% считывание параметра -с из batch скрипта
sz = str2num(getenv('SLURM_CPUS_PER_TASK'));
% условие если параметр -с не задан задать количество работников равное числу ядер процессора
if isempty(sz)
   sz = maxNumCompThreads;
end
% указание количества работников для объекта parcluster
p = c.parpool(sz);

% создание объекта parcluster

c = parcluster;

% считывание параметра -с из batch скрипта

sz = str2num(getenv('SLURM_CPUS_PER_TASK'));

% условие если параметр -с не задан задать количество работников равное числу ядер процессора

if isempty(sz)

sz = maxNumCompThreads;

end

% указание количества работников для объекта parcluster

p = c.parpool(sz);

Запустить скрипт на исполнение.