Strategy.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
#pragma once
 
namespace tarch {
  namespace multicore {
    namespace orchestration {
      class Strategy;
 
      Strategy* createDefaultStrategy();
 
      enum class FusionImplementation {
        DisableFusionAndMapOntoNativeTask,
 
        DisableFusionAndProcessImmediately,
 
        LazyEvaluation,
 
        TimedExecution,
 
        ProducerConsumerTaskSequence,
 
        EagerConsumerTasks
      };
    } // namespace orchestration
  }   // namespace multicore
} // namespace tarch
 
#include <string>
#include <utility>
#include <chrono>
 
 
 
class tarch::multicore::orchestration::Strategy {
public:
  enum class ExecutionPolicy {
    RunSerially,
    RunParallel
  };
 
  struct FuseInstruction {
    int device;
    int minTasks;
    int maxTasks;
    FuseInstruction(int device_, int minTasks_, int maxTasks_):
      device(device_),
      minTasks(minTasks_),
      maxTasks(maxTasks_)
      {}
 
    std::string toString() const {
      return "(#device=" + std::to_string(device) + ",min=" + std::to_string(minTasks)
             + ",max=" + std::to_string(maxTasks) + ")";
    }
  };
 
  virtual ~Strategy() = default;
 
  virtual void startBSPSection(int nestedParallelismLevel) = 0;
 
  virtual void endBSPSection(int nestedParallelismLevel) = 0;
  
  virtual void updateFuseStatistics(
    int    taskType,
    int    queueSize,
    double averageNumberOfReadyTasksPerProcessTaskExecution,
    double probabilityThatTaskIsCompleted
  ) = 0;
 
  static constexpr int EndOfBSPSection = -1;
 
  virtual FuseInstruction fuse(int taskType) = 0;
 
  virtual ExecutionPolicy paralleliseForkJoinSection(int nestedParallelismLevel, int numberOfTasks, int taskType) = 0;
 
  virtual FusionImplementation getFusionImplementation() const = 0;
};