是什么导致我的数组地址在传递给函数时被破坏（更改）？

Question

I am performing Compressed Sparse Raw Matrix Vector multiplications (CSR SPMV): This involves dividing the array A into multiple chunks , then pass this chunk by reference to a function, however only the first part of the array ( A[0] first chunk starting the beginning of the array) is modified. However starting from the second loop A[0 + chunkIndex] , when the function reads the sub array it jumps and reads a different address beyond the total array address range, although the indices are correct.

For reference:

---

The SPMV kernel is:

void serial_matvec(size_t TS,  double *A, int *JA, int *IA,  double *X, double *Y)
{
    double sum;
    for (int i = 0; i < TS; ++i)
    {   
        sum = 0.0;
        for (int j = IA[i]; j < IA[i + 1]; ++j)
        {
                sum += A[j] * X[JA[j]]; // the error is here , the function reads diffrent 
                                        // address of A,  and JA, so the access 
                                       // will be out-of-bound
            }
            Y[i] = sum;
        }
    }

and it is called this way:

int chunkIndex = 0;
for(size_t k = 0; k < rows/TS; ++k)
{
    chunkIndex = IA[k * TS];
    serial_matvec(TS, &A[chunkIndex], &JA[chunkIndex], &IA[k*TS], &X[0], &Y[k*TS]);
}

assume I process (8x8) Matrix , and I process 2 rows per chunk , so the loop k will be r ows/TS = 4 loops , the chunkIndex and array passed to the function will be as following:

chunkIndex: 0 --> loop k = 0, &A[0], &JA[0]

chunkIndex: --> loop k = 1, &A[16], &JA[16] //[ERROR here, function reads different address]

chunkIndex: --> loop k = 2, &A[32], &JA[32] //[ERROR here, function reads different address]

chunkIndex: --> loop k = 3, &A[48], &JA[48] //[ERROR here, function reads different address]

When I run the code, only the first chunk executes correctly, the other 3 chunks memory are corrupted and the array pointers jump into boundary beyond the array size.

I've checked all indices manually, of all the parameter, they are all correct, however when I print the addresses they are not the same. (debugging this for 3 days now)

I used valgrind and it reported:

Invalid read of size 8 and Use of uninitialised value of size 8 at the sum += A[j] * X[JA[j]]; line

I compiled it with -g -fsanitize=address and I got

heap-buffer-overflow

I tried to access these chunks manually outside the function, and they are correct, so what can cause the heap memory to be corrupted like this ?

The code is here , This is the minimum I can do.

Answer 1

The problem was that I was using global indices (indices inside main) when indexing the portion of the array ( chunk ) passed to the function, hence the out-of-bound problem.

The solution is to start indexing the sub-arrays from 0 at each function call, but I had another problem. At each function call, I process TS rows, each row has different number of non-zeros.

As an example, see the picture, chunk 1 , sorry for my bad handwriting, it is easier this way. As you can see we will need 3 indices , one for the TS rows proceeded per chunk i , and the other because each row has different number of non-zeros j , and the third one to index the sub-array passed l , which was the original problem.

and the serial_matvec function will be as following:

void serial_matvec(size_t TS, const double *A, const int *JA, const int *IA,
                   const double *X, double *Y) {
  int  l = 0;
  for (int i = 0; i < TS; ++i) {
    for (int j = 0; j < (IA[i + 1] - IA[i]); ++j) {
      Y[i] += A[l] * X[JA[l]];
      l++;
    }    
  }
}

The complete code with test is here If anyone has a more elegant solution, you are more than welcome.