19724821532

Committed 26 Nov 2025 07:54AM UTC coverage: 61.884% (-0.3%) from 62.187%

Build # 19724821532

Build Type

push

github

Committed by

web-flow

Commit Message

CUBLAS DOT with/without data transfers (#362)

* Split `ImplementationType_CUBLAS` into `ImplementationType_CUBLASWithTransfers` and `ImplementationType_CUBLASWithoutTransfers`
* Implemented dispatchers for CUBLAS DOT
* Added `<cstdint>` to C++ includes

Run Details

9 of 109 new or added lines in 4 files covered. (8.26%)

2 existing lines in 2 files now uncovered.

11248 of 18176 relevant lines covered (61.88%)

110.85 hits per line

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

76.92

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

daisytuner / sdfglib / 19724821532

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