multicore.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
 
#include <string>
#include <set>
#include <vector>
#include <list>
#include <limits>
 
#include "config.h"
#include "tarch/compiler/CompilerSpecificSettings.h"
#include "tarch/multicore/orchestration/Strategy.h"
 
#if defined(SharedOMP) || defined(SharedTBB) || defined(SharedCPP) || defined(SharedSYCL)
#define SharedMemoryParallelisation
#endif
 
#pragma once
 
namespace tarch {
  namespace multicore {
     class Task;
 
     using TaskNumber = int;
 
     constexpr TaskNumber NoOutDependencies = -1;
 
     const std::set<TaskNumber> NoInDependencies = std::set<TaskNumber>();
 
     extern const std::string SpawnedTasksStatisticsIdentifier;
 
     extern const std::string SpawnedFusableTasksStatisticsIdentifier;
 
 
     extern const std::string BSPConcurrencyLevelStatisticsIdentifier;
 
     std::string toString( const std::set<TaskNumber>& taskNumbers );
 
    void initSmartMPI();
    void shutdownSmartMPI();
 
    void setOrchestration(tarch::multicore::orchestration::Strategy* realisation);
 
    tarch::multicore::orchestration::Strategy* swapOrchestration(tarch::multicore::orchestration::Strategy* realisation);
 
    tarch::multicore::orchestration::Strategy& getOrchestration();
 
    void spawnTask(
      Task*                        task,
      const std::set<TaskNumber>&  inDependencies = tarch::multicore::NoInDependencies,
      const TaskNumber&            taskNumber = tarch::multicore::NoOutDependencies
    );
 
    enum class TaskWaitType {
      Mixed,
      ExclusivelyFusedTasks,
      OnlyNativeTasks
    };
 
    void waitForTasks(const std::set<TaskNumber>& inDependencies, TaskWaitType taskWaitType = TaskWaitType::Mixed);
 
    void waitForTask(const int taskNumber, TaskWaitType taskWaitType = TaskWaitType::Mixed);
 
    void spawnAndWait(const std::vector<Task*>& tasks);
 
 
    namespace native {
      void spawnAndWaitAsTaskLoop(const std::vector<tarch::multicore::Task*>& tasks);
 
      void spawnTask(
        Task*                        task,
        const std::set<TaskNumber>&  inDependencies,
        const TaskNumber&            taskNumber
      );
 
      void waitForTasks(const std::set<TaskNumber>& inDependencies);
 
      void waitForAllTasks();
    } // namespace native
 
 
    void waitForAllTasks();
  } // namespace multicore
} // namespace tarch