What known performance differences are found when using -std=gnu++11

Question

I've been working on a Genetic Algorithm which I'd previously been compiling using g++ 4.8.1 with the arguments

CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse -march=native -std=gnu++11 

I wasn't using many of the features of c++11 and have a reasonable profiling system so I replaced literally 3-4 lines of code and had it compile without -std=gnu++11

CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse -march=native

When I ran my profiler again, I noticed that I could see ~5% performance improvement almost everywhere, except for my sort function, which was now taking about twice as long. (It's an overloaded operator< on the object)

My questions are:

What performance differences are known between the two versions, and is it expected that c++11 would be faster in newer compilers?

I'm also expecting the fact I'm using -Ofast is playing a role, am I right in my assumption?

UPDATE:

As suggested in comments I ran the tests again using with and without -march=native

// Fast sort, slightly slower in other tests
CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse -march=native -std=gnu++11  

// Fast sort, slower in other tests
CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse -std=gnu++11  

// Slow sort, slower in other tests
CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse                     

// Slow sort, fastest in other tests
CCFLAGS=-c -Wall  -Ofast -fopenmp -mfpmath=sse  -march=native

The conclusion seems to be the same that -std=gnu++11 speeds up sort drastically with a slight penalty almost everywhere else. -march=native speeds up program whenever used.

Given that sort is only called once per generation, I'll take the speed benefit of not compiling with -std=gnu++11, but I'm still very interested in what is causing these results.

I'm using the // std::sort provided from #include

Answer 1

I am not certain why using --std=gnu++11 would make parts of the code slower. I do not use that personally (instead, I use --std=c++11). Perhaps the extra GNU features are slowing something down? More likely, the optimization hasn't caught up with the new language features yet.

As for why the sort part is faster, I have a plausible explanation:

You've enabled move semantics. Even if you don't explicitly write them yourself, if your classes are reasonably constructed, they will be generated. The "sort" algorithm probably takes advantage of them.

However, the class you've listed above doesn't seem to have much storage. However, it does not have a "swap" method, so without C++11 move semantics, the sort routine must do more work. You might look at this question and answers for more about sort and move semantics and interactions with compiler options.

Answer 2

There has been a lot of interest in why the sort method had such a performance drop.

I'm more interested in why the remaining code saw a good improvement, but to help conversation, below is the only part of my code which was quicker under -std=gnu++11

Its just the comparison of a double on a vector objects member.

class TvectorPM {
public:
    pthread_mutex_t lock;
    std::vector<PopulationMember> v; 
    void add(PopulationMember p);
};

void TvectorPM::add(PopulationMember p) {
    pthread_mutex_lock(&lock);
    v.push_back(p);
    pthread_mutex_unlock(&lock);
}


class PopulationManager {
public:
    TvectorPM populationlist;
}


void PopulationManager::sortByScore() {
    // Have overloaded operator< to make this fast
    sort(populationlist.v.begin(),populationlist.v.end());
}


class PopulationMember {
public:
    bool hasChanged;
    double score;

    inline bool operator< (const PopulationMember& rhs) const{
        return this->score < rhs.score;
    }

Answer 3

I believe this boils down to the features GNU adds(documentation on GNU Extensions).

Those extensions might optimize some functionality in rather reasonable manner and provide additional overhead for others, as the performance depends on the shape of the code.

Unfortunately I'm unable to provide specifics.

Answer 4

C++11 differs from the old versions in number of aspects. Many enhancements have been made to the language's original core too.
Also, some additional features are added. You can visit this webpage and look at the items with the C++11 tag.
Some of the minor, yet heavily used features -

1. initializer list for `vectors`<br>
2. range based `for` loop<br>
3. the `auto` keyword, for declaring data types, <br>
4. the 'uniform initialization syntax', in its full glory

and also the -std=c++11 flag that must be used to be able to enjoy any of the above features.

As for the performance issues, it may have been just a coincidence. But to be sure, run the compilations multiple times.