pragma_manager.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 PRAGMA_MANAGER_HPP
#define PRAGMA_MANAGER_HPP

#include "config_HAVE_FROM_PRAGMA_BUILT.hpp"

#include "graph.hpp"

#include "custom_map.hpp"
#include "custom_set.hpp"

#include "dbgPrintHelper.hpp"
#include "refcount.hpp"

CONSTREF_FORWARD_DECL(application_manager);
REF_FORWARD_DECL(application_manager);
CONSTREF_FORWARD_DECL(Loop);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(PartitioningManager);
REF_FORWARD_DECL(TaskGraphManager);
REF_FORWARD_DECL(TaskGraphEstimator);
REF_FORWARD_DECL(tree_manager);

class pragma_manager
{
 protected:
   const application_managerRef application_manager;

   const tree_managerRef TM;

   CustomOrderedSet<std::string> BlackBoxFunctions;

   std::map<std::string, CustomUnorderedSet<std::string>> FunctionCallPragmas;

   std::map<std::string, std::list<std::string>> function_definition_pragmas;

   std::map<unsigned int, std::string> GenericPragmas;

   const ParameterConstRef param;

   int debug_level;

 public:
   enum OmpPragmaType
   {
      OMP_ATOMIC = 0,
      OMP_BARRIER,
      OMP_CRITICAL,
      OMP_DECLARE_SIMD,
      OMP_FOR,
      OMP_PARALLEL_FOR,
      OMP_PARALLEL_SECTIONS,
      OMP_PARALLEL,
      OMP_SECTIONS,
      OMP_SECTION,
      OMP_SIMD,
      OMP_TARGET,
      OMP_TASK,
      OMP_UNKNOWN
   };

   static const std::string omp_directive_keywords[OMP_UNKNOWN];

   pragma_manager(const application_managerRef application_manager, const ParameterConstRef param);

   virtual ~pragma_manager();

   bool checkCompliant() const;

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

   const std::list<std::string> GetFunctionDefinitionPragmas(const std::string& function_name) const;

   CustomUnorderedSet<std::string> getFunctionCallPragmas(const std::string& Name) const;

   void AddFunctionDefinitionPragmas(const std::string& name, const CustomUnorderedSet<std::string>& pragmas);

   void addFunctionCallPragmas(const std::string& Name, const CustomUnorderedSet<std::string>& Pragmas);

   unsigned int addBlackBoxPragma(const std::string& function_name, unsigned int function_id);

   void setGenericPragma(unsigned int number, const std::string& line);

   std::string getGenericPragma(unsigned int number) const;

   unsigned int AddOmpSimdPragma(const std::string& line, unsigned int function_id) const;

   bool CheckOmpFor(const application_managerConstRef app_man, const unsigned int function_index,
                    const vertex bb_operation_vertex) const;

   void CheckAddOmpFor(const unsigned int function_index, const vertex bb_operation_vertex,
                       const application_managerRef AppM);

   void CheckAddOmpSimd(const unsigned int function_index, const vertex bb_operation_vertex,
                        const application_managerRef AppM);

   std::string get_mapping(const std::string& function_name) const;

   static OmpPragmaType GetOmpPragmaType(const std::string& directive);

   CustomUnorderedMapUnstable<std::string, std::string> ExtractClauses(const std::string& clauses_list) const;
};

using pragma_managerConstRef = refcount<const pragma_manager>;
using pragma_managerRef = refcount<pragma_manager>;

#endif