22151769687

Committed 18 Feb 2026 06:09PM UTC coverage: 64.742%. First build

Build # 22151769687

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #526 from daisytuner/native-ndarray

Python - Native Tensor Support: Update operations to use tensor type

Coverage Stats

2783 of 4104 new or added lines in 42 files covered. (67.81%)

23724 of 36644 relevant lines covered (64.74%)

368.06 hits per line

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

75.38

/sdfg/src/passes/dataflow/dead_data_elimination.cpp

#include "sdfg/passes/dataflow/dead_data_elimination.h"

#include "sdfg/analysis/data_dependency_analysis.h"
#include "sdfg/data_flow/library_nodes/stdlib/malloc.h"

namespace sdfg {
namespace passes {

DeadDataElimination::DeadDataElimination() : Pass(), permissive_(false) {};

DeadDataElimination::DeadDataElimination(bool permissive) : Pass(), permissive_(permissive) {};

std::string DeadDataElimination::name() { return "DeadDataElimination"; };

bool DeadDataElimination::run_pass(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {
    bool applied = false;

    auto& sdfg = builder.subject();
    auto& users = analysis_manager.get<analysis::Users>();
    auto& data_dependency_analysis = analysis_manager.get<analysis::DataDependencyAnalysis>();

    // Eliminate dead code, i.e., never read
    std::unordered_set<std::string> dead;
    for (auto& name : sdfg.containers()) {
        if (!sdfg.is_transient(name)) {
            continue;
        }
        if (users.num_views(name) > 0 || users.num_moves(name) > 0) {
            continue;
        }
        if (users.num_reads(name) == 0 && users.num_writes(name) == 0) {
            dead.insert(name);
            applied = true;
            continue;
        }

        // Writes without reads
        bool all_definitions_removed = (users.num_reads(name) == 0);
        auto raws = data_dependency_analysis.definitions(name);
        for (auto set : raws) {
            if (set.second.size() > 0) {
                all_definitions_removed = false;
                continue;
            }
            if (data_dependency_analysis.is_undefined_user(*set.first)) {
                continue;
            }

            auto write = set.first;
            if (auto transition = dynamic_cast<structured_control_flow::Transition*>(write->element())) {
                transition->assignments().erase(symbolic::symbol(name));
                applied = true;
            } else if (auto access_node = dynamic_cast<data_flow::AccessNode*>(write->element())) {
                auto& graph = access_node->get_parent();

                auto& src = (*graph.in_edges(*access_node).begin()).src();
                if (auto tasklet = dynamic_cast<data_flow::Tasklet*>(&src)) {
                    auto& block = dynamic_cast<structured_control_flow::Block&>(*graph.get_parent());
                    builder.clear_node(block, *tasklet);
                    applied = true;
                } else if (auto library_node = dynamic_cast<data_flow::LibraryNode*>(&src)) {
                    if (!library_node->side_effect() ||
                        (permissive_ && library_node->code() == stdlib::LibraryNodeType_Malloc)) {
                        auto& block = dynamic_cast<structured_control_flow::Block&>(*graph.get_parent());
                        builder.clear_node(block, *library_node);
                        applied = true;
                    } else {
                        all_definitions_removed = false;
                    }
                }
            } else {
                all_definitions_removed = false;
            }
        }

        if (all_definitions_removed) {
            dead.insert(name);
        }
    }

    for (auto& name : dead) {
        builder.remove_container(name);
    }

    return applied;
};

} // namespace passes
} // namespace sdfg

1	#include "sdfg/passes/dataflow/dead_data_elimination.h"
2
3	#include "sdfg/analysis/data_dependency_analysis.h"
4	#include "sdfg/data_flow/library_nodes/stdlib/malloc.h"
5
6	namespace sdfg {
7	namespace passes {
8
9	DeadDataElimination::DeadDataElimination() : Pass(), permissive_(false) {};	38✔
10
11	DeadDataElimination::DeadDataElimination(bool permissive) : Pass(), permissive_(permissive) {};	1✔
12
13	std::string DeadDataElimination::name() { return "DeadDataElimination"; };	×
14
15	bool DeadDataElimination::run_pass(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {	74✔
16	bool applied = false;	74✔
17
18	auto& sdfg = builder.subject();	74✔
19	auto& users = analysis_manager.get<analysis::Users>();	74✔
20	auto& data_dependency_analysis = analysis_manager.get<analysis::DataDependencyAnalysis>();	74✔
21
22	// Eliminate dead code, i.e., never read
23	std::unordered_set<std::string> dead;	74✔
24	for (auto& name : sdfg.containers()) {	679✔
25	if (!sdfg.is_transient(name)) {	679✔
26	continue;	350✔
27	}	350✔
28	if (users.num_views(name) > 0 \|\| users.num_moves(name) > 0) {	329✔
29	continue;	×
30	}	×
31	if (users.num_reads(name) == 0 && users.num_writes(name) == 0) {	329✔
32	dead.insert(name);	5✔
33	applied = true;	5✔
34	continue;	5✔
35	}	5✔
36
37	// Writes without reads
38	bool all_definitions_removed = (users.num_reads(name) == 0);	324✔
39	auto raws = data_dependency_analysis.definitions(name);	324✔
40	for (auto set : raws) {	588✔
41	if (set.second.size() > 0) {	588✔
42	all_definitions_removed = false;	580✔
43	continue;	580✔
44	}	580✔
45	if (data_dependency_analysis.is_undefined_user(*set.first)) {	8✔
46	continue;	×
47	}	×
48
49	auto write = set.first;	8✔
50	if (auto transition = dynamic_cast<structured_control_flow::Transition*>(write->element())) {	8✔
51	transition->assignments().erase(symbolic::symbol(name));	7✔
52	applied = true;	7✔
53	} else if (auto access_node = dynamic_cast<data_flow::AccessNode*>(write->element())) {	7✔
54	auto& graph = access_node->get_parent();	1✔
55
56	auto& src = (graph.in_edges(access_node).begin()).src();	1✔
57	if (auto tasklet = dynamic_cast<data_flow::Tasklet*>(&src)) {	1✔
58	auto& block = dynamic_cast<structured_control_flow::Block&>(*graph.get_parent());	1✔
59	builder.clear_node(block, *tasklet);	1✔
60	applied = true;	1✔
61	} else if (auto library_node = dynamic_cast<data_flow::LibraryNode*>(&src)) {	1✔
NEW 62	if (!library_node->side_effect() \|\|	×
NEW 63	(permissive_ && library_node->code() == stdlib::LibraryNodeType_Malloc)) {	×
64	auto& block = dynamic_cast<structured_control_flow::Block&>(*graph.get_parent());	×
65	builder.clear_node(block, *library_node);	×
66	applied = true;	×
67	} else {	×
68	all_definitions_removed = false;	×
69	}	×
70	}	×
71	} else {	1✔
72	all_definitions_removed = false;	×
73	}	×
74	}	8✔
75
76	if (all_definitions_removed) {	324✔
77	dead.insert(name);	2✔
78	}	2✔
79	}	324✔
80
81	for (auto& name : dead) {	74✔
82	builder.remove_container(name);	7✔
83	}	7✔
84
85	return applied;	74✔
86	};	74✔
87
88	} // namespace passes
89	} // namespace sdfg

daisytuner / docc / 22151769687

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