What is the most optimized way to assign a value to a two dimensional array?

Question

I want to know what is the most optimal way to assign a value to a two-dimensional array?.

Say, I want to assign value 12 to the below array.

for (int i = 0; i < m; i+++)
    for (int j = 0; j < n; j++)
        array[i][j] = 10

Is there any better way to do this without for loop?.

Answer 1

Your code is fine, readable and simple, except for the typos. Just make sure you use the same type for i and j as that of n and m.

#define N 10
#define M 10
    int array[M][N];
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++)
            array[i][j] = 0;
    }

The advantage of writing the code this way is it works for both a flat 2D array int array[M][N] and an array of arrays int *array[M] as well as a pointer to an array of arrays int **array.

If the array is a flat 2D array of integers and the value is 0, there is an alternative:

memset(array, 0, sizeof(array[0][0]) * M * N);

But it only works for very specific values that are represented in memory with identical bytes in all positions. Such is the case for 0 and -1 for regular two's complement architectures and 254 other less obvious values (out of 4 billion).

You could also intialize a single row and copy that to the following ones...

Such optimisations are confusing, error prone and unnecessary as modern optimizing compilers will generate very efficient code for this:

#define M 10
#define N 10
void clear_matrix(int array[M][N]) {
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < N; j++)
            array[i][j] = 0;
    }
}

Notes:

• Code correctness always beats optimisation: what is the purpose of getting incorrect results fast?
• Always benchmark and profile before you optimize, and focus first on the bottlenecks that stand out as obvious targets.
• It is unlikely for the matrix intialization to be the bottleneck. If is it, your algorithm is probably at fault.
• Finding a better algorithm, with reduced complexity, is a more productive effort than micro-optimisation.

Answer 2

This question is almost impossible to answer. Simple test:

#define ROWS 1000
#define COLS 4000

int arr[ROWS][COLS];

void __attribute__((noinline)) set(int val)
{
    for(size_t col = 0; col < COLS; col++)
    {
        arr[0][col] = val;
    }
    for(size_t row = 1; row < ROWS; row++)
    {
        memcpy(arr[row], arr[0], sizeof(arr[0]));
    }
}

void __attribute__((noinline)) set1(int val)
{
    static int arr1[COLS];
    for(size_t col = 0; col < COLS; col++)
    {
        arr1[col] = val;
    }
    for(size_t row = 0; row < ROWS; row++)
    {
        memcpy(arr[row], arr1, sizeof(arr1));
    }
}


void __attribute__((noinline)) set2(int val)
{
    for(size_t row = 0; row < ROWS; row++)
        for(size_t col = 0; col < COLS; col++)
        {
            arr[row][col] = val;
        }
}


int main(void)
{
    clock_t begin, end;
    double time_spent;

    begin = clock();
    for(int x = 0; x < 1000; x++)
    {
        set(x);
    }

    end = clock();
    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

    printf("%f\n", time_spent);

    begin = clock();

    for(int x = 0; x < 1000; x++)
    {
        set1(x);
    }
    end = clock();
    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("%f\n", time_spent);


    begin = clock();

    for(int x = 0; x < 1000; x++)
    {
        set2(x);
    }
    end = clock();
    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("%f\n", time_spent);

}

Godbolt shows that the loop method is fastest: https://godbolt.org/z/K9Gcbs

1.162777
1.009047
0.973361

But by ubuntu 20.4 64 bits test (same compiler version, same compiler options) gives right opposite results.

0.542433
0.502667
0.936434

So the conclusion is: Always benchmark. Do not trust opinions and myths.