Многопоточная обработка большого файла

bool FileAnalyzer::analyze_file(const std::string& file_name, const std::string& analytics_report_file_name)
{
    std::ifstream fin(file_name);
    if (!fin.is_open())
        return false;
 
    long double mean = 0.0;
    long double sum = 0.0; // sum of squared differences needed for standard deviation calculation
    std::size_t count = 0;   // number of elements in the file
 
    long double number{};
    while (fin >> number)
    {
        ++count;
        long double old_mean = mean;
        long double delta = number - mean;
        mean += delta / count;
        sum += (number - old_mean) * delta;
    }
    if (count == 0)
        return false;
    // standard deviation
    long double stddev = count > 1 ? std::sqrt(sum / (count - 1)) : 0.0;
 
    output_results(std::cout, mean, stddev);
 
    return true;
}

bool FileAnalyzer::parallel_analyze_file(const std::string& file_name, const std::string& analytics_report_file_name)
{
    struct ThreadEntry
    {
        std::thread thread;
        long double mean = 0.0;
        long double sum = 0.0;
        std::size_t count = 0;
    };
 
    const std::size_t FILE_SIZE = std::filesystem::file_size(file_name);
    const std::size_t CHUNKS = std::thread::hardware_concurrency();
    const std::size_t CHUNK_SIZE = FILE_SIZE / CHUNKS;
    std::vector<ThreadEntry> entries(CHUNKS);
    for (std::size_t i = 0; i < CHUNKS; ++i)
    {
        std::size_t begin = i * CHUNK_SIZE;
        std::size_t end = (i == CHUNKS - 1) ? FILE_SIZE : begin + CHUNK_SIZE;
        entries[i].thread = std::thread([i, &entries, &file_name](std::size_t begin, std::size_t end)
        {
            std::ifstream fin(file_name);
            if (!fin.is_open())
                return;
            fin.seekg(begin);
 
            long double number{};
            long double mean = 0.0;
            long double sum = 0.0; // sum of squared differences needed for standard deviation calculation
            std::size_t count = 0;   // number of elements in the chunk
 
            if (i != 0)
                fin >> number;
            while (fin.tellg() <= end && (fin >> number))
            {
                ++count;
                long double old_mean = mean;
                long double delta = number - mean;
                mean += delta / count;
                sum += (number - old_mean) * delta;
            }
            entries[i].mean = mean;
            entries[i].sum = sum;
            entries[i].count = count;
        }, begin, end);
    }
    for (auto& entry : entries)
        entry.thread.join();
 
    long double mean = 0.0;
    long double sum = 0.0;
    std::size_t count = 0;
    for (const auto& entry : entries)
    {
        if (entry.count == 0)
            continue;
        if (count == 0)
        {
            mean = entry.mean;
            sum = entry.sum;
            count = entry.count;
        }
        else
        {
            std::size_t next_count = count + entry.count;
            long double delta = entry.mean - mean;
            mean += delta * entry.count / next_count;
            sum += entry.sum + delta * delta * count * entry.count / next_count;
            count = next_count;
        }
    }
    std::cout << "count = " << count << "\n";
    if (count == 0)
        return false;
    long double stddev = count > 1 ? std::sqrt(sum / (count - 1)) : 0.0; // standard deviation
 
    output_results(std::cout, mean, stddev, p50, p99, p01);
 
    return true;
}

if (i != 0)
    fin >> number;

if (i != 0)
{
       std::string dummy;
       std::getline(fin, dummy, '\n');
}

if (i != 0)
    fin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');