{"id":5092,"date":"2016-12-20T22:07:03","date_gmt":"2016-12-20T22:07:03","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/copy-versus-move-semantic-a-few-numbers\/"},"modified":"2023-06-26T12:31:17","modified_gmt":"2023-06-26T12:31:17","slug":"copy-versus-move-semantic-a-few-numbers","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/copy-versus-move-semantic-a-few-numbers\/","title":{"rendered":"Copy versus Move Semantics: A few Numbers"},"content":{"rendered":"

A lot was written about the advantages of move semantics to copy semantics. Instead of an expensive copy operation, you can use a cheap move operation. But what does that mean? In this post, I will compare the copy and move semantics performance for the Standard Template Library (STL) containers. <\/p>\n

<\/p>\n

 <\/p>\n

Before I show the number, I will provide some background information.<\/p>\n

Copy versus Move Semantics<\/h2>\n

The subtle difference is if you create with a copy or move semantic a new object based on an existing one, the copy semantic will copy the elements of the resource, and the move semantic will move the elements of the resource. Of course, copying is expensive, and moving is cheap. But there are additional serious consequences.<\/p>\n

    \n
  1. With copy semantic, it can happen that a std::bad_alloc<\/a><\/span> will be thrown because your program is out of memory.<\/li>\n
  2. The resource of the move operation is afterward in a “valid but unspecified state<\/em>“.<\/li>\n<\/ol>\n

    The second point is very nice to show with std::string<\/span>.<\/p>\n

    At first, the classical copy semantics.<\/p>\n

    Copy semantics<\/h3>\n
    \n
    std::string1(\"ABCDEF\"<\/span>);\r\nstd::string str2;\r\nstr2 = str1;\r\n<\/pre>\n<\/div>\n
    \"copy\"<\/p>\n
    After the copy operation, strings str1 and str2 have the same content, “ABCDEF<\/span>“. So, what’s the difference between the move semantics?<\/p>\n
    Move semantics<\/h3>\n
     <\/p>\n
    \n
    std::string1(\"ABCDEF\"<\/span>);\r\nstd::string str3;\r\nstr3 = std::move(str1);\r\n<\/pre>\n<\/div>\n
    \"move\"<\/p>\n
    The string str1<\/span> opposes the copy semantic afterward empty “”. This is not guaranteed but often the case. I explicitly requested the move semantic with the function std::move<\/a><\/span>. The compiler will automatically perform the move semantic if it is sure that the source of the move semantic is not needed anymore.<\/p>\n
    I will explicitly request the move semantic in my program by using std::move.<\/span><\/p>\n<\/p>\n
    The Performance Differences<\/h2>\n
    I will take the naive position in my post and compare the performance difference between the copy and move semantics of the STL containers. My comparison will include the std::string<\/span>. I will ignore the associative containers<\/a>, which can have more equal keys. I’m particularly interested in the performance ratio between the copy and move semantics of the containers.<\/p>\n
    The boundary conditions<\/h3>\n
    The differences were not so dramatic between the program with maximum optimization and without optimization; therefore, I will, for simplicity reasons, only provide the results for the executable with maximum optimization. I use a GCC 4.9.2 compiler and the cl.exe compiler, which is part of Microsoft Visual Studio 2015. Both platforms are 64-bit. Therefore, the executables are built for 64-bit. <\/p>\n
    The program<\/h3>\n
    We have a lot of containers in the STL. Therefore, the program is a little bit lengthy.<\/p>\n
    \n\n\n\n
    \n
      1\r\n  2\r\n  3\r\n  4\r\n  5\r\n  6\r\n  7\r\n  8\r\n  9\r\n 10\r\n 11\r\n 12\r\n 13\r\n 14\r\n 15\r\n 16\r\n 17\r\n 18\r\n 19\r\n 20\r\n 21\r\n 22\r\n 23\r\n 24\r\n 25\r\n 26\r\n 27\r\n 28\r\n 29\r\n 30\r\n 31\r\n 32\r\n 33\r\n 34\r\n 35\r\n 36\r\n 37\r\n 38\r\n 39\r\n 40\r\n 41\r\n 42\r\n 43\r\n 44\r\n 45\r\n 46\r\n 47\r\n 48\r\n 49\r\n 50\r\n 51\r\n 52\r\n 53\r\n 54\r\n 55\r\n 56\r\n 57\r\n 58\r\n 59\r\n 60\r\n 61\r\n 62\r\n 63\r\n 64\r\n 65\r\n 66\r\n 67\r\n 68\r\n 69\r\n 70\r\n 71\r\n 72\r\n 73\r\n 74\r\n 75\r\n 76\r\n 77\r\n 78\r\n 79\r\n 80\r\n 81\r\n 82\r\n 83\r\n 84\r\n 85\r\n 86\r\n 87\r\n 88\r\n 89\r\n 90\r\n 91\r\n 92\r\n 93\r\n 94\r\n 95\r\n 96\r\n 97\r\n 98\r\n 99\r\n100\r\n101\r\n102\r\n103\r\n104\r\n105<\/pre>\n<\/td>\n
    		\n
    \/\/ movePerformance.cpp<\/span>\r\n \r\n#include <array><\/span>\r\n#include <forward_list><\/span>\r\n#include <chrono><\/span>\r\n#include <deque><\/span>\r\n#include <iomanip><\/span>\r\n#include <iostream><\/span>\r\n#include <list><\/span>\r\n#include <map><\/span>\r\n#include <numeric><\/span>\r\n#include <set><\/span>\r\n#include <string><\/span>\r\n#include <unordered_map><\/span>\r\n#include <unordered_set><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconst<\/span> int<\/span> SIZE = 10000000; \r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nvoid<\/span> measurePerformance(T& t, const<\/span> std::string& cont){\r\n  \r\n  std::cout << std::fixed << std::setprecision(10);\r\n\r\n  auto<\/span> begin= std::chrono::system_clock::now();\r\n  T t1(t);\r\n  auto<\/span> last=  std::chrono::system_clock::now() - begin;\r\n  std::cout << cont << std::endl;\r\n  auto<\/span> copyTime=  std::chrono::duration<double<\/span>>(last).count();\r\n  std::cout <<  \"    Copy: \"<\/span> << copyTime << \" sec\"<\/span> << std::endl;\r\n\r\n  begin= std::chrono::system_clock::now();\r\n  T t2(std::move(t));\r\n  last=  std::chrono::system_clock::now() - begin;\r\n  auto<\/span> moveTime= std::chrono::duration<double<\/span>>(last).count();\r\n  std::cout <<  \"    Move: \"<\/span> << moveTime << \" sec\"<\/span> << std::endl;\r\n  \r\n  std::cout << std::setprecision(2);\r\n  std::cout << \"    Ratio (copy time\/move time): \"<\/span> << (copyTime\/moveTime) << std::endl;\r\n  \r\n  std::cout << std::endl;\r\n     \r\n}\r\n\r\nint<\/span> main(){\r\n    \r\n    std::cout << std::endl;\r\n    \r\n    {\r\n      std::array<int<\/span>,SIZE\/1000> myArray;\r\n      measurePerformance(myArray,\"std::array<int,SIZE\/1000>\"<\/span>);   \r\n    }\r\n    \r\n    {\r\n      std::vector<int<\/span>> myVec(SIZE);\r\n      measurePerformance(myVec,\"std::vector<int>(SIZE)\"<\/span>);\r\n    }\r\n\r\n    {\r\n      std::deque<int<\/span>>myDec(SIZE);\r\n      measurePerformance(myDec,\"std::deque<int>(SIZE)\"<\/span>);\r\n    }\r\n    \r\n    {\r\n      std::list<int<\/span>>myList(SIZE);\r\n      measurePerformance(myList,\"std::list<int>(SIZE)\"<\/span>);\r\n    }\r\n    \r\n    {\r\n      std::forward_list<int<\/span>>myForwardList(SIZE);\r\n      measurePerformance(myForwardList,\"std::forward_list<int>(SIZE)\"<\/span>);\r\n    } \r\n       \r\n    {\r\n      std::string myString(SIZE,' '<\/span>);\r\n      measurePerformance(myString,\"std::string(SIZE,' ')\"<\/span>);\r\n    }\r\n    \r\n    std::vector<int<\/span>> tmpVec(SIZE);\r\n    std::iota(tmpVec.begin(),tmpVec.end(),0);\r\n    \r\n    {\r\n      std::set<int<\/span>>mySet(tmpVec.begin(),tmpVec.end());\r\n      measurePerformance(mySet,\"std::set<int>\"<\/span>);\r\n    }\r\n    \r\n    {\r\n      std::unordered_set<int<\/span>>myUnorderedSet(tmpVec.begin(),tmpVec.end());\r\n      measurePerformance(myUnorderedSet,\"std::unordered_set<int>\"<\/span>);\r\n    }\r\n    \r\n    {\r\n      std::map<int<\/span>,int<\/span>>myMap;\r\n      for<\/span> (auto<\/span> i= 0; i <= SIZE; ++i) myMap[i]= i;\r\n      measurePerformance(myMap,\"std::map<int,int>\"<\/span>);\r\n    }\r\n    \r\n    {\r\n      std::unordered_map<int<\/span>,int<\/span>>myUnorderedMap;\r\n      for<\/span> (auto<\/span> i= 0; i <= SIZE; ++i) myUnorderedMap[i]= i;\r\n      measurePerformance(myUnorderedMap,\"std::unordered_map<int,int>\"<\/span>);\r\n    }  \r\n    \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
     <\/p>\n
    The idea of the program is to initialize the containers with 10 million elements. Of course, the initialization will happen with copy and move semantics. The performance measurement occurs in the function template measurePerformane (lines 21 – 44). The function takes as an argument the container and the name of the container. Thanks to the Chrono library I can measure how long the copy initialization (line 27) and the move initialization (line 34) take. Ultimately, I’m interested in the ratio between the copy and move semantics (line 40).<\/p>\n
    What’s happening in the main function? I create each container with its scope so that it will be automatically released. Therefore, myArray (line 51) will automatically be released and the end of its scope (line 53). Because the containers are quite big, releasing their memory is a must. I claimed that each container has 10 million elements. That will not hold for myArray. Because myArray will not be allocated on the heap, I must dramatically reduce its size. But now to the remaining containers. With std::vector,<\/span> std::deque,<\/span> std::list<\/span>, and std::forward_list<\/span> there are in lines 55 – 73 the remaining sequential containers. In lines 75 – 78 std::string<\/span> follows. The rest are the associative containers. I have to pay attention to one characteristic of the associative container. To have unique keys and therefore the size 10 million, I use the numbers 0 to 9999999 as keys. The function std::iota<\/span> does the job.<\/span><\/p>\n
    The numbers<\/h3>\n
    \"move\"\"moveWin\"<\/p>\n
     <\/p>\n
    The results of std::array<\/span> are not so meaningful. On the one hand, std::array<\/span> is not so big; on the other hand, the time difference on Windows is not measurable with the clock std::system_clock<\/span>. <\/p>\n
    What insight can I derive from the numbers?<\/p>\n