7987440329

Committed 21 Feb 2024 10:15AM UTC coverage: 94.258% (+0.3%) from 93.968%

Build # 7987440329

Build Type

Pull #249

github

Committed by

fknorr

Commit Message

[RM] rename iggen::impl create/destroy member functions

Pull Request Pull Request #249: [IDAG] Generate and test Instruction Graph

Run Details

2906 of 3278 branches covered (88.65%)

Branch coverage included in aggregate %.

1549 of 1574 new or added lines in 19 files covered. (98.41%)

1 existing line in 1 file now uncovered.

6566 of 6771 relevant lines covered (96.97%)

171190.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.23

/include/fence.h

#pragma once

#include <memory>
#include <type_traits>

#include "buffer_storage.h"
#include "distr_queue.h"
#include "host_object.h"
#include "runtime.h"
#include "task_manager.h"

namespace celerity::detail {

template <typename DataT, int Dims>
class buffer_fence_promise;

} // namespace celerity::detail

namespace celerity {

/**
 * Owned representation of buffer contents as captured by celerity::distr_queue::fence.
 */
template <typename T, int Dims>
class buffer_snapshot {
  public:
        buffer_snapshot() = default;

        buffer_snapshot(buffer_snapshot&& other) noexcept : m_subrange(other.m_subrange), m_data(std::move(other.m_data)) { other.m_subrange = {}; }

        buffer_snapshot& operator=(buffer_snapshot&& other) noexcept {
                m_subrange = other.m_subrange, other.m_subrange = {};
                m_data = std::move(other.m_data);
        }

        id<Dims> get_offset() const { return m_subrange.offset; }

        range<Dims> get_range() const { return m_subrange.range; }

        subrange<Dims> get_subrange() const { return m_subrange; }

        const T* get_data() const { return m_data.get(); }

        inline const T& operator[](const id<Dims> index) const { return m_data[detail::get_linear_index(m_subrange.range, index)]; }

        template <int D = Dims, std::enable_if_t<(D > 0), int> = 0>
        inline decltype(auto) operator[](const size_t index) const {
                return detail::subscript<Dims>(*this, index);
        }

        template <int D = Dims, std::enable_if_t<D == 0, int> = 0>
        inline const T& operator*() const {
                return m_data[0];
        }

  private:
        template <typename U, int Dims2>
        friend class detail::buffer_fence_promise;

        subrange<Dims> m_subrange;
        std::unique_ptr<T[]> m_data; // cannot use std::vector here because of vector<bool> m(

        explicit buffer_snapshot(subrange<Dims> sr, std::unique_ptr<T[]> data) : m_subrange(sr), m_data(std::move(data)) {}
};

} // namespace celerity

namespace celerity::detail {

template <typename T>
class host_object_fence_promise final : public detail::fence_promise {
  public:
        explicit host_object_fence_promise(const experimental::host_object<T>& obj) : m_host_object(obj) {}

        std::future<T> get_future() { return m_promise.get_future(); }

        void fulfill() override { m_promise.set_value(std::as_const(detail::get_host_object_instance(m_host_object))); }

        allocation_id get_user_allocation_id() override { utils::panic("host_object_fence_promise::get_user_allocation_id"); }

  private:
        experimental::host_object<T> m_host_object;
        std::promise<T> m_promise;
};

template <typename DataT, int Dims>
class buffer_fence_promise final : public detail::fence_promise {
  public:
        explicit buffer_fence_promise(const buffer<DataT, Dims>& buf, const subrange<Dims>& sr)
            : m_buffer(buf), m_subrange(sr), m_aid(null_allocation_id /* [IDAG placeholder] */) {}

        std::future<buffer_snapshot<DataT, Dims>> get_future() { return m_promise.get_future(); }

        void fulfill() override {
                const auto access_info =
                    runtime::get_instance().get_buffer_manager().access_host_buffer<DataT, Dims>(get_buffer_id(m_buffer), access_mode::read, m_subrange);
                assert(all_true(id_cast<Dims>(access_info.backing_buffer_offset) <= m_subrange.offset));
                auto data = std::make_unique<DataT[]>(m_subrange.range.size());
                memcpy_strided_host(access_info.ptr, data.get(), sizeof(DataT), range_cast<Dims>(access_info.backing_buffer_range),
                    m_subrange.offset - id_cast<Dims>(access_info.backing_buffer_offset), m_subrange.range, {}, m_subrange.range);
                m_promise.set_value(buffer_snapshot<DataT, Dims>(m_subrange, std::move(data)));
        }

        allocation_id get_user_allocation_id() override { return m_aid; }

  private:
        buffer<DataT, Dims> m_buffer;
        subrange<Dims> m_subrange;
        allocation_id m_aid;
        std::promise<buffer_snapshot<DataT, Dims>> m_promise;
};

} // namespace celerity::detail

namespace celerity {

template <typename T>
std::future<T> distr_queue::fence(const experimental::host_object<T>& obj) {
        static_assert(std::is_object_v<T>, "host_object<T&> and host_object<void> are not allowed as parameters to fence()");

        detail::side_effect_map side_effects;
        side_effects.add_side_effect(detail::get_host_object_id(obj), experimental::side_effect_order::sequential);
        auto promise = std::make_unique<detail::host_object_fence_promise<T>>(obj);
        auto future = promise->get_future();
        detail::runtime::get_instance().get_task_manager().generate_fence_task({}, std::move(side_effects), std::move(promise));
        return future;
}

template <typename DataT, int Dims>
std::future<buffer_snapshot<DataT, Dims>> distr_queue::fence(const buffer<DataT, Dims>& buf, const subrange<Dims>& sr) {
        detail::buffer_access_map access_map;
        access_map.add_access(detail::get_buffer_id(buf),
            std::make_unique<detail::range_mapper<Dims, celerity::access::fixed<Dims>>>(celerity::access::fixed<Dims>(sr), access_mode::read, buf.get_range()));
        auto promise = std::make_unique<detail::buffer_fence_promise<DataT, Dims>>(buf, sr);
        auto future = promise->get_future();
        detail::runtime::get_instance().get_task_manager().generate_fence_task(std::move(access_map), {}, std::move(promise));
        return future;
}

} // namespace celerity

namespace celerity::experimental {

template <typename T, int Dims>
using buffer_snapshot [[deprecated("buffer_snapshot is no longer experimental, use celerity::buffer_snapshot")]] = celerity::buffer_snapshot<T, Dims>;

template <typename... Params>
[[deprecated("fence is no longer experimental, use celerity::distr_queue::fence")]] [[nodiscard]] auto fence(celerity::distr_queue& q, const Params&... args) {
        return q.fence(args...);
}

} // namespace celerity::experimental

1	#pragma once
2
3	#include <memory>
4	#include <type_traits>
5
6	#include "buffer_storage.h"
7	#include "distr_queue.h"
8	#include "host_object.h"
9	#include "runtime.h"
10	#include "task_manager.h"
11
12	namespace celerity::detail {
13
14	template <typename DataT, int Dims>
15	class buffer_fence_promise;
16
17	} // namespace celerity::detail
18
19	namespace celerity {
20
21	/**
22	* Owned representation of buffer contents as captured by celerity::distr_queue::fence.
23	*/
24	template <typename T, int Dims>
25	class buffer_snapshot {
26	public:
27	buffer_snapshot() = default;
28
29	buffer_snapshot(buffer_snapshot&& other) noexcept : m_subrange(other.m_subrange), m_data(std::move(other.m_data)) { other.m_subrange = {}; }	118✔
30
31	buffer_snapshot& operator=(buffer_snapshot&& other) noexcept {
32	m_subrange = other.m_subrange, other.m_subrange = {};
33	m_data = std::move(other.m_data);
34	}
35
36	id<Dims> get_offset() const { return m_subrange.offset; }	1✔
37
38	range<Dims> get_range() const { return m_subrange.range; }	8✔
39
40	subrange<Dims> get_subrange() const { return m_subrange; }	3✔
41
42	const T* get_data() const { return m_data.get(); }	65✔
43
44	inline const T& operator[](const id<Dims> index) const { return m_data[detail::get_linear_index(m_subrange.range, index)]; }	6✔
45
46	template <int D = Dims, std::enable_if_t<(D > 0), int> = 0>
47	inline decltype(auto) operator[](const size_t index) const {	6✔
48	return detail::subscript<Dims>(*this, index);	6✔
49	}
50
51	template <int D = Dims, std::enable_if_t<D == 0, int> = 0>
52	inline const T& operator*() const {	2✔
53	return m_data[0];	2✔
54	}
55
56	private:
57	template <typename U, int Dims2>
58	friend class detail::buffer_fence_promise;
59
60	subrange<Dims> m_subrange;
61	std::unique_ptr<T[]> m_data; // cannot use std::vector here because of vector<bool> m(
62
63	explicit buffer_snapshot(subrange<Dims> sr, std::unique_ptr<T[]> data) : m_subrange(sr), m_data(std::move(data)) {}	17✔
64	};
65
66	} // namespace celerity
67
68	namespace celerity::detail {
69
70	template <typename T>
71	class host_object_fence_promise final : public detail::fence_promise {
72	public:
73	explicit host_object_fence_promise(const experimental::host_object<T>& obj) : m_host_object(obj) {}	10✔
74
75	std::future<T> get_future() { return m_promise.get_future(); }	10✔
76
77	void fulfill() override { m_promise.set_value(std::as_const(detail::get_host_object_instance(m_host_object))); }	10✔
78
NEW 79	allocation_id get_user_allocation_id() override { utils::panic("host_object_fence_promise::get_user_allocation_id"); }	×
80
81	private:
82	experimental::host_object<T> m_host_object;
83	std::promise<T> m_promise;
84	};
85
86	template <typename DataT, int Dims>
87	class buffer_fence_promise final : public detail::fence_promise {
88	public:
89	explicit buffer_fence_promise(const buffer<DataT, Dims>& buf, const subrange<Dims>& sr)	17✔
90	: m_buffer(buf), m_subrange(sr), m_aid(null_allocation_id /* [IDAG placeholder] */) {}	17✔
91
92	std::future<buffer_snapshot<DataT, Dims>> get_future() { return m_promise.get_future(); }	17✔
93
94	void fulfill() override {	17✔
95	const auto access_info =	17✔
96	runtime::get_instance().get_buffer_manager().access_host_buffer<DataT, Dims>(get_buffer_id(m_buffer), access_mode::read, m_subrange);	17✔
97	assert(all_true(id_cast<Dims>(access_info.backing_buffer_offset) <= m_subrange.offset));	17✔
98	auto data = std::make_unique<DataT[]>(m_subrange.range.size());	17✔
99	memcpy_strided_host(access_info.ptr, data.get(), sizeof(DataT), range_cast<Dims>(access_info.backing_buffer_range),	70✔
100	m_subrange.offset - id_cast<Dims>(access_info.backing_buffer_offset), m_subrange.range, {}, m_subrange.range);	49✔
101	m_promise.set_value(buffer_snapshot<DataT, Dims>(m_subrange, std::move(data)));	17✔
102	}	34✔
103
NEW 104	allocation_id get_user_allocation_id() override { return m_aid; }	×
105
106	private:
107	buffer<DataT, Dims> m_buffer;
108	subrange<Dims> m_subrange;
109	allocation_id m_aid;
110	std::promise<buffer_snapshot<DataT, Dims>> m_promise;
111	};
112
113	} // namespace celerity::detail
114
115	namespace celerity {
116
117	template <typename T>
118	std::future<T> distr_queue::fence(const experimental::host_object<T>& obj) {	10✔
119	static_assert(std::is_object_v<T>, "host_object<T&> and host_object<void> are not allowed as parameters to fence()");
120
121	detail::side_effect_map side_effects;	10✔
122	side_effects.add_side_effect(detail::get_host_object_id(obj), experimental::side_effect_order::sequential);	10✔
123	auto promise = std::make_unique<detail::host_object_fence_promise<T>>(obj);	10✔
124	auto future = promise->get_future();	10✔
125	detail::runtime::get_instance().get_task_manager().generate_fence_task({}, std::move(side_effects), std::move(promise));	10✔
126	return future;	20✔
127	}	10✔
128
129	template <typename DataT, int Dims>
130	std::future<buffer_snapshot<DataT, Dims>> distr_queue::fence(const buffer<DataT, Dims>& buf, const subrange<Dims>& sr) {	17✔
131	detail::buffer_access_map access_map;	17✔
132	access_map.add_access(detail::get_buffer_id(buf),	34✔
133	std::make_unique<detail::range_mapper<Dims, celerity::access::fixed<Dims>>>(celerity::access::fixed<Dims>(sr), access_mode::read, buf.get_range()));	34✔
134	auto promise = std::make_unique<detail::buffer_fence_promise<DataT, Dims>>(buf, sr);	17✔
135	auto future = promise->get_future();	17✔
136	detail::runtime::get_instance().get_task_manager().generate_fence_task(std::move(access_map), {}, std::move(promise));	17✔
137	return future;	34✔
138	}	17✔
139
140	} // namespace celerity
141
142	namespace celerity::experimental {
143
144	template <typename T, int Dims>
145	using buffer_snapshot [[deprecated("buffer_snapshot is no longer experimental, use celerity::buffer_snapshot")]] = celerity::buffer_snapshot<T, Dims>;
146
147	template <typename... Params>
148	[[deprecated("fence is no longer experimental, use celerity::distr_queue::fence")]] [[nodiscard]] auto fence(celerity::distr_queue& q, const Params&... args) {	3✔
149	return q.fence(args...);	3✔
150	}
151
152	} // namespace celerity::experimental

celerity / celerity-runtime / 7987440329

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous