memory.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 _MEMORY_HPP_
#define _MEMORY_HPP_

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "refcount.hpp"
#include <map>
#include <string>

REF_FORWARD_DECL(application_manager);
CONSTREF_FORWARD_DECL(tree_manager);
REF_FORWARD_DECL(memory);
REF_FORWARD_DECL(memory_symbol);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(structural_manager);
REF_FORWARD_DECL(structural_object);
class xml_element;

class memory
{
 private:
   const tree_managerConstRef TreeM;

   std::map<unsigned int, memory_symbolRef> external;

   std::map<unsigned int, std::map<unsigned int, memory_symbolRef>> internal;

   std::map<unsigned int, CustomOrderedSet<unsigned int>> internal_variable_proxy;

   CustomOrderedSet<unsigned int> proxied_variables;

   CustomOrderedSet<unsigned int> read_only_vars;

   std::map<unsigned int, memory_symbolRef> in_vars;

   std::map<unsigned int, unsigned long long int> rangesize;

   std::map<unsigned int, std::map<unsigned int, memory_symbolRef>> parameter;
   std::map<unsigned int, memory_symbolRef> params;
   std::map<unsigned int, memory_symbolRef> callSites;

   CustomOrderedSet<unsigned int> private_memories;

   std::map<unsigned int, unsigned int> same_data_size_accesses;

   std::map<unsigned int, CustomOrderedSet<unsigned int>> source_values;

   CustomOrderedSet<unsigned int> parm_decl_copied;

   CustomOrderedSet<unsigned int> parm_decl_stored;

   CustomOrderedSet<unsigned int> actual_parm_loaded;

   unsigned long long int next_base_address;

   unsigned long long int internal_base_address_start;

   unsigned long long int maximum_private_memory_size;

   unsigned long long int total_amount_of_private_memory;

   unsigned long long int total_amount_of_parameter_memory;

   unsigned long long int off_base_address;

   unsigned long long int next_off_base_address;

   unsigned long long bus_data_bitsize;

   unsigned long long bus_size_bitsize;

   unsigned long long bram_bitsize;

   unsigned int maxbram_bitsize;

   bool intern_shared_data;

   bool use_unknown_addresses;

   bool unaligned_accesses;

   bool all_pointers_resolved;

   bool implicit_memcpy;

   unsigned long long internal_base_address_alignment;

   unsigned long long external_base_address_alignment;

   const unsigned long long parameter_alignment;

   std::map<unsigned int, unsigned int> n_mem_operations_per_var;

   bool null_pointer_check;

   std::map<unsigned int, size_t> maximum_references;

   std::map<unsigned int, size_t> maximum_loads;

   CustomOrderedSet<unsigned int> need_bus;

   bool packed_vars;

   const unsigned int& bus_addr_bitsize;

   bool enable_hls_bit_value;

 public:
   memory(const tree_managerConstRef TreeM, unsigned long long int off_base_address, unsigned int max_bram,
          bool null_pointer_check, bool initial_internal_address_p, unsigned long long initial_internal_address,
          const unsigned int& _bus_addr_bitsize);

   virtual ~memory();

   static memoryRef create_memory(const ParameterConstRef _parameters, const tree_managerConstRef _TreeM,
                                  unsigned long long int _off_base_address, unsigned int max_bram,
                                  bool _null_pointer_check, bool initial_internal_address_p,
                                  unsigned int initial_internal_address, const unsigned int& _address_bitsize);

   std::map<unsigned int, memory_symbolRef> get_ext_memory_variables() const;

   void add_external_variable(unsigned int var, const std::string& var_name);

   void add_external_symbol(unsigned int var, const memory_symbolRef m_sym);

   void add_internal_variable(unsigned int funID_scope, unsigned int var, const std::string& var_name);

   void add_internal_variable_proxy(unsigned int funID_scope, unsigned int var);

   unsigned long long compute_next_base_address(unsigned long long address, unsigned int var,
                                                unsigned long long int alignment) const;

   const CustomOrderedSet<unsigned int>& get_proxied_internal_variables(unsigned int funID_scope) const;

   bool has_proxied_internal_variables(unsigned int funID_scope) const;

   bool is_a_proxied_variable(unsigned int var) const;

   void add_read_only_variable(unsigned var);

   bool is_read_only_variable(unsigned var) const;

   void add_internal_symbol(unsigned int funID_scope, unsigned int var, const memory_symbolRef m_sym);

   void add_private_memory(unsigned int var);

   void set_sds_var(unsigned int var, bool value);

   void add_source_value(unsigned int var, unsigned int value);

   const CustomOrderedSet<unsigned int>& get_source_values(unsigned int var)
   {
      return source_values[var];
   }

   void add_parameter(unsigned int funID_scope, unsigned int var, const std::string& var_name, bool is_last);

   void add_parameter_symbol(unsigned int funID_scope, unsigned int var, const memory_symbolRef m_sym);

   bool is_internal_variable(unsigned int funID_scope, unsigned int var) const;

   bool is_external_variable(unsigned int var) const;

   bool is_private_memory(unsigned int var) const;

   bool is_sds_var(unsigned int var) const;

   bool has_sds_var(unsigned int var) const;

   bool is_parameter(unsigned int funID_scope, unsigned int var) const;

   const std::map<unsigned int, memory_symbolRef> get_callSites() const
   {
      return callSites;
   }

   unsigned long long get_callSite_base_address(unsigned int var) const;

   unsigned long long int get_internal_base_address(unsigned int var) const;

   unsigned long long get_external_base_address(unsigned int var) const;

   unsigned long long int get_parameter_base_address(unsigned int funId, unsigned int var) const;

   unsigned long long int get_base_address(unsigned int var, unsigned int funId) const;

   unsigned long long get_first_address(unsigned int funId) const;

   unsigned long long get_last_address(unsigned int funId, const application_managerRef AppM) const;

   memory_symbolRef get_symbol(unsigned int var, unsigned int funId) const;

   unsigned long long get_rangesize(unsigned int var) const;

   bool has_callSite_base_address(unsigned int var) const;

   bool has_internal_base_address(unsigned int var) const;

   unsigned int get_n_mem_operations(unsigned int var) const
   {
      return n_mem_operations_per_var.find(var)->second;
   }

   void increment_n_mem_operations(unsigned int var)
   {
      if(n_mem_operations_per_var.find(var) == n_mem_operations_per_var.end())
      {
         n_mem_operations_per_var[var] = 1;
      }
      else
      {
         ++n_mem_operations_per_var[var];
      }
   }

   bool has_external_base_address(unsigned int var) const;

   bool has_parameter_base_address(unsigned int var, unsigned int funId) const;

   bool has_base_address(unsigned int var) const;

   bool is_parm_decl_copied(unsigned int var) const;

   void add_parm_decl_copied(unsigned int var);

   bool is_parm_decl_stored(unsigned int var) const;

   void add_parm_decl_stored(unsigned int var);

   bool is_actual_parm_loaded(unsigned int var) const;

   void add_actual_parm_loaded(unsigned int var);

   std::map<unsigned int, memory_symbolRef> get_function_vars(unsigned int funID_scope) const;

   std::map<unsigned int, memory_symbolRef> get_function_parameters(unsigned int funID_scope) const;

   unsigned long long get_memory_address() const;

   void reserve_space(unsigned long long space);

   void reserve_internal_space(unsigned long long int space);

   unsigned long long get_allocated_space() const;

   unsigned long long get_allocated_parameters_memory() const;

   unsigned long long int get_allocated_internal_memory() const;

   unsigned long long int get_next_internal_base_address() const;

   unsigned long long int get_max_address() const;

   void set_bus_data_bitsize(unsigned long long bitsize)
   {
      bus_data_bitsize = bitsize;
   }

   unsigned long long get_bus_data_bitsize() const
   {
      return bus_data_bitsize;
   }

   void set_bus_size_bitsize(unsigned long long bitsize)
   {
      bus_size_bitsize = bitsize;
   }

   unsigned long long get_bus_size_bitsize() const
   {
      return bus_size_bitsize;
   }

   void set_bram_bitsize(unsigned long long bitsize)
   {
      bram_bitsize = bitsize;
   }

   unsigned long long get_bram_bitsize() const
   {
      return bram_bitsize;
   }

   void set_maxbram_bitsize(unsigned int bitsize)
   {
      maxbram_bitsize = bitsize;
   }

   unsigned int get_maxbram_bitsize() const
   {
      return maxbram_bitsize;
   }

   void set_intern_shared_data(bool has_accesses)
   {
      intern_shared_data = has_accesses;
   }

   bool has_intern_shared_data() const
   {
      return intern_shared_data;
   }

   void set_maximum_references(unsigned int var, size_t n_refs)
   {
      maximum_references[var] = n_refs;
   }

   size_t get_maximum_references(unsigned int var) const
   {
      return maximum_references.find(var) != maximum_references.end() ? maximum_references.find(var)->second : 0;
   }

   void set_maximum_loads(unsigned int var, size_t n_refs)
   {
      maximum_loads[var] = n_refs;
   }

   size_t get_maximum_loads(unsigned int var) const
   {
      return maximum_loads.find(var) != maximum_loads.end() ? maximum_loads.find(var)->second : 0;
   }

   void add_need_bus(unsigned int var)
   {
      need_bus.insert(var);
   }

   bool does_need_addr(unsigned int var) const
   {
      return need_bus.find(var) != need_bus.end();
   }
   void set_use_unknown_addresses(bool accesses)
   {
      use_unknown_addresses = accesses;
   }

   bool has_unknown_addresses() const
   {
      return use_unknown_addresses;
   }
   void set_unaligned_accesses(bool accesses)
   {
      unaligned_accesses = accesses;
   }

   bool has_unaligned_accesses() const
   {
      return unaligned_accesses;
   }

   void set_all_pointers_resolved(bool resolved)
   {
      all_pointers_resolved = resolved;
   }

   bool has_all_pointers_resolved() const
   {
      return all_pointers_resolved;
   }

   void set_packed_vars(bool packed)
   {
      packed_vars = packed_vars || packed;
   }

   bool has_packed_vars() const
   {
      return packed_vars;
   }

   void set_implicit_memcpy(bool cond)
   {
      implicit_memcpy = cond;
   }

   bool has_implicit_memcpy() const
   {
      return implicit_memcpy;
   }

   unsigned long long get_internal_base_address_alignment() const
   {
      return internal_base_address_alignment;
   }

   unsigned long long get_parameter_alignment() const
   {
      return parameter_alignment;
   }

   void set_internal_base_address_alignment(unsigned long long _internal_base_address_alignment);

   static void propagate_memory_parameters(const structural_objectRef src, const structural_managerRef tgt);

   static void add_memory_parameter(const structural_managerRef SM, const std::string& name, const std::string& value);

   void xwrite(xml_element* node);

   void xwrite2(xml_element* node);

   void xwrite(const std::string& filename);

   unsigned int count_non_private_internal_symbols() const;

   bool notEQ(refcount<memory> ref) const;

   void set_enable_hls_bit_value(bool value)
   {
      enable_hls_bit_value = value;
   }

   bool get_enable_hls_bit_value()
   {
      return enable_hls_bit_value;
   }
};
using memoryRef = refcount<memory>;

#endif