source: proiecte/GAIIA/Graf.h @ 122

#ifndef GRAF
#define GRAF

#include <stdio.h>
#include <stdlib.h>
#include <vector>

using namespace std;

/**
* class implementing a general node of a graph
*/
class Nod
{
public:
        /**
        * the node's id
        */
        int id;

        /**
        * the node's corresponding cost
        */
        double cost;

        /**
        * the number of predecessors
        */
        int nr_pred;

        /**
        * the number of successors
        */
        int nr_succ;

        /**
        * the list of predecesors
        */
        void ** predecesori;

        /**
        * the list of successors
        */
        void ** succesori;
        
public:
        /**
        * the constructor
        *
        * @param i the id
        * @param c the cost 
        */
        Nod(int i = 0, double c = 0);

        /**
        * Method printing the node's information
        */
        void print(); 

        /**
        * Method adding a predecessor
        *
        * @param p the new predecessor
        */
        void addPredecesor(void *p);

        /**
        * Method adding a successor
        *
        * @param s the new successor
        */
        void addSuccesor(void * s);
};

/**
* class implementing a node of a tasks graph
*/
class Task:public Nod
{
public:
        /**
        * the minimum topological level
        */
        int niv_topo_min;

        /**
        * the maximum topological level
        */
        int niv_topo_max;

        /**
        * the current topological level
        */
        int niv_topo;

        /**
        * the id of the associated processor
        */
        int procesor_id;
  
        /**
        * the start moment for the current task
        */
        int start;

        /**
        * the stop moment for the current task
        */
        int stop;
public:
        /**
        * the constructor
        *
        * @param i the id
        * @param c the cost 
        */
        Task(int i = 0, double c = 0);

        /**
        * Method that assocites to the current task a processor scheduling it to be executed between "st" and "fin"
        *
        * @param id the id of the associated processor
        * @param st the start moment
        * @param fin the stop moment
        */
        void setProcesor(int id,int st, int fin);

        /**
        * the default initialization
        */
        void init();

        /**
        * method printing the task's information
        */
        void print();
};

/**
* class implementing a node of a processors graph
*/
class Procesor:public Nod
{
public:
        /**
        * the total number of tasks we want to schedule
        */
        int nr_tasks;

        /**
        * the total number of processors we can use
        */
        int nr_procs;
        
        /**
        * the queue of associated tasks
        */
        int * queue;

        /**
        * current time used in the fitness computation
        */
        int time;

        /**
        * the list containing the communication costs with neighbours
        */
        int * cost_comm;
public:
        /**
        * the constructor
        *
        * @param i the processor's index
        * @param c the processor's cost
        */
        Procesor(int i = 0, int c = 0);

        /**
        * Method adding a task in the tasks queue
        *
        * @param task_id the index of the task we add in the list
        */
        void addTask(int task_id);

        /**
        * Method initializing a processor to the default values
        */
        void init();

        /**
        * method adding the communication costs for the specified number of processors
        *
        * @param v the list of communication costs
        * @param n the number of processors
        */
        void addCosts(int v[], int n);

        /**
        * Method printing the processor's information
        */
        void print();
};

/**
* class implementing a graph edge 
*/
class Muchie
{
public:
        /**
        * the predecessor node
        */
        Nod * predecesor;

        /**
        * the successor node
        */
        Nod * succesor;

        /**
        * the edge's communication cost
        */
        double cost;
public:
        /**
        * the constructor
        *
        * @param p the predecessor node
        * @param s the successor node
        * @param c the edge's communication cost
        */
        Muchie(Nod * p = NULL, Nod * s = NULL, double c = 0);

        /**
        * Method printing the edge's information
        */
        void print();
};

/**
* class implementing a graph
*/
class Graf
{
public:
        /**
        * the nodes list
        */
        Nod * noduri;

        /**
        * the edges list
        */
        Muchie * muchii;

        /**
        * the number of nodes 
        */
        int nr_noduri;

        /**
        * the number of edges
        */
        int nr_muchii;
public:
        /**
        * the constructor
        *
        * @param n the number of nodes 
        * @param m the number of edges
        */
        Graf(int n = 0, int m = 0);

        /**
        * the constructor
        *
        * @param filename the input filename 
        */
        Graf(char * filename);

        /**
        * method printing the graph's information
        */
        void print();
  
        /**
        * copy operator
        */
        Graf& operator=(const Graf& clone);
};

/**
* class implementing a graph of tasks
*/ 
class TaskGraf: public Graf
{
public:
        /**
        * the list of nodes (tasks)
        */
        Task * noduri;

        /**
        * the maximum topological level
        */
        int max_level;

        /**
        * the list of floating nodes 
        */
        vector<int> f_nodes;
public:
        /**
        * method initializing a graph of tasks to the structure specified in the file
        *
        * @param filename the input filename containing the configuration
        */
        void init(char * filename);

        /**
        * the constructor
        *
        * @param n the number of tasks
        * @param m the number of communication links
        */
        TaskGraf(int n = 0, int m = 0);

        /**
        * method that computes the topological sort 
        *
        * @return the maximum topological level
        */
        int sortare_topologica();

        /**
        * method that computes the reverse topological sort 
        */
        void sortare_topologica_inversa();

        /**
        * method that computes the list of free floating nodes
        */
        void computeFreeFloatingNodes();

        /**
        * method that initializes the structure with the default configuration
        */
        void init();

        /**
        * method that computes the topological sort 
        */
        void sort_topo();

        /**
        * method that prints the information about the graph of tasks
        */
        void print();

        /**
        * the copy operator
        */
        TaskGraf& operator=(const TaskGraf& clone);
};

/**
* class implementing a graph of processors
*/
class ProcesorGraf: public Graf
{
public:
        /**
        * the list of processors
        */
        Procesor * noduri;
        
public:
        /**
        * method initializing a graph of processors to the structure specified in the file
        *
        * @param filename the input filename containing the configuration
        */
        void init(char * filename);

        /**
        * the constructor
        *
        * @param n the number of processors
        * @param m the number of communication links
        */
        ProcesorGraf(int n = 0, int m = 0);

        /**
        * method that initializes the structure with the default configuration
        */
        void init();    

        /**
        * method that prints the information about the graph of processors
        */
        void print();

        /**
        * the copy operator
        */
        ProcesorGraf& operator=(const ProcesorGraf& clone);
};

#endif