Parameter.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 PARAMETER_HPP
#define PARAMETER_HPP

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "exceptions.hpp"
#include "refcount.hpp"
#include "string_manipulation.hpp"

#include "config_HAVE_BAMBU_RESULTS_XML.hpp"
#include "config_HAVE_FROM_AADL_ASN_BUILT.hpp"
#include "config_HAVE_FROM_C_BUILT.hpp"
#include "config_HAVE_HLS_BUILT.hpp"
#include "config_HAVE_HOST_PROFILING_BUILT.hpp"
#include "config_HAVE_TECHNOLOGY_BUILT.hpp"
#include "config_HAVE_TO_C_BUILT.hpp"
#include "config_RELEASE.hpp"

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/for_each.hpp>

#include <climits>
#include <filesystem>
#include <list>
#include <string>
#include <vector>

class xml_element;
#if HAVE_HLS_BUILT
enum class CliqueCovering_Algorithm;
enum class Evaluation_Mode;
enum class HLSFlowStep_Type;
enum class MemoryAllocation_ChannelsType;
enum class MemoryAllocation_Policy;
enum class ParametricListBased_Metric;
enum class SDCScheduling_Algorithm;
#endif
#if HAVE_HOST_PROFILING_BUILT
enum class HostProfiling_Method;
#endif
#if HAVE_FROM_C_BUILT
enum class ActorGraphBackend_Type;
enum class CompilerWrapper_CompilerTarget;
#endif

#define PARAMETER_PARSED INT_MIN
#define PARAMETER_NOTPARSED INT_MAX

#define BAMBU_OPTIONS                                                                                                  \
   (chaining)(chaining_algorithm)(constraints_file)(context_switch)(controller_architecture)(datapath_architecture)(   \
       distram_threshold)(DSP_allocation_coefficient)(DSP_margin_combinational)(DSP_margin_pipelined)(DSP_fracturing)( \
       estimate_logic_and_connections)(evaluation)(evaluation_mode)(evaluation_objectives)(experimental_setup)(        \
       export_core)(export_core_mode)(fsm_encoding)(fu_binding_algorithm)(generate_testbench)(generate_vcd)(hls_flow)( \
       hls_div)(hls_fpdiv)(interface)(interface_type)(additional_top)(data_bus_bitsize)(addr_bus_bitsize)(             \
       libm_std_rounding)(liveness_algorithm)(scheduling_mux_margins)(scheduling_priority)(scheduling_algorithm)(      \
       simulate)(simulator)(simulation_output)(speculative)(pipelining)(storage_value_insertion_algorithm)(stg)(       \
       stg_algorithm)(register_allocation_algorithm)(register_grouping)(registered_inputs)(resp_model)(                \
       datapath_interconnection_algorithm)(insert_memory_profile)(top_file)(assert_debug)(                             \
       memory_allocation_algorithm)(memory_allocation_policy)(xml_memory_allocation)(rom_duplication)(base_address)(   \
       reset_type)(reset_level)(reg_init_value)(clock_period_resource_fraction)(channels_type)(channels_number)(       \
       memory_controller_type)(soft_float)(soft_fp)(fp_subnormal)(max_sim_cycles)(sparse_memory)(max_ulp)(             \
       skip_pipe_parameter)(gcc_serialize_memory_accesses)(unaligned_access)(aligned_access)(                          \
       backend_script_extensions)(backend_sdc_extensions)(VHDL_library)(bitvalue_ipa)(use_asynchronous_memories)(      \
       do_not_chain_memories)(bram_high_latency)(cdfc_module_binding_algorithm)(function_allocation_algorithm)(        \
       testbench_input_string)(testbench_input_file)(testbench_argv)(testbench_param_size)(testbench_map_mode)(        \
       weighted_clique_register_algorithm)(disable_function_proxy)(memory_mapped_top)(expose_globals)(connect_iob)(    \
       profiling_output)(disable_bounded_function)(discrepancy)(discrepancy_force)(discrepancy_hw)(                    \
       discrepancy_no_load_pointers)(discrepancy_only)(discrepancy_permissive_ptrs)(generate_taste_architecture)(      \
       initial_internal_address)(mem_delay_read)(mem_delay_write)(tb_queue_size)(memory_banks_number)(mixed_design)(   \
       no_parse_c_python)(num_accelerators)(technology_file)(tb_extra_gcc_options)(timing_violation_abort)(            \
       top_design_name)(serialize_output)(use_ALUs)(range_analysis_mode)(fp_format)(fp_format_propagate)(              \
       fp_format_interface)(fp_rounding_mode)(fp_exception_mode)(parallel_backend)(architecture_xml)(lattice_root)(    \
       lattice_settings)(lattice_pmi_def)(lattice_inc_dirs)(xilinx_root)(xilinx_settings)(xilinx_vivado_settings)(     \
       xilinx_glbl)(mentor_root)(mentor_modelsim_bin)(mentor_optimizer)(verilator)(verilator_timescale_override)(      \
       verilator_parallel)(altera_root)(quartus_settings)(quartus_13_settings)(quartus_13_64bit)(nanoxplore_root)(     \
       nanoxplore_settings)(nanoxplore_bypass)(shared_input_registers)(inline_functions)(constraints_functions)(       \
       axi_burst_type)

#define FRAMEWORK_OPTIONS                                                                                            \
   (benchmark_name)(cat_args)(find_max_transformations)(max_transformations)(compatible_compilers)(compute_size_of)( \
       configuration_name)(debug_level)(default_compiler)(dot_directory)(host_compiler)(ilp_max_time)(ilp_solver)(   \
       input_file)(input_format)(no_clean)(no_parse_files)(no_return_zero)(output_file)(output_level)(               \
       output_temporary_directory)(output_directory)(panda_parameter)(parse_pragma)(pretty_print)(print_dot)(        \
       profiling_method)(program_name)(read_parameter_xml)(revision)(seed)(test_multiple_non_deterministic_flows)(   \
       test_single_non_deterministic_flow)(top_functions_names)(xml_input_configuration)(xml_output_configuration)(  \
       write_parameter_xml)(ignore_parallelism)(ignore_mapping)(mapping)(sequence_length)(without_transformation)(   \
       blackbox)(input_libraries)(frontend_statistics)(exec_argv)(path)

#define COMPILER_OPTIONS                                                                                              \
   (gcc_config)(gcc_costs)(gcc_defines)(gcc_extra_options)(gcc_include_sysdir)(gcc_includes)(gcc_libraries)(          \
       gcc_library_directories)(gcc_openmp_simd)(compiler_opt_level)(gcc_m32_mx32)(gcc_optimizations)(                \
       gcc_optimization_set)(gcc_parameters)(gcc_plugindir)(gcc_read_xml)(gcc_standard)(gcc_undefines)(gcc_warnings)( \
       gcc_c)(gcc_E)(gcc_S)(gcc_write_xml)

#define SYNTHESIS_OPTIONS                                                                                            \
   (clock_period)(clock_name)(reset_name)(start_name)(done_name)(device_string)(synthesis_flow)(target_device_file)( \
       target_device_script)(top_component)(writer_language)

#define SPIDER_OPTIONS                                                                                              \
   (accuracy)(aggregated_features)(cross_validation)(experimental_setup_file)(latex_format_file)(max_bound)(        \
       maximum_error)(min_bound)(minimum_significance)(normalization_file)(normalization_sequences)(output_format)( \
       precision)(processing_element_type)(skip_rows)(surviving_benchmarks)

#define EUCALIPTUS_OPTIONS (component_name)

#define TREE_PANDA_COMPILER_OPTIONS (archive_files)(obj_files)(compress_archive)

#define OPTIONS_ENUM(r, data, elem) BOOST_PP_CAT(OPT_, elem),

// cppcheck-suppress syntaxError
enum enum_option
{
   BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, BAMBU_OPTIONS)
       BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, EUCALIPTUS_OPTIONS)
           BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, FRAMEWORK_OPTIONS)
               BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, COMPILER_OPTIONS)
                   BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, SPIDER_OPTIONS)
                       BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, SYNTHESIS_OPTIONS)
                           BOOST_PP_SEQ_FOR_EACH(OPTIONS_ENUM, BOOST_PP_EMPTY, TREE_PANDA_COMPILER_OPTIONS)
};

class OptionMap : public std::map<std::string, std::string>
{
 public:
   OptionMap() = default;

   ~OptionMap() = default;
};

#define DEFAULT_OPT_BASE 512
#define OPT_READ_PARAMETERS_XML DEFAULT_OPT_BASE
#define OPT_WRITE_PARAMETERS_XML (1 + OPT_READ_PARAMETERS_XML)
#define OPT_DEBUG_CLASSES (1 + OPT_WRITE_PARAMETERS_XML)
#define OPT_BENCHMARK_NAME (1 + OPT_DEBUG_CLASSES)
#define OPT_BENCHMARK_FAKE_PARAMETERS (1 + OPT_BENCHMARK_NAME)
#define INPUT_OPT_ERROR_ON_WARNING (1 + OPT_BENCHMARK_FAKE_PARAMETERS)
#define OPT_OUTPUT_TEMPORARY_DIRECTORY (1 + INPUT_OPT_ERROR_ON_WARNING)
#define INPUT_OPT_PRINT_DOT (1 + OPT_OUTPUT_TEMPORARY_DIRECTORY)
#define INPUT_OPT_SEED (1 + INPUT_OPT_PRINT_DOT)
#define INPUT_OPT_NO_CLEAN (1 + INPUT_OPT_SEED)
#define INPUT_OPT_CONFIGURATION_NAME (1 + INPUT_OPT_NO_CLEAN)
#define INPUT_OPT_MAX_TRANSFORMATIONS (1 + INPUT_OPT_CONFIGURATION_NAME)
#define INPUT_OPT_FIND_MAX_TRANSFORMATIONS (1 + INPUT_OPT_MAX_TRANSFORMATIONS)
#define INPUT_OPT_PANDA_PARAMETER (1 + INPUT_OPT_FIND_MAX_TRANSFORMATIONS)

#define COMMON_SHORT_OPTIONS_STRING "hVv:d:"

#define COMMON_LONG_OPTIONS                                                                                            \
   {"help", no_argument, nullptr, 'h'}, {"verbosity", required_argument, nullptr, 'v'},                                \
       {"version", no_argument, nullptr, 'V'},                                                                         \
       {"read-parameters-XML", required_argument, nullptr, OPT_READ_PARAMETERS_XML},                                   \
       {"write-parameters-XML", required_argument, nullptr, OPT_WRITE_PARAMETERS_XML},                                 \
       {"debug", required_argument, nullptr, 'd'}, {"debug-classes", required_argument, nullptr, OPT_DEBUG_CLASSES},   \
       {"no-clean", no_argument, nullptr, INPUT_OPT_NO_CLEAN},                                                         \
       {"benchmark-name", required_argument, nullptr, OPT_BENCHMARK_NAME},                                             \
       {"configuration-name", required_argument, nullptr, INPUT_OPT_CONFIGURATION_NAME},                               \
       {"benchmark-fake-parameters", required_argument, nullptr, OPT_BENCHMARK_FAKE_PARAMETERS},                       \
       {"output-temporary-directory", required_argument, nullptr, OPT_OUTPUT_TEMPORARY_DIRECTORY},                     \
       {"error-on-warning", no_argument, nullptr, INPUT_OPT_ERROR_ON_WARNING},                                         \
       {"print-dot", no_argument, nullptr, INPUT_OPT_PRINT_DOT}, {"seed", required_argument, nullptr, INPUT_OPT_SEED}, \
       {"max-transformations", required_argument, nullptr, INPUT_OPT_MAX_TRANSFORMATIONS},                             \
       {"find-max-transformations", no_argument, nullptr, INPUT_OPT_FIND_MAX_TRANSFORMATIONS},                         \
   {                                                                                                                   \
      "panda-parameter", required_argument, nullptr, INPUT_OPT_PANDA_PARAMETER                                         \
   }

#define INPUT_OPT_CUSTOM_OPTIONS 1024
#define INPUT_OPT_COMPUTE_SIZEOF (1 + INPUT_OPT_CUSTOM_OPTIONS)
#define INPUT_OPT_COMPILER (1 + INPUT_OPT_COMPUTE_SIZEOF)
#define INPUT_OPT_GCC_CONFIG (1 + INPUT_OPT_COMPILER)
#define INPUT_OPT_INCLUDE_SYSDIR (1 + INPUT_OPT_GCC_CONFIG)
#define INPUT_OPT_PARAM (1 + INPUT_OPT_INCLUDE_SYSDIR)
#define INPUT_OPT_READ_GCC_XML (1 + INPUT_OPT_PARAM)
#define INPUT_OPT_STD (1 + INPUT_OPT_READ_GCC_XML)
#define INPUT_OPT_USE_RAW (1 + INPUT_OPT_STD)
#define INPUT_OPT_WRITE_GCC_XML (1 + INPUT_OPT_USE_RAW)
#define LAST_GCC_OPT INPUT_OPT_WRITE_GCC_XML

#define GCC_SHORT_OPTIONS_STRING "cf:I:D:U:O::l:L:W:Em:g::"

#if !RELEASE
#define GCC_LONG_OPTIONS_RAW_XML                                             \
   {"use-raw", no_argument, nullptr, INPUT_OPT_USE_RAW},                     \
       {"read-GCC-XML", required_argument, nullptr, INPUT_OPT_READ_GCC_XML}, \
       {"write-GCC-XML", required_argument, nullptr, INPUT_OPT_WRITE_GCC_XML},
#else
#define GCC_LONG_OPTIONS_RAW_XML {"use-raw", no_argument, nullptr, INPUT_OPT_USE_RAW},
#endif
#define GCC_LONG_OPTIONS_COMPILER {"compiler", required_argument, nullptr, INPUT_OPT_COMPILER},

#define GCC_LONG_OPTIONS                                                               \
   GCC_LONG_OPTIONS_COMPILER{"std", required_argument, nullptr, INPUT_OPT_STD},        \
       GCC_LONG_OPTIONS_RAW_XML{"param", required_argument, nullptr, INPUT_OPT_PARAM}, \
       {"Include-sysdir", no_argument, nullptr, INPUT_OPT_INCLUDE_SYSDIR},             \
       {"gcc-config", no_argument, nullptr, INPUT_OPT_GCC_CONFIG},                     \
       {"compute-sizeof", no_argument, nullptr, INPUT_OPT_COMPUTE_SIZEOF},             \
   {                                                                                   \
      "extra-gcc-options", required_argument, nullptr, INPUT_OPT_CUSTOM_OPTIONS        \
   }

enum class Parameters_FileFormat
{
   FF_UNKNOWN = 0, 
#if HAVE_FROM_AADL_ASN_BUILT
   FF_AADL, 
   FF_ASN,  
#endif
#if HAVE_FROM_C_BUILT
   FF_C,            
   FF_OBJECTIVEC,   
   FF_CPP,          
   FF_OBJECTIVECPP, 
   FF_FORTRAN,      
   FF_LLVM,         
   FF_LLVM_CPP,     
#endif
   FF_CSV, 
#if HAVE_FROM_C_BUILT
   FF_RAW, 
#endif
   FF_TEX,     
   FF_TGFF,    
   FF_VERILOG, 
   FF_VHDL,    
   FF_XML,     
#if HAVE_BAMBU_RESULTS_XML
   FF_XML_BAMBU_RESULTS, 
#endif
#if HAVE_HLS_BUILT
   FF_XML_CON, 
#endif
   FF_XML_EXPERIMENTAL_SETUP, 
   FF_XML_SKIP_ROW,           
   FF_XML_SYM_SIM,            
#if HAVE_TECHNOLOGY_BUILT
   FF_XML_TARGET, 
   FF_XML_TEC,    
#endif
   FF_XML_TEX_TABLE, 
   FF_XML_WGT_GM,    
   FF_XML_WGT_SYM,   
};

class Parameter
{
 protected:
   int argc;

   char** const argv;

   OptionMap Options;

   CustomMap<std::string, std::string> panda_parameters;

   std::map<enum enum_option, std::string> enum_options;

   std::map<enum enum_option, std::string> option_name;

   CustomUnorderedSet<std::string> debug_classes;

   int debug_level;

   void load_xml_configuration_file_rec(const xml_element* node);

   bool ManageDefaultOptions(int next_option, char* optarg_param, bool& exit_success);

#if HAVE_FROM_C_BUILT

   bool ManageGccOptions(int next_option, char* optarg_param);
#endif

   void PrintGeneralOptionsUsage(std::ostream& os) const;

   void PrintOutputOptionsUsage(std::ostream& os) const;

#if HAVE_FROM_C_BUILT

   void PrintGccOptionsUsage(std::ostream& os) const;
#endif

   virtual void SetDefaults() = 0;

   void SetCommonDefaults();

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

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

 public:
   Parameter(const std::string& program_name, int argc, char** const argv, int debug_level = 0);

   Parameter(const Parameter& other);

   virtual ~Parameter();

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

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

   virtual int Exec() = 0;

   virtual void CheckParameters() = 0;

   friend std::ostream& operator<<(std::ostream& os, const Parameter& s)
   {
      s.print(os);
      return os;
   }

   template <typename G>
   void getOption(const std::string& name, G& variable) const
   {
      THROW_ASSERT(Options.find(name) != Options.end(), "Option \"" + name + "\" not stored");
      variable = boost::lexical_cast<G>(Options.find(name)->second);
   }

   template <typename G>
   void getOption(const char* name, G& variable) const
   {
      getOption(std::string(name), variable);
   }

   template <typename G>
   G getOption(const std::string& name) const
   {
      THROW_ASSERT(Options.find(name) != Options.end(), "Option \"" + name + "\" not stored");
      return boost::lexical_cast<G>(Options.find(name)->second);
   }

   template <typename G>
   G getOption(const char* name) const
   {
      return getOption<G>(std::string(name));
   }

   template <typename G>
   G getOption(const enum enum_option name) const
   {
      THROW_ASSERT(enum_options.find(name) != enum_options.end(),
                   "Option \"" + (option_name.find(name))->second + "\" not stored");
      return boost::lexical_cast<G>(enum_options.find(name)->second);
   }

   template <typename G>
   void setOption(const std::string& name, const G value)
   {
      Options[name] = STR(value);
   }

   template <typename G>
   void setOption(const char* name, const G value)
   {
      Options[std::string(name)] = STR(value);
   }

   template <typename G>
   void setOption(const enum enum_option name, const G value)
   {
      enum_options[name] = STR(value);
   }

   bool isOption(const std::string& name) const
   {
      return Options.find(name) != Options.end();
   }

   bool isOption(const char* name) const
   {
      return isOption(std::string(name));
   }

   bool isOption(const enum enum_option name) const
   {
      return enum_options.find(name) != enum_options.end();
   }

   bool removeOption(const enum enum_option name)
   {
      if(!isOption(name))
      {
         return false;
      }
      enum_options.erase(name);
      return true;
   }

   bool removeOption(const char* name)
   {
      return removeOption(std::string(name));
   }

   bool removeOption(const std::string& name)
   {
      if(!isOption(name))
      {
         return false;
      }
      Options.erase(name);
      return true;
   }

   int get_class_debug_level(const std::string& class_name, int debug_level = -1) const;

   int GetFunctionDebugLevel(const std::string& class_name, const std::string& function_name) const;

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

   void add_debug_class(const std::string& class_name);

   void PrintUsage(std::ostream& os) const;

   std::string PrintVersion() const;

   virtual void PrintFullHeader(std::ostream& os) const;

   void PrintBugReport(std::ostream& os) const;

   Parameters_FileFormat GetFileFormat(const std::filesystem::path& file, bool check_cml_root_node = false) const;

   template <typename G>
   G GetParameter(const std::string& name) const
   {
      THROW_ASSERT(panda_parameters.find(name) != panda_parameters.end(), "Parameter \"" + name + "\" not stored");
      return boost::lexical_cast<G>(panda_parameters.find(name)->second);
   }

   bool IsParameter(const std::string& name) const;

   const std::vector<std::string> CGetArgv() const;
};

template <>
CustomSet<std::string> Parameter::getOption(const enum enum_option name) const;

template <>
std::list<std::string> Parameter::getOption(const enum enum_option name) const;

template <>
std::vector<std::string> Parameter::getOption(const enum enum_option name) const;

#if HAVE_HOST_PROFILING_BUILT
template <>
HostProfiling_Method Parameter::getOption(const enum enum_option name) const;
#endif

template <>
Parameters_FileFormat Parameter::getOption(const enum enum_option name) const;

#if HAVE_FROM_C_BUILT
template <>
CompilerWrapper_CompilerTarget Parameter::getOption(const enum enum_option name) const;
#endif

#if HAVE_FROM_C_BUILT
enum class CompilerWrapper_OptimizationSet;
template <>
CompilerWrapper_OptimizationSet Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const CompilerWrapper_OptimizationSet value);
#endif

#if HAVE_TO_C_BUILT
template <>
ActorGraphBackend_Type Parameter::getOption(const enum enum_option name) const;
#endif

#if HAVE_HLS_BUILT
template <>
HLSFlowStep_Type Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const HLSFlowStep_Type hls_flow_step_type);

template <>
MemoryAllocation_Policy Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const MemoryAllocation_Policy memory_allocation_policy);

template <>
MemoryAllocation_ChannelsType Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name,
                          const MemoryAllocation_ChannelsType memory_allocation_channels_type);

template <>
CliqueCovering_Algorithm Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const CliqueCovering_Algorithm clique_covering_algorithm);

template <>
Evaluation_Mode Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const Evaluation_Mode evaluation_mode);

template <>
ParametricListBased_Metric Parameter::getOption(const enum enum_option name) const;
template <>
void Parameter::setOption(const enum enum_option name, const ParametricListBased_Metric parametric_list_based_metric);
#endif

using ParameterRef = refcount<Parameter>;
using ParameterConstRef = refcount<const Parameter>;

#endif