26463753889

Committed 26 May 2026 05:18PM UTC coverage: 60.864% (-0.02%) from 60.886%

Build # 26463753889

Build Type

Pull #719

github

Committed by

web-flow

Commit Message

Merge 0b90ddd88 into 707dadcf8

Pull Request Pull Request #719: Libnode ptr edges

Coverage Stats

961 of 1749 new or added lines in 52 files covered. (54.95%)

90 existing lines in 29 files now uncovered.

35222 of 57870 relevant lines covered (60.86%)

11043.61 hits per line

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

0.0

/opt/src/transformations/offloading/rocm_transform.cpp

#include "sdfg/transformations/offloading/rocm_transform.h"

#include <unordered_set>

#include "sdfg/structured_control_flow/block.h"
#include "sdfg/targets/rocm/rocm_data_offloading_node.h"
#include "sdfg/transformations/transformation.h"
#include "symengine/symengine_rcp.h"

namespace sdfg {
namespace rocm {

std::string ROCMTransform::name() const { return "ROCMTransform"; }

void ROCMTransform::add_device_buffer(
    builder::StructuredSDFGBuilder& builder,
    std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression arg_size
) {
    // Allocate device pointer
    auto& sdfg = builder.subject();
    auto& type = sdfg.type(host_arg_name);
    auto new_type = type.clone();
    new_type->storage_type(global_device_storage_type(arg_size));
    builder.add_container(device_arg_name, *new_type);
}

void ROCMTransform::allocate_device_arg(
    builder::StructuredSDFGBuilder& builder,
    Block& alloc_block,
    std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression arg_size,
    symbolic::Expression page_size
) {
    auto& sdfg = builder.subject();
    if (!builder.subject().exists(device_arg_name)) {
        auto& type = sdfg.type(host_arg_name);
        auto new_type = type.clone();
        new_type->storage_type(global_device_storage_type(arg_size));
        new_type->storage_type().allocation(types::StorageType::AllocationType::Unmanaged);
        new_type->storage_type().deallocation(types::StorageType::AllocationType::Unmanaged);
        new_type->storage_type().allocation_size(SymEngine::null);

        std::unordered_set<std::string> container_set(sdfg.containers().begin(), sdfg.containers().end());
        if (container_set.find(device_arg_name) == container_set.end()) {
            builder.add_container(device_arg_name, *new_type);
        }
    }
    auto& out_type = builder.subject().type(device_arg_name);

    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        alloc_block,
        host_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::NONE,
        offloading::BufferLifecycle::ALLOC,
        out_type,
        out_type,
        this->map_.debug_info(),
        arg_size,
        symbolic::zero()
    );
}

void ROCMTransform::deallocate_device_arg(
    builder::StructuredSDFGBuilder& builder,
    Block& dealloc_block,
    std::string device_arg_name,
    symbolic::Expression arg_size,
    symbolic::Expression page_size
) {
    auto& free_type = builder.subject().type(device_arg_name);
    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        dealloc_block,
        device_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::NONE,
        offloading::BufferLifecycle::FREE,
        free_type,
        free_type,
        this->map_.debug_info(),
        arg_size,
        symbolic::zero()
    );
}

void ROCMTransform::copy_to_device(
    builder::StructuredSDFGBuilder& builder,
    const std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression size,
    symbolic::Expression page_size,
    Block& copy_block
) {
    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        copy_block,
        host_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::H2D,
        offloading::BufferLifecycle::NO_CHANGE,
        builder.subject().type(host_arg_name),
        builder.subject().type(device_arg_name),
        this->map_.debug_info(),
        size,
        symbolic::integer(0)
    );
}

void ROCMTransform::copy_to_device_with_allocation(
    builder::StructuredSDFGBuilder& builder,
    const std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression size,
    symbolic::Expression page_size,
    Block& copy_block
) {
    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        copy_block,
        host_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::H2D,
        offloading::BufferLifecycle::ALLOC,
        builder.subject().type(host_arg_name),
        builder.subject().type(device_arg_name),
        this->map_.debug_info(),
        size,
        symbolic::integer(0)
    );
}

void ROCMTransform::copy_from_device(
    builder::StructuredSDFGBuilder& builder,
    Block& copy_out_block,
    const std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression size,
    symbolic::Expression page_size
) {
    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        copy_out_block,
        host_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::D2H,
        offloading::BufferLifecycle::NO_CHANGE,
        builder.subject().type(host_arg_name),
        builder.subject().type(device_arg_name),
        this->map_.debug_info(),
        size,
        symbolic::integer(0)
    );
}

void ROCMTransform::copy_from_device_with_free(
    builder::StructuredSDFGBuilder& builder,
    Block& copy_out_block,
    const std::string host_arg_name,
    std::string device_arg_name,
    symbolic::Expression size,
    symbolic::Expression page_size
) {
    offloading::add_offloading_node<ROCMDataOffloadingNode>(
        builder,
        copy_out_block,
        host_arg_name,
        device_arg_name,
        offloading::DataTransferDirection::D2H,
        offloading::BufferLifecycle::FREE,
        builder.subject().type(host_arg_name),
        builder.subject().type(device_arg_name),
        this->map_.debug_info(),
        size,
        symbolic::integer(0)
    );
}

void ROCMTransform::to_json(nlohmann::json& j) const {
    std::string loop_type;
    if (dynamic_cast<structured_control_flow::Map*>(&map_)) {
        loop_type = "map";
    } else {
        throw std::runtime_error("Unsupported loop type for serialization of loop: " + map_.indvar()->get_name());
    }

    j["transformation_type"] = this->name();
    j["subgraph"] = {{"0", {{"element_id", this->map_.element_id()}, {"type", loop_type}}}};
    j["parameters"] = {{"block_size", block_size_}};
};

ROCMTransform ROCMTransform::from_json(builder::StructuredSDFGBuilder& builder, const nlohmann::json& desc) {
    auto loop_id = desc["subgraph"]["0"]["element_id"].get<size_t>();
    size_t block_size = desc["parameters"]["block_size"].get<size_t>();
    auto element = builder.find_element_by_id(loop_id);
    if (!element) {
        throw transformations::
            InvalidTransformationDescriptionException("Element with ID " + std::to_string(loop_id) + " not found.");
    }
    auto map = dynamic_cast<structured_control_flow::Map*>(element);

    return ROCMTransform(*map, block_size);
};


} // namespace rocm
} // namespace sdfg

1	#include "sdfg/transformations/offloading/rocm_transform.h"
2
3	#include <unordered_set>
4
5	#include "sdfg/structured_control_flow/block.h"
6	#include "sdfg/targets/rocm/rocm_data_offloading_node.h"
7	#include "sdfg/transformations/transformation.h"
8	#include "symengine/symengine_rcp.h"
9
10	namespace sdfg {
11	namespace rocm {
12
13	std::string ROCMTransform::name() const { return "ROCMTransform"; }	×
14
15	void ROCMTransform::add_device_buffer(
16	builder::StructuredSDFGBuilder& builder,
17	std::string host_arg_name,
18	std::string device_arg_name,
19	symbolic::Expression arg_size
20	) {	×
21	// Allocate device pointer
22	auto& sdfg = builder.subject();	×
23	auto& type = sdfg.type(host_arg_name);	×
24	auto new_type = type.clone();	×
25	new_type->storage_type(global_device_storage_type(arg_size));	×
26	builder.add_container(device_arg_name, *new_type);	×
27	}	×
28
29	void ROCMTransform::allocate_device_arg(
30	builder::StructuredSDFGBuilder& builder,
31	Block& alloc_block,
32	std::string host_arg_name,
33	std::string device_arg_name,
34	symbolic::Expression arg_size,
35	symbolic::Expression page_size
36	) {	×
37	auto& sdfg = builder.subject();	×
38	if (!builder.subject().exists(device_arg_name)) {	×
39	auto& type = sdfg.type(host_arg_name);	×
40	auto new_type = type.clone();	×
41	new_type->storage_type(global_device_storage_type(arg_size));	×
42	new_type->storage_type().allocation(types::StorageType::AllocationType::Unmanaged);	×
43	new_type->storage_type().deallocation(types::StorageType::AllocationType::Unmanaged);	×
44	new_type->storage_type().allocation_size(SymEngine::null);	×
45
46	std::unordered_set<std::string> container_set(sdfg.containers().begin(), sdfg.containers().end());	×
47	if (container_set.find(device_arg_name) == container_set.end()) {	×
48	builder.add_container(device_arg_name, *new_type);	×
49	}	×
50	}	×
NEW 51	auto& out_type = builder.subject().type(device_arg_name);	×
52
NEW 53	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 54	builder,	×
55	alloc_block,	×
NEW 56	host_arg_name,	×
NEW 57	device_arg_name,	×
NEW 58	offloading::DataTransferDirection::NONE,	×
NEW 59	offloading::BufferLifecycle::ALLOC,	×
NEW 60	out_type,	×
NEW 61	out_type,	×
62	this->map_.debug_info(),	×
63	arg_size,	×
NEW 64	symbolic::zero()	×
65	);	×
UNCOV 66	}	×
67
68	void ROCMTransform::deallocate_device_arg(
69	builder::StructuredSDFGBuilder& builder,
70	Block& dealloc_block,
71	std::string device_arg_name,
72	symbolic::Expression arg_size,
73	symbolic::Expression page_size
74	) {	×
NEW 75	auto& free_type = builder.subject().type(device_arg_name);	×
NEW 76	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 77	builder,	×
78	dealloc_block,	×
NEW 79	device_arg_name,	×
NEW 80	device_arg_name,	×
NEW 81	offloading::DataTransferDirection::NONE,	×
NEW 82	offloading::BufferLifecycle::FREE,	×
NEW 83	free_type,	×
NEW 84	free_type,	×
85	this->map_.debug_info(),	×
86	arg_size,	×
NEW 87	symbolic::zero()	×
88	);	×
UNCOV 89	}	×
90
91	void ROCMTransform::copy_to_device(
92	builder::StructuredSDFGBuilder& builder,
93	const std::string host_arg_name,
94	std::string device_arg_name,
95	symbolic::Expression size,
96	symbolic::Expression page_size,
97	Block& copy_block
98	) {	×
NEW 99	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 100	builder,	×
101	copy_block,	×
NEW 102	host_arg_name,	×
NEW 103	device_arg_name,	×
NEW 104	offloading::DataTransferDirection::H2D,	×
NEW 105	offloading::BufferLifecycle::NO_CHANGE,	×
NEW 106	builder.subject().type(host_arg_name),	×
NEW 107	builder.subject().type(device_arg_name),	×
108	this->map_.debug_info(),	×
109	size,	×
NEW 110	symbolic::integer(0)	×
111	);	×
UNCOV 112	}	×
113
114	void ROCMTransform::copy_to_device_with_allocation(
115	builder::StructuredSDFGBuilder& builder,
116	const std::string host_arg_name,
117	std::string device_arg_name,
118	symbolic::Expression size,
119	symbolic::Expression page_size,
120	Block& copy_block
121	) {	×
NEW 122	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 123	builder,	×
124	copy_block,	×
NEW 125	host_arg_name,	×
NEW 126	device_arg_name,	×
NEW 127	offloading::DataTransferDirection::H2D,	×
NEW 128	offloading::BufferLifecycle::ALLOC,	×
NEW 129	builder.subject().type(host_arg_name),	×
NEW 130	builder.subject().type(device_arg_name),	×
131	this->map_.debug_info(),	×
132	size,	×
NEW 133	symbolic::integer(0)	×
134	);	×
UNCOV 135	}	×
136
137	void ROCMTransform::copy_from_device(
138	builder::StructuredSDFGBuilder& builder,
139	Block& copy_out_block,
140	const std::string host_arg_name,
141	std::string device_arg_name,
142	symbolic::Expression size,
143	symbolic::Expression page_size
144	) {	×
NEW 145	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 146	builder,	×
147	copy_out_block,	×
NEW 148	host_arg_name,	×
NEW 149	device_arg_name,	×
NEW 150	offloading::DataTransferDirection::D2H,	×
NEW 151	offloading::BufferLifecycle::NO_CHANGE,	×
NEW 152	builder.subject().type(host_arg_name),	×
NEW 153	builder.subject().type(device_arg_name),	×
154	this->map_.debug_info(),	×
155	size,	×
NEW 156	symbolic::integer(0)	×
157	);	×
UNCOV 158	}	×
159
160	void ROCMTransform::copy_from_device_with_free(
161	builder::StructuredSDFGBuilder& builder,
162	Block& copy_out_block,
163	const std::string host_arg_name,
164	std::string device_arg_name,
165	symbolic::Expression size,
166	symbolic::Expression page_size
167	) {	×
NEW 168	offloading::add_offloading_node<ROCMDataOffloadingNode>(	×
NEW 169	builder,	×
170	copy_out_block,	×
NEW 171	host_arg_name,	×
NEW 172	device_arg_name,	×
NEW 173	offloading::DataTransferDirection::D2H,	×
NEW 174	offloading::BufferLifecycle::FREE,	×
NEW 175	builder.subject().type(host_arg_name),	×
NEW 176	builder.subject().type(device_arg_name),	×
177	this->map_.debug_info(),	×
178	size,	×
NEW 179	symbolic::integer(0)	×
180	);	×
UNCOV 181	}	×
182
183	void ROCMTransform::to_json(nlohmann::json& j) const {	×
184	std::string loop_type;	×
185	if (dynamic_cast<structured_control_flow::Map*>(&map_)) {	×
186	loop_type = "map";	×
187	} else {	×
188	throw std::runtime_error("Unsupported loop type for serialization of loop: " + map_.indvar()->get_name());	×
189	}	×
190
191	j["transformation_type"] = this->name();	×
192	j["subgraph"] = {{"0", {{"element_id", this->map_.element_id()}, {"type", loop_type}}}};	×
193	j["parameters"] = {{"block_size", block_size_}};	×
194	};	×
195
196	ROCMTransform ROCMTransform::from_json(builder::StructuredSDFGBuilder& builder, const nlohmann::json& desc) {	×
197	auto loop_id = desc["subgraph"]["0"]["element_id"].get<size_t>();	×
198	size_t block_size = desc["parameters"]["block_size"].get<size_t>();	×
199	auto element = builder.find_element_by_id(loop_id);	×
200	if (!element) {	×
201	throw transformations::	×
202	InvalidTransformationDescriptionException("Element with ID " + std::to_string(loop_id) + " not found.");	×
203	}	×
204	auto map = dynamic_cast<structured_control_flow::Map*>(element);	×
205
206	return ROCMTransform(*map, block_size);	×
207	};	×
208
209
210	} // namespace rocm
211	} // namespace sdfg

daisytuner / docc / 26463753889

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