Eliminating copying of function parameter

Question

I am writing a custom memory allocator. If possible, I want to make object creation function like this to abstract creation procedure completely.

template<typename T>
class CustomCreator
{
    virtual T& createObject(T value) __attribute__((always_inline))
    { 
        T* ptr = (T*)customAlloc();
        new (ptr) T(value);
        return *ptr;
    }
}

But this causes copying. Is there a way to force to eliminate copying in this case?

Here's my current testing code.

#include <iostream>

struct AA
{
    inline static void test(AA aa) __attribute__((always_inline))
    {
        AA* ptr =   new AA(aa);
        delete ptr;
    }

    AA(AA const& aa)
    {
        printf("COPY!\n");
    }
    AA(int v)
    {
        printf("CTOR!\n");
    }
};

int main(int argc, const char * argv[])
{
    AA::test(AA(77));
    return 0;
}

I tried to pass the value as T&, T const&, T&&, T const&&, but it still copies. I expected optimizer will eliminate function frame, so the function parameter can be deduced into an R-value, but I still see COPY! message.

I also tried C++11 forwarding template, but I couldn't use it because it cannot be a virtual function.

My compiler is Clang included in Xcode. (clang-425.0.28) And optimization level is set to -Os -flto.

Update (for later reference)

I wrote extra tests, and checked generated LLVM IR with clang -Os -flto -S -emit-llvm -std=c++11 -stdlib=libc++ main.cpp; options. What I could observe are: (1) function frames always can be get eliminated. (2) if large object (4096 byte) passed by value, it didn't get eliminated. (3) Passing r-value reference using std::move works well. (4) if I don't make move-constructor, compiler mostly fall back to copy-constructor.

Your code is not a situation where the copy can be elided. Copies are basically only elided for return values from functions. — Mooing Duck, May 08 '13 at 00:57
Oh wait, I think I see, did you expect `new AA(aa);` to move? Or did you expect the copy to be elided altogeather? — Mooing Duck, May 08 '13 at 00:57
You're also making the function virtual, which means dodging copying from copy-elision becomes closer to impossible since you're expecting runtime dispatch (how can the compiler know before it finishes making the program what to do?) — , May 08 '13 at 00:58
Wait, there's no virtual functions here... Is `createObject` supposed to be `virtual`? — Mooing Duck, May 08 '13 at 00:59
I updated `createObject` function to be proper and realistic. — eonil, May 08 '13 at 01:05

Mooing Duck · Accepted Answer · 2013-05-08T01:14:14.017

First:
You expected the optimizer to eliminate the function frame, but it can't, because (1) that function isn't a valid case for RVO to cheat and skip the copy constructor entirely, and (2) Your function has side effects. Namely, writing copy to the screen. So the optimizer can't optimize out the copy, because the code says it must write copy out twice. What I would do is remove the printf call, and check the assembly. Most likely, if it's simple, it is being optimized out.

Second:
If the members copy constructors can have side effects (such as allocating memory), then most likely you're right that it isn't being optimized out. However, you can tell it to move members rather than copying them, which is probably what you expected. For this to work you'll need to make sure your class has a move constructor alongside your copy constructor.

inline static void test(AA aa) __attribute__((always_inline))
{
    AA* ptr =   new AA(std::move(aa));
    delete ptr;
}

Third:
In reality, even that isn't really what you want. What you probably want is something more like perfect forwarding, which will just directly pass the parameters to the constructor without making copies of ANYTHING. This means even with the optimizer disabled entirely, your code is still avoiding copies. (Note that this may not apply to your situation, templates cannot be virtual like this, unless it's specialized)

template<class ...types>
inline static void test(types&&... values) __attribute__((always_inline))
{
    AA* ptr =   new AA(std::forward<types>(values)...);
    delete ptr;
}

@ThePhD: Thanks, I'd shortened the names incorrectly. All the code is guessed, there's probably more errors — Mooing Duck, May 08 '13 at 01:16
I though compiler to be more aggressive, but maybe I have to check the assemblies! — eonil, May 08 '13 at 01:34
*"(2) Your function has side effects. Namely, writing copy to the screen. So the optimizer can't optimize out the copy, because the code says it must write copy out twice."* - A constructor having side effects is still not a valid reason not to apply RVO. Optimizing out side effects via copy elision is explicitly allowed by the standard. — Christian Rau, May 08 '13 at 07:45
@ChristianRau: "(1) that function isn't a valid case for RVO to cheat and skip the copy constructor entirely" That's why there were two seperate points, one for RVO, and one for generic optimization. — Mooing Duck, May 08 '13 at 16:30

score 2 · Answer 2 · edited May 23 '17 at 11:55

Isn't your copy-constructor explicitly called in line AA* ptr = new AA(aa);? If you want to avoid copying initializing value, you should do it like this:

#include <iostream>
#include <utility>

int main(int argc, const char * argv[])
{
    struct
    AA
    {   inline static void test(AA aa) __attribute__((always_inline))
        {
            AA* ptr = new AA(std::move(aa));
            delete ptr;
        }

        inline static void test(AA&& aa) __attribute__((always_inline))
        {
            AA* ptr = new AA(std::move(aa));
            delete ptr;
        }

        AA(AA const& aa)
        {
            printf("COPY!\n");
        }

        AA(AA const&& aa) // Move constructors are not default here - you have to declare one
        {
            printf("MOVE!\n");
        }

        AA(int v)
        {
            printf("CTOR!\n");
            xx  =   v;
        }

        int xx  =   55;
    };

    AA::test(AA(77));
    return 0;
}

Problems:

Conditions allowing default move constructor are quite tight, you are better off writing one yourself.
If you pass value along (even a temporary one) you still need std::move to to pass it even further without creating a copy.

score 0 · Answer 3 · answered May 08 '13 at 01:07

First, let's solve your A&& move problem. You can get a move constructor by making a move constructor (or declaring it default) (or letting the compiler generate one), and making sure you call std::move on aa when you pass it through: Live example here.

The same will apply to any virtual instance function you are working with. I've also included the forwarding variadic version in the example as well, just in case you'd like a reference on how to do that as well (notice all the arguments are std::forwarded to their next calls).

In either case, this seems like a question spawned from a serious case of XY, that is: you're trying to solve a problem you've created with your current design. I don't know why you need to create objects through instance methods on a pre-existing object (factory-type creation?), but it sounds messy. In either case, the above should help you out enough to get your going. Just make sure if you're moving parameters, to always wrap the && item with a std::move (or std::forward if you're working with universal references and template parameters).

Yes I was intended factory method. This function is a primitive for it. And I wanted to add more allocation algorithms later by subclassing. So it became `virtual`. — eonil, May 08 '13 at 01:12

Eliminating copying of function parameter

Update (for later reference)

3 Answers3