Question

I have a proprietary MCU that does a periodic task, and wish to fill its “downtime” with other things to do. Typically, this has been done with large switch statements, which is okay, but I’m wondering if there’s a more elegant way. This is a very common pattern in the code for this particular device, so having a generic method would be nice.

So I wrote the following code, and it works, but it doesn’t currently inline the functions.

    static InterlacedFunction searchFunctions[4] = {...};

    typedef int (* const InterlacedFunction)(int);

    template<const int numberOfWovenFunctions> int SendPacketWithWovenFunctions(
            int * packet,
            const int packetLength,
            InterlacedFunction (&functions)[numberOfWovenFunctions],
            int firstArgument = 0)
    {
            int returnFromLastWoven = (numberOfWovenFunctions != 0) ? (functions[0])(firstArgument) : 0;

            SendData(packet[0]);

            for(int i = 1; i < packetLength; i++)
            {
                    if(i < numberOfWovenFunctions)
                            returnFromLastWoven = (functions[i])(returnFromLastWoven);
                    SendData(packet[i]);
            }
            return returnFromLastWoven;
    }

Am I missing something, is it impossible for Clang to inline these functions or does Clang just not have the optimization yet?

Answer 1

In general compilers are not aggressive at inlining calls through function pointers, even when they are known at compile time.

In this case you are relying on the compiler being clever enough to unroll the loop into a block of numberOfWovenFunctions iterations, or generate a switch of the inlined functions for you, both of which are unlikely.

If you wanted to make the idiom more generic you could do so with a recursive templates (it would be a pain to write if you do not have c++11 variadic templates), though whether it actually constitutes a simplification is perhaps questionable.

i.e. you template on the list of woven function pointer values, and at each level call the woven function, store the result, call sendPacket and the recurse into the next template level with the stored result. Something like (untested):

template <InterlacedFunction ... args>
struct WovenFunc;

//Base case - send remaining packets
template <> 
struct WovenFunc<>{
    static int call(int value, int * packet, size_t count){
        for(size_t c = 0; c < count; ++c) SendData(packet[c]);
        return value;
    }
};

//Recursive case - send packets + weave functions
template <InterlacedFunction arg, InterlacedFunction ... args>
struct WovenFunc<arg, args...>{
    static int call(int initial, int * packets, size_t count){
        int r = arg(initial);
        SendData(packets[0]);
        if(count)
            return WovenFunc<args...>::call(r, packets + 1, count - 1);
    }
};

And then in the send:

typedef WovenFunc<Woven1, Woven2, Woven3> WovenSend
WovenSend::call(returnFromLastWoven, packets, packetLength);

Obviously you can make is more generic.