15044057891

Committed 15 May 2025 11:42AM UTC coverage: 59.37% (+1.8%) from 57.525%

Build # 15044057891

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14 from daisytuner/sanitizers

enables sanitizer on unit tests

Run Details

63 of 67 new or added lines in 47 files covered. (94.03%)

570 existing lines in 62 files now uncovered.

7356 of 12390 relevant lines covered (59.37%)

505.93 hits per line

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

4.08

/src/codegen/dispatchers/kernel_dispatcher.cpp

#include "sdfg/codegen/dispatchers/kernel_dispatcher.h"

#include "sdfg/codegen/language_extension.h"
#include "sdfg/schedule.h"

namespace sdfg {
namespace codegen {

KernelDispatcher::KernelDispatcher(LanguageExtension& language_extension, Schedule& schedule,
                                   structured_control_flow::Kernel& node, bool instrumented)
    : NodeDispatcher(language_extension, schedule, node, instrumented),
      node_(node){

      };

void KernelDispatcher::dispatch_node(PrettyPrinter& main_stream, PrettyPrinter& globals_stream,
                                     PrettyPrinter& library_stream) {
    bool gridDim_x = false;
    bool gridDim_y = false;
    bool gridDim_z = false;
    bool blockDim_x = false;
    bool blockDim_y = false;
    bool blockDim_z = false;
    bool blockIdx_x = false;
    bool blockIdx_y = false;
    bool blockIdx_z = false;
    bool threadIdx_x = false;
    bool threadIdx_y = false;
    bool threadIdx_z = false;

    for (auto& container : schedule_.sdfg().containers()) {
        if (container == node_.gridDim_x()->get_name()) {
            gridDim_x = true;
        } else if (container == node_.gridDim_y()->get_name()) {
            gridDim_y = true;
        } else if (container == node_.gridDim_z()->get_name()) {
            gridDim_z = true;
        } else if (container == node_.blockDim_x()->get_name()) {
            blockDim_x = true;
        } else if (container == node_.blockDim_y()->get_name()) {
            blockDim_y = true;
        } else if (container == node_.blockDim_z()->get_name()) {
            blockDim_z = true;
        } else if (container == node_.blockIdx_x()->get_name()) {
            blockIdx_x = true;
        } else if (container == node_.blockIdx_y()->get_name()) {
            blockIdx_y = true;
        } else if (container == node_.blockIdx_z()->get_name()) {
            blockIdx_z = true;
        } else if (container == node_.threadIdx_x()->get_name()) {
            threadIdx_x = true;
        } else if (container == node_.threadIdx_y()->get_name()) {
            threadIdx_y = true;
        } else if (container == node_.threadIdx_z()->get_name()) {
            threadIdx_z = true;
        }
    }

    if (gridDim_x) {
        main_stream << node_.gridDim_x()->get_name() << " = "
                    << language_extension_.expression(node_.gridDim_x_init()) << ";" << std::endl;
    }
    if (gridDim_y) {
        main_stream << node_.gridDim_y()->get_name() << " = "
                    << language_extension_.expression(node_.gridDim_y_init()) << ";" << std::endl;
    }
    if (gridDim_z) {
        main_stream << node_.gridDim_z()->get_name() << " = "
                    << language_extension_.expression(node_.gridDim_z_init()) << ";" << std::endl;
    }
    if (blockDim_x) {
        main_stream << node_.blockDim_x()->get_name() << " = "
                    << language_extension_.expression(node_.blockDim_x_init()) << ";" << std::endl;
    }
    if (blockDim_y) {
        main_stream << node_.blockDim_y()->get_name() << " = "
                    << language_extension_.expression(node_.blockDim_y_init()) << ";" << std::endl;
    }
    if (blockDim_z) {
        main_stream << node_.blockDim_z()->get_name() << " = "
                    << language_extension_.expression(node_.blockDim_z_init()) << ";" << std::endl;
    }
    if (blockIdx_x) {
        main_stream << node_.blockIdx_x()->get_name() << " = "
                    << language_extension_.expression(node_.blockIdx_x_init()) << ";" << std::endl;
    }
    if (blockIdx_y) {
        main_stream << node_.blockIdx_y()->get_name() << " = "
                    << language_extension_.expression(node_.blockIdx_y_init()) << ";" << std::endl;
    }
    if (blockIdx_z) {
        main_stream << node_.blockIdx_z()->get_name() << " = "
                    << language_extension_.expression(node_.blockIdx_z_init()) << ";" << std::endl;
    }
    if (threadIdx_x) {
        main_stream << node_.threadIdx_x()->get_name() << " = "
                    << language_extension_.expression(node_.threadIdx_x_init()) << ";" << std::endl;
    }
    if (threadIdx_y) {
        main_stream << node_.threadIdx_y()->get_name() << " = "
                    << language_extension_.expression(node_.threadIdx_y_init()) << ";" << std::endl;
    }
    if (threadIdx_z) {
        main_stream << node_.threadIdx_z()->get_name() << " = "
                    << language_extension_.expression(node_.threadIdx_z_init()) << ";" << std::endl;
    }

    main_stream << "{" << std::endl;
    main_stream.setIndent(main_stream.indent() + 4);

    SequenceDispatcher dispatcher(language_extension_, schedule_, node_.root(), false);
    dispatcher.dispatch(main_stream, globals_stream, library_stream);

    main_stream.setIndent(main_stream.indent() - 4);
    main_stream << "}" << std::endl;
};

}  // namespace codegen
}  // namespace sdfg

1	#include "sdfg/codegen/dispatchers/kernel_dispatcher.h"
2
3	#include "sdfg/codegen/language_extension.h"
4	#include "sdfg/schedule.h"
5
6	namespace sdfg {
7	namespace codegen {
8
9	KernelDispatcher::KernelDispatcher(LanguageExtension& language_extension, Schedule& schedule,	1✔
10	structured_control_flow::Kernel& node, bool instrumented)
11	: NodeDispatcher(language_extension, schedule, node, instrumented),	1✔
12	node_(node){	1✔
13
14	};	1✔
15
16	void KernelDispatcher::dispatch_node(PrettyPrinter& main_stream, PrettyPrinter& globals_stream,	×
17	PrettyPrinter& library_stream) {
18	bool gridDim_x = false;	×
19	bool gridDim_y = false;	×
20	bool gridDim_z = false;	×
21	bool blockDim_x = false;	×
22	bool blockDim_y = false;	×
23	bool blockDim_z = false;	×
24	bool blockIdx_x = false;	×
25	bool blockIdx_y = false;	×
26	bool blockIdx_z = false;	×
27	bool threadIdx_x = false;	×
28	bool threadIdx_y = false;	×
29	bool threadIdx_z = false;	×
30
31	for (auto& container : schedule_.sdfg().containers()) {	×
32	if (container == node_.gridDim_x()->get_name()) {	×
33	gridDim_x = true;	×
34	} else if (container == node_.gridDim_y()->get_name()) {	×
35	gridDim_y = true;	×
36	} else if (container == node_.gridDim_z()->get_name()) {	×
37	gridDim_z = true;	×
38	} else if (container == node_.blockDim_x()->get_name()) {	×
39	blockDim_x = true;	×
40	} else if (container == node_.blockDim_y()->get_name()) {	×
41	blockDim_y = true;	×
42	} else if (container == node_.blockDim_z()->get_name()) {	×
43	blockDim_z = true;	×
44	} else if (container == node_.blockIdx_x()->get_name()) {	×
45	blockIdx_x = true;	×
46	} else if (container == node_.blockIdx_y()->get_name()) {	×
47	blockIdx_y = true;	×
48	} else if (container == node_.blockIdx_z()->get_name()) {	×
49	blockIdx_z = true;	×
50	} else if (container == node_.threadIdx_x()->get_name()) {	×
51	threadIdx_x = true;	×
52	} else if (container == node_.threadIdx_y()->get_name()) {	×
53	threadIdx_y = true;	×
54	} else if (container == node_.threadIdx_z()->get_name()) {	×
55	threadIdx_z = true;	×
UNCOV 56	}	×
57	}
58
59	if (gridDim_x) {	×
60	main_stream << node_.gridDim_x()->get_name() << " = "	×
61	<< language_extension_.expression(node_.gridDim_x_init()) << ";" << std::endl;	×
UNCOV 62	}	×
63	if (gridDim_y) {	×
64	main_stream << node_.gridDim_y()->get_name() << " = "	×
65	<< language_extension_.expression(node_.gridDim_y_init()) << ";" << std::endl;	×
UNCOV 66	}	×
67	if (gridDim_z) {	×
68	main_stream << node_.gridDim_z()->get_name() << " = "	×
69	<< language_extension_.expression(node_.gridDim_z_init()) << ";" << std::endl;	×
UNCOV 70	}	×
71	if (blockDim_x) {	×
72	main_stream << node_.blockDim_x()->get_name() << " = "	×
73	<< language_extension_.expression(node_.blockDim_x_init()) << ";" << std::endl;	×
UNCOV 74	}	×
75	if (blockDim_y) {	×
76	main_stream << node_.blockDim_y()->get_name() << " = "	×
77	<< language_extension_.expression(node_.blockDim_y_init()) << ";" << std::endl;	×
UNCOV 78	}	×
79	if (blockDim_z) {	×
80	main_stream << node_.blockDim_z()->get_name() << " = "	×
81	<< language_extension_.expression(node_.blockDim_z_init()) << ";" << std::endl;	×
UNCOV 82	}	×
83	if (blockIdx_x) {	×
84	main_stream << node_.blockIdx_x()->get_name() << " = "	×
85	<< language_extension_.expression(node_.blockIdx_x_init()) << ";" << std::endl;	×
UNCOV 86	}	×
87	if (blockIdx_y) {	×
88	main_stream << node_.blockIdx_y()->get_name() << " = "	×
89	<< language_extension_.expression(node_.blockIdx_y_init()) << ";" << std::endl;	×
UNCOV 90	}	×
91	if (blockIdx_z) {	×
92	main_stream << node_.blockIdx_z()->get_name() << " = "	×
93	<< language_extension_.expression(node_.blockIdx_z_init()) << ";" << std::endl;	×
UNCOV 94	}	×
95	if (threadIdx_x) {	×
96	main_stream << node_.threadIdx_x()->get_name() << " = "	×
97	<< language_extension_.expression(node_.threadIdx_x_init()) << ";" << std::endl;	×
UNCOV 98	}	×
99	if (threadIdx_y) {	×
100	main_stream << node_.threadIdx_y()->get_name() << " = "	×
101	<< language_extension_.expression(node_.threadIdx_y_init()) << ";" << std::endl;	×
UNCOV 102	}	×
103	if (threadIdx_z) {	×
104	main_stream << node_.threadIdx_z()->get_name() << " = "	×
105	<< language_extension_.expression(node_.threadIdx_z_init()) << ";" << std::endl;	×
UNCOV 106	}	×
107
108	main_stream << "{" << std::endl;	×
109	main_stream.setIndent(main_stream.indent() + 4);	×
110
111	SequenceDispatcher dispatcher(language_extension_, schedule_, node_.root(), false);	×
112	dispatcher.dispatch(main_stream, globals_stream, library_stream);	×
113
114	main_stream.setIndent(main_stream.indent() - 4);	×
115	main_stream << "}" << std::endl;	×
116	};	×
117
118	} // namespace codegen
119	} // namespace sdfg

daisytuner / sdfglib / 15044057891

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