Найшвидший спосіб обнулити 2d-масив у C?

Я хочу кілька разів обнулити великий 2d-масив у C. Це те, що я роблю на даний момент:

// Array of size n * m, where n may not equal m
for(j = 0; j < n; j++)
{
    for(i = 0; i < m; i++)
    {  
        array[i][j] = 0;
    }
}

Я спробував використовувати memset:

memset(array, 0, sizeof(array))

Але це працює лише для одновимірних масивів. Коли я надрукую вміст 2D-масиву, перший рядок дорівнює нулям, але тоді я отримав навантаження випадкових великих чисел, і він виходить з ладу.

memset(array, 0, sizeof(array[0][0]) * m * n);

Де mі n- ширина та висота двовимірного масиву (у вашому прикладі у вас є квадратний двовимірний масив, отже m == n).

Якщо arrayце справді масив, тоді ви можете "обнулити" за допомогою:

memset(array, 0, sizeof array);

Але є два моменти, які ви повинні знати:

• це працює, лише якщо arrayнасправді є "двовимірний масив", тобто було оголошено T array[M][N];для якогось типуT .
• він працює лише в тому обсязі, де arrayбуло оголошено. Якщо ви передасте його функції, тоді ім'я array спаде до покажчика і sizeofне дасть вам розміру масиву.

Давайте проведемо експеримент:

#include <stdio.h>

void f(int (*arr)[5])
{
    printf("f:    sizeof arr:       %zu\n", sizeof arr);
    printf("f:    sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("f:    sizeof arr[0][0]: %zu\n", sizeof arr[0][0]);
}

int main(void)
{
    int arr[10][5];
    printf("main: sizeof arr:       %zu\n", sizeof arr);
    printf("main: sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("main: sizeof arr[0][0]: %zu\n\n", sizeof arr[0][0]);
    f(arr);
    return 0;
}

На моїй машині вищезгадані відбитки:

main: sizeof arr:       200
main: sizeof arr[0]:    20
main: sizeof arr[0][0]: 4

f:    sizeof arr:       8
f:    sizeof arr[0]:    20
f:    sizeof arr[0][0]: 4

Незважаючи на те arr, що це масив, він передається покажчику на свій перший елемент при передачі f(), і тому розміри, надруковані в f()"неправильні". Крім того, f()за розміром arr[0]є розмір масиву arr[0], який є "масивом [5] з int". Це не розмір an int *, тому що "загнивання" відбувається лише на першому рівні, і саме тому нам потрібно заявитиf() , що бере вказівник на масив правильного розміру.

Отже, як я вже казав, те, що ви робили спочатку, працюватиме лише за умови, якщо будуть виконані дві наведені вище умови. Якщо ні, то вам потрібно буде зробити те, що сказали інші:

memset(array, 0, m*n*sizeof array[0][0]);

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

Ну, найшвидший спосіб це зробити - це взагалі не робити.

Звучить дивно, я знаю, ось якийсь псевдокод:

int array [][];
bool array_is_empty;


void ClearArray ()
{
   array_is_empty = true;
}

int ReadValue (int x, int y)
{
   return array_is_empty ? 0 : array [x][y];
}

void SetValue (int x, int y, int value)
{
   if (array_is_empty)
   {
      memset (array, 0, number of byte the array uses);
      array_is_empty = false;
   }
   array [x][y] = value;
}

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

Що призводить до запитання "чому ви хочете багаторазово обнуляти великий 2d-масив"? Для чого використовується масив? Чи є спосіб змінити код, щоб масив не потребував обнулення?

Наприклад, якщо у вас було:

clear array
for each set of data
  for each element in data set
    array += element 

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

 for set 0 and set 1
   for each element in each set
     array = element1 + element2

 for remaining data sets
   for each element in data set
     array += element 

Це не вимагає очищення масиву, але все одно працює. І це буде набагато швидше, ніж очищення масиву. Як я вже сказав, найшвидший спосіб - це не робити в першу чергу.

Якщо ви дійсно, справді одержимі швидкістю (і не стільки переносимістю), я думаю, що найшвидшим способом зробити це було б використання властивостей SIMD-вектора. наприклад, на процесорах Intel, ви можете скористатися цими інструкціями SSE2:

__m128i _mm_setzero_si128 ();                   // Create a quadword with a value of 0.
void _mm_storeu_si128 (__m128i *p, __m128i a);  // Write a quadword to the specified address.

Кожна інструкція магазину встановлюватиме чотири 32-бітові вставки до нуля за один удар.

p має бути вирівняним по 16 байтів, але це обмеження також добре для швидкості, оскільки воно допоможе кешу. Інше обмеження полягає в тому, що p повинен вказувати на розмір розподілу, кратний 16 байтам, але це теж круто, тому що це дозволяє нам легко розгортати цикл.

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

// Assumes int is 32-bits.
const int mr = roundUpToNearestMultiple(m, 4);      // This isn't the optimal modification of m and n, but done this way here for clarity.    
const int nr = roundUpToNearestMultiple(n, 4);    

int i = 0;
int array[mr][nr] __attribute__ ((aligned (16)));   // GCC directive.
__m128i* px = (__m128i*)array;
const int incr = s >> 2;                            // Unroll it 4 times.
const __m128i zero128 = _mm_setzero_si128();

for(i = 0; i < s; i += incr)
{
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
}

Існує також варіант _mm_storeu який обходить кеш-пам’ять (тобто обнулення масиву не забруднює кеш-пам’ять), що за певних обставин може дати вам певні переваги щодо продуктивності.

Див. Тут посилання на SSE2: http://msdn.microsoft.com/en-us/library/kcwz153a(v=vs.80).aspx

Якщо ви ініціалізуєте масив за допомогою malloc, використовуйте callocнатомість; це обнулить ваш масив безкоштовно. (Те саме, що очевидно, як memset, просто менше коду для вас.)

int array[N][M] = {0};

... принаймні в GCC 4.8.

Як було оголошено ваш 2D-масив?

Якщо це щось на зразок:

int arr[20][30];

Ви можете обнулити його, виконавши:

memset(arr, sizeof(int)*20*30);

Використовуйте мозоль замість мальлоку. calloc ініціює всі поля до 0.

int * a = (int *) calloc (n, розмір (int));

// всі комірки а були ініціалізовані до 0

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

(змінити тип покажчиків ptr та ptr1, якщо тип масиву відрізняється від int)

#define SIZE_X 100
#define SIZE_Y 100

int *ptr, *ptr1;
ptr = &array[0][0];
ptr1 = ptr + SIZE_X*SIZE_Y*sizeof(array[0][0]);

while(ptr < ptr1)
{
    *ptr++ = 0;
}

memset(array, 0, sizeof(int [n][n]));

Ви можете спробувати це

int array[20,30] = {{0}};

Це відбувається тому, що sizeof (масив) дає вам розмір розміщення об'єкта, на який вказує масив . ( масив - це просто вказівник на перший рядок вашого багатовимірного масиву). Однак ви виділили j масивів розміром i . Отже, вам потрібно помножити розмір одного рядка, який повертається на sizeof (масив) з кількістю виділених вами рядків, наприклад:

bzero(array, sizeof(array) * j);

Також зауважте, що sizeof (масив) працюватиме лише для статично виділених масивів. Для динамічно виділеного масиву ви б писали

size_t arrayByteSize = sizeof(int) * i * j; 
int *array = malloc(array2dByteSite);
bzero(array, arrayByteSize);