Andrea

I imagine the difference you’re seeing with gcc is that they are using a ref-counted string. Try the experiment again, but using MyVector<std::vector<int>> instead.

Andrea

Thanks for your comment. I make an upfront reservation for the the move vector’s capacity, so passing the pointer around would minimize the number of heap allocations:

        std::vector<Move> generate(const Position& p)
        {
            std::vector<Move> moves;
            moves.reserve(32);
 
            generate<King>(p, moves);
            .... 
 
            return moves;
        }

One more question, though: would this still apply if I would use your stack allocator? So with

        std::vector<Move, stack_alloc<Move, 32> > moves;

wouldn’t that make the “+” notation more viable?

Matthias

template<typename T>
std::vector<T> operator+(std::vector<T> lhs, const std::vector<T>& rhs)
{
        lhs.insert(lhs.end(), rhs.begin(), rhs.end());
        return lhs;
}

That being said, I would be tempted to just do the following:

std::vector<Move>
generate(const Position& p)
{
    std::vector<Move> moves;
    generate<King>(p, moves);
    generate<Queen>(p, moves);
    generate<Rook>(p, moves);
    generate<Bishop>(p, moves);
    generate<Knight>(p, moves);
    generate<Pawn>(p, moves);
    return moves;
}

This isn’t quite as “cute” but is perfectly efficient. And this also comes with a caveat. If in the original code the client is calling this over and over as in:

std::vector<Moves> moves;
while (...)
{
    // ...
    moves.clear();
    generate(p, moves);
    // ...
}

Then you might consider leaving your code as is. Count trips to the heap. Whatever minimizes that count is the best solution. Don’t throw away vector capacity to then just allocate it back. If you can reuse capacity, doing so is always a win. If moves is likely to hold capacity prior to the call to generate then attempt to take advantage of it.

#include <cstddef>
#include <new>
#include <utility>

template <class T>
class MyVector
{
    T* begin_;
    T* end_;
    T* capacity_;

public:
    MyVector()
        : begin_(nullptr),
          end_(nullptr),
          capacity_(nullptr)
        {}

    ~MyVector()
    {
        clear();
        ::operator delete(begin_);
    }

    MyVector(std::size_t N, const T& t)
        : MyVector()
    {
        if (N > 0)
        {
            begin_ = end_ = static_cast<T*>(::operator new(N*sizeof(T)));
            capacity_ = begin_ + N;
            for (; N > 0; --N, ++end_)
                ::new(end_) T(t);
        }
    }

    MyVector(const MyVector& v)
        : MyVector()
    {
        std::size_t N = v.size();
        if (N > 0)
        {
            begin_ = end_ = static_cast<T*>(::operator new(N*sizeof(T)));
            capacity_ = begin_ + N;
            for (std::size_t i = 0; i < N; ++i, ++end_)
                ::new(end_) T(v[i]);
        }
    }

    MyVector(MyVector&& v)
        : begin_(v.begin_),
          end_(v.end_),
          capacity_(v.capacity_)
    {
        v.begin_ = nullptr;
        v.end_ = nullptr;
        v.capacity_ = nullptr;
    }

#ifndef USE_SWAP_ASSIGNMENT

    MyVector& operator=(const MyVector& v)
    {
        if (this != &v)
        {
            std::size_t N = v.size();
            if (capacity() < N)
            {
                clear();
                ::operator delete(begin_);
                begin_ = end_ = static_cast<T*>(::operator new(N*sizeof(T)));
                capacity_ = begin_ + N;
            }
            T* p = begin_;
            const T* q = v.begin_;
            for (; p < end_ && q < v.end_; ++p, ++q)
                *p = *q;
            if (q < v.end_)
            {
                for (; q < v.end_; ++q, ++end_)
                    ::new(end_) T(*q);
            }
            else
            {
                while (end_ > p)
                {
                    --end_;
                    end_->~T();
                }
            }
        }
        return *this;
    }

    MyVector& operator=(MyVector&& v)
    {
        clear();
        swap(v);
        return *this;
    }

#else

    MyVector& operator=(MyVector v)
    {
        swap(v);
        return *this;
    }

#endif

    void clear()
    {
        while (end_ > begin_)
        {
            --end_;
            end_->~T();
        }
    }

    std::size_t size() const
        {return static_cast<std::size_t>(end_ - begin_);}
    std::size_t capacity() const
        {return static_cast<std::size_t>(capacity_ - begin_);}
    const T& operator[](std::size_t i) const
        {return begin_[i];}
    T& operator[](std::size_t i)
        {return begin_[i];}
    void swap(MyVector& v)
    {
        std::swap(begin_, v.begin_);
        std::swap(end_, v.end_);
        std::swap(capacity_, v.capacity_);
    }
};

template <class T>
inline
void
swap(MyVector<T>& x, MyVector<T>& y)
{
    x.swap(y);
}

#include <iostream>
#include <string>
#include <chrono>

int main()
{
    MyVector<std::string> v1(1000, "1234567890123456789012345678901234567890");
    MyVector<std::string> v2(1000, "1234567890123456789012345678901234567890123456789");
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::duration<double, std::micro> US;
    auto t0 = Clock::now();
    v2 = v1;
    auto t1 = Clock::now();
    std::cout << US(t1-t0).count() << " microseconds\n";
}

$ clang++ -stdlib=libc++ -std=c++11 -O3 -DUSE_SWAP_ASSIGNMENT test.cpp
$ a.out
174.516 microseconds
$ a.out
180.83 microseconds
$ a.out
175.848 microseconds

$ clang++ -stdlib=libc++ -std=c++11 -O3  test.cpp
$ a.out
26.339 microseconds
$ a.out
24.179 microseconds
$ a.out
24.103 microseconds

T(T&& x)
{
     // Steal resources from x.
}

T& operator=(T x)    // uses T(T&&) iff x is an r-value
{
    swap(*this, x);
    return *this;
}

template<typename T>
std::vector<T> operator+(const std::vector<T>& lhs, const std::vector<T>& rhs)
{
        auto tmp = lhs;
        tmp.insert(tmp.end(), rhs.begin(), rhs.end());
        return tmp;
}
 
template<typename T>
std::vector<T> operator+(const std::vector<T>& lhs, std::vector<T>&& rhs)
{
        rhs.insert(rhs.begin(), lhs.begin(), lhs.end());
        return std::move(rhs);
}
 
template<typename T>
std::vector<T> operator+(std::vector<T>&& lhs, const std::vector<T>& rhs)
{
        lhs.insert(lhs.end(), rhs.begin(), rhs.end());
        return std::move(lhs);
}
 
template<typename T>
std::vector<T> operator+(std::vector<T>&& lhs, std::vector<T>&& rhs)
{
        lhs.insert(lhs.end(), rhs.begin(), rhs.end());
        return std::move(lhs);
}

It’s different from the Matrix example in this blog because operator+ is not commutative, and it’s also different to the std::string example in the Nxxx standard proposal documents because std::vector does not have a built-in operator+=. So another question is: do I also need to have 4 overloads of operator+= to let std::vector have full append functionality? What signature would they have to have?