Вариантная версия FastDelegate и дополнительная копия

Question

Я портирую FastDelegate на C ++ 0x с использованием шаблонов с переменными числами.

    #include "FastDelegate.h"

    template<class R=fastdelegate::detail::DefaultVoid, class ...P>
    class fast_delegate_base {
    private:
        typedef typename fastdelegate::detail::DefaultVoidToVoid<R>::type desired_ret_t;
        typedef desired_ret_t (*static_func_ptr)(P...);
        typedef R (*unvoid_static_func_ptr)(P...);
        typedef R (fastdelegate::detail::GenericClass::*generic_mem_fn)(P...);
        typedef fastdelegate::detail::ClosurePtr<generic_mem_fn, static_func_ptr, unvoid_static_func_ptr> closure_t;
        closure_t closure_;
    public:
        // Typedefs to aid generic programming
        typedef fast_delegate_base type;

        // Construction and comparison functions
        fast_delegate_base() { clear(); }

        fast_delegate_base(const fast_delegate_base &x)
        {
            closure_.CopyFrom(this, x.closure_);
        }

        void operator = (const fast_delegate_base &x)
        {
            closure_.CopyFrom(this, x.closure_);
        }
        bool operator ==(const fast_delegate_base &x) const
        {
            return closure_.IsEqual(x.closure_);
        }
        bool operator !=(const fast_delegate_base &x) const
        {
            return !closure_.IsEqual(x.closure_);
        }
        bool operator <(const fast_delegate_base &x) const
        {
            return closure_.IsLess(x.closure_);
        }
        bool operator >(const fast_delegate_base &x) const
        {
            return x.closure_.IsLess(closure_);
        }

        // Binding to non-const member functions
        template<class X, class Y>
        fast_delegate_base(Y *pthis, desired_ret_t (X::* function_to_bind)(P...) )
        {
            closure_.bindmemfunc(fastdelegate::detail::implicit_cast<X*>(pthis), function_to_bind);
        }

        template<class X, class Y>
        inline void bind(Y *pthis, desired_ret_t (X::* function_to_bind)(P...))
        {
            closure_.bindmemfunc(fastdelegate::detail::implicit_cast<X*>(pthis), function_to_bind);
        }

        // Binding to const member functions.
        template<class X, class Y>
        fast_delegate_base(const Y *pthis, desired_ret_t (X::* function_to_bind)(P...) const)
        {
            closure_.bindconstmemfunc(fastdelegate::detail::implicit_cast<const X*>(pthis), function_to_bind);
        }

        template<class X, class Y>
        inline void bind(const Y *pthis, desired_ret_t (X::* function_to_bind)(P...) const)
        {
            closure_.bindconstmemfunc(fastdelegate::detail::implicit_cast<const X *>(pthis), function_to_bind);
        }

        // Static functions. We convert them into a member function call.
        // This constructor also provides implicit conversion
        fast_delegate_base(desired_ret_t (*function_to_bind)(P...) )
        {
            bind(function_to_bind);
        }

        // for efficiency, prevent creation of a temporary
        void operator = (desired_ret_t (*function_to_bind)(P...) )
        {
            bind(function_to_bind);
        }

        inline void bind(desired_ret_t (*function_to_bind)(P...))
        {
            closure_.bindstaticfunc(this, &fast_delegate_base::invoke_static_func, function_to_bind);
        }

        // Invoke the delegate
        template<typename ...A>
        R operator()(A&&... args) const
        {
            return (closure_.GetClosureThis()->*(closure_.GetClosureMemPtr()))(std::forward<A>(args)...);
        }
        // Implicit conversion to "bool" using the safe_bool idiom

    private:
        typedef struct safe_bool_struct
        {
            int a_data_pointer_to_this_is_0_on_buggy_compilers;
            static_func_ptr m_nonzero;
        } useless_typedef;
        typedef static_func_ptr safe_bool_struct::*unspecified_bool_type;
    public:
        operator unspecified_bool_type() const { return empty()? 0: &safe_bool_struct::m_nonzero; }
        // necessary to allow ==0 to work despite the safe_bool idiom
        inline bool operator==(static_func_ptr funcptr) { return closure_.IsEqualToStaticFuncPtr(funcptr); }
        inline bool operator!=(static_func_ptr funcptr) { return !closure_.IsEqualToStaticFuncPtr(funcptr); }
        // Is it bound to anything?
        inline bool operator ! () const { return !closure_; }
        inline bool empty() const { return !closure_; }
        void clear() { closure_.clear();}
        // Conversion to and from the DelegateMemento storage class
        const fastdelegate::DelegateMemento & GetMemento() { return closure_; }
        void SetMemento(const fastdelegate::DelegateMemento &any) { closure_.CopyFrom(this, any); }

    private:
        // Invoker for static functions
        R invoke_static_func(P... args) const
        {
            return (*(closure_.GetStaticFunction()))(args...);
        }
    };

    // fast_delegate<> is similar to std::function, but it has comparison operators.
    template<typename _Signature>
    class fast_delegate;

    template<typename R, typename ...P>
    class fast_delegate<R(P...)> : public fast_delegate_base<R, P...>
    {
    public:
        typedef fast_delegate_base<R, P...> BaseType;

        fast_delegate() : BaseType() { }

        template<class X, class Y>
        fast_delegate(Y * pthis, R (X::* function_to_bind)(P...))
            : BaseType(pthis, function_to_bind)
        { }

        template<class X, class Y>
        fast_delegate(const Y *pthis, R (X::* function_to_bind)(P...) const)
            : BaseType(pthis, function_to_bind)
        { }

        fast_delegate(R (*function_to_bind)(P...))
            : BaseType(function_to_bind)
        { }

        void operator = (const BaseType &x)
        {
            *static_cast<BaseType*>(this) = x;
        }
    };

Но одно из ограничений моей реализации заключается в том, что при использовании функций, не являющихся членами, и в случае, если эта функция принимает параметр (ы) по значению, выполняется дополнительное копирование значения для каждого параметра. Я предполагаю, что это происходит между fast_delegate_base::operator()() и fast_delegate_base::invoke_static_func().

Я пытался заставить fast_delegate_base::invoke_static_func() принимать параметры Rvalue, но не смог.

Например:

class C1
{
public:
    C1() { printf("C1()\n"); }
    ~C1() { printf("~C1()\n"); }
    C1(const C1&)
    {
        printf("C1(const C1&)\n");
    }

    int test(int t) const
    {
        printf("C1::test(%d)\n", t);
        return 1;
    }
};

int test(C1 c)
{
    c.test(1234);
    return 1;
}

// ...

C1 c1;
fast_delegate<int(C1)> t1(test);
t1(c1);

Результат этого кода:

C1()
C1(const C1&)
C1(const C1&)
C1::test(1234)
~C1()
~C1()
~C1()

Есть ли у вас идеи, чтобы избежать этой копии дополнительного значения?

Answer 1

Мне кажется, что эта копия присуща дизайну класса, в частности, существует invoke_static_func.

Из того, что я вижу, это прокси для нормализации статических функций и функций-членовв только функции-члены, так что каждая их отправка может быть выполнена как вызов функции-члена.Единственное отличие состоит в том, что этот элемент является экземпляром fast_delegate_base, а не экземпляром какого-либо класса, членом которого является целевая функция.

Таким образом, при вызове статических функций существует дополнительный фрейм вызова и избавление отЭта дополнительная копия вам понадобится, чтобы дополнительный кадр вызова (invoke_static_func) принял свой параметр по ссылке (пока игнорируйте последствия этого, если тип аргумента не является значением).

К сожалению, invoke_static_func должен вызываться через указатель функции, у которого есть список аргументов, содержащий типы значений, поэтому operator() вынужден сделать копию для вызова указателя функции (то есть для вызова invoke_static_func).Заставить invoke_static_func принимать параметры по ссылке не помогает, потому что он все равно должен вызываться через указатель функции, который не имеет ссылочных типов аргументов.

И нет способа invoke_static_func избежать создания копии для вызоваtest (C1), это просто простой вызов по значению, поэтому вам понадобятся обе копии, чтобы этот проект работал.

---

Чтобы объяснить это с другой точки зрения, с точки зрения чистого C:

Оператор () должен вызвать функцию func (this_ptr, arg_1, arg_2, arg_3).Целевая функция будет ожидать, что эти параметры будут в определенных регистрах или в определенных местах стека в зависимости от их положения в списке аргументов и размера.

Но статическая функция не имеет первого магического параметра «this», его сигнатурыпросто func(arg_1, arg_2, arg_3).Таким образом, он ожидает, что все остальные аргументы будут в других регистрах и / или расположениях стека, чем соответствующая функция-член.Поэтому вам нужна эта копия, чтобы переместить аргументы в правильные регистры / ячейки стека, чтобы соответствовать соглашению о вызовах для статической функции.

Что в принципе означает, что вы не можете избежать этой второй копии для статической функции сэтот дизайн.

---

Однако ... вы можете улучшить это с помощью некоторого хитрого метапрограммирования шаблонов, чтобы применить std :: move к значениям аргументов типа в реализации invoke_static_func, уменьшая ваш вызовнакладные расходы на копию и перемещение, которое почти равно одной копии.

Я обновлю этот ответ, если и когда выясню, возможно ли 1035 * (и еслину и как).

---

Редактировать

Примерно так должно получиться:

template <bool IsClass, class U>
struct move_if_class
{
    template <typename T>
    T&& operator()(const T& t) { return std::move(const_cast<T&>(t)); }
};

template <class T>
struct move_if_class<false,T>
{
    T&& operator()(typename std::remove_reference<T>::type& t) { return std::forward<T>(t); }
    T&& operator()(typename std::remove_reference<T>::type&& t) { return std::forward<T>(t); }
};

R invoke_static_func(P... args) const
{
    return (*(closure_.GetStaticFunction()))(move_if_class<std::is_class<P>::value,P>()(args)...);
}   

И после добавления хода c'tor:

C1()
C1(const C1&)
C1(C1&&)
C1::test(1234)
~C1()
~C1()
~C1()