technology_manager.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_MANAGER_HPP
#define TECHNOLOGY_MANAGER_HPP

#include "config_HAVE_CIRCUIT_BUILT.hpp"

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "refcount.hpp"
#include "strong_typedef.hpp"

#include <ostream>
#include <string>
#include <vector>

#define DESIGN std::string("design")
#define WORK_LIBRARY std::string("work")
#define OPENMP_LIBRARY std::string("OpenMP_library")
#define PROXY_LIBRARY std::string("proxy_library")
#define INTERFACE_LIBRARY std::string("interface_library")
#define LIBRARY_STD std::string("STD")
#define LIBRARY_STD_FU std::string("STD_FU")
#define CG_LIBRARY std::string("CG")
#define LIBRARY_PC std::string("STD_PC")
#define LIBRARY_STD_DATAFLOW std::string("STD_DATAFLOW")

CONSTREF_FORWARD_DECL(Parameter);
CONSTREF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(library_manager);
using fileIO_istreamRef = refcount<std::istream>;
REF_FORWARD_DECL(structural_manager);
REF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(technology_node);
REF_FORWARD_DECL(simple_indent);
class xml_element;
class allocation;
class mixed_hls;
struct TimeStamp;
UINT_STRONG_TYPEDEF_FORWARD_DECL(ControlStep);
class functional_unit;


class technology_manager
{
 public:
   const static unsigned int XML;

   using library_map_type = CustomUnorderedMap<std::string, library_managerRef>;

 private:
   const ParameterConstRef Param;

   int debug_level;

   library_map_type library_map;

   std::vector<std::string> libraries;

   CustomSet<std::string> builtins;

   CustomUnorderedMap<std::string, technology_nodeRef> function_fu;

   const functional_unit* CGetSetupHoldFU() const;

 public:
   explicit technology_manager(const ParameterConstRef Param);

   ~technology_manager();

 private:
   friend class allocation;

 public:
   void add(const technology_nodeRef curr, const std::string& Library);

#if HAVE_CIRCUIT_BUILT

   void add_resource(const std::string& Library, const std::string& fu_name,
                     const structural_managerRef CM = structural_managerRef(), const bool is_builtin = false);
#endif

   technology_nodeRef add_operation(const std::string& Library, const std::string& fu_name,
                                    const std::string& operation_name);



   const std::vector<std::string>& get_library_list() const
   {
      return libraries;
   }

   bool can_implement(const std::string& fu_name, const std::string& op_name, const std::string& Library) const;

   technology_nodeRef get_fu(const std::string& fu_name, const std::string& Library) const;

   technology_nodeRef get_fu(const std::string& fu_name, std::string* Library = nullptr) const;

   std::string get_library(const std::string& Name) const;

   void erase_library(const std::string& Name);

   bool is_library_manager(const std::string& Name) const;

   library_managerRef get_library_manager(const std::string& Name) const;

   ControlStep get_initiation_time(const std::string& fu_name, const std::string& op_name,
                                   const std::string& Library) const;

   double get_execution_time(const std::string& fu_name, const std::string& op_name, const std::string& Library) const;

   double get_area(const std::string& fu_name, const std::string& Library) const;

   bool IsBuiltin(const std::string& component_name) const;


   void xload(const xml_element* node);

   void xwrite(xml_element* rootnode, const CustomOrderedSet<std::string>& libraries = CustomOrderedSet<std::string>());


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

   double CGetSetupHoldTime() const;

   TimeStamp CGetSetupHoldTimeStamp() const;

   technology_nodeRef GetFunctionFU(const std::string& fname) const;
};

using technology_managerRef = refcount<technology_manager>;

#endif