Чому в результаті множення масивів 2048x2048 порівняно з множиною 2047x2047 є величезна ефективність?

Я роблю деякий показник множення матриць, як це було зазначено раніше, Чому MATLAB настільки швидкий у матричному множенні?

Тепер у мене з'явився ще один випуск: при множенні двох матриць 2048x2048 існує велика різниця між C # та іншими. Коли я намагаюся помножити лише матриці 2047x2047, це здається нормальним. Додано ще деякі для співставлення.

1024x1024 - 10 секунд.

1027x1027 - 10 секунд.

2047x2047 - 90 секунд.

2048x2048 - 300 секунд.

2049x2049 - 91 секунда. (оновлення)

2500x2500 - 166 секунд

Це різниця в три з половиною хвилини для випадку 2k на 2k.

використовуючи 2dim масиви

//Array init like this
int rozmer = 2048;
float[,] matice = new float[rozmer, rozmer];

//Main multiply code
for(int j = 0; j < rozmer; j++)
{
   for (int k = 0; k < rozmer; k++)
   {
     float temp = 0;
     for (int m = 0; m < rozmer; m++)
     {
       temp = temp + matice1[j,m] * matice2[m,k];
     }
     matice3[j, k] = temp;
   }
 }

Це, мабуть, стосується конфліктів у вашому кеш-пам'яті L2.

Пропуски кеша на matice1 не є проблемою, оскільки до них звертаються послідовно. Однак для matice2, якщо повний стовпець вписується в L2 (тобто, коли ви отримуєте доступ до matice2 [0, 0], matice2 [1, 0], matice2 [2, 0] ... і т. Д., Нічого не вилучається), ніж немає проблем з кеш пропущений і з matice2.

Тепер заглибимось у те, як працює кеш, якщо байт-адреса вашої змінної дорівнює X, ніж рядок кешу для неї буде (X >> 6) & (L - 1). Де L - загальна кількість рядків кеша у вашому кеші. L завжди потужність 2. Шість походить від того, що 2 ^ 6 == 64 байти - це стандартний розмір лінії кеша.

Тепер що це означає? Ну це означає, що якщо у мене адреса X і Y і (X >> 6) - (Y >> 6) ділиться на L (тобто деяка велика потужність 2), вони будуть зберігатися в тій же кеш-лінії.

Тепер, щоб повернутися до вашої проблеми, яка різниця між 2048 та 2049,

коли 2048 - ваш розмір:

якщо взяти & matice2 [x, k] і & matice2 [y, k], різниця (& matice2 [x, k] >> 6) - (& matice2 [y, k] >> 6) буде розділена на 2048 * 4 (розмір поплавця). Так велика потужність 2.

Таким чином, залежно від розміру вашого L2, у вас буде багато конфліктів між кешами, і ви використовуєте лише невелику частину свого L2 для зберігання стовпця, таким чином, ви фактично не зможете зберігати повний стовпець у своєму кеші, таким чином ви отримаєте погану ефективність .

Якщо розмір становить 2049, то різниця становить 2049 * 4, що не має сили 2, тож у вас буде менше конфліктів, і ваш стовпець буде безпечно вписуватися у ваш кеш.

Тепер для перевірки цієї теорії ви можете зробити кілька речей:

Виділіть свій масив matice2, як цей matice2 [razmor, 4096], і запустіть з razmor = 1024, 1025 або будь-якого розміру, і ви повинні побачити дуже погану продуктивність порівняно з тим, що раніше мали. Це тому, що ви змушуєте вирівнювати всі стовпці, щоб суперечити один одному.

Потім спробуйте matice2 [razmor, 4097] і запустіть його будь-якого розміру, і ви повинні побачити набагато кращу продуктивність.

Можливо, ефект кешування Маючи розміри матриці, які мають велику потужність у два, і розмір кешу, який також є потужністю двох, ви можете закінчити лише за допомогою невеликої частки кеш-пам'яті L1, сильно уповільнивши ситуацію. Наївне множення матриць зазвичай обмежене необхідністю отримання даних у кеш. Оптимізовані алгоритми з використанням плиткових алгоритмів (або алгоритмів, що не підлягають кешу) зосереджуються на тому, щоб краще використовувати кеш L1.

Якщо ви час інших пар (2 ^ n-1,2 ^ n), я думаю, ви побачите подібні ефекти.

Для більш повного пояснення у внутрішній циклі, де ви отримуєте доступ до matice2 [m, k], ймовірно, що matice2 [m, k] та matice2 [m + 1, k] зміщені один від одного на 2048 * sizeof (float) і, таким чином, відображати один і той же індекс у кеші L1. З керованим асоціативним кешем N-способу у вас зазвичай буде 1-8 розташувань кешу для всіх цих. Таким чином, майже всі ці звернення ініціюють вилучення кешу L1 та отримання даних із більш повільного кешу чи основної пам'яті.

Це може бути пов'язано з розміром кеш-процесора. Якщо 2 ряди матричної матриці не підходять, то ви втратите час замінюючи елементи з ОЗП. Додаткових 4095 елементів може бути достатньо, щоб не допустити розміщення рядків.

У вашому випадку 2 ряди для 2047 2d матриць потрапляють в пам'ять 16 КБ (при 32 типі бітів). Наприклад, якщо у вас є кеш L1 (найближчий до процесора в шині) об'ємом 64 Кб, то ви можете помістити принаймні 4 ряди (2047 * 32) в кеш відразу. Якщо довші ряди є необхідними, щоб прокладки пари рядків перевищували 16 КБ, тоді все починає плутатись. Крім того, кожен раз, коли ви "пропускаєте" кеш, заміна даних з іншого кешу або основної пам'яті затримує речі.

Моя здогадка полягає в тому, що на відмінність часу запуску, яке ви бачите з різними розмірами матриць, впливає те, наскільки ефективно операційна система може використовувати наявний кеш (а деякі комбінації просто проблематичні). Звичайно, це все грубе спрощення з мого боку.

Луї Бренді написав дві публікації в блозі, аналізуючи саме це питання:

Більше Craziness Cache та обчислювальна продуктивність - практичне дослідження для початківців із цікавою статистикою та спробами пояснити поведінку більш детально, воно дійсно зводиться до обмежень розміру кешу.

Враховуючи, що час падає на більші розміри, чи не буде більш ймовірним конфлікт кешу, особливо з потужностями 2 для проблемних розмірів матриці? Я не є фахівцем з питань кешування, але відмінна інформація з питань продуктивності кеша , пов'язані тут .

Коли ви звертаєтесь до matice2масиву вертикально, він буде помінятись у кеш-пам'ять та виходити з неї значно більше. Якщо дзеркально відобразити масив по діагоналі, щоб ви могли отримати доступ до нього, використовуючи [k,m]замість [m,k], код запуститься набагато швидше.

Я перевірив це на матрицях 1024x1024, і це приблизно вдвічі швидше. Для матриць 2048x2048 це приблизно в десять разів швидше.

Збільшення кешу

Або кеш-обмолот , якщо я можу ввести термін.

Кеші працюють за допомогою індексації бітами низького порядку та позначенням бітів високого порядку.

Уявіть, що у вашому кеші є 4 слова, а у вашої матриці розмір 4 х 4. Коли доступ до стовпця має значення, а рядок має будь-яку потужність у довжину двох, то кожен елемент стовпця в пам'яті буде відображатись на той самий елемент кешу.

Потужність-два-плюс-один насправді приблизно оптимальна для цієї проблеми. Кожен новий елемент стовпця буде відображатись у наступному слоті кеша точно так, як якщо б він отримував доступ за рядком.

У реальному житті тег охоплює кілька послідовно зростаючих адрес, які кешуватимуть кілька сусідніх елементів підряд. Зсуваючи відро, на яке відображається кожен новий рядок, проходження стовпця не замінює попередній запис. При переході наступного стовпця весь кеш буде заповнений різними рядками, і кожен розділ рядка, який впишеться в кеш, буде потрапляти на кілька стовпців.

Оскільки кеш значно швидший, ніж DRAM (в основному в силу того, що він знаходиться на чіпі), швидкість звернення - це все.

Здається, ви досягли обмеження розміру кешу, або, можливо, у вас виникли проблеми з повторюваністю у часі.

Незалежно від проблеми, ви просто не повинні писати матричне множення самостійно в C #, а натомість використовувати оптимізовану версію BLAS. Цей розмір матриці повинен бути помножений на секунду на будь-якій сучасній машині.

Ефективне використання ієрархії кешу є дуже важливим. Потрібно переконатися, що багатовимірні масиви мають гарне розташування даних, що може бути досягнуто плиткою . Для цього вам потрібно буде зберегти 2D масив як 1D масив разом з механізмом індексації. Проблема традиційного методу полягає в тому, що хоча два суміжні елементи масиву, що знаходяться в одному рядку, знаходяться поруч один з одним у пам'яті, два суміжні елементи в одному стовпчику будуть розділені W елементами в пам'яті, де W - кількість стовпців . Плитка може скласти стільки ж, скільки і в десять разів різниця в продуктивності.

Я підозрюю, що це результат чогось під назвою " Послідовне потоплення ". Це те, що ви намагаєтеся провести перегляд списку об'єктів, який трохи більший за розмір кешу, тому кожен окремий запит до списку (масиву) повинен бути виконаний з оперативної пам'яті, і ви не отримаєте жодного кешу хіт.

У вашому випадку ви перебираєте свої масиви 2048 в індексах 2048 разів, але у вас є лише простір для 2047 (можливо, через деяку накладну структуру масиву), тому кожен раз, коли ви отримуєте доступ до позиції масиву, йому потрібно отримати цю позицію масиву від барана. Потім він зберігається в кеші, але безпосередньо перед його повторним використанням він скидається. Таким чином кеш по суті є марним, що призводить до набагато більшого часу виконання.