Efficient sub-array (2D) access - c++

Question

NB: I'm open to suggestion of a better title..
Imagine an nxn square, stored as an integer array.
What is the most efficient method of generating an n-length array of the integers in each of the n non-overlapping sqrt(n)xsqrt(n) sub-squares?
A special case (n=9) of this is Sudoku, if we wanted the numbers in the smaller squares.
The only method I can think of is something like:
int square[n][n], subsq[n], len;
int s = sqrt(n);
for(int j=0; j<n; j+=s){
for(int i=0; i<n; i+=s){
//square[i][j] is the top-left of each sub-square
len = 0;
for(int y=j; y<j+s; y++){
for(int x=i; x<i+s; x++){
subsq[len] = square[x][y];
len++;
}
}
}
}
But this seems loopy, if you'll forgive me the pun.
Does anyone have a more efficient suggestion?

Answer 1

Despite the four level loop, you are only accessing each array element at most one time, so the complexity of your approach is O(n^2), and not O(n^4) as the four loop levels suggest. And, since you actually want to look at all elements, this is close to optimal.
There is only one possible suboptimality: Incomplete use of cachelines. If s is not a multiple of a cache line, your subsquares will end in the middle of a cacheline, leading to parts of the data being fetched twice from memory. However, this is only an issue if your subsquares do not fit into cache anymore, so you need a very large problem size to trigger this. For a sudoku square, there is no faster way than the one you've given.
To work around this cacheline issue (once you determined that this is really worth it!), you can go through your matrix one line at a time, aggregating data for ciel(n/sqrt(n)) subsquares in an output array. This would exchange the loops in the following way:
for(int j=0; j<n; j+=s){
for(int y=j; y<j+s; y++){
for(int i=0; i<n; i+=s){
for(int x=i; x<i+s; x++){
However, this will only work out if the intermediate data you need to hold while traversing a single subsquare is small. If you need to copy the entire data into a temporary array like you do, you won't gain anything.
If you really want to optimize, try to get away from storing the data in the temporary subseq array. Try to interprete the data you find directly where you read it from the matrix. If you are indeed checking sudoku squares, it is possible to avoid this temporary array.
From the way you pose the question, I presume that your goal is to pass the data in each subsquare to an analysis function in turn. If that is the case, you can simply pass a pointer to the 2D subarray to the function like this:
void analyse(int width, int height, int (*subsquare)[n]) {
for(int y = 0; y < height; y++) {
for(int x = 0; x < width; x++) {
subsquare[y][x]; //do anything you like with this value
}
}
}
int main() {
int square[n][n], subsq[n], len;
int s = sqrt(n);
for(int j=0; j<n; j+=s){
for(int i=0; i<n; i+=s){
analyse(s, s, (int (*)[n])&square[i][j]);
}
}
}
Now you can just pass any 2D subarray shape to your analysis function by varying the first two parameters, and completely avoid a copy.