20764569418

Committed 06 Jan 2026 10:50PM UTC coverage: 62.168% (+21.4%) from 40.764%

Build # 20764569418

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #433 from daisytuner/clang-coverage

updates clang coverage flags

Run Details

14988 of 24109 relevant lines covered (62.17%)

88.57 hits per line

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

77.83

/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

    // CMath
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::cmath::LibraryNodeType_CMath.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::cmath::CMathNodeDispatcher>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::cmath::CMathNode&>(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 with data transfers
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLASWithTransfers.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_CUBLASWithTransfers>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)
            );
        }
    );
    // Dot - CUBLAS without data transfers
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLASWithoutTransfers.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_CUBLASWithoutTransfers>(
                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 with data transfers
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLASWithTransfers.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_CUBLASWithTransfers>(
                language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)
            );
        }
    );
    // GEMM - CUBLAS without data transfers
    LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(
        math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLASWithoutTransfers.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_CUBLASWithoutTransfers>(
                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(
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✔
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	}	28✔
32
33	throw std::runtime_error("Unsupported control flow node: " + std::string(typeid(node).name()));	×
34	};	28✔
35
36	void register_default_dispatchers() {	1✔
37	/* Control flow dispatchers */
38	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
39	typeid(structured_control_flow::Block),	1✔
40	[](LanguageExtension& language_extension,	1✔
41	StructuredSDFG& sdfg,	1✔
42	analysis::AnalysisManager& analysis_manager,	1✔
43	structured_control_flow::ControlFlowNode& node,	1✔
44	InstrumentationPlan& instrumentation,	1✔
45	ArgCapturePlan& arg_capture) {	4✔
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	);	4✔
54	}	4✔
55	);	1✔
56	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
57	typeid(structured_control_flow::Sequence),	1✔
58	[](LanguageExtension& language_extension,	1✔
59	StructuredSDFG& sdfg,	1✔
60	analysis::AnalysisManager& analysis_manager,	1✔
61	structured_control_flow::ControlFlowNode& node,	1✔
62	InstrumentationPlan& instrumentation,	1✔
63	ArgCapturePlan& arg_capture) {	18✔
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	);	18✔
72	}	18✔
73	);	1✔
74	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
75	typeid(structured_control_flow::IfElse),	1✔
76	[](LanguageExtension& language_extension,	1✔
77	StructuredSDFG& sdfg,	1✔
78	analysis::AnalysisManager& analysis_manager,	1✔
79	structured_control_flow::ControlFlowNode& node,	1✔
80	InstrumentationPlan& instrumentation,	1✔
81	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
90	}	1✔
91	);	1✔
92	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
93	typeid(structured_control_flow::While),	1✔
94	[](LanguageExtension& language_extension,	1✔
95	StructuredSDFG& sdfg,	1✔
96	analysis::AnalysisManager& analysis_manager,	1✔
97	structured_control_flow::ControlFlowNode& node,	1✔
98	InstrumentationPlan& instrumentation,	1✔
99	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
108	}	1✔
109	);	1✔
110	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
111	typeid(structured_control_flow::For),	1✔
112	[](LanguageExtension& language_extension,	1✔
113	StructuredSDFG& sdfg,	1✔
114	analysis::AnalysisManager& analysis_manager,	1✔
115	structured_control_flow::ControlFlowNode& node,	1✔
116	InstrumentationPlan& instrumentation,	1✔
117	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
126	}	1✔
127	);	1✔
128	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
129	typeid(structured_control_flow::Map),	1✔
130	[](LanguageExtension& language_extension,	1✔
131	StructuredSDFG& sdfg,	1✔
132	analysis::AnalysisManager& analysis_manager,	1✔
133	structured_control_flow::ControlFlowNode& node,	1✔
134	InstrumentationPlan& instrumentation,	1✔
135	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
146	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
147	typeid(structured_control_flow::Return),	1✔
148	[](LanguageExtension& language_extension,	1✔
149	StructuredSDFG& sdfg,	1✔
150	analysis::AnalysisManager& analysis_manager,	1✔
151	structured_control_flow::ControlFlowNode& node,	1✔
152	InstrumentationPlan& instrumentation,	1✔
153	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
162	}	1✔
163	);	1✔
164	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
165	typeid(structured_control_flow::Break),	1✔
166	[](LanguageExtension& language_extension,	1✔
167	StructuredSDFG& sdfg,	1✔
168	analysis::AnalysisManager& analysis_manager,	1✔
169	structured_control_flow::ControlFlowNode& node,	1✔
170	InstrumentationPlan& instrumentation,	1✔
171	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
180	}	1✔
181	);	1✔
182	NodeDispatcherRegistry::instance().register_dispatcher(	1✔
183	typeid(structured_control_flow::Continue),	1✔
184	[](LanguageExtension& language_extension,	1✔
185	StructuredSDFG& sdfg,	1✔
186	analysis::AnalysisManager& analysis_manager,	1✔
187	structured_control_flow::ControlFlowNode& node,	1✔
188	InstrumentationPlan& instrumentation,	1✔
189	ArgCapturePlan& arg_capture) {	1✔
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	);	1✔
198	}	1✔
199	);	1✔
200
201	/* Map dispatchers */
202	MapDispatcherRegistry::instance().register_map_dispatcher(	1✔
203	structured_control_flow::ScheduleType_Sequential::value(),	1✔
204	[](LanguageExtension& language_extension,	1✔
205	StructuredSDFG& sdfg,	1✔
206	analysis::AnalysisManager& analysis_manager,	1✔
207	structured_control_flow::Map& node,	1✔
208	InstrumentationPlan& instrumentation,	1✔
209	ArgCapturePlan& arg_capture) {	1✔
210	return std::make_unique<	×
211	SequentialMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);	×
212	}	×
213	);	1✔
214	MapDispatcherRegistry::instance().register_map_dispatcher(	1✔
215	structured_control_flow::ScheduleType_CPU_Parallel::value(),	1✔
216	[](LanguageExtension& language_extension,	1✔
217	StructuredSDFG& sdfg,	1✔
218	analysis::AnalysisManager& analysis_manager,	1✔
219	structured_control_flow::Map& node,	1✔
220	InstrumentationPlan& instrumentation,	1✔
221	ArgCapturePlan& arg_capture) {	1✔
222	return std::make_unique<	×
223	CPUParallelMapDispatcher>(language_extension, sdfg, analysis_manager, node, instrumentation, arg_capture);	×
224	}	×
225	);	1✔
226
227	// stdlib
228	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
229	stdlib::LibraryNodeType_Alloca.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
230	[](LanguageExtension& language_extension,	1✔
231	const Function& function,	1✔
232	const data_flow::DataFlowGraph& data_flow_graph,	1✔
233	const data_flow::LibraryNode& node) {	1✔
234	return std::make_unique<stdlib::AllocaNodeDispatcher>(	×
235	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::AllocaNode&>(node)	×
236	);	×
237	}	×
238	);	1✔
239	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
240	stdlib::LibraryNodeType_Calloc.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
241	[](LanguageExtension& language_extension,	1✔
242	const Function& function,	1✔
243	const data_flow::DataFlowGraph& data_flow_graph,	1✔
244	const data_flow::LibraryNode& node) {	1✔
245	return std::make_unique<stdlib::CallocNodeDispatcher>(	×
246	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::CallocNode&>(node)	×
247	);	×
248	}	×
249	);	1✔
250	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
251	stdlib::LibraryNodeType_Free.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
252	[](LanguageExtension& language_extension,	1✔
253	const Function& function,	1✔
254	const data_flow::DataFlowGraph& data_flow_graph,	1✔
255	const data_flow::LibraryNode& node) {	1✔
256	return std::make_unique<stdlib::FreeNodeDispatcher>(	×
257	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::FreeNode&>(node)	×
258	);	×
259	}	×
260	);	1✔
261	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
262	stdlib::LibraryNodeType_Malloc.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
263	[](LanguageExtension& language_extension,	1✔
264	const Function& function,	1✔
265	const data_flow::DataFlowGraph& data_flow_graph,	1✔
266	const data_flow::LibraryNode& node) {	1✔
267	return std::make_unique<stdlib::MallocNodeDispatcher>(	×
268	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MallocNode&>(node)	×
269	);	×
270	}	×
271	);	1✔
272	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
273	stdlib::LibraryNodeType_Memcpy.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
274	[](LanguageExtension& language_extension,	1✔
275	const Function& function,	1✔
276	const data_flow::DataFlowGraph& data_flow_graph,	1✔
277	const data_flow::LibraryNode& node) {	1✔
278	return std::make_unique<stdlib::MemcpyNodeDispatcher>(	×
279	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemcpyNode&>(node)	×
280	);	×
281	}	×
282	);	1✔
283	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
284	stdlib::LibraryNodeType_Memmove.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
285	[](LanguageExtension& language_extension,	1✔
286	const Function& function,	1✔
287	const data_flow::DataFlowGraph& data_flow_graph,	1✔
288	const data_flow::LibraryNode& node) {	1✔
289	return std::make_unique<stdlib::MemmoveNodeDispatcher>(	×
290	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemmoveNode&>(node)	×
291	);	×
292	}	×
293	);	1✔
294	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
295	stdlib::LibraryNodeType_Memset.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
296	[](LanguageExtension& language_extension,	1✔
297	const Function& function,	1✔
298	const data_flow::DataFlowGraph& data_flow_graph,	1✔
299	const data_flow::LibraryNode& node) {	1✔
300	return std::make_unique<stdlib::MemsetNodeDispatcher>(	×
301	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::MemsetNode&>(node)	×
302	);	×
303	}	×
304	);	1✔
305	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
306	stdlib::LibraryNodeType_Trap.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
307	[](LanguageExtension& language_extension,	1✔
308	const Function& function,	1✔
309	const data_flow::DataFlowGraph& data_flow_graph,	1✔
310	const data_flow::LibraryNode& node) {	1✔
311	return std::make_unique<stdlib::TrapNodeDispatcher>(	×
312	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::TrapNode&>(node)	×
313	);	×
314	}	×
315	);	1✔
316	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
317	stdlib::LibraryNodeType_Unreachable.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
318	[](LanguageExtension& language_extension,	1✔
319	const Function& function,	1✔
320	const data_flow::DataFlowGraph& data_flow_graph,	1✔
321	const data_flow::LibraryNode& node) {	1✔
322	return std::make_unique<stdlib::UnreachableNodeDispatcher>(	×
323	language_extension, function, data_flow_graph, dynamic_cast<const stdlib::UnreachableNode&>(node)	×
324	);	×
325	}	×
326	);	1✔
327
328	// CallNode
329	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
330	data_flow::LibraryNodeType_Call.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
331	[](LanguageExtension& language_extension,	1✔
332	const Function& function,	1✔
333	const data_flow::DataFlowGraph& data_flow_graph,	1✔
334	const data_flow::LibraryNode& node) {	1✔
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	);	1✔
340	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
341	data_flow::LibraryNodeType_Invoke.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
342	[](LanguageExtension& language_extension,	1✔
343	const Function& function,	1✔
344	const data_flow::DataFlowGraph& data_flow_graph,	1✔
345	const data_flow::LibraryNode& node) {	1✔
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	);	1✔
351
352	// BarrierLocal
353	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
354	data_flow::LibraryNodeType_BarrierLocal.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
355	[](LanguageExtension& language_extension,	1✔
356	const Function& function,	1✔
357	const data_flow::DataFlowGraph& data_flow_graph,	1✔
358	const data_flow::LibraryNode& node) {	1✔
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	);	1✔
362	}	1✔
363	);	1✔
364
365	// Metadata
366	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
367	data_flow::LibraryNodeType_Metadata.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
368	[](LanguageExtension& language_extension,	1✔
369	const Function& function,	1✔
370	const data_flow::DataFlowGraph& data_flow_graph,	1✔
371	const data_flow::LibraryNode& node) {	1✔
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	);	1✔
377
378	// Math
379
380	// CMath
381	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
382	math::cmath::LibraryNodeType_CMath.value() + "::" + data_flow::ImplementationType_NONE.value(),	1✔
383	[](LanguageExtension& language_extension,	1✔
384	const Function& function,	1✔
385	const data_flow::DataFlowGraph& data_flow_graph,	1✔
386	const data_flow::LibraryNode& node) {	1✔
387	return std::make_unique<math::cmath::CMathNodeDispatcher>(	×
388	language_extension, function, data_flow_graph, dynamic_cast<const math::cmath::CMathNode&>(node)	×
389	);	×
390	}	×
391	);	1✔
392
393	// Dot - BLAS
394	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
395	math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_BLAS.value(),	1✔
396	[](LanguageExtension& language_extension,	1✔
397	const Function& function,	1✔
398	const data_flow::DataFlowGraph& data_flow_graph,	1✔
399	const data_flow::LibraryNode& node) {	1✔
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	);	1✔
405	// Dot - CUBLAS with data transfers
406	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
407	math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLASWithTransfers.value(),	1✔
408	[](LanguageExtension& language_extension,	1✔
409	const Function& function,	1✔
410	const data_flow::DataFlowGraph& data_flow_graph,	1✔
411	const data_flow::LibraryNode& node) {	1✔
412	return std::make_unique<math::blas::DotNodeDispatcher_CUBLASWithTransfers>(	×
413	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)	×
414	);	×
415	}	×
416	);	1✔
417	// Dot - CUBLAS without data transfers
418	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
419	math::blas::LibraryNodeType_DOT.value() + "::" + math::blas::ImplementationType_CUBLASWithoutTransfers.value(),	1✔
420	[](LanguageExtension& language_extension,	1✔
421	const Function& function,	1✔
422	const data_flow::DataFlowGraph& data_flow_graph,	1✔
423	const data_flow::LibraryNode& node) {	1✔
424	return std::make_unique<math::blas::DotNodeDispatcher_CUBLASWithoutTransfers>(	×
425	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::DotNode&>(node)	×
426	);	×
427	}	×
428	);	1✔
429
430	// GEMM - BLAS
431	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
432	math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_BLAS.value(),	1✔
433	[](LanguageExtension& language_extension,	1✔
434	const Function& function,	1✔
435	const data_flow::DataFlowGraph& data_flow_graph,	1✔
436	const data_flow::LibraryNode& node) {	1✔
437	return std::make_unique<math::blas::GEMMNodeDispatcher_BLAS>(	×
438	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)	×
439	);	×
440	}	×
441	);	1✔
442	// GEMM - CUBLAS with data transfers
443	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
444	math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLASWithTransfers.value(),	1✔
445	[](LanguageExtension& language_extension,	1✔
446	const Function& function,	1✔
447	const data_flow::DataFlowGraph& data_flow_graph,	1✔
448	const data_flow::LibraryNode& node) {	1✔
449	return std::make_unique<math::blas::GEMMNodeDispatcher_CUBLASWithTransfers>(	×
450	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)	×
451	);	×
452	}	×
453	);	1✔
454	// GEMM - CUBLAS without data transfers
455	LibraryNodeDispatcherRegistry::instance().register_library_node_dispatcher(	1✔
456	math::blas::LibraryNodeType_GEMM.value() + "::" + math::blas::ImplementationType_CUBLASWithoutTransfers.value(),	1✔
457	[](LanguageExtension& language_extension,	1✔
458	const Function& function,	1✔
459	const data_flow::DataFlowGraph& data_flow_graph,	1✔
460	const data_flow::LibraryNode& node) {	1✔
461	return std::make_unique<math::blas::GEMMNodeDispatcher_CUBLASWithoutTransfers>(	×
462	language_extension, function, data_flow_graph, dynamic_cast<const math::blas::GEMMNode&>(node)	×
463	);	×
464	}	×
465	);	1✔
466	}	1✔
467
468	} // namespace codegen
469	} // namespace sdfg

daisytuner / sdfglib / 20764569418

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