reconfigurable_zone.h

Go to the documentation of this file.

#ifndef RECONFIGURABLE_ZONE_H
#define RECONFIGURABLE_ZONE_H

#define SC_INCLUDE_DYNAMIC_PROCESSES

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <list>
#include <systemc.h>
#include "pe_implementation.h"
#include "resources.h"
#include "simulation_controller.h"
#include "task_implementation.h"
#include "simulation_controller.h"
#include "window_function.h"
#include "rz_config.h"

using namespace std;

        /*

        faire une table qui contient (atteignable du Reconfiguration_manager, user_scheduling et user_monitoring) :

        instName : ConfigRZ (equ. de ConfigProcessor)

        avec dans ConfigRZ :

        ConfigProcessorName cfgProcessorName;
        ConfigPowerGroup cfgPowerGroup;

        comment l'atteindre ?

        - avec le nom de l'instance d'une RZ (sw ou hw)

        ConfigRZ cfgRZ = getConfigRZ(inst_name)

        */


class RZ {

private:
        // instance processor_name (or rz_name)
        string name;

        // Current Fct Point
        string groupDomainName;
        Config_fct_point *current_cfg_fct_point;

        vector<TaskImplementation> taskImplementationVector;
        PEImplementation implementation;
        Resources resources;

        map<RZState, sc_time> occupationTimes;
        sc_time lastModificationTime;

        RZState state;

        int currentImplementationID;

        // Analog trace stuff
        sc_time requestTime;
        sc_time last_window_reset;
        
        WindowFunction window_function[NB_RZ_STATES];
        sc_time stateTimeOnLastCall[NB_RZ_STATES];

public:
        RZ(string n, vector<TaskImplementation> vec, PEImplementation impl) : name(n), taskImplementationVector(vec), implementation(impl) {

                current_cfg_fct_point = new Config_fct_point();
                groupDomainName = "";

                if(impl == HARD) Simulation_controller::get_logfile() << "RZ " << name << " can host: " << endl;
                else if(impl == SOFT) Simulation_controller::get_logfile() << "Processor " << name << " can host: " << endl;

                for(int i = 0; i < (int) taskImplementationVector.size(); i++) {
                        Simulation_controller::get_logfile() << "Implementation " << taskImplementationVector.at(i).getImplementationName() << " of task " << taskImplementationVector.at(i).getTaskName() 
                                << " (" << taskImplementationVector.at(i).getCompressedReconfigurationTime() << ", " << taskImplementationVector.at(i).getPreloadReconfigurationTime() << ") " << endl;
                }

                // Init table
                occupationTimes[RZ_BLANK] = SC_ZERO_TIME;
                occupationTimes[RZ_RECONFIG] = SC_ZERO_TIME;
                occupationTimes[RZ_MAPPED] = SC_ZERO_TIME;
                occupationTimes[RZ_ACTIVE] = SC_ZERO_TIME;

                state = RZ_BLANK;

                currentImplementationID = 0;
        }

        string getName(void) const;
        PEImplementation get_implementation_type(void) const;
        vector<TaskImplementation> getTaskImplementationVector(void) const;
        vector<TaskImplementation>* getTaskImplementationVectorPtr(void);
        Resources* get_resources_ptr(void);

        sc_time getOccupationTime(RZState state);
        RZState getRZState(void);
        void setRZState(RZState);
        void setCurrentImplementationID(int);
        TaskImplementation getCurrentImplementation(void);

        void setResources(map<string, int> &res);

        Config_fct_point& getConfigFctPoint();
        void setConfigFctPoint(Config_fct_point*);
        void RZ::setGroupDomainName(string domainName);
        string RZ::getGroupDomainName();

        double getStateOccupationRateOverLastWindow(RZState);
        void resetWindow(void);

};

#endif