19192861975

Committed 08 Nov 2025 12:14PM UTC coverage: 61.281% (-0.1%) from 61.415%

Build # 19192861975

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #329 from daisytuner/trap-nodes

Trap nodes and unreachable return

Run Details

17 of 101 new or added lines in 7 files covered. (16.83%)

6 existing lines in 2 files now uncovered.

10264 of 16749 relevant lines covered (61.28%)

100.39 hits per line

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

77.78

/src/codegen/dispatchers/node_dispatcher_registry.cpp

#include "sdfg/codegen/dispatchers/node_dispatcher_registry.h"

#include "sdfg/codegen/dispatchers/block_dispatcher.h"
#include "sdfg/codegen/dispatchers/for_dispatcher.h"
#include "sdfg/codegen/dispatchers/if_else_dispatcher.h"
#include "sdfg/codegen/dispatchers/map_dispatcher.h"
#include "sdfg/codegen/dispatchers/sequence_dispatcher.h"
#include "sdfg/codegen/dispatchers/while_dispatcher.h"

#include "sdfg/data_flow/library_nodes/barrier_local_node.h"
#include "sdfg/data_flow/library_nodes/call_node.h"
#include "sdfg/data_flow/library_nodes/invoke_node.h"
#include "sdfg/data_flow/library_nodes/math/math.h"
#include "sdfg/data_flow/library_nodes/metadata_node.h"
#include "sdfg/data_flow/library_nodes/stdlib/stdlib.h"

namespace sdfg {
namespace codegen {

std::unique_ptr<NodeDispatcher> create_dispatcher(
    LanguageExtension& language_extension,
    StructuredSDFG& sdfg,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::ControlFlowNode& node,
    InstrumentationPlan& instrumentation_plan,
    ArgCapturePlan& arg_capture_plan
) {
    auto dispatcher = NodeDispatcherRegistry::instance().get_dispatcher(typeid(node));
    if (dispatcher) {
        return dispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan);
    }

    throw std::runtime_error("Unsupported control flow node: " + std::string(typeid(node).name()));
};

void register_default_dispatchers() {
    /* Control flow dispatchers */
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Block),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<BlockDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Block&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Sequence),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<SequenceDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Sequence&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::IfElse),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<IfElseDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::IfElse&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::While),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<WhileDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::While&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::For),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<ForDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::For&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Map),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<MapDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Map&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Return),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<ReturnDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Return&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Break),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<BreakDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Break&>(node),
                instrumentation,
                arg_capture
            );
        }
    );
    NodeDispatcherRegistry::instance().register_dispatcher(
        typeid(structured_control_flow::Continue),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::ControlFlowNode& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<ContinueDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Continue&>(node),
                instrumentation,
                arg_capture
            );
        }
    );

    /* Map dispatchers */
    MapDispatcherRegistry::instance().register_map_dispatcher(
        structured_control_flow::ScheduleType_Sequential::value(),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::Map& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<
                SequentialMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);
        }
    );
    MapDispatcherRegistry::instance().register_map_dispatcher(
        structured_control_flow::ScheduleType_CPU_Parallel::value(),
        [](LanguageExtension& language_extension,
           StructuredSDFG& sdfg,
           analysis::AnalysisManager& analysis_manager,
           structured_control_flow::Map& node,
           InstrumentationPlan& instrumentation,
           ArgCapturePlan& arg_capture) {
            return std::make_unique<
                CPUParallelMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);
        }
    );

    // stdlib
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Alloca.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::AllocaNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::AllocaNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Calloc.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::CallocNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::CallocNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Free.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::FreeNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::FreeNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Malloc.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::MallocNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MallocNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Memcpy.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::MemcpyNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemcpyNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Memmove.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::MemmoveNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemmoveNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Memset.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::MemsetNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemsetNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Trap.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::TrapNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::TrapNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        stdlib::LibraryNodeType_Unreachable.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<stdlib::UnreachableNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const stdlib::UnreachableNode&>(node)
            );
        }
    );

    // CallNode
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        data_flow::LibraryNodeType_Call.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<data_flow::CallNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const data_flow::CallNode&>(node)
            );
        }
    );
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        data_flow::LibraryNodeType_Invoke.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<data_flow::InvokeNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const data_flow::InvokeNode&>(node)
            );
        }
    );

    // BarrierLocal
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        data_flow::LibraryNodeType_BarrierLocal.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<data_flow::BarrierLocalNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const data_flow::BarrierLocalNode&>(node)
            );
        }
    );

    // Metadata
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        data_flow::LibraryNodeType_Metadata.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<data_flow::MetadataDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const data_flow::MetadataNode&>(node)
            );
        }
    );

    // Math

    // Intrinsic
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::LibraryNodeType_Intrinsic.value() + "::" + data_flow::ImplementationType_NONE.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<math::IntrinsicNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::IntrinsicNode&>(node)
            );
        }
    );

    // Dot - BLAS
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_BLAS.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<math::blas::DotNodeDispatcher_BLAS>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)
            );
        }
    );
    // Dot - CUBLAS
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLAS.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<math::blas::DotNodeDispatcher_CUBLAS>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)
            );
        }
    );

    // GEMM - BLAS
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_BLAS.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<math::blas::GEMMNodeDispatcher_BLAS>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)
            );
        }
    );
    // GEMM - CUBLAS
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLAS.value(),
        [](LanguageExtension& language_extension,
           const Function& function,
           const data_flow::DataFlowGraph& data_flow_graph,
           const data_flow::LibraryNode& node) {
            return std::make_unique<math::blas::GEMMNodeDispatcher_CUBLAS>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)
            );
        }
    );
}

} // namespace codegen
} // namespace sdfg

1	#include "sdfg/codegen/dispatchers/node_dispatcher_registry.h"
2
3	#include "sdfg/codegen/dispatchers/block_dispatcher.h"
4	#include "sdfg/codegen/dispatchers/for_dispatcher.h"
5	#include "sdfg/codegen/dispatchers/if_else_dispatcher.h"
6	#include "sdfg/codegen/dispatchers/map_dispatcher.h"
7	#include "sdfg/codegen/dispatchers/sequence_dispatcher.h"
8	#include "sdfg/codegen/dispatchers/while_dispatcher.h"
9
10	#include "sdfg/data_flow/library_nodes/barrier_local_node.h"
11	#include "sdfg/data_flow/library_nodes/call_node.h"
12	#include "sdfg/data_flow/library_nodes/invoke_node.h"
13	#include "sdfg/data_flow/library_nodes/math/math.h"
14	#include "sdfg/data_flow/library_nodes/metadata_node.h"
15	#include "sdfg/data_flow/library_nodes/stdlib/stdlib.h"
16
17	namespace sdfg {
18	namespace codegen {
19
20	std::unique_ptr<NodeDispatcher> create_dispatcher(	28✔
21	LanguageExtension& language_extension,
22	StructuredSDFG& sdfg,
23	analysis::AnalysisManager& analysis_manager,
24	structured_control_flow::ControlFlowNode& node,
25	InstrumentationPlan& instrumentation_plan,
26	ArgCapturePlan& arg_capture_plan
27	) {
28	auto dispatcher = NodeDispatcherRegistry::instance().get_dispatcher(typeid(node));	28✔
29	if (dispatcher) {	28✔
30	return dispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_plan, arg_capture_plan);	28✔
31	}
32
33	throw std::runtime_error("Unsupported control flow node: " + std::string(typeid(node).name()));	×
34	};	28✔
35
36	void register_default_dispatchers() {	2✔
37	/* Control flow dispatchers */
38	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
39	typeid(structured_control_flow::Block),	2✔
40	[](LanguageExtension& language_extension,	6✔
41	StructuredSDFG& sdfg,
42	analysis::AnalysisManager& analysis_manager,
43	structured_control_flow::ControlFlowNode& node,
44	InstrumentationPlan& instrumentation,
45	ArgCapturePlan& arg_capture) {
46	return std::make_unique<BlockDispatcher>(	4✔
47	language_extension,	4✔
48	sdfg,	4✔
49	analysis_manager,	4✔
50	static_cast<structured_control_flow::Block&>(node),	4✔
51	instrumentation,	4✔
52	arg_capture	4✔
53	);
54	}
55	);
56	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
57	typeid(structured_control_flow::Sequence),	2✔
58	[](LanguageExtension& language_extension,	20✔
59	StructuredSDFG& sdfg,
60	analysis::AnalysisManager& analysis_manager,
61	structured_control_flow::ControlFlowNode& node,
62	InstrumentationPlan& instrumentation,
63	ArgCapturePlan& arg_capture) {
64	return std::make_unique<SequenceDispatcher>(	18✔
65	language_extension,	18✔
66	sdfg,	18✔
67	analysis_manager,	18✔
68	static_cast<structured_control_flow::Sequence&>(node),	18✔
69	instrumentation,	18✔
70	arg_capture	18✔
71	);
72	}
73	);
74	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
75	typeid(structured_control_flow::IfElse),	2✔
76	[](LanguageExtension& language_extension,	3✔
77	StructuredSDFG& sdfg,
78	analysis::AnalysisManager& analysis_manager,
79	structured_control_flow::ControlFlowNode& node,
80	InstrumentationPlan& instrumentation,
81	ArgCapturePlan& arg_capture) {
82	return std::make_unique<IfElseDispatcher>(	1✔
83	language_extension,	1✔
84	sdfg,	1✔
85	analysis_manager,	1✔
86	static_cast<structured_control_flow::IfElse&>(node),	1✔
87	instrumentation,	1✔
88	arg_capture	1✔
89	);
90	}
91	);
92	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
93	typeid(structured_control_flow::While),	2✔
94	[](LanguageExtension& language_extension,	3✔
95	StructuredSDFG& sdfg,
96	analysis::AnalysisManager& analysis_manager,
97	structured_control_flow::ControlFlowNode& node,
98	InstrumentationPlan& instrumentation,
99	ArgCapturePlan& arg_capture) {
100	return std::make_unique<WhileDispatcher>(	1✔
101	language_extension,	1✔
102	sdfg,	1✔
103	analysis_manager,	1✔
104	static_cast<structured_control_flow::While&>(node),	1✔
105	instrumentation,	1✔
106	arg_capture	1✔
107	);
108	}
109	);
110	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
111	typeid(structured_control_flow::For),	2✔
112	[](LanguageExtension& language_extension,	3✔
113	StructuredSDFG& sdfg,
114	analysis::AnalysisManager& analysis_manager,
115	structured_control_flow::ControlFlowNode& node,
116	InstrumentationPlan& instrumentation,
117	ArgCapturePlan& arg_capture) {
118	return std::make_unique<ForDispatcher>(	1✔
119	language_extension,	1✔
120	sdfg,	1✔
121	analysis_manager,	1✔
122	static_cast<structured_control_flow::For&>(node),	1✔
123	instrumentation,	1✔
124	arg_capture	1✔
125	);
126	}
127	);
128	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
129	typeid(structured_control_flow::Map),	2✔
130	[](LanguageExtension& language_extension,	2✔
131	StructuredSDFG& sdfg,
132	analysis::AnalysisManager& analysis_manager,
133	structured_control_flow::ControlFlowNode& node,
134	InstrumentationPlan& instrumentation,
135	ArgCapturePlan& arg_capture) {
136	return std::make_unique<MapDispatcher>(	×
137	language_extension,	×
138	sdfg,	×
139	analysis_manager,	×
140	static_cast<structured_control_flow::Map&>(node),	×
141	instrumentation,	×
142	arg_capture	×
143	);
144	}
145	);
146	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
147	typeid(structured_control_flow::Return),	2✔
148	[](LanguageExtension& language_extension,	3✔
149	StructuredSDFG& sdfg,
150	analysis::AnalysisManager& analysis_manager,
151	structured_control_flow::ControlFlowNode& node,
152	InstrumentationPlan& instrumentation,
153	ArgCapturePlan& arg_capture) {
154	return std::make_unique<ReturnDispatcher>(	1✔
155	language_extension,	1✔
156	sdfg,	1✔
157	analysis_manager,	1✔
158	static_cast<structured_control_flow::Return&>(node),	1✔
159	instrumentation,	1✔
160	arg_capture	1✔
161	);
162	}
163	);
164	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
165	typeid(structured_control_flow::Break),	2✔
166	[](LanguageExtension& language_extension,	3✔
167	StructuredSDFG& sdfg,
168	analysis::AnalysisManager& analysis_manager,
169	structured_control_flow::ControlFlowNode& node,
170	InstrumentationPlan& instrumentation,
171	ArgCapturePlan& arg_capture) {
172	return std::make_unique<BreakDispatcher>(	1✔
173	language_extension,	1✔
174	sdfg,	1✔
175	analysis_manager,	1✔
176	static_cast<structured_control_flow::Break&>(node),	1✔
177	instrumentation,	1✔
178	arg_capture	1✔
179	);
180	}
181	);
182	NodeDispatcherRegistry::instance().register_dispatcher(	4✔
183	typeid(structured_control_flow::Continue),	2✔
184	[](LanguageExtension& language_extension,	3✔
185	StructuredSDFG& sdfg,
186	analysis::AnalysisManager& analysis_manager,
187	structured_control_flow::ControlFlowNode& node,
188	InstrumentationPlan& instrumentation,
189	ArgCapturePlan& arg_capture) {
190	return std::make_unique<ContinueDispatcher>(	1✔
191	language_extension,	1✔
192	sdfg,	1✔
193	analysis_manager,	1✔
194	static_cast<structured_control_flow::Continue&>(node),	1✔
195	instrumentation,	1✔
196	arg_capture	1✔
197	);
198	}
199	);
200
201	/* Map dispatchers */
202	MapDispatcherRegistry::instance().register_map_dispatcher(	4✔
203	structured_control_flow::ScheduleType_Sequential::value(),	2✔
204	[](LanguageExtension& language_extension,	3✔
205	StructuredSDFG& sdfg,
206	analysis::AnalysisManager& analysis_manager,
207	structured_control_flow::Map& node,
208	InstrumentationPlan& instrumentation,
209	ArgCapturePlan& arg_capture) {
210	return std::make_unique<	1✔
211	SequentialMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);	1✔
212	}
213	);
214	MapDispatcherRegistry::instance().register_map_dispatcher(	4✔
215	structured_control_flow::ScheduleType_CPU_Parallel::value(),	2✔
216	[](LanguageExtension& language_extension,	2✔
217	StructuredSDFG& sdfg,
218	analysis::AnalysisManager& analysis_manager,
219	structured_control_flow::Map& node,
220	InstrumentationPlan& instrumentation,
221	ArgCapturePlan& arg_capture) {
222	return std::make_unique<	×
223	CPUParallelMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);	×
224	}
225	);
226
227	// stdlib
228	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
229	stdlib::LibraryNodeType_Alloca.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
230	[](LanguageExtension& language_extension,	2✔
231	const Function& function,
232	const data_flow::DataFlowGraph& data_flow_graph,
233	const data_flow::LibraryNode& node) {
234	return std::make_unique<stdlib::AllocaNodeDispatcher>(	×
235	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::AllocaNode&>(node)	×
236	);
237	}
238	);
239	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
240	stdlib::LibraryNodeType_Calloc.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
241	[](LanguageExtension& language_extension,	2✔
242	const Function& function,
243	const data_flow::DataFlowGraph& data_flow_graph,
244	const data_flow::LibraryNode& node) {
245	return std::make_unique<stdlib::CallocNodeDispatcher>(	×
246	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::CallocNode&>(node)	×
247	);
248	}
249	);
250	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
251	stdlib::LibraryNodeType_Free.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
252	[](LanguageExtension& language_extension,	2✔
253	const Function& function,
254	const data_flow::DataFlowGraph& data_flow_graph,
255	const data_flow::LibraryNode& node) {
256	return std::make_unique<stdlib::FreeNodeDispatcher>(	×
257	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::FreeNode&>(node)	×
258	);
259	}
260	);
261	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
262	stdlib::LibraryNodeType_Malloc.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
263	[](LanguageExtension& language_extension,	2✔
264	const Function& function,
265	const data_flow::DataFlowGraph& data_flow_graph,
266	const data_flow::LibraryNode& node) {
267	return std::make_unique<stdlib::MallocNodeDispatcher>(	×
268	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MallocNode&>(node)	×
269	);
270	}
271	);
272	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
273	stdlib::LibraryNodeType_Memcpy.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
274	[](LanguageExtension& language_extension,	2✔
275	const Function& function,
276	const data_flow::DataFlowGraph& data_flow_graph,
277	const data_flow::LibraryNode& node) {
278	return std::make_unique<stdlib::MemcpyNodeDispatcher>(	×
279	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemcpyNode&>(node)	×
280	);
281	}
282	);
283	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
284	stdlib::LibraryNodeType_Memmove.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
285	[](LanguageExtension& language_extension,	2✔
286	const Function& function,
287	const data_flow::DataFlowGraph& data_flow_graph,
288	const data_flow::LibraryNode& node) {
289	return std::make_unique<stdlib::MemmoveNodeDispatcher>(	×
290	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemmoveNode&>(node)	×
291	);
292	}
293	);
294	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
295	stdlib::LibraryNodeType_Memset.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
296	[](LanguageExtension& language_extension,	2✔
297	const Function& function,
298	const data_flow::DataFlowGraph& data_flow_graph,
299	const data_flow::LibraryNode& node) {
300	return std::make_unique<stdlib::MemsetNodeDispatcher>(	×
301	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemsetNode&>(node)	×
302	);
303	}
304	);
305	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
306	stdlib::LibraryNodeType_Trap.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
307	[](LanguageExtension& language_extension,	2✔
308	const Function& function,
309	const data_flow::DataFlowGraph& data_flow_graph,
310	const data_flow::LibraryNode& node) {
NEW 311	return std::make_unique<stdlib::TrapNodeDispatcher>(	×
NEW 312	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::TrapNode&>(node)	×
313	);
314	}
315	);
316	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
317	stdlib::LibraryNodeType_Unreachable.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
318	[](LanguageExtension& language_extension,	2✔
319	const Function& function,
320	const data_flow::DataFlowGraph& data_flow_graph,
321	const data_flow::LibraryNode& node) {
NEW 322	return std::make_unique<stdlib::UnreachableNodeDispatcher>(	×
NEW 323	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::UnreachableNode&>(node)	×
324	);
325	}
326	);
327
328	// CallNode
329	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
330	data_flow::LibraryNodeType_Call.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
331	[](LanguageExtension& language_extension,	2✔
332	const Function& function,
333	const data_flow::DataFlowGraph& data_flow_graph,
334	const data_flow::LibraryNode& node) {
335	return std::make_unique<data_flow::CallNodeDispatcher>(	×
336	language_extension, function, data_flow_graph, dynamic_cast<const data_flow::CallNode&>(node)	×
337	);
338	}
339	);
340	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
341	data_flow::LibraryNodeType_Invoke.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
342	[](LanguageExtension& language_extension,	2✔
343	const Function& function,
344	const data_flow::DataFlowGraph& data_flow_graph,
345	const data_flow::LibraryNode& node) {
346	return std::make_unique<data_flow::InvokeNodeDispatcher>(	×
347	language_extension, function, data_flow_graph, dynamic_cast<const data_flow::InvokeNode&>(node)	×
348	);
349	}
350	);
351
352	// BarrierLocal
353	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
354	data_flow::LibraryNodeType_BarrierLocal.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
355	[](LanguageExtension& language_extension,	3✔
356	const Function& function,
357	const data_flow::DataFlowGraph& data_flow_graph,
358	const data_flow::LibraryNode& node) {
359	return std::make_unique<data_flow::BarrierLocalNodeDispatcher>(	1✔
360	language_extension, function, data_flow_graph, dynamic_cast<const data_flow::BarrierLocalNode&>(node)	1✔
361	);
362	}
363	);
364
365	// Metadata
366	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
367	data_flow::LibraryNodeType_Metadata.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
368	[](LanguageExtension& language_extension,	2✔
369	const Function& function,
370	const data_flow::DataFlowGraph& data_flow_graph,
371	const data_flow::LibraryNode& node) {
372	return std::make_unique<data_flow::MetadataDispatcher>(	×
373	language_extension, function, data_flow_graph, dynamic_cast<const data_flow::MetadataNode&>(node)	×
374	);
375	}
376	);
377
378	// Math
379
380	// Intrinsic
381	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
382	math::LibraryNodeType_Intrinsic.value() + "::" + data_flow::ImplementationType_NONE.value(),	2✔
383	[](LanguageExtension& language_extension,	2✔
384	const Function& function,
385	const data_flow::DataFlowGraph& data_flow_graph,
386	const data_flow::LibraryNode& node) {
387	return std::make_unique<math::IntrinsicNodeDispatcher>(	×
388	language_extension, function, data_flow_graph, dynamic_cast<const math::IntrinsicNode&>(node)	×
389	);
390	}
391	);
392
393	// Dot - BLAS
394	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
395	math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_BLAS.value(),	2✔
396	[](LanguageExtension& language_extension,	2✔
397	const Function& function,
398	const data_flow::DataFlowGraph& data_flow_graph,
399	const data_flow::LibraryNode& node) {
400	return std::make_unique<math::blas::DotNodeDispatcher_BLAS>(	×
401	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)	×
402	);
403	}
404	);
405	// Dot - CUBLAS
406	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
407	math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLAS.value(),	2✔
408	[](LanguageExtension& language_extension,	2✔
409	const Function& function,
410	const data_flow::DataFlowGraph& data_flow_graph,
411	const data_flow::LibraryNode& node) {
412	return std::make_unique<math::blas::DotNodeDispatcher_CUBLAS>(	×
413	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)	×
414	);
415	}
416	);
417
418	// GEMM - BLAS
419	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
420	math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_BLAS.value(),	2✔
421	[](LanguageExtension& language_extension,	2✔
422	const Function& function,
423	const data_flow::DataFlowGraph& data_flow_graph,
424	const data_flow::LibraryNode& node) {
425	return std::make_unique<math::blas::GEMMNodeDispatcher_BLAS>(	×
426	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)	×
427	);
428	}
429	);
430	// GEMM - CUBLAS
431	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	4✔
432	math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLAS.value(),	2✔
433	[](LanguageExtension& language_extension,	2✔
434	const Function& function,
435	const data_flow::DataFlowGraph& data_flow_graph,
436	const data_flow::LibraryNode& node) {
437	return std::make_unique<math::blas::GEMMNodeDispatcher_CUBLAS>(	×
438	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)	×
439	);
440	}
441	);
442	}	2✔
443
444	} // namespace codegen
445	} // namespace sdfg

daisytuner / sdfglib / 19192861975

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