Fast generation of number combinations for variable nested for loops - c++

Question

I have the following code, that generates a combination of numbers/indices for variable nested for loops
#include <iostream>
#include <array>
template<size_t ... Rest>
inline void index_generator() {
constexpr int size = sizeof...(Rest);
std::array<int,size> maxes = {Rest...};
std::array<int,size> a;
int i,j;
std::fill(a.begin(),a.end(),0);
while(1)
{
for(i = 0; i<size; i++) {
std::cout << a[i] << " ";
}
std::cout << "\n";
for(j = size-1 ; j>=0 ; j--)
{
if(++a[j]<maxes[j])
break;
else
a[j]=0;
}
if(j<0)
break;
}
}
int main()
{
index_generator<2,3,3>();
return 0;
}
which outputs the following
0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
0 1 2
0 2 0
0 2 1
0 2 2
1 0 0
1 0 1
1 0 2
1 1 0
1 1 1
1 1 2
1 2 0
1 2 1
1 2 2
this is indeed equivalent to having
for (int i=0; i<2; ++i)
for (int j=0; j<3; ++j)
for (int k=0; i<3; ++k)
I can generate the equivalent of any number of nested for loops using the above method, however I have noticed that as the number of loops increase this code performs slower and slower, compared to its equivalent counterpart (i.e. nested for loops). I have checked both with gcc 5.3 and clang 3.8. Maybe this is due the processor having a hard time predicting the branch in while(true) or maybe its something else.
What I do in the innermost loops is typically access the data from two arrays and do multiplications on them something like c_ptr[idx] +=a_ptr[idx]*b_ptr[idx]. Since the indices generated using both nested for loops and using the above technique is the same, the memory access pattern remains the same. So I am quite sure this is not a cache miss/hit problem as far as data access is concerned.
So my question is:
Is there a way to generate these combination/indices as fast as the nested for loop style code or potentially even faster?
Since we know the number of for loops to set up and the indices of the for loop are known at compile time, can better optimisation opportunities not be exploited? SIMD for instance?

Answer 1

You can generate it with a single loop of the multiplication of all the dimensions and use modulo for the final indices.
#include <iostream>
#include <array>
template<size_t ... Rest>
inline void index_generator( ) {
constexpr int size = sizeof...( Rest );
std::array<int, size> maxes = { Rest... };
int total = 1;
for (int i = 0; i<size; ++i) {
total *= maxes[i];
}
for (int i = 0; i < total; ++i) {
int remaining = total;
for (int n = 0; n < size; ++n) {
remaining /= maxes[n];
std::cout << ( i / remaining ) % maxes[n] << " ";
}
std::cout << std::endl;
}
}
Or just generate recursive templates to actually produce nested loops and let the compiler optimize it for you. It depends on the actual usage of the indices. Right now your function is not too useful.
EDIT:
Benchmarked the three solution, first is the one in the question, the second is mine without the arrays, and thirs is recursive templates. The last one has a fault that its a bit harder to access the actual parameters to use, but not impossible. Also had to add a sum calculation to not suffer from being optimized out, and had to remove the console output to reduce the effect of that in the benchmark. The results are from my i7 machine release mode (VS 2015 community) and with the given setup below. The LOG and PROFILE_SCOPE are my macros.
#include <array>
// Original from the question
template<size_t ... Rest>
inline void index_generator1( ) {
constexpr int size = sizeof...( Rest );
std::array<int, size> maxes = { Rest... };
std::array<int, size> a;
int i, j;
std::fill( a.begin( ), a.end( ), 0 );
int x = 0;
while (1) {
for (i = 0; i < size; i++) {
x += a[i];
}
for (j = size - 1; j >= 0; j--) {
if (++a[j] < maxes[j])
break;
else
a[j] = 0;
}
if (j < 0)
break;
}
LOG( x )
}
// Initial try
template<size_t ... Rest>
inline void index_generator2( ) {
constexpr int size = sizeof...( Rest );
int x = 0;
std::array<int, size> maxes = { Rest... };
int total = 1;
for (int i = 0; i < size; ++i) {
total *= maxes[i];
}
for (int i = 0; i < total; ++i) {
int remaining = total;
for (int n = 0; n < size; ++n) {
remaining /= maxes[n];
x += ( i / remaining ) % maxes[n];
}
}
LOG(x)
}
// Recursive templates
template <int... Args>
struct Impl;
template <int First, int... Args>
struct Impl<First, Args...>
{
static int Do( int sum )
{
int x = 0;
for (int i = 0; i < First; ++i) {
x += Impl<Args...>::Do( sum + i );
}
return x;
}
};
template <>
struct Impl<>
{
static int Do( int sum )
{
return sum;
}
};
template <int... Args>
void index_generator3( )
{
LOG( Impl<Args...>::Do( 0 ) );
}
Executed code
{
PROFILE_SCOPE( Index1 )
index_generator1<200, 3, 400, 20>( );
}
{
PROFILE_SCOPE( Index2 )
index_generator2<200, 3, 400, 20>( );
}
{
PROFILE_SCOPE( Index3 )
index_generator3<200, 3, 400, 20>( );
}
Result in console:
[19:35:50]: 1485600000
[19:35:50]: 1485600000
[19:35:50]: 1485600000
[19:35:56]: PerCall(ms)
[19:35:56]: Index1 10.4016
[19:35:56]: Index2 75.3770
[19:35:56]: Index3 4.2299