Calling a function, how hard can it be?

Talk content

  • Overview of various ways to call function pointers.
  • Delegate, an alternative to std::function.

What is a function call?

void fkn1() { 
    cout << 0 << endl;
}

void fkn1(int x) { 
    cout << x << endl;
}

void fkn2(int x) { 
    cout << 2*x << endl;
}


int main() {

    // Specify both function name, signature and make the call. 
    // or, deduce function address from signature and name, call address.
    // This is overload resolution in standard language.
    fkn1(1);
}

Some notation

  • Function signature: The type of the function includes a number of parameters and their types.
  • Function pointer: Object with the address of a function. Its type is given by the function signature.
  • Function definition: Supplies a body to a function name with a particular signature.
  • Function address: Can be taken from a function definition and later be used to call the function with arguments.
  • Function arguments: Values to pass into a function at call time.
  • Overload set: A set of functions sharing the same name, but with different signatures.

 

void fkn1() { 
    cout << 0 << endl;
}

void fkn1(int x) { 
    cout << x << endl;
}

void fkn2(int x) { 
    cout << 2*x << endl;
}

int main() {
    // Specify signature, part of the type system.
    using Fkn = void(*)(int);

    // make function pointer.
    Fkn fkn = nullptr;

    // Calculate address from name together with signature.
    // Overload resolution is performed. Assign to pointer.  
    fkn = &fkn1;

    // Do the call. Address and argument values 
    // needed at the call site. No resolution done.
    fkn(2);
}

Using a function pointer

Function names

  • Set at compile time. Name + signature identify a unique function and give an address.
  • Usage (direct call or assigning to pointer) is compile-time fixed. Can be used as a template argument.
  • Once a function address is assigned to function pointer, it can manipulated as any value type at runtime.
  • Calling a function pointer is a form of information hiding. We do not need to know the actual function at the call site. Only the variable and signature.

Fkn pointer construction

Req: Fkn signature

Assign address

Req: name + signature

or address

Fkn call:

Req: signature + arguments

Fkn pointer destruction

Time

struct C1 {
    static void fkn1(C1* obj) {
        cout << 1 << endl;
    }
    static void fkn2(C1* obj) {
        cout << 2 << endl;
    }
};

int main() {
    // static member function works as free functions. Just
    // declared within a class and have the class name as part of their name.
    C1::fkn1(nullptr);

    // Specify signature when setting up a function pointer type. 
    using Fkn = void(*)(C1*);

    // Use name (including class name) with signature to extract address.
    Fkn fkn = &C1::fkn1;

    // and finally call.
    C1 c1;
    fkn(&c1);
}

Function pointer to class static functions

struct C1 {
    static void fkn1(C1 const* c1) {
        cout << 1 << endl;
    }
    void member() const {
        cout << x << endl;
    }
};

int main() {
    // Static function signature as before.
    using Fkn = void (*)(C1 const*);  
    Fkn freeFkn = &C1::fkn1;

    // Member function
    // Good analogy: the object pointer is a hidden first argument.
    // Note: object pointer type is part of the signature, 
    // just as first argument in free function pointer.
    using MemberFkn = void (C1::*)() const;
    MemberFkn mFkn = &C1::member;


    C1 c1;
    // Call on fkn pointers. Require fkn address and signature.
    freeFkn(&c1);
    // Note the quirky syntax. Required. 
    (c1.*mFkn)();
}

Member function pointers

struct B1 {
    virtual void member() {
        cout << 1 << endl;
    }
};

struct D1 : public B1 {
    void member() {
        cout << 2 << endl;
    }
};

int main() {
    D1 d1;
    // Specify signature to base class member function.
    using MemPtr = void (B1::*)();

    // Get base member function pointer.
    MemPtr ptr = &B1::member;

    // Get a base pointer.
    B1* b_ptr = &d1;

    // Member function special power: Do dynamic dispatch. Calls D1::member.
    (b_ptr->*ptr)();
}

Member pointer secret power: dynamic dispatch

struct F1 {
    F1(int m) : member(m) {}

    void operator()(int i) {
        cout << i + member << endl;
    }
    void operator()() {
        cout << m << endl;
    }
    int member;
};


int main() {
    // Functors are ordinary classes
    F1 f1{4};

    // That can be called as functions.
    f1(3);
    f1();

    // Can create references and pointers:    
    F1* ptr = &f1;
    F1& ref = f1;

    // And call through them.
    (*ptr)();
    ref();
}
// However there is no special function pointer syntax for functors.

Functors: objects with operator()

struct F1 {
    F1(int m) : member(m) {}

    void operator()(int i) {
        cout << i + member << endl;
    }
    int member;
};


int main() {
    // Functors are ordinary classes
    int m = 4; 
    F1 f1{4};

    auto lambda = [m](int i) -> void { cout << i + m << endl; } 

    // Lambda is defined to construct a templated functor.
    // F1 is similar to the functor class made from lambda.

    f1(3);
    lambda(3);
}

Lambdas

struct F1 {
    F1(int m) : member(m) {}

    void operator()(int i) {
        cout << i + member << endl;
    }
    int member;
};


int main() {

    F1 f1(4);
    // Store a copy of the functor.
    std::function<void(int)> fknStore = f1;

    // Call the function store. 
    // Note: Do not need to know the type of the functor, only signature.
    fknStore(3);

    // std::function implement type-erasure to allow storing full type 
    // but only exposing signature at call time. 
}

std::function and type erasure

std::function

  • Will automatically handle free functions, Functors, and lambdas. (Not member functions, use lambda)
  • Great for general purpose storage of callables
  • A convenient way to get type erasure between assignment and call point.
  • Can heap allocate for object storage. Can throw exceptions
  • Can use virtual functions to implement type erasure (might be slow).

Common scenario in embedded

  • You have some driver with interrupt functionality. You want callbacks. But can not afford exceptions or heap allocation.
  • The callback usually require some stored context pointer.
  • We want type safety and would be good to call  a member function on a particular object.
// Common C function solution.

// Driver code. Offers a callback without knowing callers type.

typedef void (*DrvCB)(void* ctx, int cbArg);

void drv_registerCB(DrvCB cb, void* context);



// User of the driver:
struct UserData { /* ... */ };

void userCodeInit(struct UserData* ud)
{
    // Init ctx ...
    drv_registerCB(drvCB, (void*)ud);
    // ...
} 

static void drvCB(void* ctx, int cbArg)
{
    // Required cast from void to regain context type.
    struct UserData* ud = (struct UserData*)ctx;
    // Do callback processing...
}

// Direct old style C++ conversion.

class Driver {
public:
    using DrvCB = void (*)(void* ctx, int cbArg);
    void registerCB(DrvCB cb_, void* ctx_) {
        cb = cb_;
        cbCtx = ctx_;
    }

private:
    DrvCB cb;
    void* cbCtx;
};

class UserClass
{
public:
    UserClass(Driver* drv_p)
    {
        drv_p->registerCB(drvCB_, (void*)this);
        // ...
    }
private:
    static void drvCB_(void* ctx, int arg) { 
         static_cast<UserClass*>(ctx)->drvCB(arg);
    }
    void drvCB(int arg) { 
         // Actual CB processing
    }
}

A std::function replacement

  • Create a std::function alternative. Let us call it 'delegate'.
  • Borrow the idea with a static->member function adapter. Encapsulate this into the delegate.
  • A function address is a compile-time constant. It can be used as a template argument.
  • To avoid heap allocation, require the user to have storage for stateful Functors.
  • Have support for member functions.
class Delegate
{
public:
    using AdapterFkn = void (*)(void*ctx,int arg);

    // New set method. Handles member function to object.
    template <class T, void (T::*memFkn)(int arg)>
    void set(T& object)
    {
        cb = &doMemberCB<T, memFkn>;
        ctx = static_cast<void*>(&object);
    }

    void operator()(int t) {
        cb(t);
    }
private:
    // Handler function for memeber callbacks. Same internal signature
    // Other ways to unpack the template parameters.
    template <class T, void (T::*memFkn)(int)>
    inline static void doMemberCB(void* o, int arg)
    {
        T* obj = static_cast<T*>(o);
        ((*obj).*(memFkn))(arg);
    }

    AdapterFkn cb = nullptr;
    void* ctx = nullptr;
};

Delegate handling of a member function

class Driver {
public:
    Delegate& regCB();

private:
    void isrProc() {
        // ...
        del(value);
    }
    // Note: no type information about the registered caller. It
    // is handled in the 'set' function template. It does not leak
    // to the delegate class. (Later, will be: delegate<void(int)>)
    Delegate del;
};

class UserClass
{
public:
    UserClass(Driver& drv)
    {
        drv.regCB().set<UserClass, &UserClass::drvCB>(*this);
        // ...
    }
private:
    // Trampoline fkn now in delegate. Only need memeber fkn.
    void drvCB(int arg) { 
         // Actual CB processing
    }
}

Use of delegate

Delegate

  • Straight-forward to generalize with argument parameter packs and return value.
  • Proper use of inlining will remove any overhead of the adapter function. Both operator() and the adapter-function inlined to call site.
  • Easy to add more set/adapter functions for normal function pointers / functors.
  • Stateless lambdas are guaranteed to be convertible to function pointers and can be handled.
  • No possible way for the delegate to throw an exception. (User code can though.)
class Delegate
{
public:
    using AdapterFkn = void (*)(void*ctx,int arg);


    template<typename T>
    void setFunctor(T& f) {
        cb = &adaptFunctor<T>;
        ctx = static_cast<void*>(&t);
    }
    void operator()(int t) {
        cb(ctx, t);
    }
private:
    template<class T>
    static void adaptFunctor(void* ctx_, int arg) {
        (*static_cast<T*>(ctx_))(arg);
    }

    AdapterFkn cb = nullptr;
    void* ctx = nullptr;
};

Delegate handling a functor

Delegate as a library class

  • Aim for the expressive power of std::function, feel like a free function pointer in use. (With less quirky syntax)
  • Delegate should only contain type information about the calling signature.
  • Model function pointers in terms of const correctness, value semantics, comparing to nullptr etc.
  • Predictable efficient behavior. No own exceptions, no heap allocation, but still with type safety. Only 2 pointers used for storage.
  • Tradeoff: User need to keep track of referred object lifetimes. (Like use of any pointer).
#include "delegate/delegate.hpp"

struct Packet { /* ... */ };

class Driver {
public:
    Driver() = default;
    using RxDelegate = delegate<void(const Packet&)>;

    RxDelegate& registerRx() { return packetRx; } ;  // Either this,
    void setRx(RxDelegate rx) { packetRx = rx; };    // Or this.

private:
    RxDelegate packetRx;
};



class ProtocolRx {
public:
    ProtocolRx(Driver& drv) {
        drv.registerRx().set<
            ProtocolRx, &ProtocolRx::rxPacket>(*this); // Either this,

        drv.setRx(Driver::RxDelegate::make<
            ProtocolRx, &ProtocolRx::rxPacket>(*this); // Or this

        drv.registerRx().set<&ProtocolRx::rxPacket>(*this); // C++17
    }
private:
    void rxPacket(Packet const& packet)
    { /* ... */ }
};

#include "delegate/delegate.hpp"

struct TStruct {
    int member(int i)         { return i + 1; }
    int cmember(int i) const  { return i + 2; }
};

TEST(delegate, Member_intermediate_storage) {

    TStruct ts;
    const TStruct cts;

    delegate<int(int)> del;
    del.set<TStruct, &TStruct::member>(ts);
    int res = del(1);
    EXPECT_EQ(res, 2);

    // Must not compile. Need const member for const object.
    // del.set<TStruct, &TStruct::member>(cts);

    del.set<TStruct, &TStruct::cmember>(ts);
    res = del(1);
    EXPECT_EQ(res, 3);

    del.set<TStruct, &TStruct::cmember>(cts);
    res = del(1);
    EXPECT_EQ(res, 3);

    // Must not compile. Do not allow storing pointer to temporary.
    // del.set<TStruct, &TStruct::member>(TStruct{});
    // del.set<TStruct, &TStruct::cmember>(TStruct{});
}

Const correctness

Const member functions

  • Member function const determine if a function can be called on const objects or not. This can be checked during {set, make} calls. Once done, it is not needed anymore for doing a call.
  • This requires us to set the member function and the object at the same time for const correctness.
  • Use another class MemFkn to store a member function without an object. Require additional type information for const. (skipping volatile...)
  • Same with functors w.r.t operator(), but no issue since there is only one object here.
#include "delegate/delegate.hpp"

TEST(delegate, construction1) {
    delegate<void()> del;
    delegate<void()> del2;

    EXPECT_TRUE(del.null());
    EXPECT_FALSE(del);
    EXPECT_TRUE(del == nullptr); // And variants.

    
    EXPECT_TRUE(del == del2);
    EXPECT_TRUE(del.equal(del2));
    EXPECT_FALSE(del.less(del2));

    // Ok to call null delegate. Call function that do nothing and 
    // return default constructed return value.
    del();  
}

Default construct and safe nullptr call

#include "delegate/delegate.hpp"

// Base, Derived defined as expected, virtual memb, cmemb.

TEST(delegate, test_virtual_dispatch) 
{
    Derived d;
    delegate<int(int)> del;

    Base& b = d;
    del.set<Base, &Base::memb>(b);
    // Derived::memb called.
    del(1);

    const Base& cb = d;
    del.set<Base, &Base::cmemb>(cb);
    // Derived::cmemb called.
    del(1);
}

Summary

  • delegate should work well in most settings where std::function is used today. It emulates member function pointers which std::function does not.
  • Takes function names as template arguments, providing better opportunities for optimization/inlining for the compiler. (todo: performance measurement...)

Available at:

https://github.com/rosbacke/delegate

Embedded_delegates

By mikael rosbacke

Made with Slides.com

Embedded_delegates

  • 398

More from mikael rosbacke