{"id":5638,"date":"2019-05-28T13:00:09","date_gmt":"2019-05-28T13:00:09","guid":{"rendered":"http:\/\/writeasync.net\/?p=5638"},"modified":"2019-05-28T00:12:11","modified_gmt":"2019-05-28T00:12:11","slug":"native-code-always-faster","status":"publish","type":"post","link":"http:\/\/writeasync.net\/?p=5638","title":{"rendered":"Native code: always faster?"},"content":{"rendered":"

Last month, I explored some performance optimizations for a C# Letter Boxed solver<\/a>. It was a fair bit of effort but in the end I could solve a typical puzzle in ~80 ms. Success! However, you might rightly point out that I could have spent that time building a solution in a “naturally” high performance language such as native C++. Would that effort have been worth it? After all, isn’t a given C++ app simply just faster<\/a> than its C# equivalent?<\/p>\n

It certainly seems that way, if you browse<\/a> the<\/a> literature<\/a> (i.e. blog posts). Intuitively, it makes sense that any intermediate runtime layer is going to cost at least a few more CPU cycles, all else being equal. But that’s the sticking point — all else is not<\/em> equal. Rarely is a program just a set of pure mathematical calculations, so in practice there are additional (usually dominating) factors which affect performance. Everything from the memory allocation strategy<\/a>, the cache locality<\/a> of your data, and even the available data structures<\/a> will matter as much — if not more — to the overall execution speed.<\/p>\n

But rather than opine abstractly about it, let’s look at a real use case. The Letter Boxed solver example is actually a great proving ground for this “C++ is faster” performance hypothesis for multiple reasons:<\/p>\n

    \n
  1. I already have a working reference implementation in C# for direct comparison.<\/li>\n
  2. The project has full unit tests which I can borrow to aid in implementing the C++ version.<\/li>\n
  3. The core algorithms and abstractions exist in very similar forms for C++ (Dictionary has its analog unordered_map<\/a>, HashSet has unordered_set<\/a>, etc.).<\/li>\n<\/ol>\n

    So let’s get started! First, we need three more projects (native test library, native core library, native solver app<\/a>). Then it’s on to the code, starting with a relatively straight port of the Str class (Str.h<\/a>, Str.cpp<\/a>, StrTest.cpp<\/a>). Note that I have used some C++-isms, such as operator+<\/code><\/a> instead of an Append<\/code> method, a user-defined character literal<\/a> (eliminating the need for a full-fledged Ch<\/code> enum, which became just a typedef<\/code> of uint8_t<\/code> here), and a stream insertion operator<\/a> for “stringifying.”<\/p>\n

    Next up is LetterBoxStr, a pretty simple fa\u00e7ade around Str (LetterBoxStr.h<\/a>, LetterBoxStr.cpp<\/a>, LetterBoxStrTest.cpp<\/a>). Again I can benefit from C++ here by using bitset<\/a> rather than rolling my own Vertices struct as I did in the C# version. (One caveat is that the string output is “backwards” compared to the one I built, so I had to reverse all the expected values in the assertions.)<\/p>\n

    At last, it is time to build the star of the show, StrTrie. (StrTrie.h<\/a>, StrTrie.cpp<\/a>, StrTrieTest.cpp<\/a>) It is a relatively faithful port from the C# implementation, aside from the required, albeit verbose, iterator syntax for finding and inserting values into the map<\/a>.<\/p>\n

    By this point, I have almost enough pieces to stitch together the first half of the native solver app. Just one little Stopwatch class<\/a> (very thinly wrapping the types in std::chrono<\/a>) to aid in performance reporting and we’re off to the races! Except I happened to realize there is a terrible bug in StrTrie which in practice I had not hit yet because my inputs were always sorted. How embarrassing! After a quick fix in the C# code<\/a> and its C++ counterpart<\/a> we can now move back to the native solver skeleton<\/a>. So far it just loads the trie from a file, but already I can see that we’re in trouble:<\/p>\n

    \r\n> LetterBoxedSolver.Native.exe RMEWCLTGKAPI words.txt\r\n[0.000] Loading trie...\r\n[0.226] Loaded 162309 words.\r\n<\/pre>\n
    Recall the C# version:<\/p>\n
    \r\n> dotnet LetterBoxedSolver.dll RMEWCLTGKAPI words.txt\r\n[000.000] Loading trie...\r\n[000.059] Loaded 162309 words.\r\n[000.060] Finding valid words...\r\n[000.072] Found 754 valid words.\r\n[000.072] Finding solutions...\r\nMARKETPLACE-EARWIG\r\nWIGWAM-MARKETPLACE\r\nPRAGMATIC-CAKEWALK\r\n[000.080] Done.\r\n<\/pre>\n
    Simply loading the trie in the C++ app puts us at ~140 ms slower<\/em> than the entire<\/strong> C# solution. Running the profiler and trying various tricks to no avail have convinced me that the way unordered_map<\/code> is defined leads to this slowdown — apparently an artifact of how iterators need to be implemented<\/a>. What a pity — we could really do without the iterator requirement as they are not necessary for this particular application.<\/p>\n
    Not be deterred, I continued with the rest of the implementation. Moving on to LetterBoxStrSearch (LetterBoxStrSearch.h<\/a>, LetterBoxStrSearch.cpp<\/a>, LetterBoxStrSearchTest.cpp<\/a>) which uses a template parameter for the found<\/code> functor (compile-time inheritance FTW<\/a>). Then to the last required data structure, LetterBoxStrWords, to select the two-word solutions. (LetterBoxStrWords.h<\/a>, LetterBoxStrWords.cpp<\/a>, LetterBoxStrWordsTest.cpp<\/a>)<\/p>\n
    With all that done, we can implement the full native solver<\/a>. The syntax of the output streams is a bit awkward due to the lack of a nice formatting library, but it’ll do. Let’s see the results:<\/p>\n
    \r\n[0.000] Loading trie...\r\n[0.225] Loaded 162309 words.\r\n[0.225] Finding valid words...\r\n[0.229] Found 754 valid words.\r\n[0.230] Finding solutions...\r\nMARKETPLACE-EARWIG\r\nWIGWAM-MARKETPLACE\r\nPRAGMATIC-CAKEWALK\r\n[0.235] Done.\r\n<\/pre>\n
    We knew it was going to be slower overall but there is one big ray of hope here — the solution process is much faster than the C# version. It only took ~5 ms to find the words and ~5 ms to find solutions, easily twice as fast as the managed app.<\/p>\n
    Let’s try a puzzle with many more potential solutions to see if the perf gains are sticky:<\/p>\n
    \r\n>LetterBoxedSolver.Native.exe ERGBIDNCFTAO words.txt\r\n[0.000] Loading trie...\r\n[0.224] Loaded 162309 words.\r\n[0.225] Finding valid words...\r\n[0.237] Found 1436 valid words.\r\n[0.238] Finding solutions...\r\nBAITED-DEFORCING\r\n -- snipped 72 other solutions -- \r\nOBTECTED-DRAFTING\r\n[0.324] Done.\r\n<\/pre>\n
    How does that compare with the C# app?<\/p>\n
    \r\ndotnet LetterBoxedSolver.dll ERGBIDNCFTAO words.txt\r\n[000.000] Loading trie...\r\n[000.056] Loaded 162309 words.\r\n[000.057] Finding valid words...\r\n[000.071] Found 1436 valid words.\r\n[000.072] Finding solutions...\r\nROBAND-DEFECTING\r\n -- snipped 72 other solutions -- \r\nOBTECTED-DRAFTING\r\n[000.120] Done.\r\n<\/pre>\n
    Hmm, not so great. (We can ignore that the order of solutions is different because of hash table implementation details — the words are ultimately the same.) Finding solutions is now also slower. But we should be suspicious because we are dealing with console output here, and iostreams are known to be slow<\/a>.<\/p>\n
    Let’s commit a bit of programming heresy and use the maligned<\/a> and unsafe printf<\/a> instead of cout<\/a>:<\/p>\n
    \r\n[000.000] Loading trie...\r\n[000.223] Loaded 162309 words.\r\n[000.224] Finding valid words...\r\n[000.237] Found 1436 valid words.\r\n[000.237] Finding solutions...\r\nBAITED-DEFORCING\r\n -- snipped 72 other solutions -- \r\nOBTECTED-DRAFTING\r\n[000.280] Done.\r\n<\/pre>\n
    That’s a bit better. The C++ solution now has a slight edge over the C# version when solving, but still takes too long to load the trie. Clearly we need to rethink some of the data structures we are using here, but that is an exploration for another time.<\/p>\n
    What did we learn? C++ can be faster at some<\/em> things, no doubt. But there are many other factors to consider before blindly assuming native perf >> managed perf.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Last month, I explored some performance optimizations for a C# Letter Boxed solver. It was a fair bit of effort but in the end I could solve a typical puzzle in ~80 ms. Success! However, you might rightly point out… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[105,101,104],"tags":[],"class_list":["post-5638","post","type-post","status-publish","format-standard","hentry","category-games","category-native","category-performance"],"_links":{"self":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5638","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=5638"}],"version-history":[{"count":1,"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5638\/revisions"}],"predecessor-version":[{"id":5639,"href":"http:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5638\/revisions\/5639"}],"wp:attachment":[{"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=5638"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=5638"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=5638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}