liveness.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef LIVENESS_HPP
#define LIVENESS_HPP

#include "graph.hpp"

#include <list>
#include <string>

#include "custom_map.hpp"
#include "custom_set.hpp"

#include "refcount.hpp"

REF_FORWARD_DECL(hls);
REF_FORWARD_DECL(HLS_manager);
CONSTREF_FORWARD_DECL(Parameter);
CONSTREF_FORWARD_DECL(BBGraph);
REF_FORWARD_DECL(tree_manager);

class liveness
{
 private:
   const tree_managerRef TreeM;

   const ParameterConstRef Param;

   std::map<vertex, CustomOrderedSet<unsigned int>> live_in;

   std::map<vertex, CustomOrderedSet<unsigned int>> live_out;

   const std::string null_vertex_string;

   const CustomOrderedSet<unsigned int> empty_set;

   std::list<vertex> support_set;

   std::map<unsigned int, vertex> var_op_definition;

   std::map<vertex, CustomOrderedSet<vertex>> ending_operations;

   std::map<vertex, CustomOrderedSet<vertex>> running_operations;

   std::map<vertex, std::map<vertex, std::map<unsigned int, CustomOrderedSet<vertex>>>> state_in_definitions;

   std::map<vertex, std::map<vertex, std::map<unsigned int, CustomOrderedSet<vertex>>>> state_out_definitions;

   std::map<vertex, std::string> names;

   hlsRef HLS;
   const HLS_managerRef HLSMgr;

   CustomOrderedSet<vertex> dummy_states;

 public:
   liveness(const HLS_managerRef HLSMgr, const ParameterConstRef Param);

   ~liveness();

   void set_live_in(const vertex& v, unsigned int var);

   void set_live_in(const vertex& v, const CustomOrderedSet<unsigned int>& live_set);

   void set_live_in(const vertex& v, const CustomOrderedSet<unsigned int>::const_iterator first,
                    const CustomOrderedSet<unsigned int>::const_iterator last);

   void erase_el_live_in(const vertex& v, unsigned int var);

   void set_live_out(const vertex& v, const CustomOrderedSet<unsigned int>& vars);

   void set_live_out(const vertex& v, unsigned int var);

   void set_live_out(const vertex& v, const CustomOrderedSet<unsigned int>::const_iterator first,
                     const CustomOrderedSet<unsigned int>::const_iterator last);

   void erase_el_live_out(const vertex& v, unsigned int var);

   const CustomOrderedSet<unsigned int>& get_live_in(const vertex& v) const;

   const CustomOrderedSet<unsigned int>& get_live_out(const vertex& v) const;

   std::map<vertex, vertex> start_op;

   const std::list<vertex>& get_support() const
   {
      return support_set;
   }

   vertex get_op_where_defined(unsigned int var) const;

   bool has_op_where_defined(unsigned int var) const;

   void add_op_definition(unsigned int var, vertex v)
   {
      var_op_definition[var] = v;
   }

   bool is_defined(unsigned int var) const;

   const CustomOrderedSet<vertex>& get_state_in(vertex state, vertex op, unsigned int var) const;

   bool has_state_in(vertex state, vertex op, unsigned int var) const;

   void add_state_in_for_var(unsigned int var, vertex op, vertex state, vertex state_in);

   const CustomOrderedSet<vertex>& get_state_out(vertex state, vertex op, unsigned int var) const;

   bool has_state_out(vertex state, vertex op, unsigned int var) const;

   void add_state_out_for_var(unsigned int var, vertex op, vertex state, vertex state_in);

   const CustomOrderedSet<vertex>& get_state_where_end(vertex op) const;

   void add_state_for_ending_op(vertex op, vertex v)
   {
      ending_operations[op].insert(v);
   }

   const CustomOrderedSet<vertex>& get_state_where_run(vertex op) const;

   void add_state_for_running_op(vertex op, vertex v)
   {
      running_operations[op].insert(v);
   }

   void add_name(vertex v, const std::string& name)
   {
      names[v] = name;
   }

   const std::string& get_name(vertex v) const;

   void add_support_state(vertex v)
   {
      support_set.push_front(v);
   }

   bool are_in_conflict(vertex op1, vertex op2) const;

   // activate conflicts with reachability computation
   // void compute_conflicts_with_reachability(hlsRef _HLS)
   //{
   //   HLS = _HLS;
   //}

   void set_HLS(hlsRef _HLS)
   {
      HLS = _HLS;
   }

   vertex get_start_op(vertex state) const;

   void set_start_op(vertex state, vertex op);

   void add_dummy_state(vertex state)
   {
      dummy_states.insert(state);
   }

   bool is_a_dummy_state(vertex state)
   {
      return dummy_states.find(state) != dummy_states.end();
   }

   bool non_in_parallel(vertex v1, vertex v2, const BBGraphConstRef cdg) const;
};

// refcount definition for class
using livenessRef = refcount<liveness>;

#endif