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

74.38

/src/structured_control_flow/kernel.cpp

#include "sdfg/structured_control_flow/kernel.h"

#include "sdfg/structured_control_flow/sequence.h"
#include "sdfg/symbolic/symbolic.h"

namespace sdfg {
namespace structured_control_flow {

Kernel::Kernel(size_t element_id, const DebugInfo& debug_info, std::string suffix,
               symbolic::Expression gridDim_x_init, symbolic::Expression gridDim_y_init,
               symbolic::Expression gridDim_z_init, symbolic::Expression blockDim_x_init,
               symbolic::Expression blockDim_y_init, symbolic::Expression blockDim_z_init,
               symbolic::Expression blockIdx_x_init, symbolic::Expression blockIdx_y_init,
               symbolic::Expression blockIdx_z_init, symbolic::Expression threadIdx_x_init,
               symbolic::Expression threadIdx_y_init, symbolic::Expression threadIdx_z_init)
    : ControlFlowNode(element_id, debug_info),
      suffix_(suffix),
      gridDim_x_init_(gridDim_x_init),
      gridDim_y_init_(gridDim_y_init),
      gridDim_z_init_(gridDim_z_init),
      blockDim_x_init_(blockDim_x_init),
      blockDim_y_init_(blockDim_y_init),
      blockDim_z_init_(blockDim_z_init),
      blockIdx_x_init_(blockIdx_x_init),
      blockIdx_y_init_(blockIdx_y_init),
      blockIdx_z_init_(blockIdx_z_init),
      threadIdx_x_init_(threadIdx_x_init),
      threadIdx_y_init_(threadIdx_y_init),
      threadIdx_z_init_(threadIdx_z_init) {
    this->root_ = std::unique_ptr<Sequence>(new Sequence(++element_id, debug_info));

    this->gridDim_x_ = symbolic::symbol("__daisy_gridDim_x_" + suffix);
    this->gridDim_y_ = symbolic::symbol("__daisy_gridDim_y_" + suffix);
    this->gridDim_z_ = symbolic::symbol("__daisy_gridDim_z_" + suffix);

    this->blockDim_x_ = symbolic::symbol("__daisy_blockDim_x_" + suffix);
    this->blockDim_y_ = symbolic::symbol("__daisy_blockDim_y_" + suffix);
    this->blockDim_z_ = symbolic::symbol("__daisy_blockDim_z_" + suffix);

    this->blockIdx_x_ = symbolic::symbol("__daisy_blockIdx_x_" + suffix);
    this->blockIdx_y_ = symbolic::symbol("__daisy_blockIdx_y_" + suffix);
    this->blockIdx_z_ = symbolic::symbol("__daisy_blockIdx_z_" + suffix);

    this->threadIdx_x_ = symbolic::symbol("__daisy_threadIdx_x_" + suffix);
    this->threadIdx_y_ = symbolic::symbol("__daisy_threadIdx_y_" + suffix);
    this->threadIdx_z_ = symbolic::symbol("__daisy_threadIdx_z_" + suffix);
};

symbolic::Expression Kernel::gridDim_x_init() const { return this->gridDim_x_init_; }

symbolic::Expression Kernel::gridDim_y_init() const { return this->gridDim_y_init_; }

symbolic::Expression Kernel::gridDim_z_init() const { return this->gridDim_z_init_; }

symbolic::Expression Kernel::blockDim_x_init() const { return this->blockDim_x_init_; }

symbolic::Expression Kernel::blockDim_y_init() const { return this->blockDim_y_init_; }

symbolic::Expression Kernel::blockDim_z_init() const { return this->blockDim_z_init_; }

symbolic::Expression Kernel::blockIdx_x_init() const { return this->blockIdx_x_init_; }

symbolic::Expression Kernel::blockIdx_y_init() const { return this->blockIdx_y_init_; }

symbolic::Expression Kernel::blockIdx_z_init() const { return this->blockIdx_z_init_; }

symbolic::Expression Kernel::threadIdx_x_init() const { return this->threadIdx_x_init_; }

symbolic::Expression Kernel::threadIdx_y_init() const { return this->threadIdx_y_init_; }

symbolic::Expression Kernel::threadIdx_z_init() const { return this->threadIdx_z_init_; }

symbolic::Symbol Kernel::gridDim_x() const { return this->gridDim_x_; }

symbolic::Symbol Kernel::gridDim_y() const { return this->gridDim_y_; }

symbolic::Symbol Kernel::gridDim_z() const { return this->gridDim_z_; }

symbolic::Symbol Kernel::blockDim_x() const { return this->blockDim_x_; }

symbolic::Symbol Kernel::blockDim_y() const { return this->blockDim_y_; }

symbolic::Symbol Kernel::blockDim_z() const { return this->blockDim_z_; }

symbolic::Symbol Kernel::blockIdx_x() const { return this->blockIdx_x_; }

symbolic::Symbol Kernel::blockIdx_y() const { return this->blockIdx_y_; }

symbolic::Symbol Kernel::blockIdx_z() const { return this->blockIdx_z_; }

symbolic::Symbol Kernel::threadIdx_x() const { return this->threadIdx_x_; }

symbolic::Symbol Kernel::threadIdx_y() const { return this->threadIdx_y_; }

symbolic::Symbol Kernel::threadIdx_z() const { return this->threadIdx_z_; }

Sequence& Kernel::root() const { return *this->root_; };

std::string Kernel::suffix() const { return this->suffix_; }

void Kernel::replace(const symbolic::Expression& old_expression,
                     const symbolic::Expression& new_expression) {
    if (symbolic::eq(this->gridDim_x_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->gridDim_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->gridDim_y_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->gridDim_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->gridDim_z_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->gridDim_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockDim_x_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockDim_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockDim_y_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockDim_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockDim_z_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockDim_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockIdx_x_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockIdx_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockIdx_y_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockIdx_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->blockIdx_z_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->blockIdx_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->threadIdx_x_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->threadIdx_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->threadIdx_y_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->threadIdx_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }
    if (symbolic::eq(this->threadIdx_z_, old_expression)) {
        assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));
        this->threadIdx_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);
    }

    this->blockIdx_x_init_ = symbolic::subs(this->blockIdx_x_init_, old_expression, new_expression);
    this->blockIdx_y_init_ = symbolic::subs(this->blockIdx_y_init_, old_expression, new_expression);
    this->blockIdx_z_init_ = symbolic::subs(this->blockIdx_z_init_, old_expression, new_expression);
    this->threadIdx_x_init_ =
        symbolic::subs(this->threadIdx_x_init_, old_expression, new_expression);
    this->threadIdx_y_init_ =
        symbolic::subs(this->threadIdx_y_init_, old_expression, new_expression);
    this->threadIdx_z_init_ =
        symbolic::subs(this->threadIdx_z_init_, old_expression, new_expression);
    this->blockDim_x_init_ = symbolic::subs(this->blockDim_x_init_, old_expression, new_expression);
    this->blockDim_y_init_ = symbolic::subs(this->blockDim_y_init_, old_expression, new_expression);
    this->blockDim_z_init_ = symbolic::subs(this->blockDim_z_init_, old_expression, new_expression);
    this->gridDim_x_init_ = symbolic::subs(this->gridDim_x_init_, old_expression, new_expression);
    this->gridDim_y_init_ = symbolic::subs(this->gridDim_y_init_, old_expression, new_expression);
    this->gridDim_z_init_ = symbolic::subs(this->gridDim_z_init_, old_expression, new_expression);

    this->root_->replace(old_expression, new_expression);
};

}  // namespace structured_control_flow
}  // namespace sdfg

1	#include "sdfg/structured_control_flow/kernel.h"
2
3	#include "sdfg/structured_control_flow/sequence.h"
4	#include "sdfg/symbolic/symbolic.h"
5
6	namespace sdfg {
7	namespace structured_control_flow {
8
9	Kernel::Kernel(size_t element_id, const DebugInfo& debug_info, std::string suffix,	28✔
10	symbolic::Expression gridDim_x_init, symbolic::Expression gridDim_y_init,
11	symbolic::Expression gridDim_z_init, symbolic::Expression blockDim_x_init,
12	symbolic::Expression blockDim_y_init, symbolic::Expression blockDim_z_init,
13	symbolic::Expression blockIdx_x_init, symbolic::Expression blockIdx_y_init,
14	symbolic::Expression blockIdx_z_init, symbolic::Expression threadIdx_x_init,
15	symbolic::Expression threadIdx_y_init, symbolic::Expression threadIdx_z_init)
16	: ControlFlowNode(element_id, debug_info),	14✔
17	suffix_(suffix),	14✔
18	gridDim_x_init_(gridDim_x_init),	14✔
19	gridDim_y_init_(gridDim_y_init),	14✔
20	gridDim_z_init_(gridDim_z_init),	14✔
21	blockDim_x_init_(blockDim_x_init),	14✔
22	blockDim_y_init_(blockDim_y_init),	14✔
23	blockDim_z_init_(blockDim_z_init),	14✔
24	blockIdx_x_init_(blockIdx_x_init),	14✔
25	blockIdx_y_init_(blockIdx_y_init),	14✔
26	blockIdx_z_init_(blockIdx_z_init),	14✔
27	threadIdx_x_init_(threadIdx_x_init),	14✔
28	threadIdx_y_init_(threadIdx_y_init),	14✔
29	threadIdx_z_init_(threadIdx_z_init) {	28✔
30	this->root_ = std::unique_ptr<Sequence>(new Sequence(++element_id, debug_info));	14✔
31
32	this->gridDim_x_ = symbolic::symbol("__daisy_gridDim_x_" + suffix);	14✔
33	this->gridDim_y_ = symbolic::symbol("__daisy_gridDim_y_" + suffix);	14✔
34	this->gridDim_z_ = symbolic::symbol("__daisy_gridDim_z_" + suffix);	14✔
35
36	this->blockDim_x_ = symbolic::symbol("__daisy_blockDim_x_" + suffix);	14✔
37	this->blockDim_y_ = symbolic::symbol("__daisy_blockDim_y_" + suffix);	14✔
38	this->blockDim_z_ = symbolic::symbol("__daisy_blockDim_z_" + suffix);	14✔
39
40	this->blockIdx_x_ = symbolic::symbol("__daisy_blockIdx_x_" + suffix);	14✔
41	this->blockIdx_y_ = symbolic::symbol("__daisy_blockIdx_y_" + suffix);	14✔
42	this->blockIdx_z_ = symbolic::symbol("__daisy_blockIdx_z_" + suffix);	14✔
43
44	this->threadIdx_x_ = symbolic::symbol("__daisy_threadIdx_x_" + suffix);	14✔
45	this->threadIdx_y_ = symbolic::symbol("__daisy_threadIdx_y_" + suffix);	14✔
46	this->threadIdx_z_ = symbolic::symbol("__daisy_threadIdx_z_" + suffix);	14✔
47	};	14✔
48
49	symbolic::Expression Kernel::gridDim_x_init() const { return this->gridDim_x_init_; }	9✔
50
51	symbolic::Expression Kernel::gridDim_y_init() const { return this->gridDim_y_init_; }	9✔
52
53	symbolic::Expression Kernel::gridDim_z_init() const { return this->gridDim_z_init_; }	9✔
54
55	symbolic::Expression Kernel::blockDim_x_init() const { return this->blockDim_x_init_; }	9✔
56
57	symbolic::Expression Kernel::blockDim_y_init() const { return this->blockDim_y_init_; }	9✔
58
59	symbolic::Expression Kernel::blockDim_z_init() const { return this->blockDim_z_init_; }	9✔
60
61	symbolic::Expression Kernel::blockIdx_x_init() const { return this->blockIdx_x_init_; }	1✔
62
63	symbolic::Expression Kernel::blockIdx_y_init() const { return this->blockIdx_y_init_; }	1✔
64
65	symbolic::Expression Kernel::blockIdx_z_init() const { return this->blockIdx_z_init_; }	1✔
66
67	symbolic::Expression Kernel::threadIdx_x_init() const { return this->threadIdx_x_init_; }	1✔
68
69	symbolic::Expression Kernel::threadIdx_y_init() const { return this->threadIdx_y_init_; }	1✔
70
71	symbolic::Expression Kernel::threadIdx_z_init() const { return this->threadIdx_z_init_; }	1✔
72
73	symbolic::Symbol Kernel::gridDim_x() const { return this->gridDim_x_; }	27✔
74
75	symbolic::Symbol Kernel::gridDim_y() const { return this->gridDim_y_; }	27✔
76
77	symbolic::Symbol Kernel::gridDim_z() const { return this->gridDim_z_; }	27✔
78
79	symbolic::Symbol Kernel::blockDim_x() const { return this->blockDim_x_; }	50✔
80
81	symbolic::Symbol Kernel::blockDim_y() const { return this->blockDim_y_; }	35✔
82
83	symbolic::Symbol Kernel::blockDim_z() const { return this->blockDim_z_; }	34✔
84
85	symbolic::Symbol Kernel::blockIdx_x() const { return this->blockIdx_x_; }	44✔
86
87	symbolic::Symbol Kernel::blockIdx_y() const { return this->blockIdx_y_; }	29✔
88
89	symbolic::Symbol Kernel::blockIdx_z() const { return this->blockIdx_z_; }	28✔
90
91	symbolic::Symbol Kernel::threadIdx_x() const { return this->threadIdx_x_; }	67✔
92
93	symbolic::Symbol Kernel::threadIdx_y() const { return this->threadIdx_y_; }	41✔
94
95	symbolic::Symbol Kernel::threadIdx_z() const { return this->threadIdx_z_; }	38✔
96
97	Sequence& Kernel::root() const { return *this->root_; };	122✔
98
99	std::string Kernel::suffix() const { return this->suffix_; }	×
100
101	void Kernel::replace(const symbolic::Expression& old_expression,	2✔
102	const symbolic::Expression& new_expression) {
103	if (symbolic::eq(this->gridDim_x_, old_expression)) {	2✔
104	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
105	this->gridDim_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 106	}	×
107	if (symbolic::eq(this->gridDim_y_, old_expression)) {	2✔
108	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
109	this->gridDim_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 110	}	×
111	if (symbolic::eq(this->gridDim_z_, old_expression)) {	2✔
112	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
113	this->gridDim_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 114	}	×
115	if (symbolic::eq(this->blockDim_x_, old_expression)) {	2✔
116	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
117	this->blockDim_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 118	}	×
119	if (symbolic::eq(this->blockDim_y_, old_expression)) {	2✔
120	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
121	this->blockDim_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 122	}	×
123	if (symbolic::eq(this->blockDim_z_, old_expression)) {	2✔
124	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
125	this->blockDim_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 126	}	×
127	if (symbolic::eq(this->blockIdx_x_, old_expression)) {	2✔
128	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
129	this->blockIdx_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 130	}	×
131	if (symbolic::eq(this->blockIdx_y_, old_expression)) {	2✔
132	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	1✔
133	this->blockIdx_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	1✔
134	}	1✔
135	if (symbolic::eq(this->blockIdx_z_, old_expression)) {	2✔
136	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
137	this->blockIdx_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 138	}	×
139	if (symbolic::eq(this->threadIdx_x_, old_expression)) {	2✔
140	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	1✔
141	this->threadIdx_x_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	1✔
142	}	1✔
143	if (symbolic::eq(this->threadIdx_y_, old_expression)) {	2✔
144	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
145	this->threadIdx_y_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 146	}	×
147	if (symbolic::eq(this->threadIdx_z_, old_expression)) {	2✔
148	assert(SymEngine::is_a<SymEngine::Symbol>(*new_expression));	×
149	this->threadIdx_z_ = SymEngine::rcp_static_cast<const SymEngine::Symbol>(new_expression);	×
UNCOV 150	}	×
151
152	this->blockIdx_x_init_ = symbolic::subs(this->blockIdx_x_init_, old_expression, new_expression);	2✔
153	this->blockIdx_y_init_ = symbolic::subs(this->blockIdx_y_init_, old_expression, new_expression);	2✔
154	this->blockIdx_z_init_ = symbolic::subs(this->blockIdx_z_init_, old_expression, new_expression);	2✔
155	this->threadIdx_x_init_ =	2✔
156	symbolic::subs(this->threadIdx_x_init_, old_expression, new_expression);	2✔
157	this->threadIdx_y_init_ =	2✔
158	symbolic::subs(this->threadIdx_y_init_, old_expression, new_expression);	2✔
159	this->threadIdx_z_init_ =	2✔
160	symbolic::subs(this->threadIdx_z_init_, old_expression, new_expression);	2✔
161	this->blockDim_x_init_ = symbolic::subs(this->blockDim_x_init_, old_expression, new_expression);	2✔
162	this->blockDim_y_init_ = symbolic::subs(this->blockDim_y_init_, old_expression, new_expression);	2✔
163	this->blockDim_z_init_ = symbolic::subs(this->blockDim_z_init_, old_expression, new_expression);	2✔
164	this->gridDim_x_init_ = symbolic::subs(this->gridDim_x_init_, old_expression, new_expression);	2✔
165	this->gridDim_y_init_ = symbolic::subs(this->gridDim_y_init_, old_expression, new_expression);	2✔
166	this->gridDim_z_init_ = symbolic::subs(this->gridDim_z_init_, old_expression, new_expression);	2✔
167
168	this->root_->replace(old_expression, new_expression);	2✔
169	};	2✔
170
171	} // namespace structured_control_flow
172	} // 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