async, C++ (vc++) - rextester

Language: Layout:

#include <iostream>
#include <numeric>
#include <future>
#include <ctime>
#include <chrono>
#include <string>

auto psum( const double* begin, const double* end, std::size_t seg_size )
{
    const std::size_t n =  end - begin ;
    if( n <= seg_size ) return std::accumulate( begin, end, 0.0 ) ;

const double* next_seg_begin = begin + seg_size ;

// compute the sum of the tail asynchronously (potentially in another thread)
    auto future_sum_tail = std::async( std::launch::async, psum, next_seg_begin, end, seg_size ) ;

// compute the sum of the first segment in this thread
    const auto sum_head = std::accumulate( begin, begin+seg_size, 0.0 ) ;

return sum_head + future_sum_tail.get() ;
}

struct timer
{
    timer( std::string n ) : name(n) {}

~timer()
    {
        using namespace std::chrono ;
        const auto finish_p = std::clock() ;
        const auto finish_w = steady_clock::now() ;
        std::cout << '\n' << name << "\n---------\n"
                  << " processor: " << (finish_p-start_p) * 1000.0 / CLOCKS_PER_SEC << " milliseconds.\n"
                  << "wall clock: " << duration_cast<milliseconds>(finish_w-start_w).count() << " milliseconds.\n" ;
    }

const std::string name ;
    const std::clock_t start_p = std::clock() ;
    const std::chrono::steady_clock::time_point start_w =  std::chrono::steady_clock::now() ;
};

int main()
{
    const std::size_t N = 8'000'000 ;
    static double seq[N];
    std::iota( seq, seq+N, 0 ) ;

double sum ;
    {
        timer t { "linear" };
        sum = std::accumulate( seq, seq+N, 0.0 ) ;
    }
    std::cout << "sum: " << sum << '\n' ;

{
        timer t { "async (4 segments)" };
        sum = psum( seq, seq+N, N/4 ) ;
    }
    std::cout << "sum: " << sum << '\n' ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 3,77 sec, absolute running time: 0,44 sec, absolute service time: 4,22 sec