PxTask.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */

#ifndef PX_TASK_H
#define PX_TASK_H

#include "foundation/Px.h"
#include "pxtask/PxTaskManager.h"
#include "foundation/PxAssert.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxBaseTask
{
public:
    PxBaseTask() : mEventID(0xFFFF), mProfileStat(0), mTm(0) {}
    virtual ~PxBaseTask() {}

    virtual void        run() = 0;

    virtual const char* getName() const = 0;

    virtual void        addReference() = 0;
    virtual void        removeReference() = 0;
    virtual PxI32       getReference() const = 0;

    virtual void        release() = 0;

    PX_INLINE void runProfiled(PxU32 threadId=0)
    {       
        mTm->emitStartEvent(*this, threadId);
        run();
        mTm->emitStopEvent(*this, threadId);
    }

    PX_INLINE void setProfileStat( PxU16 stat )
    {
        mProfileStat = stat;
    }

    PX_INLINE PxTaskManager* getTaskManager() const
    {
        return mTm;
    }

protected:
    PxU16               mEventID;       
    PxU16               mProfileStat;   
    PxTaskManager*      mTm;            

    friend class PxTaskMgr;
};


class PxTask : public PxBaseTask
{
public:
    PxTask() : mTaskID(0) {}
    virtual ~PxTask() {}

    virtual void release()
    {
        PX_ASSERT(mTm);

        // clear mTm before calling taskCompleted() for safety
        PxTaskManager* save = mTm;
        mTm = NULL;
        save->taskCompleted( *this );
    }

    //         task is allowed to start.
    PX_INLINE void finishBefore( PxTaskID taskID )
    {
        PX_ASSERT(mTm);
        mTm->finishBefore( *this, taskID);
    }

    //         task has completed.
    PX_INLINE void startAfter( PxTaskID taskID )
    {
        PX_ASSERT(mTm);
        mTm->startAfter( *this, taskID );
    }

    PX_INLINE void addReference()
    {
        PX_ASSERT(mTm);
        mTm->addReference( mTaskID );
    }

    PX_INLINE void removeReference()
    {
        PX_ASSERT(mTm);
        mTm->decrReference( mTaskID );
    }

    PX_INLINE PxI32 getReference() const
    {
        return mTm->getReference( mTaskID );
    }
    
    PX_INLINE PxTaskID      getTaskID() const
    {
        return mTaskID;
    }

    virtual void submitted()
    {
        mStreamIndex = 0;
        mPreSyncRequired = false;
        mProfileStat = 0;
    }

    PX_INLINE void      requestSyncPoint()
    {
        mPreSyncRequired = true;
    }


protected:
    PxTaskID            mTaskID;            
    PxU32               mStreamIndex;       
    bool                mPreSyncRequired;   

    friend class PxTaskMgr;
    friend class PxGpuWorkerThread;
};


class PxLightCpuTask : public PxBaseTask
{
public:
    PxLightCpuTask()
        : mCont( NULL )
        , mRefCount( 0 )
    {
    }
    virtual ~PxLightCpuTask()
    {
        mTm = NULL;
    }

    PX_INLINE void setContinuation(PxTaskManager& tm, PxBaseTask* c)
    {
        PX_ASSERT( mRefCount == 0 );
        mRefCount = 1;
        mCont = c;
        mTm = &tm;
        if( mCont )
        {
            mCont->addReference();
        }
    }

    PX_INLINE void setContinuation( PxBaseTask* c )
    {
        PX_ASSERT( c );
        PX_ASSERT( mRefCount == 0 );
        mRefCount = 1;
        mCont = c;
        if( mCont )
        {
            mCont->addReference();
            mTm = mCont->getTaskManager();
            PX_ASSERT( mTm );
        }
    }

    PX_INLINE PxBaseTask*   getContinuation()   const
    {
        return mCont;
    }

    PX_INLINE void removeReference()
    {
        mTm->decrReference(*this);
    }

    PX_INLINE PxI32 getReference() const
    {
        return mRefCount;
    }

    PX_INLINE void addReference()
    {
        mTm->addReference(*this);
    }

    PX_INLINE void release()
    {
        if( mCont )
        {
            mCont->removeReference();
        }
    }

protected:

    PxBaseTask*         mCont;          
    volatile PxI32      mRefCount;      

    friend class PxTaskMgr;
};

#ifndef PX_DOXYGEN
} // end physx namespace
#endif

#endif