Examples of when a bitwise swap() is a bad idea?

by

This is not specifically about swap but an example showing that low level optimizations are maybe not worth the trouble. The compiler often figures it out anyway.

Of course, this is my favorite example where the compiler is exceptionally lucky, but anyway we shouldn’t assume that compilers are stupid and that we can easily improve on the generated code with some simple tricks.

My test code is – construct a std::string and copy it.

std::string whatever = "abcdefgh";
std::string whatever2 = whatever;

The first constructor looks like this

  basic_string(const value_type* _String,
               const allocator_type& _Allocator = allocator_type() ) : _Parent(_Allocator)
  {
     const size_type _StringSize = traits_type::length(_String);

     if (_MySmallStringCapacity < _StringSize)
     {
        _AllocateAndCopy(_String, _StringSize);
     }
     else
     {
        traits_type::copy(_MySmallString._Buffer, _String, _StringSize);

        _SetSmallStringCapacity();
        _SetSize(_StringSize);
     }
  }

The generated code is

   std::string whatever = "abcdefgh";
000000013FCC30C3  mov         rdx,qword ptr [string "abcdefgh" (13FD07498h)]  
000000013FCC30CA  mov         qword ptr [whatever],rdx  
000000013FCC30D2  mov         byte ptr [rsp+347h],0  
000000013FCC30DA  mov         qword ptr [rsp+348h],8  
000000013FCC30E6  mov         byte ptr [rsp+338h],0

Here traits_type::copycontains a call to memcpy, which is optimized into a single register copy of the whole string (carefully selected to fit). The compiler also transforms a call to strlen into a compile time 8.

Then we copy it into a new string. The copy constructor looks like this

  basic_string(const basic_string& _String)
     : _Parent(std::allocator_traits<allocator_type>::select_on_container_copy_construction(_String._MyAllocator))
  {
     if (_MySmallStringCapacity < _String.size())
     {
        _AllocateAndCopy(_String);
     }
     else
     {
        traits_type::copy(_MySmallString._Buffer, _String.data(), _String.size());

        _SetSmallStringCapacity();
        _SetSize(_String.size());
     }
  }

and results in just 4 machine instructions:

   std::string whatever2 = whatever;
000000013FCC30EE  mov         qword ptr [whatever2],rdx  
000000013FCC30F6  mov         byte ptr [rsp+6CFh],0  
000000013FCC30FE  mov         qword ptr [rsp+6D0h],8  
000000013FCC310A  mov         byte ptr [rsp+6C0h],0

Note that the optimizer remembers that the char‘s are still in register rdx and that the string length must be the same, 8.

It is after seeing things like this that I like to trust my compiler, and avoid trying to improve code with bit fiddling. It doesn’t help, unless profiling finds an unexpected bottleneck.

(featuring MSVC 10 and my std::string implementation)

More Related Contents:

  1. swap string a in place to string b in C++ [closed]
  2. Determine if int is not 0 with no if statements
  3. Invalid solution for code challenge with operator restrictions
  4. How do you set, clear, and toggle a single bit?
  5. What can I do with a moved-from object?
  6. Position of least significant bit that is set
  7. How to create a byte out of 8 bool values (and vice versa)?
  8. C/C++: Force Bit Field Order and Alignment
  9. What is the idea behind ^= 32, that converts lowercase letters to upper and vice versa?
  10. C/C++ check if one bit is set in, i.e. int variable
  11. In C/C++ what’s the simplest way to reverse the order of bits in a byte?
  12. Weird behavior of right shift operator (1 >> 32)
  13. Should I use #define, enum or const?
  14. How to add two numbers without using ++ or + or another arithmetic operator
  15. How does the standard library implement std::swap?
  16. get absolute value without using abs function nor if statement
  17. What happens when you bit shift beyond the end of a variable?
  18. What’s the fastest way to pack 32 0/1 values into the bits of a single 32-bit variable?
  19. Efficient bitwise operations for counting bits or find the right|left most ones
  20. Performance wise, how fast are Bitwise Operators vs. Normal Modulus?
  21. Branchless code that maps zero, negative, and positive to 0, 1, 2
  22. iter_swap() versus swap() — what’s the difference?
  23. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  24. Fastest way to produce a mask with n ones starting at position i
  25. Swapping Nodes on a single linked list
  26. How to set, clear, and toggle a single bit?
  27. Fast divisibility tests (by 2,3,4,5,.., 16)?
  28. Move semantics == custom swap function obsolete?
  29. How can I test whether a number is a power of 2?
  30. C++ trying to swap values in a vector

Leave a Comment