Завдання

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

Завдання мовою CUDA C++ виконують в Ubuntu 26.04 (WSL2, CMake і Ninja або CLion), завдання з ILGPU – у Rider; якщо GPU NVIDIA недоступний, програми ILGPU запускають на CPU-акселераторі.

Варіанти

Варіант 1. Фільтр Собеля

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка генерує зображення 1920×1080 у відтінках сірого (коло на градієнтному тлі), обчислює модуль градієнта фільтром Собеля ядром на 2D-сітці блоків 16×16 і записує результат у файл sobel.pgm.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка читає зображення PGM (P5), ім’я якого вводить користувач, перевіряє формат, застосовує фільтр Собеля на GPU і на CPU (OpenMP), перевіряє збіг результатів і виводить час копіювань, ядра та CPU, виміряний подіями CUDA й std::chrono, а також прискорення з урахуванням копіювань і без них.

3. Високий рівень. Створити проєкт CMake з програмою sobel, яка застосовує до зображення PGM фільтр Собеля (модуль градієнта) на GPU мовою CUDA C++ і приймає опції --input <файл.pgm>, --output <файл.pgm>, --block 8|16|32, --repeat <k>, --csv <файл> і --help. Програма обробляє зображення ядром зі спільною пам’яттю (тайл із рамкою) і без неї, виводить таблицю медіанних часів для кожного розміру блоку й записує CSV. Помилки формату файлу та опцій – у stderr з кодом завершення 1.

Варіант 2. Множина Мандельброта на ILGPU і CUDA

1. Початковий рівень. Створити консольну програму мовою C# з бібліотекою ILGPU, яка обчислює множину Мандельброта 1600×1200 (не більше 500 ітерацій) ядром з індексом Index2D на GPU і записує зображення у файл mandel.pgm.

2. Базовий рівень. Створити консольну програму мовою C# з ILGPU, яка запитує роздільність (від 320×240 до 7680×4320) і максимальну кількість ітерацій, перевіряє введення, обчислює множину Мандельброта на GPU (або на CPU-акселераторі, якщо GPU немає) і за допомогою Parallel.For, перевіряє збіг загальної кількості ітерацій з допуском 0,01 % і виводить таблицю часу.

3. Високий рівень. Створити дві програми, що обчислюють множину Мандельброта на GPU: CUDA C++ mandel і C# ILGPU MandelNet. Обидві приймають однакові опції --size <ш>x<в>, --iter <n>, --float|--double, --csv <файл> і --help та записують у CSV роздільність, спосіб, час ядра й копіювання. Сценарій запускає обидві програми для чотирьох роздільностей і будує зведену таблицю; некоректні опції – код 1.

Варіант 3. SAXPY і закріплена пам’ять

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка обчислює $y=ax+y$ для ${10}^7$ чисел float ядром з перевіркою меж, перевіряє результат на CPU і виводить найбільшу похибку.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує довжину векторів (від ${10}^3$ до $2\cdot {10}^8$) і для звичайної та закріпленої (cudaMallocHost) пам’яті вимірює подіями CUDA час копіювання на GPU, ядра SAXPY і копіювання назад, виводить таблицю часу й пропускної здатності копіювань у ГБ/с.

3. Високий рівень. Створити проєкт CMake з програмою saxpybench мовою CUDA C++, яка обчислює SAXPY ($y=ax+y$ для float) і приймає опції --sizes 1e3,1e5,1e7, --memory pageable,pinned,managed, --csv <файл> і --help. Для кожної комбінації програма вимірює медіану п’яти запусків повного циклу (копіювання, ядро, копіювання назад) і окремо ядра, порівнює з OpenMP і виводить розмір, з якого GPU стає вигіднішим за CPU. Помилки виділення пам’яті – код 2.

Варіант 4. Множення матриць з тайлами

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

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує розмір $n$ (кратний 32), множить матриці наївним ядром і ядром із тайлами 16×16 у спільній пам’яті, перевіряє похибку відносно CPU і виводить таблицю часу, GFLOPS і прискорення.

3. Високий рівень. Створити проєкт CMake з програмою matmulbench мовою CUDA C++, яка множить випадкові матриці $n\times n$ власними ядрами з тайлами (довільні $n$, перевірка меж) і приймає опції --sizes 512,1024,2048, --tiles 8,16,32, --cublas, --csv <файл> і --help. Програма порівнює власні ядра з cuBLAS (cublasSgemm) і OpenMP та виводить таблицю GFLOPS з позначкою найкращого ядра. Розмір менше 1 – код 1.

Варіант 5. Задача n тіл

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка для 4096 тіл із випадковими масами й координатами обчислює на GPU прискорення кожного тіла від усіх інших (закон тяжіння з пом’якшенням $ϵ=0,01$) і виводить прискорення перших п’яти тіл.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує кількість тіл і кроків, моделює рух тіл під дією взаємного тяжіння (випадкові маси й координати) методом Ейлера на GPU (дані залишаються на пристрої між кроками), перевіряє збереження імпульсу системи та виводить кількість кроків за секунду для GPU і OpenMP.

3. Високий рівень. Створити проєкт CMake з програмою nbody мовою CUDA C++, яка моделює рух тіл під дією взаємного тяжіння, завантажуючи тайли тіл у спільну пам’ять, з опціями --bodies <n>, --steps <k>, --tile <t>, --csv <файл> і --help. Програма записує траєкторії трьох тіл у CSV і виводить таблицю «кількість тіл – кроків/с GPU – кроків/с CPU – прискорення» для 1024–32 768 тіл.

Варіант 6. Гістограма супутникових знімків

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка для згенерованого знімка 4096×4096 (значення каналу 0–255) будує гістограму з 256 кошиків атомарними операціями на GPU і виводить 10 найчастіших значень.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка читає файл PGM, ім’я якого вводить користувач, будує гістограму глобальними атомарними операціями, локальними гістограмами у спільній пам’яті та OpenMP, перевіряє збіг і виводить таблицю часу.

3. Високий рівень. Створити проєкт CMake з програмою histo, яка приймає кілька файлів PGM, опції --bins 16|64|256, --csv <файл> і --help, обробляє знімки пакетом у двох потоках CUDA із закріпленою пам’яттю, виводить для кожного знімка середню яскравість і частку «хмар» (яскравість понад 200) та підсумковий час; нечитабельний файл – stderr, код 1.

Варіант 7. Розмиття Гаусса

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка розмиває зображення 1920×1080 у відтінках сірого фільтром Гаусса 5×5 (коефіцієнти в константній пам’яті) і записує результат у файл blur.pgm.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка генерує зображення у відтінках сірого, запитує $\sigma$ (від 0,5 до 5), будує ядро фільтра Гаусса розміром $6\sigma +1$, завантажує його в константну пам’ять функцією cudaMemcpyToSymbol, розмиває зображення на GPU і на CPU, перевіряє похибку та виводить час і прискорення.

3. Високий рівень. Створити проєкт CMake з програмою gauss, яка приймає опції --input, --output, --sigma <s>, --separable, --csv <файл> і --help, реалізує двовимірне й розділене (рядки, потім стовпці) розмиття, порівнює їх час і похибку та виводить таблицю для $\sigma =1,2,4$. Некоректна $\sigma$ – код 1.

Варіант 8. Монте-Карло для числа π

1. Початковий рівень. Створити консольну програму мовою CUDA C++, у якій кожен потік генерує 1000 випадкових точок власним генератором (лінійний конгруентний із зерном, залежним від номера потоку), рахує точки всередині чверті кола, а хост обчислює $\pi$ і похибку.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка оцінює $\pi$ методом Монте-Карло: запитує кількість випадкових точок (до ${10}^{10}$), підраховує точки всередині чверті кола редукцією у спільній пам’яті та atomicAdd, виводить оцінку $\pi$, абсолютну похибку й кількість вибірок за секунду для GPU і OpenMP.

3. Високий рівень. Створити проєкт CMake з програмою montecarlo мовою CUDA C++, яка оцінює $\pi$ методом Монте-Карло (частка випадкових точок у чверті кола) з опціями --samples <n>, --generator lcg|curand, --runs <k>, --csv <файл> і --help. Програма порівнює власний генератор з cuRAND, виводить таблицю «вибірки – оцінка – похибка – довірчий інтервал 95 % – вибірок/с» і перевіряє, що похибка зменшується пропорційно $1/\sqrt{n}$.

Варіант 9. Теплопровідність 2D

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка моделює нагрівання пластини 512×512 (верхній край 100 °C) явною схемою з $r=0,2$ протягом 1000 кроків, чергуючи два буфери на GPU, і виводить температуру в центрі.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує розмір сітки й кількість кроків і моделює нагрівання квадратної пластини (верхній край 100 °C) явною схемою на GPU без копіювань між кроками та на CPU з OpenMP, перевіряє різницю розв’язків (не більше ${10}^{-4}$) і виводить час на крок.

3. Високий рівень. Створити проєкт CMake з програмою heatgpu мовою CUDA C++, яка моделює нагрівання квадратної пластини явною схемою на GPU з опціями --size <n>, --steps <k>, --snapshot <кожні k кроків>, --shared, --csv <файл> і --help. Програма зберігає знімки поля температур у файли PGM через асинхронні копіювання в окремому потоці CUDA та порівнює ядро зі спільною пам’яттю з простим ядром; помилки запису файлів – код 2.

Варіант 10. Анімація множини Жюліа

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка обчислює 60 кадрів 800×600 множини Жюліа для $c=0,7885e^{i\alpha }$, $\alpha$ від 0 до $2\pi$, і записує кадри у файли frame00.pgm–frame59.pgm.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує роздільність і кількість кадрів, обчислює кадри анімації множини Жюліа ($c=0,7885e^{i\alpha }$, $\alpha$ від 0 до $2\pi$) на GPU і на CPU (OpenMP) та виводить кількість кадрів за секунду з урахуванням копіювання кадру на хост і без нього.

3. Високий рівень. Створити проєкт CMake з програмою julia мовою CUDA C++, яка обчислює кадри анімації множини Жюліа ($c=0,7885e^{i\alpha }$) і записує їх у PGM, з опціями --size, --frames, --streams 1|2|4, --output <тека> і --help. Програма перекриває обчислення наступного кадру з копіюванням і записом попереднього (закріплена пам’ять, кілька потоків CUDA) та виводить таблицю кадрів за секунду для різної кількості потоків.

Варіант 11. Гра «Життя» на ILGPU

1. Початковий рівень. Створити консольну програму мовою C# з ILGPU, яка моделює гру «Життя» на полі 256×256 з тороїдальними межами (початкове поле – випадкове, зерно 11) протягом 100 поколінь ядром Index2D і виводить кількість живих клітин.

2. Базовий рівень. Створити консольну програму мовою C# з ILGPU, яка запитує розмір поля й кількість поколінь, моделює гру «Життя» Конвея з тороїдальними межами (випадкове початкове поле) на GPU і за допомогою Parallel.For, перевіряє однаковість полів після кожних 10 поколінь і виводить кількість поколінь за секунду.

3. Високий рівень. Створити застосунок мовою C# з ILGPU, який моделює гру «Життя» Конвея з опціями --size, --generations, --pattern <файл RLE>, --accelerator cuda|cpu, --csv і --help. Програма читає початкову фігуру у форматі RLE, моделює її на обраному акселераторі, записує кожне соте покоління у PGM і виводить таблицю продуктивності для полів від 256 до 8192.

Варіант 12. Редукція максимуму

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка знаходить максимум масиву з $2^{24}$ випадкових чисел float ядром редукції у спільній пам’яті (другий етап – на CPU) і перевіряє результат.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує довжину масиву, знаходить максимум і його індекс двома ядрами (чергування адрес і послідовна адресація), порівнює з thrust::max_element і OpenMP та виводить таблицю часу й ГБ/с.

3. Високий рівень. Створити проєкт CMake з програмою reducemax мовою CUDA C++, яка знаходить максимум масиву випадкових float ядрами редукції у спільній пам’яті (чергування адрес, послідовна адресація) і, з опцією --warp-shuffle, редукцією всередині варпа функцією __shfl_down_sync. Опції --size, --threads 128,256,512, --csv, --help. Програма порівнює всі варіанти для трьох розмірів блоку, перевіряє результат на CPU і виводить частку пікової пропускної здатності пам’яті GPU.

Варіант 13. Пакетна зміна розміру зображень

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка зменшує згенероване зображення 3840×2160 до 1280×720 білінійною інтерполяцією на GPU і записує результат у PGM.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує файл PGM і масштаб (від 0,1 до 4), змінює розмір білінійною інтерполяцією на GPU й CPU, перевіряє різницю (не більше 1) та виводить час копіювань і ядра.

3. Високий рівень. Створити проєкт CMake з програмою resize мовою CUDA C++, яка змінює розмір усіх зображень PGM з теки білінійною інтерполяцією на GPU з опціями --width <w>, --height <h>, --streams <k>, --output <тека> і --help. Файли обробляються пакетом у $k$ потоках CUDA; програма виводить таблицю часу для $k=1,2,4$; відсутня тека – код 1.

Варіант 14. Пошук nonce (навчальне хешування)

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка для рядка «block-42» перебирає на GPU значення nonce від 0 до $2^{28}$, обчислює 32-бітовий хеш FNV-1a рядка з nonce і виводить найменший nonce, для якого хеш має 20 старших нульових бітів.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує рядок і складність (кількість нульових бітів від 8 до 28), шукає nonce на GPU (перший знайдений – через atomicMin) і на CPU (OpenMP) та виводить nonce, хеш і кількість хешів за секунду.

3. Високий рівень. Створити проєкт CMake з програмою miner мовою CUDA C++, яка шукає nonce, для якого 32-бітовий хеш FNV-1a рядка --data з nonce має --difficulty старших нульових бітів. Опції --batch <n>, --timeout <с>, --help. Програма перебирає nonce пакетами на GPU і CPU (OpenMP) з раннім завершенням, виводить таблицю «складність – час – хешів/с» для GPU і CPU та повертає код 3, якщо nonce не знайдено до тайм-ауту.

Варіант 15. k-means для кольорів

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка для згенерованого кольорового зображення 1024×1024 призначає кожен піксель найближчому з 8 заданих кольорів ядром на GPU і виводить кількість пікселів кожного кольору.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка генерує кольорове зображення, запитує кількість кольорів $k$ (від 2 до 32) і ітерацій та квантує кольори алгоритмом k-means: призначення пікселів найближчим центрам і суми кластерів на GPU (атомарні операції), нові центри на CPU. Програма виводить центри й час ітерації.

3. Високий рівень. Створити проєкт CMake з програмою quantize мовою CUDA C++, яка зменшує кількість кольорів зображення PPM до $k$ алгоритмом k-means (призначення пікселів і суми кластерів на GPU) з опціями --input <файл.ppm>, --output <файл.ppm>, --k <n>, --max-iter, --eps і --help. Програма зупиняється, коли центри зміщуються менше ніж на eps, записує зображення з палітрою $k$ кольорів і порівнює час з OpenMP-версією; помилки формату PPM – код 1.

Варіант 16. Трасування сфер на ILGPU

1. Початковий рівень. Створити консольну програму мовою C# з ILGPU, яка трасує один промінь на піксель для сцени з трьох сфер (структури, без класів) і записує зображення 800×600 у PGM з освітленістю за законом Ламберта.

2. Базовий рівень. Створити консольну програму мовою C# з ILGPU, яка запитує роздільність і кількість випадкових сфер (від 1 до 100), рендерить сцену трасуванням одного променя на піксель з освітленням за законом Ламберта на GPU і за допомогою Parallel.For, перевіряє збіг зображень (різниця не більше 1) і виводить час та прискорення.

3. Високий рівень. Створити застосунок мовою C# з ILGPU, який рендерить сцену зі сфер трасуванням променів (освітлення за Ламбертом, опція --shadows – тіні) з опціями --scene <файл JSON>, --size, --accelerator cuda|cpu, --output і --help. Програма читає сцену з файлу, рендерить на обраному акселераторі, записує зображення й виводить таблицю часу для кількох роздільностей; помилки файлу сцени – код 1.

Варіант 17. Згортка аудіосигналу

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка генерує сигнал 10 с при 48 кГц (сума синусоїд) і застосовує фільтр ковзного середнього з 64 коефіцієнтами, розміщеними в константній пам’яті, виводячи перші 10 відліків результату.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка читає WAV-файл (16 біт, моно), ім’я якого вводить користувач, застосовує фільтр нижніх частот із заданою кількістю коефіцієнтів (до 1024) на GPU і CPU, перевіряє похибку й записує результат у новий WAV.

3. Високий рівень. Створити проєкт CMake з програмою fir мовою CUDA C++, яка застосовує до WAV-файлу (16 біт, моно) FIR-фільтр нижніх частот на GPU з опціями --input, --output, --cutoff <Гц>, --taps <n>, --shared і --help. Програма порівнює ядро з коефіцієнтами в константній пам’яті та ядро з тайлом сигналу у спільній пам’яті й виводить таблицю часу для 64–4096 коефіцієнтів; непідтримуваний формат WAV – код 1.

Варіант 18. Ціни опціонів Блека–Шоулза

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка обчислює ціни європейських опціонів call і put за формулою Блека–Шоулза для ${10}^6$ випадкових наборів параметрів на GPU і виводить перші п’ять результатів.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує кількість опціонів, обчислює ціни на GPU в float і double та на CPU (OpenMP), перевіряє паритет call–put і виводить час, прискорення й найбільшу розбіжність.

3. Високий рівень. Створити проєкт CMake з програмою options з опціями --count, --precision float|double, --csv <вхід>, --output <файл> і --help, яка читає параметри опціонів із CSV, обчислює ціни й «греки» (дельта, вега) на GPU і порівнює час float/double з урахуванням копіювань; некоректний рядок CSV – повідомлення з номером рядка, код 1.

Варіант 19. Префіксна сума

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка обчислює префіксну суму масиву з 1024 цілих чисел в одному блоці алгоритмом Блеллока у спільній пам’яті та перевіряє результат на CPU.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує довжину масиву (до ${10}^8$), обчислює префіксну суму ієрархічно (суми блоків, скан сум, додавання), порівнює з thrust::inclusive_scan і std::inclusive_scan та виводить час.

3. Високий рівень. Створити проєкт CMake з програмою scan з опціями --size, --type int|float, --exclusive, --csv і --help, яка використовує скан для стиснення масиву (залишити додатні елементи), перевіряє результат і виводить таблицю часу власної реалізації й Thrust для п’яти розмірів.

Варіант 20. Матриця відстаней між містами

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка для 2000 міст із випадковими координатами (широта, довгота) обчислює на GPU матрицю відстаней за формулою гаверсинуса 2D-ядром і виводить найближчу пару міст.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка читає міста з CSV (назва, широта, довгота), обчислює матрицю відстаней у float і double на GPU, порівнює похибку й час та виводить для кожного міста найближче.

3. Високий рівень. Створити проєкт CMake з програмою distances з опціями --input <файл.csv>, --precision float|double, --output <файл> і --help, яка обробляє до 50 000 міст частинами, що вміщуються в пам’ять GPU, записує матрицю у двійковий файл і виводить час та обсяг переданих даних; помилки CSV – код 1.

Варіант 21. Система частинок фейєрверку

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка моделює ${10}^6$ частинок (положення, швидкість, гравітація) протягом 500 кроків на GPU і виводить середню висоту частинок.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка моделює частинки фейєрверку (положення, швидкість, гравітація) на GPU двома способами: з уніфікованою пам’яттю (cudaMallocManaged) і з явними копіюваннями. Програма запитує кількість частинок і кроків та виводить час обох варіантів і перевірку однаковості результатів.

3. Високий рівень. Створити проєкт CMake з програмою fireworks мовою CUDA C++, яка моделює частинки фейєрверку (положення, швидкість, гравітація) на GPU з опціями --particles, --steps, --memory managed|explicit, --frames <тека> і --help. Кожні 50 кроків програма малює кадр (PGM) з положень частинок атомарними операціями й виводить таблицю часу для двох способів керування пам’яттю.

Варіант 22. Сегментація КТ-зрізів

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка генерує тривимірний об’єм 256×256×128 (сфера щільності 1000 у середовищі 0) і позначає вокселі із щільністю понад поріг ядром на 3D-сітці, виводячи кількість позначених вокселів.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує розміри тривимірного об’єму й два пороги, генерує об’єм КТ (сфера щільності 1000 у середовищі 0), виконує порогову сегментацію (вокселі між порогами) на GPU з блоками $8\times 8\times 8$ і на CPU, перевіряє збіг і виводить об’єм сегмента в мл (воксель 0,5 мм).

3. Високий рівень. Створити проєкт CMake з програмою ctseg з опціями --input <файл.raw>, --dims <x>x<y>x<z>, --low, --high, --slices <тека> і --help, яка читає 16-бітовий об’єм, сегментує його, записує зрізи у PGM і виводить таблицю часу для блоків $4^3$, $8^3$, $16\times 16\times 4$; розбіжність розміру файлу – код 1.

Варіант 23. Хвильове рівняння

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка моделює коливання струни з 10 000 точок (початковий «горб» у центрі) явною схемою протягом 5000 кроків на GPU і виводить відхилення в п’яти точках.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка моделює двовимірне хвильове рівняння на сітці $n\times n$ (вводить користувач) з ядром зі спільною пам’яттю для шаблону 5 точок і простим ядром, перевіряє збіг і виводить час кроку.

3. Високий рівень. Створити проєкт CMake з програмою wave мовою CUDA C++, яка моделює двовимірне хвильове рівняння явною схемою (шаблон 5 точок) на GPU з опціями --size, --steps, --source <x,y> (точка початкового збурення), --frames <тека> і --help. Програма вимірює час кроку для сіток 512–8192, виводить таблицю «сітка – мс на крок – ГБ/с – прискорення відносно OpenMP» і записує кадри поля.

Варіант 24. Перетворення RGB→HSV

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка перетворює згенероване зображення 1920×1080 з RGB у HSV на GPU і виводить кількість пікселів із відтінком у діапазоні червоного (0–20° або 340–360°).

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка читає PPM-файл (імітація фото номера авто), будує маску пікселів заданого кольору в HSV (межі вводить користувач), записує маску у PGM і виводить час GPU та CPU.

3. Високий рівень. Створити проєкт CMake з програмою colormask з опціями --input <тека>, --hue <min>-<max>, --sat <min>, --val <min>, --output <тека> і --help, яка обробляє всі PPM у теці, знаходить обмежувальний прямокутник маски атомарними atomicMin/atomicMax і виводить таблицю файлів із координатами й часом.

Варіант 25. Сортування підрахунком

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка сортує ${10}^7$ випадкових оцінок від 0 до 100: будує гістограму ключів на GPU, обчислює зміщення на CPU і перевіряє впорядкованість.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує кількість ключів і діапазон (до 65 536 значень), сортує підрахунком з локальними гістограмами на GPU, порівнює з thrust::sort і std::sort та виводить таблицю часу.

3. Високий рівень. Створити проєкт CMake з програмою countsort з опціями --count, --range, --stable, --csv і --help, яка сортує пари «ключ – значення» стабільно (префіксна сума на GPU), перевіряє стабільність і виводить час для п’яти розмірів із копіюваннями та без них.

Варіант 26. Шум Перліна на ILGPU

1. Початковий рівень. Створити консольну програму мовою C# з ILGPU, яка генерує карту висот 1024×1024 градієнтним шумом Перліна (таблиця перестановок передається в ядро як ArrayView<int>) і записує її у PGM.

2. Базовий рівень. Створити консольну програму мовою C# з ILGPU, яка запитує розмір карти, кількість октав і зерно, генерує карту висот фрактальним шумом Перліна (сума октав) на GPU і за допомогою Parallel.For, перевіряє збіг (допуск ${10}^{-5}$) і виводить час.

3. Високий рівень. Створити застосунок мовою C# з ILGPU, який генерує карту висот ландшафту фрактальним шумом Перліна з опціями --size, --octaves, --seed, --water <рівень>, --output і --help, розфарбовує її за висотою (PPM), обчислює частку води (висота нижче рівня) редукцією з ILGPU.Algorithms і виводить таблицю часу для CUDA- та CPU-акселератора.

Варіант 27. Відстань Геммінга для ДНК

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка порівнює 100 000 випадкових послідовностей ДНК довжиною 128 з еталонною на GPU й виводить кількість послідовностей з відстанню Геммінга не більше 10.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує кількість і довжину послідовностей ДНК, генерує випадкові послідовності й еталонну, кодує нуклеотиди двома бітами, обчислює відстані Геммінга до еталонної на GPU (__popc) і на CPU та виводить пропускну здатність у мільйонах порівнянь за секунду.

3. Високий рівень. Створити проєкт CMake з програмою hamming з опціями --reads <файл FASTA>, --reference <файл>, --max-dist <d>, --batch <n> і --help, яка обробляє файл пакетами з перекриттям копіювань і обчислень, виводить знайдені збіги та таблицю часу для розмірів пакета; помилки формату FASTA – код 1.

Варіант 28. Розріджене множення CSR

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка множить розріджену тридіагональну матрицю ${10}^6\times {10}^6$ у форматі CSR на вектор одиниць (потік на рядок) і перевіряє результат.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка генерує випадкову розріджену матрицю із заданою кількістю ненульових елементів у рядку, множить її на вектор на GPU (потік на рядок і варп на рядок) та з OpenMP і виводить таблицю часу й GFLOPS.

3. Високий рівень. Створити проєкт CMake з програмою spmv з опціями --matrix <файл .mtx>, --kernel scalar|vector, --iterations <k> і --help, яка читає матрицю у форматі Matrix Market, виконує 100 ітерацій методу степенів на GPU без копіювань між ними й виводить час ітерації та оцінку найбільшого власного значення.

Варіант 29. Виживання популяції (Монте-Карло)

1. Початковий рівень. Створити консольну програму мовою CUDA C++, у якій кожен потік моделює популяцію з 50 особин протягом 100 років (випадкові народження й смерті) і рахує частку з ${10}^6$ симуляцій, у яких популяція вижила.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка запитує початковий розмір популяції, ймовірності народження й смерті та кількість симуляцій, обчислює ймовірність виживання на GPU (cuRAND) і на CPU та виводить 95 % довірчий інтервал і час.

3. Високий рівень. Створити проєкт CMake з програмою survival з опціями --sizes 10,20,50,100, --birth, --death, --years, --sims, --csv і --help, яка будує залежність ймовірності виживання від початкового розміру, записує CSV і виводить таблицю з довірчими інтервалами; некоректні ймовірності – код 1.

Варіант 30. Аналіз програми в Nsight Systems

1. Початковий рівень. Створити консольну програму мовою CUDA C++, яка 20 разів копіює масив 64 МБ на GPU, виконує просте ядро й копіює результат назад, і отримати для неї звіт nsys profile --stats=true, вивівши частку часу копіювань.

2. Базовий рівень. Створити консольну програму мовою CUDA C++, яка обробляє 100 зображень 1920×1080 (перетворення в сірий і розмиття), у двох версіях: наївній (копіювання кожного кроку) та оптимізованій (закріплена пам’ять, дані на GPU між ядрами), і вивести час обох.

3. Високий рівень. Створити проєкт CMake з програмою pipeline мовою CUDA C++, яка обробляє пакет зображень на GPU (перетворення в сірий і розмиття) у версіях --version naive|pinned|streams (копіювання кожного кроку; закріплена пам’ять із даними на GPU між ядрами; кілька потоків CUDA) з позначками NVTX для етапів. Профілювати всі версії за допомогою nsys, скласти таблицю часу копіювань, ядер і загального часу за звітами cuda_gpu_mem_time_sum та cuda_gpu_kern_sum і пояснити вузькі місця.

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

1. Опрацювати теоретичні відомості та приклади розв’язання завдань.
2. Перевірити середовище: nvidia-smi і nvcc --version в Ubuntu у WSL2, зібрати приклад «Сума векторів» проєктом CMake (LANGUAGES CXX CUDA, CMAKE_CUDA_ARCHITECTURES).
3. Реалізувати послідовну версію завдання на CPU, потім ядро (ядра) GPU з перевіркою меж і перевіркою всіх викликів CUDA; переконатися, що результати GPU і CPU збігаються (для дійсних чисел – з допуском).
4. Виміряти час подіями CUDA (або Stopwatch для ILGPU) з прогріванням і медіаною кількох запусків окремо для ядра й копіювань; порівняти з найкращою версією для CPU (OpenMP або Parallel.For) і пояснити, чи вигідний GPU з урахуванням пересилань.
5. Продемонструвати роботу програми, пояснити код і результати вимірювань, відповісти на контрольні питання.