fu_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 FU_BINDING_HPP
#define FU_BINDING_HPP

#include "custom_set.hpp"
#include "op_graph.hpp"
#include "refcount.hpp"

#include <iosfwd>
#include <limits>
#include <list>
#include <map>
#include <utility>

class funit_obj;
class module;
REF_FORWARD_DECL(AllocationInformation);
REF_FORWARD_DECL(fu_binding);
REF_FORWARD_DECL(generic_obj);
REF_FORWARD_DECL(hls);
REF_FORWARD_DECL(HLS_manager);
REF_FORWARD_DECL(memory);
REF_FORWARD_DECL(structural_manager);
REF_FORWARD_DECL(structural_object);
REF_FORWARD_DECL(technology_node);
REF_FORWARD_DECL(tree_node);
CONSTREF_FORWARD_DECL(AllocationInformation);
CONSTREF_FORWARD_DECL(HLS_manager);
CONSTREF_FORWARD_DECL(OpGraph);
CONSTREF_FORWARD_DECL(tree_manager);

struct jms_sorter
{
   bool operator()(const structural_objectRef& a, const structural_objectRef& b) const;
};

class fu_binding
{
 protected:
   std::map<unsigned int, unsigned int> allocation_map;

   std::map<std::pair<unsigned int, unsigned int>, generic_objRef> unique_table;

   std::map<std::pair<unsigned int, unsigned int>, OpVertexSet> operations;

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

   AllocationInformationRef allocation_information;

   const tree_managerConstRef TreeM;

   const OpGraphConstRef op_graph;

   CustomOrderedSet<vertex> ports_are_swapped;

   const ParameterConstRef parameters;

   int debug_level;

   bool has_resource_sharing_p;

   void update_allocation(unsigned int unit, unsigned int number);

   structural_objectRef add_gate(const HLS_managerRef HLSMgr, const hlsRef HLS, const technology_nodeRef fu,
                                 const std::string& name, const OpVertexSet& ops, structural_objectRef clock_port,
                                 structural_objectRef reset_port) const;

   void check_parametrization(structural_objectRef curr_gate);

   void kill_proxy_memory_units(std::map<unsigned int, unsigned int>& memory_units, structural_objectRef curr_gate,
                                std::map<unsigned int, std::list<structural_objectRef>>& var_call_sites_rel,
                                std::map<unsigned int, unsigned int>& reverse_memory_units);

   void kill_proxy_function_units(std::map<unsigned int, std::string>& wrapped_units, structural_objectRef curr_gate,
                                  std::map<std::string, std::list<structural_objectRef>>& fun_call_sites_rel,
                                  std::map<std::string, unsigned int>& reverse_wrapped_units);

   void manage_killing_memory_proxies(std::map<unsigned int, structural_objectRef>& mem_obj,
                                      std::map<unsigned int, unsigned int>& reverse_memory_units,
                                      std::map<unsigned int, std::list<structural_objectRef>>& var_call_sites_rel,
                                      const structural_managerRef SM, const hlsRef HLS, unsigned int& _unique_id);

   void manage_killing_function_proxies(std::map<unsigned int, structural_objectRef>& fun_obj,
                                        std::map<std::string, unsigned int>& reverse_function_units,
                                        std::map<std::string, std::list<structural_objectRef>>& fun_call_sites_rel,
                                        const structural_managerRef SM, const hlsRef HLS, unsigned int& _unique_id);

 public:
   static const unsigned int UNKNOWN;

   fu_binding(const HLS_managerConstRef _HLSMgr, const unsigned int function_id, const ParameterConstRef parameters);

   fu_binding(const fu_binding& original);

   fu_binding& operator=(const fu_binding&) = delete;

   virtual ~fu_binding();

   static fu_bindingRef create_fu_binding(const HLS_managerConstRef _HLSMgr, const unsigned int _function_id,
                                          const ParameterConstRef _parameters);

   void bind(const vertex& v, unsigned int unit, unsigned int index = std::numeric_limits<unsigned int>::max());

   unsigned int get_assign(const vertex& v) const;

   unsigned int get_assign(const unsigned int statement_index) const;

   unsigned int get_index(const vertex& v) const;

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

   unsigned int get_number(unsigned int unit) const
   {
      auto it = allocation_map.find(unit);
      if(it != allocation_map.end())
      {
         return it->second;
      }
      else
      {
         return 0;
      }
   }

   const funit_obj& operator[](const vertex& v);

   generic_objRef get(const vertex v) const;

   generic_objRef get(unsigned int name, unsigned int index)
   {
      return (unique_table.count(std::make_pair(name, index))) ? unique_table[std::make_pair(name, index)] :
                                                                 generic_objRef();
   }

   std::list<unsigned int> get_allocation_list() const;

   bool is_assigned(const vertex& v) const;

   bool is_assigned(const unsigned int statement_index) const;

   virtual void add_to_SM(const HLS_managerRef HLSMgr, const hlsRef HLS, structural_objectRef clock_port,
                          structural_objectRef reset_port);

   virtual void manage_extern_global_port(const HLS_managerRef HLSMgr, const hlsRef HLS, const structural_managerRef SM,
                                          structural_objectRef port_in, unsigned int dir, structural_objectRef circuit,
                                          unsigned int num);

   static void manage_memory_ports_chained(const structural_managerRef SM,
                                           const std::list<structural_objectRef>& memory_modules,
                                           const structural_objectRef circuit);
   virtual void manage_memory_ports_parallel_chained(const HLS_managerRef HLSMgr, const structural_managerRef SM,
                                                     const std::list<structural_objectRef>& memory_modules,
                                                     const structural_objectRef circuit, const hlsRef HLS,
                                                     unsigned int& unique_id);

   OpVertexSet get_operations(unsigned int unit, unsigned int index) const;

   void specialise_fu(const HLS_managerRef HLSMgr, const hlsRef HLS, structural_objectRef fu_obj, unsigned int fu,
                      const OpVertexSet& operations, unsigned int ar);

   void specialize_memory_unit(const HLS_managerRef HLSMgr, const hlsRef HLS, structural_objectRef fu_obj,
                               unsigned int ar, const std::string& base_address, unsigned long long rangesize,
                               bool is_memory_splitted, bool is_sparse_memory, bool is_sds);

   virtual bool manage_module_ports(const HLS_managerRef HLSMgr, const hlsRef HLS, const structural_managerRef SM,
                                    const structural_objectRef curr_gate, unsigned int num);

   void set_ports_are_swapped(vertex v, bool condition);

   bool get_ports_are_swapped(vertex v) const
   {
      return ports_are_swapped.find(v) != ports_are_swapped.end();
   }

   bool has_resource_sharing() const
   {
      return has_resource_sharing_p;
   }

   static void
   join_merge_split(const structural_managerRef SM, const hlsRef HLS,
                    std::map<structural_objectRef, std::list<structural_objectRef>, jms_sorter>& primary_outs,
                    const structural_objectRef circuit, unsigned int& unique_id);

   static void fill_array_ref_memory(std::ostream& init_file_a, std::ostream& init_file_b, unsigned int ar,
                                     unsigned long long& vec_size, unsigned long long& elts_size, const memoryRef mem,
                                     tree_managerConstRef TM, bool is_sds, unsigned long long bitsize_align);

   static void write_init(const tree_managerConstRef TreeM, tree_nodeRef var_node, tree_nodeRef init_node,
                          std::vector<std::string>& init_file, const memoryRef mem,
                          unsigned long long element_precision);
};

using fu_bindingRef = refcount<fu_binding>;
using fu_bindingConstRef = refcount<const fu_binding>;

#endif