15044057891

Committed 15 May 2025 11:42AM UTC coverage: 59.37% (+1.8%) from 57.525%

Build # 15044057891

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14 from daisytuner/sanitizers

enables sanitizer on unit tests

Run Details

63 of 67 new or added lines in 47 files covered. (94.03%)

570 existing lines in 62 files now uncovered.

7356 of 12390 relevant lines covered (59.37%)

505.93 hits per line

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

91.3

/src/passes/dataflow/trivial_array_elimination.cpp

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

#include <cassert>

#include "sdfg/data_flow/access_node.h"
#include "sdfg/symbolic/symbolic.h"
#include "sdfg/types/array.h"
#include "sdfg/types/type.h"
#include "sdfg/types/utils.h"

namespace sdfg {
namespace passes {

TrivialArrayElimination::TrivialArrayElimination()
    : Pass(){

      };

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

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

    auto& sdfg = builder.subject();
    auto& users = analysis_manager.get<analysis::Users>();
    for (auto& name : sdfg.containers()) {
        // Criterion: Only transients
        if (!sdfg.is_transient(name)) {
            continue;
        }
        if (!users.moves(name).empty() || !users.views(name).empty()) {
            continue;
        }

        // Criterion: Data type must be or contain arrays
        std::unique_ptr<types::IType> type = sdfg.type(name).clone();
        uint depth = 0;
        bool has_trivial_dimension = false;
        while (auto atype = dynamic_cast<const types::Array*>(type.get())) {
            if (symbolic::eq(atype->num_elements(), symbolic::one())) {
                has_trivial_dimension = true;
                break;
            }
            type = atype->element_type().clone();
            depth++;
        }

        if (!has_trivial_dimension) {
            continue;
        }

        // Construct new type
        auto atype = static_cast<const types::Array*>(type.get());
        std::unique_ptr<types::IType> inner_type = atype->element_type().clone();
        std::unique_ptr<types::IType> new_type =
            types::recombine_array_type(sdfg.type(name), depth, *inner_type.get());

        // Replace data type
        builder.change_type(name, *new_type.get());

        // Replace all reads
        for (auto& user : users.reads(name)) {
            auto access_node = dynamic_cast<data_flow::AccessNode*>(user->element());
            assert(access_node != nullptr && "Expected AccessNode");

            auto& graph = access_node->get_parent();
            for (auto& oedge : graph.out_edges(*access_node)) {
                auto& subset = oedge.subset();
                subset.erase(subset.begin() + depth);
            }
        }
        // Replace all writes
        for (auto& user : users.writes(name)) {
            auto access_node = dynamic_cast<data_flow::AccessNode*>(user->element());
            assert(access_node != nullptr && "Expected AccessNode");

            auto& graph = access_node->get_parent();
            for (auto& iedge : graph.in_edges(*access_node)) {
                auto& subset = iedge.subset();
                subset.erase(subset.begin() + depth);
            }
        }

        applied = true;
    }

    return applied;
};

}  // namespace passes
}  // namespace sdfg

1	#include "sdfg/passes/dataflow/trivial_array_elimination.h"
2
3	#include <cassert>
4
5	#include "sdfg/data_flow/access_node.h"
6	#include "sdfg/symbolic/symbolic.h"
7	#include "sdfg/types/array.h"
8	#include "sdfg/types/type.h"
9	#include "sdfg/types/utils.h"
10
11	namespace sdfg {
12	namespace passes {
13
14	TrivialArrayElimination::TrivialArrayElimination()	6✔
15	: Pass(){	6✔
16
17	};	6✔
18
19	std::string TrivialArrayElimination::name() { return "TrivialArrayElimination"; };	×
20
21	bool TrivialArrayElimination::run_pass(builder::StructuredSDFGBuilder& builder,	6✔
22	analysis::AnalysisManager& analysis_manager) {
23	bool applied = false;	6✔
24
25	auto& sdfg = builder.subject();	6✔
26	auto& users = analysis_manager.get<analysis::Users>();	6✔
27	for (auto& name : sdfg.containers()) {	18✔
28	// Criterion: Only transients
29	if (!sdfg.is_transient(name)) {	12✔
UNCOV 30	continue;	×
31	}
32	if (!users.moves(name).empty() \|\| !users.views(name).empty()) {	12✔
33	continue;	×
34	}
35
36	// Criterion: Data type must be or contain arrays
37	std::unique_ptr<types::IType> type = sdfg.type(name).clone();	12✔
38	uint depth = 0;	12✔
39	bool has_trivial_dimension = false;	12✔
40	while (auto atype = dynamic_cast<const types::Array*>(type.get())) {	20✔
41	if (symbolic::eq(atype->num_elements(), symbolic::one())) {	14✔
42	has_trivial_dimension = true;	6✔
43	break;	6✔
44	}
45	type = atype->element_type().clone();	8✔
46	depth++;	8✔
47	}
48
49	if (!has_trivial_dimension) {	12✔
50	continue;	6✔
51	}
52
53	// Construct new type
54	auto atype = static_cast<const types::Array*>(type.get());	6✔
55	std::unique_ptr<types::IType> inner_type = atype->element_type().clone();	6✔
56	std::unique_ptr<types::IType> new_type =
57	types::recombine_array_type(sdfg.type(name), depth, *inner_type.get());	6✔
58
59	// Replace data type
60	builder.change_type(name, *new_type.get());	6✔
61
62	// Replace all reads
63	for (auto& user : users.reads(name)) {	9✔
64	auto access_node = dynamic_cast<data_flow::AccessNode*>(user->element());	3✔
65	assert(access_node != nullptr && "Expected AccessNode");	6✔
66
67	auto& graph = access_node->get_parent();	3✔
68	for (auto& oedge : graph.out_edges(*access_node)) {	6✔
69	auto& subset = oedge.subset();	3✔
70	subset.erase(subset.begin() + depth);	3✔
71	}
72	}
73	// Replace all writes
74	for (auto& user : users.writes(name)) {	9✔
75	auto access_node = dynamic_cast<data_flow::AccessNode*>(user->element());	3✔
76	assert(access_node != nullptr && "Expected AccessNode");	6✔
77
78	auto& graph = access_node->get_parent();	3✔
79	for (auto& iedge : graph.in_edges(*access_node)) {	6✔
80	auto& subset = iedge.subset();	3✔
81	subset.erase(subset.begin() + depth);	3✔
82	}
83	}
84
85	applied = true;	6✔
86	}	12✔
87
88	return applied;	6✔
UNCOV 89	};	×
90
91	} // namespace passes
92	} // namespace sdfg

daisytuner / sdfglib / 15044057891

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