parametric_list_based.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 PARAMETRIC_LIST_BASED_HPP
#define PARAMETRIC_LIST_BASED_HPP

#include <iosfwd>
#include <set>
#include <vector>

#include "Vertex.hpp"
#include "custom_map.hpp"
#include "custom_set.hpp"
#include "hash_helper.hpp"
#include "op_graph.hpp"
#include "refcount.hpp"
#include "rehashed_heap.hpp"
#include "scheduling.hpp"

REF_FORWARD_DECL(hls);
CONSTREF_FORWARD_DECL(OpGraph);
CONSTREF_FORWARD_DECL(Schedule);
REF_FORWARD_DECL(Schedule);
class graph;
class resource_ordering_functor;
REF_FORWARD_DECL(fu_binding);
class OpVertexSet;

#if HAVE_UNORDERED
using PriorityQueues = std::vector<rehashed_heap<int>>;
#else
struct PrioritySorter : public std::binary_function<vertex, vertex, bool>
{
   refcount<priority_data<int>> priority;

   const OpGraphConstRef op_graph;

   PrioritySorter(const refcount<priority_data<int>> priority, const OpGraphConstRef op_graph);

   bool operator()(const vertex x, const vertex y) const;
};

using PriorityQueues = std::vector<std::set<vertex, PrioritySorter>>;
#endif

enum class ParametricListBased_Metric
{
   DYNAMIC_MOBILITY = 0,
   STATIC_FIXED,
   STATIC_MOBILITY
};

class ParametricListBasedSpecialization : public HLSFlowStepSpecialization
{
 public:
   const ParametricListBased_Metric parametric_list_based_metric;

   explicit ParametricListBasedSpecialization(const ParametricListBased_Metric parametric_list_based_metric);

   std::string GetKindText() const override;

   std::string GetSignature() const override;
};

class parametric_list_based : public Scheduling
{
 private:
   static const double EPSILON;

   void compute_exec_stage_time(const unsigned int fu_type, double& stage_period, const ControlStep cs,
                                const OpGraphConstRef op_graph, vertex v, double& op_execution_time,
                                double& phi_extra_time, double current_starting_time, double setup_hold_time);

   const ParametricListBased_Metric parametric_list_based_metric;

   OpGraphConstRef flow_graph;

   OpGraphConstRef flow_graph_with_feedbacks;

   vertex2float starting_time;

   OpVertexMap<double> ending_time;

   double clock_cycle;

   CustomUnorderedMapUnstable<std::pair<vertex, unsigned int>, bool> is_complex;

   std::map<std::string, std::set<std::string>> reachable_proxy_functions;

   void compute_starting_ending_time_asap(
       const CustomUnorderedSet<vertex>& operations, const vertex v, const unsigned int fu_type, const ControlStep cs,
       double& current_starting_time, double& current_ending_time, double& stage_period, bool& cannot_be_chained,
       fu_bindingRef res_binding, const ScheduleConstRef schedule, double& phi_extra_time, double setup_hold_time,
       CustomMap<std::pair<unsigned int, unsigned int>, double>& local_connection_map);

   bool BB_update_resources_use(unsigned int& used_resources, const unsigned int fu_type) const;

   void add_to_priority_queues(PriorityQueues& priority_queue,
                               std::set<unsigned int, resource_ordering_functor>& ready_resources,
                               const vertex v) const;

   bool store_in_chaining_with_load_in(const CustomUnorderedSet<vertex>& operations, unsigned int current_vertex_cstep,
                                       vertex v);
   bool store_in_chaining_with_load_out(const CustomUnorderedSet<vertex>& operations, unsigned int current_vertex_cstep,
                                        vertex v);

   bool check_non_direct_operation_chaining(const CustomUnorderedSet<vertex>& operations, vertex current_v,
                                            unsigned int v_fu_type, const ControlStep cs,
                                            const ScheduleConstRef schedule, fu_bindingRef res_binding) const;

   bool check_direct_operation_chaining(const CustomUnorderedSet<vertex>& operations, vertex current_v,
                                        const ControlStep cs, const ScheduleConstRef schedule,
                                        fu_bindingRef res_binding) const;

   bool check_LOAD_chaining(const CustomUnorderedSet<vertex>& operations, vertex current_v, const ControlStep cs,
                            const ScheduleConstRef schedule) const;

   void CheckSchedulabilityConditions(
       const CustomUnorderedSet<vertex>& operations, const vertex& current_vertex, ControlStep current_cycle,
       double& current_starting_time, double& current_ending_time, double& current_stage_period,
       CustomMap<std::pair<unsigned int, unsigned int>, double>& local_connection_map,
       double current_cycle_starting_time, double current_cycle_ending_time, double setup_hold_time,
       double& phi_extra_time, double scheduling_mux_margins, bool unbounded, bool unbounded_Functions,
       bool LoadStoreOp, const std::set<std::string>& proxy_functions_used, bool cstep_has_RET_conflict,
       unsigned int fu_type, const vertex2obj<ControlStep>& current_ASAP, const fu_bindingRef res_binding,
       const ScheduleRef schedule, bool& predecessorsCond, bool& pipeliningCond, bool& cannotBeChained0,
       bool& chainingRetCond, bool& cannotBeChained1, bool& asyncCond, bool& cannotBeChained2, bool& cannotBeChained3,
       bool& MultiCond0, bool& MultiCond1, bool& LoadStoreFunctionConflict, bool& FunctionStoreconflict,
       bool& proxyFunCond, bool unbounded_RW, bool seeMulticycle);

   const CustomUnorderedSet<std::tuple<HLSFlowStep_Type, HLSFlowStepSpecializationConstRef, HLSFlowStep_Relationship>>
   ComputeHLSRelationships(const DesignFlowStep::RelationshipType relationship_type) const override;

   void compute_function_topological_order();

 public:
   parametric_list_based(const ParameterConstRef parameters, const HLS_managerRef HLSMgr, unsigned int _funId,
                         const DesignFlowManagerConstRef design_flow_manager,
                         const HLSFlowStepSpecializationConstRef hls_flow_step_specialization);

   ~parametric_list_based() override;

   DesignFlowStep_Status InternalExec() override;

   void exec(const OpVertexSet& operations, ControlStep current_cycle);

   void Initialize() override;
};
#endif