FusableTasksQueue.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 "tarch/logging/Log.h"
#include "tarch/multicore/multicore.h"
#include "tarch/multicore/Task.h"
#include "tarch/multicore/taskfusion/taskfusion.h"
 
 
#include <map>
#include <unordered_set>
 
 
namespace tarch {
  namespace multicore {
    namespace taskfusion {
      class FusableTasksQueue;
      class ProcessOneReadyTask;
      class ProcessSetOfReadyTasks;
    }
  }
}
 
 
class tarch::multicore::taskfusion::FusableTasksQueue {
  public:
    static constexpr int AnyTask = -1;
 
    static const std::string SizeOfFusableTaskQueueStatisticsIdentifier;
 
    FusableTasksQueue(int type_);
    ~FusableTasksQueue()                        = default;
    FusableTasksQueue(const FusableTasksQueue&) = delete;
 
    void insertReadyTask( Task* task, int taskNumber );
 
    void drainReadyTasks();
 
    TaskNumber getFirstReadyTaskNumber();
 
    std::pair< TaskNumber, Task* > extractFirstReadyTask( TaskNumber handlingTask );
 
    Task*  extractReadyTask( TaskNumber taskNumber, TaskNumber handlingTask );
 
    void runningTaskFinished( TaskNumber taskNumber );
 
    TaskNumber getTaskHandlingRunningTask( TaskNumber taskNumber );
 
    void updateTaskFusionProbabilities( bool triggerFusion );
 
    std::pair< TaskNumber, Task* > extractReadyTask( TaskNumber handlingTask );
 
    static constexpr bool UseTryLockAndReturnTrueIfLockFailed = true;
    static constexpr bool LockQueueAndReturnReliableResult    = false;
 
    bool isTaskReadyOrRunning(
      int                 taskNumber,
      bool                tryLock
    );
 
    bool isTaskReady(
      int                 taskNumber,
      bool                tryLock
    );
 
    int getType() const;
 
    int getNumberOfReadyTasks();
  private:
    static tarch::logging::Log                 _log;
 
    const int                                  _type;
 
    using ReadyTasks           = std::map< int, tarch::multicore::Task* >;
 
    using RunningTasks         = std::map< int, int >;
 
    ReadyTasks                                 _readyTasks;
 
    RunningTasks                               _runningTasks;
 
    tarch::multicore::BooleanSemaphore         _readyTasksSemaphore;
    tarch::multicore::BooleanSemaphore         _runningTasksSemaphore;
 
    tarch::multicore::BooleanSemaphore         _statisticsSemaphore;
    tarch::timing::GlidingAverageMeasurement   _numberOfReadyTasksPerProcessTaskExecution;
    tarch::timing::GlidingAverageMeasurement   _probabilityThatTaskIsCompleted;
};