7846801124

Committed 09 Feb 2024 04:26PM UTC coverage: 93.748% (-0.2%) from 93.932%

Build # 7846801124

Build Type

Pull #246

github

Committed by

fknorr

Commit Message

Explicitly manage buffer / host object lifetimes in graph generation

task_manager and distributed_graph_generator already maintain state for each
buffer and host object, but keep it around indefinitely even after the
buffer or host object in question is destroyed. Also, neither have
access to buffer debug names and thus can't include that information in
error reports (such as uninitialized-read detection).

This commit adds explicit methods for tracking the creation and
destruction of objects to task_manager, distributed_graph_generator,
scheduler (and now by necessity, runtime, which receives these requests
directly instead of via the buffer_lifetime_callback).

This also removes the recorder -> buffer_manager dependency by
replicating the buffer name (like all other metadata) in both graph
generators. This foreshadows the eventual removal of buffer_manager with
the merge of instruction graph scheduling.

Pull Request Pull Request #246: Explicitly manage buffer / host object lifetimes in graph generation

Run Details

2236 of 2519 branches covered (0.0%)

Branch coverage included in aggregate %.

184 of 185 new or added lines in 15 files covered. (99.46%)

12 existing lines in 1 file now uncovered.

5067 of 5271 relevant lines covered (96.13%)

298349.36 hits per line

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

79.15

/src/recorders.cc

#include "recorders.h"
#include "command.h"
#include "task_manager.h"

namespace celerity::detail {

// Naming

std::string get_buffer_name(const buffer_id bid, const buffer_name_map& accessed_buffer_names) {
        if(const auto it = accessed_buffer_names.find(bid); it != accessed_buffer_names.end()) { return it->second; }
        return {};
}

// Tasks

access_list build_access_list(const task& tsk, const buffer_name_map& accessed_buffer_names, const std::optional<subrange<3>> execution_range = {}) {
        access_list ret;
        const auto exec_range = execution_range.value_or(subrange<3>{tsk.get_global_offset(), tsk.get_global_size()});
        const auto& bam = tsk.get_buffer_access_map();
        for(const auto bid : bam.get_accessed_buffers()) {
                for(const auto mode : bam.get_access_modes(bid)) {
                        const auto req = bam.get_mode_requirements(bid, mode, tsk.get_dimensions(), exec_range, tsk.get_global_size());
                        ret.push_back({bid, get_buffer_name(bid, accessed_buffer_names), mode, req});
                }
        }
        return ret;
}

reduction_list build_reduction_list(const task& tsk, const buffer_name_map& accessed_buffer_names) {
        reduction_list ret;
        for(const auto& reduction : tsk.get_reductions()) {
                ret.push_back({reduction.rid, reduction.bid, get_buffer_name(reduction.bid, accessed_buffer_names), reduction.init_from_buffer});
        }
        return ret;
}

task_dependency_list build_task_dependency_list(const task& tsk) {
        task_dependency_list ret;
        for(const auto& dep : tsk.get_dependencies()) {
                ret.push_back({dep.node->get_id(), dep.kind, dep.origin});
        }
        return ret;
}

task_record::task_record(const task& from, const buffer_name_map& accessed_buffer_names)
    : tid(from.get_id()), debug_name(from.get_debug_name()), cgid(from.get_collective_group_id()), type(from.get_type()), geometry(from.get_geometry()),
      reductions(build_reduction_list(from, accessed_buffer_names)), accesses(build_access_list(from, accessed_buffer_names)),
      side_effect_map(from.get_side_effect_map()), dependencies(build_task_dependency_list(from)) {}

// Commands

command_type get_command_type(const abstract_command& cmd) {
        if(utils::isa<epoch_command>(&cmd)) return command_type::epoch;
        if(utils::isa<horizon_command>(&cmd)) return command_type::horizon;
        if(utils::isa<execution_command>(&cmd)) return command_type::execution;
        if(utils::isa<push_command>(&cmd)) return command_type::push;
        if(utils::isa<await_push_command>(&cmd)) return command_type::await_push;
        if(utils::isa<reduction_command>(&cmd)) return command_type::reduction;
        if(utils::isa<fence_command>(&cmd)) return command_type::fence;
        CELERITY_CRITICAL("Unexpected command type");
        std::terminate();
}

std::optional<epoch_action> get_epoch_action(const abstract_command& cmd) {
        const auto* epoch_cmd = dynamic_cast<const epoch_command*>(&cmd);
        return epoch_cmd != nullptr ? epoch_cmd->get_epoch_action() : std::optional<epoch_action>{};
}

std::optional<subrange<3>> get_execution_range(const abstract_command& cmd) {
        const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd);
        return execution_cmd != nullptr ? execution_cmd->get_execution_range() : std::optional<subrange<3>>{};
}

std::optional<reduction_id> get_reduction_id(const abstract_command& cmd) {
        if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().rid;
        if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().rid;
        if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().rid;
        return {};
}

std::optional<buffer_id> get_buffer_id(const abstract_command& cmd) {
        if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().bid;
        if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().bid;
        if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().bid;
        return {};
}

std::string get_cmd_buffer_name(const std::optional<buffer_id>& bid, const buffer_name_map& accessed_buffer_names) {
        if(bid.has_value()) return get_buffer_name(*bid, accessed_buffer_names);
        return {};
}

std::optional<node_id> get_target(const abstract_command& cmd) {
        if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_target();
        return {};
}

std::optional<region<3>> get_await_region(const abstract_command& cmd) {
        if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_region();
        return {};
}

std::optional<subrange<3>> get_push_range(const abstract_command& cmd) {
        if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_range();
        return {};
}

std::optional<transfer_id> get_transfer_id(const abstract_command& cmd) {
        if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id();
        if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id();
        return {};
}

std::optional<task_id> get_task_id(const abstract_command& cmd) {
        if(const auto* task_cmd = dynamic_cast<const task_command*>(&cmd)) return task_cmd->get_tid();
        return {};
}

const task* get_task_for(const abstract_command& cmd, const task_manager* task_mngr) {
        if(const auto* task_cmd = dynamic_cast<const task_command*>(&cmd)) {
                if(task_mngr != nullptr) {
                        assert(task_mngr->has_task(task_cmd->get_tid()));
                        return task_mngr->get_task(task_cmd->get_tid());
                }
        }
        return nullptr;
}

bool get_is_reduction_initializer(const abstract_command& cmd) {
        if(const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd)) return execution_cmd->is_reduction_initializer();
        return false;
}

access_list build_cmd_access_list(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names) {
        const auto execution_range_a = get_execution_range(cmd);
        const auto execution_range_b = subrange<3>{tsk.get_global_offset(), tsk.get_global_size()};
        const auto execution_range = execution_range_a.value_or(execution_range_b);
        return build_access_list(tsk, accessed_buffer_names, execution_range);
}

command_dependency_list build_command_dependency_list(const abstract_command& cmd) {
        command_dependency_list ret;
        for(const auto& dep : cmd.get_dependencies()) {
                ret.push_back({dep.node->get_cid(), dep.kind, dep.origin});
        }
        return ret;
}

std::string get_task_name(const task& tsk) { return tsk.get_debug_name(); } // TODO remove?

std::optional<task_type> get_task_type(const abstract_command& cmd, const task_manager* task_mngr) {
        if(const auto* tsk = get_task_for(cmd, task_mngr)) return tsk->get_type();
        return {};
}

std::optional<collective_group_id> get_collective_group_id(const abstract_command& cmd, const task_manager* task_mngr) {
        if(const auto* tsk = get_task_for(cmd, task_mngr)) return tsk->get_collective_group_id();
        return {};
}

command_record::command_record(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names)
    : cid(cmd.get_cid()), type(get_command_type(cmd)), epoch_action(get_epoch_action(cmd)), execution_range(get_execution_range(cmd)),
      reduction_id(get_reduction_id(cmd)), buffer_id(get_buffer_id(cmd)), buffer_name(get_cmd_buffer_name(buffer_id, accessed_buffer_names)),
      target(get_target(cmd)), await_region(get_await_region(cmd)), push_range(get_push_range(cmd)), transfer_id(get_transfer_id(cmd)),
      task_id(get_task_id(cmd)), task_geometry(tsk.get_geometry()), is_reduction_initializer(get_is_reduction_initializer(cmd)),
      accesses(build_cmd_access_list(cmd, tsk, accessed_buffer_names)), reductions(build_reduction_list(tsk, accessed_buffer_names)),
      side_effects(tsk.get_side_effect_map()), dependencies(build_command_dependency_list(cmd)), task_name(get_task_name(tsk)), task_type(tsk.get_type()),
      collective_group_id(tsk.get_collective_group_id()) {}

} // namespace celerity::detail

1	#include "recorders.h"
2	#include "command.h"
3	#include "task_manager.h"
4
5	namespace celerity::detail {
6
7	// Naming
8
9	std::string get_buffer_name(const buffer_id bid, const buffer_name_map& accessed_buffer_names) {	2,368✔
10	if(const auto it = accessed_buffer_names.find(bid); it != accessed_buffer_names.end()) { return it->second; }	2,368✔
11	return {};	86✔
12	}
13
14	// Tasks
15
16	access_list build_access_list(const task& tsk, const buffer_name_map& accessed_buffer_names, const std::optional<subrange<3>> execution_range = {}) {	2,438✔
17	access_list ret;	2,438✔
18	const auto exec_range = execution_range.value_or(subrange<3>{tsk.get_global_offset(), tsk.get_global_size()});	2,438✔
19	const auto& bam = tsk.get_buffer_access_map();	2,438✔
20	for(const auto bid : bam.get_accessed_buffers()) {	3,899✔
21	for(const auto mode : bam.get_access_modes(bid)) {	3,580✔
22	const auto req = bam.get_mode_requirements(bid, mode, tsk.get_dimensions(), exec_range, tsk.get_global_size());	2,119✔
23	ret.push_back({bid, get_buffer_name(bid, accessed_buffer_names), mode, req});	2,119✔
24	}	3,580✔
25	}	2,438✔
26	return ret;	2,438✔
27	}	×
28
29	reduction_list build_reduction_list(const task& tsk, const buffer_name_map& accessed_buffer_names) {	2,438✔
30	reduction_list ret;	2,438✔
31	for(const auto& reduction : tsk.get_reductions()) {	2,518✔
32	ret.push_back({reduction.rid, reduction.bid, get_buffer_name(reduction.bid, accessed_buffer_names), reduction.init_from_buffer});	80✔
33	}
34	return ret;	2,438✔
35	}	×
36
37	task_dependency_list build_task_dependency_list(const task& tsk) {	1,141✔
38	task_dependency_list ret;	1,141✔
39	for(const auto& dep : tsk.get_dependencies()) {	3,174✔
40	ret.push_back({dep.node->get_id(), dep.kind, dep.origin});	2,033✔
41	}
42	return ret;	1,141✔
43	}	×
44
45	task_record::task_record(const task& from, const buffer_name_map& accessed_buffer_names)	1,141✔
46	: tid(from.get_id()), debug_name(from.get_debug_name()), cgid(from.get_collective_group_id()), type(from.get_type()), geometry(from.get_geometry()),	1,141✔
47	reductions(build_reduction_list(from, accessed_buffer_names)), accesses(build_access_list(from, accessed_buffer_names)),	1,141✔
48	side_effect_map(from.get_side_effect_map()), dependencies(build_task_dependency_list(from)) {}	1,141✔
49
50	// Commands
51
52	command_type get_command_type(const abstract_command& cmd) {	1,297✔
53	if(utils::isa<epoch_command>(&cmd)) return command_type::epoch;	1,297✔
54	if(utils::isa<horizon_command>(&cmd)) return command_type::horizon;	1,080✔
55	if(utils::isa<execution_command>(&cmd)) return command_type::execution;	861✔
56	if(utils::isa<push_command>(&cmd)) return command_type::push;	173✔
57	if(utils::isa<await_push_command>(&cmd)) return command_type::await_push;	88✔
58	if(utils::isa<reduction_command>(&cmd)) return command_type::reduction;	26✔
59	if(utils::isa<fence_command>(&cmd)) return command_type::fence;	4!
60	CELERITY_CRITICAL("Unexpected command type");	×
61	std::terminate();	×
62	}
63
64	std::optional<epoch_action> get_epoch_action(const abstract_command& cmd) {	1,297✔
65	const auto* epoch_cmd = dynamic_cast<const epoch_command*>(&cmd);	1,297!
66	return epoch_cmd != nullptr ? epoch_cmd->get_epoch_action() : std::optional<epoch_action>{};	2,594✔
67	}
68
69	std::optional<subrange<3>> get_execution_range(const abstract_command& cmd) {	2,594✔
70	const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd);	2,594!
71	return execution_cmd != nullptr ? execution_cmd->get_execution_range() : std::optional<subrange<3>>{};	2,594✔
72	}
73
74	std::optional<reduction_id> get_reduction_id(const abstract_command& cmd) {	1,297✔
75	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().rid;	1,297!
76	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().rid;	1,212!
77	if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().rid;	1,150!
78	return {};	1,128✔
79	}
80
81	std::optional<buffer_id> get_buffer_id(const abstract_command& cmd) {	1,297✔
82	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().bid;	1,297!
83	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().bid;	1,212!
84	if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().bid;	1,150!
85	return {};	1,128✔
86	}
87
88	std::string get_cmd_buffer_name(const std::optional<buffer_id>& bid, const buffer_name_map& accessed_buffer_names) {	1,297✔
89	if(bid.has_value()) return get_buffer_name(*bid, accessed_buffer_names);	1,297✔
90	return {};	1,128✔
91	}
92
93	std::optional<node_id> get_target(const abstract_command& cmd) {	1,297✔
94	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_target();	1,297!
95	return {};	1,212✔
96	}
97
98	std::optional<region<3>> get_await_region(const abstract_command& cmd) {	1,297✔
99	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_region();	1,297!
100	return {};	1,235✔
101	}
102
103	std::optional<subrange<3>> get_push_range(const abstract_command& cmd) {	1,297✔
104	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_range();	1,297!
105	return {};	1,212✔
106	}
107
108	std::optional<transfer_id> get_transfer_id(const abstract_command& cmd) {	1,297✔
109	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id();	1,297!
110	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id();	1,212!
111	return {};	1,150✔
112	}
113
114	std::optional<task_id> get_task_id(const abstract_command& cmd) {	1,297✔
115	if(const auto* task_cmd = dynamic_cast<const task_command*>(&cmd)) return task_cmd->get_tid();	1,297!
116	return {};	169✔
117	}
118
NEW UNCOV 119	const task* get_task_for(const abstract_command& cmd, const task_manager* task_mngr) {	×
UNCOV 120	if(const auto* task_cmd = dynamic_cast<const task_command*>(&cmd)) {	×
UNCOV 121	if(task_mngr != nullptr) {	×
UNCOV 122	assert(task_mngr->has_task(task_cmd->get_tid()));	×
UNCOV 123	return task_mngr->get_task(task_cmd->get_tid());	×
124	}
125	}
UNCOV 126	return nullptr;	×
127	}
128
129	bool get_is_reduction_initializer(const abstract_command& cmd) {	1,297✔
130	if(const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd)) return execution_cmd->is_reduction_initializer();	1,297!
131	return false;	609✔
132	}
133
134	access_list build_cmd_access_list(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names) {	1,297✔
135	const auto execution_range_a = get_execution_range(cmd);	1,297✔
136	const auto execution_range_b = subrange<3>{tsk.get_global_offset(), tsk.get_global_size()};	1,297✔
137	const auto execution_range = execution_range_a.value_or(execution_range_b);	1,297✔
138	return build_access_list(tsk, accessed_buffer_names, execution_range);	2,594✔
139	}
140
141	command_dependency_list build_command_dependency_list(const abstract_command& cmd) {	1,297✔
142	command_dependency_list ret;	1,297✔
143	for(const auto& dep : cmd.get_dependencies()) {	3,496✔
144	ret.push_back({dep.node->get_cid(), dep.kind, dep.origin});	2,199✔
145	}
146	return ret;	1,297✔
147	}	×
148
149	std::string get_task_name(const task& tsk) { return tsk.get_debug_name(); } // TODO remove?	1,297✔
150
UNCOV 151	std::optional<task_type> get_task_type(const abstract_command& cmd, const task_manager* task_mngr) {	×
UNCOV 152	if(const auto* tsk = get_task_for(cmd, task_mngr)) return tsk->get_type();	×
UNCOV 153	return {};	×
154	}
155
UNCOV 156	std::optional<collective_group_id> get_collective_group_id(const abstract_command& cmd, const task_manager* task_mngr) {	×
UNCOV 157	if(const auto* tsk = get_task_for(cmd, task_mngr)) return tsk->get_collective_group_id();	×
UNCOV 158	return {};	×
159	}
160
161	command_record::command_record(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names)	1,297✔
162	: cid(cmd.get_cid()), type(get_command_type(cmd)), epoch_action(get_epoch_action(cmd)), execution_range(get_execution_range(cmd)),	1,297✔
163	reduction_id(get_reduction_id(cmd)), buffer_id(get_buffer_id(cmd)), buffer_name(get_cmd_buffer_name(buffer_id, accessed_buffer_names)),	1,297✔
164	target(get_target(cmd)), await_region(get_await_region(cmd)), push_range(get_push_range(cmd)), transfer_id(get_transfer_id(cmd)),	1,297✔
165	task_id(get_task_id(cmd)), task_geometry(tsk.get_geometry()), is_reduction_initializer(get_is_reduction_initializer(cmd)),	1,297✔
166	accesses(build_cmd_access_list(cmd, tsk, accessed_buffer_names)), reductions(build_reduction_list(tsk, accessed_buffer_names)),	1,297✔
167	side_effects(tsk.get_side_effect_map()), dependencies(build_command_dependency_list(cmd)), task_name(get_task_name(tsk)), task_type(tsk.get_type()),	1,297✔
168	collective_group_id(tsk.get_collective_group_id()) {}	1,297✔
169
170	} // namespace celerity::detail

celerity / celerity-runtime / 7846801124

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