7848944582

Committed 09 Feb 2024 07:55PM UTC coverage: 94.026% (+0.09%) from 93.932%

Build # 7848944582

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

2237 of 2509 branches covered (0.0%)

Branch coverage included in aggregate %.

192 of 193 new or added lines in 15 files covered. (99.48%)

6 existing lines in 3 files now uncovered.

5066 of 5258 relevant lines covered (96.35%)

220506.71 hits per line

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

88.83

/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;
        utils::panic("Unexpected command type");
}

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 {};
}

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?

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✔
UNCOV 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!
NEW UNCOV 60	utils::panic("Unexpected command type");	×
61	}
62
63	std::optional<epoch_action> get_epoch_action(const abstract_command& cmd) {	1,297✔
64	const auto* epoch_cmd = dynamic_cast<const epoch_command*>(&cmd);	1,297!
65	return epoch_cmd != nullptr ? epoch_cmd->get_epoch_action() : std::optional<epoch_action>{};	2,594✔
66	}
67
68	std::optional<subrange<3>> get_execution_range(const abstract_command& cmd) {	2,594✔
69	const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd);	2,594!
70	return execution_cmd != nullptr ? execution_cmd->get_execution_range() : std::optional<subrange<3>>{};	2,594✔
71	}
72
73	std::optional<reduction_id> get_reduction_id(const abstract_command& cmd) {	1,297✔
74	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().rid;	1,297!
75	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().rid;	1,212!
76	if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().rid;	1,150!
77	return {};	1,128✔
78	}
79
80	std::optional<buffer_id> get_buffer_id(const abstract_command& cmd) {	1,297✔
81	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id().bid;	1,297!
82	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id().bid;	1,212!
83	if(const auto* reduction_cmd = dynamic_cast<const reduction_command*>(&cmd)) return reduction_cmd->get_reduction_info().bid;	1,150!
84	return {};	1,128✔
85	}
86
87	std::string get_cmd_buffer_name(const std::optional<buffer_id>& bid, const buffer_name_map& accessed_buffer_names) {	1,297✔
88	if(bid.has_value()) return get_buffer_name(*bid, accessed_buffer_names);	1,297✔
89	return {};	1,128✔
90	}
91
92	std::optional<node_id> get_target(const abstract_command& cmd) {	1,297✔
93	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_target();	1,297!
94	return {};	1,212✔
95	}
96
97	std::optional<region<3>> get_await_region(const abstract_command& cmd) {	1,297✔
98	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_region();	1,297!
99	return {};	1,235✔
100	}
101
102	std::optional<subrange<3>> get_push_range(const abstract_command& cmd) {	1,297✔
103	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_range();	1,297!
104	return {};	1,212✔
105	}
106
107	std::optional<transfer_id> get_transfer_id(const abstract_command& cmd) {	1,297✔
108	if(const auto* push_cmd = dynamic_cast<const push_command*>(&cmd)) return push_cmd->get_transfer_id();	1,297!
109	if(const auto* await_push_cmd = dynamic_cast<const await_push_command*>(&cmd)) return await_push_cmd->get_transfer_id();	1,212!
110	return {};	1,150✔
111	}
112
113	std::optional<task_id> get_task_id(const abstract_command& cmd) {	1,297✔
114	if(const auto* task_cmd = dynamic_cast<const task_command*>(&cmd)) return task_cmd->get_tid();	1,297!
115	return {};	169✔
116	}
117
118	bool get_is_reduction_initializer(const abstract_command& cmd) {	1,297✔
119	if(const auto* execution_cmd = dynamic_cast<const execution_command*>(&cmd)) return execution_cmd->is_reduction_initializer();	1,297!
120	return false;	609✔
121	}
122
123	access_list build_cmd_access_list(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names) {	1,297✔
124	const auto execution_range_a = get_execution_range(cmd);	1,297✔
125	const auto execution_range_b = subrange<3>{tsk.get_global_offset(), tsk.get_global_size()};	1,297✔
126	const auto execution_range = execution_range_a.value_or(execution_range_b);	1,297✔
127	return build_access_list(tsk, accessed_buffer_names, execution_range);	2,594✔
128	}
129
130	command_dependency_list build_command_dependency_list(const abstract_command& cmd) {	1,297✔
131	command_dependency_list ret;	1,297✔
132	for(const auto& dep : cmd.get_dependencies()) {	3,496✔
133	ret.push_back({dep.node->get_cid(), dep.kind, dep.origin});	2,199✔
134	}
135	return ret;	1,297✔
136	}	×
137
138	std::string get_task_name(const task& tsk) { return tsk.get_debug_name(); } // TODO remove?	1,297✔
139
140	command_record::command_record(const abstract_command& cmd, const task& tsk, const buffer_name_map& accessed_buffer_names)	1,297✔
141	: cid(cmd.get_cid()), type(get_command_type(cmd)), epoch_action(get_epoch_action(cmd)), execution_range(get_execution_range(cmd)),	1,297✔
142	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✔
143	target(get_target(cmd)), await_region(get_await_region(cmd)), push_range(get_push_range(cmd)), transfer_id(get_transfer_id(cmd)),	1,297✔
144	task_id(get_task_id(cmd)), task_geometry(tsk.get_geometry()), is_reduction_initializer(get_is_reduction_initializer(cmd)),	1,297✔
145	accesses(build_cmd_access_list(cmd, tsk, accessed_buffer_names)), reductions(build_reduction_list(tsk, accessed_buffer_names)),	1,297✔
146	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✔
147	collective_group_id(tsk.get_collective_group_id()) {}	1,297✔
148
149	} // namespace celerity::detail

celerity / celerity-runtime / 7848944582

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