schedule.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include <sdfg/codegen/instrumentation/instrumentation_info.h>
#include <sdfg/serializer/json_serializer.h>
#include <sdfg/structured_control_flow/map.h>
 
namespace sdfg {
namespace omp {

enum OpenMPSchedule {
    Static, 
    Dynamic, 
    Guided 
};

class ScheduleType_OMP {
public:
    static void num_threads(structured_control_flow::ScheduleType& schedule, const symbolic::Expression num_threads) {
        serializer::JSONSerializer serializer;
        schedule.set_property("num_threads", serializer.expression(num_threads));
    }

    static const symbolic::Expression num_threads(const structured_control_flow::ScheduleType& schedule) {
        serializer::JSONSerializer serializer;
        if (schedule.properties().find("num_threads") == schedule.properties().end()) {
            return SymEngine::null;
        }
        std::string expr_str = schedule.properties().at("num_threads");
        auto expr = symbolic::parse(expr_str);
        return expr;
    }

    static void omp_schedule(structured_control_flow::ScheduleType& schedule, const OpenMPSchedule schedule_type) {
        schedule.set_property("omp_schedule", std::to_string(schedule_type));
    }

    static OpenMPSchedule omp_schedule(const structured_control_flow::ScheduleType& schedule) {
        if (schedule.properties().find("omp_schedule") == schedule.properties().end()) {
            return OpenMPSchedule::Static;
        }
        return static_cast<OpenMPSchedule>(std::stoi(schedule.properties().at("omp_schedule")));
    }
 
    static const std::string value() {
        return "CPU_PARALLEL";
    }
 
    static structured_control_flow::ScheduleType create() {
        return structured_control_flow::ScheduleType(value(), structured_control_flow::ScheduleTypeCategory::Parallelizer);
    }
};
 
} // namespace omp
} // namespace sdfg