17621055299

Committed 10 Sep 2025 05:00PM UTC coverage: 59.755% (+0.6%) from 59.145%

Build # 17621055299

Build Type

Pull #210

github

Committed by

web-flow

Commit Message

Merge 6e7cc1401 into b8fdeb232

Pull Request Pull Request #210: New debug info

Run Details

777 of 1111 new or added lines in 46 files covered. (69.94%)

11 existing lines in 11 files now uncovered.

9755 of 16325 relevant lines covered (59.75%)

115.06 hits per line

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

0.0

/src/data_flow/library_nodes/math/ml/dropout.cpp

#include "sdfg/data_flow/library_nodes/math/ml/dropout.h"

#include "sdfg/analysis/analysis.h"
#include "sdfg/builder/structured_sdfg_builder.h"

#include "sdfg/analysis/scope_analysis.h"

namespace sdfg {
namespace math {
namespace ml {

DropoutNode::DropoutNode(
    size_t element_id, const DebugInfoRegion& debug_info, const graph::Vertex vertex, data_flow::DataFlowGraph& parent
)
    : MathNode(
          element_id,
          debug_info,
          vertex,
          parent,
          LibraryNodeType_Dropout,
          {"output", "mask"},
          {"data"},
          data_flow::ImplementationType_NONE
      ) {}

void DropoutNode::validate(const Function& function) const {
    // TODO: Implement
}

bool DropoutNode::expand(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {
    auto& dataflow = this->get_parent();
    auto& block = static_cast<structured_control_flow::Block&>(*dataflow.get_parent());
    if (dataflow.in_degree(*this) != 1 || dataflow.out_degree(*this) != 2) {
        return false;
    }
    auto& scope_analysis = analysis_manager.get<analysis::ScopeAnalysis>();
    auto& parent = static_cast<structured_control_flow::Sequence&>(*scope_analysis.parent_scope(&block));
    int index = parent.index(block);
    auto& transition = parent.at(index).second;

    auto& input = this->inputs_.at(0);
    auto& output_data = this->outputs_.at(0);
    auto& output_mask = this->outputs_.at(1);

    auto& iedge = *dataflow.in_edges(*this).begin();
    auto oedge_output = &(*dataflow.out_edges(*this).begin());
    auto oedge_mask = &(*(++dataflow.out_edges(*this).begin()));
    if (oedge_output->src_conn() != "output") {
        std::swap(oedge_output, oedge_mask);
    }

    // Checks if legal
    auto& input_node = static_cast<data_flow::AccessNode&>(iedge.src());
    auto& output_node_output = static_cast<data_flow::AccessNode&>(oedge_output->dst());
    auto& output_node_mask = static_cast<data_flow::AccessNode&>(oedge_mask->dst());
    if (dataflow.in_degree(input_node) != 0 || dataflow.out_degree(output_node_output) != 0 ||
        dataflow.out_degree(output_node_mask) != 0) {
        return false;
    }

    // Add new graph after the current block
    auto& new_sequence = builder.add_sequence_before(
        parent, block, transition.assignments(), builder.debug_info().get_region(block.debug_info().indices())
    );

    // Add maps
    auto& begin_subsets_out = oedge_output->begin_subset();
    auto& end_subsets_out = oedge_output->end_subset();
    data_flow::Subset new_subset;
    structured_control_flow::Sequence* last_scope = &new_sequence;
    structured_control_flow::Map* last_map = nullptr;
    for (size_t i = 0; i < begin_subsets_out.size(); i++) {
        auto& dim_begin = begin_subsets_out[i];
        auto& dim_end = end_subsets_out[i];

        std::string indvar_str = builder.find_new_name("_i");
        builder.add_container(indvar_str, types::Scalar(types::PrimitiveType::UInt64));

        auto indvar = symbolic::symbol(indvar_str);
        auto init = dim_begin;
        auto update = symbolic::add(indvar, symbolic::one());
        auto condition = symbolic::Lt(indvar, symbolic::add(dim_end, symbolic::one()));
        last_map = &builder.add_map(
            *last_scope,
            indvar,
            condition,
            init,
            update,
            structured_control_flow::ScheduleType_Sequential::create(),
            {},
            builder.debug_info().get_region(block.debug_info().indices())
        );
        last_scope = &last_map->root();

        new_subset.push_back(indvar);
    }

    // output = data, mask = 1
    {
        auto& code_block =
            builder.add_block(*last_scope, {}, builder.debug_info().get_region(block.debug_info().indices()));
        auto& input_node_new = builder.add_access(
            code_block, input_node.data(), builder.debug_info().get_region(input_node.debug_info().indices())
        );
        auto& output_node_output_new = builder.add_access(
            code_block,
            output_node_output.data(),
            builder.debug_info().get_region(output_node_output.debug_info().indices())
        );
        auto& output_node_mask_new = builder.add_access(
            code_block,
            output_node_mask.data(),
            builder.debug_info().get_region(output_node_mask.debug_info().indices())
        );

        auto& tasklet_output = builder.add_tasklet(
            code_block, data_flow::assign, "_out", {"_in"}, builder.debug_info().get_region(block.debug_info().indices())
        );
        builder.add_computational_memlet(
            code_block,
            input_node_new,
            tasklet_output,
            "_in",
            new_subset,
            iedge.base_type(),
            builder.debug_info().get_region(block.debug_info().indices())
        );
        builder.add_computational_memlet(
            code_block,
            tasklet_output,
            "_out",
            output_node_output_new,
            new_subset,
            oedge_output->base_type(),
            builder.debug_info().get_region(block.debug_info().indices())
        );

        auto& tasklet_mask = builder.add_tasklet(
            code_block, data_flow::assign, "_out", {"1"}, builder.debug_info().get_region(block.debug_info().indices())
        );
        builder.add_computational_memlet(
            code_block,
            tasklet_mask,
            "_out",
            output_node_mask_new,
            new_subset,
            oedge_mask->base_type(),
            builder.debug_info().get_region(block.debug_info().indices())
        );
    }

    // Clean up block
    builder.remove_memlet(block, iedge);
    builder.remove_memlet(block, *oedge_output);
    builder.remove_memlet(block, *oedge_mask);
    builder.remove_node(block, input_node);
    builder.remove_node(block, output_node_output);
    builder.remove_node(block, output_node_mask);
    builder.remove_node(block, *this);
    builder.remove_child(parent, index + 1);

    return true;
}

std::unique_ptr<data_flow::DataFlowNode> DropoutNode::
    clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {
    return std::unique_ptr<data_flow::DataFlowNode>(new DropoutNode(element_id, this->debug_info(), vertex, parent));
}

} // namespace ml
} // namespace math
} // namespace sdfg

1	#include "sdfg/data_flow/library_nodes/math/ml/dropout.h"
2
3	#include "sdfg/analysis/analysis.h"
4	#include "sdfg/builder/structured_sdfg_builder.h"
5
6	#include "sdfg/analysis/scope_analysis.h"
7
8	namespace sdfg {
9	namespace math {
10	namespace ml {
11
12	DropoutNode::DropoutNode(	×
13	size_t element_id, const DebugInfoRegion& debug_info, const graph::Vertex vertex, data_flow::DataFlowGraph& parent
14	)
15	: MathNode(	×
16	element_id,	×
17	debug_info,	×
18	vertex,	×
19	parent,	×
20	LibraryNodeType_Dropout,
21	{"output", "mask"},	×
22	{"data"},	×
23	data_flow::ImplementationType_NONE
24	) {}	×
25
26	void DropoutNode::validate(const Function& function) const {	×
27	// TODO: Implement
28	}	×
29
30	bool DropoutNode::expand(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {	×
31	auto& dataflow = this->get_parent();	×
32	auto& block = static_cast<structured_control_flow::Block&>(*dataflow.get_parent());	×
33	if (dataflow.in_degree(this) != 1 \|\| dataflow.out_degree(this) != 2) {	×
34	return false;	×
35	}
36	auto& scope_analysis = analysis_manager.get<analysis::ScopeAnalysis>();	×
37	auto& parent = static_cast<structured_control_flow::Sequence&>(*scope_analysis.parent_scope(&block));	×
38	int index = parent.index(block);	×
39	auto& transition = parent.at(index).second;	×
40
41	auto& input = this->inputs_.at(0);	×
42	auto& output_data = this->outputs_.at(0);	×
43	auto& output_mask = this->outputs_.at(1);	×
44
45	auto& iedge = dataflow.in_edges(this).begin();	×
46	auto oedge_output = &(dataflow.out_edges(this).begin());	×
47	auto oedge_mask = &((++dataflow.out_edges(this).begin()));	×
48	if (oedge_output->src_conn() != "output") {	×
49	std::swap(oedge_output, oedge_mask);	×
50	}	×
51
52	// Checks if legal
53	auto& input_node = static_cast<data_flow::AccessNode&>(iedge.src());	×
54	auto& output_node_output = static_cast<data_flow::AccessNode&>(oedge_output->dst());	×
55	auto& output_node_mask = static_cast<data_flow::AccessNode&>(oedge_mask->dst());	×
56	if (dataflow.in_degree(input_node) != 0 \|\| dataflow.out_degree(output_node_output) != 0 \|\|	×
57	dataflow.out_degree(output_node_mask) != 0) {	×
58	return false;	×
59	}
60
61	// Add new graph after the current block
NEW 62	auto& new_sequence = builder.add_sequence_before(	×
NEW 63	parent, block, transition.assignments(), builder.debug_info().get_region(block.debug_info().indices())	×
64	);
65
66	// Add maps
67	auto& begin_subsets_out = oedge_output->begin_subset();	×
68	auto& end_subsets_out = oedge_output->end_subset();	×
69	data_flow::Subset new_subset;	×
70	structured_control_flow::Sequence* last_scope = &new_sequence;	×
71	structured_control_flow::Map* last_map = nullptr;	×
72	for (size_t i = 0; i < begin_subsets_out.size(); i++) {	×
73	auto& dim_begin = begin_subsets_out[i];	×
74	auto& dim_end = end_subsets_out[i];	×
75
76	std::string indvar_str = builder.find_new_name("_i");	×
77	builder.add_container(indvar_str, types::Scalar(types::PrimitiveType::UInt64));	×
78
79	auto indvar = symbolic::symbol(indvar_str);	×
80	auto init = dim_begin;	×
81	auto update = symbolic::add(indvar, symbolic::one());	×
82	auto condition = symbolic::Lt(indvar, symbolic::add(dim_end, symbolic::one()));	×
83	last_map = &builder.add_map(	×
84	*last_scope,	×
85	indvar,
86	condition,
87	init,
88	update,
89	structured_control_flow::ScheduleType_Sequential::create(),	×
90	{},	×
NEW 91	builder.debug_info().get_region(block.debug_info().indices())	×
92	);
93	last_scope = &last_map->root();	×
94
95	new_subset.push_back(indvar);	×
96	}	×
97
98	// output = data, mask = 1
99	{
NEW 100	auto& code_block =	×
NEW 101	builder.add_block(*last_scope, {}, builder.debug_info().get_region(block.debug_info().indices()));	×
NEW 102	auto& input_node_new = builder.add_access(	×
NEW 103	code_block, input_node.data(), builder.debug_info().get_region(input_node.debug_info().indices())	×
104	);
NEW 105	auto& output_node_output_new = builder.add_access(	×
NEW 106	code_block,	×
NEW 107	output_node_output.data(),	×
NEW 108	builder.debug_info().get_region(output_node_output.debug_info().indices())	×
109	);
NEW 110	auto& output_node_mask_new = builder.add_access(	×
NEW 111	code_block,	×
NEW 112	output_node_mask.data(),	×
NEW 113	builder.debug_info().get_region(output_node_mask.debug_info().indices())	×
114	);
115
NEW 116	auto& tasklet_output = builder.add_tasklet(	×
NEW 117	code_block, data_flow::assign, "_out", {"_in"}, builder.debug_info().get_region(block.debug_info().indices())	×
118	);
119	builder.add_computational_memlet(	×
NEW 120	code_block,	×
NEW 121	input_node_new,	×
NEW 122	tasklet_output,	×
NEW 123	"_in",	×
124	new_subset,
NEW 125	iedge.base_type(),	×
NEW 126	builder.debug_info().get_region(block.debug_info().indices())	×
127	);
128	builder.add_computational_memlet(	×
129	code_block,	×
130	tasklet_output,	×
131	"_out",	×
132	output_node_output_new,	×
133	new_subset,
134	oedge_output->base_type(),	×
NEW 135	builder.debug_info().get_region(block.debug_info().indices())	×
136	);
137
NEW 138	auto& tasklet_mask = builder.add_tasklet(	×
NEW 139	code_block, data_flow::assign, "_out", {"1"}, builder.debug_info().get_region(block.debug_info().indices())	×
140	);
141	builder.add_computational_memlet(	×
142	code_block,	×
143	tasklet_mask,	×
144	"_out",	×
145	output_node_mask_new,	×
146	new_subset,
147	oedge_mask->base_type(),	×
NEW 148	builder.debug_info().get_region(block.debug_info().indices())	×
149	);
150	}
151
152	// Clean up block
153	builder.remove_memlet(block, iedge);	×
154	builder.remove_memlet(block, *oedge_output);	×
155	builder.remove_memlet(block, *oedge_mask);	×
156	builder.remove_node(block, input_node);	×
157	builder.remove_node(block, output_node_output);	×
158	builder.remove_node(block, output_node_mask);	×
159	builder.remove_node(block, *this);	×
160	builder.remove_child(parent, index + 1);	×
161
162	return true;	×
163	}	×
164
165	std::unique_ptr<data_flow::DataFlowNode> DropoutNode::
166	clone(size_t element_id, const graph::Vertex vertex, data_flow::DataFlowGraph& parent) const {	×
167	return std::unique_ptr<data_flow::DataFlowNode>(new DropoutNode(element_id, this->debug_info(), vertex, parent));	×
168	}	×
169
170	} // namespace ml
171	} // namespace math
172	} // namespace sdfg

daisytuner / sdfglib / 17621055299

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