Почему std::string_view МЕДЛЕННЕЕ, чем std::string?

#include <iostream>
#include <iomanip>
#include <unordered_set>
#include <chrono>
#include <cstdio>
#include <mutex>
#include <thread>
#include <cstring>
 
#include <experimental/string_view>
#include <experimental/filesystem>
 
 
 
namespace sc = std::chrono;
namespace fs = std::experimental::filesystem;
 
thread_local std::unordered_set<std::/*experimental::*/string/*_view*/> chunk;
std::mutex m;
std::unordered_set<std::/*experimental::*/string/*_view*/> hashSet;
 
 
void processData(const char *const data, uint32_t len)
{
    chunk.reserve(len / 4);
    const char *ptr = data, *prevPtr = data;
 
    while ( ptr = (const char*)memchr(ptr, '\n', len - (ptr-data)))
    {
        chunk.emplace((const char*)prevPtr, ptr-prevPtr);
 
        prevPtr = ++ptr;
    }
    std::lock_guard<decltype(m)> lock(m);
    hashSet.insert(chunk.cbegin(), chunk.cend());
 
}
 
int main()
{
 
    hashSet.reserve(1024*1024*2);
    const char *const fileName = "/home/z/random_values.txt";
    const auto fileSize = fs::file_size(fileName);
    const std::size_t idealThreadCount = std::thread::hardware_concurrency();
    auto buffer = std::make_unique<char[]>(fileSize);
    auto fh = std::unique_ptr<FILE, void(*)(FILE*)>(std::fopen(fileName, "rb"), [](auto *p){std::fclose(p); });
 
    std::cout << "File size: " << fileSize << " bytes\n"
              << "HW concurrency: " << idealThreadCount << std::endl;
 
    const auto start = sc::high_resolution_clock::now();
    std::fread(buffer.get(), 1, fileSize, fh.get());
 
 
    ///-------------------Multithreaded approach
    const int chunkSize = fileSize / idealThreadCount;
    std::vector<std::thread> threads;
    const char *prevPtr = buffer.get(),
               *ptr     = buffer.get(),
               *endPtr  = buffer.get() + fileSize;
 
    for(size_t threadIndex = 0; threadIndex  < idealThreadCount; ++threadIndex )
    {
 
        // If we have enough data for processing.
        if((endPtr - ptr) >= chunkSize)
        {
            ptr += chunkSize;
 
            // Find closest newline.
            while(*ptr != '\n')
                ++ptr;
        }
        else
        {
            // Process remainders of data: from last pos to the end of file.
            threads.emplace_back(processData, prevPtr, endPtr - prevPtr);
            break;
        }
 
        threads.emplace_back(processData, prevPtr, ptr  - prevPtr +1);
        prevPtr = ++ptr;
    }
 
    for(auto& thread : threads)
        thread.join();
 
 
    ///-------------------Single thread approach
//    const char* mapPtr = /*file.map(0, fileSize)*/buffer.get();
//    const char *ptr = mapPtr, *prevPtr = mapPtr;
//    while ( ptr = (const char*)memchr(ptr, '\n', fileSize - (ptr-mapPtr)))
//    {
//        hashSet.emplace((const char*)prevPtr, ptr-prevPtr);
 
//        prevPtr = ++ptr;
//    }
 
 
    // Show results.
    const auto end = sc::high_resolution_clock::now();
 
    std::cout << "+-----------------------------------------+\n"; // 43 chars
    std::cout << std::setw(25) << std::left << "|    Unique elements:"
              << "< " << hashSet.size() << " >\n"
 
              << std::setw(25) << std::left << "|    Elapsed time:"
              << "< " << sc::duration_cast<sc::milliseconds>(end-start).count()
              << "ms >" << std::endl;
    std::cout << "+-----------------------------------------+\n";
}

#include <iostream>
#include <fstream>
#include <iomanip>
#include <unordered_set>
#include <chrono>
#include <iterator>
#include <string>
#include <algorithm>
#include <future>
#include <thread>
#include <experimental/filesystem>
#include <boost/spirit/include/qi.hpp>
 
namespace sc = std::chrono;
namespace qi = boost::spirit::qi;
 
std::unordered_set<int> MTVersion()
{
    const static char* fileName = "/home/xxx/random_values";
    std::ifstream file(fileName);
    if (file)
    {
        auto start = sc::high_resolution_clock::now();
 
        const auto fileSize = std::experimental::filesystem::file_size(
                fileName);
 
        std::istreambuf_iterator<char> begFile { file };
        std::istreambuf_iterator<char> endFile;
        std::string fileBuf;
        fileBuf.reserve(fileSize);
        fileBuf.insert(fileBuf.begin(), begFile, endFile);
        file.close();
 
        std::vector<std::future<std::unordered_set<int>>>vecOfFut;
 
        const auto threadCount = std::thread::hardware_concurrency();
        auto threadOffset = fileBuf.size() / threadCount;
        double threadOffsetDelta = threadOffset / threadCount;//на глазок :)
        auto beginIt = fileBuf.begin();
        auto endIt = fileBuf.begin();
 
        size_t backetCount = 1024 * 1024 * 10;
 
        double i = threadCount;
        while (--i)
        {
            endIt = std::find(
                    beginIt + threadOffset
                            - static_cast<size_t>((i - threadCount / 2.0)
                                    * threadOffsetDelta), fileBuf.end(), '\n');
 
            vecOfFut.push_back(
                    std::async(std::launch::async,
                            [=](std::string::iterator begin,std::string::iterator end)
                            {
                                std::unordered_set<int> ret;
                                qi::parse(begin, end, qi::int_ % qi::eol, ret);
 
                                return ret;
                            }, beginIt, endIt));
 
            beginIt = ++endIt;
        }
        std::unordered_set<int> hashSet(backetCount);
        for (auto& fut : vecOfFut)
        {
            auto set = fut.get();
            hashSet.insert(std::begin(set), std::end(set));
        }
        auto end = sc::high_resolution_clock::now();
 
        std::cout << "+-----------------------------------------+\n"; // 43 chars
        std::cout << std::setw(25) << std::left << "|    Unique elements:"
                << "< " << hashSet.size() << " >\n"
 
                << std::setw(25) << std::left << "|    Elapsed time:" << "< "
                << sc::duration_cast<sc::milliseconds>(end - start).count()
                << "ms >" << std::endl;
        std::cout << "+-----------------------------------------+\n";
 
        return hashSet;
    }
    throw std::runtime_error("Error opening file");
}
 
int main()
{
    MTVersion();
}