27876065887

Committed 20 Jun 2026 03:46PM UTC coverage: 61.765% (-0.07%) from 61.832%

Build # 27876065887

Build Type

Pull #789

github

Committed by

web-flow

Commit Message

Merge 79a38c1d2 into b7103c21a

Pull Request Pull Request #789: Device Residency

Coverage Stats

81 of 204 new or added lines in 6 files covered. (39.71%)

2 existing lines in 2 files now uncovered.

37026 of 59947 relevant lines covered (61.76%)

1015.8 hits per line

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

43.59

/opt/src/passes/offloading/rocm_library_node_rewriter_pass.cpp

#include "sdfg/passes/offloading/rocm_library_node_rewriter_pass.h"
#include <optional>

#include "sdfg/data_flow/library_nodes/math/math.h"
#include "sdfg/data_flow/library_nodes/stdlib/memset.h"
#include "sdfg/symbolic/symbolic.h"
#include "sdfg/targets/rocm/rocm.h"

namespace sdfg {
namespace rocm {

std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
    try_library_node_implementation(const data_flow::LibraryNode& lib_node, types::PrimitiveType data_type) {
    if (data_type == types::PrimitiveType::Float || data_type == types::PrimitiveType::Double) {
        if (lib_node.code() == math::blas::LibraryNodeType_GEMM.value()) {
            auto& gemm_node = static_cast<const math::blas::GEMMNode&>(lib_node);
            return try_rocm_gemm_node_implementation(gemm_node, data_type);
        } else if (lib_node.code() == math::blas::LibraryNodeType_DOT.value()) {
            return rocm::ImplementationType_ROCMWithTransfers;
        } else {
            return std::nullopt;
        }
    } else {
        return std::nullopt;
    }
}

std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
    try_rocm_gemm_node_implementation(const math::blas::GEMMNode& gemm_node, types::PrimitiveType data_type) {
    return rocm::ImplementationType_ROCMWithTransfers;
}

std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
    try_memset_implementation(const ::sdfg::stdlib::MemsetNode& memset_node) {
    return rocm::ImplementationType_ROCMWithTransfers;
}

RocmLibraryNodeRewriter::
    RocmLibraryNodeRewriter(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager)
    : visitor::StructuredSDFGVisitor(builder, analysis_manager) {}

bool RocmLibraryNodeRewriter::accept(structured_control_flow::Block& node) {
    auto& dataflow = node.dataflow();
    for (auto& library_node : dataflow.nodes()) {
        if (auto lib_node = dynamic_cast<math::blas::BLASNode*>(&library_node)) {
            auto implType = try_library_node_implementation(*lib_node, lib_node->scalar_primitive());

            if (implType) {
                lib_node->implementation_type() = implType.value();
            }
        }
        if (auto memset_node = dynamic_cast<::sdfg::stdlib::MemsetNode*>(&library_node)) {
            auto implType = try_memset_implementation(*memset_node);
            if (implType) {
                memset_node->implementation_type() = implType.value();
            }
        }
    }
    return false;
}

} // namespace rocm
} // namespace sdfg

1	#include "sdfg/passes/offloading/rocm_library_node_rewriter_pass.h"
2	#include <optional>
3
4	#include "sdfg/data_flow/library_nodes/math/math.h"
5	#include "sdfg/data_flow/library_nodes/stdlib/memset.h"
6	#include "sdfg/symbolic/symbolic.h"
7	#include "sdfg/targets/rocm/rocm.h"
8
9	namespace sdfg {
10	namespace rocm {
11
12	std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
13	try_library_node_implementation(const data_flow::LibraryNode& lib_node, types::PrimitiveType data_type) {	×
14	if (data_type == types::PrimitiveType::Float \|\| data_type == types::PrimitiveType::Double) {	×
15	if (lib_node.code() == math::blas::LibraryNodeType_GEMM.value()) {	×
16	auto& gemm_node = static_cast<const math::blas::GEMMNode&>(lib_node);	×
17	return try_rocm_gemm_node_implementation(gemm_node, data_type);	×
18	} else if (lib_node.code() == math::blas::LibraryNodeType_DOT.value()) {	×
19	return rocm::ImplementationType_ROCMWithTransfers;	×
20	} else {	×
21	return std::nullopt;	×
22	}	×
23	} else {	×
24	return std::nullopt;	×
25	}	×
26	}	×
27
28	std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
29	try_rocm_gemm_node_implementation(const math::blas::GEMMNode& gemm_node, types::PrimitiveType data_type) {	×
UNCOV 30	return rocm::ImplementationType_ROCMWithTransfers;	×
31	}	×
32
33	std::optional<data_flow::ImplementationType> RocmLibraryNodeRewriter::
34	try_memset_implementation(const ::sdfg::stdlib::MemsetNode& memset_node) {	2✔
35	return rocm::ImplementationType_ROCMWithTransfers;	2✔
36	}	2✔
37
38	RocmLibraryNodeRewriter::
39	RocmLibraryNodeRewriter(builder::StructuredSDFGBuilder& builder, analysis::AnalysisManager& analysis_manager)
40	: visitor::StructuredSDFGVisitor(builder, analysis_manager) {}	2✔
41
42	bool RocmLibraryNodeRewriter::accept(structured_control_flow::Block& node) {	2✔
43	auto& dataflow = node.dataflow();	2✔
44	for (auto& library_node : dataflow.nodes()) {	4✔
45	if (auto lib_node = dynamic_cast<math::blas::BLASNode*>(&library_node)) {	4✔
46	auto implType = try_library_node_implementation(*lib_node, lib_node->scalar_primitive());	×
47
48	if (implType) {	×
49	lib_node->implementation_type() = implType.value();	×
50	}	×
51	}	×
52	if (auto memset_node = dynamic_cast<::sdfg::stdlib::MemsetNode*>(&library_node)) {	4✔
53	auto implType = try_memset_implementation(*memset_node);	2✔
54	if (implType) {	2✔
55	memset_node->implementation_type() = implType.value();	2✔
56	}	2✔
57	}	2✔
58	}	4✔
59	return false;	2✔
60	}	2✔
61
62	} // namespace rocm
63	} // namespace sdfg

daisytuner / docc / 27876065887

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