23339691255

Committed 20 Mar 2026 10:53AM UTC coverage: 64.293% (+0.2%) from 64.115%

Build # 23339691255

Build Type

Pull #603

github

Committed by

web-flow

Commit Message

Merge cf3873416 into 3f0642c14

Pull Request Pull Request #603: Loop Collapse Transform

Coverage Stats

243 of 265 new or added lines in 4 files covered. (91.7%)

1 existing line in 1 file now uncovered.

26647 of 41446 relevant lines covered (64.29%)

406.67 hits per line

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

71.43

/opt/src/passes/scheduler/cuda_scheduler.cpp

#include "sdfg/passes/scheduler/cuda_scheduler.h"

#include "sdfg/passes/scheduler/loop_scheduler.h"
#include "sdfg/passes/symbolic/symbol_propagation.h"
#include "sdfg/structured_control_flow/map.h"
#include "sdfg/transformations/collapse_to_depth.h"
#include "sdfg/transformations/offloading/cuda_parallelize_nested_map.h"
#include "sdfg/transformations/offloading/cuda_transform.h"
#include "sdfg/transformations/offloading/gpu_loop_reordering.h"
#include "sdfg/transformations/offloading/gpu_tiling.h"

namespace sdfg {
namespace passes {
namespace scheduler {

SchedulerAction CUDAScheduler::schedule(
    builder::StructuredSDFGBuilder& builder,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::StructuredLoop& loop,
    bool offload_unknown_sizes
) {
    if (auto map_node = dynamic_cast<structured_control_flow::Map*>(&loop)) {
        // Apply CUDA parallelization to the loop
        bool applied_collapse = false;
        // transformations::CollapseToDepth collapse_to_depth(*map_node, 2);
        // if (collapse_to_depth.can_be_applied(builder, analysis_manager)) {
        //     collapse_to_depth.apply(builder, analysis_manager);
        //     analysis_manager.invalidate_all();
        //     applied_collapse = true;
        // }
        // auto collapsed_map = collapse_to_depth.outer_loop();
        cuda::CUDATransform cuda_transform(*map_node, 32, offload_unknown_sizes);
        if (cuda_transform.can_be_applied(builder, analysis_manager)) {
            cuda_transform.apply(builder, analysis_manager);

            transformations::GPULoopReordering gpu_loop_reordering_pass(*map_node);
            if (gpu_loop_reordering_pass.can_be_applied(builder, analysis_manager)) {
                gpu_loop_reordering_pass.apply(builder, analysis_manager);
            }

            auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();
            auto descendants = loop_analysis.descendants(map_node);
            for (auto& descendant : descendants) {
                if (auto nested_map = dynamic_cast<structured_control_flow::Map*>(descendant)) {
                    transformations::CUDAParallelizeNestedMap nested_cuda_transform(*nested_map, 8);
                    if (nested_cuda_transform.can_be_applied(builder, analysis_manager)) {
                        nested_cuda_transform.apply(builder, analysis_manager);
                    }
                }
            }


            analysis_manager.invalidate_all();
            auto& loop_analysis2 = analysis_manager.get<analysis::LoopAnalysis>();
            for (auto& descendant : loop_analysis2.descendants(map_node)) {
                if (auto target_loop = dynamic_cast<structured_control_flow::StructuredLoop*>(descendant)) {
                    transformations::GPUTiling gpu_tiling_transform(*target_loop, 8);
                    if (gpu_tiling_transform.can_be_applied(builder, analysis_manager)) {
                        gpu_tiling_transform.apply(builder, analysis_manager);
                    }
                }
            }

            analysis_manager.invalidate_all();
            return NEXT;
        }
        if (applied_collapse) {
            return NEXT;
        }
    }

    auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();
    auto loop_info = loop_analysis.loop_info(&loop);

    // Check if in not outermost loop
    if (loop_info.loopnest_index == -1 || loop_info.num_maps <= 1 || loop_info.is_perfectly_nested ||
        loop_info.has_side_effects) {
        return NEXT;
    } else {
        // Visit 1st-level children
        return CHILDREN;
    }
}

SchedulerAction CUDAScheduler::schedule(
    builder::StructuredSDFGBuilder& builder,
    analysis::AnalysisManager& analysis_manager,
    structured_control_flow::While& loop,
    bool offload_unknown_sizes
) {
    auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();
    auto loop_info = loop_analysis.loop_info(&loop);
    // Check if in not outermost loop
    if (loop_info.loopnest_index == -1 || loop_info.has_side_effects) {
        return NEXT;
    } else {
        // Visit 1st-level children
        return CHILDREN;
    }
}

std::unordered_set<ScheduleTypeCategory> CUDAScheduler::compatible_types() { return {ScheduleTypeCategory::None}; }

} // namespace scheduler
} // namespace passes
} // namespace sdfg

1	#include "sdfg/passes/scheduler/cuda_scheduler.h"
2
3	#include "sdfg/passes/scheduler/loop_scheduler.h"
4	#include "sdfg/passes/symbolic/symbol_propagation.h"
5	#include "sdfg/structured_control_flow/map.h"
6	#include "sdfg/transformations/collapse_to_depth.h"
7	#include "sdfg/transformations/offloading/cuda_parallelize_nested_map.h"
8	#include "sdfg/transformations/offloading/cuda_transform.h"
9	#include "sdfg/transformations/offloading/gpu_loop_reordering.h"
10	#include "sdfg/transformations/offloading/gpu_tiling.h"
11
12	namespace sdfg {
13	namespace passes {
14	namespace scheduler {
15
16	SchedulerAction CUDAScheduler::schedule(
17	builder::StructuredSDFGBuilder& builder,
18	analysis::AnalysisManager& analysis_manager,
19	structured_control_flow::StructuredLoop& loop,
20	bool offload_unknown_sizes
21	) {	4✔
22	if (auto map_node = dynamic_cast<structured_control_flow::Map*>(&loop)) {	4✔
23	// Apply CUDA parallelization to the loop
24	bool applied_collapse = false;	4✔
25	// transformations::CollapseToDepth collapse_to_depth(*map_node, 2);
26	// if (collapse_to_depth.can_be_applied(builder, analysis_manager)) {
27	// collapse_to_depth.apply(builder, analysis_manager);
28	// analysis_manager.invalidate_all();
29	// applied_collapse = true;
30	// }
31	// auto collapsed_map = collapse_to_depth.outer_loop();
32	cuda::CUDATransform cuda_transform(*map_node, 32, offload_unknown_sizes);	4✔
33	if (cuda_transform.can_be_applied(builder, analysis_manager)) {	4✔
34	cuda_transform.apply(builder, analysis_manager);	4✔
35
36	transformations::GPULoopReordering gpu_loop_reordering_pass(*map_node);	4✔
37	if (gpu_loop_reordering_pass.can_be_applied(builder, analysis_manager)) {	4✔
38	gpu_loop_reordering_pass.apply(builder, analysis_manager);	2✔
39	}	2✔
40
41	auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();	4✔
42	auto descendants = loop_analysis.descendants(map_node);	4✔
43	for (auto& descendant : descendants) {	4✔
44	if (auto nested_map = dynamic_cast<structured_control_flow::Map*>(descendant)) {	2✔
45	transformations::CUDAParallelizeNestedMap nested_cuda_transform(*nested_map, 8);	2✔
46	if (nested_cuda_transform.can_be_applied(builder, analysis_manager)) {	2✔
47	nested_cuda_transform.apply(builder, analysis_manager);	2✔
48	}	2✔
49	}	2✔
50	}	2✔
51
52
53	analysis_manager.invalidate_all();	4✔
54	auto& loop_analysis2 = analysis_manager.get<analysis::LoopAnalysis>();	4✔
55	for (auto& descendant : loop_analysis2.descendants(map_node)) {	4✔
56	if (auto target_loop = dynamic_cast<structured_control_flow::StructuredLoop*>(descendant)) {	2✔
57	transformations::GPUTiling gpu_tiling_transform(*target_loop, 8);	2✔
58	if (gpu_tiling_transform.can_be_applied(builder, analysis_manager)) {	2✔
59	gpu_tiling_transform.apply(builder, analysis_manager);	×
60	}	×
61	}	2✔
62	}	2✔
63
64	analysis_manager.invalidate_all();	4✔
65	return NEXT;	4✔
66	}	4✔
NEW 67	if (applied_collapse) {	×
NEW 68	return NEXT;	×
NEW 69	}	×
UNCOV 70	}	×
71
72	auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();	×
73	auto loop_info = loop_analysis.loop_info(&loop);	×
74
75	// Check if in not outermost loop
76	if (loop_info.loopnest_index == -1 \|\| loop_info.num_maps <= 1 \|\| loop_info.is_perfectly_nested \|\|	×
77	loop_info.has_side_effects) {	×
78	return NEXT;	×
79	} else {	×
80	// Visit 1st-level children
81	return CHILDREN;	×
82	}	×
83	}	×
84
85	SchedulerAction CUDAScheduler::schedule(
86	builder::StructuredSDFGBuilder& builder,
87	analysis::AnalysisManager& analysis_manager,
88	structured_control_flow::While& loop,
89	bool offload_unknown_sizes
90	) {	2✔
91	auto& loop_analysis = analysis_manager.get<analysis::LoopAnalysis>();	2✔
92	auto loop_info = loop_analysis.loop_info(&loop);	2✔
93	// Check if in not outermost loop
94	if (loop_info.loopnest_index == -1 \|\| loop_info.has_side_effects) {	2✔
95	return NEXT;	×
96	} else {	2✔
97	// Visit 1st-level children
98	return CHILDREN;	2✔
99	}	2✔
100	}	2✔
101
102	std::unordered_set<ScheduleTypeCategory> CUDAScheduler::compatible_types() { return {ScheduleTypeCategory::None}; }	5✔
103
104	} // namespace scheduler
105	} // namespace passes
106	} // namespace sdfg

daisytuner / docc / 23339691255

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