Question

I created a very simple code to learn if vector access is faster than matrix access.

I tried 3 things:

1: Create a vector with 100.000.000 elements of int:

int *matrix=(int*)malloc(sizeof(int)*100000*1000)
for(long int=x;x<100000*1000;x++)matrix[x]=1;

2: Create a matrix with the same size:

int ** matrix=(int**)malloc(sizeof(int*)*100000);
for(long int=0; x<100000;x++){
   matrix[x]=(int*)malloc(sizeof(int*)*1000);
}
for(int x=0; x<100000;x++){
   for(int y=0;y<1000;y++){
     matrix[x][y]=1;
   }
}

3: Create the same vector, but write inside it as matrix

for(int x=0; x<100000;x++){
   for(int y=0;y<1000;y++){
     matrix[(x*1000)+y]=1;
   }
}

Always the matrix access (CASE 2) takes 2 times the case 1 and 3.The Case 3 is a little bit faster then Case 1.
I’m using the -O2 param in my C++ compiler (g++)

I can understand why the vector is faster then the matrix: (But i’ll love some explanation).
But i cannot understand why the Case 3 is faster than the case 1, i imagined that the multiplication process will slow down the things a lot and not make it faster.
I don’t understand why, even if the difference is 0.002 ( It could be the time and the processor usage in the time (i imagine))

If i compile all the 3 cases without optimization the Case 2 is the slower, case 3 than case 1.
So, without the optimization process the case 1 is faster.

Vector is, usually, faster?

Thanks

Answer 1

The reason why case 2 is the slowest, is because it has one more level of indirection.

In case 1 and 3 you fetch the desired element from memory. While in case 2 you first have to fetch the address of the row/col array from memory, to make afterwards the fetch from the desired element. As in modern computer the memory accesses are the far most expensive operations (in terms of execution), it is no wonder that it is much slower.

The difference in 1 and 3 is as expected very minimal. Fiddling with the optimizing options already makes a difference, so here nobody can give you a definitivly answer with knowing the exact machine you are using. Best (and only reasonable) approach here would be, to look at the generated assembler code. One reason could be that in one version your loop variable is long, in the other not (therefor you do there the element address computation), depending on your cpu this can make a difference.

EDIT: Your wording is choosen very bad, as there is no Matrix memory access. Memory is always flat. A matrix addressing is just an “virtual” addressing you put on top (either directly like you did e.g. in 3) or indirect (by using e.g. a different language which does it for you, like fortran). So you have more or less to distinguish between different memory layouts for matrices. In 3 you have the matrix as one big chunk in the matrix, while in 2 you have it row-by-row/col-by-col in the memory, which has the disadvantage that it one more level of indirection (but has the advantage that you can faster perform certain operations, like e.g. swapping to rows, and that it can be better for a garbage collector). There are also many other ways to store matrices in memory (esp. if you have to handle sparse matrices).