#include <vector>
#include <algorithm>
#include <boost/compute.hpp>

namespace compute = boost::compute;


const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE(
        __kernel void vectorAdd(__global const float *a,
                                __global const float *b,
                                __global float *c)
        {
           int i=get_global_id(0);
           c[i]=a[i]+b[i];
        });

int main()
{
    // get the default compute device
    compute::device gpu = compute::system::default_device();

    // create a compute context and command queue
    compute::context ctx(gpu);
    compute::command_queue queue(ctx, gpu);


    compute::program program = compute::program::build_with_source(source, ctx);
    compute::kernel kernel = program.create_kernel("vectorAdd");

    // generate random numbers on the host
    std::vector<float> host_vector(5);
    std::generate(host_vector.begin(), host_vector.end(), rand);

    // create vector on the device
    compute::vector<float> device_vector(5, ctx);
    compute::vector<float> device_vector_out(5, ctx);

    // copy data to the device
    compute::copy(
        host_vector.begin(), host_vector.end(), device_vector.begin(), queue
    );

    kernel.set_arg(0, device_vector);
    kernel.set_arg(1, device_vector);
    kernel.set_arg(2, device_vector_out);

    std::cout << "before addition" << std::endl;
    for(auto a : host_vector) {
        std::cout << a << std::endl;
    }


    queue.enqueue_1d_range_kernel(kernel, 0, 5, 1);
    queue.finish();

    std::vector<float> host_out(5);
    compute::copy(device_vector_out.begin(), device_vector_out.end(), host_out.begin(), queue);

    std::cout << "sorted" << std::endl;
    for(auto a : host_out) {
        std::cout << a << std::endl;
    }

    return 0;
}