yask_compiler_api.hpp

Go to the documentation of this file.

/*****************************************************************************
 
YASK: Yet Another Stencil Kit
Copyright (c) 2014-2024, Intel Corporation
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
* The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
 
*****************************************************************************/
 
 
// This file uses Doxygen markup for API documentation-generation.
// See https://www.doxygen.nl/manual/index.html.
#pragma once
 
#include "yask_common_api.hpp"
#include <functional>
#include <vector>
 
namespace yask {
 
    // Forward declarations of classes and their pointers.
    // See yask_compiler_api.hpp for more.
 
    class yc_solution;
    typedef std::shared_ptr<yc_solution> yc_solution_ptr;
 
    class yc_var;
    typedef yc_var* yc_var_ptr;
 
    // Forward declarations of expression nodes and their pointers.
 
    class yc_expr_node;
    typedef std::shared_ptr<yc_expr_node> yc_expr_node_ptr;
 
    class yc_bool_node;
    typedef std::shared_ptr<yc_bool_node> yc_bool_node_ptr;
 
    class yc_number_node;
    typedef std::shared_ptr<yc_number_node> yc_number_node_ptr;
 
    class yc_index_node;
    typedef std::shared_ptr<yc_index_node> yc_index_node_ptr;
 
    class yc_equation_node;
    typedef std::shared_ptr<yc_equation_node> yc_equation_node_ptr;
 
    class yc_var_point_node;
    typedef std::shared_ptr<yc_var_point_node> yc_var_point_node_ptr;
 
}
 
#include "aux/yc_node_api.hpp"
 
namespace yask {
 
    class yc_factory {
    public:
        virtual ~yc_factory() {}
 
 
        virtual std::string
        get_version_string();
 
 
        virtual yc_solution_ptr
        new_solution(const std::string& name  ) const;
    }; // yc_factory.
 
 
    class yc_solution {
    public:
        virtual ~yc_solution() {}
 
        virtual void
        set_debug_output(yask_output_ptr debug ) =0;
 
 
        virtual std::string
        get_name() const =0;
 
 
        virtual void
        set_name(std::string name ) =0;
 
 
        virtual std::string
        get_description() const =0;
 
 
        virtual void
        set_description(std::string description ) =0;
 
 
        virtual std::string
        get_target() =0;
 
 
        virtual void
        set_target(
                   const std::string& format) =0;
 
 
        virtual bool
        is_target_set() =0;
 
 
        virtual int
        get_element_bytes() const =0;
 
        virtual void
        set_element_bytes(int nbytes  ) =0;
 
 
        virtual yc_var_ptr
        new_var(const std::string& name,
                 const std::vector<yc_index_node_ptr>& dims ) =0;
 
        #ifndef SWIG
 
        virtual yc_var_ptr
        new_var(const std::string& name ,
                 const std::initializer_list<yc_index_node_ptr>& dims ) =0;
        #endif
 
 
        virtual yc_var_ptr
        new_scratch_var(const std::string& name,
                         const std::vector<yc_index_node_ptr>& dims ) =0;
 
        #ifndef SWIG
 
        virtual yc_var_ptr
        new_scratch_var(const std::string& name,
                         const std::initializer_list<yc_index_node_ptr>& dims ) =0;
        #endif
 
 
        virtual int
        get_num_vars() const =0;
 
 
        virtual std::vector<yc_var_ptr>
        get_vars() =0;
 
 
        virtual yc_var_ptr
        get_var(const std::string& name  ) =0;
 
 
        virtual void
        set_fold_len(const yc_index_node_ptr dim,
                     int len  ) =0;
 
 
        virtual bool
        is_folding_set() =0;
        
        virtual void
        clear_folding() =0;
 
 
        virtual int
        get_num_equations() const =0;
 
 
        virtual std::vector<yc_equation_node_ptr>
        get_equations() =0;
 
 
        virtual int
        get_prefetch_dist(
                          int level) =0;
 
        virtual void
        set_prefetch_dist(
                          int level,
                          int distance) =0;
 
 
        virtual std::string
        apply_command_line_options(const std::string& args ) =0;
 
 
        virtual std::string
        apply_command_line_options(int argc, char* argv[]) =0;
 
 
        virtual std::string
        apply_command_line_options(const string_vec& args) =0;
 
 
        virtual std::string
        get_command_line_help() =0;
 
 
        virtual std::string
        get_command_line_values() =0;
 
 
        virtual void
        output_solution(yask_output_ptr output) =0;
 
        #ifndef SWIG
        typedef std::function<void(yc_solution& soln,
                                   yask_output_ptr output)> output_hook_t;
 
 
        virtual void
        call_before_output(
                           output_hook_t hook_fn) =0;
        #endif
 
 
        virtual void
        call_after_new_solution(const std::string& code) =0;
 
 
        #define CALL_AFTER_NEW_SOLUTION(...) call_after_new_solution(#__VA_ARGS__)
        
 
        virtual void
        set_domain_dims(const std::vector<yc_index_node_ptr>& dims ) =0;
 
        #ifndef SWIG
 
        virtual void
        set_domain_dims(const std::initializer_list<yc_index_node_ptr>& dims ) =0;
        #endif
        
 
        virtual void
        set_step_dim(const yc_index_node_ptr dim) =0;
        
 
        virtual void
        set_dependency_checker_enabled(bool enable) =0;
 
 
        virtual bool
        is_dependency_checker_enabled() const =0;
 
 
        virtual void
        add_flow_dependency(yc_equation_node_ptr from,
                            yc_equation_node_ptr to) =0;
 
 
        virtual void
        clear_dependencies() =0;
 
        YASK_DEPRECATED
        void
        set_cluster_mult(const yc_index_node_ptr dim,
                         int mult) { }
 
 
        YASK_DEPRECATED
        bool
        is_clustering_set() { return false; }
        
        YASK_DEPRECATED
        void
        clear_clustering() { }
 
        YASK_DEPRECATED
        inline void
        format(const std::string& format_type,
               yask_output_ptr output) {
            set_target(format_type);
            output_solution(output);
        }
 
        YASK_DEPRECATED
        inline yc_var_ptr
        new_grid(const std::string& name,
                 const std::vector<yc_index_node_ptr>& dims) {
            return new_var(name, dims);
        }
 
        #ifndef SWIG
        YASK_DEPRECATED
        inline yc_var_ptr
        new_grid(const std::string& name,
                 const std::initializer_list<yc_index_node_ptr>& dims) {
            return new_var(name, dims);
        }
        #endif
 
        YASK_DEPRECATED
        inline yc_var_ptr
        new_scratch_grid(const std::string& name,
                         const std::vector<yc_index_node_ptr>& dims) {
            return new_scratch_var(name, dims);
        }
 
        #ifndef SWIG
        YASK_DEPRECATED
        inline yc_var_ptr
        new_scratch_grid(const std::string& name,
                         const std::initializer_list<yc_index_node_ptr>& dims) {
            return new_scratch_var(name, dims);
        }
        #endif
 
        YASK_DEPRECATED
        inline int
        get_num_grids() const {
            return get_num_vars();
        }
 
        YASK_DEPRECATED
        inline std::vector<yc_var_ptr>
        get_grids() {
            return get_vars();
        }
 
        YASK_DEPRECATED
        inline yc_var_ptr
        get_grid(const std::string& name) {
            return get_var(name);
        }
    };                          // yc_solution.
 
 
    class yc_var {
    public:
        virtual ~yc_var() {}
 
 
        virtual const std::string& get_name() const =0;
 
 
        virtual int get_num_dims() const =0;
 
 
        virtual string_vec
        get_dim_names() const =0;
 
 
        virtual yc_var_point_node_ptr
        new_var_point(const std::vector<yc_number_node_ptr>& index_exprs ) =0;
 
        #ifndef SWIG
 
        virtual yc_var_point_node_ptr
        new_var_point(const std::initializer_list<yc_number_node_ptr>& index_exprs) = 0;
        #endif
 
 
        virtual bool
        is_dynamic_step_alloc() const =0;
 
 
        virtual void
        set_dynamic_step_alloc(bool is_dynamic) =0;
 
 
        virtual idx_t
        get_step_alloc_size() const =0;
 
 
        virtual void
        set_step_alloc_size(idx_t size) =0;
 
        YASK_DEPRECATED
        virtual yc_var_point_node_ptr
        new_relative_var_point(const std::vector<int>& dim_offsets) =0;
        #ifndef SWIG
        YASK_DEPRECATED
        virtual yc_var_point_node_ptr
        new_relative_var_point(const std::initializer_list<int>& dim_offsets) = 0;
        #endif
        
        YASK_DEPRECATED
        inline yc_var_point_node_ptr
        new_grid_point(const std::vector<yc_number_node_ptr>& index_exprs) {
            return new_var_point(index_exprs);
        }
        #ifndef SWIG
        YASK_DEPRECATED
        inline yc_var_point_node_ptr
        new_grid_point(const std::initializer_list<yc_number_node_ptr>& index_exprs) {
            return new_var_point(index_exprs);
        }
        #endif
        
        YASK_DEPRECATED
        virtual yc_var_point_node_ptr
        new_relative_grid_point(const std::vector<int>& dim_offsets) =0;
        #ifndef SWIG
        YASK_DEPRECATED
        virtual yc_var_point_node_ptr
        new_relative_grid_point(const std::initializer_list<int>& dim_offsets) =0;
        #endif
        
    };                      // yc_var.
 
 
    class yc_var_proxy {
    private:
        yc_var_ptr _var;
        
    public:
 
 
        yc_var_proxy(const std::string& name,
                    yc_solution_ptr soln,
                    const std::vector< yc_index_node_ptr > &dims,
                    bool is_scratch = false) {
            if (is_scratch)
                _var = soln->new_scratch_var(name, dims);
            else
                _var = soln->new_var(name, dims);
        }
 
        #ifndef SWIG
 
        yc_var_proxy(const std::string& name,
                    yc_solution_ptr soln,
                    const std::initializer_list< yc_index_node_ptr > &dims,
                    bool is_scratch = false) {
            if (is_scratch)
                _var = soln->new_scratch_var(name, dims);
            else
                _var = soln->new_var(name, dims);
        }
        #endif
        
 
        yc_var_proxy(const std::string& name,
                    yc_solution_ptr soln) {
            _var = soln->new_var(name, { });
        }
 
 
        yc_var_proxy(yc_var_ptr& var) : _var(var) { }
                    
 
        yc_var_proxy(yc_var_proxy& proxy) : _var(proxy.get_var()) { }
                    
        virtual ~yc_var_proxy() { }
 
        virtual yc_var_ptr get_var() {
            return _var;
        }
 
        virtual yc_var_ptr get_var() const {
            return _var;
        }
 
 
        virtual yc_var_point_node_ptr
        operator()(const std::vector<yc_number_node_ptr>& index_exprs) {
            return _var->new_var_point(index_exprs);
        }
 
        #ifndef SWIG
 
        virtual yc_var_point_node_ptr
        operator()(const std::initializer_list<yc_number_node_ptr>& index_exprs) {
            return _var->new_var_point(index_exprs);
        }
 
 
        virtual yc_var_point_node_ptr operator()(const yc_number_any_arg i1 = nullptr,
                                                  const yc_number_any_arg i2 = nullptr,
                                                  const yc_number_any_arg i3 = nullptr,
                                                  const yc_number_any_arg i4 = nullptr,
                                                  const yc_number_any_arg i5 = nullptr,
                                                  const yc_number_any_arg i6 = nullptr) {
            std::vector<yc_number_node_ptr> args;
            if (i1)
                args.push_back(i1);
            if (i2)
                args.push_back(i2);
            if (i3)
                args.push_back(i3);
            if (i4)
                args.push_back(i4);
            if (i5)
                args.push_back(i5);
            if (i6)
                args.push_back(i6);
            return _var->new_var_point(args);
        }
 
 
        virtual operator yc_number_ptr_arg() {
            return _var->new_var_point({});
        }
 
 
        virtual yc_var_point_node_ptr operator[](const yc_number_any_arg i1) {
            return _var->new_var_point({i1});
        }
        
        #endif
        
    };                          // yc_var_proxy.
 
    YASK_DEPRECATED
    typedef yc_var yc_grid;
    YASK_DEPRECATED
    typedef yc_var_ptr yc_grid_ptr;
    YASK_DEPRECATED
    typedef yc_var_point_node yc_grid_point_node;
    YASK_DEPRECATED
    typedef yc_var_point_node_ptr yc_grid_point_node_ptr;
 
} // namespace yask.
 
// More solution-based objects.
#include "aux/yc_solution_api.hpp"