technology_node.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 TECHNOLOGY_NODE_HPP
#define TECHNOLOGY_NODE_HPP

#include "config_HAVE_CIRCUIT_BUILT.hpp"
#include "config_HAVE_EXPERIMENTAL.hpp"

#include "refcount.hpp"
#include "simple_indent.hpp"
#include "utility.hpp"
#include <map>
#include <ostream>
#include <string>
#include <vector>

REF_FORWARD_DECL(technology_node);
#if HAVE_CIRCUIT_BUILT
REF_FORWARD_DECL(structural_manager);
#endif
class xml_element;
REF_FORWARD_DECL(xml_node);
REF_FORWARD_DECL(technology_manager);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(attribute);
REF_FORWARD_DECL(area_info);
REF_FORWARD_DECL(layout_model);
REF_FORWARD_DECL(time_info);
REF_FORWARD_DECL(power_model);

#define LUT_GATE_STD "LUT"
#define IBUF_GATE_STD "IBUF"
#define OBUF_GATE_STD "OBUF"

// Logic Ports
#define AND_GATE_STD "AND_GATE"
#define NAND_GATE_STD "NAND_GATE"
#define OR_GATE_STD "OR_GATE"
#define NOR_GATE_STD "NOR_GATE"
#define XOR_GATE_STD "XOR_GATE"
#define XNOR_GATE_STD "XNOR_GATE"
#define NOT_GATE_STD "NOT_GATE"
#define DFF_GATE_STD "DFF_GATE"
#define BUFF_GATE_STD "BUFF_GATE"

#define TEST_MUL_MUX_8 "TEST_MUL_MUX_8"
#define MUX_GATE_STD "MUX_GATE"
#define DEMUX_GATE_STD "DEMUX_GATE"
#define MUX_N_TO_1 "MUX_N_to_1"
#define MULTIPLIER_STD "mult_expr_FU"
#define UI_MULTIPLIER_STD "ui_mult_expr_FU"
#define UI_CONST_MULTIPLIER_STD "ui_const_mult_expr_FU"
#define ADDER_STD "plus_expr_FU"
#define COND_EXPR_STD "cond_expr_FU"
#define UI_ADDER_STD "ui_plus_expr_FU"
#define UI_ALIGN_ADDER_STD "ui_align_plus_expr_FU"
#define CONCAT4_STD "concat_4_constructor"
#define SIGNED_BITFIELD_FU_STD "Sbitfield_FU"
#define UNSIGNED_BITFIELD_FU_STD "Ubitfield_FU"
#define CONSTANT_STD "constant_value"
#define ASSIGN_SIGNED_STD "ASSIGN_SIGNED_FU"
#define ASSIGN_UNSIGNED_STD "ASSIGN_UNSIGNED_FU"
#define ASSIGN_REAL_STD "ASSIGN_REAL_FU"
#define ASSIGN_VECTOR_BOOL_STD "ASSIGN_VECTOR_BOOL_FU"
#define ASSIGN_VEC_SIGNED_STD "ASSIGN_VEC_SIGNED_FU"
#define ASSIGN_VEC_UNSIGNED_STD "ASSIGN_VEC_UNSIGNED_FU"
#define ADDR_EXPR_STD "addr_expr_FU"
#define ASSERT_EXPR_SIGNED_STD "assert_expr_FU"
#define ASSERT_EXPR_UNSIGNED_STD "ui_assert_expr_FU"
#define ASSERT_EXPR_REAL_STD "fp_assert_expr_FU"
#define BMEMORY_STD "BMEMORY_CTRL"
#define BMEMORY_STDN "BMEMORY_CTRLN"
#define MEMCPY_STD "__internal_bambu_memcpy"
#define ARRAY_1D_STD_BRAM "ARRAY_1D_STD_BRAM"
#define ARRAY_1D_STD_BRAM_SDS "ARRAY_1D_STD_BRAM_SDS"
#define ARRAY_1D_STD_BRAM_SDS_BUS "ARRAY_1D_STD_BRAM_SDS_BUS"
#define ARRAY_1D_STD_DISTRAM_SDS "ARRAY_1D_STD_DISTRAM_SDS"
#define ARRAY_1D_STD_BRAM_N1 "ARRAY_1D_STD_BRAM_N1"
#define ARRAY_1D_STD_BRAM_N1_SDS "ARRAY_1D_STD_BRAM_N1_SDS"
#define ARRAY_1D_STD_DISTRAM_N1_SDS "ARRAY_1D_STD_DISTRAM_N1_SDS"
#define ARRAY_1D_STD_BRAM_N1_SDS_BUS "ARRAY_1D_STD_BRAM_N1_SDS_BUS"
#define ARRAY_1D_STD_BRAM_NN "ARRAY_1D_STD_BRAM_NN"
#define ARRAY_1D_STD_BRAM_NN_SDS "ARRAY_1D_STD_BRAM_NN_SDS"
#define ARRAY_1D_STD_BRAM_NN_SDS_BUS "ARRAY_1D_STD_BRAM_NN_SDS_BUS"
#define ARRAY_1D_STD_DISTRAM_NN_SDS "ARRAY_1D_STD_DISTRAM_NN_SDS"
#define STD_BRAM "STD_BRAM"
#define STD_BRAMN "STD_BRAMN"
#define MEMLOAD_STD "__builtin_memload"
#define MEMSTORE_STD "__builtin_memstore"
#define MEMLOAD_STDN "__builtin_memload_N"
#define MEMSTORE_STDN "__builtin_memstore_N"
#define BUILTIN_EXIT_STD "__builtin_exit"
#define BUILTIN_ABORT_STD "__builtin_abort"
#define BUILTIN_WAIT_CALL_STD "__builtin_wait_call"
#define PROXY_CTRL "PROXY_CTRL"
#define PROXY_CTRLN "PROXY_CTRLN"
#define DPROXY_CTRL "DPROXY_CTRL"
#define DPROXY_CTRLN "DPROXY_CTRLN"
#define SPROXY_CTRL "SPROXY_CTRL"
#define SPROXY_CTRLN "SPROXY_CTRLN"

#define MEMORY_TYPE_ASYNCHRONOUS "ASYNCHRONOUS"
#define MEMORY_TYPE_SYNCHRONOUS_UNALIGNED "SYNCHRONOUS_UNALIGNED"
#define MEMORY_TYPE_SYNCHRONOUS_SDS "SYNCHRONOUS_SDS"
#define MEMORY_TYPE_SYNCHRONOUS_SDS_BUS "SYNCHRONOUS_SDS_BUS"

#define CHANNELS_TYPE_MEM_ACC_11 "MEM_ACC_11"
#define CHANNELS_TYPE_MEM_ACC_N1 "MEM_ACC_N1"
#define CHANNELS_TYPE_MEM_ACC_NN "MEM_ACC_NN"
#define CHANNELS_TYPE_MEM_ACC_P1N "MEM_ACC_P1N"
#define CHANNELS_TYPE_MEM_ACC_CS "MEM_ACC_CS"

#define MEMORY_CTRL_TYPE_D00 "D00"
#define MEMORY_CTRL_TYPE_PROXY "PROXY"
#define MEMORY_CTRL_TYPE_DPROXY "DPROXY"
#define MEMORY_CTRL_TYPE_SPROXY "SPROXY"
#define MEMORY_CTRL_TYPE_PROXYN "PROXYN"
#define MEMORY_CTRL_TYPE_DPROXYN "DPROXYN"
#define MEMORY_CTRL_TYPE_SPROXYN "SPROXYN"

#define UUDATA_CONVERTER_STD "UUdata_converter_FU"
#define IUDATA_CONVERTER_STD "IUdata_converter_FU"
#define UIDATA_CONVERTER_STD "UIdata_converter_FU"
#define IIDATA_CONVERTER_STD "IIdata_converter_FU"
#define BIVECTOR_CONVERTER_STD "BIvector_converter_FU"
#define BUVECTOR_CONVERTER_STD "BUvector_converter_FU"
#define UBVECTOR_CONVERTER_STD "UBvector_converter_FU"
#define IIVECTOR_CONVERTER_STD "IIvector_converter_FU"
#define UUVECTOR_CONVERTER_STD "UUvector_converter_FU"
#define UIVECTOR_CONVERTER_STD "UIvector_converter_FU"
#define IUVECTOR_CONVERTER_STD "IUvector_converter_FU"

#define FFDATA_CONVERTER_STD "FFdata_converter_FU"
#define SF_FFDATA_CONVERTER_32_64_STD "sf_FFdata_converter_FU_32_64"
#define SF_FFDATA_CONVERTER_64_32_STD "sf_FFdata_converter_FU_64_32"

#define UUCONVERTER_EXPR_STD "UUconvert_expr_FU"
#define IUCONVERTER_EXPR_STD "IUconvert_expr_FU"
#define UICONVERTER_EXPR_STD "UIconvert_expr_FU"
#define IICONVERTER_EXPR_STD "IIconvert_expr_FU"
#define VIEW_CONVERT_STD_INT "view_convert_expr_FU"
#define VIEW_CONVERT_STD_UINT "ui_view_convert_expr_FU"
#define VIEW_CONVERT_STD_REAL "fp_view_convert_expr_FU"

#define EXTRACT_BIT_EXPR_SIGNED_STD "extract_bit_expr_FU"
#define EXTRACT_BIT_EXPR_UNSIGNED_STD "ui_extract_bit_expr_FU"
#define LUT_EXPR_STD "lut_expr_FU"

// For distributed controller
#define CE_STD "CE_FU"
#define CE_FSM "CE_FSM"
#define CE_BYPASS "CE_BYPASS"
#define JOIN_STD "JOIN_FU"
#define SIMPLEJOIN_STD "SIMPLEJOIN_FU"
#define PT_STD "PT_FU"
#define START_STD "START_FU"
#define COND_STD "COND_FU"
#define SWITCH_CASE_STD "SWITCH_CASE_FU"
#define MC_STD "MC_FU"
#define FC_STD "FC_FU"

#define register_SHIFT "register_SHIFT"

#define register_STD "register_STD"

#define register_SR "register_SR"

#define flipflop_SR "flipflop_SR"

#define register_AR "register_AR"

#define flipflop_AR "flipflop_AR"

#define register_AR_NORETIME "register_AR_NORETIME"
#define register_AR_NORETIME_INT "register_AR_NORETIME_INT"
#define register_AR_NORETIME_UINT "register_AR_NORETIME_UINT"
#define register_AR_NORETIME_REAL "register_AR_NORETIME_REAL"
#define register_SE "register_SE"
#define register_SRSE "register_SRSE"
#define register_ARSE "register_ARSE"
#define register_SARSE "register_SARSE"
#define MEMORY_MAPPED_REGISTER_FU "memory_mapped_register_FU"
#define RETURN_MM_REGISTER_FU "return_value_mm_register_FU"
#define NOTYFY_CALLER_MINIMAL_FU "notify_caller_minimal_FU"
#define STATUS_REGISTER_FU "status_register_FU"
#define STATUS_REGISTER_NO_NOTIFIED_FU "status_register_no_notified_FU"
#define MEMORY_MAPPED_REGISTERN_FU "memory_mapped_registerN_FU"
#define RETURN_MM_REGISTERN_FU "return_value_mm_registerN_FU"
#define NOTYFY_CALLER_MINIMALN_FU "notify_caller_minimalN_FU"
#define STATUS_REGISTERN_FU "status_registerN_FU"
#define STATUS_REGISTER_NO_NOTIFIEDN_FU "status_register_no_notifiedN_FU"

#define GET_TEC_KIND_TEXT(meth)               \
   std::string get_kind_text() const override \
   {                                          \
      return std::string(#meth);              \
   }

enum tec_kind
{
   operation_K,
   functional_unit_K,
   functional_unit_template_K
};

#define GET_TEC_KIND(meth)                 \
   enum tec_kind get_kind() const override \
   {                                       \
      return (meth##_K);                   \
   }

struct technology_node
{
   technology_node();

   virtual ~technology_node();

   virtual const std::string& get_name() const = 0;

   virtual void xload(const xml_element* Enode, const technology_nodeRef owner, const ParameterConstRef Param) = 0;

   virtual void xwrite(xml_element* rootnode, const technology_nodeRef tn, const ParameterConstRef Param) = 0;

   virtual void print(std::ostream& os) const = 0;

   virtual std::string get_kind_text() const = 0;

   virtual enum tec_kind get_kind() const = 0;

   friend std::ostream& operator<<(std::ostream& os, const technology_nodeRef& s)
   {
      if(s)
      {
         s->print(os);
      }
      return os;
   }

 protected:
   static simple_indent PP;
};
using technology_nodeRef = refcount<technology_node>;
using technology_nodeConstRef = refcount<const technology_node>;

struct operation : public technology_node
{
   std::string operation_name;

   time_infoRef time_m;

#if HAVE_EXPERIMENTAL
   power_modelRef power_m;
#endif

   bool commutative;

   bool bounded;

   bool primary_inputs_registered;

   std::map<std::string, std::vector<unsigned int>> supported_types;

   std::string pipe_parameters;

   std::string portsize_parameters;

   operation();

   ~operation() override;

   const std::string& get_name() const override
   {
      return operation_name;
   }

   bool is_type_supported(const std::string& type_name) const;

   bool is_type_supported(const std::string& type_name, unsigned long long type_prec) const;

   bool is_type_supported(const std::string& type_name, const std::vector<unsigned long long>& type_prec,
                          const std::vector<unsigned long long>& type_n_element) const;

   std::string get_type_supported_string() const;

   void xload(const xml_element* Enode, const technology_nodeRef fu, const ParameterConstRef Param) override;

   void xwrite(xml_element* rootnode, const technology_nodeRef tn, const ParameterConstRef Param) override;

   bool is_bounded() const
   {
      return bounded;
   }

   bool is_primary_inputs_registered() const
   {
      return primary_inputs_registered;
   }

   void print(std::ostream& os) const override;

   GET_TEC_KIND_TEXT(operation)

   
   GET_TEC_KIND(operation)
};

struct functional_unit : public technology_node
{
   using type_t = enum { UNKNOWN = 0, COMBINATIONAL, STATETABLE, FF, LATCH, PHYSICAL };

   using operation_vec = std::vector<technology_nodeRef>;

   type_t logical_type;

   std::string functional_unit_name;

   std::vector<std::string> ordered_attributes;

   std::map<std::string, attributeRef> attributes;

   double clock_period;

   double clock_period_resource_fraction;

   area_infoRef area_m;

#if HAVE_CIRCUIT_BUILT
   structural_managerRef CM;
#endif

   xml_nodeRef XML_description;

   std::string fu_template_name;

   std::string fu_template_parameters;

   std::string characterizing_constant_value;

   std::string memory_type;

   std::string channels_type;

   std::string memory_ctrl_type;

   std::string bram_load_latency;

   std::string component_timing_alias;

   TimeStamp characterization_timestamp;

   functional_unit();

   explicit functional_unit(const xml_nodeRef XML_description);

   ~functional_unit() override;

   void add(const technology_nodeRef& curr)
   {
      if(op_name_to_op.count(curr->get_name()))
      {
         auto del = std::find(list_of_operation.begin(), list_of_operation.end(), op_name_to_op[curr->get_name()]);
         if(del != list_of_operation.end())
         {
            list_of_operation.erase(del);
         }
      }
      list_of_operation.push_back(curr);
      op_name_to_op[curr->get_name()] = curr;
   }

   void set_clock_period(double _clock_period);

   double get_clock_period() const
   {
      return clock_period;
   }

   void set_clock_period_resource_fraction(double _clock_period_resource_fraction);

   double get_clock_period_resource_fraction() const
   {
      return clock_period_resource_fraction;
   }

   const operation_vec& get_operations() const
   {
      return list_of_operation;
   }

   size_t get_operations_num() const
   {
      return list_of_operation.size();
   }

   technology_nodeRef get_operation(const std::string& op_name) const;

   const std::string& get_name() const override
   {
      return functional_unit_name;
   }

   void xload(const xml_element* node, const technology_nodeRef fu, const ParameterConstRef Param) override;

   void xwrite(xml_element* rootnode, const technology_nodeRef tn, const ParameterConstRef Param) override;

   void print(std::ostream& os) const override;

   GET_TEC_KIND_TEXT(functional_unit)

   
   GET_TEC_KIND(functional_unit)

 private:
   std::map<std::string, technology_nodeRef> op_name_to_op;

   operation_vec list_of_operation;

   friend class technology_manager;
};

struct functional_unit_template : public technology_node
{
   technology_nodeRef FU;

   std::string specialized;

   std::string characterizing_constant_value;

   std::string memory_type;

   std::string channels_type;

   std::string memory_ctrl_type;

   std::string bram_load_latency;

   bool no_constant_characterization;


   functional_unit_template();

   explicit functional_unit_template(const xml_nodeRef XML_description);

   const std::string& get_name() const override
   {
      return FU->get_name();
   }

   void xload(const xml_element* Enode, const technology_nodeRef tnd, const ParameterConstRef Param) override;

   void xwrite(xml_element* rootnode, const technology_nodeRef tn, const ParameterConstRef Param) override;

   void print(std::ostream& os) const override;

   GET_TEC_KIND_TEXT(functional_unit_template)

   
   GET_TEC_KIND(functional_unit_template)
};

#endif