18558780296

Committed 16 Oct 2025 10:49AM UTC coverage: 61.233% (-0.3%) from 61.523%

Build # 18558780296

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #279 from daisytuner/ext-prefix

Separate Dominance Analysis and Codegen for Linker with Prefixes

Run Details

62 of 95 new or added lines in 26 files covered. (65.26%)

13 existing lines in 7 files now uncovered.

8981 of 14667 relevant lines covered (61.23%)

98.73 hits per line

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

4.41

/src/passes/dataflow/byte_reference_elimination.cpp

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

#include "sdfg/analysis/users.h"
#include "sdfg/analysis/dominance_analysis.h"
#include "sdfg/types/utils.h"

namespace sdfg {
namespace passes {

ByteReferenceElimination::ByteReferenceElimination()
    : Pass() {

      };

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

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

    auto& sdfg = builder.subject();
    auto& users_analysis = analysis_manager.get<analysis::Users>();
    auto& dominance_analysis = analysis_manager.get<analysis::DominanceAnalysis>();

    for (auto& name : sdfg.containers()) {
        if (!sdfg.is_transient(name)) {
            continue;
        }
        if (!dynamic_cast<const types::Pointer*>(&sdfg.type(name))) {
            continue;
        }
        auto views = users_analysis.views(name);
        auto moves = users_analysis.moves(name);
        if (moves.size() != 1) {
            continue;
        }
        auto move = *moves.begin();
        auto move_node = dynamic_cast<data_flow::AccessNode*>(move->element());
        auto& move_graph = move_node->get_parent();
        auto& move_edge = *move_graph.in_edges(*move_node).begin();
        auto& move_type = move_edge.base_type();
        if (move_type.type_id() != types::TypeID::Pointer) {
            continue;
        }
        auto& move_pointer_type = static_cast<const types::Pointer&>(move_type);
        if (!move_pointer_type.has_pointee_type()) {
            continue;
        }
        auto& move_pointee_type = move_pointer_type.pointee_type();
        if (move_pointee_type.type_id() == types::TypeID::Scalar) {
            if (move_pointee_type.primitive_type() == types::PrimitiveType::Int8) {
                continue;
            }
        }
        auto move_pointee_type_bytes = types::get_type_size(move_pointee_type, false);
        if (move_pointee_type_bytes.is_null() || !SymEngine::is_a<SymEngine::Integer>(*move_pointee_type_bytes)) {
            continue;
        }
        auto move_pointee_type_bytes_int = SymEngine::rcp_static_cast<const SymEngine::Integer>(move_pointee_type_bytes
        );

        for (auto& view : views) {
            auto view_node = dynamic_cast<data_flow::AccessNode*>(view->element());
            if (!dominance_analysis.dominates(*move, *view)) {
                continue;
            }

            auto& view_graph = view_node->get_parent();
            auto& view_edge = *view_graph.out_edges(*view_node).begin();
            auto& view_type = view_edge.base_type();
            if (view_type.type_id() != types::TypeID::Pointer) {
                continue;
            }

            // Criterion: View must do address calculation in bytes
            auto& view_pointer_type = static_cast<const types::Pointer&>(view_type);
            auto& view_pointee_type = view_pointer_type.pointee_type();
            if (view_pointee_type.type_id() != types::TypeID::Scalar) {
                continue;
            }
            if (view_pointee_type.primitive_type() != types::PrimitiveType::Int8) {
                continue;
            }
            if (view_edge.subset().size() != 1) {
                continue;
            }
            auto offset = view_edge.subset().at(0);
            if (!SymEngine::is_a<SymEngine::Integer>(*offset)) {
                continue;
            }
            auto offset_int = SymEngine::rcp_static_cast<const SymEngine::Integer>(offset);
            if (offset_int->as_int() % move_pointee_type_bytes_int->as_int() != 0 || offset_int->as_int() == 0) {
                continue;
            }

            // Convert bytes into elements
            auto offset_elements = symbolic::div(offset_int, move_pointee_type_bytes);
            view_edge.set_subset({offset_elements});
            view_edge.set_base_type(move_pointer_type);

            applied = true;
        }
    }

    return applied;
};

} // namespace passes
} // namespace sdfg

1	#include "sdfg/passes/dataflow/byte_reference_elimination.h"
2
3	#include "sdfg/analysis/users.h"
4	#include "sdfg/analysis/dominance_analysis.h"
5	#include "sdfg/types/utils.h"
6
7	namespace sdfg {
8	namespace passes {
9
10	ByteReferenceElimination::ByteReferenceElimination()	1✔
11	: Pass() {	1✔
12
13	};	1✔
14
15	std::string ByteReferenceElimination::name() { return "ByteReferenceElimination"; };	×
16
17	bool ByteReferenceElimination::
18	run_pass(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager) {	×
19	bool applied = false;	×
20
21	auto& sdfg = builder.subject();	×
NEW 22	auto& users_analysis = analysis_manager.get<analysis::Users>();	×
NEW 23	auto& dominance_analysis = analysis_manager.get<analysis::DominanceAnalysis>();	×
24
25	for (auto& name : sdfg.containers()) {	×
26	if (!sdfg.is_transient(name)) {	×
27	continue;	×
28	}
29	if (!dynamic_cast<const types::Pointer*>(&sdfg.type(name))) {	×
30	continue;	×
31	}
NEW 32	auto views = users_analysis.views(name);	×
NEW 33	auto moves = users_analysis.moves(name);	×
34	if (moves.size() != 1) {	×
35	continue;	×
36	}
37	auto move = *moves.begin();	×
38	auto move_node = dynamic_cast<data_flow::AccessNode*>(move->element());	×
39	auto& move_graph = move_node->get_parent();	×
40	auto& move_edge = move_graph.in_edges(move_node).begin();	×
41	auto& move_type = move_edge.base_type();	×
42	if (move_type.type_id() != types::TypeID::Pointer) {	×
43	continue;	×
44	}
45	auto& move_pointer_type = static_cast<const types::Pointer&>(move_type);	×
46	if (!move_pointer_type.has_pointee_type()) {	×
47	continue;	×
48	}
49	auto& move_pointee_type = move_pointer_type.pointee_type();	×
50	if (move_pointee_type.type_id() == types::TypeID::Scalar) {	×
51	if (move_pointee_type.primitive_type() == types::PrimitiveType::Int8) {	×
52	continue;	×
53	}
54	}	×
55	auto move_pointee_type_bytes = types::get_type_size(move_pointee_type, false);	×
56	if (move_pointee_type_bytes.is_null() \|\| !SymEngine::is_a<SymEngine::Integer>(*move_pointee_type_bytes)) {	×
57	continue;	×
58	}
59	auto move_pointee_type_bytes_int = SymEngine::rcp_static_cast<const SymEngine::Integer>(move_pointee_type_bytes	×
60	);
61
62	for (auto& view : views) {	×
63	auto view_node = dynamic_cast<data_flow::AccessNode*>(view->element());	×
NEW 64	if (!dominance_analysis.dominates(move, view)) {	×
65	continue;	×
66	}
67
68	auto& view_graph = view_node->get_parent();	×
69	auto& view_edge = view_graph.out_edges(view_node).begin();	×
70	auto& view_type = view_edge.base_type();	×
71	if (view_type.type_id() != types::TypeID::Pointer) {	×
72	continue;	×
73	}
74
75	// Criterion: View must do address calculation in bytes
76	auto& view_pointer_type = static_cast<const types::Pointer&>(view_type);	×
77	auto& view_pointee_type = view_pointer_type.pointee_type();	×
78	if (view_pointee_type.type_id() != types::TypeID::Scalar) {	×
79	continue;	×
80	}
81	if (view_pointee_type.primitive_type() != types::PrimitiveType::Int8) {	×
82	continue;	×
83	}
84	if (view_edge.subset().size() != 1) {	×
85	continue;	×
86	}
87	auto offset = view_edge.subset().at(0);	×
88	if (!SymEngine::is_a<SymEngine::Integer>(*offset)) {	×
89	continue;	×
90	}
91	auto offset_int = SymEngine::rcp_static_cast<const SymEngine::Integer>(offset);	×
92	if (offset_int->as_int() % move_pointee_type_bytes_int->as_int() != 0 \|\| offset_int->as_int() == 0) {	×
93	continue;	×
94	}
95
96	// Convert bytes into elements
97	auto offset_elements = symbolic::div(offset_int, move_pointee_type_bytes);	×
98	view_edge.set_subset({offset_elements});	×
99	view_edge.set_base_type(move_pointer_type);	×
100
101	applied = true;	×
102	}	×
103	}	×
104
105	return applied;	×
106	};	×
107
108	} // namespace passes
109	} // namespace sdfg

daisytuner / sdfglib / 18558780296

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