conn_binding.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 CONN_BINDING_HPP
#define CONN_BINDING_HPP

#include "config_HAVE_UNORDERED.hpp"

#include <iosfwd>
#include <string>

#include "refcount.hpp"
REF_FORWARD_DECL(HLS_manager);
REF_FORWARD_DECL(generic_obj);
REF_FORWARD_DECL(connection_obj);
CONSTREF_FORWARD_DECL(BehavioralHelper);
REF_FORWARD_DECL(structural_manager);
REF_FORWARD_DECL(structural_object);
REF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(hls);
REF_FORWARD_DECL(conn_binding);
CONSTREF_FORWARD_DECL(OpGraph);
class GenericObjUnsignedIntSorter;

#include "custom_map.hpp"
#include "generic_obj.hpp"
#include "graph.hpp"

using data_transfer = std::tuple<unsigned int, unsigned int, vertex, vertex, vertex>;

class conn_binding
{
 public:
   using direction_type = enum { IN = 0, OUT };

   using type_t = enum { STG = 0 };

   using connection = std::tuple<generic_objRef, generic_objRef, unsigned int, unsigned int>;

#if HAVE_UNORDERED
   using conn_implementation_map = std::map<connection, connection_objRef>;
#else

   struct ConnectionSorter : public std::binary_function<connection, connection, bool>
   {
      bool operator()(const connection& x, const connection& y) const;
   };

   using conn_implementation_map = std::map<connection, connection_objRef, ConnectionSorter>;
#endif

   using const_param = std::tuple<std::string, std::string>;

   struct ConnectionTarget : public std::tuple<generic_objRef, unsigned int, unsigned int>
   {
      ConnectionTarget(generic_objRef tgt, unsigned int tgt_port, unsigned int tgt_port_index);

#if !HAVE_UNORDERED

      bool operator<(const ConnectionTarget& other) const;
#endif
   };

#if HAVE_UNORDERED
   using ConnectionSources = CustomUnorderedMap<generic_objRef, CustomOrderedSet<data_transfer>>;
#else
   using ConnectionSources = std::map<generic_objRef, CustomOrderedSet<data_transfer>, GenericObjSorter>;
#endif

 protected:
   const ParameterConstRef parameters;

   int debug_level;

 private:
   int output_level;

 private:
   const BehavioralHelperConstRef BH;

   std::map<vertex, std::map<unsigned int, generic_objRef>> activation_ports;

   std::map<unsigned int, generic_objRef> input_ports;

   std::map<unsigned int, generic_objRef> output_ports;

   std::map<const_param, generic_objRef> constant_values;

   std::map<std::string, structural_objectRef> converters;

   std::map<std::pair<vertex, unsigned int>, generic_objRef> command_input_ports;

   std::map<vertex, generic_objRef> command_output_ports;

#if HAVE_UNORDERED
   using Selectors = std::map<std::pair<generic_objRef, unsigned int>, generic_objRef>;
#else
   using Selectors = std::map<std::pair<generic_objRef, unsigned int>, generic_objRef, GenericObjUnsignedIntSorter>;
#endif
   std::map<unsigned int, Selectors> selectors;

#if HAVE_UNORDERED
   CustomUnorderedSet<generic_objRef> sparse_logic;
#else
   CustomOrderedSet<generic_objRef, GenericObjSorter> sparse_logic;
#endif

   std::map<ConnectionTarget, ConnectionSources> conn_variables;

   conn_implementation_map conn_implementation;

   static unsigned unique_id;

   void specialise_mux(const generic_objRef mux, unsigned int bits_tgt) const;

   void mux_connection(const hlsRef HLS, const structural_managerRef SM);

   void add_sparse_logic_dp(const hlsRef HLS, const structural_managerRef SM, const HLS_managerRef HLSMgr);

   void add_command_ports(const HLS_managerRef HLSMgr, const hlsRef HLS, const structural_managerRef SM);

   virtual void mux_allocation(const hlsRef HLS, const structural_managerRef SM, structural_objectRef src,
                               structural_objectRef tgt, connection_objRef conn);

   void add_datapath_connection(const technology_managerRef TM, const structural_managerRef SM,
                                const structural_objectRef src, const structural_objectRef port_tgt,
                                unsigned int conn_type);

   bool check_pv_allconnected(structural_objectRef port_i);

 public:
   conn_binding(const BehavioralHelperConstRef BH, const ParameterConstRef parameters);

   virtual ~conn_binding();

   generic_objRef bind_port(unsigned int var, direction_type dir);

   generic_objRef bind_command_port(const vertex& ver, direction_type dir, unsigned int mode, const OpGraphConstRef g);

   generic_objRef bind_selector_port(direction_type dir, unsigned int mode, const vertex& cond,
                                     const OpGraphConstRef data);

   generic_objRef bind_selector_port(direction_type dir, unsigned int mode, const generic_objRef elem, unsigned int op);

   generic_objRef get_port(unsigned int var, direction_type dir);

   virtual void print() const;

   void add_data_transfer(const generic_objRef op1, const generic_objRef op2, unsigned int operand,
                          unsigned int port_index, data_transfer data);

   void AddConnectionCB(const generic_objRef op1, const generic_objRef op2, unsigned int operand,
                        unsigned int port_index, connection_objRef conn);

   const std::map<ConnectionTarget, ConnectionSources>& get_data_transfers() const;

   unsigned long long determine_bit_level_mux() const;

   const std::map<unsigned int, Selectors>& GetSelectors() const
   {
      return selectors;
   }

   void add_sparse_logic(const generic_objRef so)
   {
      sparse_logic.insert(so);
   }

   virtual void add_to_SM(const HLS_managerRef HLSMgr, const hlsRef HLS, const structural_managerRef SM);

   generic_objRef get_constant_obj(const std::string& value, const std::string& param, unsigned int precision);

   const std::map<const_param, generic_objRef>& get_constant_objs() const;

   static conn_bindingRef create_conn_binding(const HLS_managerRef _HLSMgr, const hlsRef _HLS,
                                              const BehavioralHelperConstRef _BH, const ParameterConstRef _parameters);

   void cleanInternals();
};
using conn_bindingRef = refcount<conn_binding>;

#endif