scheduler_interface.h

Go to the documentation of this file.

#ifndef SCHEDULER_INTERFACE_H
#define SCHEDULER_INTERFACE_H

#include <vector>
#include <ostream>
#include "task_implementation.h"
#include "reconfigurable_zone.h"
#include "scheduler_request.h"
#include "application_interface.h"

/* Macro to define User Mapping/Scheduling Algo */
#define MAPPING_ALGORITHM(nom) Return_mapping_information waiting_queue_handler_mapping_ ## nom ## (Scheduler_interface &scheduler)
#define SCHEDULING_ALGORITHM(nom) void waiting_queue_handler_scheduling_ ## nom ## (Scheduler_interface &scheduler)

#define DEFAULT_MAPPING_ALGORITHM(nom) Return_mapping_information waiting_queue_handler_mapping_ ## nom ## (Scheduler_interface &scheduler) { \
        return waiting_queue_handler_mapping_default_algo(scheduler); \
        }

#define DEFAULT_SCHEDULING_ALGORITHM(nom) void waiting_queue_handler_scheduling_ ## nom ## (Scheduler_interface &scheduler) { \
        waiting_queue_handler_scheduling_default_algo(scheduler); \
        }

/* Macro only for Generation */
#define WAITING_QUEUE_HANDLER(nom) void waiting_queue_handler_## nom ##(Scheduler_interface &scheduler)
#define WAITING_QUEUE_HANDLER_REF(nom) waiting_queue_handler_## nom
#define CALL_WAITING_QUEUE_HANDLER(nom) waiting_queue_handler_## nom ##(scheduler)
#define CALL_MAPPING_ALGORITHM(nom) waiting_queue_handler_mapping_ ## nom ## (scheduler)
#define CALL_SCHEDULING_ALGORITHM(nom) waiting_queue_handler_scheduling_ ## nom ## (scheduler)


/* For User : Return information from Mapping Algorithm */
class Return_mapping_information {

        bool rz_found;
        bool exit_mapping_algo;
        RZ* implementation_RZ;
        int implementation_ID;
        Config_fct_point* cfgFctPt;

public:
        Return_mapping_information() {
                rz_found = false;
                exit_mapping_algo = true;
                cfgFctPt = NULL;
        }

                Return_mapping_information(RZ* _implementation_RZ, int _implementation_ID) {
                rz_found = true;
                exit_mapping_algo = true;
                implementation_RZ = _implementation_RZ;
                implementation_ID = _implementation_ID;
                cfgFctPt = NULL;
        }

        Return_mapping_information(RZ* _implementation_RZ, int _implementation_ID, Config_fct_point* _cfgFctPt) {
                rz_found = true;
                exit_mapping_algo = true;
                implementation_RZ = _implementation_RZ;
                implementation_ID = _implementation_ID;
                cfgFctPt = _cfgFctPt;
        }

        Return_mapping_information(RZ* _implementation_RZ, int _implementation_ID, bool exit_mapping_algorithm) {
                rz_found = true;
                exit_mapping_algo = exit_mapping_algorithm;
                implementation_RZ = _implementation_RZ;
                implementation_ID = _implementation_ID;
                cfgFctPt = NULL;
        }

                Return_mapping_information(RZ* _implementation_RZ, int _implementation_ID, Config_fct_point* _cfgFctPt, bool exit_mapping_algorithm) {
                rz_found = true;
                exit_mapping_algo = exit_mapping_algorithm;
                implementation_RZ = _implementation_RZ;
                implementation_ID = _implementation_ID;
                cfgFctPt = _cfgFctPt;
        }

        Return_mapping_information(const Return_mapping_information &other) {
                rz_found = other.rz_found;
                implementation_RZ = other.implementation_RZ;
                implementation_ID = other.implementation_ID;
                cfgFctPt = other.cfgFctPt;
        }

        bool RZ_found() {
                return rz_found;
        }

                
        bool hasCfgTcfPt() {
                return cfgFctPt != NULL;
        }

        bool exit_mapping_algorithm() {
                return exit_mapping_algo;
        }

        void set_exit_mapping_algo(bool exit_mapping_algorithm) {
                exit_mapping_algo = exit_mapping_algorithm;
        }

        RZ* get_implementation_RZ() {
                return implementation_RZ;
        }

        int get_implementation_ID() {
                return implementation_ID;
        }

        Config_fct_point* getConfigFctPoint() {
                return cfgFctPt;
        }
};



class Scheduler_interface : public sc_interface {

public:
        
        //
        // ======= Waiting queue =======
        //

        virtual bool Scheduler_are_tasks_waiting(void) const = 0;

        //virtual SchedulerRequest Scheduler_get_top_request(void) = 0;

        virtual SchedulerRequest& Scheduler_current_task_waiting() = 0;  

        //virtual void Scheduler_pop_request(void) = 0;

        virtual int Scheduler_get_waiting_queue_size(void) = 0;

        virtual int Scheduler_position_of_current_element(void) = 0;

        virtual SchedulerRequest& Scheduler_get_element(int position) = 0;

        virtual void Scheduler_update_queue(void) = 0;

        virtual Task_to_schedule_interface* Scheduler_get_task_to_schedule_ptr(int taskID) = 0;

        virtual bool Scheduler_last_task_waiting(void) const = 0;       

        virtual void Scheduler_erase_current_task_waiting() = 0;

        virtual SchedulerRequest Scheduler_next_task_waiting() = 0;

        virtual void Scheduler_reset_current_position_in_waiting_queue() = 0;


        //
        // ======= RZ & tasks =======
        //

        virtual vector<RZ *> Scheduler_get_compatible_rz_vector(int task_id) = 0;

        virtual sc_time Scheduler_get_task_running_time(int task_id) = 0;

        virtual vector<RZ *> Scheduler_get_all_rz_vector(void) = 0;

        virtual int Scheduler_get_current_module_ID(RZ* rz) = 0;

        virtual bool Scheduler_is_RZ_blank(RZ *rz) = 0;

        virtual int Scheduler_get_module_ID(SchedulerRequest& req) = 0;


        virtual int Scheduler_get_application_number(void) = 0;

        virtual Application_interface* Scheduler_get_application_interface(int index) = 0;

        virtual bool Scheduler_exist_rz_properties(string inst_name) = 0;

        virtual bool Scheduler_exist_rz_properties(RZ *rz) = 0;

        virtual RZ_config& Scheduler_get_rz_properties(string inst_name) = 0;

        virtual RZ_config& Scheduler_get_rz_properties(RZ *rz) = 0;

        virtual Config_fct_point& Scheduler_get_current_fct_point(RZ *rz) = 0;

        
        //
        // ======= Scheduler execution =======
        //

        virtual void Scheduler_emulate_scheduler_behavior(void) = 0;

        virtual void Scheduler_set_scheduler_active(int taskid) = 0;

        
        //
        // ======= Requests and owners =======
        //

        virtual bool Scheduler_has_task_already_requested_mapping(int task_to_map, int request_owner) = 0;      

        virtual void Scheduler_add_finished_precedence(int task_mapped, int precedence) = 0;

        virtual void Scheduler_notify_request_owner_module_ready(int owner, int ready) = 0;

        virtual void Scheduler_print_finished_precedence_vector(int task_id) = 0;

        virtual void Scheduler_send_update_parameters_to_module(RZ* rz) = 0;
        
        
        //
        // ======= Task configuration =======
        //

        virtual void Scheduler_configure_task(RZ* rz, int id, int implID, int requestOwner) = 0;

        virtual void Scheduler_rerun_task(SchedulerRequest& req) = 0;

        virtual void Scheduler_set_current_task(RZ *rz, int task_id) = 0;


        //
        // ======= Task/RZ state =======
        //

        virtual Task_state Scheduler_get_task_state(int task_id) = 0;

        virtual Task_state Scheduler_get_task_state(RZ *rz) = 0;


        virtual bool Scheduler_set_blank(int hosting_rz_id) = 0;

        virtual bool Scheduler_set_blank(RZ *rz) = 0;

        

        //
        // ======= Preemption =======
        //

        virtual bool Scheduler_is_task_preempted(int taskid) const = 0;


        //
        // ======= Scheduler effort =======
        //

        virtual double Scheduler_get_performance_effort(void) const = 0;

        virtual double Scheduler_get_power_effort(void) const = 0;

        virtual double Scheduler_get_area_effort(void) const = 0;


        //
        // ======= Misc =======
        //

        virtual const char* Scheduler_get_name(void) const = 0;

        virtual ostream& Scheduler_get_output_stream(void) = 0;

        virtual void Scheduler_display_task_state_table(void) const = 0;

        virtual void Scheduler_display_rz_current_module_table(void) const = 0;

        virtual void Scheduler_display_waiting_queue(void) const = 0;

};

/* Default */
WAITING_QUEUE_HANDLER(default_algo);
MAPPING_ALGORITHM(default_algo);
SCHEDULING_ALGORITHM(default_algo);

/* Mapping/Sheduling Algorithm : AMAP_EDF */
WAITING_QUEUE_HANDLER(AMAP_EDF);
MAPPING_ALGORITHM(AMAP_EDF);
SCHEDULING_ALGORITHM(AMAP_EDF);

#endif