If or function pointers in fortran

Question

as it is so common with Fortran, I\'m writing a massively parallel scientific code. In the beginning of my code I read my configuration file which tells me which type of solver

Answer 1

After a brief search I couldn't find the answer to the question, so I ran a little benchmark myself (see this link for the Makefile & dependencies). The benchmark consists of:

• Draw random number to select method a, b, or c, which all perform a simple addition to their single integer argument
• Call the chosen method 100 million times, using either a procedure pointer or if-statements
• Repeat the above 5 times

The result with gfortran 4.8.5 on an CPU E5-2630 v3 @ 2.40GHz is:

Time per call (proc. pointer):       1.89 ns
Time per call (if statement):        1.89 ns

In other words, there is not much of a performance difference!

Answer 2

If you solver routines take a non-trivial runtime, then the trivial runtime of the IF statements is likely to be immaterial. If the sovler routines have a comparable runtine to the IF statement, then the total runtime is very short, so why do your care? This seems an optimization unlikely to pay off.

The first rule of runtime optimization is to profile your code is see what portions are consuming the runtime. Otherwise you are likely to optimize portions that are unimportant, which will accomplish nothing.

For what its worth, someone else recently had a very similar concern: Fortran Subroutine Pointers for Mismatching Array Dimensions

Answer 3

Knowing nothing about Fortran, this is my answer: The main problem with branching is that a CPU potentially cannot speculatively execute code across them. To mitigate this problem, branch prediction was introduced (which is very sophisticated in modern CPUs).

Indirect calls through a function pointer can be a problem for the prediction unit of the CPU. If it can't predict where the call will actually go, this will stall the pipeline.

I am quite sure that the CPU will correctly predict that your branch will always be taken or not taken because it is a trivial case of prediction.

Maybe the CPU can speculate across the indirect call, maybe it can't. This is why you need to test which is better.

If it cannot, you will certainly notice in your benchmark.

In addition, maybe you can hoist the if test out of your inner loop so it won't be called often. This will make the actual performance of the branch irrelevant.

Answer 4

If you only plan to use the function pointers once, at initialisation, and you are running codes on a BlueGene, isn't your concern for the efficiency mis-directed ? Generally, any initialisation which works is OK, if it takes 1sec instead of 1msec it's probably going to have 0 impact on total execution time.

Code initialisation routines for clarity, ease of modification, that sort of thing.

EDIT

My guess is that using function pointers rather than your current code will have no impact on execution speed. But it's just a (educated perhaps) guess and I'll be very interested in any data you gather on this question.