16439520920

Committed 22 Jul 2025 08:53AM UTC coverage: 65.927% (+0.8%) from 65.094%

Build # 16439520920

Build Type

Pull #153

github

Committed by

web-flow

Commit Message

Merge a0eea6968 into abe57c083

Pull Request Pull Request #153: Restricts memlets to contiguous memory

Run Details

211 of 300 new or added lines in 29 files covered. (70.33%)

66 existing lines in 7 files now uncovered.

8314 of 12611 relevant lines covered (65.93%)

128.5 hits per line

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

59.38

/src/data_flow/tasklet.cpp

#include "sdfg/data_flow/tasklet.h"

#include "sdfg/symbolic/symbolic.h"

namespace sdfg {
namespace data_flow {

Tasklet::Tasklet(
    size_t element_id,
    const DebugInfo& debug_info,
    const graph::Vertex vertex,
    DataFlowGraph& parent,
    const TaskletCode code,
    const std::pair<std::string, sdfg::types::Scalar>& output,
    const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
    const symbolic::Condition& condition
)
    : CodeNode(element_id, debug_info, vertex, parent), code_(code), output_(output), inputs_(inputs),
      condition_(condition) {};

void Tasklet::validate(const Function& function) const {
    // TODO: Implement
}

TaskletCode Tasklet::code() const { return this->code_; };

const std::vector<std::pair<std::string, sdfg::types::Scalar>>& Tasklet::inputs() const { return this->inputs_; };

std::vector<std::pair<std::string, sdfg::types::Scalar>>& Tasklet::inputs() { return this->inputs_; };

const std::pair<std::string, sdfg::types::Scalar>& Tasklet::output() const { return this->output_; };

const std::pair<std::string, sdfg::types::Scalar>& Tasklet::input(size_t index) const { return this->inputs_[index]; };

const sdfg::types::Scalar& Tasklet::input_type(const std::string& input) const {
    return std::find_if(
               this->inputs_.begin(),
               this->inputs_.end(),
               [&input](const std::pair<std::string, sdfg::types::Scalar>& p) { return p.first == input; }
    )->second;
};

bool Tasklet::needs_connector(size_t index) const {
    // Is non-constant, if starts with _in prefix
    if (this->inputs_[index].first.compare(0, 3, "_in") == 0) {
        return true;
    }
    return false;
};

const sdfg::types::Scalar& Tasklet::output_type() const { return this->output_.second; };

const symbolic::Condition& Tasklet::condition() const { return this->condition_; };

symbolic::Condition& Tasklet::condition() { return this->condition_; };

bool Tasklet::is_conditional() const { return !symbolic::is_true(this->condition_); };

std::unique_ptr<DataFlowNode> Tasklet::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)
    const {
    return std::unique_ptr<Tasklet>(new Tasklet(
        element_id, this->debug_info_, vertex, parent, this->code_, this->output_, this->inputs_, this->condition_
    ));
};

void Tasklet::replace(const symbolic::Expression& old_expression, const symbolic::Expression& new_expression) {
    this->condition_ = symbolic::subs(this->condition_, old_expression, new_expression);
};

} // namespace data_flow
} // namespace sdfg

1	#include "sdfg/data_flow/tasklet.h"
2
3	#include "sdfg/symbolic/symbolic.h"
4
5	namespace sdfg {
6	namespace data_flow {
7
8	Tasklet::Tasklet(	331✔
9	size_t element_id,
10	const DebugInfo& debug_info,
11	const graph::Vertex vertex,
12	DataFlowGraph& parent,
13	const TaskletCode code,
14	const std::pair<std::string, sdfg::types::Scalar>& output,
15	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& inputs,
16	const symbolic::Condition& condition
17	)
18	: CodeNode(element_id, debug_info, vertex, parent), code_(code), output_(output), inputs_(inputs),	662✔
19	condition_(condition) {};	662✔
20
21	void Tasklet::validate(const Function& function) const {	291✔
22	// TODO: Implement
23	}	291✔
24
25	TaskletCode Tasklet::code() const { return this->code_; };	774✔
26
27	const std::vector<std::pair<std::string, sdfg::types::Scalar>>& Tasklet::inputs() const { return this->inputs_; };	582✔
28
29	std::vector<std::pair<std::string, sdfg::types::Scalar>>& Tasklet::inputs() { return this->inputs_; };	2✔
30
31	const std::pair<std::string, sdfg::types::Scalar>& Tasklet::output() const { return this->output_; };	512✔
32
33	const std::pair<std::string, sdfg::types::Scalar>& Tasklet::input(size_t index) const { return this->inputs_[index]; };	455✔
34
35	const sdfg::types::Scalar& Tasklet::input_type(const std::string& input) const {	×
36	return std::find_if(	×
37	this->inputs_.begin(),	×
38	this->inputs_.end(),	×
39	[&input](const std::pair<std::string, sdfg::types::Scalar>& p) { return p.first == input; }	×
40	)->second;	×
41	};
42
43	bool Tasklet::needs_connector(size_t index) const {	229✔
44	// Is non-constant, if starts with _in prefix
45	if (this->inputs_[index].first.compare(0, 3, "_in") == 0) {	229✔
46	return true;	17✔
47	}
48	return false;	212✔
49	};	229✔
50
51	const sdfg::types::Scalar& Tasklet::output_type() const { return this->output_.second; };	×
52
53	const symbolic::Condition& Tasklet::condition() const { return this->condition_; };	×
54
UNCOV 55	symbolic::Condition& Tasklet::condition() { return this->condition_; };	×
56
57	bool Tasklet::is_conditional() const { return !symbolic::is_true(this->condition_); };	195✔
58
59	std::unique_ptr<DataFlowNode> Tasklet::clone(size_t element_id, const graph::Vertex vertex, DataFlowGraph& parent)	×
60	const {
61	return std::unique_ptr<Tasklet>(new Tasklet(	×
62	element_id, this->debug_info_, vertex, parent, this->code_, this->output_, this->inputs_, this->condition_	×
63	));
64	};	×
65
66	void Tasklet::replace(const symbolic::Expression& old_expression, const symbolic::Expression& new_expression) {	2✔
67	this->condition_ = symbolic::subs(this->condition_, old_expression, new_expression);	2✔
68	};	2✔
69
70	} // namespace data_flow
71	} // namespace sdfg

daisytuner / sdfglib / 16439520920

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