15512392058

Committed 07 Jun 2025 10:47PM UTC coverage: 62.261% (+4.8%) from 57.416%

Build # 15512392058

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #63 from daisytuner/schedules

Schedules

Run Details

152 of 194 new or added lines in 24 files covered. (78.35%)

39 existing lines in 7 files now uncovered.

7467 of 11993 relevant lines covered (62.26%)

127.08 hits per line

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

82.08

/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/library_node.h"
#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::neg:
            return "-";
        case data_flow::TaskletCode::add:
            return "+";
        case data_flow::TaskletCode::sub:
            return "-";
        case data_flow::TaskletCode::mul:
            return "*";
        case data_flow::TaskletCode::div:
            return "/";
        case data_flow::TaskletCode::fma:
            return "fma";
        case data_flow::TaskletCode::mod:
            return "%";
        case data_flow::TaskletCode::max:
            return "max";
        case data_flow::TaskletCode::min:
            return "min";
        case data_flow::TaskletCode::minnum:
            return "minnum";
        case data_flow::TaskletCode::maxnum:
            return "maxnum";
        case data_flow::TaskletCode::minimum:
            return "minimum";
        case data_flow::TaskletCode::maximum:
            return "maximum";
        case data_flow::TaskletCode::trunc:
            return "trunc";
        case data_flow::TaskletCode::logical_and:
            return "&&";
        case data_flow::TaskletCode::logical_or:
            return "||";
        case data_flow::TaskletCode::bitwise_and:
            return "&";
        case data_flow::TaskletCode::bitwise_or:
            return "|";
        case data_flow::TaskletCode::bitwise_xor:
            return "^";
        case data_flow::TaskletCode::bitwise_not:
            return "~";
        case data_flow::TaskletCode::shift_left:
            return "<<";
        case data_flow::TaskletCode::shift_right:
            return ">>";
        case data_flow::TaskletCode::olt:
            return "<";
        case data_flow::TaskletCode::ole:
            return "<=";
        case data_flow::TaskletCode::oeq:
            return "==";
        case data_flow::TaskletCode::one:
            return "!=";
        case data_flow::TaskletCode::oge:
            return ">=";
        case data_flow::TaskletCode::ogt:
            return ">";
        case data_flow::TaskletCode::ord:
            return "==";
        case data_flow::TaskletCode::ult:
            return "<";
        case data_flow::TaskletCode::ule:
            return "<=";
        case data_flow::TaskletCode::ueq:
            return "==";
        case data_flow::TaskletCode::une:
            return "!=";
        case data_flow::TaskletCode::uge:
            return ">=";
        case data_flow::TaskletCode::ugt:
            return ">";
        case data_flow::TaskletCode::uno:
            return "!=";
        case data_flow::TaskletCode::abs:
            return "abs";
        case data_flow::TaskletCode::acos:
            return "acos";
        case data_flow::TaskletCode::acosf:
            return "acosf";
        case data_flow::TaskletCode::acosl:
            return "acosl";
        case data_flow::TaskletCode::acosh:
            return "acosh";
        case data_flow::TaskletCode::acoshf:
            return "acoshf";
        case data_flow::TaskletCode::acoshl:
            return "acoshl";
        case data_flow::TaskletCode::asin:
            return "asin";
        case data_flow::TaskletCode::asinf:
            return "asinf";
        case data_flow::TaskletCode::asinl:
            return "asinl";
        case data_flow::TaskletCode::asinh:
            return "asinh";
        case data_flow::TaskletCode::asinhf:
            return "asinhf";
        case data_flow::TaskletCode::asinhl:
            return "asinhl";
        case data_flow::TaskletCode::atan:
            return "atan";
        case data_flow::TaskletCode::atanf:
            return "atanf";
        case data_flow::TaskletCode::atanl:
            return "atanl";
        case data_flow::TaskletCode::atan2:
            return "atan2";
        case data_flow::TaskletCode::atan2f:
            return "atan2f";
        case data_flow::TaskletCode::atan2l:
            return "atan2l";
        case data_flow::TaskletCode::atanh:
            return "atanh";
        case data_flow::TaskletCode::atanhf:
            return "atanhf";
        case data_flow::TaskletCode::atanhl:
            return "atanhl";
        case data_flow::TaskletCode::cabs:
            return "cabs";
        case data_flow::TaskletCode::cabsf:
            return "cabsf";
        case data_flow::TaskletCode::cabsl:
            return "cabsl";
        case data_flow::TaskletCode::ceil:
            return "ceil";
        case data_flow::TaskletCode::ceilf:
            return "ceilf";
        case data_flow::TaskletCode::ceill:
            return "ceill";
        case data_flow::TaskletCode::copysign:
            return "copysign";
        case data_flow::TaskletCode::copysignf:
            return "copysignf";
        case data_flow::TaskletCode::copysignl:
            return "copysignl";
        case data_flow::TaskletCode::cos:
            return "cos";
        case data_flow::TaskletCode::cosf:
            return "cosf";
        case data_flow::TaskletCode::cosl:
            return "cosl";
        case data_flow::TaskletCode::cosh:
            return "cosh";
        case data_flow::TaskletCode::coshf:
            return "coshf";
        case data_flow::TaskletCode::coshl:
            return "coshl";
        case data_flow::TaskletCode::cbrt:
            return "cbrt";
        case data_flow::TaskletCode::cbrtf:
            return "cbrtf";
        case data_flow::TaskletCode::cbrtl:
            return "cbrtl";
        case data_flow::TaskletCode::exp10:
            return "exp10";
        case data_flow::TaskletCode::exp10f:
            return "exp10f";
        case data_flow::TaskletCode::exp10l:
            return "exp10l";
        case data_flow::TaskletCode::exp2:
            return "exp2";
        case data_flow::TaskletCode::exp2f:
            return "exp2f";
        case data_flow::TaskletCode::exp2l:
            return "exp2l";
        case data_flow::TaskletCode::exp:
            return "exp";
        case data_flow::TaskletCode::expf:
            return "expf";
        case data_flow::TaskletCode::expl:
            return "expl";
        case data_flow::TaskletCode::expm1:
            return "expm1";
        case data_flow::TaskletCode::expm1f:
            return "expm1f";
        case data_flow::TaskletCode::expm1l:
            return "expm1l";
        case data_flow::TaskletCode::fabs:
            return "fabs";
        case data_flow::TaskletCode::fabsf:
            return "fabsf";
        case data_flow::TaskletCode::fabsl:
            return "fabsl";
        case data_flow::TaskletCode::floor:
            return "floor";
        case data_flow::TaskletCode::floorf:
            return "floorf";
        case data_flow::TaskletCode::floorl:
            return "floorl";
        case data_flow::TaskletCode::fls:
            return "fls";
        case data_flow::TaskletCode::flsl:
            return "flsl";
        case data_flow::TaskletCode::fmax:
            return "fmax";
        case data_flow::TaskletCode::fmaxf:
            return "fmaxf";
        case data_flow::TaskletCode::fmaxl:
            return "fmaxl";
        case data_flow::TaskletCode::fmin:
            return "fmin";
        case data_flow::TaskletCode::fminf:
            return "fminf";
        case data_flow::TaskletCode::fminl:
            return "fminl";
        case data_flow::TaskletCode::fmod:
            return "fmod";
        case data_flow::TaskletCode::fmodf:
            return "fmodf";
        case data_flow::TaskletCode::fmodl:
            return "fmodl";
        case data_flow::TaskletCode::frexp:
            return "frexp";
        case data_flow::TaskletCode::frexpf:
            return "frexpf";
        case data_flow::TaskletCode::frexpl:
            return "frexpl";
        case data_flow::TaskletCode::labs:
            return "labs";
        case data_flow::TaskletCode::ldexp:
            return "ldexp";
        case data_flow::TaskletCode::ldexpf:
            return "ldexpf";
        case data_flow::TaskletCode::ldexpl:
            return "ldexpl";
        case data_flow::TaskletCode::log10:
            return "log10";
        case data_flow::TaskletCode::log10f:
            return "log10f";
        case data_flow::TaskletCode::log10l:
            return "log10l";
        case data_flow::TaskletCode::log2:
            return "log2";
        case data_flow::TaskletCode::log2f:
            return "log2f";
        case data_flow::TaskletCode::log2l:
            return "log2l";
        case data_flow::TaskletCode::log:
            return "log";
        case data_flow::TaskletCode::logf:
            return "logf";
        case data_flow::TaskletCode::logl:
            return "logl";
        case data_flow::TaskletCode::logb:
            return "logb";
        case data_flow::TaskletCode::logbf:
            return "logbf";
        case data_flow::TaskletCode::logbl:
            return "logbl";
        case data_flow::TaskletCode::log1p:
            return "log1p";
        case data_flow::TaskletCode::log1pf:
            return "log1pf";
        case data_flow::TaskletCode::log1pl:
            return "log1pl";
        case data_flow::TaskletCode::modf:
            return "modf";
        case data_flow::TaskletCode::modff:
            return "modff";
        case data_flow::TaskletCode::modfl:
            return "modfl";
        case data_flow::TaskletCode::nearbyint:
            return "nearbyint";
        case data_flow::TaskletCode::nearbyintf:
            return "nearbyintf";
        case data_flow::TaskletCode::nearbyintl:
            return "nearbyintl";
        case data_flow::TaskletCode::pow:
            return "pow";
        case data_flow::TaskletCode::powf:
            return "powf";
        case data_flow::TaskletCode::powl:
            return "powl";
        case data_flow::TaskletCode::rint:
            return "rint";
        case data_flow::TaskletCode::rintf:
            return "rintf";
        case data_flow::TaskletCode::rintl:
            return "rintl";
        case data_flow::TaskletCode::round:
            return "round";
        case data_flow::TaskletCode::roundf:
            return "roundf";
        case data_flow::TaskletCode::roundl:
            return "roundl";
        case data_flow::TaskletCode::roundeven:
            return "roundeven";
        case data_flow::TaskletCode::roundevenf:
            return "roundevenf";
        case data_flow::TaskletCode::roundevenl:
            return "roundevenl";
        case data_flow::TaskletCode::sin:
            return "sin";
        case data_flow::TaskletCode::sinf:
            return "sinf";
        case data_flow::TaskletCode::sinl:
            return "sinl";
        case data_flow::TaskletCode::sinh:
            return "sinh";
        case data_flow::TaskletCode::sinhf:
            return "sinhf";
        case data_flow::TaskletCode::sinhl:
            return "sinhl";
        case data_flow::TaskletCode::sqrt:
            return "sqrt";
        case data_flow::TaskletCode::sqrtf:
            return "sqrtf";
        case data_flow::TaskletCode::sqrtl:
            return "sqrtl";
        case data_flow::TaskletCode::rsqrt:
            return "rsqrt";
        case data_flow::TaskletCode::rsqrtf:
            return "rsqrtf";
        case data_flow::TaskletCode::rsqrtl:
            return "rsqrtl";
        case data_flow::TaskletCode::tan:
            return "tan";
        case data_flow::TaskletCode::tanf:
            return "tanf";
        case data_flow::TaskletCode::tanl:
            return "tanl";
        case data_flow::TaskletCode::tanh:
            return "tanh";
        case data_flow::TaskletCode::tanhf:
            return "tanhf";
        case data_flow::TaskletCode::tanhl:
            return "tanhl";
    };
    throw InvalidSDFGException("code_to_string: Unsupported tasklet code");
};

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(StructuredSDFG& sdfg,
                               structured_control_flow::ControlFlowNode& node) {
    if (auto block = dynamic_cast<structured_control_flow::Block*>(&node)) {
        this->visualizeBlock(sdfg, *block);
        return;
    }
    if (auto sequence = dynamic_cast<structured_control_flow::Sequence*>(&node)) {
        this->visualizeSequence(sdfg, *sequence);
        return;
    }
    if (auto if_else = dynamic_cast<structured_control_flow::IfElse*>(&node)) {
        this->visualizeIfElse(sdfg, *if_else);
        return;
    }
    if (auto while_loop = dynamic_cast<structured_control_flow::While*>(&node)) {
        this->visualizeWhile(sdfg, *while_loop);
        return;
    }
    if (auto loop = dynamic_cast<structured_control_flow::For*>(&node)) {
        this->visualizeFor(sdfg, *loop);
        return;
    }
    if (auto return_node = dynamic_cast<structured_control_flow::Return*>(&node)) {
        this->visualizeReturn(sdfg, *return_node);
        return;
    }
    if (auto break_node = dynamic_cast<structured_control_flow::Break*>(&node)) {
        this->visualizeBreak(sdfg, *break_node);
        return;
    }
    if (auto continue_node = dynamic_cast<structured_control_flow::Continue*>(&node)) {
        this->visualizeContinue(sdfg, *continue_node);
        return;
    }
    if (auto map_node = dynamic_cast<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) {
        std::string arg = tasklet.input(i).first;
        if (!tasklet.needs_connector(i)) {
            if (arg != "NAN" && arg != "INFINITY") {
                if (tasklet.input(i).second.primitive_type() == types::PrimitiveType::Float)
                    arg += "f";
            }
        }
        arguments.push_back(this->expression(arg));
    }

    if (tasklet.code() == data_flow::TaskletCode::assign) {
        this->stream_ << arguments.at(0);
    } else if (tasklet.code() == data_flow::TaskletCode::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 if (data_flow::is_infix(tasklet.code())) {
        switch (data_flow::arity(tasklet.code())) {
            case 1:
                this->stream_ << op << " " << arguments.at(0);
                break;
            case 2:
                this->stream_ << arguments.at(0) << " " << op << " " << arguments.at(1);
                break;
            default:
                throw std::runtime_error("Unsupported arity");
        }
    } 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) {
    if ((init->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER ||
         init->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL) &&
        (condition->get_type_code() == SymEngine::TypeID::SYMENGINE_STRICTLESSTHAN ||
         condition->get_type_code() == SymEngine::TypeID::SYMENGINE_LESSTHAN) &&
        condition->get_args().size() == 2 &&
        condition->get_args().at(0)->__str__() == indvar->__str__() &&
        (condition->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER ||
         condition->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL) &&
        update->get_type_code() == SymEngine::TypeID::SYMENGINE_ADD &&
        update->get_args().size() == 2 &&
        (update->get_args().at(0)->__str__() == indvar->__str__() ||
         update->get_args().at(1)->__str__() == indvar->__str__()) &&
        (update->get_args().at(0)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER ||
         update->get_args().at(0)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL ||
         update->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER ||
         update->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL)) {
        this->stream_ << indvar->get_name() << " = " << init->__str__() << ":";
        if (condition->get_type_code() == SymEngine::TypeID::SYMENGINE_STRICTLESSTHAN)
            this->stream_ << "(" << condition->get_args().at(1)->__str__() << "-1)";
        else
            this->stream_ << condition->get_args().at(1)->__str__();
        size_t i = (update->get_args().at(0).get() == indvar.get()) ? 1 : 0;
        if (update->get_args().at(i)->__str__() != "1")
            this->stream_ << ":" << update->get_args().at(i)->__str__();
    } else {
        this->stream_ << indvar->get_name() << " = " << this->expression(init->__str__()) << "; "
                      << this->expression(condition->__str__()) << "; " << indvar->get_name()
                      << " = " << this->expression(update->__str__());
    }
}

void Visualizer::visualizeLibraryNode(const data_flow::LibraryNodeCode libnode_type) {
    switch (libnode_type) {
        case data_flow::LibraryNodeCode::barrier_local:
            this->stream_ << "Local Barrier";
            break;
        default:
            throw std::runtime_error("Unsupported library node type");
    }
}

void Visualizer::visualizeSubset(Function const& function, types::IType const& type,
                                 data_flow::Subset const& sub) {
    if (sub.empty()) return;
    if (dynamic_cast<const types::Scalar*>(&type)) {
        return;
    } else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {
        this->stream_ << "[" << this->expression(sub.at(0)->__str__()) << "]";
        if (sub.size() > 1) {
            data_flow::Subset element_subset(sub.begin() + 1, sub.end());
            types::IType const& element_type = array_type->element_type();
            this->visualizeSubset(function, element_type, element_subset);
        }
    } else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {
        this->stream_ << "[" << this->expression(sub.at(0)->__str__()) << "]";
        data_flow::Subset element_subset(sub.begin() + 1, sub.end());
        types::IType const& pointee_type = pointer_type->pointee_type();
        this->visualizeSubset(function, pointee_type, element_subset);
    } else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {
        types::StructureDefinition const& definition = function.structure(structure_type->name());
        this->stream_ << ".member_" << this->expression(sub.at(0)->__str__());
        if (sub.size() > 1) {
            auto member = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(0));
            types::IType const& member_type = definition.member_type(member);
            data_flow::Subset element_subset(sub.begin() + 1, sub.end());
            this->visualizeSubset(function, member_type, element_subset);
        }
    } else {
        throw InvalidSDFGException("visualizeSubset: Unsupported type");
    }
}

}  // 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/library_node.h"
11	#include "sdfg/data_flow/tasklet.h"
12	#include "sdfg/helpers/helpers.h"
13	#include "sdfg/structured_control_flow/block.h"
14	#include "sdfg/structured_control_flow/control_flow_node.h"
15	#include "sdfg/structured_control_flow/for.h"
16	#include "sdfg/structured_control_flow/if_else.h"
17	#include "sdfg/structured_control_flow/return.h"
18	#include "sdfg/structured_control_flow/sequence.h"
19	#include "sdfg/structured_control_flow/while.h"
20	#include "sdfg/symbolic/symbolic.h"
21	#include "sdfg/types/type.h"
22	#include "symengine/basic.h"
23
24	namespace sdfg {
25	namespace visualizer {
26
27	constexpr const char* code_to_string(data_flow::TaskletCode c) {	175✔
28	switch (c) {	175✔
29	case data_flow::TaskletCode::assign:
30	return "=";	5✔
31	case data_flow::TaskletCode::neg:
32	return "-";	1✔
33	case data_flow::TaskletCode::add:
34	return "+";	3✔
35	case data_flow::TaskletCode::sub:
36	return "-";	1✔
37	case data_flow::TaskletCode::mul:
38	return "*";	4✔
39	case data_flow::TaskletCode::div:
40	return "/";	1✔
41	case data_flow::TaskletCode::fma:
42	return "fma";	3✔
43	case data_flow::TaskletCode::mod:
44	return "%";	1✔
45	case data_flow::TaskletCode::max:
46	return "max";	1✔
47	case data_flow::TaskletCode::min:
48	return "min";	1✔
49	case data_flow::TaskletCode::minnum:
50	return "minnum";	1✔
51	case data_flow::TaskletCode::maxnum:
52	return "maxnum";	1✔
53	case data_flow::TaskletCode::minimum:
54	return "minimum";	1✔
55	case data_flow::TaskletCode::maximum:
56	return "maximum";	1✔
57	case data_flow::TaskletCode::trunc:
58	return "trunc";	1✔
59	case data_flow::TaskletCode::logical_and:
60	return "&&";	1✔
61	case data_flow::TaskletCode::logical_or:
62	return "\|\|";	1✔
63	case data_flow::TaskletCode::bitwise_and:
64	return "&";	1✔
65	case data_flow::TaskletCode::bitwise_or:
66	return "\|";	1✔
67	case data_flow::TaskletCode::bitwise_xor:
68	return "^";	1✔
69	case data_flow::TaskletCode::bitwise_not:
70	return "~";	1✔
71	case data_flow::TaskletCode::shift_left:
72	return "<<";	1✔
73	case data_flow::TaskletCode::shift_right:
74	return ">>";	1✔
75	case data_flow::TaskletCode::olt:
76	return "<";	1✔
77	case data_flow::TaskletCode::ole:
78	return "<=";	1✔
79	case data_flow::TaskletCode::oeq:
80	return "==";	1✔
81	case data_flow::TaskletCode::one:
82	return "!=";	1✔
83	case data_flow::TaskletCode::oge:
84	return ">=";	1✔
85	case data_flow::TaskletCode::ogt:
86	return ">";	1✔
87	case data_flow::TaskletCode::ord:
88	return "==";	1✔
89	case data_flow::TaskletCode::ult:
90	return "<";	1✔
91	case data_flow::TaskletCode::ule:
92	return "<=";	1✔
93	case data_flow::TaskletCode::ueq:
94	return "==";	1✔
95	case data_flow::TaskletCode::une:
96	return "!=";	1✔
97	case data_flow::TaskletCode::uge:
98	return ">=";	1✔
99	case data_flow::TaskletCode::ugt:
100	return ">";	1✔
101	case data_flow::TaskletCode::uno:
102	return "!=";	1✔
103	case data_flow::TaskletCode::abs:
104	return "abs";	1✔
105	case data_flow::TaskletCode::acos:
106	return "acos";	1✔
107	case data_flow::TaskletCode::acosf:
108	return "acosf";	1✔
109	case data_flow::TaskletCode::acosl:
110	return "acosl";	1✔
111	case data_flow::TaskletCode::acosh:
112	return "acosh";	1✔
113	case data_flow::TaskletCode::acoshf:
114	return "acoshf";	1✔
115	case data_flow::TaskletCode::acoshl:
116	return "acoshl";	1✔
117	case data_flow::TaskletCode::asin:
118	return "asin";	1✔
119	case data_flow::TaskletCode::asinf:
120	return "asinf";	1✔
121	case data_flow::TaskletCode::asinl:
122	return "asinl";	1✔
123	case data_flow::TaskletCode::asinh:
124	return "asinh";	1✔
125	case data_flow::TaskletCode::asinhf:
126	return "asinhf";	1✔
127	case data_flow::TaskletCode::asinhl:
128	return "asinhl";	1✔
129	case data_flow::TaskletCode::atan:
130	return "atan";	1✔
131	case data_flow::TaskletCode::atanf:
132	return "atanf";	1✔
133	case data_flow::TaskletCode::atanl:
134	return "atanl";	1✔
135	case data_flow::TaskletCode::atan2:
136	return "atan2";	1✔
137	case data_flow::TaskletCode::atan2f:
138	return "atan2f";	1✔
139	case data_flow::TaskletCode::atan2l:
140	return "atan2l";	1✔
141	case data_flow::TaskletCode::atanh:
142	return "atanh";	1✔
143	case data_flow::TaskletCode::atanhf:
144	return "atanhf";	1✔
145	case data_flow::TaskletCode::atanhl:
146	return "atanhl";	1✔
147	case data_flow::TaskletCode::cabs:
148	return "cabs";	1✔
149	case data_flow::TaskletCode::cabsf:
150	return "cabsf";	1✔
151	case data_flow::TaskletCode::cabsl:
152	return "cabsl";	1✔
153	case data_flow::TaskletCode::ceil:
154	return "ceil";	1✔
155	case data_flow::TaskletCode::ceilf:
156	return "ceilf";	1✔
157	case data_flow::TaskletCode::ceill:
158	return "ceill";	1✔
159	case data_flow::TaskletCode::copysign:
160	return "copysign";	1✔
161	case data_flow::TaskletCode::copysignf:
162	return "copysignf";	1✔
163	case data_flow::TaskletCode::copysignl:
164	return "copysignl";	1✔
165	case data_flow::TaskletCode::cos:
166	return "cos";	1✔
167	case data_flow::TaskletCode::cosf:
168	return "cosf";	1✔
169	case data_flow::TaskletCode::cosl:
170	return "cosl";	1✔
171	case data_flow::TaskletCode::cosh:
172	return "cosh";	1✔
173	case data_flow::TaskletCode::coshf:
174	return "coshf";	1✔
175	case data_flow::TaskletCode::coshl:
176	return "coshl";	1✔
177	case data_flow::TaskletCode::cbrt:
178	return "cbrt";	1✔
179	case data_flow::TaskletCode::cbrtf:
180	return "cbrtf";	1✔
181	case data_flow::TaskletCode::cbrtl:
182	return "cbrtl";	1✔
183	case data_flow::TaskletCode::exp10:
184	return "exp10";	1✔
185	case data_flow::TaskletCode::exp10f:
186	return "exp10f";	1✔
187	case data_flow::TaskletCode::exp10l:
188	return "exp10l";	1✔
189	case data_flow::TaskletCode::exp2:
190	return "exp2";	1✔
191	case data_flow::TaskletCode::exp2f:
192	return "exp2f";	1✔
193	case data_flow::TaskletCode::exp2l:
194	return "exp2l";	1✔
195	case data_flow::TaskletCode::exp:
196	return "exp";	1✔
197	case data_flow::TaskletCode::expf:
198	return "expf";	1✔
199	case data_flow::TaskletCode::expl:
200	return "expl";	1✔
201	case data_flow::TaskletCode::expm1:
202	return "expm1";	1✔
203	case data_flow::TaskletCode::expm1f:
204	return "expm1f";	1✔
205	case data_flow::TaskletCode::expm1l:
206	return "expm1l";	1✔
207	case data_flow::TaskletCode::fabs:
208	return "fabs";	1✔
209	case data_flow::TaskletCode::fabsf:
210	return "fabsf";	1✔
211	case data_flow::TaskletCode::fabsl:
212	return "fabsl";	1✔
213	case data_flow::TaskletCode::floor:
214	return "floor";	1✔
215	case data_flow::TaskletCode::floorf:
216	return "floorf";	1✔
217	case data_flow::TaskletCode::floorl:
218	return "floorl";	1✔
219	case data_flow::TaskletCode::fls:
220	return "fls";	1✔
221	case data_flow::TaskletCode::flsl:
222	return "flsl";	1✔
223	case data_flow::TaskletCode::fmax:
224	return "fmax";	1✔
225	case data_flow::TaskletCode::fmaxf:
226	return "fmaxf";	1✔
227	case data_flow::TaskletCode::fmaxl:
228	return "fmaxl";	1✔
229	case data_flow::TaskletCode::fmin:
230	return "fmin";	1✔
231	case data_flow::TaskletCode::fminf:
232	return "fminf";	1✔
233	case data_flow::TaskletCode::fminl:
234	return "fminl";	1✔
235	case data_flow::TaskletCode::fmod:
236	return "fmod";	1✔
237	case data_flow::TaskletCode::fmodf:
238	return "fmodf";	1✔
239	case data_flow::TaskletCode::fmodl:
240	return "fmodl";	1✔
241	case data_flow::TaskletCode::frexp:
242	return "frexp";	1✔
243	case data_flow::TaskletCode::frexpf:
244	return "frexpf";	1✔
245	case data_flow::TaskletCode::frexpl:
246	return "frexpl";	1✔
247	case data_flow::TaskletCode::labs:
248	return "labs";	1✔
249	case data_flow::TaskletCode::ldexp:
250	return "ldexp";	1✔
251	case data_flow::TaskletCode::ldexpf:
252	return "ldexpf";	1✔
253	case data_flow::TaskletCode::ldexpl:
254	return "ldexpl";	1✔
255	case data_flow::TaskletCode::log10:
256	return "log10";	1✔
257	case data_flow::TaskletCode::log10f:
258	return "log10f";	1✔
259	case data_flow::TaskletCode::log10l:
260	return "log10l";	1✔
261	case data_flow::TaskletCode::log2:
262	return "log2";	1✔
263	case data_flow::TaskletCode::log2f:
264	return "log2f";	1✔
265	case data_flow::TaskletCode::log2l:
266	return "log2l";	1✔
267	case data_flow::TaskletCode::log:
268	return "log";	1✔
269	case data_flow::TaskletCode::logf:
270	return "logf";	1✔
271	case data_flow::TaskletCode::logl:
272	return "logl";	1✔
273	case data_flow::TaskletCode::logb:
274	return "logb";	1✔
275	case data_flow::TaskletCode::logbf:
276	return "logbf";	1✔
277	case data_flow::TaskletCode::logbl:
278	return "logbl";	1✔
279	case data_flow::TaskletCode::log1p:
280	return "log1p";	1✔
281	case data_flow::TaskletCode::log1pf:
282	return "log1pf";	1✔
283	case data_flow::TaskletCode::log1pl:
284	return "log1pl";	1✔
285	case data_flow::TaskletCode::modf:
286	return "modf";	1✔
287	case data_flow::TaskletCode::modff:
288	return "modff";	1✔
289	case data_flow::TaskletCode::modfl:
290	return "modfl";	1✔
291	case data_flow::TaskletCode::nearbyint:
292	return "nearbyint";	1✔
293	case data_flow::TaskletCode::nearbyintf:
294	return "nearbyintf";	1✔
295	case data_flow::TaskletCode::nearbyintl:
296	return "nearbyintl";	1✔
297	case data_flow::TaskletCode::pow:
298	return "pow";	1✔
299	case data_flow::TaskletCode::powf:
300	return "powf";	1✔
301	case data_flow::TaskletCode::powl:
302	return "powl";	1✔
303	case data_flow::TaskletCode::rint:
304	return "rint";	1✔
305	case data_flow::TaskletCode::rintf:
306	return "rintf";	1✔
307	case data_flow::TaskletCode::rintl:
308	return "rintl";	1✔
309	case data_flow::TaskletCode::round:
310	return "round";	1✔
311	case data_flow::TaskletCode::roundf:
312	return "roundf";	1✔
313	case data_flow::TaskletCode::roundl:
314	return "roundl";	1✔
315	case data_flow::TaskletCode::roundeven:
316	return "roundeven";	1✔
317	case data_flow::TaskletCode::roundevenf:
318	return "roundevenf";	1✔
319	case data_flow::TaskletCode::roundevenl:
320	return "roundevenl";	1✔
321	case data_flow::TaskletCode::sin:
322	return "sin";	1✔
323	case data_flow::TaskletCode::sinf:
324	return "sinf";	1✔
325	case data_flow::TaskletCode::sinl:
326	return "sinl";	1✔
327	case data_flow::TaskletCode::sinh:
328	return "sinh";	1✔
329	case data_flow::TaskletCode::sinhf:
330	return "sinhf";	1✔
331	case data_flow::TaskletCode::sinhl:
332	return "sinhl";	1✔
333	case data_flow::TaskletCode::sqrt:
334	return "sqrt";	1✔
335	case data_flow::TaskletCode::sqrtf:
336	return "sqrtf";	1✔
337	case data_flow::TaskletCode::sqrtl:
338	return "sqrtl";	1✔
339	case data_flow::TaskletCode::rsqrt:
340	return "rsqrt";	1✔
341	case data_flow::TaskletCode::rsqrtf:
342	return "rsqrtf";	1✔
343	case data_flow::TaskletCode::rsqrtl:
344	return "rsqrtl";	1✔
345	case data_flow::TaskletCode::tan:
346	return "tan";	1✔
347	case data_flow::TaskletCode::tanf:
348	return "tanf";	1✔
349	case data_flow::TaskletCode::tanl:
350	return "tanl";	1✔
351	case data_flow::TaskletCode::tanh:
352	return "tanh";	1✔
353	case data_flow::TaskletCode::tanhf:
354	return "tanhf";	1✔
355	case data_flow::TaskletCode::tanhl:
356	return "tanhl";	1✔
357	};
358	throw InvalidSDFGException("code_to_string: Unsupported tasklet code");	×
359	};	175✔
360
361	std::string Visualizer::expression(const std::string expr) {	246✔
362	if (this->replacements_.empty()) return expr;	246✔
363	std::string res = expr;	×
364	size_t pos1 = 0, pos2 = 0;	×
365	for (std::pair<const std::string, const std::string> replace : this->replacements_) {	×
366	pos2 = res.find(replace.first);	×
367	if (pos2 == res.npos) continue;	×
368	pos1 = 0;	×
369	std::stringstream res_tmp;	×
370	while (pos2 < res.npos) {	×
371	res_tmp << res.substr(pos1, pos2 - pos1) << replace.second;	×
372	pos1 = pos2 + replace.first.size();	×
373	pos2 = res.find(replace.first, pos1);	×
374	}
375	if (pos1 < res.npos) res_tmp << res.substr(pos1);	×
376	res = res_tmp.str();	×
377	}	×
378	return res;	×
379	}	246✔
380
381	void Visualizer::visualizeNode(StructuredSDFG& sdfg,	190✔
382	structured_control_flow::ControlFlowNode& node) {
383	if (auto block = dynamic_cast<structured_control_flow::Block*>(&node)) {	190✔
384	this->visualizeBlock(sdfg, *block);	176✔
385	return;	176✔
386	}
387	if (auto sequence = dynamic_cast<structured_control_flow::Sequence*>(&node)) {	14✔
NEW 388	this->visualizeSequence(sdfg, *sequence);	×
389	return;	×
390	}
391	if (auto if_else = dynamic_cast<structured_control_flow::IfElse*>(&node)) {	14✔
392	this->visualizeIfElse(sdfg, *if_else);	3✔
393	return;	3✔
394	}
395	if (auto while_loop = dynamic_cast<structured_control_flow::While*>(&node)) {	11✔
396	this->visualizeWhile(sdfg, *while_loop);	2✔
397	return;	2✔
398	}
399	if (auto loop = dynamic_cast<structured_control_flow::For*>(&node)) {	9✔
400	this->visualizeFor(sdfg, *loop);	6✔
401	return;	6✔
402	}
403	if (auto return_node = dynamic_cast<structured_control_flow::Return*>(&node)) {	3✔
404	this->visualizeReturn(sdfg, *return_node);	1✔
405	return;	1✔
406	}
407	if (auto break_node = dynamic_cast<structured_control_flow::Break*>(&node)) {	2✔
408	this->visualizeBreak(sdfg, *break_node);	1✔
409	return;	1✔
410	}
411	if (auto continue_node = dynamic_cast<structured_control_flow::Continue*>(&node)) {	1✔
412	this->visualizeContinue(sdfg, *continue_node);	1✔
413	return;	1✔
414	}
415	if (auto map_node = dynamic_cast<structured_control_flow::Map*>(&node)) {	×
NEW 416	this->visualizeMap(sdfg, *map_node);	×
417	return;	×
418	}
419	throw std::runtime_error("Unsupported control flow node");	×
420	}	190✔
421
422	void Visualizer::visualizeTasklet(data_flow::Tasklet const& tasklet) {	175✔
423	std::string op = code_to_string(tasklet.code());	175✔
424	std::vector<std::string> arguments;	175✔
425	for (size_t i = 0; i < tasklet.inputs().size(); ++i) {	393✔
426	std::string arg = tasklet.input(i).first;	218✔
427	if (!tasklet.needs_connector(i)) {	218✔
428	if (arg != "NAN" && arg != "INFINITY") {	205✔
429	if (tasklet.input(i).second.primitive_type() == types::PrimitiveType::Float)	205✔
430	arg += "f";	×
431	}	205✔
432	}	205✔
433	arguments.push_back(this->expression(arg));	218✔
434	}	218✔
435
436	if (tasklet.code() == data_flow::TaskletCode::assign) {	175✔
437	this->stream_ << arguments.at(0);	5✔
438	} else if (tasklet.code() == data_flow::TaskletCode::fma) {	175✔
439	if (arguments.size() != 3) throw std::runtime_error("FMA requires 3 arguments");	3✔
440	this->stream_ << arguments.at(0) << " * " << arguments.at(1) << " + " << arguments.at(2);	3✔
441	} else if (data_flow::is_infix(tasklet.code())) {	170✔
442	switch (data_flow::arity(tasklet.code())) {	31✔
443	case 1:
444	this->stream_ << op << " " << arguments.at(0);	×
445	break;	×
446	case 2:
447	this->stream_ << arguments.at(0) << " " << op << " " << arguments.at(1);	31✔
448	break;	31✔
449	default:
450	throw std::runtime_error("Unsupported arity");	×
451	}
452	} else {	31✔
453	this->stream_ << op << "(" << helpers::join(arguments, ", ") << ")";	136✔
454	}
455	}	175✔
456
457	void Visualizer::visualizeForBounds(symbolic::Symbol const& indvar,	6✔
458	symbolic::Expression const& init,
459	symbolic::Condition const& condition,
460	symbolic::Expression const& update) {
461	if ((init->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER \|\|	12✔
462	init->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL) &&	×
463	(condition->get_type_code() == SymEngine::TypeID::SYMENGINE_STRICTLESSTHAN \|\|	6✔
464	condition->get_type_code() == SymEngine::TypeID::SYMENGINE_LESSTHAN) &&	2✔
465	condition->get_args().size() == 2 &&	6✔
466	condition->get_args().at(0)->__str__() == indvar->__str__() &&	6✔
467	(condition->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER \|\|	6✔
468	condition->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL) &&	6✔
469	update->get_type_code() == SymEngine::TypeID::SYMENGINE_ADD &&	6✔
470	update->get_args().size() == 2 &&	6✔
471	(update->get_args().at(0)->__str__() == indvar->__str__() \|\|	6✔
472	update->get_args().at(1)->__str__() == indvar->__str__()) &&	6✔
473	(update->get_args().at(0)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER \|\|	6✔
474	update->get_args().at(0)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL \|\|	×
475	update->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_INTEGER \|\|	×
476	update->get_args().at(1)->get_type_code() == SymEngine::TypeID::SYMENGINE_SYMBOL)) {	×
477	this->stream_ << indvar->get_name() << " = " << init->__str__() << ":";	6✔
478	if (condition->get_type_code() == SymEngine::TypeID::SYMENGINE_STRICTLESSTHAN)	6✔
479	this->stream_ << "(" << condition->get_args().at(1)->__str__() << "-1)";	4✔
480	else
481	this->stream_ << condition->get_args().at(1)->__str__();	2✔
482	size_t i = (update->get_args().at(0).get() == indvar.get()) ? 1 : 0;	6✔
483	if (update->get_args().at(i)->__str__() != "1")	6✔
484	this->stream_ << ":" << update->get_args().at(i)->__str__();	×
485	} else {	6✔
486	this->stream_ << indvar->get_name() << " = " << this->expression(init->__str__()) << "; "	×
487	<< this->expression(condition->__str__()) << "; " << indvar->get_name()	×
488	<< " = " << this->expression(update->__str__());	×
489	}
490	}	6✔
491
492	void Visualizer::visualizeLibraryNode(const data_flow::LibraryNodeCode libnode_type) {	×
493	switch (libnode_type) {	×
494	case data_flow::LibraryNodeCode::barrier_local:
495	this->stream_ << "Local Barrier";	×
496	break;	×
497	default:
498	throw std::runtime_error("Unsupported library node type");	×
499	}
500	}	×
501
502	void Visualizer::visualizeSubset(Function const& function, types::IType const& type,	204✔
503	data_flow::Subset const& sub) {
504	if (sub.empty()) return;	204✔
505	if (dynamic_cast<const types::Scalar*>(&type)) {	22✔
506	return;	×
507	} else if (auto array_type = dynamic_cast<const types::Array*>(&type)) {	22✔
508	this->stream_ << "[" << this->expression(sub.at(0)->__str__()) << "]";	6✔
509	if (sub.size() > 1) {	6✔
510	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	×
511	types::IType const& element_type = array_type->element_type();	×
512	this->visualizeSubset(function, element_type, element_subset);	×
513	}	×
514	} else if (auto pointer_type = dynamic_cast<const types::Pointer*>(&type)) {	22✔
515	this->stream_ << "[" << this->expression(sub.at(0)->__str__()) << "]";	16✔
516	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	16✔
517	types::IType const& pointee_type = pointer_type->pointee_type();	16✔
518	this->visualizeSubset(function, pointee_type, element_subset);	16✔
519	} else if (auto structure_type = dynamic_cast<const types::Structure*>(&type)) {	16✔
520	types::StructureDefinition const& definition = function.structure(structure_type->name());	×
521	this->stream_ << ".member_" << this->expression(sub.at(0)->__str__());	×
522	if (sub.size() > 1) {	×
523	auto member = SymEngine::rcp_dynamic_cast<const SymEngine::Integer>(sub.at(0));	×
524	types::IType const& member_type = definition.member_type(member);	×
525	data_flow::Subset element_subset(sub.begin() + 1, sub.end());	×
526	this->visualizeSubset(function, member_type, element_subset);	×
527	}	×
528	} else {	×
529	throw InvalidSDFGException("visualizeSubset: Unsupported type");	×
530	}
531	}	204✔
532
533	} // namespace visualizer
534	} // namespace sdfg

daisytuner / sdfglib / 15512392058

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