15656007340

Committed 14 Jun 2025 08:51PM UTC coverage: 13.234% (-49.9%) from 63.144%

Build # 15656007340

Build Type

Pull #76

github

Committed by

web-flow

Commit Message

Merge 9586c8161 into 413c53212

Pull Request Pull Request #76: New Loop Dependency Analysis

Run Details

361 of 465 new or added lines in 7 files covered. (77.63%)

6215 existing lines in 110 files now uncovered.

1612 of 12181 relevant lines covered (13.23%)

13.64 hits per line

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

32.35

/src/data_flow/tasklet.cpp

#include "sdfg/data_flow/tasklet.h"

#include "sdfg/symbolic/symbolic.h"

namespace sdfg {
namespace data_flow {

Tasklet::Tasklet(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(debug_info, vertex, parent),
      code_(code),
      output_(output),
      inputs_(inputs),
      condition_(condition) {};

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

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

daisytuner / sdfglib / 15656007340

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