Как ускорить вычисления потоками?

/////
vector <double> lam,h;
//как-то заполняются
////////
double Cycle(vector<double> lam, vector<double> h, int N){
    vector<double> sumk;
    double summ(0);
    double sumi(0);
    for (int k = 0; k < N; k++) {
        for (int i = 0; i < N; i++) {
            sumi += lam[i] * h[abs(i - k)];
        }
        sumk.push_back(sumi);
        sumi = 0;
    }
    for (int m = 0; m < N; m++) {
        double sum(0);
        for (int k = 0; k < N; k++) {
            sum += h[abs(m - k)] * exp(-1 - sumk[k]);
        }
        summ += pow(y[m] - sum, 2);
    }
}
////

/////
vector <double> lam,h;
//как-то заполняются
////////
double Cycle(vector<double> lam, vector<double> h, int N){
    vector<double> sumk;
    double summ(0);
    double sumi(0);
    for (int k = 0; k < N; k++) {
        auto f = [&sumi](int i, int k, vector<double> lam, vector<double> h) {
        sumi+=lam[i] * h[abs(i - k)];
            };
        for (int i = 0; i < N; i+=4) {
            thread one(f, i, k, lam, h);
            thread two(f, i+1, k, lam, h);
            thread three(f, i+2, k, lam, h);
            thread four(f, i+3, k, lam, h);
 
            one.join();
            two.join();
            three.join();
            four.join();
 
        }
        sumk.push_back(sumi);
        sumi = 0;
    }
    for (int m = 0; m < N; m++) {
        double sum(0);
        for (int k = 0; k < N; k++) {
            sum += h[abs(m - k)] * exp(-1 - sumk[k]);
        }
        summ += pow(y[m] - sum, 2);
    }
}
////

sumk.push_back(exp(-1. - sumi));

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <ctime>
#include <future>
#include <thread>
using namespace std;
 
 
int main()
{
    int N = 70000;
    vector<double> lam(N, 1.), h(N, 1.), y(N, 1.);
    vector<double> sumk;
    sumk.reserve(N);
    double summ{}, sumi{}, sum{};
    int hc = std::thread::hardware_concurrency();
    std::vector<std::future<std::vector<double>>> vv;
    vv.reserve(hc);
    auto t1 = clock();
    auto lmd1 = [N, &lam, &h](int a, int b)
    {
        vector<double> sumk;
        sumk.reserve(b - a);
        double sumi{};
        for (int k = a; k < b; ++k)
        {
            for (int i = 0; i < N; ++i)
            {
                sumi += lam[i] * h[abs(i - k)];
            }
            sumk.push_back(exp(-1. - sumi));
            sumi = 0.;
        }
        return sumk;
    };
    for (int i = 0; i < hc; ++i)
    {
        int a = i * (N / hc);
        int b = (i + 1) * (N / hc) + ((i == hc - 1) ? N % hc : 0);
        vv.emplace_back(std::async(std::launch::async, lmd1, a, b));
    }
    for (auto& f : vv)
    {
        auto sf = f.share();
        sumk.insert(sumk.end(), sf.get().begin(), sf.get().end());
    }
 
    std::vector<std::future<double>> vf;
    vf.reserve(hc);
    auto t2 = clock();
    auto lmd2 = [N, &h, &sumk, &y](int a, int b)
    {
        double sum = 0., summcur = 0.;
        for (int m = a; m < b; ++m)
        {
            sum = 0.;
            for (int k = 0; k < N; ++k)
            {
                sum += h[abs(m - k)] * sumk[k];
            }
            summcur += pow(y[m] - sum, 2.);
        }
        return summcur;
    };
 
    for (int i = 0; i < hc; ++i)
    {
        int a = i * (N / hc);
        int b = (i + 1) * (N / hc) + ((i == hc - 1) ? N % hc : 0);
        vf.emplace_back(std::async(std::launch::async, lmd2, a, b));
    }
    for (auto& f : vf)
    {
        summ += f.get();
    }
 
    auto t3 = clock();
    std::cout << summ << "\n";
    std::cout << (t2 - t1) / 1000. << "\n";
    std::cout << (t3 - t2) / 1000. << "\n";
}