---

       

---

PxTask.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and 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.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.

#ifndef PXTASK_PXTASK_H
#define PXTASK_PXTASK_H

#include "task/PxTaskDefine.h"
#include "task/PxTaskManager.h"
#include "task/PxCpuDispatcher.h"
#include "task/PxGpuDispatcher.h"
#include "foundation/PxAssert.h"

namespace physx
{

class PxBaseTask
{
public:
    PxBaseTask() : mContextID(0), mTm(NULL) {}
    virtual ~PxBaseTask() {}

    virtual void        run() = 0;

    virtual const char* getName() const = 0;

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

    virtual void        release() = 0;

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

    PX_FORCE_INLINE void    setContextId(PxU64 id)          { mContextID = id;      }
    PX_FORCE_INLINE PxU64   getContextId()          const   { return mContextID;    }

protected:
    PxU64               mContextID;     
    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 int32_t getReference() const
    {
        return mTm->getReference( mTaskID );
    }
    
    PX_INLINE PxTaskID      getTaskID() const
    {
        return mTaskID;
    }

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

    PX_INLINE void      requestSyncPoint()
    {
        mPreSyncRequired = true;
    }

protected:
    PxTaskID            mTaskID;            
    uint32_t            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 int32_t getReference() const
    {
        return mRefCount;
    }

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

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

protected:

    PxBaseTask*         mCont;          
    volatile int32_t    mRefCount;      

    friend class PxTaskMgr;
};


}// end physx namespace


#endif // PXTASK_PXTASK_H

---

Copyright © 2008-2018 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com