15262928007

Committed 26 May 2025 10:36PM UTC coverage: 58.284% (-2.0%) from 60.304%

Build # 15262928007

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #36 from daisytuner/sdfg-validation

Introduces new definition of memlets plus sanity checks

Run Details

104 of 266 new or added lines in 6 files covered. (39.1%)

241 existing lines in 15 files now uncovered.

7908 of 13568 relevant lines covered (58.28%)

96.1 hits per line

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

45.45

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

daisytuner / sdfglib / 15262928007

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