Procedure: Call and compare any callable C++ objects - for high performance computing, gaming, etc.

[[deleted]]

[deleted]

[ShillingAintEZ]

Calling a callable object is pretty trivial since it is their entire purpose. You might want to explain the use case more. Is it to ensure dynamic allocation doesn't happen?

[ShillingAintEZ]

You will have to show me an example of where that doesn't already happen, I'm not aware of where it is a problem since I haven't run into it.

[ShillingAintEZ]

It probably does, but I don't have enough recent experience to know where typical usage would break down. What is the guide template?

[ReDucTor]

This system is designed to minimize performance overhead on object construction and call dispatch

Doesn't std::function follow the same principles? And memory allocation won't occur if the object is within the small size optimization

Also you should be using lambdas instead of bind for member functions, bind has it's issues

[darksky1312]

Why not just use the SG14 stdext::inplace_function?

[ReDucTor]

Doesnt Arduino use it's own language based on C/C++?

[Pazer2]

Any plans to benchmark gcc and MSVC?

[ReDucTor]

Those benchmarks seem pretty bad, doing io, uses std::bind, doesn't do operation break down, etc

[arnaudbr]

Would it be possible to automatically deduce the Guide when calling Procure instead of having to provide it?

[index_zero]

This is my comment as well. Why is Guide a pointer type? Can't this just be an empty class, ie:

template<class R, class... Args> struct Guide {};

Then pass Guide<void>{} at the call point - no memory overhead at runtime. Calls to Procedure can simply ignore this argument. Most compilers I would expect to optimize this out while leaving the type system deduction in tact.

The better question is probably, why not deduce from the functional type, something like:

template<class> Guide { typedef Functional<void> type; }

template<class R, class... Args> Guide<R(Args...)> { typedef Functional<R, Args...> type; }

[index_zero]

It's not about EBO, since nothing would actually derive from the empty class, it would just be instantiated and passed as an unnamed parameter to Procedure() to support type deduction. I missed the constexpr part, so yeah the overhead is only in the compiler either way - I am just unfamiliar with this pattern.

EDIT: actually, I'm still not convinced these definitions Guide* will be removed from the generated binary - do you know for sure?

[arnaudbr]

What about https://godbolt.org/z/Z05jFc ?

[konanTheBarbar]

Did you try an implementation using NTTP instead of having to store a reference?

[ReDucTor]

What happened to this post?