OMP data dependency array in a struct

I am new in parallel programming with OpenMP and I am just learning how task and data dependency work. I develop a simply matrix multiplication (using blocks) program where I define a struct as follow:

struct matrix {
    int ncols;
    int nrows;
    double* mat;
};

Now, for each matrix I do a malloc to obtain a linear vector and so a linearised matrix. The parallelized code that I'm tring to write is this:

#pragma omp parallel
#pragma omp single
for(i=0; i<m1->nrows; i+=BS){
        for(j=0; j<m2->ncols; j+=BS){
            for(k=0; k<m3->ncols; k+=BS){
                #pragma omp task depend(in: m1->mat[i:BS*BS], m2->mat[k:BS*BS]) depend(inout: m3->mat[i:BS*BS])
                for (ii = i; ii < i+BS; ii++) {
                    for (jj = j; jj < j+BS; jj++) {
                        for (kk = k; kk < k+BS; kk++) { 
                            m3->mat[ii * m3->ncols + jj] += m1->mat[ii*m1->ncols+kk] * m2->mat[kk*m2->ncols+jj];
                        }   
                    }
                }
            }
        }
    }

The problem is that the compiler reports some errors but I am sure that it is possible to set dependencies with arrays...

mat_mul_blocks.c:67:42: error: expected ‘]’ before ‘:’ token
   67 |     #pragma omp task depend(in: m1->mat[i:BS*BS], m2->mat[k:BS*BS]) depend(inout: m3->mat[i:BS*BS])
      |                                          ^
      |                                          ]
mat_mul_blocks.c:67:60: error: expected ‘]’ before ‘:’ token
   67 |     #pragma omp task depend(in: m1->mat[i:BS*BS], m2->mat[k:BS*BS]) depend(inout: m3->mat[i:BS*BS])
      |                                                            ^
      |                                                            ]
mat_mul_blocks.c:67:92: error: expected ‘]’ before ‘:’ token
   67 | in: m1->mat[i:BS*BS], m2->mat[k:BS*BS]) depend(inout: m3->mat[i:BS*BS])

Solution

Based on Section 2.19.11 and Section 2.1 of the OpenMP 5.1 specification:

The syntax of the depend clause is as follows:
depend([depend-modifier,] dependence-type: locator-list)
[...]
A locator-list consists of a comma-separated collection of one or more locator list items
[...]
The list items that appear in the depend clause may include array sections or the omp_all_memory reserved locator.

Thus, put it shortly: this is totally conforming for compiler not to implement array section parsing/support. This is actually the case of GCC, while Clang parses them correctly.

Several compilers and runtimes do not care-about/support array sections in depend clause. AFAIK, all mainstream OpenMP implementations (including GOMP of GCC and IOMP of Clang/ICC) just ignore them at runtime so far... The rational is that the dependency analysis would be clearly too much expensive to perform at runtime (some research project tried to implement this, but the performance results were not great). Because the OpenMP runtime used is tightly bound to compilers and because of the previous point, some compilers may not support array sections at all in depend clause (which means it will results in parsing errors in your case).

That being said, based on Section 2.1.5, the array-section syntax you use looks conforming to the OpenMP standard but be aware that locators/array-sections must not overlap. In your case, they seems to overlapp breaking the OpenMP standard and resulting in an undefined behaviour for OpenMP runtimes supporting array sections.

I advise you not to use array sections in depend clause. Instead, you can use pointers with dependency locators predefined outside the directive to avoid compiler parsing issues:

const double* dep1 = &m3->mat[i * m3->ncols + j];
const double* dep2 = &m1->mat[i * m1->ncols + k];
const double* dep3 = &m2->mat[k * m1->ncols + j];
#pragma omp task depend(in: *dep1, *dep2) depend(inout: *dep3)

This code should work on most compilers including GCC, Clang and ICC (MSVC only support OpenMP 2.0 so far). Note that since C++17, you can use the attribute [[maybe_unused]] to avoid compilers generating useless warnings for the unused variables when OpenMP is not enabled/supported by the target compiler (or wrongly detected as unused).