//==============================================================
// Copyright © Intel Corporation
//
// SPDX-License-Identifier: MIT
// =============================================================
#include <CL/sycl.hpp>
#include <cassert>

using namespace sycl;

constexpr int N = 32;

int main() {
    queue Q;
    
    buffer<int4> A{ range{N} };
    buffer<int4> B{ range{N} };
    buffer<int4> C{ range{N} };

    accessor pC{ C };

    Q.submit([&](handler& h) {
        accessor aA{ A, h, write_only, no_init };
        accessor aB{ B, h, write_only, no_init };
        accessor aC{ C, h, write_only, no_init };
        h.parallel_for(N, [=](id<1> i) {
            aA[i] = { 1,1,1,1 };
            aB[i] = { 30,30,30,30 };
            aC[i] = { 0,0,0,0 };
            });
        });
    Q.submit([&](handler& h) {
        accessor aA{ A, h, read_only };
        accessor aB{ B, h, read_only };
        accessor aC{ C, h, read_write };
        h.parallel_for(N, [=](id<1> i) { aC[i] += aA[i] + aB[i]; });
        });
    Q.submit([&](handler& h) {
        h.require(pC);
        h.parallel_for(N, [=](id<1> i) { pC[i]++; });
        });

    host_accessor result{ C, read_only };
    for (int i = 0; i < N; i++) {
        assert(result[i][0] == N);
        assert(result[i][1] == N);
        assert(result[i][2] == N);
        assert(result[i][3] == N);
    }

    return 0;
}