Task.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
 
#include <functional>
#include <limits>
#include <list>
#include <set>
#include <string>
#include <tuple>
#include <vector>
 
#include "multicore.h"
 
 
namespace tarch {
  namespace multicore {
    class Task {
    protected:
      const int _taskType;
      int       _priority;
 
    public:
      static constexpr int DefaultPriority = 1024;
      static constexpr int Host            = -1;
      static constexpr int DontFuse        = -1;
 
      Task(int taskType, int priority);
 
      virtual ~Task() {}
 
      int getTaskType() const;
      int getPriority() const;
 
      void setPriority(int priority);
 
      virtual bool canFuse() const;
 
      virtual void run() = 0;
 
      virtual void fuse(const std::vector<Task*>& otherTasks, int targetDevice = Host);
 
      virtual std::string toString() const;
    };
 
    class TaskComparison {
    public:
      bool operator()(const Task& lhs, const Task& rhs) const;
      bool operator()(Task* lhs, Task* rhs) const;
    };
 
    class TaskWithCopyOfFunctor: public Task {
    private:
      std::function<void()> _taskFunctor;
 
      #if PeanoDebug>0
      std::string           _taskDescription;
      #endif
 
    public:
      TaskWithCopyOfFunctor()                             = delete;
      TaskWithCopyOfFunctor(const TaskWithCopyOfFunctor&) = delete;
 
      TaskWithCopyOfFunctor(
        int taskType,
        int priority,
        const std::function<void()>& taskFunctor
        #if PeanoDebug>0
        , const std::string&           taskDescription = ""
        #endif
      );
 
      virtual void run() override;
 
      virtual std::string toString() const override;
    };
 
    class EmptyTask: public Task {
      public:
        EmptyTask() = delete;
 
        EmptyTask(int priority);
 
        virtual void run() override;
 
        virtual std::string toString() const override;
    };
 
    class TaskWithoutCopyOfFunctor: public Task {
    private:
      std::function<void()>& _taskFunctor;
 
    public:
      TaskWithoutCopyOfFunctor()                                = delete;
      TaskWithoutCopyOfFunctor(const TaskWithoutCopyOfFunctor&) = delete;
 
      TaskWithoutCopyOfFunctor(int taskType, int priority, std::function<void()>& taskFunctor);
 
      virtual void run() override;
    };
  }   // namespace multicore
} // namespace tarch
 
bool operator<(const tarch::multicore::Task& lhs, const tarch::multicore::Task& rhs);