Контрольні завдання

Практичні завдання за темами курсу для перевірки знань. Кожне завдання — окрема програма.

Тема 1. Основи паралельних обчислень

1. Створити консольну програму, яка запитує частку паралельного коду (від 0 до 1) і кількість процесорів, перевіряє введення та виводить прискорення й ефективність за законом Амдала і межу прискорення.
2. Створити консольну програму, яка запитує послідовну частку програми та максимальну кількість процесорів і виводить таблицю масштабованого прискорення й ефективності за законом Густафсона–Барсіса для $p=1,2,4,\dots$ до заданого значення.
3. Створити консольну програму, яка читає з клавіатури пари «кількість процесорів – виміряний час» (серед них має бути вимірювання для одного процесора) і виводить таблицю прискорення, ефективності та метрики Карпа–Флатта.
4. Створити консольну програму, яка запитує бажане прискорення та частку паралельного коду і за законом Амдала визначає мінімальну кількість процесорів, потрібну для цього прискорення, або повідомляє, що воно недосяжне.
5. Створити консольну програму, яка за виміряним прискоренням на $p$ процесорах (вводяться користувачем) обчислює частку паралельного коду за законом Амдала та прогнозує прискорення для $2p$ і $4p$ процесорів.
6. Створити консольну програму, яка вимірює за допомогою Stopwatch час обчислення суми квадратів чисел від 1 до $n$ ($n$ вводиться), виконує прогрівання та 7 запусків і виводить мінімум, медіану й максимум часу.
7. Створити консольну програму, яка вимірює час трьох етапів обробки масиву випадкових чисел заданого користувачем розміру (заповнення, сортування, підрахунок суми), виводить частку кожного етапу та прогноз прискорення за законом Амдала для 8 ядер, якщо розпаралелити сортування.
8. Створити консольну програму, яка виводить звіт про апаратну та програмну конфігурацію комп’ютера: операційна система, архітектура, версія .NET, кількість логічних процесорів, доступна пам’ять, конфігурація збирання й точність таймера.
9. Створити консольну програму, яка запитує час виконання задачі на одному процесорі, частку паралельного коду та кількість процесорів і виводить прогнозований час, прискорення, ефективність і вартість (процесорний час) за законом Амдала.
10. Створити консольну програму, яка порівнює час обходу двовимірного масиву розміром $n\times n$ ($n$ вводиться) за рядками та за стовпцями (медіана 5 запусків з прогріванням) і виводить, у скільки разів один спосіб швидший за інший.

Тема 2. Процеси та потоки

11. Створити консольну програму, яка запитує кількість потоків N (від 1 до 32), запускає N іменованих потоків Thread, кожен з яких обчислює суму квадратів чисел від 1 до 1 000 000·(номер потоку), записує результат у свій елемент масиву, і після Join виводить таблицю «ім’я потоку – ManagedThreadId – результат».
12. Створити консольну програму, яка запитує розмір масиву та кількість потоків, заповнює масив випадковими числами (фіксоване зерно), обчислює суму масиву розбиттям на N потоків і послідовно, перевіряє збіг і виводить час обох варіантів, прискорення та ефективність.
13. Створити консольну програму, яка ставить у пул потоків 50 робіт (обчислення факторіала числа від 1 до 50 як BigInteger), чекає завершення всіх робіт і виводить результати в порядку номерів та кількість різних потоків пулу, що їх виконали.
14. Створити консольну програму, яка запускає фоновий потік, що кожні 100 мс збільшує лічильник, доки не встановлено прапорець volatile bool; основний потік після натискання Enter встановлює прапорець, чекає завершення потоку не довше 1 с і виводить значення лічильника та ознаку, чи завершився потік вчасно.
15. Створити консольну програму, яка запускає потік, що перетворює рядки з масиву на числа; виняток у потоці перехоплюється, зберігається й після Join виводиться основним потоком разом з номером некоректного рядка та сумою коректних чисел.
16. Створити консольну програму-координатор, яка запитує кількість процесів N, запускає себе N разів із аргументами --worker i N (дочірній процес рахує прості числа у своїй частині діапазону до 1 000 000), читає стандартний вивід кожного процесу, перевіряє коди завершення й виводить загальну кількість простих чисел і час.
17. Створити консольну програму, яка виводить маску спорідненості та клас пріоритету власного процесу, запитує нову маску у двійковому вигляді, перевіряє її коректність, встановлює маску й клас BelowNormal, виконує обчислення у 4 потоках і виводить час до та після зміни маски.
18. Створити консольну програму, яка за допомогою System.Threading.Timer виводить поточний час кожні N мілісекунд (N вводиться, від 100 до 5 000), зупиняє таймер після натискання Enter і виводить кількість спрацювань та номери потоків пулу, у яких виконувався обробник.
19. Створити консольну програму, яка запитує межу діапазону й максимальну кількість потоків, рахує прості числа розбиттям на 1, 2, 4, … потоків і виводить таблицю «потоки – час – прискорення – ефективність» з медіаною трьох запусків і перевіркою результату.
20. Створити консольну програму, яка в трьох потоках використовує ThreadLocal<Random> із різними зернами для генерації 1 000 000 випадкових чисел кожним потоком і лічильник ThreadLocal<int> з trackAllValues, а після завершення виводить середнє значення чисел кожного потоку та значення всіх лічильників.

Тема 3. Синхронізація потоків

21. Створити консольну програму, яка запитує кількість потоків і кількість збільшень на потік, виконує збільшення спільного лічильника без синхронізації, з Interlocked.Increment і з lock, та виводить таблицю «спосіб – отримане значення – очікуване значення – час, мс».
22. Створити консольну програму, яка запитує кількість потоків і діапазон цілих чисел, розбиває діапазон між потоками й знаходить максимальну суму цифр числа, оновлюючи спільний максимум CAS-циклом Interlocked.CompareExchange. Вивести максимум, число, у якого він досягається, і перевірку з послідовним обчисленням.
23. Створити консольну програму з класом банківського рахунку, у якому методи Deposit і Withdraw (без переходу в мінус) захищені окремим об’єктом Lock. Програма запитує кількість потоків і операцій, виконує випадкові операції та перевіряє, що кінцевий баланс дорівнює початковому плюс сума успішних операцій.
24. Створити консольну програму з обмеженим буфером на Monitor.Wait і Monitor.PulseAll. Користувач вводить ємність буфера, кількість виробників, споживачів і елементів; програма виводить кількість вироблених і спожитих елементів, їхні суми та максимальну заповненість буфера.
25. Створити консольну програму-модель пункту видачі посилок, яка запитує кількість вікон і клієнтів, обмежує одночасне обслуговування SemaphoreSlim з таймаутом очікування та виводить журнал подій, кількість відмов і максимальну кількість одночасно обслуговуваних клієнтів.
26. Створити консольну програму з довідником товарів, захищеним ReaderWriterLockSlim. Користувач вводить кількість читачів, кількість запитів і частку записів у відсотках; програма порівнює час роботи з lock і з ReaderWriterLockSlim та виводить кількість виконаних читань і записів.
27. Створити консольну програму, у якій користувач вводить кількість потоків-робітників. Робітники одночасно стартують за сигналом ManualResetEventSlim, виконують роботу випадкової тривалості, а основний потік чекає їх завершення через CountdownEvent. Вивести час старту й завершення кожного робітника.
28. Створити консольну програму, яка моделює перекази між рахунками в кількох потоках з наївним порядком блокування та виявляє взаємоблокування за таймаутом Join, а потім виконує ті самі перекази з упорядкуванням блокувань за номером рахунку. Вивести результат обох варіантів і перевірку загальної суми.
29. Створити консольну програму, яка розв’язує задачу про обідаючих філософів для кількості філософів, введеної користувачем, із захопленням виделок за допомогою Monitor.TryEnter з таймаутом і випадковою затримкою. Вивести кількість обідів і повторних спроб кожного філософа.
30. Створити консольну програму, яка запитує кількість учасників і кількість етапів змагання. На кожному етапі учасники-потоки готуються різний час і стартують одночасно через Barrier; програма виводить час кожного учасника на етапах і підсумкову таблицю місць.

Тема 4. Потокобезпечні колекції

31. Створити консольну програму, яка запитує кількість потоків (1–32) і кількість випадкових чисел, у кількох потоках рахує, скільки разів трапляється кожна остання цифра, у спільному ConcurrentDictionary<int, long> методом AddOrUpdate та виводить таблицю «цифра – кількість» і результат перевірки послідовним підрахунком.
32. Створити консольну програму, яка запитує кількість виробників, споживачів і елементів, реалізує патерн «виробник – споживач» на BlockingCollection<int> з обмеженою ємністю, коректно завершує всіх споживачів після завершення всіх виробників і виводить кількість та суму елементів кожного споживача з перевіркою загальної суми.
33. Створити консольну програму, яка запитує кількість рядків і ємність каналу, будує двоетапний конвеєр на обмежених каналах (генерація рядків чисел → обчислення суми рядка в двох задачах → підсумовування) та виводить загальну суму, кількість рядків і час, перевіряючи суму послідовним обчисленням.
34. Створити консольну програму, яка запитує кількість потоків і операцій, у кількох потоках кладе й вилучає завдання з ConcurrentQueue<int> лише методами Enqueue і TryDequeue та виводить кількість доданих, вилучених і залишених завдань із перевіркою, що жодне завдання не оброблено двічі.
35. Створити консольну програму, яка запитує кількість потоків і ключів, у кількох потоках одночасно запитує значення «дорогої» функції для ключів через ConcurrentDictionary<int, Lazy<long>> і виводить значення, час роботи та кількість викликів функції, яка має дорівнювати кількості ключів.
36. Створити консольну програму, яка запитує кількість потоків і чисел, рахує парні числа масиву в кількох потоках двома способами (лічильники в спільному масиві та локальні змінні), виконує прогрівання й медіану трьох запусків і виводить таблицю часу й прискорення для 1, 2, 4 і 8 потоків з поясненням різниці.
37. Створити консольну програму, у якій кілька потоків додають введену з клавіатури кількість рядків до спільного ImmutableList<string> через ImmutableInterlocked.Update, а потім програма виводить кількість елементів, кількість повторів перетворення та перевіряє, що список містить усі рядки.
38. Створити консольну програму, яка запитує ємність каналу та режим переповнення (DropOldest, DropNewest, DropWrite), швидко записує 10 000 чисел методом TryWrite в обмежений канал із повільним споживачем і виводить кількість записаних, прочитаних і відкинутих чисел, підраховану делегатом itemDropped.
39. Створити консольну програму, яка запитує кількість споживачів і завдань, додає завдання в BlockingCollection<string?> з «отруйними пігулками» (null) для завершення кожного споживача та виводить, скільки завдань обробив кожен споживач і що всі потоки завершилися.
40. Створити консольну програму з неблокуючим лічильником максимуму: кілька потоків (кількість вводиться) генерують випадкові числа й оновлюють спільний максимум CAS-циклом Interlocked.CompareExchange. Програма виводить знайдений максимум, кількість невдалих спроб CAS і перевіряє максимум послідовним проходом.

Тема 5. Задачі TPL і async/await

41. Створити консольну програму, яка запитує в користувача кількість задач N (1–16) і верхню межу M, розбиває діапазон 1…M на N частин, у кожній задачі Task.Run рахує прості числа, після Task.WhenAll виводить кількість простих чисел у кожній частині, загальну кількість і час обчислення та перевіряє результат послідовним підрахунком.
42. Створити консольну програму, яка одночасно запускає три імітовані запити до служб погоди з різними випадковими затримками, виводить першу отриману відповідь за допомогою Task.WhenAny, скасовує решту запитів токеном і виводить стани всіх задач.
43. Створити консольну програму, яка будує ланцюжок задач «прочитати файл → порахувати слова → записати результат у файл» за допомогою ContinueWith, додає продовження з OnlyOnFaulted для виведення помилки і перевіряє роботу для наявного та відсутнього файла, шлях до якого вводить користувач.
44. Створити консольну програму, яка запускає 5 задач, дві з яких кидають винятки різних типів, очікує їх через Task.WhenAll у блоці try, виводить перший виняток, перехоплений await, і всі винятки з властивості Exception, а також стан кожної задачі.
45. Створити консольну програму, яка обчислює суму ряду 1/k² для k від 1 до 2 мільярдів у задачі з токеном скасування, перевіряючи токен кожні 1 000 000 ітерацій. Користувач вводить таймаут у секундах (CancelAfter); програма виводить або результат, або повідомлення про скасування з кількістю виконаних ітерацій і стан задачі.
46. Створити консольну програму, яка асинхронно копіює файл, шлях до якого вводить користувач, блоками по 1 МБ, виводить прогрес у відсотках через власну реалізацію IProgress<int> і дозволяє скасувати копіювання клавішею Esc із вилученням неповної копії.
47. Створити консольну програму, яка асинхронно читає всі текстові файли заданої теки (File.ReadAllTextAsync) одночасно, не більше 4 файлів водночас (SemaphoreSlim), і виводить таблицю «файл – рядків – слів» з підсумковим рядком і загальним часом.
48. Створити консольну програму, яка запускає локальний тестовий сервер HttpListener з трьома сторінками (одна відповідає із затримкою 3 с) і за допомогою одного екземпляра HttpClient одночасно завантажує сторінки з таймаутом 1 с на запит, виводячи для кожної сторінки розмір або повідомлення про таймаут.
49. Створити консольну програму з асинхронним генератором IAsyncEnumerable<int>, який кожні 200 мс (PeriodicTimer) повертає випадкове число від 1 до 100. Програма перебирає числа циклом await foreach, виводить їх і поточне середнє та зупиняється через кількість секунд, введену користувачем, через токен скасування.
50. Створити консольну програму з класом-імітатором, який генерує подію Completed через випадковий час від 0,5 до 3 с. За допомогою TaskCompletionSource програма перетворює подію на задачу, очікує її з таймаутом 2 с (WaitAsync) і виводить результат очікування для 5 запусків.

Тема 6. Паралелізм даних і PLINQ

51. Створити консольну програму, яка запитує розмір масиву $n$ (від 10⁶ до 10⁸), заповнює його випадковими цілими числами від 0 до 999 (фіксоване зерно) і обчислює суму квадратів елементів послідовно та за допомогою Parallel.For з локальним станом потоку (localInit, localFinally). Програма перевіряє збіг сум і виводить час обох способів та прискорення.
52. Створити консольну програму, яка для масиву з $n$ дійсних чисел (розмір вводить користувач) обчислює середнє значення й дисперсію за допомогою Parallel.ForEach з Partitioner.Create(0, n, rangeSize), де розмір діапазону також вводить користувач, перевіряє результат послідовним обчисленням і виводить кількість діапазонів, результат і час.
53. Створити консольну програму, яка генерує масив з $n$ рядків-записів «ім’я;місто;вік» (фіксоване зерно) і за допомогою PLINQ (AsParallel, Where, GroupBy) обчислює кількість людей, старших за вік, введений користувачем, для кожного міста. Результат виводиться, відсортований за назвою міста, разом із часом PLINQ і LINQ та перевіркою збігу результатів.
54. Створити консольну програму, яка за допомогою PLINQ Aggregate з функціями seed, update, combine і result обчислює для масиву з $n$ випадкових цілих чисел (розмір вводить користувач) одночасно мінімум, максимум, суму й кількість парних чисел. Програма перевіряє результат послідовним обчисленням і виводить його та час.
55. Створити консольну програму, яка знаходить у масиві з 50 000 000 випадкових цілих чисел індекс першого елемента, рівного числу, введеному користувачем, за допомогою Parallel.For з ParallelLoopState.Break. Програма виводить IsCompleted, LowestBreakIteration, результат послідовного пошуку та час обох пошуків або повідомлення, що число відсутнє.
56. Створити консольну програму, яка сортує масив з $n$ випадкових цілих чисел (розмір і поріг вводить користувач) паралельним сортуванням злиттям: дві половини сортуються через Parallel.Invoke, фрагменти, менші за поріг, сортуються Array.Sort. Програма перевіряє впорядкованість результату та виводить час паралельного сортування, послідовного сортування злиттям і прискорення.
57. Створити консольну програму, яка оцінює число π методом Монте-Карло для кількості випробувань, введеної користувачем, розбиваючи випробування на 64 блоки з власними генераторами new Random(seed + номер блоку) у Parallel.For. Програма виводить оцінку, похибку й таблицю часу, прискорення та ефективності для 1, 2, 4 і 8 потоків.
58. Створити консольну програму, яка знаходить максимум масиву з $2^k$ випадкових чисел ($k$ від 10 до 26 вводить користувач) паралельною редукцією: на кожному рівні дерева попарні максимуми обчислюються через Parallel.For у новий масив удвічі меншої довжини. Програма виводить максимум, кількість рівнів і перевіряє результат з Enumerable.Max.
59. Створити консольну програму, яка обробляє 100 імітованих «файлів» (кожен – затримка Task.Delay від 100 до 500 мс і підрахунок суми випадкових чисел) за допомогою Parallel.ForEachAsync з обмеженням кількості одночасних операцій, введеним користувачем, і маркером скасування, що спрацьовує через задану кількість секунд. Програма виводить кількість оброблених файлів, загальну суму та час або повідомлення про скасування.
60. Створити консольну програму, яка обчислює множину Мандельброта на зображенні, розміри якого вводить користувач, за допомогою Parallel.For за рядками з ParallelOptions.MaxDegreeOfParallelism для 1, 2, 4, 8 і 16 потоків. Для кожної кількості потоків програма виводить медіану трьох запусків, прискорення й ефективність і перевіряє, що загальна кількість ітерацій збігається з послідовною версією.

Тема 7. Векторизація SIMD

61. Створити консольну програму, яка виводить значення Vector.IsHardwareAccelerated, Vector<float>.Count, IsHardwareAccelerated для Vector128, Vector256, Vector512 та IsSupported для Avx2, Fma, Avx512F, AdvSimd у вирівняній таблиці, а також найширший прискорений вектор цього ПК.
62. Створити консольну програму, яка запитує довжину масиву (від 0 до 10 000 000), заповнює масив int випадковими числами й обчислює суму скалярно та за допомогою Vector<int> з обробкою хвоста, перевіряє збіг сум і виводить час обох способів.
63. Створити консольну програму, яка множить масив float на число, введене користувачем, і додає до іншого масиву (операція axpy) скалярно та Vector256<float> з обробкою хвоста, перевіряє результат для довжин 0, 1, 7, 8, 9 і 1 000 003 і виводить час.
64. Створити консольну програму, яка замінює в масиві short з 10 000 000 відліків усі значення, більші за введений поріг, на поріг, скалярно та векторно (Vector256.GreaterThan і ConditionalSelect), і виводить кількість змінених значень та час обох способів.
65. Створити консольну програму, яка знаходить у текстовому файлі, шлях до якого вводить користувач, позиції всіх входжень введеного символу ASCII за допомогою Vector128.Equals і ExtractMostSignificantBits, виводить кількість і перші 10 позицій та перевіряє результат скалярним пошуком.
66. Створити консольну програму, яка генерує 100 000 векторів розмірністю 128, знаходить для введеного номера вектора 5 найбільш схожих за косинусною подібністю (TensorPrimitives.CosineSimilarity) і виводить таблицю «номер – подібність» та час.
67. Створити консольну програму, яка запитує розмір матриць $n$ і розмір плитки, множить матриці double порядком ikj і блочно, перевіряє збіг результатів і виводить час та GFLOPS обох способів.
68. Створити консольну програму, яка розв’язує СЛАР з діагональною перевагою, розмір якої вводить користувач, методом Якобі з Parallel.For за рядками до точності ${10}^{-8}$ і виводить кількість ітерацій, максимальну похибку розв’язку та час послідовної й паралельної версій.
69. Створити консольну програму, яка розв’язує СЛАР розміром $n$ (вводить користувач) методом Гаусса з вибором головного елемента, виконуючи виключення рядків через Parallel.For і TensorPrimitives.MultiplyAdd, та виводить нев’язку $max|Ax-b|$ і час.
70. Створити консольну програму, яка нормалізує 1 000 000 векторів Vector3 методом Vector3.Normalize і векторно для окремих масивів координат (Vector256<float>, Vector256.Sqrt), перевіряє максимальну різницю та виводить час і прискорення.

Тема 8. Паралельні алгоритми

71. Створити консольну програму, яка запитує межі інтегрування й точність і обчислює ${\int }_a^b\sin (x)/(1+x^2)dx$ паралельною складеною формулою Сімпсона, подвоюючи кількість відрізків, доки оцінка похибки за правилом Рунге не стане меншою за задану точність; виводить значення, кількість відрізків, оцінку похибки і час.
72. Створити консольну програму, яка обчислює ${\int }_0^{100}2x\cos x^{2}dx$ адаптивним методом Сімпсона з рекурсивними задачами Parallel.Invoke до введеної користувачем глибини, виводить значення, похибку відносно $\sin {10}^4$, кількість задач і час порівняно з послідовною версією.
73. Створити консольну програму, яка запитує довжину векторів і кількість потоків і обчислює скалярний добуток блочним, циклічним і блочно-циклічним (блоки по 1024) розподілами, виводячи результати з 17 цифрами та час кожного розподілу.
74. Створити консольну програму, яка запитує розмір матриці $n$ і кількість потоків, множить випадкову матрицю на вектор горизонтальними смугами, перевіряє результат послідовним множенням і виводить час, прискорення та ефективність.
75. Створити консольну програму, яка запитує розмір матриць $n$ (кратний 4) і множить їх шаховою схемою $4\times 4$ (16 задач, кожна обчислює свій блок $C_{ij}$), перевіряє результат послідовним множенням і виводить час обох способів і прискорення.
76. Створити консольну програму, яка знаходить усі корені функції $\sin (10x)-x/5$ на відрізку, введеному користувачем: паралельно відокремлює корені на сітці із заданою кількістю відрізків і уточнює їх бісекцією до ${10}^{-12}$; виводить корені та час.
77. Створити консольну програму, яка для введеної кількості початкових швидкостей розв’язує рівняння маятника з опором методом Рунге–Кутти 4-го порядку до зупинки маятника паралельно з динамічним розподілом задач і виводить кількість обертів для кожної десятої швидкості та час.
78. Створити консольну програму, яка множить матриці $n\times n$ (вводить користувач) смугами на 1, 2, 4 і 8 потоках, вимірює час і виводить таблицю «потоки – прогноз $S=min(p,8)$ – виміряне $S$ – ефективність».
79. Створити консольну програму, яка оцінює об’єм кулі радіуса 1 методом Монте-Карло за введеною кількістю точок з окремим генератором на кожен з 64 блоків і виводить оцінку, довірчий інтервал і перевірку, що два запуски дають однаковий результат.
80. Створити консольну програму, яка розв’язує тридіагональну систему $4x_i-x_{i-1}-x_{i+1}=b_i$ розміру $n$ (вводить користувач, $b$ з відомого розв’язку) методом спряжених градієнтів з паралельними детермінованими скалярними добутками і виводить кількість ітерацій, нев’язку та час послідовної й паралельної версій.

Тема 9. Багатопотоковість у C++

81. Створити проєкт CMake (ціль Threads::Threads, стандарт C++23, пресети debug і release з генератором Ninja) з консольною програмою мовою C++, яка запитує розмір масиву й кількість потоків, обчислює суму квадратів елементів у потоках std::jthread і виводить суму, час і прискорення порівняно з послідовним обчисленням.
82. Створити консольну програму мовою C++, яка запитує $n$ і кількість потоків $p$, підраховує кількість простих чисел до $n$, розбиваючи діапазон на $p$ частин для потоків std::jthread, перевіряє результат послідовним підрахунком і виводить таблицю часу, прискорення й ефективності для $p$ від 1 до введеного значення.
83. Створити консольну програму мовою C++, у якій 8 потоків виконують введену кількість переказів між 5 рахунками з std::scoped_lock, а окремий лічильник успішних переказів реалізовано через std::atomic. Програма перевіряє незмінність загальної суми й виводить баланси та кількість успішних і відхилених переказів.
84. Створити консольну програму мовою C++ з потокобезпечною чергою на std::mutex і std::condition_variable, у якій 2 виробники генерують введену кількість завдань, а 3 споживачі їх обробляють (обчислюють факторіал за модулем ${10}^9+7$). Програма коректно завершує споживачів і виводить кількість оброблених завдань кожним споживачем і суму результатів.
85. Створити консольну програму мовою C++, яка для введеного каталогу запускає для кожного підкаталогу задачу std::async(std::launch::async, …), що підраховує кількість і розмір файлів .cpp і .h за допомогою std::filesystem, і виводить таблицю підкаталогів, загальні підсумки та повідомлення про помилки, отримані через future.
86. Створити консольну програму мовою C++ з пулом потоків на std::jthread, std::condition_variable і std::packaged_task, який приймає задачі обчислення числа Фібоначчі за модулем для введених користувачем номерів і повертає результати через std::future; програма виводить результати в порядку введення та кількість потоків пулу.
87. Створити консольну програму мовою C++, яка генерує введену кількість випадкових дійсних чисел, сортує їх std::sort з політиками seq і par та обчислює середнє квадратичне std::transform_reduce з політиками seq, par і par_unseq. Програма виводить таблицю часу, прискорення й перевірку однаковості результатів.
88. Створити консольну програму мовою C++, яка запускає 4 робочі потоки std::jthread, що до запиту зупинки через std::stop_token обчислюють суму випадкових чисел, а головний потік зупиняє їх через кількість секунд, введену користувачем. Програма виводить кількість оброблених чисел і суму кожного потоку.
89. Створити консольну програму мовою C++, у якій 10 потоків-відвідувачів користуються читальним залом на 3 місця, обмеженим std::counting_semaphore, а синхронний старт усіх відвідувачів забезпечує std::latch. Програма виводить журнал подій і перевіряє, що в залі ніколи не було більше 3 відвідувачів.
90. Створити консольну програму мовою C++, яка обчислює інтеграл функції $e^{-x^2}$ на введеному відрізку методом трапецій у $p=1,2,4,8$ потоках, вимірює час годинником std::chrono::steady_clock як медіану трьох запусків і виводить таблицю $p$, $T_p$, $S_p$, $E_p$ та значення інтеграла.

Тема 10. OpenMP

91. Створити консольну програму мовою C++ з OpenMP, яка запитує кількість потоків (від 1 до 64) і в паралельній області виводить для кожного потоку його номер, кількість потоків команди та приватну змінну, ініціалізовану через firstprivate значенням, введеним користувачем, збільшеним на номер потоку; після області програма виводить значення цієї змінної й пояснює, чому воно не змінилося.
92. Створити консольну програму мовою C++ з OpenMP, яка запитує кількість відрізків $n$ і обчислює число $\pi$ як інтеграл $4/(1+x^2)$ на $[0,1]$ директивою parallel for reduction(+:sum) для 1, 2, 4, 8 і 16 потоків, виводячи таблицю значення, похибки, часу (omp_get_wtime), прискорення й ефективності.
93. Створити консольну програму мовою C++ з OpenMP, яка запитує верхню межу $N$ і підраховує прості числа до $N$ з schedule(static), schedule(dynamic, 100) і schedule(guided), перевіряє однаковість кількості простих чисел і виводить таблицю часу для кожного виду розподілу.
94. Створити консольну програму мовою C++ з OpenMP, яка генерує масив із $n$ випадкових цілих чисел ($n$ вводить користувач, фіксоване зерно) і паралельно знаходить суму, мінімум, максимум і кількість парних чисел клаузами reduction, перевіряє результати послідовним обходом і виводить їх.
95. Створити консольну програму мовою C++ з OpenMP, яка генерує ${10}^7$ оцінок студентів від 0 до 100 і будує гістограму з 10 інтервалів трьома способами (critical, atomic, reduction(+:hist[0:10])), перевіряє однаковість гістограм і виводить гістограму та час кожного способу.
96. Створити консольну програму мовою C++ з OpenMP, яка запитує $n$ (від 20 до 45) і обчислює $n$-те число Фібоначчі рекурсивно задачами task і taskwait з порогом, нижче якого обчислення послідовне; програма виводить результат і час для порогів 10, 20 і 30.
97. Створити консольну програму мовою C++ з OpenMP, яка сортує масив із $n$ випадкових чисел ($n$ вводить користувач) рекурсивним сортуванням злиттям із задачами OpenMP і порогом 10 000 елементів, перевіряє впорядкованість і виводить час паралельного сортування та std::sort.
98. Створити консольну програму мовою C++ з OpenMP, яка обчислює скалярний добуток двох векторів із $n$ дійсних чисел ($n$ вводить користувач) чотирма способами: звичайним циклом, omp simd reduction, parallel for reduction і parallel for simd reduction, перевіряє відносну розбіжність результатів (не більше ${10}^{-9}$) і виводить таблицю часу та прискорення.
99. Створити консольну програму мовою C++ з OpenMP, яка виводить значення omp_get_proc_bind, кількість місць omp_get_num_places і процесори кожного місця, а в паралельній області – номер потоку та номер його місця omp_get_place_num. Запустити програму зі змінними OMP_PLACES=cores і OMP_PROC_BIND=close та spread і пояснити різницю виведення.
100. Створити консольну програму мовою C++ з OpenMP, яка запитує розмір квадратних матриць $n$ і множить дві випадкові матриці директивою parallel for за рядками для 1, 2, 4, 8 і 16 потоків, перевіряє збіг результату з послідовним множенням і виводить таблицю часу, прискорення $S$ та ефективності $E$.

Тема 11. Обчислення на GPU

101. Створити консольну програму мовою CUDA C++, яка запитує довжину двох векторів, заповнює їх випадковими числами, обчислює їх поелементний добуток ядром з глобальним індексом і перевіркою меж, перевіряє результат на CPU і виводить найбільшу похибку.
102. Створити консольну програму мовою CUDA C++, яка виділяє пам’ять пристрою для масиву з $n$ чисел ($n$ вводить користувач), копіює дані на GPU, множить кожен елемент на 2 ядром, копіює результат назад, звільняє пам’ять і перевіряє всі виклики CUDA.
103. Створити консольну програму мовою CUDA C++, яка інвертує згенероване зображення 1920×1080 у відтінках сірого ядром на 2D-сітці блоків 16×16, записує результат у PGM і виводить розміри сітки.
104. Створити консольну програму мовою CUDA C++, яка транспонує матрицю $n\times n$ ($n$ вводить користувач) наївним ядром і ядром з тайлом 32×32 у спільній пам’яті, перевіряє результати та виводить час обох ядер, виміряний подіями CUDA.
105. Створити консольну програму мовою CUDA C++, яка обчислює суму масиву з $n$ цілих чисел редукцією з послідовною адресацією у спільній пам’яті та atomicAdd, порівнює результат і час з OpenMP.
106. Створити консольну програму мовою CUDA C++, яка будує гістограму з 10 інтервалів для ${10}^7$ випадкових оцінок від 0 до 100 локальними гістограмами у спільній пам’яті та виводить гістограму й час.
107. Створити консольну програму мовою CUDA C++, яка для масиву з $n$ чисел вимірює подіями CUDA окремо час копіювання на GPU, роботи ядра (квадрат кожного елемента) і копіювання назад та виводить прискорення відносно OpenMP з урахуванням копіювань і без нього.
108. Створити консольну програму мовою C# з ILGPU, яка виводить перелік доступних пристроїв, обирає GPU (або CPU-акселератор) і обчислює SAXPY для $n$ чисел ядром з Index1D і MemoryBuffer1D, перевіряючи результат.
109. Створити консольну програму мовою C# з ILGPU, яка розмиває згенероване зображення середнім 3×3 ядром з Index2D і порівнює час з Parallel.For з урахуванням копіювань.
110. Створити консольну програму мовою CUDA C++, яка обробляє масив частинами у чотирьох потоках CUDA із закріпленою пам’яттю (копіювання, ядро, копіювання) і порівнює час з обробкою без потоків.

Тема 12. Передавання повідомлень MPI

111. Створити консольну програму мовою C++ з MPI, у якій кожен процес виводить свій ранг, кількість процесів і ім’я вузла, а ранг 0 додатково збирає ранги всіх процесів операцією MPI_Gather і виводить їх у порядку зростання.
112. Створити консольну програму мовою C++ з MPI, яка обчислює суму чисел від 1 до $n$ ($n$ вводить користувач на ранзі 0): ранг 0 розсилає $n$ операцією MPI_Bcast, кожен ранг підсумовує свою частину, MPI_Reduce збирає результат, який порівнюється з формулою.
113. Створити консольну програму мовою C++ з MPI, у якій ранги утворюють кільце й передають по ньому маркер (число), кожен ранг додає до нього свій ранг; обмін без взаємоблокувань для будь-якої кількості процесів, ранг 0 виводить підсумок.
114. Створити консольну програму мовою C++ з MPI, у якій кожен ранг обмінюється масивом з ${10}^6$ чисел з обома сусідами в кільці неблокуючими операціями MPI_Isend і MPI_Irecv з MPI_Waitall та виводить суму отриманих значень.
115. Створити консольну програму мовою C++ з MPI, яка розподіляє масив з $n$ чисел ($n$ вводить користувач, може не ділитися на кількість процесів) операцією MPI_Scatterv, знаходить мінімум, максимум і середнє та виводить їх на ранзі 0.
116. Створити консольну програму мовою C++ з MPI, яка множить матрицю $n\times n$ на вектор: рядки матриці розподіляються MPI_Scatter, вектор – MPI_Bcast, результат збирається MPI_Gather і перевіряється послідовним множенням.
117. Створити консольну програму мовою C++ з MPI за схемою «майстер–робітник», у якій ранг 0 роздає робітникам по одному 1000 чисел для перевірки на простоту, збирає відповіді й виводить кількість простих і кількість чисел, перевірених кожним робітником.
118. Створити консольну програму мовою C++ з MPI, яка створює двовимірну періодичну декартову топологію процесів, знаходить сусідів кожного процесу MPI_Cart_shift і обмінюється з ними рангами, а кожен процес виводить свої координати й ранги сусідів.
119. Створити консольну програму мовою C++ з MPI і OpenMP, яка ініціалізує MPI функцією MPI_Init_thread з MPI_THREAD_FUNNELED, обчислює $\pi$ інтегруванням: кроки діляться між рангами, у межах рангу – потоками з reduction, і виводить кількість рангів, потоків і результат.
120. Створити консольну програму мовою C++ з MPI, яка вимірює MPI_Wtime час обчислення суми ${10}^8$ чисел для поточної кількості процесів (час найповільнішого рангу, медіана 5 запусків між MPI_Barrier) і виводить час, прискорення відносно послідовного обчислення на ранзі 0 та ефективність.

Тема 13. Кластер і планувальник Slurm

121. Створити скрипт sbatch для послідовної програми ./model з аргументами input.dat 1000: 1 задача, 2 ГБ пам’яті, ліміт 30 хв, розділ debug, файл виводу з назвою завдання й номером; після виконання програми скрипт виводить код її завершення й час роботи в секундах (змінна SECONDS).
122. Створити скрипт sbatch для багатопотокової програми OpenMP на одному вузлі з 8 CPU і 4 ГБ пам’яті, у якому кількість потоків береться зі змінної Slurm, прив’язка потоків задається OMP_PLACES=cores і OMP_PROC_BIND=close, а перед запуском виводяться вузол, кількість виділених CPU і значення змінних OpenMP.
123. Створити MPI-програму мовою C++, у якій кожен ранг виводить свій номер, кількість рангів і ім’я вузла, а ранг 0 збирає імена вузлів (MPI_Gather) і виводить, скільки рангів працює на кожному вузлі; та скрипт sbatch для 3 вузлів по 4 ранги із запуском через srun --mpi=pmix.
124. Створити скрипт sbatch для гібридної програми MPI + OpenMP на 2 вузлах з 2 рангами на вузлі та 4 потоками на ранг: директиви розкладки, змінна OMP_NUM_THREADS, запуск через srun; перед запуском скрипт перевіряє, що добуток кількості рангів на кількість потоків дорівнює кількості виділених CPU, і завершується з кодом 1, якщо ні.
125. Створити скрипт sbatch з масивом із 50 елементів (не більше 10 одночасно), у якому елемент $i$ обробляє $i$-й рядок файлу params.txt (параметри програми ./sim), записує результат у results/<i>.txt, та скрипт, що після завершення масиву (залежність) об’єднує результати й виводить номери елементів без результату.
126. Створити скрипт bash, який надсилає ланцюжок із трьох завдань a.sbatch → b.sbatch → c.sbatch з умовами afterok і завдання cleanup.sbatch з умовою afterany на останнє завдання ланцюжка, виводить номери завдань, а після завершення – таблицю станів і кодів завершення всіх чотирьох завдань за sacct.
127. Створити скрипт bash, який виводить: розділи кластера з кількістю вільних і зайнятих вузлів (sinfo), свої завдання з причинами очікування (squeue з власним форматом), очікуваний час старту завдань, що чекають, і пропонує скасувати (scancel) завдання, які чекають понад задану користувачем кількість годин.
128. Створити скрипт bash, який за виводом sacct -X --parsable2 за період, що вводить користувач, виводить таблицю завдань «номер – назва – стан – код завершення – тривалість – CPU·год» і підсумок: кількість завдань за станами та загальні CPU·год.
129. Записати фрагмент slurm.conf для кластера з керувальним вузлом head і вузлами node[01-04] (8 CPU: 1 сокет, 4 ядра, 2 потоки, 16 ГБ пам’яті з резервом для ОС) з розподілом ядер і пам’яті, прив’язкою задач через cgroup, розділами short (усі вузли, 1 год, за замовчуванням) і long (вузли 3–4, 3 доби); та скрипт bash, який перевіряє синтаксис фрагмента (обов’язкові параметри, формат часу, існування вузлів розділів).
130. Створити діагностичний скрипт bash для обчислювального вузла, який перевіряє й виводить у вигляді таблиці «параметр – значення – рекомендовано»: регулятор частоти, режим THP, vm.swappiness, kernel.numa_balancing, ліміти memlock і nofile, MTU мережевого інтерфейсу, стан служб munge, slurmd, chrony і стан вузла в Slurm (sinfo -n).

Тема 14. Сокети, RPC і gRPC

131. Створити асинхронний TCP-сервер, який одночасно обслуговує кількох клієнтів і на кожен рядок відповідає цим рядком у верхньому регістрі, та клієнт, що надсилає рядки з клавіатури; сервер виводить підключення й відключення клієнтів.
132. Створити TCP-клієнт і сервер калькулятора з кадруванням «довжина (4 байти) + JSON»: клієнт надсилає операцію та два числа, сервер повертає результат або повідомлення про помилку (ділення на нуль, невідома операція).
133. Створити UDP-сервер, який на запит «TIME» повертає поточний час, та клієнт, що надсилає 10 запитів з таймаутом 1 с, повторює загублені й виводить затримку кожного запиту та кількість втрат.
134. Створити TCP-клієнт, який підключається до сервера з повторними спробами (3 спроби, експоненційна затримка, таймаут з’єднання 2 с) і виводить причину кожної невдачі (SocketError) та підсумкове повідомлення.
135. Описати в .proto сервіс студентів з методами GetStudent(id) і AddStudent(student), реалізувати gRPC-сервер на ASP.NET Core і клієнт; неіснуючий студент повертає код NotFound, який клієнт виводить.
136. Створити gRPC-сервіс із серверним потоком, що надсилає N простих чисел з паузою 200 мс, та клієнт, який виводить їх; клієнт задає дедлайн 1 с і виводить отримані числа та код статусу DeadlineExceeded.
137. Створити gRPC-сервіс із клієнтським потоком, що приймає числа й повертає їхню кількість, суму та середнє, і клієнт, який надсилає числа з текстового файлу.
138. Створити gRPC-сервіс луни з двонаправленим потоком, який на кожне повідомлення відповідає двома повідомленнями, та клієнт, що одночасно надсилає й читає повідомлення, виводячи порядок отримання.
139. Створити gRPC-сервіс з перехоплювачем, який записує в консоль назву методу, тривалість і код статусу кожного виклику, та клієнт, що передає метадані client-name і виконує успішний і помилковий виклики.
140. Створити сервіс CoreWCF з контрактом [ServiceContract] (операції «додати» та «перелік» нотаток) і кінцевою точкою BasicHttpBinding, та консольний клієнт на System.ServiceModel.Http, що викликає обидві операції й обробляє FaultException.

Тема 15. Брокер RabbitMQ

141. Створити видавця, який публікує в стійку чергу RabbitMQ N повідомлень (N вводиться з клавіатури), і споживача з ручними підтвердженнями, що виводить кожне повідомлення та їх загальну кількість.
142. Створити чергу завдань із двома робітниками: завдання містить тривалість обробки в мілісекундах, робітники мають prefetch 1 і ручні підтвердження; вивести, які завдання виконав кожен робітник, і загальний час.
143. Створити видавця, який публікує повідомлення журналу в обмінник direct з ключами info, warning, error, і два споживачі: перший отримує лише error, другий – усі рівні; кожен виводить отримані повідомлення.
144. Створити видавця подій в обмінник fanout і три споживачі зі стійкими чергами; показати, що споживач, запущений пізніше, отримує події, опубліковані до його запуску.
145. Створити видавця подій з ключами <місто>.<тип> в обмінник topic і споживача, який приймає шаблони прив’язки аргументами командного рядка та виводить отримані події.
146. Створити видавця з підтвердженнями видавця та mandatory: true, який публікує повідомлення в чергу, ім’я якої вводиться з клавіатури, і виводить «підтверджено» або причину відмови (PublishException, повернення).
147. Створити чергу tasks з dead letter exchange: споживач відхиляє повідомлення з непарними номерами (requeue: false), а другий споживач черги відхилених виводить їх разом із причиною з заголовка x-death.
148. Створити RPC через черги: сервер обчислює факторіал числа, клієнт надсилає три запити одночасно з різними CorrelationId, чекає відповідей не довше 2 с і виводить результати або повідомлення про таймаут.
149. Створити ідемпотентного споживача платежів: видавець публікує платежі з MessageId, серед яких є дублікати; споживач зараховує кожен платіж один раз і виводить баланс і кількість пропущених дублікатів.
150. Створити координатора, який ділить обчислення суми квадратів чисел від 1 до N на K частин і публікує їх у чергу, та робітника, що обчислює частини й повертає результат; координатор виводить суму, перевіряє її формулою і виводить час.

Тема 16. Актори та Microsoft Orleans

151. Створити застосунок Orleans (силос і клієнт в одному процесі) із зерном лічильника (ключ – рядок) з методами Increment і Get; клієнт виконує 1000 одночасних викликів Increment для двох лічильників і виводить значення та час.
152. Створити силос і окремий консольний клієнт Orleans із зерном нотаток користувача (ключ – ім’я), методами «додати» та «перелік»; клієнт виконує команди з клавіатури.
153. Створити застосунок Orleans із зерном профілю користувача, стан якого зберігається через IPersistentState у провайдері Redis або пам’яті; після перезапуску програми профіль читається знову й виводиться.
154. Створити застосунок Orleans із зерном таймера вікторини, яке після старту щосекунди таймером (RegisterGrainTimer) виводить час, що залишився, і через 10 с завершує раунд.
155. Створити застосунок Orleans із зерном підписки, яке нагадуванням (провайдер у пам’яті, мінімальний період зменшено до 5 с) тричі виводить повідомлення про оплату й скасовує нагадування.
156. Створити застосунок Orleans із двома зернами, що викликають одне одного по колу, і продемонструвати TimeoutException та його усунення за допомогою [Reentrant] або RequestContext.AllowCallChainReentrancy; вивести час виконання.
157. Створити застосунок Orleans із [StatelessWorker]-зерном перевірки e-mail і зерном статистики; клієнт перевіряє 1000 адрес з файлу, а програма виводить кількість коректних і некоректних адрес.
158. Створити консольну програму, що викликає ненадійну операцію (виняток з імовірністю 50 %) з повторами: 4 спроби, експоненційна затримка 100, 200, 400 мс з джитером; вивести кожну спробу та підсумок.
159. Створити консольну програму, що моделює N = 5 реплік і для введених W та R виконує 10 000 операцій запису й читання, виводячи частку застарілих читань і перевірку умови R + W > N.
160. Створити консольну програму з актором на Channel<T>, який веде облік товарів (надходження, продаж, залишок); 8 задач одночасно надсилають повідомлення, а програма виводить правильний залишок.

Тема 17. Docker, Kubernetes, Aspire

161. Створити багатоетапний Dockerfile для вебсервісу ASP.NET Core на .NET 10 з фінальним образом aspnet:10.0, запуском від користувача app і файлом .dockerignore; зібрати образ, запустити контейнер з публікацією порту 8080 і перевірити сервіс.
162. Створити compose.yaml із сервісом API, брокером RabbitMQ з healthcheck і робітником; API й робітник запускаються після готовності брокера, рядок підключення передається змінною середовища, робітників масштабують командою docker compose up --scale.
163. Створити стенд Docker Compose із вебсервісом і Redis, дані Redis зберігаються в іменованому томі; показати, що дані переживають docker compose down і повторний up.
164. Створити маніфести Kubernetes для вебсервісу: Deployment на 3 репліки, Service типу NodePort, ConfigMap з параметрами, переданими через envFrom; розгорнути їх командою kubectl apply і показати розподіл запитів між подами.
165. Створити Deployment вебсервісу ASP.NET Core з readinessProbe, livenessProbe, requests і limits; продемонструвати виключення неготового пода зі служби та перезапуск контейнера після невдалої проби життєздатності.
166. Розгорнути Deployment вебсервісу ASP.NET Core і виконати його поступове оновлення на нову версію образу з параметрами maxSurge: 1 і maxUnavailable: 0, переглянути історію ревізій і виконати відкат командою kubectl rollout undo.
167. Створити індексоване завдання Kubernetes (completions: 6, parallelism: 3), кожен под якого обчислює суму квадратів свого діапазону чисел за JOB_COMPLETION_INDEX; зібрати результати з журналів і вивести загальну суму.
168. Створити HorizontalPodAutoscaler для обчислювального вебсервісу (від 1 до 5 реплік, ціль 50 % процесора) і показати зміну кількості реплік під навантаженням командою kubectl get hpa -w.
169. Створити рішення Aspire з AppHost, ServiceDefaults, вебсервісом і Redis: рядок підключення передається через WithReference, сервіс запускається після готовності Redis (WaitFor), робітник має дві репліки (WithReplicas); показати ресурси в дашборді.
170. Створити вебсервіс у рішенні Aspire з власною метрикою OpenTelemetry (лічильник запитів із міткою результату) і власним спаном ActivitySource для обчислення; показати метрику й трасування в дашборді Aspire.

Тема 18. Архітектура мікросервісів

171. Створити рішення Aspire з двома вебсервісами (каталог товарів і замовлення), кожен з власною базою PostgreSQL, і шлюзом YARP, який маршрутизує /api/catalog/** і /api/orders/** через виявлення сервісів; замовлення перевіряє товар викликом каталогу, а неіснуючий товар повертає код 400.
172. Створити сервіс, який публікує подію «замовлення створено» в RabbitMQ, і споживача, що обробляє її ідемпотентно: оброблені ідентифікатори повідомлень зберігаються в таблиці Inbox, а повторна доставка тієї самої події не змінює результат; показати це повторною публікацією.
173. Створити оркестровану сагу оформлення замовлення з кроками «резерв товару → оплата → підтвердження»: при відмові оплати виконується компенсація (зняття резерву), стан саги зберігається в базі даних, а запит стану повертає журнал кроків таблицею.
174. Реалізувати Transactional Outbox: сервіс записує замовлення й повідомлення в таблицю Outbox в одній транзакції EF Core, а фоновий ретранслятор публікує повідомлення в RabbitMQ; показати, що при зупиненому брокері повідомлення не губляться.
175. Створити два вебсервіси, де HTTP-клієнт першого викликає другий із політикою стійкості Microsoft.Extensions.Http.Resilience (тайм-аут, три повтори, запобіжник); продемонструвати роботу запобіжника, зупинивши викликаний сервіс, і вивести зміни його стану в журнал.
176. Створити рішення Aspire зі шлюзом YARP, двома HTTP-сервісами й споживачем RabbitMQ, налаштувати трасування OpenTelemetry для запиту, що проходить через них, додати власний спан ActivitySource з атрибутами та показати в дашборді Aspire одне трасування з усіма спанами.
177. Створити вебсервіс із двома версіями API (/v1/... і /v2/...), де друга версія розширює формат відповіді, а перша позначена застарілою заголовком відповіді; показати, що старий і новий клієнти працюють одночасно.
178. Створити рішення Aspire з вебсервісами, що використовують PostgreSQL і RabbitMQ, і перевірками працездатності /health і /alive, де готовність залежить від доступності бази даних і брокера; показати зміну стану ресурсу в дашборді після зупинки бази даних.
179. Створити шлюз YARP перед вебсервісом з обмеженням частоти запитів (5 запитів за 10 с на клієнта), кодом 429 і заголовком Retry-After; консольний клієнт надсилає 20 запитів і виводить таблицю «номер – код – час».
180. Створити інтеграційний тест Aspire.Hosting.Testing, який запускає AppHost з двома сервісами й шлюзом, чекає готовності ресурсів, виконує запити через шлюз і перевіряє коди відповідей та вміст для успішного й помилкового сценаріїв.