Завдання

Відповідно до номера свого варіанта виконайте завдання обраного рівня складності.

Варіанти

Варіант 1. Масштабованість теплопровідності

1. Початковий рівень. Створити MPI-програму мовою C++, яка моделює охолодження стрижня з ${10}^6$ вузлів явною схемою (кожен ранг зберігає свою частину й обмінюється граничними значеннями з сусідами) протягом 2000 кроків і виводить час та температуру в центрі, і скрипт sbatch, що запускає її на одному вузлі з 4 процесами через srun --mpi=pmix і записує вивід у файл heat-<номер завдання>.out.

2. Базовий рівень. Створити скрипт bash, який запитує розмір стрижня (від ${10}^5$ до ${10}^8$ вузлів) і кількість кроків, перевіряє введення та наявність виконуваного файлу MPI-програми моделювання теплопровідності, надсилає завдання для 1, 2 і 3 вузлів по 4 процеси (sbatch --wait або залежності), після завершення збирає час з файлів виводу й виводить таблицю «вузли – процеси – час, с – прискорення $S$ – ефективність $E$».

3. Високий рівень. Створити набір скриптів scalebench для дослідження масштабованості MPI-програми мовою C++, що моделює теплопровідність стрижня явною схемою (обмін граничними значеннями між рангами), з опціями --nodes 1,2,3, --ppn 1,2,4, --size <n>, --steps <k>, --repeat <r>, --weak, --csv <файл> і --help. Набір генерує скрипти sbatch для кожної конфігурації, надсилає їх в одне виділення або ланцюжком singleton, збирає медіану $r$ запусків і виводить таблицю сильної (з --weak – слабкої) масштабованості та CSV. Помилки опцій – код 1; завдання зі станом, відмінним від COMPLETED (sacct), – у потік помилок, код 2.

Варіант 2. Епідемічна модель SIR

1. Початковий рівень. Створити консольну програму мовою C++, яка моделює епідемію за моделлю SIR (населення 100 000, 10 хворих на початку, крок 0,1 доби, 200 діб) для коефіцієнтів $\beta$ і $\gamma$, заданих аргументами, і виводить рядок CSV: $\beta$, $\gamma$, пік хворих, доба піку, частка перехворілих; та скрипт sbatch з масивом --array=1-10, у якому елемент $i$ задає $\beta =0,1\cdot i$ при $\gamma =0,1$.

2. Базовий рівень. Створити скрипт sbatch з масивом із 100 завдань, кожне з яких запускає програму мовою C++ моделі епідемії SIR (рядок CSV: $\beta$, $\gamma$, пік хворих, доба піку, частка перехворілих) з парою $(\beta ,\gamma )$ із SLURM_ARRAY_TASK_ID на сітці 10 × 10 ($\beta$ 0,1–1,0, $\gamma$ 0,05–0,5), і скрипт bash, який після масиву (залежність afterok) перевіряє наявність 100 рядків, об’єднує їх у CSV, сортує за піком і виводить 5 найгірших і 5 найкращих сценаріїв та пропущені елементи.

3. Високий рівень. Створити проєкт sirsweep (CMake, програма моделі мовою C++ і скрипти bash), який приймає опції --beta <від:до:крок>, --gamma <від:до:крок>, --days <n>, --max-parallel <k> (обмеження %k масиву), --out <каталог> і --help, генерує масив завдань, повторно надсилає лише елементи, що завершилися з помилкою (за sacct), і будує звіт: таблицю піку хворих у вигляді матриці $\beta \times \gamma$, $R_0=\beta /\gamma$ для кожної клітинки та CSV. Некоректні діапазони – код завершення 1, незавершені елементи після повтору – 2.

Варіант 3. Звіт використання кластера

1. Початковий рівень. Створити консольну програму C#, яка читає файл з виводом sacct --parsable2 --format=JobID,User,CPUTimeRAW (ім’я файлу – аргумент), пропускає рядки кроків (номер містить крапку) і виводить для кожного користувача кількість завдань і використаний час CPU в годинах, упорядкувавши за спаданням часу.

2. Базовий рівень. Створити консольну програму C#, яка запитує файл з виводом sacct --parsable2 з полями JobID, User, Account, State, AllocCPUS, ElapsedRaw, Submit, Start і дату початку звіту, перевіряє наявність потрібних стовпців і формат рядків та виводить таблицю «користувач – рахунок – завдань – успішних, % – CPU·год – середнє очікування» з підсумковим рядком; рядки з помилками формату підраховуються й виводяться окремо.

3. Високий рівень. Створити консольний застосунок C# clusterusage, який приймає опції --input <файл> (без неї запускає sacct сам), --from, --to, --group-by user|account|partition, --top <n>, --csv <файл> і --help, будує звіт використання: CPU·год, частка від загального, кількість завдань за станами, середнє й найбільше очікування, завдання з найбільшим часом CPU, а також погодинну гістограму зайнятості CPU кластера (текстовими стовпчиками). Невідома опція – код 1, помилка читання або запуску sacct – код 2.

Варіант 4. Перевірка стану вузлів

1. Початковий рівень. Створити скрипт bash, який через pdsh -w node[01-03] збирає з кожного вузла ім’я, кількість процесорів (nproc), обсяг пам’яті, версію ядра й версію Slurm (slurmd -V) і виводить таблицю, у якій кожен вузол займає один рядок.

2. Базовий рівень. Створити скрипт bash, який приймає список вузлів аргументом (типово node[01-03]), збирає з вузлів версію ядра, версії пакетів slurmd, munge, openmpi-bin, контрольну суму /etc/slurm/slurm.conf і munge.key (sha256sum, для ключа – через sudo), стан служб munge і slurmd та відхилення годинника від вузла head. Скрипт виводить таблицю і позначає ! значення, які відрізняються від більшості вузлів; недоступні вузли перелічуються окремо.

3. Високий рівень. Створити інструмент nodecheck (bash або C#), який приймає опції --nodes <список>, --baseline <файл> (еталонна конфігурація в JSON), --save-baseline, --json і --help, збирає параметри вузлів (процесори, пам’ять, ядро, пакети, контрольні суми конфігурацій, служби, час, ліміти ulimit -l -n, регулятор частоти, THP, vm.swappiness), порівнює їх з еталоном і виводить таблицю відхилень із рекомендацією щодо виправлення. Код завершення: 0 – відхилень немає, 1 – помилка опцій, 3 – знайдено відхилення, 4 – є недоступні вузли.

Варіант 5. Конвеєр обробки зображень

1. Початковий рівень. Створити два скрипти sbatch і скрипт запуску: перше завдання генерує 8 зображень PGM 600×400 з випадковим шумом (C++ або awk), друге – масив із 8 елементів, кожен з яких розмиває одне зображення фільтром середнього 3×3 (програма мовою C++), і запускається з умовою afterok; скрипт запуску виводить номери завдань.

2. Базовий рівень. Створити конвеєр із трьох завдань Slurm: генерація зображень PGM із шумом → масив обробки, де кожен елемент розмиває одне зображення фільтром середнього (програма мовою C++) → збирання звіту. Скрипт запуску запитує кількість зображень (від 1 до 100) і розмір фільтра (3, 5 або 7), перевіряє введення й надсилає завдання з умовами afterok; завдання звіту виводить таблицю «файл – середня яскравість до – після – час обробки». Завдання з умовою afternotok у разі збою записує список необроблених файлів.

3. Високий рівень. Створити проєкт imgpipe (програма обробки мовою C++ і скрипти bash) з опціями --input <каталог>, --filters blur,sobel,median, --chunk <k> (зображень на елемент масиву), --max-parallel <n>, --retry <r> і --help. Скрипт будує ланцюжок завдань для кожного фільтра, автоматично повторно надсилає елементи, що завершилися з помилкою (не більше $r$ разів), і створює звіт: кількість оброблених файлів, помилки, сумарний і середній час за даними sacct. Код завершення: 0 – усі оброблено, 2 – є необроблені файли.

Варіант 6. Генератор slurm.conf

1. Початковий рівень. Створити скрипт bash, який виконує slurmd -C на вузлах node[01-03] через pdsh, залишає лише рядки NodeName і зменшує RealMemory кожного вузла на 5 % (округлення вниз до сотень МБ), виводячи готові рядки для slurm.conf.

2. Базовий рівень. Створити консольну програму C#, яка читає з файлу вивід pdsh -w <вузли> slurmd -C (ім’я файлу вводить користувач), розбирає параметри кожного вузла, об’єднує вузли з однаковою конфігурацією в стислий запис (node[01-03]) і виводить рядки NodeName та рядок PartitionName=debug з усіма вузлами; рядки неправильного формату виводяться як попередження.

3. Високий рівень. Створити консольний застосунок C# slurmconfgen, який генерує повний slurm.conf і cgroup.conf за виводом slurmd -C вузлів (опція --nodes <список> запускає pdsh … slurmd -C, --input <файл> читає готовий вивід), групуючи однакові вузли. Опції: --controller <вузол>, --mem-reserve <відсоток>, --partition <ім’я>:<MaxTime> (кілька разів), --accounting, --help. Застосунок перевіряє, що вузли кожного розділу існують, а MaxTime має правильний формат, порівнює результат з наявним файлом і виводить різницю. Помилки – у потік помилок, код 1.

Варіант 7. Гібридна множина Мандельброта

1. Початковий рівень. Створити гібридну програму MPI + OpenMP мовою C++, яка обчислює кількість ітерацій для зображення множини Мандельброта 2400×1600 (не більше 2000 ітерацій на точку): ранги ділять рядки по черзі, потоки OpenMP обробляють рядок з schedule(dynamic); і скрипт sbatch для 2 вузлів по 2 ранги з 2 потоками, що задає OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK.

2. Базовий рівень. Створити скрипт sbatch, який в одному виділенні з 12 CPU запускає гібридну програму множини Мандельброта з розкладками «ранги × потоки» 1 × 12, 2 × 6, 3 × 4, 6 × 2 і 12 × 1 (кроки srun -n … -c …), для кожної виконує 3 запуски, перевіряє однаковість загальної кількості ітерацій і виводить таблицю медіан часу та прискорення відносно 1 × 1.

3. Високий рівень. Створити проєкт mandelhybrid (CMake, find_package(MPI) і find_package(OpenMP)) з програмою, що приймає опції --size <ш>x<в>, --iter <n>, --schedule static|dynamic, --image <файл.pgm> і --help (зображення збирає ранг 0 через MPI_Gatherv), і скрипт генерації завдань для всіх розкладок на 1–3 вузлах. Звіт: таблиця «вузли – ранги – потоки – час – $S$ – $E$» з найкращою розкладкою для кожної кількості вузлів і частка часу обміну (MPI_Wtime навколо збирання).

Варіант 8. Регулятор частоти процесора

1. Початковий рівень. Створити скрипт bash, який виводить для кожного логічного процесора поточний регулятор частоти й поточну частоту з каталогу /sys/devices/system/cpu/cpu*/cpufreq, а якщо каталогу немає (віртуальна машина), виводить повідомлення про відсутність драйвера cpufreq.

2. Базовий рівень. Створити скрипт sbatch, який на фізичному вузлі (опція -w) виводить поточний регулятор, запускає однопотоковий тест (обчислення $\pi$ методом прямокутників з ${10}^9$ кроків, програма мовою C++) 5 разів і виводить медіану часу та середню частоту процесора під час тесту (/proc/cpuinfo, поле cpu MHz). Скрипт перевіряє, що регулятор доступний, і завершується з поясненням, якщо ні.

3. Високий рівень. Створити інструмент govbench (скрипти bash і програма тесту мовою C++), який для кожного регулятора зі списку --governors performance,powersave,schedutil встановлює його через cpupower (з sudo), запускає однопотоковий і багатопотоковий тести --repeat <r> разів, повертає початковий регулятор навіть у разі помилки (trap) і виводить таблицю «регулятор – тест – медіана часу – частота – відхилення від performance, %» та CSV. У ВМ без cpufreq інструмент завершується з кодом 3 і повідомленням.

Варіант 9. Черга студентських завдань

1. Початковий рівень. Створити фрагмент slurm.conf з розділами lab (вузли node[01-02], найбільший час 15 хв, за замовчуванням) і project (усі вузли, 4 год) та скрипт bash, який надсилає в кожен розділ тестове завдання sleep 30 і виводить номер завдання, розділ і стан через squeue.

2. Базовий рівень. Створити скрипт bash, який перевіряє обмеження розділів кластера: для кожного розділу з sinfo -h -o "%P %l" надсилає завдання з лімітом часу, меншим і більшим за найбільший (--time), та із запитом пам’яті, більшим за RealMemory вузла, фіксує, прийнято чи відхилено кожне завдання (текст помилки sbatch), скасовує прийняті тестові завдання й виводить таблицю «розділ – тест – очікуваний – фактичний результат».

3. Високий рівень. Створити набір тестів queuetest (bash) для налаштувань черги навчального кластера: опції --config <файл сценаріїв>, --user <ім’я>, --cleanup і --help. Сценарій описує завдання (розділ, вузли, час, пам’ять, QoS) та очікуваний результат (відхилено, PENDING з певною причиною, RUNNING); інструмент надсилає завдання, чекає до 60 с, порівнює стан і причину з очікуваними, скасовує тестові завдання та виводить підсумок «пройдено / не пройдено». Код завершення – кількість непройдених сценаріїв.

Варіант 10. Ризик портфеля методом Монте-Карло

1. Початковий рівень. Створити консольну програму мовою C++, яка методом Монте-Карло (${10}^7$ сценаріїв, генератор std::mt19937_64 із зерном з аргументу) оцінює ймовірність збитку понад 10 % для портфеля з трьох активів з нормальними річними дохідностями (параметри в програмі), і скрипт sbatch з масивом із 10 елементів, у якому зерно дорівнює SLURM_ARRAY_TASK_ID.

2. Базовий рівень. Створити скрипт sbatch з масивом із 20 елементів, кожен з яких запускає програму мовою C++, що методом Монте-Карло (зерно – SLURM_ARRAY_TASK_ID) оцінює для портфеля з трьох активів ймовірність збитку понад 10 % і VaR 95 %, і скрипт bash, який після завершення масиву (залежність afterok) збирає ці оцінки з файлів виводу, перевіряє, що всі елементи дали результат, і виводить середнє, стандартне відхилення, 95-відсотковий довірчий інтервал кожної величини та таблицю результатів елементів.

3. Високий рівень. Створити проєкт mcrisk (програма мовою C++ з OpenMP і скрипти), який приймає опції --assets <файл CSV з дохідностями й кореляціями>, --scenarios <n>, --jobs <k>, --threads <t>, --confidence 0.95,0.99 і --help, генерує масив із $k$ елементів (у кожному – потоки OpenMP з незалежними генераторами), збирає результати й обчислює VaR і CVaR з довірчими інтервалами. Коректність кореляційної матриці (симетрія, розклад Холецького) перевіряється до надсилання; помилка – код 1.

Варіант 11. Моніторинг навантаження вузлів

1. Початковий рівень. Створити скрипт bash, який через pdsh виконує на вузлах node[01-03] команду mpstat 1 5 (пакет sysstat) і виводить для кожного вузла середнє завантаження процесора (%usr, %sys, %idle) одним рядком.

2. Базовий рівень. Створити скрипт bash, який протягом заданого користувачем часу (від 10 до 600 с) кожні 5 с збирає з усіх вузлів завантаження процесора, вільну пам’ять і кількість задач Slurm на вузлі (squeue -w <вузол> -h | wc -l), записує вимірювання в CSV і наприкінці виводить таблицю «вузол – середнє / найбільше завантаження – найменше вільної пам’яті».

3. Високий рівень. Створити консольний застосунок C# clustermon, який приймає опції --nodes <список>, --interval <с>, --duration <с>, --alert-load <відсоток>, --csv <файл> і --help, опитує вузли через SSH (mpstat, free, sinfo -N), відображає таблицю, що оновлюється в консолі, позначає вузли з навантаженням понад поріг або в станах DRAIN і DOWN, а після завершення зберігає CSV і підсумок. Недоступність вузла не зупиняє моніторинг, а виводиться як попередження в потік помилок.

Варіант 12. Сортування великого файлу

1. Початковий рівень. Створити скрипт sbatch з масивом із 4 елементів, кожен з яких сортує свою частину файлу з $4\cdot {10}^6$ цілих чисел (частини заздалегідь розділено командою split -n l/4) командою sort -n і записує результат у sorted-<номер>.txt.

2. Базовий рівень. Створити ланцюжок із трьох завдань: генерація файлу з $n$ випадкових чисел ($n$ – аргумент скрипту запуску, від ${10}^5$ до ${10}^8$) і поділ на $k$ частин; масив із $k$ елементів сортування; завдання злиття sort -m -n з умовою afterok, яке перевіряє впорядкованість і кількість рядків результату та виводить час кожного етапу.

3. Високий рівень. Створити проєкт extsort (програма сортування частини мовою C++ з паралельним std::sort і скрипти), який приймає опції --input <файл>, --chunks <k>, --mem-per-chunk <МБ>, --output <файл> і --help, обчислює кількість частин за розміром файлу й пам’яттю, будує ланцюжок «поділ → масив сортування → злиття», у разі збою одного елемента повторює лише його і виводить звіт часу етапів за sacct. Результат перевіряється на впорядкованість; помилка перевірки – код 2.

Варіант 13. Автоматичний бенчмарк

1. Початковий рівень. Створити скрипт bash, який для кожного значення кількості процесів 1, 2, 4 і 8 генерує файл bench-<p>.sbatch з директивами #SBATCH --ntasks=<p> і командою srun --mpi=pmix ./pi_mpi, надсилає всі файли й виводить номери завдань.

2. Базовий рівень. Створити скрипт bash для бенчмарку MPI-програми обчислення $\pi$ (./pi_mpi), який запитує список кількостей процесів і кількість повторень, перевіряє введення, генерує й надсилає завдання sbatch (srun --mpi=pmix), чекає їх завершення (squeue у циклі з паузою), витягає час з файлів виводу, записує results.csv з полями p,run,time і виводить таблицю медіан і прискорення.

3. Високий рівень. Створити інструмент autobench (bash), який читає файл сценарію (програма, аргументи, списки nodes, ntasks, cpus-per-task, змінні середовища, кількість повторень), генерує скрипти для всіх комбінацій, надсилає їх з обмеженням кількості одночасних завдань, збирає час з виводу й стан із sacct, записує CSV і звіт з найкращою конфігурацією. Опції: --scenario <файл>, --dry-run (лише показати скрипти), --resume (пропустити виконані комбінації), --help; помилки сценарію – код 1.

Варіант 14. Відновлення вузла зі стану DRAIN

1. Початковий рівень. Створити скрипт bash, який виводить вузли в станах drain, draining і down з причиною, користувачем і часом (sinfo -R з власним форматом) та для кожного такого вузла – відповідь ping і стан служби slurmd через SSH.

2. Базовий рівень. Створити діагностичний скрипт bash, який для вузла, заданого аргументом, перевіряє: доступність SSH, стан munge і slurmd, розбіжність часу з head, вільне місце в /var і /tmp, відповідність ресурсів slurmd -C рядку вузла в slurm.conf, останні помилки в /var/log/slurm/slurmd.log; виводить таблицю перевірок «ok / FAIL» з поясненням і рекомендовану команду (systemctl restart …, scontrol update … resume).

3. Високий рівень. Створити інструмент noderescue (bash) для відновлення вузлів Slurm зі станів drain/down з опціями --node <ім’я> або --all, --fix, --log <файл> і --help. Інструмент перевіряє доступність SSH, служби munge і slurmd, розбіжність часу з head, вільне місце в /var і /tmp, відповідність slurmd -C рядку вузла в slurm.conf та помилки в журналі slurmd. З --fix виконує безпечні виправлення (перезапуск служб, синхронізація часу, scontrol update state=resume лише після успіху всіх перевірок), веде журнал дій з часом і завершується з кодом, що дорівнює кількості недоступних вузлів.

Варіант 15. Число π на кластері

1. Початковий рівень. Створити MPI-програму мовою C++, яка обчислює $\pi$ як інтеграл $4/(1+x^2)$ на $[0;1]$ з кількістю кроків з аргументу (ранги додають кожен $p$-й прямокутник, MPI_Reduce) і виводить значення, похибку та час, і скрипт sbatch для 2 вузлів по 4 процеси.

2. Базовий рівень. Створити скрипт sbatch, який в одному виділенні з 3 вузлів запускає програму обчислення $\pi$ для 1, 2, 4, 8 і 12 процесів (сильна масштабованість, $2\cdot {10}^9$ кроків) і для тих самих кількостей процесів з $2\cdot {10}^8$ кроків на процес (слабка масштабованість), для кожного випадку виконує 5 запусків і виводить таблиці медіан часу, прискорення та ефективності.

3. Високий рівень. Створити проєкт piscale (програма мовою C++ і скрипти), який приймає опції --method rect|simpson|montecarlo, --steps <n>, --procs 1,2,4,8,12, --mode strong|weak|both, --repeat <r>, --csv <файл> і --help, запускає кроки srun в одному виділенні, порівнює запуск на одному вузлі й на кількох вузлах з тією самою кількістю процесів, обчислює прискорення, ефективність, частку послідовної роботи за законом Амдала (оцінка методом найменших квадратів) і записує CSV для графіка.

Варіант 16. Прозорі великі сторінки

1. Початковий рівень. Створити консольну програму мовою C++, яка множить дві квадратні матриці $n\times n$ ($n$ – аргумент, типово 2048) порядком циклів i-k-j і виводить час та поточний режим THP з файлу /sys/kernel/mm/transparent_hugepage/enabled, і скрипт sbatch, що запускає її для $n=1024,2048,3072$.

2. Базовий рівень. Створити програму мовою C++, яка виділяє пам’ять для матриць функцією aligned_alloc (вирівнювання 2 МБ) і залежно від аргументу huge або normal викликає madvise(MADV_HUGEPAGE) чи madvise(MADV_NOHUGEPAGE), множить матриці, виводить час і значення AnonHugePages з /proc/self/smaps_rollup; та скрипт sbatch, що порівнює обидва режими для трьох розмірів матриць (медіана 3 запусків) і виводить таблицю.

3. Високий рівень. Створити дослідження thpbench (програма мовою C++ з OpenMP і скрипти), яке для режимів THP always, madvise, never (зміна через sudo на окремому вузлі, завдання з -w і --exclusive) і розмірів матриць зі списку виконує множення матриць і випадкові звернення до пам’яті, записує час, AnonHugePages і кількість промахів TLB (perf stat, якщо доступний), відновлює початковий режим (trap) і будує звіт з рекомендацією для вузлів кластера.

Варіант 17. Інтерактивні сеанси

1. Початковий рівень. Створити скрипт bash, який отримує виділення salloc -N2 -n4 -t 10 з командою, що виводить номер завдання, список вузлів, а потім кроком srun для кожної задачі – ім’я вузла, номер задачі й процесори, до яких її прив’язано (taskset -cp $$).

2. Базовий рівень. Створити скрипт bash, який запитує кількість вузлів, задач і час сеансу, перевіряє введення за sinfo (не більше, ніж є вузлів і CPU), отримує виділення salloc, у ньому перевіряє змінні SLURM_*, запускає тестовий крок srun на всіх задачах, записує журнал сеансу з часом кожної команди у файл і після завершення виводить з sacct кроки сеансу та їхню тривалість.

3. Високий рівень. Створити утиліту hpcshell (bash), яка приймає опції --nodes <n>, --tasks <n>, --cpus-per-task <c>, --time <хв>, --partition <розділ>, --log <файл> і --help, отримує виділення, запускає інтерактивну оболонку на першому вузлі (srun --pty bash) із запрошенням, що містить номер завдання й залишок часу, записує всі команди сеансу в журнал, попереджає за 5 хв до завершення ліміту (сигнал --signal) і після виходу виводить використані CPU·год. Помилки salloc – код 2.

Варіант 18. Рендеринг кадрів анімації

1. Початковий рівень. Створити консольну програму мовою C++, яка малює кадр анімації (кулька, що рухається по колу, зображення PPM 640×480) для номера кадру з аргументу, і скрипт sbatch з масивом --array=0-59, у якому кожен елемент створює файл frame-<номер>.ppm.

2. Базовий рівень. Створити ланцюжок завдань Slurm для рендерингу анімації: масив, кожен елемент якого запускає програму мовою C++, що малює кадр (кулька рухається по колу, файл PPM) за номером кадру; кількість кадрів і розмір вводить користувач у скрипті запуску з перевіркою. Завдання перевірки з умовою afterany знаходить відсутні або порожні кадри й виводить їхні номери, а завдання ffmpeg -framerate 30 -i frame-%03d.ppm з умовою afterok збирає відео (без ffmpeg – повідомлення й кількість готових кадрів).

3. Високий рівень. Створити проєкт renderfarm (програма трасування променів простої сцени мовою C++ з OpenMP і скрипти), який приймає опції --frames <n>, --size <ш>x<в>, --frames-per-task <k>, --threads <t>, --max-parallel <m>, --output <каталог> і --help, повторно рендерить лише відсутні кадри, збирає відео та виводить звіт: час рендерингу кадру (мін., середній, макс.), використані CPU·год і прогноз часу для 4K.

Варіант 19. Облік квот лабораторії

1. Початковий рівень. Створити скрипт bash, який за допомогою sacct -X --allusers --parsable2 за поточний місяць підсумовує CPUTimeRAW за рахунками (Account) і виводить таблицю «рахунок – CPU·год».

2. Базовий рівень. Створити консольну програму C#, яка читає файл квот (рахунок;квота CPU·год) і файл з виводом sacct --parsable2 (імена файлів вводить користувач), перевіряє формат обох файлів, обчислює для кожного рахунку використання, залишок і відсоток квоти та виводить таблицю, позначаючи рахунки з використанням понад 80 % і понад 100 %.

3. Високий рівень. Створити консольний застосунок C# quota, який приймає опції --quotas <файл>, --from, --to, --warn <відсоток>, --by-user і --help, будує звіт використання квот рахунків і користувачів, прогнозує дату вичерпання квоти за середнім денним використанням і генерує команди sacctmgr modify account … set GrpTRESMins=cpu=… для рахунків, що перевищили квоту (лише виводить, не виконує). Код 3 – є перевищення.

Варіант 20. Розподілений підрахунок слів

1. Початковий рівень. Створити скрипт sbatch з масивом із 4 елементів (етап map), кожен з яких підраховує слова у своєму текстовому файлі part-<номер>.txt (tr, sort, uniq -c) і записує результат у counts-<номер>.txt.

2. Базовий рівень. Створити ланцюжок завдань Slurm map → reduce для підрахунку слів: масив map із $k$ елементів (кількість файлів у каталозі, заданому користувачем), кожен з яких рахує слова свого файлу (tr, sort, uniq -c), завдання reduce з умовою afterok, яке об’єднує часткові словники (awk), і скрипт запуску з перевіркою каталогу. Завдання reduce виводить 20 найчастіших слів, загальну кількість слів і кількість різних слів.

3. Високий рівень. Створити проєкт mapreduce (програми map і reduce мовою C++ або C# і скрипти), який приймає опції --input <каталог>, --mappers <k>, --reducers <r> (розподіл слів між reduce-завданнями за хешем), --top <n>, --stopwords <файл> і --help, будує граф залежностей «map (масив) → reduce (масив) → злиття», перевіряє збіг результату з послідовним підрахунком на малих даних і виводить звіт часу етапів за sacct.

Варіант 21. Прив’язка задач до ядер

1. Початковий рівень. Створити скрипт sbatch, який на одному вузлі запускає 4 задачі srun з ключами --cpu-bind=cores, --cpu-bind=threads і --cpu-bind=none та для кожного варіанта виводить для кожної задачі список процесорів з taskset -cp $$.

2. Базовий рівень. Створити скрипт sbatch, який запускає MPI-програму обчислення $\pi$ (або іншу, задану аргументом) з кількістю задач, що дорівнює кількості ядер вузла, для варіантів --cpu-bind=none, cores, threads, map_cpu:<список> і --hint=nomultithread, виконує по 5 запусків і виводить таблицю медіан часу та розкид (мін./макс.) для кожного варіанта.

3. Високий рівень. Створити дослідження bindbench (гібридна програма MPI + OpenMP мовою C++ і скрипти), яке порівнює прив’язку Slurm (--cpu-bind, --distribution=block|cyclic) у поєднанні з OMP_PROC_BIND=close|spread і OMP_PLACES=cores|threads для обчислювального і обмеженого пам’яттю тестів, виводить фактичну прив’язку кожного потоку (sched_getcpu), таблицю часу та рекомендацію; опції --tests, --repeat, --csv, --help.

Варіант 22. Резервне копіювання результатів

1. Початковий рівень. Створити скрипт sbatch для завдання резервного копіювання, яке запускається з умовою afterany:<номер> після обчислювального завдання й архівує каталог results у файл results-<номер>.tar.gz у каталозі /home/$USER/backup.

2. Базовий рівень. Створити скрипт запуску, який надсилає обчислювальне завдання (програма й аргументи – параметри скрипту) і завдання резервного копіювання з умовою afterany. Завдання копіювання обчислює SHA-256 кожного файлу результатів (sha256sum), створює архів, перевіряє його розпакуванням у тимчасовий каталог і звіркою контрольних сум та виводить таблицю файлів зі статусом перевірки й станом обчислювального завдання (sacct).

3. Високий рівень. Створити інструмент jobbackup (bash), який приймає опції --job <номер> або --watch <користувач> (для кожного завершеного завдання), --dest <каталог>, --keep <n> (кількість архівів), --verify і --help, створює інкрементні архіви результатів завдань із маніфестом контрольних сум, перевіряє їх, видаляє старі архіви понад $n$ і веде журнал. Помилка перевірки архіву – код 2, відсутність завдання – 1.

Варіант 23. Ліміти ulimit і memlock

1. Початковий рівень. Створити скрипт sbatch, який виводить на обчислювальному вузлі ліміти процесу (ulimit -a), значення memlock і nofile у кроці srun, а також ліміти самої служби slurmd з файлу /proc/<pid>/limits.

2. Базовий рівень. Створити програму мовою C++, яка намагається закріпити в пам’яті (mlock) буфер заданого розміру (від 1 до 4096 МБ, аргумент) і відкрити задану кількість файлів, виводячи, на якому розмірі або кількості виникла помилка; та скрипт sbatch, що запускає програму для кількох розмірів на вході і в кроці srun і виводить таблицю «ліміт – очікувано – фактично».

3. Високий рівень. Створити інструмент limitscheck (bash і програма мовою C++), який порівнює ліміти memlock, nofile, nproc, stack у трьох контекстах: сеанс SSH на вузлі, скрипт sbatch і крок srun на кожному вузлі, пояснює розбіжності (параметр PropagateResourceLimits, файли /etc/security/limits.d/, LimitMEMLOCK служби slurmd) і генерує файл налаштувань 90-hpc.conf з рекомендованими значеннями. Опції --nodes, --report <файл>, --help.

Варіант 24. Метеомодель з контрольними точками

1. Початковий рівень. Створити консольну програму мовою C++, яка моделює поширення температури на сітці 500×500 (явна схема), кожні 100 кроків записує контрольну точку у файл, а під час запуску продовжує з останньої контрольної точки, якщо вона є; та скрипт sbatch з лімітом часу 2 хв.

2. Базовий рівень. Створити програму мовою C++, що моделює поширення температури на сітці явною схемою й за сигналом USR1 записує контрольну точку й завершується, а під час запуску продовжує з останньої контрольної точки, та скрипт sbatch з ключами --signal=B:USR1@30 і --requeue. Обробник сигналу (trap) у скрипті передає сигнал програмі, після чого скрипт повторно ставить завдання в чергу (scontrol requeue $SLURM_JOB_ID), доки не виконано задану кількість кроків, і виводить номер перезапуску (SLURM_RESTART_COUNT) і крок, з якого продовжено.

3. Високий рівень. Створити проєкт weathercp (MPI-програма мовою C++ з розподіленою сіткою і скрипти), яка записує узгоджені контрольні точки всіх рангів (MPI_File_write_at_all або окремі файли з маніфестом), перевіряє цілісність контрольної точки під час відновлення (контрольна сума), підтримує зміну кількості процесів між перезапусками і збирає звіт: кількість перезапусків, втрачений час, накладні витрати на запис контрольних точок. Опції --steps, --checkpoint-every, --size, --help.

Варіант 25. Порівняння mpirun і srun

1. Початковий рівень. Створити скрипт sbatch, який в одному виділенні з 8 задачами запускає MPI-програму обчислення $\pi$ командами srun --mpi=pmix і mpirun та виводить для обох випадків час виконання, виміряний командою time.

2. Базовий рівень. Створити скрипт sbatch, який вимірює накладні витрати запуску (програма MPI з мінімальною роботою) для 1, 2, 4, 8 і 16 процесів командами srun --mpi=pmix і mpirun (з --use-hwthread-cpus, коли процесів більше, ніж ядер) по 5 разів і виводить таблицю медіан «процеси – srun, с – mpirun, с – різниця».

3. Високий рівень. Створити дослідження launchbench (MPI-програма мовою C++ і скрипти), яке вимірює окремо час запуску (від команди до MPI_Init), час MPI_Init і час завершення для srun (PMIx), mpirun на одному вузлі й на кількох вузлах, перевіряє, чи обліковує sacct задачі в кожному випадку, і будує звіт з CSV. Опції --procs, --nodes, --repeat, --help.

Варіант 26. Прогноз часу очікування

1. Початковий рівень. Створити скрипт bash, який за виводом sacct -X --allusers --parsable2 за останній тиждень обчислює середній і найбільший час очікування (Start – Submit) завдань кожного розділу.

2. Базовий рівень. Створити консольну програму C#, яка читає файл з виводом sacct --parsable2 (поля Partition, NCPUS, Timelimit, Submit, Start), групує завдання за розділом і розміром (1, 2–4, 5–16, понад 16 CPU) та лімітом часу і виводить таблицю медіани й 90-го процентиля очікування для кожної групи, пропускаючи рядки з помилками формату.

3. Високий рівень. Створити консольний застосунок C# waitforecast, який приймає опції --history <файл>, --partition, --cpus <n>, --time <хв> і --help, будує модель прогнозу часу очікування за історією (подібні завдання за розміром, лімітом і часом доби, зважене середнє), порівнює прогноз з фактичним очікуванням на останніх 20 % історії (середня абсолютна похибка) і виводить прогноз для заданого завдання разом з squeue --start для порівняння.

Варіант 27. Кластер на віртуальних машинах

1. Початковий рівень. Створити скрипт PowerShell, який створює у Hyper-V внутрішній комутатор ClusterNet (якщо його немає) і віртуальну машину другого покоління із заданим аргументами ім’ям, кількістю процесорів і пам’яттю, вимкненою динамічною пам’яттю та підключеним образом ISO.

2. Базовий рівень. Створити скрипт bash для підготовки нового обчислювального вузла, який приймає ім’я й IP-адресу, перевіряє їхній формат, записує конфігурацію Netplan, ім’я вузла, рядки /etc/hosts, встановлює slurmd, munge, nfs-common, копіює munge.key і slurm.conf з head, запускає служби та перевіряє munge -n | ssh head unmunge, виводячи результат кожного кроку.

3. Високий рівень. Створити набір скриптів deploycluster (PowerShell для Hyper-V і bash для вузлів), який за файлом опису кластера (імена, IP, vCPU, пам’ять) створює ВМ, після встановлення Ubuntu налаштовує вузли (мережа, користувачі з однаковими UID, chrony, SSH-ключі, NFS, MUNGE, Slurm), генерує slurm.conf за slurmd -C, перевіряє кластер (sinfo, srun -N<n> hostname) і виводить звіт. Кожен крок ідемпотентний (повторний запуск не змінює налаштованого); опції --config, --only <етап>, --help.

Варіант 28. Мережеві затримки між вузлами

1. Початковий рівень. Створити MPI-програму мовою C++ «пінг-понг» для двох рангів, яка 1000 разів пересилає повідомлення 8 байтів і виводить середню затримку в мікросекундах, і скрипт sbatch, що запускає її на двох вузлах (--nodes=2 --ntasks-per-node=1) і на одному вузлі.

2. Базовий рівень. Створити MPI-програму «пінг-понг», яка вимірює затримку й пропускну здатність для повідомлень від 1 байта до 16 МБ (степені двійки), і скрипт sbatch, що запускає її між вузлами й на одному вузлі та виводить таблицю «розмір – затримка, мкс – пропускна здатність, МБ/с» для обох випадків.

3. Високий рівень. Створити дослідження netbench (MPI-програма мовою C++ і скрипти), яке вимірює затримку, пропускну здатність і час MPI_Allreduce між усіма парами вузлів кластера, перевіряє MTU інтерфейсів (ip link) і можливість передавання кадрів 9000 байтів (ping -M do -s 8972), будує матрицю затримок між вузлами, позначає аномальні пари й оцінює (за моделлю $t=\alpha +n/\beta$) параметри мережі. Опції --sizes, --repeat, --csv, --help.

Варіант 29. Порівняльний звіт вузлів

1. Початковий рівень. Створити скрипт bash, який надсилає однакове завдання (однопотоковий тест обчислення $\pi$) на кожен вузол розділу за допомогою ключа -w <вузол> і після завершення виводить час на кожному вузлі.

2. Базовий рівень. Створити скрипт bash, який отримує список вузлів з sinfo -N -h -o %N, надсилає на кожен вузол тести процесора (однопотоковий і багатопотоковий) і пам’яті (копіювання масиву 1 ГБ) по 3 рази, збирає результати й виводить таблицю вузлів з відхиленням від медіани кластера, позначаючи вузли з відхиленням понад 10 %.

3. Високий рівень. Створити інструмент nodeaudit (скрипти й програма тестів мовою C++ з OpenMP), який регулярно (опція --schedule генерує завдання з --begin) тестує вузли, зберігає історію результатів у CSV, виявляє аномалії (відхилення від історичної медіани понад поріг) і пропонує команду виведення вузла в DRAIN з причиною. Опції --nodes, --threshold, --history <файл>, --help; код 3 – знайдено аномальні вузли.

Варіант 30. Спільна тека проєкту

1. Початковий рівень. Створити скрипт bash для адміністратора, який створює групу proj з однаковим GID на всіх вузлах (pdsh), каталог /home/proj з власником root:proj, правами 2770, і перевіряє права через ls -ld на кожному вузлі.

2. Базовий рівень. Створити скрипт sbatch з масивом із 6 елементів на різних вузлах, кожен з яких записує у спільний каталог проєкту файл із номером елемента й ім’ям вузла, дописує рядок у спільний журнал з блокуванням flock і перевіряє групу створеного файлу; завдання з умовою afterok перевіряє, що всі файли й рядки журналу на місці та мають групу proj.

3. Високий рівень. Створити інструмент projshare (bash), який приймає опції --create <проєкт>, --add-user <користувач>, --check, --quota <ГБ> і --help, створює групу й каталог на сервері NFS, додає користувачів на всіх вузлах з однаковими GID, запускає тестові завдання запису з кількох вузлів одночасно, вимірює швидкість запису в NFS (МБ/с) і перевіряє права доступу для сторонніх користувачів. Код 2 – перевірка прав не пройдена.

Порядок виконання та захисту роботи

1. Опрацювати теоретичні відомості та приклади розв’язання завдань.
2. Створити чотири ВМ Hyper-V (head, node01–node03), встановити Ubuntu Server 26.04, налаштувати статичні адреси, /etc/hosts, однакових користувачів, chrony, вхід SSH за ключем і перевірити вузли скриптом check-nodes.sh.
3. Налаштувати NFS для /home, встановити MUNGE і Slurm, скопіювати munge.key, записати slurm.conf і cgroup.conf за виводом slurmd -C, запустити служби й перевірити sinfo, srun -N3 hostname.
4. Виконати завдання свого варіанта: скрипти sbatch, програми та звіти зберегти в репозиторії; для вимірювань часу – прогрівання, медіана щонайменше 5 запусків, таблиця й графік.
5. Для завдань про налаштування ОС записати значення параметрів до й після зміни та результат вимірювань; на ВМ, де параметр недоступний, пояснити причину.
6. Продемонструвати кластер і результати, пояснити скрипти та вивід squeue, sacct, sinfo, відповісти на контрольні питання. Після захисту зупинити ВМ або зробити контрольні точки.