Нова надія для NVIDIA Pascal: до +100% швидкості у stable-diffusion.cpp
БЛОГИ · ШІ ТА НЕЙРОМЕРЕЖІ
ОПУБЛІКОВАНО
ЧИТАННЯ33 хв

Нова надія для NVIDIA Pascal: до +100% швидкості у stable-diffusion.cpp

Відсутність тензорних ядер та урізаний у 64 рази блок FP16 давно зробили відеокарти архітектури NVIDIA Pascal (SM 6.1) аутсайдерами у сучасних дифузійних моделях. Ми вирішили виправити цю несправедливість: написали власний нативний C++/CUDA конвеєр W8A8 та ядро FlashAttention на базі апаратних інструкцій INT8 __dp4a, реалізували дворівневий менеджер пам'яті та прискорили генерацію важких моделей (Krea 2, Z-Image, Anima) у stable-diffusion.cpp майже вдвічі без втрати якості.

Вступ

В одному з минулих матеріалів, коли ми препарували майнерські прискорювачі P104-100, я побіжно згадував, що попри свій поважний вік архітектура Pascal все ще непогано порається з генерацією зображень. І, відверто кажучи, на цьому можна було б поставити крапку, змирившись з тим, що старенькі GTX 1070/1080/1080Ti, P104-100 чи P102-100 просто доживають свій вік. Проте, як завжди, є одне суттєве «але»: дивлячись на те, як ці карти пихтять у stable-diffusion.cpp на сучасних важких моделях рівня Krea 2 або Z-Image, мене не полишало відчуття, що софт використовує лише третину реального потенціалу кремнію.

Невеличкий технічний екскурс, щоб ми з вами були на одній хвилі. Чому взагалі відеокарти сімейства Pascal (серія GTX 1000 та їхні «безголові» майнерські брати P104/P102) так сильно страждають у сучасних нейромережах? Все впирається у два жорстких апаратних обмеження:

  1. Повна відсутність тензорних ядер (Tensor Cores). Вони з'явилися лише в наступному поколінні (Volta / Turing).

  2. Катастрофічно урізаний блок FP16. На споживчих GPU, заснованих на архітектурі Pascal (у термінології CUDA це рівень можливостей SM 6.1 - кристали GP102, GP104, GP106 та GP107), продуктивність у половинній точності (FP16 / half2) штучно задушена у 64 рази відносно стандартного FP32 (так званий штраф 1:64).

Тобто будь-який сучасний код, який на умовній RTX 2060 Super чи RTX 3090 отримує двократне прискорення за рахунок переходу з FP32 на FP16, на картах GTX 1000 або взагалі не працює, або перетворює відеокарту на слайд-шоу.

Але що ми ще знаємо про GPU на архітектурі Pascal (за винятком хіба що офісної GT 1030 на чипі GP108)? Правильно - саме в чипах SM 6.1 інженери NVIDIA додали дуже цікаву, але часто ігноровану розробниками апаратну інструкцію __dp4a (Dot Product of 4x 8-bit Integers and Accumulate). Якщо казати максимально просто: замість того, щоб рахувати важкі 32-бітні числа з плаваючою комою по одному за такт, відеокарта бере одразу чотири 8-бітних цілих числа (INT8), перемножує їх з іншою четвіркою і складає результат у 32-бітний акумулятор. І все це — за один такт!

Давайте подивимось на сухі цифри на прикладі народної GTX 1070:

  • У класичному режимі FP32 її стеля - близько 6.5 TFLOPS.

  • А от у режимі INT8 __dp4a теоретичний пік злітає до ~26 TOPS. Тобто фізично кристал здатен перемолоти у 4 рази більше математичних операцій за ту саму одиницю часу!

Тому ідея напрошувалась сама собою: а що як змусити stable-diffusion.cpp рахувати важкі дифузійні моделі (Anima, Krea 2, Z-Image) через швидкий нативний INT8 __dp4a, не втративши при цьому якість картинки і не вилетівши за межі 8 ГБ відеопам'яті?

Як це все відбувалося

Одразу буду з вами максимально чесним: я залізячник та оверклокер, і хоча я чудово розумію саму архітектуру чипів, роботу пам'яті та логіку конвеєра, написати з нуля низькорівневі матричні ядра на C++/CUDA з інтринсіками, шаред-меморі та варп-редукціями - для мене завдання за межею реальності. Тому цей проєкт народжувався у специфічному тандемі.

Починалася вся ця епопея ще разом із Gemini 3.8 Flash, але, відверто кажучи, з нею ми швидко вперлися в стіну: "старенька" періодично ліпила дитячі помилки в коді та вперто сперечалася з моїми інженерними гіпотезами і взагалі, пушила тейк що з Паскалю вичавили вже все що можливо. Але, моя чуйка казала чітко: ГПУ валяться в фолбек на FP32 і не використовують свої м'язи на повну.

Справжній прорив стався тоді, коли ми переїхали на нову Gemini 4 Hydrogen (далі по тексту я буду називати її просто «Гідра», бо за ті десятки годин, що ми провели разом над цим кодом, вона вже стала як рідна). І ось тут робота пішла зовсім на іншому рівні: Гідра поводилася як дорослий системний інженер - вона без зайвих суперечок брала мої архітектурні ідеї, перекладала їх у чистий CUDA-код, одразу перевіряла на живому залізі, і лише у тих вкрай рідкісних випадках, коли мій задум об'єктивно не працював на рівні математики чи компілятора, аргументовано пропонувала обхідний шлях.

Чи було це просто? Звісно ж ні! Як з'ясувалося під час ревізії коду, просто взяти і «прикрутити __dp4a» до stable-diffusion.cpp не вийде - частково він там вже був, а спадок від перших спроб із 3.8 Flash приховував чимало сюрпризів. Тож нумо розбиратися, де саме ховалися гальма і як нам вдалося прискорити старий добрий Pascal майже вдвічі.

Трішки подробиць

Перше важливе відкриття, яке ми з Гідрою зафіксували ще на етапі розбору польотів: стоковий бекенд ggml-cuda вже вміє використовувати __dp4a на картах Pascal! Більше того, він робить це всередині свого стандартного квантованого ядра mmq (matrix multiplication quantized).

Здавалося б - розходимось, все вже написано до нас, так? А от і ні. Проблема стокового mmq у тому, що він оперує невеликими тайлами 64×64 і постійно витрачає ресурси чипа на розпаковку складних блоків квантування прямо під час множення матриць. У результаті на GTX 1070 стокове ядро видавало лише жалюгідні ~7.8 TOPS із теоретичних 26 TOPS пікової потужності. Тобто понад дві третини обчислювального потенціалу GPU простоювали через неоптимальну роботу з пам'яттю та регістрами. Саме тому наші перші наївні спроби «просто підсунути свій __dp4a» без повної переробки тайлінгу та кешування впиралися у стелю стокового коду або навіть програвали йому.

До того ж, коли ми оновили кодову базу stable-diffusion.cpp до актуального master (коміт b9d7176, підмодуль ggml d803c238) і Гідра провела повний аудит старого коду, який ми починали писати ще з Gemini 3.8 Flash, спливли три критичні проблеми:

  1. Мертва перевірка архітектури. У старому коді перевірка покоління GPU виглядала як cc == 61. Звучить логічно для SM 6.1? А от і ні: всередині ggml-cuda версії архітектур множаться на сто, і для Pascal використовується константа 610 (GGML_CUDA_CC_DP4A). Через цей банальний недогляд кастомний шлях узагалі не вмикався на реальних картах GTX 1000.

  2. Помилки бітової розпаковки та розмірностей. У початкових функціях деквантування Q4_K та Q3_K знайшлися баги зі зсувами бітів, формат Q8_0 був взагалі відсутній, а головне — код не перевіряв старші розмірності тензорів (ne2 / ne3) та їхню безперервність у пам'яті (contiguous). Як наслідок - при спробі порахувати багатовимірні батчі ядро могло читати сміття з пам'яті.

  3. Втрачений макрос при збірці. Система збірки CMake банально не передавала макрос SD_USE_CUDA фінальним бінарникам sd-cli (і, як з'ясувалося пізніше, sd-server). Тобто ви могли скільки завгодно прописувати прапорець --dp4a у консолі, але сам виконуваний файл навіть не підозрював, що йому дозволено смикати CUDA-функції нашого бекенду.

Щоб раз і назавжди закрити питання сумісності та чистоти експерименту, ми зібрали єдиний уніфікований бінарник (sd-cli_DP4a.exe та sd-server_DP4a.exe через зв'язку portable-msvc + CUDA 12.9 + Ninja). Логіка максимально проста і прозора: за замовчуванням він працює як на 100% чистий сток, але варто додати прапорець --dp4a (або змінну середовища SD_CUDA_DP4A=1), як вмикається наш прискорений конвеєр. А от у серверній версії sd-server_DP4a.exe ми увімкнули --dp4a одразу за замовчуванням — щоб він безшовно підхоплював прискорення у нашій веб-оболонці CoT Studio без зайвих танців з бубном.

Як ми тестували

Хто читає мої матеріали давно, той знає: я терпіти не можу «тепличні» або маніпулятивні тести, коли в одному прогоні випадково вивантажився браузер, а в іншому модель полізла у повільну системну ОЗП через своп драйвера. Тому шоб виключити будь-які похибки на тестовому стенді з GTX 1070 8 ГБ (CUDA_VISIBLE_DEVICES=0), ми зафіксували жорсткий протокол тестування, однаковий як для стоку, так і для --dp4a:

  • Послідовне вивантаження модулів (--offload-to-cpu --mmap) та текстовий енкодер на процесорі (--backend te=cpu). Навіщо це потрібно? Коли ви генеруєте картинку на 8 ГБ відеокарті, тримати в пам'яті одночасно важкий текстовий енкодер (наприклад, Qwen 3 VL або T5) і саму дифузійну модель - це гарантований виліт за межі VRAM. У нашому випадку процесор спокійно відпрацьовує текст (вхідний промпт), після чого під час самого семплінгу (Stage 2) у відеопам'яті GTX 1070 знаходиться виключно дифузійна модель.

  • Обов'язковий FlashAttention (--diffusion-fa) та тайлінг VAE (--vae-tiling --vae-tile-size 512x512). І ось тут показова історія про різницю підходів двох моделей. Ще на старті проєкту Gemini 3.8 Flash агресивно пушила ідею дрібного тайлінгу VAE 64×64 (мовляв, так безпечніше для відеопам'яті) і вперто сперечалася зі мною, коли я наполягав на 512×512. Коли ж ми перейшли на Гідру, вона без жодних заперечень одразу протестувала мій варіант із тайлом 512×512 — і виявилося, що я мав рацію на всі сто: такий розмір чудово влазить у VRAM, дає адекватну швидкість декодування і не плодить зайвих швів на зображенні.

  • Фіксований --seed 42. Це база для прямого візуального порівняння. Ми звіряли кожну тестову генерацію буквально «піксель у піксель, деталь у деталь», щоб переконатися, що перехід на 8-бітну цілочисельну математику не перетворив картинку на мильне місиво.

  • Роздільний замір часу. Ми окремо фіксували чистий час роботи самого семплера (Stage 2, швидкість кроку в s/it) та загальний час генерації від моменту запуску до збереження PNG на диск.

Еволюція архітектури: 5 кроків до фінального результату

Коли ми вичистили старі баги і отримали стабільний тестовий стенд, постало головне інженерне питання: як саме побудувати обчислювальний конвеєр, щоб вичавити з GTX 1070 та P102 максимум тих самих 26 TOPS і при цьому не впертися в обсяг відеопам'яті? До фінальної архітектури ми йшли у п'ять ітерацій.

Крок 1. Великотайловий конвеєр W8A8 128×128 __dp4a GEMM (dp4a_gemm.cu)

Чому стокове ядро mmq так слабко навантажувало чип? Бо воно працює з дрібними тайлами 64×64 і намагається розпаковувати хитромудрі формати квантування ggml (де біти перемішані зі скейлами в блоках) прямо на льоту всередині матричного множення.

Ми пішли іншим шляхом і реалізували повноцінний матричний конвеєр W8A8 (де і ваги моделі, і активації приводяться до чистого 8-бітного формату int8):

  • Попередня перепаковка ваг. Квантовані шари моделі заздалегідь розпаковуються у максимально простий, «плаский» масив int8 із окремим рядковим коефіцієнтом масштабування (scale_B[N]). Жодних побітових зсувів під час самого множення!

  • Швидке квантування активацій на льоту. Вхідні активації (які йдуть у FP32) перед множенням миттєво квантуються у int8 разом із власним скейлом (scale_A[M]) за допомогою широких векторних завантажень float4 (kernel_quant_row_f32_to_i8_vec4).

  • Масивне ядро 128×128. Саме ядро множення матриць (kernel_w8a8_dp4a_128x128) рахує вже великий тайл 128×128. Щоб ядра не голодували без даних, завантаження з внутрішньої Shared Memory чипа відбувається широкими 128-бітними транзакціями LDS.128 (тип int4 — одразу по 16 чисел int8 за такт) із попередньою підкачкою в регістри (register prefetch). Після того як __dp4a блискавично перемножує цілі числа в int32 акумулятор, результат просто домножується на scale_A * scale_B і повертається у чесний FP32.

Що це дало на практиці? Перший же замір на легкій тестовій моделі anima-Q4_K (512×768, 20 кроків) показав, що час семплінгу на GTX 1070 впав із стокових 49.24 с (2.41 с/it) до 37.15 с (1.78 с/it). Плюс 32.5% швидкості з першого ж заходу! Але це була лише розминка.

Крок 2. Нативний INT8 __dp4a FlashAttention (fattn_dp4a.cuh)

Коли ми прискорили звичайне множення матриць (MUL_MAT) і увімкнули внутрішній профайлер (SD_CUDA_PROF=1), картина змінилася: тепер головним гальмом став блок уваги - FLASH_ATTN_EXT, який з'їдав до 20–25% часу кожного кроку генерації. І це логічно: у стоковому ggml-cuda для архітектури Pascal просто немає швидкого спеціалізованого ядра FlashAttention, тому відеокарта змушена прокручувати важкі матриці уваги через повільні шляхи у FP32.

Ми з Гідрою вирішили не залишати це вузьке місце і написали власне ядро kernel_flash_attn_dp4a<D> (спочатку під стандартну розмірність голови уваги head_dim = 128, а згодом додали і підтримку head_dim = 64 із захистом меж пам'яті для потоків варпу lane >= 16):

  • Тайли матриць Q, K, P та V квантуються в INT8 прямо на льоту всередині блоку.

  • Найважчі матричні добутки Q·Kᵀ та P·V тепер теж крутяться на максимальній швидкості через апаратний __dp4a.

  • Критичний момент для Pascal -чесний FP32 онлайн-софтмакс. Проміжний розрахунок експоненти (softmax) між двома множеннями виконується суворо в 32-бітній точності (FP32). Ми свідомо не використали там жодної інструкції half2 (FP16), щоб випадково не спіймати той самий 64-кратний штраф швидкості на картах GTX 1000. Додатково в ядро заклали повноцінну підтримку GQA (Grouped-Query Attention) та масок уваги.

Результат перевершив очікування: сам оператор FLASH_ATTN_EXT прискорився у 2.12 раза! Загальний час семплінгу на моделі anima-Q4_K скоротився вже до 28.66 с (1.40 с/it, тобто +71.8% відносно стоку). А на версії anima-Q3_K ми отримали падіння часу з 52.49 с до 28.46 с (1.39 с/it) — приріст швидкості склав вражаючі +84.4%!

Крок 3. Дворівнева робота з пам'яттю: Persistent W8 Cache + Scratchpad Buffer

На відносно компактній моделі Anima все літало, але щойно ми перейшли до справді важких сучасних гігантів - таких як Krea 2 (~5.3 ГБ) та Z-Image (~5 ГБ) - на 8-гігабайтній GTX 1070 ми боляче вдарилися об стелю відеопам'яті.

Чому так сталося? Дивіться: щоб працювати без затримок, нашому ядру з Кроку 1 потрібно зберігати у VRAM розпаковану int8-копію ваг. Для невеликої моделі це не проблема. Але коли сама модель займає понад 5 ГБ, спроба покласти поруч ще й її розпакований кеш призводить або до миттєвого вильоту за нестачею пам'яті (Out of Memory), або до ще гіршого сценарію - внутрішній планувальник ggml_graph_cut бачить дефіцит VRAM, починає різати граф обчислень на десятки дрібних шматків і на кожному кроці ганяє шари туди-сюди через повільну шину PCIe.

Потрібно було елегантне інженерне рішення, яке б дозволило і рибку з'їсти (зберегти швидкість тайлів 128×128), і в ліміт 8 ГБ вписатися. Так народилася дворівнева схема пам'яті в dp4a_gemm.cu у парі з новими надшвидкими ядрами розпаковки (32×8, 8 варпів на блок):

  1. Рівень 1 (Persistent W8 Cache - постійний кеш у VRAM). Ядро кешує розпаковані int8-ваги шарів у відеопам'ять рівно доти, доки на карті залишається залізний безпечний резерв у 1536 МБ вільної пам'яті (перевірка cudaMemGetInfo < need_bytes + 1536 МБ автоматично зупиняє подальше розростання кешу). Чому саме півтора гігабайта? Цього запасу гарантовано вистачає для робочих буферів графа та декодера VAE, завдяки чому ggml ніколи не ріже модель на сегменти.

  2. Рівень 2 (On-the-fly Layer Scratchpad - тимчасовий буфер одного шару). Усі шари важкої моделі, які не помістилися в Рівень 1 (або взагалі всі шари, якщо примусово задати SD_CUDA_DP4A_CACHE_MB=0), не відкочуються на повільний стоковий mmq! Замість цього прямо перед множенням матриць поточний шар за мікросекунди розпаковується у єдиний перевикористовуваний тимчасовий буфер розміром лише ~16–96 МБ (Scratchpad) і все одно пережовується нашим швидким ядром 128×128 __dp4a.

Перевірка боєм: коли ми заради експерименту повністю вимкнули постійний кеш (CACHE_MB=0), залишивши лише крихітний 16-мегабайтний Scratchpad, модель anima-Q4_K видала 29.36 с (1.43 с/it) проти 28.66 с із повним кешем — втрата швидкості склала якісь копійчані 2%, зате економія VRAM колосальна! А головне - 5.5-гігабайтна Krea 2 Turbo Q3_K тепер спокійно помістилася у 8 ГБ пам'яті GTX 1070 і прискорилася зі стокових 50.17 с (6.03 с/it) до 28.59–28.67 с (3.25–3.32 с/it), давши чисті +75% приросту!

Крок 4. Підтримка всього зоопарку квантів та детектив із sd-server

Щоб наш бекенд був універсальним інструментом, а не милицею під один конкретний файл, ми з Гідрою послідовно написали швидкі ядра розпаковки (32×8) для всієї лінійки популярних форматів квантування ggml:Q3_K, Q4_K, Q4_0, Q4_1, Q5_K, Q5_0, Q5_1, Q6_K та Q8_0.(Невеличка ремарка для допитливих: формату Q6_1 у природі ggml просто не існує, бо 6-бітні ваги там представлені виключно блоками Q6_K, а специфічне сімейство векторних квантів IQ* ми свідомо залишили за дужками).

Коли ж прийшов час інтегрувати наше рішення у sd-server для роботи всередині моєї локальної студії CoT Studio, виліз дуже підступний баг. Запускаю генерацію важкої моделі сімейства Z-Image (Q5_K) у розширенні 832×1216 через студію - і бачу жахливі 11 с/it. Тобто швидкість рівня чистого стоку! Як так, якщо в консольному sd-cli все літає?

Розтин показав класичну пастку системи збірки: у CMakeLists.txt прапорець компіляції SD_USE_CUDA передавався лише консольному клієнту, а серверний таргет sd-server збирався без нього і мовчки ігнорував наш бекенд. Після того як ми виправили CMake та перезібрали sd-server_DP4a.exe, час кроку на Z-Image безпосередньо в інтерфейсі CoT Studio миттєво впав із 11 с до 6.9 с (навіть із текстовим енкодером на GPU), а в чистому CLI-режимі - взагалі до 5.43 с/it!

Крок 5. Ізоляція кешу для сервера та захист VAE від пастки FP16 1:64

На фінальному етапі полірування ми закрили ще два критично важливих інженерних моменти, без яких бекенд не можна було б назвати стабільним:

  1. Безпечне очищення кешу при зміні моделі в sd-server (g_state[device]). У чому тут підступ? Консольний sd-cli запустився, згенерував картинку і закрився - операційна система сама прибрала всю пам'ять. А от sd-server висить у фоні постійно. Наш кеш першого рівня запам'ятовує розпаковані ваги за адресою тензора у відеопам'яті (src0->data). Якщо ви в сервері вивантажите, скажімо, модель Anima і завантажите на її місце Krea 2, драйвер NVIDIA виділить новій моделі ті самі звільнені адреси у VRAM. Без примусового скидання кешу ядро побачить знайомі адреси і підсуне новій моделі старі ваги від попередньої! Тому ми розділили стан кешу окремо для кожної відеокарти в системі (g_state[device]) і жорстко прив'язали його очищення (ggml_cuda_dp4a_clear_cache()) до моменту вивільнення контексту моделі (free_sd_ctx), при цьому не зачіпаючи покрокове вивантаження --offload-to-cpu.

  2. Захист від просідання cuBLAS у VAE. Оскільки декодер VAE та окремі допоміжні шари часто зберігаються у форматі FP16, існував ризик, що стандартна бібліотека NVIDIA cuBLAS на картах Pascal спробує рахувати їх у нативному 16-бітному режимі і свалиться у той самий штраф швидкості 1:64. Щоб перекрити цю шпарину, ми у файлі ggml-cuda.cu примусово увімкнули режим накопичення у FP32 (prefer_f32_output = true / CUDA_R_32F) для всіх операцій GGML_TYPE_F16 на архітектурі SM 6.1 при активному --dp4a.

Результати тестування на GTX 1070 8 ГБ: цифри, якість та стрес-тест

Теорія та код - це чудово, але давайте подивимось, як вся ця архітектура поводиться у реальних завданнях на нашій піддослідній GTX 1070 8 ГБ.

Базові заміри продуктивності (512×768, тайлінг VAE 512×512, енкодер на CPU)

Спочатку ми прогнали серію тестів у класичному вертикальному форматі 512×768, щоб оцінити не лише максимальний приріст із повним кешем, а й те, наскільки швидко працює наш другий рівень пам'яті (тимчасовий буфер Scratchpad при примусово вимкненому кеші CACHE_MB=0):

Сімейство моделі та квант

Режим роботи

Швидкість кроку

Чистий час семплінгу

Прискорення

Anima (Q4_K), 20 кроків

Сток (mmq)

2.41 с/it

49.24 с

—

Anima (Q4_K), 20 кроків

--dp4a (повний кеш)

1.40 с/it

28.66 с

+71.8%

Anima (Q4_K), 20 кроків

--dp4a (CACHE_MB=0, буфер ~16 МБ)

1.43 с/it

29.36 с

+67.7%

Anima (Q3_K), 20 кроків

Сток (mmq)

2.62 с/it

52.49 с

—

Anima (Q3_K), 20 кроків

--dp4a (повний кеш)

1.39 с/it

28.46 с

+84.4%

Anima (Q3_K), 20 кроків

--dp4a (CACHE_MB=0, буфер ~16 МБ)

1.54 с/it

30.75 с

+70.7%

Krea 2 (Q3_K), 8 кроків

Сток (mmq)

6.03 с/it

50.17 с

—

Krea 2 (Q3_K), 8 кроків

--dp4a (авто / буфер ~96 МБ)

3.25–3.32 с/it

28.59–28.67 с

+75.0%…+75.5%

Зверніть увагу на цікавий технічний нюанс: у стоковому режимі молодший квант Q3_K на моделі Anima працює навіть повільніше за Q4_K (2.62 с/it проти 2.41 с/it), тому що стоковому ядру складніше розбирати непарні бітові маски 3-бітного формату на кожному кроці. У нашому ж режимі --dp4a з кешем обидва формати розпаковуються у плоский int8 лише один раз, тому Q3_K та Q4_K видають однакові 1.39–1.40 с/it, а приріст відносно стоку на Q3_K сягає 84.4%!

Окремо перевірили важку Z-Image (Q5_K) у високому портретному розширенні 832×1216 (2 кроки, --cfg-scale 1.0):

Режим роботи

Крок 1 (з ініціалізацією)

Крок 2 (усталений)

Семплінг разом (2 кроки)

Прискорення

Сток (без --dp4a)

12.42 с/it

10.24 с/it

22.69 с

—

Наша збірка (--dp4a)

7.26 с/it

5.43 с/it

12.74 с

+78.1%

На усталеному другому кроці ми отримуємо майже двократне скорочення часу очікування — з 10.24 с до 5.43 с.

Перевірка якості та швидкості у 768×768 (8 кроків, --seed 42)

Головне побоювання будь-якого ентузіаста, коли він чує про переведення активацій та уваги у INT8: «А чи не перетвориться картинка на мило з артефактами?». Щоб відповісти на це питання предметно, ми прогнали всі три сімейства моделей у розширенні 768×768 (8 кроків, --cfg-scale 1.0, фіксований --seed 42) і порівняли рендери напряму:

Сімейство моделі

Семплінг (Сток)

Семплінг (--dp4a)

Повний час (Сток → --dp4a)

Візуальний вердикт

Krea 2 (Q3_K)

80.65 с

41.92 с (1.92x)

89.93 с → 50.25 с

Повний паритет: пори шкіри, відблиск в оці, вії, латунні шестерні та плівкове зерно без жодного мила

Z-Image (Q5_K)

38.61 с

21.02 с (1.84x)

45.40 с → 27.77 с

Повний паритет: текстура шкіри, окремі волосинки, відблиски та метал абсолютно чисті

Anima (Q4_K + Turbo LoRA)

19.08 с

12.14 с (1.57x)

27.31 с → 20.10 с

Чіткий лайн, контраст та дрібні деталі без будь-якої деградації

Стрес-тест у чесному FullHD (1920×1080) та моніторинг VRAM

Але чи витримає наша дворівнева схема пам'яті справжній краш-тест? Ми запустили генерацію у повноцінному FullHD (1920×1080) на важкій моделі Krea 2 (Q3_K) на тій самій 8-гігабайтній GTX 1070, паралельно знімаючи показники споживання відеопам'яті через nvidia-smi кожні пів секунди:

Метрика

Сток (без --dp4a)

Наша збірка (--dp4a)

Підсумок

Крок 1

55.69 с/it

31.35 с/it

у 1.78x швидше

Крок 2 (усталений)

48.69 с/it

24.13 с/it

у 2.02x швидше

Чистий семплінг (2 кроки)

104.44 с

55.51 с

у 1.88x швидше

Декодування VAE (18 тайлів 512×512)

30.85 с

30.84 с

повний паритет

Загальний час генерації

136.80 с

87.89 с

економія майже 49 секунд

Пікове споживання VRAM (nvidia-smi)

6748 MiB

6870 MiB

лише +122 MiB (запас ~1.3 GiB)

Середнє споживання VRAM

5210 MiB

5677 MiB

+467 MiB

Подивіться на ці цифри: на усталеному кроці у важкому FullHD ми отримали рівно двократне прискорення (2.02x) - 24.13 с замість 48.69 с! При цьому пікове споживання відеопам'яті зросло на смішні 122 мегабайти, залишивши понад 1.3 ГБ вільного запасу. Тобто наш лімітер у 1536 МБ та буфер Scratchpad відпрацювали як швейцарський годинник.

Наостанок ми перевірили ще важчу версію Krea 2 у кванті Q4_K (вага самого файлу — 6.72 ГБ) із увімкненим --offload-to-cpu все на тій же 8 ГБ GTX 1070:

  • У розширенні 512×512 усталений крок прискорився з 4.03 с/it до 2.52 с/it (1.60x), а загальний семплінг скоротився з 15.15 с до 12.35 с.

  • У важкому квадраті 1024×1024 швидкість кроку зросла з 18.34 с/it до 10.09 с/it (1.82x), зменшивши час семплінгу з 44.47 с до 27.09 с.

Тепер найцікавіше, а саме, приклади генерацій і порівняння стокового ядра з нашим кастомним. Ще раз наголошую: чекпоінти та seed були однакові у всіх тестових прогонах, та на обох ядрах:

Anima (Q4_K + Turbo LoRA)

01-anima-q4k-1024-30steps-stock.png
01-anima-q4k-1024-30steps-dp4a.pngDP4a (INT8)

Z-Image (Q5_K)

03-zimage-q5k-1024-8steps-stock.png
03-zimage-q5k-1024-8steps-dp4a.pngDP4a (INT8)

Krea 2 Tutbo (Q3_K)

02-krea2-q3k-1024-10steps-stock.png
02-krea2-q3k-1024-10steps-dp4a.pngDP4a (INT8)

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

Обмеження та підводні камені

Я б не поважав себе як автора, якби показав вам лише красиві графіки прискорення і промовчав про нюанси. Будь-яка низькорівнева оптимізація має свої фізичні та архітектурні межі. Під час тестів ми з Гідрою зіткнулися з трьома важливими моментами, про які ви маєте знати заздалегідь:

1. Сирі .safetensors у форматі FP16 / BF16 не прискорюють лінійні шари напряму

Наше матричне ядро W8A8 __dp4a перехоплює виключно квантовані формати ваг (Q3_K – Q8_0). Якщо ви згодуєте програмі оригінальний неквантований чекпоінт у BF16 або FP16, наш бекенд прискорить лише блоки уваги FlashAttention (це дасть скромні +15–20%), а всі основні матричні множення підуть стандартним шляхом через cuBLAS.

Як це обійти без конвертації моделі на диску? Дуже просто: достатньо передати прапорець --type q8_0 при запуску .safetensors. У цьому випадку stable-diffusion.cpp прямо під час завантаження на льоту квантує ваги у 8-бітний формат Q8_0. Модель одразу займає вдвічі менше відеопам'яті, зберігає ~99% візуальної якості оригіналу і на повну вмикає наше прискорення __dp4a.

2. Пастка --offload-to-cpu та ggml_graph_cut: показовий кейс на P102-100 (10 ГБ)

Коли ми перенесли тести на наш «безголовий» майнерський прискорювач P102-100 10 ГБ, спливла дуже повчальна історія. Важка модель Krea 2 у кванті Q3_K (~5.3 ГБ) відпрацювала на P102 просто чудово (~200 секунд на важкому прогоні). А от коли ми спробували запустити ту саму модель у більших квантах Q4_K та Q4_0 (вага файлу 6.7–7.0 ГБ), час генерації раптово обвалився до ~450 секунд — тобто майже до рівня стоку!

І що найцікавіше: на 8-гігабайтній ігровій GTX 1070 той самий 6.72-гігабайтний файл Q4_K щойно в наших тестах чесно показав 1.82-кратне прискорення (10.09 с/it проти 18.34 с/it). Що за чортівня?

Розгадка криється у роботі прапорця --offload-to-cpu та планувальника ggml_graph_cut. Як тільки сумарний обсяг «ваги моделі + робочі буфери графа» (на P102 це зайняло 8.7 ГБ із 10 ГБ) перетинає внутрішній поріг одного суцільного сегмента, ggml_graph_cut починає примусово різати модель на ~33 дрібних сегменти по 13 тензорів у кожному. У логах це виглядає як нескінченні рядки loading tensors completed, taking 0.21s десятки разів на кожному кроці семплінгу! Тобто рушій починає безперервно ганяти шматки ваг із системної ОЗП у відеопам'ять через шину PCIe прямо під час обчислень.

На повноцінній GTX 1070 із широкою шиною PCIe 3.0 x16 ці пересилання проходять відносно безболісно. А от на майнерській P102-100, де шина фізично задушена до PCIe 1.0 x4, затик на перекачуванні гігабайтів даних туди-сюди повністю з'їдає весь виграш від швидкого ядра на GPU.

Висновок простий: якщо ви використовуєте майнерські карти серії P100 із повільною шиною PCIe та прапорцем --offload-to-cpu, критично важливо обирати такий квант моделі, який вкладається в один суцільний сегмент без розрізання графа (для 12-мільярдних моделей рівня Krea 2 на 10 ГБ карті ідеальний баланс — це саме Q3_K вагою ~5.3–5.5 ГБ).

3. Де ще працює ця архітектура за межами stable-diffusion.cpp? (Спойлер: ми вже імплантували її в 3D-авторигінг!)

Зв'язка нашого конвеєра W8A8 __dp4a, чесного FP32 софтмаксу у FlashAttention та блокування повільного FP16 1:64 у cuBLAS - це не якась специфічна милиця суто під генерацію картинок. Це універсальний рецепт для архітектури Pascal (SM 6.1), який дає кратний приріст скрізь, де відеокарта впирається безпосередньо в обчислення (compute-bound), тобто перемножує достатньо «широкі» матриці з розмірністю потоку даних M >= 16.

І щоб не кидатися голослівною теорією про те, що цей підхід міг би прискорити генерацію відео, аудіо чи фазу читання довгого промпту (prefill) у LLM, ми з Гідрою пішли далі і буквально імплантували наші ядра dp4a_gemm та fattn_dp4a у зовсім інший проєкт — генератор 3D-скелетів та скіннінгу для ігрових моделей (SkinTokens / skt_rig).

Для перевірки ми квантували базову модель skintokens з FP32 у формат Q8_0 (вага файлу на диску одразу схудла з 2075 МБ до 1354.7 МБ) і прогнали повний цикл генерації скелета на тестовій 3D-моделі (woman.sktmesh, beam = 10, --seed 42). Результати цього тесту — просто ідеальна ілюстрація фізики роботи GPU:

Режим роботи (skt_rig)

shape

cond

backbone (beam = 10)

fsq_decoder (J = 52)

Загальний час

Пік VRAM

FP32 (еталонний сток)

210.3 мс

201.6 мс

13.49 с

14.93 с

30.94 с

2918.9 MiB

Q8_0 + dp4a_gemm

179.6 мс

185.3 мс

12.18 с

10.41 с

24.31 с

2734.9 MiB

Q8_0 + dp4a_gemm + fattn_dp4a

178.9 мс

185.1 мс

12.27 с

7.42 с (2.01x)

21.39 с

2734.9 MiB

Подивіться, наскільки закономірно поводяться різні частини однієї нейромережі:

  • Там, де чип рахує важку математику (fsq_decoder, де розмірність матриці M = 8192), ми отримали рівно 2.01-кратне прискорення (+101% швидкості)! Час роботи декодера впав із 14.93 с до 7.42 с, а на виході ми отримали абсолютно той самий скелет на 52 кістки. До речі, увімкнення fattn_dp4a у FsqDecoder дало ще й приємний бонус по пам'яті: ядру більше не потрібно виділяти проміжний буфер уваги kq, що додатково розвантажило граф у VRAM.

  • А от у блоці авторегресії (backbone) приріст мінімальний (13.49 с → 12.27 с). Чому? Бо при beam = 10 розмірність пакета становить M = 10 (менше за поріг ефективної утилізації тайлів M >= 16). На кожному кроці поштучного декодування відеокарта просто чекає, поки контролер пам'яті прокачає ваги з чипів GDDR5 (mmvq), а процесор відпрацює свої кроки. Тобто тут завдання є суто memory-bound (упирається у пропускну здатність шини пам'яті, а не в ALU чипа).

Саме тому важливо тверезо розуміти межі технології: під час поштучної генерації тексту у великих мовних моделях (batch = 1, M = 1) або в вузькій авторегресії ніякий W8A8 дива не зробить — там править бал виключно швидкість відеопам'яті. Але щойно з'являється щільний потік даних (дифузія, 3D-декодери, аудіо/відео, енкодери або батчевий prefill великого контексту в LLM) - наш нативний __dp4a конвеєр розкриває старі карти GTX 1000 та серію P100 на всі 200%!

Підсумки

Чи варто було витрачати стільки десятків годин на низькорівневу оптимізацію під архітектуру, якій у 2026 році вже виповнилося десять років? Як на мене - на всі сто відсотків так. І справа тут далеко не лише у нашій тестовій GTX 1070 8 ГБ чи майнерських P104-100 та P102-100.

Давайте подивимось на картину ширше. Що таке архітектура Pascal з індексом SM 6.1? Це ціла плеяда карт, які досі у величезній кількості живуть у домашніх ПК, робочих станціях та бюджетних AI-серверах. Окрім масових GTX 1060 6 ГБ, GTX 1070 Ti та GTX 1080, сюди входять справжні важковаговики на повному та майже повному кристалі GP102:

  • Народна легенда GTX 1080 Ti (11 ГБ) та її старші брати TITAN X (Pascal) і TITAN Xp (12 ГБ). З їхніми 11–12 гігабайтами швидкої пам'яті GDDR5X та широкою 352/384-бітною шиною наш конвеєр W8A8 __dp4a дозволить крутити квантовані Q4_K та Q5_K чекпоінти сучасних дифузійних гігантів без жодного розрізання графа, маючи на борту шалені ~44–48 TOPS цілочисельної потужності.

  • Серверний улюбленець ентузіастів локального ШІ - NVIDIA Tesla P40 (24 ГБ), а також професійна Quadro P6000 (24 ГБ). І ось для цих двох монстрів наше ядро стає буквальним квитком у друге життя! Чому? Бо маючи 24 ГБ VRAM, ви взагалі забуваєте про ліміти відеопам'яті: будь-яка важка модель рівня Krea 2, Z-Image або Flux не просто цілком залітає у пам'ять самої карти, а й на 100% розміщує там наш Persistent W8 Cache (Рівень 1). Жодного перекачування по PCIe, жодних компромісів — чистий конвеєр 128×128 __dp4a на всіх 3840 ядрах CUDA чипа GP102.

Тобто за фактом, коли софт перестає тупо битися головою об урізаний FP16 (1:64) і починає на повну використовувати апаратний INT8 __dp4a разом із правильним менеджментом пам'яті, старі добрі «Паскалі» перетворюються з повільних аутсайдерів на реально гідні обчислювачі, які генерують картинку майже вдвічі швидше за сток без жодної втрати візуальної якості.

Окремо хочу сказати про те, як саме народжувався цей проєкт. Для мене це був показовий приклад здорової інженерної синергії людини та ШІ. Якщо на старті з молодшою Gemini 3.8 Flash нам доводилося буквально воювати за кожну гіпотезу та виправляти дитячі одруківки в коді, то перехід на Gemini 4 Hydrogen (нашу Гідру) змінив правила гри. Коли ти сам чітко розумієш фізику заліза, бачиш, де саме захлинається пам'ять чи шина PCIe, і ставиш конкретне архітектурне завдання — інструмент рівня Гідри дозволяє реалізувати такі низькорівневі речі на C++/CUDA, на які в одного розробника пішли б місяці безсонних ночей над документацією NVIDIA.

Усі наші напрацювання, вихідні коди ядер dp4a_gemm.cu та fattn_dp4a.cuh, готові патчі для чистого апстриму stable-diffusion.cpp, а також вже зібрані бінарники під Windows (sd-cli_DP4a.exe та sd-server_DP4a.exe) ми відкрито викладаємо у публічний доступ. Забирайте, ганяйте на своїх GTX 1070, 1080 Ti, P104, P102, Tesla P40 чи Quadro P6000, інтегруйте у власні проєкти і обов'язково пишіть у коментарях, які цифри вийшли на вашому залізі.

Що ж, їжу для роздумів (і код для тестів) я вам надав, а зараз маю повертатися до стенду. Бо як ви вже здогадалися за спойлерами у тексті, в одному з наступних матеріалів на вас чекає детальний розбір польотів топового майнерського прискорювача на чипі GP102 - тієї самої P102-100 10 ГБ. Тож далеко не розходьтесь!

Посилання на репозиторій: sd-cpp-pascal-dp4a