schedule.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 SCHEDULE_HPP
#define SCHEDULE_HPP

#include "graph.hpp"

#include <iosfwd>

#include "refcount.hpp"
#include "strong_typedef.hpp"

CONSTREF_FORWARD_DECL(AllocationInformation);
REF_FORWARD_DECL(behavioral_manager);
UINT_STRONG_TYPEDEF(ControlStep);
#ifdef NDEBUG
#define ControlStep(value) value
#endif
CONSTREF_FORWARD_DECL(FunctionBehavior);
enum class FunctionFrontendFlowStep_Movable;
class HLS_manager;
class OpVertexSet;
CONSTREF_FORWARD_DECL(HLS_manager);
CONSTREF_FORWARD_DECL(OpGraph);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(tree_manager);
CONSTREF_FORWARD_DECL(StateInfo);
CONSTREF_FORWARD_DECL(tree_manipulation);
REF_FORWARD_DECL(fu_binding);

#include "custom_map.hpp"
#include "custom_set.hpp"
#include "graph.hpp"
#include "hash_helper.hpp"
#include <iosfwd>

struct AbsControlStep : std::pair<unsigned int, ControlStep>
{
 public:
   static const ControlStep UNKNOWN;

   AbsControlStep();

   AbsControlStep(const unsigned int basic_block_index, const ControlStep control_step);

   bool operator<(const AbsControlStep& other) const;
};

class Schedule
{
 private:
   friend class parametric_list_based;
   friend class AllocationInformation;

   const Wrefcount<const HLS_manager> hls_manager;

   tree_managerRef TM;

   tree_manipulationConstRef tree_man;

   AllocationInformationConstRef allocation_information;

   const unsigned int function_index;

   ControlStep tot_csteps;

   CustomUnorderedMapUnstable<unsigned int, ControlStep> op_starting_cycle;

   CustomMap<ControlStep, CustomSet<unsigned int>> starting_cycles_to_ops;

   CustomUnorderedMapUnstable<unsigned int, ControlStep> op_ending_cycle;

   CustomMap<unsigned int, double> starting_times;

   CustomMap<unsigned int, double> ending_times;

   CustomMap<std::pair<unsigned int, unsigned int>, double> connection_times;

   CustomUnorderedMap<vertex, bool> spec;

   std::map<vertex, double> op_slack;

   OpGraphConstRef op_graph;

   const ParameterConstRef parameters;

   const int debug_level;

   double GetReadyTime(const unsigned int tree_node_index, const unsigned int basic_block_index) const;

   double GetBBEndingTime(const unsigned int basic_block_index) const;

 public:
   Schedule(const HLS_managerConstRef hls_manager, const unsigned int function_index, const OpGraphConstRef op_graph,
            const ParameterConstRef parameters);

   ~Schedule();

   void Initialize();

   ControlStep get_csteps() const
   {
      return tot_csteps;
   }

   void set_csteps(ControlStep cs)
   {
      tot_csteps = cs;
   }

   void print(fu_bindingRef Rfu = fu_bindingRef()) const;

   void WriteDot(const std::string& file_name, OpGraphConstRef sub_op_graph = OpGraphConstRef(),
                 OpVertexSet* opSet = nullptr) const;

   void set_spec(const CustomUnorderedMap<vertex, bool>& spec_map)
   {
      spec = spec_map;
   }

   CustomUnorderedMap<vertex, bool> get_spec() const
   {
      return spec;
   }

   void set_execution(const vertex& op, ControlStep c_step);

   void set_execution_end(const vertex& op, ControlStep c_step_end);

   bool is_scheduled(const vertex& op) const;

   bool is_scheduled(const unsigned int statement_index) const;

   AbsControlStep get_cstep(const vertex& op) const;

   AbsControlStep get_cstep(const unsigned int index) const;

   AbsControlStep get_cstep_end(const vertex& op) const;

   AbsControlStep get_cstep_end(const unsigned int statement_index) const;

   double GetEndingTime(const unsigned int operation) const;

   double GetStartingTime(const unsigned int operation) const;

   double get_fo_correction(unsigned int first_operation, unsigned int second_operation) const;

   unsigned int num_scheduled() const;

   void clear();

   void set_slack(vertex op, double v_slack)
   {
      op_slack[op] = v_slack;
   }

   double get_slack(vertex op) const
   {
      if(op_slack.find(op) != op_slack.end())
      {
         return op_slack.find(op)->second;
      }
      else
      {
         return 0.0;
      }
   }

   void UpdateTime(const unsigned int operation_index, bool update_cs = true);

   FunctionFrontendFlowStep_Movable CanBeMoved(const unsigned int statement_index,
                                               const unsigned int basic_block) const;

   bool EvaluateCondsMerging(const unsigned statement_index, const unsigned int first_condition,
                             const unsigned second_condition, unsigned int function_decl_nid) const;

   bool EvaluateMultiWayIfsMerging(const unsigned int first_statement_index, const unsigned int second_statement_index,
                                   unsigned int function_decl_nid) const;

   const std::string PrintTimingInformation(const unsigned int statement_index) const;

   CustomSet<unsigned int> ComputeCriticalPath(const StateInfoConstRef state_info) const;

   void AddConnectionTimes(unsigned int first_operation, unsigned int second_operation, const double value);
};
using ScheduleRef = refcount<Schedule>;
using ScheduleConstRef = refcount<const Schedule>;
#endif