design_flow_graph.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 DESIGN_FLOW_GRAPH_HPP
#define DESIGN_FLOW_GRAPH_HPP

#include "edge_info.hpp"  // for EdgeInfo, EdgeIn...
#include "graph.hpp"      // for vertex, EdgeDesc...
#include "graph_info.hpp" // for GraphInfo
#include "node_info.hpp"  // for NodeInfo
#include "refcount.hpp"   // for refcount, Refcou...
#include <cstddef>        // for size_t
#include <iosfwd>         // for ostream
#include <string>         // for string

#include "custom_map.hpp" // for unordered_map

CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(DesignFlowGraphsCollection);
REF_FORWARD_DECL(DesignFlowStep);
enum class DesignFlowStep_Status;
class SdfGraph;

struct DesignFlowStepInfo : public NodeInfo
{
 public:
   const DesignFlowStepRef design_flow_step;

   DesignFlowStep_Status status;

   DesignFlowStepInfo(const DesignFlowStepRef _design_flow_step, const bool unnecessary);
};
using DesignFlowStepInfoRef = refcount<DesignFlowStepInfo>;
using DesignFlowStepInfoConstRef = refcount<const DesignFlowStepInfo>;

struct DesignFlowDependenceInfo : public EdgeInfo
{
 public:
   DesignFlowDependenceInfo();

   ~DesignFlowDependenceInfo() override;
};
using DesignFlowDependenceInfoRef = refcount<DesignFlowDependenceInfo>;
using DesignFlowDependenceInfoConstRef = refcount<const DesignFlowDependenceInfo>;

struct DesignFlowGraphInfo : public GraphInfo
{
 public:
   vertex entry;

   vertex exit;
};
using DesignFlowGraphInfoRef = refcount<DesignFlowGraphInfo>;
using DesignFlowGraphInfoConstRef = refcount<const DesignFlowGraphInfo>;

class DesignFlowGraphsCollection : public graphs_collection
{
 protected:
   CustomUnorderedMap<std::string, vertex> signature_to_vertex;

 public:
   explicit DesignFlowGraphsCollection(const ParameterConstRef parameters);

   ~DesignFlowGraphsCollection() override;

   vertex GetDesignFlowStep(const std::string& signature) const;

   inline EdgeDescriptor AddDesignFlowDependence(const vertex source, const vertex target, const int selector)
   {
      if(ExistsEdge(source, target))
      {
         return AddSelector(source, target, selector);
      }
      else
      {
         return InternalAddEdge(source, target, selector, EdgeInfoRef(new DesignFlowDependenceInfo()));
      }
   }

   vertex AddDesignFlowStep(const DesignFlowStepRef design_flow_step, const bool unnecessary);
};
using DesignFlowGraphsCollectionRef = refcount<DesignFlowGraphsCollection>;
using DesignFlowGraphsCollectionConstRef = refcount<const DesignFlowGraphsCollection>;

class DesignFlowGraph : public graph
{
 public:
   static const int DEPENDENCE_SELECTOR;

   static const int PRECEDENCE_SELECTOR;

   static const int AUX_SELECTOR;

   static const int DEPENDENCE_FEEDBACK_SELECTOR;

   enum Type
   {
      ALL, 
   };

   DesignFlowGraph(const DesignFlowGraphsCollectionRef design_flow_graphs_collection, const int _selector);

   DesignFlowGraph(const DesignFlowGraphsCollectionRef design_flow_graphs_collection, const int _selector,
                   const CustomUnorderedSet<vertex>& vertices);

   ~DesignFlowGraph() override;

   vertex GetDesignFlowStep(const std::string& signature) const;

   inline DesignFlowStepInfoRef GetDesignFlowStepInfo(const vertex step)
   {
      return RefcountCast<DesignFlowStepInfo>(graph::GetNodeInfo(step));
   }

   inline const DesignFlowStepInfoConstRef CGetDesignFlowStepInfo(const vertex step) const
   {
      return RefcountCast<const DesignFlowStepInfo>(graph::CGetNodeInfo(step));
   }

   inline DesignFlowGraphInfoRef GetDesignFlowGraphInfo()
   {
      return RefcountCast<DesignFlowGraphInfo>(graph::GetGraphInfo());
   }

   inline const DesignFlowGraphInfoConstRef CGetDesignFlowGraphInfo() const
   {
      return RefcountCast<const DesignFlowGraphInfo>(graph::CGetGraphInfo());
   }

   void WriteDot(const std::string& file_name, const int detail_level = 0) const;

#ifndef NDEBUG

   void WriteDot(const std::string& file_name,
                 const CustomMap<size_t, CustomMap<vertex, DesignFlowStep_Status>>& vertex_history,
                 const CustomMap<size_t, CustomUnorderedMapStable<EdgeDescriptor, int>>& edge_history,
                 const CustomMap<vertex, std::string>& vertex_names, const size_t writing_step_counter) const;
#endif
};
using DesignFlowGraphRef = refcount<DesignFlowGraph>;
using DesignFlowGraphConstRef = refcount<const DesignFlowGraph>;

class DesignFlowStepWriter : public VertexWriter
{
 private:
   const CustomMap<vertex, DesignFlowStep_Status>& vertex_history;

   const CustomMap<vertex, std::string>& actor_names;

 public:
   DesignFlowStepWriter(
       const DesignFlowGraph* design_flow_graph,
       const CustomMap<vertex, DesignFlowStep_Status>& vertex_history = CustomMap<vertex, DesignFlowStep_Status>(),
       const CustomMap<vertex, std::string>& actor_names = CustomMap<vertex, std::string>(),
       const int detail_level = 0);

   ~DesignFlowStepWriter() override;

   void operator()(std::ostream& out, const vertex& v) const override;
};

class DesignFlowEdgeWriter : public EdgeWriter
{
 private:
   const CustomMap<vertex, DesignFlowStep_Status>& vertex_history;

   const CustomUnorderedMapStable<EdgeDescriptor, int>& edge_history;

 public:
   DesignFlowEdgeWriter(
       const DesignFlowGraph* design_flow_graph,
       const CustomMap<vertex, DesignFlowStep_Status>& vertex_history = CustomMap<vertex, DesignFlowStep_Status>(),
       const CustomUnorderedMapStable<EdgeDescriptor, int>& edge_history =
           CustomUnorderedMapStable<EdgeDescriptor, int>(),
       const int detail_level = 0);

   void operator()(std::ostream& out, const EdgeDescriptor& edge) const override;
};

#endif