PxSpuTask.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_SPU_TASK_H
#define PX_SPU_TASK_H

#include "pxtask/PxTask.h"
#include "pxtask/PxSpuDispatcher.h"

#include "physxprofilesdk/PxProfileZone.h"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

class PxSpuTask : public PxLightCpuTask
{
public:

    static const PxU32 kMaxSpus = 6;        
    static const PxU32 kArgsPerSpu = 2; 

    PxSpuTask(const void* elfStart, PxU32 elfSize, PxU32 numSpus=1, const PxU32* args=NULL) 
        : mElfStart(elfStart)
        , mElfSize(elfSize)
        , mNbSpusToRun(numSpus)
        , mNbSpusFinished(0)
        , mEmitProfile(false)
    {
        if (args)
        {
            memcpy(mArgs, args, mNbSpusToRun*kArgsPerSpu*sizeof(PxU32));
        }       
    }

    virtual ~PxSpuTask() {}

    PX_INLINE PxU32 getSpuCount() const
    {
        return mNbSpusToRun; 
    }

    PX_INLINE void setSpuCount(PxU32 numSpusToRun)  
    { 
        PX_ASSERT(numSpusToRun);
        mNbSpusToRun = numSpusToRun; 
    }

    PX_INLINE const PxU32* getArgs(PxU32 spuIndex) const 
    { 
        PX_ASSERT(spuIndex < kMaxSpus); 
        return mArgs[spuIndex]; 
    }


    PX_INLINE void setArgs(PxU32 spuIndex, PxU32 arg0, PxU32 arg1)
    {
        PX_ASSERT(spuIndex < kMaxSpus);
        PxU32* arguments = mArgs[spuIndex];
        arguments[0]=arg0;
        arguments[1]=arg1;
    }

    PX_INLINE const void* getElfStart() const
    {
        return mElfStart; 
    }

    PX_INLINE PxU32 getElfSize() const 
    {
        return mElfSize;
    }

    PX_INLINE void notifySpuFinish()
    {
        ++mNbSpusFinished;

        // if all SPU tasks have finished clean-up and release
        if (mNbSpusFinished == mNbSpusToRun)
        {
            // emit profiling event
            if (mEmitProfile)
            {
                getTaskManager()->emitStopEvent(*this, PxProfileEventSender::CrossThreadId);
                mEmitProfile = false;
            }           

            mNbSpusFinished = 0;
            release();          
        }
    }

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

    virtual void run() {}

    void runProfiled() 
    {
        // emit profiling event
        getTaskManager()->emitStartEvent(*this, PxProfileEventSender::CrossThreadId);
        mEmitProfile = true;

        run();
    }


protected:

    const void* mElfStart;              
    PxU32 mElfSize;                     
    PxU32 mNbSpusToRun;             
    PxU32 mNbSpusFinished;              
    PxU32 mArgs[kMaxSpus][kArgsPerSpu]; 
    bool mEmitProfile;                  

} 
// wrap this in a macro so Doxygen doesn't get confused and output it
#ifndef PX_DOXYGEN
PX_ALIGN_SUFFIX(16)
#endif
;

#ifndef PX_DOXYGEN
} // end physx namespace
#endif

#endif