Beatmup::CustomPipeline::Impl Class Reference

Inheritance diagram for Beatmup::CustomPipeline::Impl:

Public Member Functions
	Impl ()
virtual	~Impl ()
TaskHolder &	getCurrentTask ()
	Returns currently pointed task. More...
const TaskHolder &	getCurrentTask () const
void	runTask ()
	Executes the pointed task. More...
void	goToNextTask ()
	Goes to the next task in the list. More...
bool	allTasksDone () const
	Returns true if all tasks are done. More...
bool	allTasksAborted () const
	Returns true if the current session is aborted. More...
int	getTaskCount ()
TaskHolder *	getTask (int index)
int	getTaskIndex (const TaskHolder *holder)
void	addTask (TaskHolder *taskHolder)
void	insertTask (TaskHolder *newbie, const TaskHolder *before)
bool	removeTask (const TaskHolder *target)
void	measure ()
	Determining execution mode (GPU or CPU) and thread count for each task. More...
AbstractTask::TaskDeviceRequirement	getUsedDevices () const
ThreadIndex	getMaxThreads () const
void	beforeProcessing (GraphicPipeline *gpu)
bool	process (GraphicPipeline *gpu, TaskThread &thread, CustomPipeline &pipeline)
	Processing entry point. More...

Private Attributes
std::vector< TaskHolder * >::iterator	currentTask
std::vector< TaskHolder * >	tasks
	the list of tasks More...
std::mutex	tasksAccess
	task list access control More...
GraphicPipeline *	gpu
TaskThread *	thread
AbstractTask::TaskDeviceRequirement	executionMode
ThreadIndex	maxThreadCount
bool	measured
	if true, the execution mode and the thread count are determined More...
bool	abort
	if true, one of threads executing the current task caused its aborting More...

Detailed Description

Definition at line 26 of file custom_pipeline.cpp.

Constructor & Destructor Documentation

Impl()

Beatmup::CustomPipeline::Impl::Impl ( )

inline

Definition at line 39 of file custom_pipeline.cpp.

          :
        measured(false)
    {}

~Impl()

virtual Beatmup::CustomPipeline::Impl::~Impl ( )

inlinevirtual

Definition at line 43 of file custom_pipeline.cpp.

                    {
        // destroying taskholders
        for (auto task : tasks)
            delete task;
    }

Member Function Documentation

getCurrentTask() [1/2]

TaskHolder& Beatmup::CustomPipeline::Impl::getCurrentTask ( )

inlinevirtual

Returns currently pointed task.

Implements Beatmup::TaskRouter.

Definition at line 49 of file custom_pipeline.cpp.

                                 {
        return **currentTask;
    }

getCurrentTask() [2/2]

const TaskHolder& Beatmup::CustomPipeline::Impl::getCurrentTask ( ) const

inlinevirtual

Implements Beatmup::TaskRouter.

Definition at line 53 of file custom_pipeline.cpp.

                                             {
        return **currentTask;
    }

runTask()

void Beatmup::CustomPipeline::Impl::runTask ( )

inlinevirtual

Executes the pointed task.

Implements Beatmup::TaskRouter.

Definition at line 57 of file custom_pipeline.cpp.

                   {
        auto startTime = std::chrono::high_resolution_clock::now();
        TaskHolder& task = **currentTask;
        task.getTask().beforeProcessing(
            task.threadCount,
            task.executionMode != AbstractTask::TaskDeviceRequirement::CPU_ONLY && gpu ? ProcessingTarget::GPU : ProcessingTarget::CPU,
            gpu
        );
 
        // wait for other workers
        thread->synchronize();
 
        // perform the task
        bool result;
        if (task.executionMode != AbstractTask::TaskDeviceRequirement::CPU_ONLY && gpu)
            result = task.getTask().processOnGPU(*gpu, *thread);
        else
            result = task.getTask().process(*thread);
 
        if (!result)
            abort = true;
 
        // wait for other workers
        thread->synchronize();
 
        task.getTask().afterProcessing(
            task.threadCount,
            task.executionMode != AbstractTask::TaskDeviceRequirement::CPU_ONLY && gpu ? gpu : nullptr,
            !abort
        );
 
        auto endTime = std::chrono::high_resolution_clock::now();
        task.time = std::chrono::duration<float, std::milli>(endTime - startTime).count();
    }

goToNextTask()

void Beatmup::CustomPipeline::Impl::goToNextTask ( )

inlinevirtual

Goes to the next task in the list.

Implements Beatmup::TaskRouter.

Definition at line 92 of file custom_pipeline.cpp.

                        {
        currentTask++;
    }

allTasksDone()

bool Beatmup::CustomPipeline::Impl::allTasksDone ( ) const

inlinevirtual

Returns true if all tasks are done.

Implements Beatmup::TaskRouter.

Definition at line 96 of file custom_pipeline.cpp.

                              {
        return currentTask >= tasks.end();
    }

allTasksAborted()

bool Beatmup::CustomPipeline::Impl::allTasksAborted ( ) const

inlinevirtual

Returns true if the current session is aborted.

Implements Beatmup::TaskRouter.

Definition at line 100 of file custom_pipeline.cpp.

                                 {
        return abort && thread->isTaskAborted();
    }

getTaskCount()

int Beatmup::CustomPipeline::Impl::getTaskCount ( )

inline

Definition at line 105 of file custom_pipeline.cpp.

                       {
        std::lock_guard<std::mutex> lock(tasksAccess);
        return (int) tasks.size();
    }

getTask()

TaskHolder* Beatmup::CustomPipeline::Impl::getTask ( int  index )

inline

Definition at line 110 of file custom_pipeline.cpp.

                                   {
        std::lock_guard<std::mutex> lock(tasksAccess);
        BEATMUP_ASSERT_DEBUG(0 <= index && index < tasks.size());
        return tasks[index];
    }

getTaskIndex()

int Beatmup::CustomPipeline::Impl::getTaskIndex ( const TaskHolder *  holder )

inline

Definition at line 116 of file custom_pipeline.cpp.

                                               {
        std::lock_guard<std::mutex> lock(tasksAccess);
        const auto& it = std::find(tasks.cbegin(), tasks.cend(), holder);
        if (it == tasks.cend())
            return -1;
        return (int) (it - tasks.cbegin());
    }

addTask()

void Beatmup::CustomPipeline::Impl::addTask ( TaskHolder *  taskHolder )

inline

Definition at line 124 of file custom_pipeline.cpp.

                                         {
        std::lock_guard<std::mutex> lock(tasksAccess);
        measured = false;
        tasks.push_back(taskHolder);
    }

insertTask()

void Beatmup::CustomPipeline::Impl::insertTask ( TaskHolder *  newbie, const TaskHolder *  before  )

inline

Definition at line 130 of file custom_pipeline.cpp.

                                                                  {
        std::lock_guard<std::mutex> lock(tasksAccess);
        const auto& nextHolder = std::find(tasks.cbegin(), tasks.cend(), before);
        if (nextHolder == tasks.cend())
            throw RuntimeError("Reference task holder is not found in the task list");
        measured = false;
        tasks.insert(nextHolder , newbie);
    }

removeTask()

bool Beatmup::CustomPipeline::Impl::removeTask ( const TaskHolder *  target )

inline

Definition at line 139 of file custom_pipeline.cpp.

                                              {
        std::lock_guard<std::mutex> lock(tasksAccess);
        const auto& pointer = std::find(tasks.cbegin(), tasks.cend(), target);
        if (pointer == tasks.cend())
            return false;
        delete *pointer;
        tasks.erase(pointer);
        return true;
    }

measure()

void Beatmup::CustomPipeline::Impl::measure ( )

inline

Determining execution mode (GPU or CPU) and thread count for each task.

Definition at line 152 of file custom_pipeline.cpp.

                   {
        std::lock_guard<std::mutex> lock(tasksAccess);
        executionMode = TaskDeviceRequirement::CPU_ONLY;
        maxThreadCount = 0;
        for (auto& it : tasks) {
            switch (it->executionMode = it->getTask().getUsedDevices()) {
                case TaskDeviceRequirement::GPU_ONLY:
                    executionMode = TaskDeviceRequirement::GPU_ONLY;
                    break;
                case TaskDeviceRequirement::GPU_OR_CPU:
                    if (executionMode == TaskDeviceRequirement::CPU_ONLY)
                        executionMode = TaskDeviceRequirement::GPU_OR_CPU;
                    break;
                default:
                    break;
            }
            it->threadCount = it->getTask().getMaxThreads();
            maxThreadCount = std::max(maxThreadCount, it->threadCount);
        }
        measured = true;
    }

getUsedDevices()

AbstractTask::TaskDeviceRequirement Beatmup::CustomPipeline::Impl::getUsedDevices ( ) const

inline

Definition at line 174 of file custom_pipeline.cpp.

                                                             {
        if (!measured)
            throw PipelineNotReady("Pipeline not measured; call measure() first.");
        return executionMode;
    }

getMaxThreads()

ThreadIndex Beatmup::CustomPipeline::Impl::getMaxThreads ( ) const

inline

Definition at line 180 of file custom_pipeline.cpp.

                                      {
        if (!measured)
            throw PipelineNotReady("Pipeline not measured; call measure() first.");
        return maxThreadCount;
    }

beforeProcessing()

void Beatmup::CustomPipeline::Impl::beforeProcessing ( GraphicPipeline *  gpu )

inline

Definition at line 186 of file custom_pipeline.cpp.

                                                {
        this->gpu = gpu;
        abort = false;
    }

process()

bool Beatmup::CustomPipeline::Impl::process ( GraphicPipeline *  gpu, TaskThread &  thread, CustomPipeline &  pipeline  )

inline

Processing entry point.

Definition at line 194 of file custom_pipeline.cpp.

                                                                                      {
        // managing worker thread
        if (thread.isManaging()) {
            this->thread = &thread;
            std::lock_guard<std::mutex> lock(tasksAccess);
            currentTask = tasks.begin();
            pipeline.route(*this);
        }
 
        // secondary worker thread
        else {
            do {
                thread.synchronize();
                if (!allTasksDone() && !allTasksAborted() && thread.currentThread() < (*currentTask)->threadCount)
                    if (!(*currentTask)->getTask().process(thread))
                        abort = true;
                thread.synchronize();
            } while (!allTasksDone() && !allTasksAborted());
        }
 
        return !abort;
    }

Member Data Documentation

currentTask

std::vector<TaskHolder*>::iterator Beatmup::CustomPipeline::Impl::currentTask

private

Definition at line 28 of file custom_pipeline.cpp.

tasks

std::vector<TaskHolder*> Beatmup::CustomPipeline::Impl::tasks

private

the list of tasks

Definition at line 29 of file custom_pipeline.cpp.

tasksAccess

std::mutex Beatmup::CustomPipeline::Impl::tasksAccess

private

task list access control

Definition at line 30 of file custom_pipeline.cpp.

gpu

GraphicPipeline* Beatmup::CustomPipeline::Impl::gpu

private

Definition at line 31 of file custom_pipeline.cpp.

thread

TaskThread* Beatmup::CustomPipeline::Impl::thread

private

Definition at line 32 of file custom_pipeline.cpp.

executionMode

AbstractTask::TaskDeviceRequirement Beatmup::CustomPipeline::Impl::executionMode

private

Definition at line 33 of file custom_pipeline.cpp.

maxThreadCount

ThreadIndex Beatmup::CustomPipeline::Impl::maxThreadCount

private

Definition at line 34 of file custom_pipeline.cpp.

measured

bool Beatmup::CustomPipeline::Impl::measured

private

if true, the execution mode and the thread count are determined

Definition at line 35 of file custom_pipeline.cpp.

abort

bool Beatmup::CustomPipeline::Impl::abort

private

if true, one of threads executing the current task caused its aborting

Definition at line 36 of file custom_pipeline.cpp.

---

The documentation for this class was generated from the following file:

• core/pipelining/custom_pipeline.cpp