loop tilling/blocking in SCA forward transformation

[clementval]

Support for loop-tiling/blocking

[clementval]

@mlange05 Do you have an example of how you would like this to be?

[mlange05]

Ok, this is just a preliminary sketch, but basically what I would like for the SCA case is to add an option to insert a single level of blocking around the root call. Something like:

!$claw parallelize forward blocked="bsize"
DO p = 1, nproma     
  CALL compute_column(nz, q(p,:), t(p,:), z(p,:))                                                                                             
END DO 

then transforms into something like

p_blocks = <number of blocks as a function of "bsize">                                                                                                                                                                                                                                                 
DO p_i = 1, p_blocks                                                                                                                                                                                                                                                          
   p0 = <first index of block in global array>                                                                                                                                                                                                                                
   p1 = <final index of block in global array>                                                                                                                                                                                                                                
   CALL compute_column ( nz , q (p0:p1 , : ) , t (p0:p1, : ) , z (p0:p1, : ), nproma=p1-p0 )   
END DO

The details of how to define the bsize variable in the pragma or the derivation of block sizes/indices are still a bit fuzzy (sorry), but I'll provide a more concrete example soon...

One key detail to note then is that the OpenMP-parallel loop would live on the outer loop in this calling routine (to avoid false sharing), and would need to be removed from all kernels under this root call for the C backend.

[clementval]

@mlange05 Thanks for the input. I will try to draft something in the document and we can iterate on it.

[clementval]

@mlange05 Is it fine if this notion is tied with the Single Column Abstraction or would you see a use case where you would used this loop tilling/blocking as low-level transformation like a loop-fusion?