20095110671

Committed 10 Dec 2025 10:17AM UTC coverage: 40.342% (-21.5%) from 61.872%

Build # 20095110671

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #384 from daisytuner/viz-struct-subset-fix

Fixing a bug in handling subsets on structures that caused crashes in…

Run Details

13651 of 43783 branches covered (31.18%)

Branch coverage included in aggregate %.

0 of 8 new or added lines in 1 file covered. (0.0%)

250 existing lines in 14 files now uncovered.

11659 of 18956 relevant lines covered (61.51%)

101.74 hits per line

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

54.04

/src/visualizer/visualizer.cpp

#include "sdfg/visualizer/visualizer.h"

#include <cassert>
#include <sstream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include "sdfg/data_flow/tasklet.h"
#include "sdfg/helpers/helpers.h"
#include "sdfg/structured_control_flow/block.h"
#include "sdfg/structured_control_flow/control_flow_node.h"
#include "sdfg/structured_control_flow/for.h"
#include "sdfg/structured_control_flow/if_else.h"
#include "sdfg/structured_control_flow/return.h"
#include "sdfg/structured_control_flow/sequence.h"
#include "sdfg/structured_control_flow/while.h"
#include "sdfg/symbolic/symbolic.h"
#include "sdfg/types/type.h"
#include "symengine/basic.h"

namespace sdfg {
namespace visualizer {

constexpr const char* code_to_string(data_flow::TaskletCode c) {
    switch (c) {
        case data_flow::TaskletCode::assign:
            return "=";
        case data_flow::TaskletCode::int_add:
        case data_flow::TaskletCode::fp_add:
            return "+";
        case data_flow::TaskletCode::int_sub:
        case data_flow::TaskletCode::fp_sub:
            return "-";
        case data_flow::TaskletCode::int_mul:
        case data_flow::TaskletCode::fp_mul:
            return "*";
        case data_flow::TaskletCode::int_udiv:
        case data_flow::TaskletCode::int_sdiv:
        case data_flow::TaskletCode::fp_div:
            return "/";
        case data_flow::TaskletCode::int_urem:
        case data_flow::TaskletCode::int_srem:
        case data_flow::TaskletCode::fp_rem:
            return "%";
        case data_flow::TaskletCode::fp_fma:
            return "fma";
        default:
            return "?";
    };
};

std::string Visualizer::expression(const std::string expr) {
    if (this->replacements_.empty()) return expr;
    std::string res = expr;
    size_t pos1 = 0, pos2 = 0;
    for (std::pair<const std::string, const std::string> replace : this->replacements_) {
        pos2 = res.find(replace.first);
        if (pos2 == res.npos) continue;
        pos1 = 0;
        std::stringstream res_tmp;
        while (pos2 < res.npos) {
            res_tmp << res.substr(pos1, pos2 - pos1) << replace.second;
            pos1 = pos2 + replace.first.size();
            pos2 = res.find(replace.first, pos1);
        }
        if (pos1 < res.npos) res_tmp << res.substr(pos1);
        res = res_tmp.str();
    }
    return res;
}

void Visualizer::visualizeNode(const StructuredSDFG& sdfg, const structured_control_flow::ControlFlowNode& node) {
    if (auto block = dynamic_cast<const structured_control_flow::Block*>(&node)) {
        this->visualizeBlock(sdfg, *block);
        return;
    }
    if (auto sequence = dynamic_cast<const structured_control_flow::Sequence*>(&node)) {
        this->visualizeSequence(sdfg, *sequence);
        return;
    }
    if (auto if_else = dynamic_cast<const structured_control_flow::IfElse*>(&node)) {
        this->visualizeIfElse(sdfg, *if_else);
        return;
    }
    if (auto while_loop = dynamic_cast<const structured_control_flow::While*>(&node)) {
        this->visualizeWhile(sdfg, *while_loop);
        return;
    }
    if (auto loop = dynamic_cast<const structured_control_flow::For*>(&node)) {
        this->visualizeFor(sdfg, *loop);
        return;
    }
    if (auto return_node = dynamic_cast<const structured_control_flow::Return*>(&node)) {
        this->visualizeReturn(sdfg, *return_node);
        return;
    }
    if (auto break_node = dynamic_cast<const structured_control_flow::Break*>(&node)) {
        this->visualizeBreak(sdfg, *break_node);
        return;
    }
    if (auto continue_node = dynamic_cast<const structured_control_flow::Continue*>(&node)) {
        this->visualizeContinue(sdfg, *continue_node);
        return;
    }
    if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(&node)) {
        this->visualizeMap(sdfg, *map_node);
        return;
    }
    throw std::runtime_error("Unsupported control flow node");
}

void Visualizer::visualizeTasklet(data_flow::Tasklet const& tasklet) {
    std::string op = code_to_string(tasklet.code());
    std::vector<std::string> arguments;
    for (size_t i = 0; i < tasklet.inputs().size(); ++i) {
        arguments.push_back(this->expression(tasklet.input(i)));
    }

    if (tasklet.code() == data_flow::TaskletCode::assign) {
        this->stream_ << arguments.at(0);
    } else if (tasklet.code() == data_flow::TaskletCode::fp_fma) {
        if (arguments.size() != 3) throw std::runtime_error("FMA requires 3 arguments");
        this->stream_ << arguments.at(0) << " * " << arguments.at(1) << " + " << arguments.at(2);
    } else {
        this->stream_ << op << "(" << helpers::join(arguments, ", ") << ")";
    }
}

void Visualizer::visualizeForBounds(
    symbolic::Symbol const& indvar,
    symbolic::Expression const& init,
    symbolic::Condition const& condition,
    symbolic::Expression const& update
) {
    this->stream_ << indvar->get_name() << " = " << this->expression(init->__str__()) << "; "
                  << this->expression(condition->__str__()) << "; " << indvar->get_name() << " = "
                  << this->expression(update->__str__());
}

std::string Visualizer::subsetRangeString(data_flow::Subset const& subset, int subIdx) {
    auto& dim = subset.at(subIdx);
    return this->expression(dim->__str__());
}

/// @brief If known, use the type to better visualize structures. Then track the type as far as it goes.
void Visualizer::
    visualizeSubset(Function const& function, data_flow::Subset const& sub, types::IType const* type, int subIdx) {
    if (static_cast<int>(sub.size()) <= subIdx) {
        return;
    }
    if (auto structure_type = dynamic_cast<const types::Structure*>(type)) {
        types::StructureDefinition const& definition = function.structure(structure_type->name());

        auto memberIdx = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(subIdx));
        if (!memberIdx.is_null()) {
            this->stream_ << ".member_" << this->expression(memberIdx->__str__());
            auto& member_type = definition.member_type(memberIdx);
            this->visualizeSubset(function, sub, &member_type, subIdx + 1);
        } else {
            this->stream_ << ".member[" << subsetRangeString(sub, subIdx) << "]";
            this->visualizeSubset(function, sub, nullptr, subIdx + 1);
        }
    } else if (auto array_type = dynamic_cast<const types::Array*>(type)) {
        this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";
        types::IType const& element_type = array_type->element_type();
        this->visualizeSubset(function, sub, &element_type, subIdx + 1);
    } else if (auto pointer_type = dynamic_cast<const types::Pointer*>(type)) {
        this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";
        const types::IType* pointee_type;
        if (pointer_type->has_pointee_type()) {
            pointee_type = &pointer_type->pointee_type();
        } else {
            auto z = symbolic::zero();
            if (!symbolic::eq(sub.at(subIdx), z)) {
                this->stream_ << "#illgl";
            }
            pointee_type = nullptr;
        }
        this->visualizeSubset(function, sub, pointee_type, subIdx + 1);
    } else {
        if (type == nullptr) {
            this->stream_ << "(rogue)";
        }
        this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";
        visualizeSubset(function, sub, nullptr, subIdx + 1);
    }
}

} // namespace visualizer
} // namespace sdfg

1	#include "sdfg/visualizer/visualizer.h"
2
3	#include <cassert>
4	#include <sstream>
5	#include <stdexcept>
6	#include <string>
7	#include <utility>
8	#include <vector>
9
10	#include "sdfg/data_flow/tasklet.h"
11	#include "sdfg/helpers/helpers.h"
12	#include "sdfg/structured_control_flow/block.h"
13	#include "sdfg/structured_control_flow/control_flow_node.h"
14	#include "sdfg/structured_control_flow/for.h"
15	#include "sdfg/structured_control_flow/if_else.h"
16	#include "sdfg/structured_control_flow/return.h"
17	#include "sdfg/structured_control_flow/sequence.h"
18	#include "sdfg/structured_control_flow/while.h"
19	#include "sdfg/symbolic/symbolic.h"
20	#include "sdfg/types/type.h"
21	#include "symengine/basic.h"
22
23	namespace sdfg {
24	namespace visualizer {
25
26	constexpr const char* code_to_string(data_flow::TaskletCode c) {	26✔
27	switch (c) {	26!
28	case data_flow::TaskletCode::assign:
29	return "=";	16✔
30	case data_flow::TaskletCode::int_add:
31	case data_flow::TaskletCode::fp_add:
32	return "+";	4✔
33	case data_flow::TaskletCode::int_sub:
34	case data_flow::TaskletCode::fp_sub:
35	return "-";	1✔
36	case data_flow::TaskletCode::int_mul:
37	case data_flow::TaskletCode::fp_mul:
38	return "*";	4✔
39	case data_flow::TaskletCode::int_udiv:
40	case data_flow::TaskletCode::int_sdiv:
41	case data_flow::TaskletCode::fp_div:
42	return "/";	×
43	case data_flow::TaskletCode::int_urem:
44	case data_flow::TaskletCode::int_srem:
45	case data_flow::TaskletCode::fp_rem:
46	return "%";	×
47	case data_flow::TaskletCode::fp_fma:
48	return "fma";	1✔
49	default:
50	return "?";	×
51	};
52	};	26✔
53
54	std::string Visualizer::expression(const std::string expr) {	121✔
55	if (this->replacements_.empty()) return expr;	121!
56	std::string res = expr;	×
57	size_t pos1 = 0, pos2 = 0;	×
58	for (std::pair<const std::string, const std::string> replace : this->replacements_) {	×
59	pos2 = res.find(replace.first);	×
60	if (pos2 == res.npos) continue;	×
61	pos1 = 0;	×
62	std::stringstream res_tmp;	×
63	while (pos2 < res.npos) {	×
64	res_tmp << res.substr(pos1, pos2 - pos1) << replace.second;	×
65	pos1 = pos2 + replace.first.size();	×
66	pos2 = res.find(replace.first, pos1);	×
67	}
68	if (pos1 < res.npos) res_tmp << res.substr(pos1);	×
69	res = res_tmp.str();	×
70	}	×
71	return res;	×
72	}	121!
73
74	void Visualizer::visualizeNode(const StructuredSDFG& sdfg, const structured_control_flow::ControlFlowNode& node) {	47✔
75	if (auto block = dynamic_cast<const structured_control_flow::Block*>(&node)) {	47!
76	this->visualizeBlock(sdfg, *block);	26✔
77	return;	26✔
78	}
79	if (auto sequence = dynamic_cast<const structured_control_flow::Sequence*>(&node)) {	21!
80	this->visualizeSequence(sdfg, *sequence);	×
81	return;	×
82	}
83	if (auto if_else = dynamic_cast<const structured_control_flow::IfElse*>(&node)) {	21!
84	this->visualizeIfElse(sdfg, *if_else);	3✔
85	return;	3✔
86	}
87	if (auto while_loop = dynamic_cast<const structured_control_flow::While*>(&node)) {	18!
88	this->visualizeWhile(sdfg, *while_loop);	2✔
89	return;	2✔
90	}
91	if (auto loop = dynamic_cast<const structured_control_flow::For*>(&node)) {	16!
92	this->visualizeFor(sdfg, *loop);	10✔
93	return;	10✔
94	}
95	if (auto return_node = dynamic_cast<const structured_control_flow::Return*>(&node)) {	6!
96	this->visualizeReturn(sdfg, *return_node);	1✔
97	return;	1✔
98	}
99	if (auto break_node = dynamic_cast<const structured_control_flow::Break*>(&node)) {	5!
100	this->visualizeBreak(sdfg, *break_node);	1✔
101	return;	1✔
102	}
103	if (auto continue_node = dynamic_cast<const structured_control_flow::Continue*>(&node)) {	4!
104	this->visualizeContinue(sdfg, *continue_node);	1✔
105	return;	1✔
106	}
107	if (auto map_node = dynamic_cast<const structured_control_flow::Map*>(&node)) {	3!
108	this->visualizeMap(sdfg, *map_node);	3✔
109	return;	3✔
110	}
111	throw std::runtime_error("Unsupported control flow node");	×
112	}	47✔
113
114	void Visualizer::visualizeTasklet(data_flow::Tasklet const& tasklet) {	26✔
115	std::string op = code_to_string(tasklet.code());	26!
116	std::vector<std::string> arguments;	26✔
117	for (size_t i = 0; i < tasklet.inputs().size(); ++i) {	63!
118	arguments.push_back(this->expression(tasklet.input(i)));	37!
119	}	37✔
120
121	if (tasklet.code() == data_flow::TaskletCode::assign) {	26!
122	this->stream_ << arguments.at(0);	16!
123	} else if (tasklet.code() == data_flow::TaskletCode::fp_fma) {	26!
124	if (arguments.size() != 3) throw std::runtime_error("FMA requires 3 arguments");	1!
125	this->stream_ << arguments.at(0) << " * " << arguments.at(1) << " + " << arguments.at(2);	1!
126	} else {	1✔
127	this->stream_ << op << "(" << helpers::join(arguments, ", ") << ")";	9!
128	}
129	}	26✔
130
131	void Visualizer::visualizeForBounds(	13✔
132	symbolic::Symbol const& indvar,
133	symbolic::Expression const& init,
134	symbolic::Condition const& condition,
135	symbolic::Expression const& update
136	) {
137	this->stream_ << indvar->get_name() << " = " << this->expression(init->__str__()) << "; "	26!
138	<< this->expression(condition->__str__()) << "; " << indvar->get_name() << " = "	13!
139	<< this->expression(update->__str__());	13!
140	}	13✔
141
142	std::string Visualizer::subsetRangeString(data_flow::Subset const& subset, int subIdx) {	39✔
143	auto& dim = subset.at(subIdx);	39✔
144	return this->expression(dim->__str__());	39!
145	}	×
146
147	/// @brief If known, use the type to better visualize structures. Then track the type as far as it goes.
148	void Visualizer::
149	visualizeSubset(Function const& function, data_flow::Subset const& sub, types::IType const* type, int subIdx) {	95✔
150	if (static_cast<int>(sub.size()) <= subIdx) {	95✔
151	return;	56✔
152	}
153	if (auto structure_type = dynamic_cast<const types::Structure*>(type)) {	39!
154	types::StructureDefinition const& definition = function.structure(structure_type->name());	×
155
NEW 156	auto memberIdx = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(subIdx));	×
NEW 157	if (!memberIdx.is_null()) {	×
NEW 158	this->stream_ << ".member_" << this->expression(memberIdx->__str__());	×
NEW 159	auto& member_type = definition.member_type(memberIdx);	×
NEW 160	this->visualizeSubset(function, sub, &member_type, subIdx + 1);	×
NEW 161	} else {	×
NEW 162	this->stream_ << ".member[" << subsetRangeString(sub, subIdx) << "]";	×
NEW 163	this->visualizeSubset(function, sub, nullptr, subIdx + 1);	×
164	}
165	} else if (auto array_type = dynamic_cast<const types::Array*>(type)) {	39✔
166	this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";	16!
167	types::IType const& element_type = array_type->element_type();	16✔
168	this->visualizeSubset(function, sub, &element_type, subIdx + 1);	16✔
169	} else if (auto pointer_type = dynamic_cast<const types::Pointer*>(type)) {	39✔
170	this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";	22!
171	const types::IType* pointee_type;
172	if (pointer_type->has_pointee_type()) {	22✔
173	pointee_type = &pointer_type->pointee_type();	19✔
174	} else {	19✔
175	auto z = symbolic::zero();	3✔
176	if (!symbolic::eq(sub.at(subIdx), z)) {	3!
177	this->stream_ << "#illgl";	1!
178	}	1✔
179	pointee_type = nullptr;	3✔
180	}	3✔
181	this->visualizeSubset(function, sub, pointee_type, subIdx + 1);	22✔
182	} else {	22✔
183	if (type == nullptr) {	1!
184	this->stream_ << "(rogue)";	1✔
185	}	1✔
186	this->stream_ << "[" << subsetRangeString(sub, subIdx) << "]";	1!
187	visualizeSubset(function, sub, nullptr, subIdx + 1);	1✔
188	}
189	}	95✔
190
191	} // namespace visualizer
192	} // namespace sdfg

daisytuner / sdfglib / 20095110671

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