ASLAP.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 ASLAP_HPP
#define ASLAP_HPP

#include <deque>
#include <iosfwd>

#include "graph.hpp"
#include "refcount.hpp"

#include "schedule.hpp"

CONSTREF_FORWARD_DECL(AllocationInformation);
REF_FORWARD_DECL(HLS_constraints);
CONSTREF_FORWARD_DECL(Schedule);
REF_FORWARD_DECL(Schedule);
REF_FORWARD_DECL(hls);
CONSTREF_FORWARD_DECL(HLS_manager);
CONSTREF_FORWARD_DECL(OpGraph);
CONSTREF_FORWARD_DECL(Parameter);
class graph;
class OpVertexSet;
enum class Allocation_MinMax;

class ASLAP
{
 private:
   ScheduleRef ASAP;

   ScheduleRef ALAP;

   ControlStep min_tot_csteps;

   ControlStep max_tot_csteps;

   OpGraphConstRef beh_graph;

   std::deque<vertex> levels;

   bool has_branching_blocks;

   const AllocationInformationConstRef allocation_information;

   bool speculation;

   const double clock_period;

   int debug_level;

   unsigned int ctrl_step_multiplier;

   const CustomUnorderedSet<vertex>& operations;
   void add_constraints_to_ALAP();

   void add_constraints_to_ASAP();

   void compute_ALAP_fast(bool* feasible = nullptr);

   void compute_ALAP_LB();

   void compute_ALAP_worst_case();

   ControlStep get_min_csteps() const
   {
      return min_tot_csteps;
   }

   ControlStep get_max_csteps() const
   {
      return max_tot_csteps;
   }

   ControlStep GetCycleLatency(const vertex operation, Allocation_MinMax minmax) const;

 public:
   ASLAP(const HLS_managerConstRef hls_manager, const hlsRef HLS, const bool speculation,
         const CustomUnorderedSet<vertex>& operations, const ParameterConstRef parameters,
         unsigned int _ctrl_step_multiplier);

   ~ASLAP() = default;

   enum ALAP_method
   {
      ALAP_fast,
      ALAP_worst_case,
      ALAP_with_upper,
      ALAP_with_upper_minus_one,
      ALAP_with_partial_scheduling
   };

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

   void compute_ASAP(const ScheduleConstRef partial_schedule = ScheduleConstRef());

   const ScheduleConstRef CGetASAP() const
   {
      return ASAP;
   }

   ScheduleRef GetASAP()
   {
      return ASAP;
   }

   void compute_ALAP(ALAP_method met, const ScheduleConstRef partial_schedule = ScheduleConstRef(),
                     bool* feasible = nullptr, const ControlStep = ControlStep(0u));

   const ScheduleConstRef CGetALAP() const
   {
      return ALAP;
   }

   const ScheduleRef GetALAP()
   {
      return ALAP;
   }

   void update_ALAP(const ControlStep maxc, bool* feasible = nullptr,
                    const ScheduleConstRef partial_schedule = ScheduleConstRef());

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

   const OpGraphConstRef CGetOpGraph() const;
};

using ASLAPRef = refcount<ASLAP>;

#endif