24835309539

Committed 23 Apr 2026 12:30PM UTC coverage: 64.104% (-0.06%) from 64.167%

Build # 24835309539

Build Type

Pull #690

github

Committed by

web-flow

Commit Message

Merge 651f9c45e into 3762dada8

Pull Request Pull Request #690: Modular Compile process

Coverage Stats

224 of 347 new or added lines in 13 files covered. (64.55%)

2 existing lines in 2 files now uncovered.

30800 of 48047 relevant lines covered (64.1%)

573.39 hits per line

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

58.33

/sdfg/include/sdfg/codegen/code_generator.h

#pragma once

#include <filesystem>
#include <string>
#include <utility>

#include "code_snippet_factory.h"
#include "sdfg/analysis/mem_access_range_analysis.h"
#include "sdfg/codegen/instrumentation/arg_capture_plan.h"
#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
#include "sdfg/codegen/utils.h"
#include "sdfg/structured_sdfg.h"
#include "sdfg/types/type.h"

namespace sdfg {
namespace codegen {

/**
 * @brief Base class for code generators
 *
 * This class provides the basic structure for code generators.
 * It contains the streams for the includes, classes, globals, library functions and main code.
 */
class CodeGenerator {
protected:
    /// @brief Reference to the schedule
    StructuredSDFG& sdfg_;

    /// @brief Analysis manager for the SDFG
    analysis::AnalysisManager& analysis_manager_;

    /// @brief Instrumentation strategy
    InstrumentationPlan& instrumentation_plan_;
    ArgCapturePlan& arg_capture_plan_;

    /// @brief Stream for includes
    PrettyPrinter includes_stream_;

    /// @brief Stream for classes
    PrettyPrinter classes_stream_;

    /// @brief Stream for global variables and functions
    PrettyPrinter globals_stream_;

    /// @brief Stream for library functions
    std::shared_ptr<CodeSnippetFactory> library_snippet_factory_;

    /// @brief Main stream
    PrettyPrinter main_stream_;

    /// @brief Prefix to use for external functions
    std::string externals_prefix_;

public:
    CodeGenerator(
        StructuredSDFG& sdfg,
        analysis::AnalysisManager& analysis_manager,
        InstrumentationPlan& instrumentation_plan,
        ArgCapturePlan& arg_capture_plan,
        std::shared_ptr<CodeSnippetFactory> library_snippet_factory = std::make_shared<CodeSnippetFactory>(),
        const std::string& externals_prefix = ""
    )
        : sdfg_(sdfg), analysis_manager_(analysis_manager), instrumentation_plan_(instrumentation_plan),
          arg_capture_plan_(arg_capture_plan), library_snippet_factory_(std::move(library_snippet_factory)),
          externals_prefix_(externals_prefix) {};


    virtual ~CodeGenerator() = default;

    [[nodiscard]] const StructuredSDFG& sdfg() const { return this->sdfg_; };

    /**
     * @brief Generate the code
     *
     * @return true if the code was generated successfully
     */
    virtual bool generate() = 0;

    /// @brief Generate a function definition for the SDFG
    virtual std::string function_definition() = 0;

    /// @brief write the contents of the main header into out
    virtual bool emit_header(PrettyPrinter& out) = 0;

    /// @brief write the contents of the main source file into out. Can also generate additional source files (snippets)
    /// that also depend on the header
    virtual bool emit_main_source(std::ostream& out, const std::filesystem::path& header_path) = 0;

    /// @brief Generate the SDFG's code into source files
    virtual bool as_source(const std::filesystem::path& header_path, const std::filesystem::path& source_path) = 0;

    /// @brief Generate only the function source code and append it to the source file. @ref as_source generates this
    /// into `source_path` after includes, globals and structs
    virtual void append_function_source(std::ostream& ofs_source) = 0;

    /// @brief Get the includes
    const PrettyPrinter& includes() const { return this->includes_stream_; };

    /// @brief Get the classes
    const PrettyPrinter& classes() const { return this->classes_stream_; };

    /// @brief Get the globals
    const PrettyPrinter& globals() const { return this->globals_stream_; };

    /// @brief all created library snippets
    const std::unordered_map<std::string, CodeSnippet>& library_snippets() const {
        return this->library_snippet_factory_->snippets();
    };

    /// @brief Get the main stream
    const PrettyPrinter& main() const { return this->main_stream_; };
};

} // namespace codegen
} // namespace sdfg

1	#pragma once
2
3	#include <filesystem>
4	#include <string>
5	#include <utility>
6
7	#include "code_snippet_factory.h"
8	#include "sdfg/analysis/mem_access_range_analysis.h"
9	#include "sdfg/codegen/instrumentation/arg_capture_plan.h"
10	#include "sdfg/codegen/instrumentation/instrumentation_plan.h"
11	#include "sdfg/codegen/utils.h"
12	#include "sdfg/structured_sdfg.h"
13	#include "sdfg/types/type.h"
14
15	namespace sdfg {
16	namespace codegen {
17
18	/**
19	* @brief Base class for code generators
20	*
21	* This class provides the basic structure for code generators.
22	* It contains the streams for the includes, classes, globals, library functions and main code.
23	*/
24	class CodeGenerator {
25	protected:
26	/// @brief Reference to the schedule
27	StructuredSDFG& sdfg_;
28
29	/// @brief Analysis manager for the SDFG
30	analysis::AnalysisManager& analysis_manager_;
31
32	/// @brief Instrumentation strategy
33	InstrumentationPlan& instrumentation_plan_;
34	ArgCapturePlan& arg_capture_plan_;
35
36	/// @brief Stream for includes
37	PrettyPrinter includes_stream_;
38
39	/// @brief Stream for classes
40	PrettyPrinter classes_stream_;
41
42	/// @brief Stream for global variables and functions
43	PrettyPrinter globals_stream_;
44
45	/// @brief Stream for library functions
46	std::shared_ptr<CodeSnippetFactory> library_snippet_factory_;
47
48	/// @brief Main stream
49	PrettyPrinter main_stream_;
50
51	/// @brief Prefix to use for external functions
52	std::string externals_prefix_;
53
54	public:
55	CodeGenerator(
56	StructuredSDFG& sdfg,
57	analysis::AnalysisManager& analysis_manager,
58	InstrumentationPlan& instrumentation_plan,
59	ArgCapturePlan& arg_capture_plan,
60	std::shared_ptr<CodeSnippetFactory> library_snippet_factory = std::make_shared<CodeSnippetFactory>(),
61	const std::string& externals_prefix = ""
62	)
63	: sdfg_(sdfg), analysis_manager_(analysis_manager), instrumentation_plan_(instrumentation_plan),	23✔
64	arg_capture_plan_(arg_capture_plan), library_snippet_factory_(std::move(library_snippet_factory)),	23✔
65	externals_prefix_(externals_prefix) {};	23✔
66
67
68	virtual ~CodeGenerator() = default;	23✔
69
NEW 70	[[nodiscard]] const StructuredSDFG& sdfg() const { return this->sdfg_; };	×
71
72	/**
73	* @brief Generate the code
74	*
75	* @return true if the code was generated successfully
76	*/
77	virtual bool generate() = 0;
78
79	/// @brief Generate a function definition for the SDFG
80	virtual std::string function_definition() = 0;
81
82	/// @brief write the contents of the main header into out
83	virtual bool emit_header(PrettyPrinter& out) = 0;
84
85	/// @brief write the contents of the main source file into out. Can also generate additional source files (snippets)
86	/// that also depend on the header
87	virtual bool emit_main_source(std::ostream& out, const std::filesystem::path& header_path) = 0;
88
89	/// @brief Generate the SDFG's code into source files
90	virtual bool as_source(const std::filesystem::path& header_path, const std::filesystem::path& source_path) = 0;
91
92	/// @brief Generate only the function source code and append it to the source file. @ref as_source generates this
93	/// into `source_path` after includes, globals and structs
94	virtual void append_function_source(std::ostream& ofs_source) = 0;
95
96	/// @brief Get the includes
97	const PrettyPrinter& includes() const { return this->includes_stream_; };	×
98
99	/// @brief Get the classes
100	const PrettyPrinter& classes() const { return this->classes_stream_; };	7✔
101
102	/// @brief Get the globals
103	const PrettyPrinter& globals() const { return this->globals_stream_; };	4✔
104
105	/// @brief all created library snippets
106	const std::unordered_map<std::string, CodeSnippet>& library_snippets() const {	×
107	return this->library_snippet_factory_->snippets();	×
108	};	×
109
110	/// @brief Get the main stream
111	const PrettyPrinter& main() const { return this->main_stream_; };	8✔
112	};
113
114	} // namespace codegen
115	} // namespace sdfg

daisytuner / docc / 24835309539

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