flopoco_wrapper.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 FLOPOCOWRAPPER_HPP
#define FLOPOCOWRAPPER_HPP

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "dbgPrintHelper.hpp"
#include "exceptions.hpp"
#include "refcount.hpp"
#include "simple_indent.hpp"
#include "utility.hpp"

#include <string>
#include <vector>

#define FILE_EXT ".vhdl"
#define ENCODE_NAME(FU_name, FU_prec_in, FU_prec_out, pipe_parameter) \
   ((FU_name) + "_" + STR(FU_prec_in) + "_" + STR(FU_prec_out) + ((pipe_parameter) != "" ? "_" + (pipe_parameter) : ""))
#define FLOPOCO_ADDITIONAL_BITS 2
#define IN_WRAP_PREFIX "in_wrap_"
#define OUT_WRAP_PREFIX "out_wrap_"
#define WRAPPED_PREFIX "wrapped_"

REF_FORWARD_DECL(flopoco_wrapper);
namespace flopoco
{
   class Operator;
   class Target;
} // namespace flopoco

class flopoco_wrapper
{
 private:
#ifndef NDEBUG
   int debug_level;
#endif
   CustomUnorderedMap<std::string, flopoco::Operator*> FUs;
   CustomUnorderedSet<std::string> FU_files;
   CustomUnorderedMap<std::string, std::pair<unsigned int, unsigned int>> FU_to_prec;
   simple_indent PP;
   using port_type = enum { port_in, port_out, clk, rst };
   using component_type = enum { top, wrapped, in_wrap, out_wrap };
   using unit_type = enum {
      UT_ADD,
      UT_SUB,
      UT_MULT,
      UT_DIV,
      UT_FF_CONV,
      UT_ADDSUB,
      UT_UFIX2FP,
      UT_IFIX2FP,
      UT_FP2UFIX,
      UT_FP2IFIX,
      UT_EXP,
      UT_SQRT,
      UT_compare_expr,
      UT_LOG,
      UT_POW,
      UT_UNKNOWN
   };

   unit_type type;

   bool signed_p;

   std::vector<flopoco::Operator*> oplist;

   flopoco::Target* target;

   flopoco::Operator* get_FU(std::string FU_name_stored) const;

   const std::vector<std::string> get_ports(const std::string& FU_name_stored, unsigned int expected_ports,
                                            port_type type, bool check_ports = true) const;

   const std::string get_port(port_type type) const;

   int InternalWriteVHDL(const std::string& FU_name, const unsigned int FU_prec_in, const unsigned int FU_prec_out,
                         const std::string& filename, const std::string& pipe_parameter);

   void outputHeaderVHDL(const std::string& FU_name_stored, std::ostream& os) const;
   void outputWrapVHDL(const std::string& FU_name_stored, std::ostream& os, const std::string& pipe_parameter);
   void outputPortDeclaration(const std::string& FU_prefix, const std::string& FU_name_stored, std::ostream& os,
                              component_type type, const std::string& pipe_parameter);
   void outputSignals(const std::string& FU_name_stored, std::ostream& os);
   void outputPortMap(const std::string& FU_name_stored, std::ostream& os, const std::string& pipe_parameter);

 public:
   flopoco_wrapper(int _debug_level, const std::string& FU_target);

   ~flopoco_wrapper();

   // no copy constructor
   flopoco_wrapper(const flopoco_wrapper& inst) = delete;

   void add_FU(const std::string& FU_type, unsigned int FU_prec_in, unsigned int FU_prec_out,
               const std::string& FU_name, const std::string& pipe_parameter);

   unsigned int get_FUPipelineDepth(const std::string& FU_name, const unsigned int FU_prec_in,
                                    const unsigned int FU_prec_out, const std::string& pipe_parameter) const;

   int writeVHDL(const std::string& FU_name, const unsigned int FU_prec_in, const unsigned int FU_prec_out,
                 std::string pipe_parameter, std::string& filename);

   std::string writeVHDLcommon();

   const CustomUnorderedSet<std::string>& get_files_written()
   {
      return this->FU_files;
   }

   bool is_unit_written(const std::string& FU_name, const unsigned int FU_prec_in, const unsigned int FU_prec_out,
                        const std::string& pipe_parameter) const
   {
      return this->FU_files.find(ENCODE_NAME(FU_name, FU_prec_in, FU_prec_out, pipe_parameter) + FILE_EXT) !=
             this->FU_files.end();
   }

   const std::vector<std::string> get_in_ports(const std::string& FU_name, const unsigned int FU_prec_in,
                                               const unsigned int FU_prec_out, const unsigned int expected_ports,
                                               const std::string& pipe_parameter) const
   {
      return get_ports(ENCODE_NAME(WRAPPED_PREFIX + FU_name, FU_prec_in, FU_prec_out, pipe_parameter), expected_ports,
                       port_in);
   }
   const std::vector<std::string> get_out_ports(const std::string& FU_name, const unsigned int FU_prec_in,
                                                const unsigned int FU_prec_out, const unsigned int expected_ports,
                                                const std::string& pipe_parameter) const
   {
      return get_ports(ENCODE_NAME(WRAPPED_PREFIX + FU_name, FU_prec_in, FU_prec_out, pipe_parameter), expected_ports,
                       port_out);
   }

   static void DECODE_BITS(unsigned int FU_prec, unsigned int& n_mant, unsigned int& n_exp);

   static constexpr double DEFAULT_TARGET_FREQUENCY = 100.0;
};

using flopoco_wrapperRef = refcount<flopoco_wrapper>;

#endif /* FLOPOCOWRAPPER_H */