Параллельное приложение

double** Reading()
{
    ifstream inp("D:\\test\m.txt");
    int m, n;
    n = 50;
    m = 50;
    inp >> m >> n;
    double **arr;
    arr = new double*[m];
    for (int i = 0; i<m; i++)
    {
        arr[i] = new double[n];
        for (int j = 0; j<n; j++)
        {
            inp >> arr[i][j];
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}
 
double* Calculation(double** x, int k, int l)
{
    double *arr;
    arr = new double[l];
    double d;
    for (int i = 0; i < k; i++)
    {
        for (int j = 0; j < l; j++)
        {
            d = d + x[i][j];
        }
        arr[i] = d;
    }
    return arr;
}
 
void Write(double* arr, int k)
{
    fstream f;
    f.open("C://test.txt", fstream::in | fstream::out);
 
    for (int i = 0; i < 4; i++)
        f << arr[i] << endl;
    f.close();
}

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <queue>
#include <numeric>
#include <iterator>
#include <vector>
#include <windows.h>
 
using value_queue_t = std::queue<double>;
using array_queue_t = std::queue<std::vector<double>>;
 
array_queue_t array_queue;
CRITICAL_SECTION arr_queue_sc;
HANDLE arr_queue_sem;
 
value_queue_t sum_queue;
CRITICAL_SECTION sum_queue_cs;
HANDLE sum_queue_sem;
 
DWORD WINAPI read_file(PVOID p)
{
    std::ifstream inp(static_cast<const char*>(p));
    std::istringstream iss;
    std::string line;
    
    while(std::getline(inp, line))
    {
        iss.clear();
        iss.str(line);
        std::istream_iterator<value_queue_t::value_type> beg(iss), end;
        
        EnterCriticalSection(&arr_queue_sc);
        array_queue.emplace(beg, end);
        ReleaseSemaphore(arr_queue_sem, 1, NULL);
        LeaveCriticalSection(&arr_queue_sc);
    }
    
    EnterCriticalSection(&arr_queue_sc);
    ReleaseSemaphore(arr_queue_sem, 1, NULL);
    LeaveCriticalSection(&arr_queue_sc);
    return 0;
}
 
DWORD WINAPI do_calc(PVOID)
{
    bool finished = false;
    
    while(!finished)
    {
        array_queue_t::value_type arr;
        
        WaitForSingleObject(arr_queue_sem, INFINITE);
        
        EnterCriticalSection(&arr_queue_sc);
        if(array_queue.empty())
        {
            finished = true;
            LeaveCriticalSection(&arr_queue_sc);
            continue;
        }
        arr.swap(array_queue.front());
        array_queue.pop();
        LeaveCriticalSection(&arr_queue_sc);
 
        value_queue_t::value_type sum = std::accumulate(arr.begin(), arr.end(),
                                                        value_queue_t::value_type());
        
        EnterCriticalSection(&sum_queue_cs);
        sum_queue.push(sum);
        ReleaseSemaphore(sum_queue_sem, 1, NULL);
        LeaveCriticalSection(&sum_queue_cs);
    }
    
    EnterCriticalSection(&sum_queue_cs);
    ReleaseSemaphore(sum_queue_sem, 1, NULL);
    LeaveCriticalSection(&sum_queue_cs);
    return 0;
}
 
DWORD WINAPI write_file(PVOID p)
{
    std::ofstream out(static_cast<const char*>(p));
    bool finished = false;
    
    while(!finished)
    {
        value_queue_t::value_type val;
 
        WaitForSingleObject(sum_queue_sem, INFINITE);
        
        EnterCriticalSection(&sum_queue_cs);
        if(sum_queue.empty())
        {
            finished = true;
            LeaveCriticalSection(&sum_queue_cs);
            continue;
        }
        val = sum_queue.front();
        sum_queue.pop();
        LeaveCriticalSection(&sum_queue_cs);
 
        out << val << ' ';
    }
    return 0;
}
 
int main()
{
    const int thr_num = 3;
    HANDLE threads[thr_num]{};
    const char input_file[]{"input.txt"};
    const char output_file[]{ "output.txt" };
 
    InitializeCriticalSection(&arr_queue_sc);
    InitializeCriticalSection(&sum_queue_cs);
    arr_queue_sem = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
    sum_queue_sem = CreateSemaphore(NULL, 0, LONG_MAX, NULL);
 
    threads[0] = CreateThread(NULL, 0, read_file, (PVOID)input_file, 0, NULL);
    threads[1] = CreateThread(NULL, 0, do_calc, NULL, 0, NULL);
    threads[2] = CreateThread(NULL, 0, write_file, (PVOID)output_file, 0, NULL);
 
    WaitForMultipleObjects(thr_num, threads, TRUE, INFINITE);
    DeleteCriticalSection(&arr_queue_sc);
    DeleteCriticalSection(&sum_queue_cs);
    CloseHandle(arr_queue_sem);
    CloseHandle(sum_queue_sem);
    for(int i = 0; i < thr_num; ++i)
        CloseHandle(threads[i]);
    return 0;
}