Question

I wrote an in-place permutation algorithm [an exercise in TAOCP3], where the inner loop is

template<typename T>
void inplace_permute(T *pT, int *P, const int n)
{
  // part of the inner loop
  pT[j] = std::move(pT[k]);
  P[j] = j;

  // more logic to update j, k, etc.
}

Here, pT is the array of elements to be sorted, P is the permutation table and n is the number of elements.

Will std::move increase performance if T is a complex type, e.g., a string? Also important, can it be optimized out if T is a primitive type (e.g., an int?)

Answer 1

I’ll sum up your question as:

What does std::move do ?

Basically, std::move makes the use of Move Constructor and Move Assignment Operator available.

Typically, those are close to a bitwise copy (they are not exactly one), and so the performance is usually related to the sizeof the class.

Therefore, std::move(someint) and std::move(somestring) would have similar performance if they had a similar size, even though one is a built-in and the other a user class.

There are some differences though.

• on a built-in, a move is just a bitwise copy. Because the moved-from value is unspecified, no zeroing is required. You may want, after moving, to assign it a known value (0 or whatever)
• on a user class, which typically has resources (such a dynamically allocated buffer), moving implies: cleaning the moved-to instance (for assignment), making a somewhat bitwise copy, resetting the moved-from instance. So there is a bit more work.

To understand, we can illustrate this with an example string implementation:

class String {
public:
  // Many things
  String(String&& right);
  String& operator=(String right);

  friend void swap(String& left, String& right);

private:
  // On 64 bits platform, 4x as big as an `int`
  size_t capacity;
  size_t size;
  char* buffer;
};

// Move Constructor
String::String(String&& right):
   capacity(right.capacity), size(right.size), buffer(right.buffer)
{
  right = String(); // reset right
}


// Assignment Operator
String& String::operator=(String right) {
  swap(*this, right);
  return *this;
}

// Swap
void swap(String& left, String& right) {
  using std::swap;
  swap(left.capacity, right.capacity);
  swap(left.size    , right.size);
  swap(left.buffer  , right.buffer);
}

As you can see, the assignment pT[j] = std::move(pT[k]); means (semantically):

• creating a temporary (make a bitwise copy of pT[k])
• reset pT[k]
• exchange the state between the temporary and pT[j]
• destroy the temporary (which typically release the storage inherited from pT[j])

The compiler should, more or less, be able to optimize it into:

• exchange the state between pT[j] and pT[k]
• destroy pT[k] (just release the storage)
• rebuild a new instance in pT[k]

Or, crudely:

swap(ptj, ptk);    // swap 3 fields
delete ptk.buffer; // might be a no-op
ptk = String();    // 0-out 3 fields

Note: this is a toy implementation, it would be a bit more simple on gcc and much more complex on VC++ as they use different representations of the data.