1

For example, there is hard logic inside function void Func(long param1, long param2, long param3, long param4, long param5).

It has a lot of statements inside depends on parameters, different checks, calculations depends on combinations and etc.

And that function is called many million times and takes serious amount of execution time. And I'd like to reduce that time.

All parameters are taken from config.ini file, so, they are unknown at compile time.

But I know, that param1 may be in diapason [1..3], param2 in diapason [0..1] and etc.

So, finally, there is maybe 200 combinations of those parameters.

And I'd like my compiler compile separated 200 combination, and at the beginning of run-time, when config.ini loaded, just choose one of them, and avoid run-time calculation of parameter's dependencies.

Is that possible to achieve in C++98? Or in C++11/14?

Arkady
  • 2,084
  • 3
  • 27
  • 48

2 Answers2

2

It is certainly possible to do this using templates, since templates can have integers instead of type parameters. For instance, the following function

template <int iParam1, int iParam2>
int sum()
{
    return iParam1 + iParam2;
}

is a function in which iParam1 and iParam2 are fixed values for a specific template instantiation. For example, function sum<1, 2> is a function that always returns 3.

In you case, define Func with this prototype:

template <long Param1, long Param2, long Param3, long Param4, long Param5>
void Func()

Then, create a std::map that maps a combination of parameters to a function in which these parameters are fixed. Something like this:

using ParamCombination = std::tuple<long, long, long, long, long>;

using ParamsToFunction = std::pair < ParamCombination, std::function<void()> >;

std::map< ParamCombination, std::function<void()> > map =
{
    ParamsToFunction(std::make_tuple<long, long, long, long, long>(1, 2, 2, 2, 2), Func<1, 2, 2, 2, 2>),
    ...
    // This map will contain pairs of all possible parameter combinations
    // and their corresponding functions. This is a long list but it can be
    // easily generated using a script.    
};

These function will have all the benefits of compile time optimizations. Finally, during runtime, all you need to do is create a tuple that represents a parameter combination and call the function that this tuple maps to:

auto comb = ParamCombination(1, 2, 2, 2, 2);
map[comb](); // function call
Marko Popovic
  • 3,999
  • 3
  • 22
  • 37
  • Thank you, that looks like what I wanted to achieve. And it is not hard to extrapolate it to C++98. – Arkady Mar 17 '16 at 11:23
0

I don't know if you have considered this but you could load the config at the beginning, calculate your 200 possible solutions and put them into a lookup table. This depends on the storage you can spare. Since your number of combination seems to be small, this should be no problem. You simple merge the parameter to an integer. E.g. ( x =[0...3]; y = [0...1]) => use first 2 bit for x 3rd bit for y and so on. Calculate all possibilities using loops. And store the result inside of an array. If you don't own parameter with the power of two. You can simply multiply the possibilities. E.g x =[0...3] y =[0...5] z =[0...2] => idx = x + y*(possibilites of x = 4) + z * (pos. x = 4) * (pos. y = 6)

Marko Popovic
  • 3,999
  • 3
  • 22
  • 37
Schafwolle
  • 501
  • 3
  • 15
  • But it is really hard to make 200 a little bit different bodies of function (with different parameters inside), to create such map. I'd like to use something like templates, but not for types, but for parameters – Arkady Mar 17 '16 at 11:01
  • It is a good idea to use a lookup table. especially because there is a small number of combinations. However, this approach can only be used if the output of function depends SOLELY on the input parameters. It is possible that the function uses some object or system state too. – Marko Popovic Mar 17 '16 at 12:31