18690518437

Committed 21 Oct 2025 04:19PM UTC coverage: 60.779% (-0.4%) from 61.158%

Build # 18690518437

Build Type

Pull #288

github

Committed by

web-flow

Commit Message

Merge ccfe2f66e into 41678795b

Pull Request Pull Request #288: Instrumentation info

Run Details

107 of 280 new or added lines in 20 files covered. (38.21%)

6 existing lines in 4 files now uncovered.

9397 of 15461 relevant lines covered (60.78%)

91.74 hits per line

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

78.74

/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/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
) {
    auto dispatcher = NodeDispatcherRegistry::instance().get_dispatcher(typeid(node));
    if (dispatcher) {
        return dispatcher(language_extension, sdfg, analysis_manager, node, instrumentation_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) {
            return std::make_unique<BlockDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Block&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<SequenceDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Sequence&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<IfElseDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::IfElse&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<WhileDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::While&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<ForDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::For&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<MapDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Map&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<ReturnDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Return&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<BreakDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Break&>(node),
                instrumentation
            );
        }
    );
    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) {
            return std::make_unique<ContinueDispatcher>(
                language_extension,
                sdfg,
                analysis_manager,
                static_cast<structured_control_flow::Continue&>(node),
                instrumentation
            );
        }
    );

    /* 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) {
            return std::make_unique<
                SequentialMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation);
        }
    );
    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) {
            return std::make_unique<
                CPUParallelMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation);
        }
    );

    // 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)
            );
        }
    );

    // 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)
            );
        }
    );

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

daisytuner / sdfglib / 18690518437

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