diff options
Diffstat (limited to 'Minecraft.Client/PS3/PS3Extras/C4JSpursJob.cpp')
| -rw-r--r-- | Minecraft.Client/PS3/PS3Extras/C4JSpursJob.cpp | 409 |
1 files changed, 409 insertions, 0 deletions
diff --git a/Minecraft.Client/PS3/PS3Extras/C4JSpursJob.cpp b/Minecraft.Client/PS3/PS3Extras/C4JSpursJob.cpp new file mode 100644 index 00000000..fd8ddd9a --- /dev/null +++ b/Minecraft.Client/PS3/PS3Extras/C4JSpursJob.cpp @@ -0,0 +1,409 @@ +#include "stdafx.h" + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <cell/spurs.h> +#include "C4JSpursJob.h" +#include "C4JThread_SPU.h" +// #include "PS3\SPU_Tasks\SPUMemTools\SPUMemTools.h" + + +using namespace cell::Spurs::JobQueue; + +static const unsigned int NUM_SUBMIT_JOBS = 128; +#define DMA_ALIGNMENT (128) +#define JOBHEADER_SYMBOL(JobName) _binary_jqjob_##JobName##_jobbin2_jobheader + +C4JSpursJobQueue* C4JSpursJobQueue::m_pMainJobQueue = NULL; + +uint16_t C4JSpursJobQueue::Port::s_jobTagBitmask = 0; +C4JSpursJobQueue::Port* C4JSpursJobQueue::Port::s_allocatedPorts[16] = {NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL, + NULL,NULL,NULL,NULL }; +bool C4JSpursJobQueue::Port::s_initialised; +CRITICAL_SECTION C4JSpursJobQueue::Port::s_lock; + + +C4JSpursJobQueue::C4JSpursJobQueue() +{ + int ret; + cell::Spurs::Spurs* spurs = C4JThread_SPU::getSpurs2(); + + //E create job descriptor pool + const CellSpursJobQueueJobDescriptorPool poolDescriptor = { + 0, 0, NUM_SUBMIT_JOBS, 0, 0, 0, 0, 0 + }; + unsigned int sizeOfJobDescriptorPool = + CELL_SPURS_JOBQUEUE_JOB_DESCRIPTOR_POOL_SIZE(0, 0, NUM_SUBMIT_JOBS, 0, 0, 0, 0, 0); + + pPool = (uint8_t*)memalign(DMA_ALIGNMENT, sizeOfJobDescriptorPool); + + //E create jobQueue + pJobQueue = (JobQueue<JOB_QUEUE_DEPTH>*)memalign(CELL_SPURS_JOBQUEUE_ALIGN, sizeof(JobQueue<JOB_QUEUE_DEPTH>)); + assert(pJobQueue != NULL); + + ret = JobQueue<JOB_QUEUE_DEPTH>::create( pJobQueue, + spurs, + "SampleJobQueue", + 5, //numSpus + 8, // priority + (void*)pPool, + &poolDescriptor, + 4, // maxGrab + false, // submitWithEntryLock + false, // doBusyWaiting + false, //isHaltOnError + true, // autoPrxLoad + 1 ); //uint8_t maxNumJobsOnASpu = CELL_SPURS_JOBQUEUE_DEFAULT_MAX_NUM_JOBS_ON_SPU, + + + + assert(ret == CELL_OK); + (void)ret; +} + + +C4JSpursJobQueue::Port::Port(const char* portName) +{ + m_portName = portName; + if(!s_initialised) + InitializeCriticalSection(&s_lock); + s_initialised = true; + + EnterCriticalSection(&s_lock); + + m_pPort2 = (Port2*)memalign(CELL_SPURS_JOBQUEUE_PORT2_ALIGN, CELL_SPURS_JOBQUEUE_PORT2_SIZE); + assert(m_pPort2); + int ret = Port2::create(m_pPort2, C4JSpursJobQueue::getMainJobQueue().pJobQueue); + assert(ret == CELL_OK); + + + m_jobTag = getFreeJobTag(); + m_bDestroyed = false; + LeaveCriticalSection(&s_lock); +} + +C4JSpursJobQueue::Port::~Port() +{ + EnterCriticalSection(&s_lock); + releaseJobTag(m_jobTag); + if(!m_bDestroyed) + { + int ret = m_pPort2->destroy(); + assert(ret == CELL_OK); + } + free(m_pPort2); + LeaveCriticalSection(&s_lock); + +} + + +void C4JSpursJobQueue::Port::submitJob(C4JSpursJob* pJob) +{ + if(m_bDestroyed) + return; + int ret; + //E submit job + ret = m_pPort2->copyPushJob(&pJob->m_job256.header, sizeof(CellSpursJob256), sizeof(CellSpursJob256), m_jobTag, + CELL_SPURS_JOBQUEUE_FLAG_SYNC_JOB); + if(ret != CELL_OK) + app.DebugPrintf("copyPushJob failed with error 0x%08x\n", ret); + assert(ret == CELL_OK); + +} + +void C4JSpursJobQueue::Port::waitForCompletion() +{ + if(m_bDestroyed) + return; + int ret; + ret = m_pPort2->sync(0); + assert(ret == CELL_OK); + (void)ret; // remove unused var warning +} + +bool C4JSpursJobQueue::Port::hasCompleted() +{ + if(m_bDestroyed) + return true; + + int ret; + ret = m_pPort2->sync(CELL_SPURS_JOBQUEUE_FLAG_NON_BLOCKING); + if(ret == CELL_SPURS_JOB_ERROR_AGAIN) + return false; + assert(ret == CELL_OK); + return true; +} + + +void C4JSpursJobQueue::Port::submitSync() +{ + if(m_bDestroyed) + return; + + int status; + status = m_pPort2->pushSync(1u << m_jobTag, 0); + assert(status == CELL_OK); + (void)status; // remove unused var warning +} + +int C4JSpursJobQueue::Port::getFreeJobTag() +{ + for(int i=0;i<16;i++) + { + if((s_jobTagBitmask & (1<<i)) == 0) + { + s_jobTagBitmask |= (1<<i); + s_allocatedPorts[i] = this; + return i; + } + } + assert(0); + return 0; +} + +void C4JSpursJobQueue::Port::releaseJobTag( int tag ) +{ + s_jobTagBitmask &= ~(1<<tag); + s_allocatedPorts[tag] = NULL; +} + +void C4JSpursJobQueue::Port::destroyAll() +{ + // bit hacky, but the texture blit port seems to stall on destroy if we don't have this + // presumably because it uses a non-blocking sync + extern C4JSpursJobQueue::Port* g_texBlitJobQueuePort; + if(g_texBlitJobQueuePort) + { + g_texBlitJobQueuePort->waitForCompletion(); + } + + for(int i=0;i<16;i++) + { + if(s_allocatedPorts[i]) + { + s_allocatedPorts[i]->m_bDestroyed = true; + int ret = s_allocatedPorts[i]->m_pPort2->destroy(); + assert(ret == CELL_OK); + } + } +#ifndef _CONTENT_PACKAGE + printf("C4JSpursJobQueue::Port::destroyAll\n"); +#endif +} + + + + +void C4JSpursJobQueue::shutdown() +{ + Port::destroyAll(); + int ret = pJobQueue->shutdown(); + assert(ret == CELL_OK); + int exitCode; + ret = pJobQueue->join(&exitCode); + assert(ret == CELL_OK && exitCode == CELL_OK); + + free(pJobQueue); + free(pPool); +#ifndef _CONTENT_PACKAGE + printf("C4JSpursJobQueue::shutdown\n"); +#endif +} + + + +C4JSpursJob::C4JSpursJob() +{ + __builtin_memset(&m_job256, 0, sizeof(CellSpursJob256)); +} + + + +C4JSpursJob_CompressedTile::C4JSpursJob_CompressedTile(TileCompressData_SPU* pDataIn, unsigned char* pDataOut) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(CompressedTile); + //E create job + m_job256.header = JOBHEADER_SYMBOL(CompressedTile); + m_job256.header.sizeStack = (64*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + m_job256.workArea.userData[1] = (uintptr_t)pDataOut; + +} + + +C4JSpursJob_ChunkUpdate::C4JSpursJob_ChunkUpdate(ChunkRebuildData* pDataIn, ChunkRebuildData* pDataOut) +: C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(ChunkUpdate); + //E create job + m_job256.header = JOBHEADER_SYMBOL(ChunkUpdate); + m_job256.header.sizeStack = (60*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + m_job256.workArea.userData[1] = (uintptr_t)pDataOut; + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + +C4JSpursJob_LevelRenderer_cull::C4JSpursJob_LevelRenderer_cull(LevelRenderer_cull_DataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(LevelRenderer_cull); + //E create job + m_job256.header = JOBHEADER_SYMBOL(LevelRenderer_cull); + m_job256.header.sizeStack = (200*1024)>>4; // this is extremely tight, global flags take up 164K + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + +C4JSpursJob_LevelRenderer_zSort::C4JSpursJob_LevelRenderer_zSort(LevelRenderer_cull_DataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(LevelRenderer_zSort); + //E create job + m_job256.header = JOBHEADER_SYMBOL(LevelRenderer_zSort); + m_job256.header.sizeStack = (200*1024)>>4; // this is extremely tight, global flags take up 164K + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + +C4JSpursJob_LevelRenderer_FindNearestChunk::C4JSpursJob_LevelRenderer_FindNearestChunk(LevelRenderer_FindNearestChunk_DataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(LevelRenderer_FindNearestChunk); + //E create job + m_job256.header = JOBHEADER_SYMBOL(LevelRenderer_FindNearestChunk); + m_job256.header.sizeStack = (200*1024)>>4; // this is extremely tight, global flags take up 164K + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + + + +// C4JSpursJob_Renderer_TextureUpdate::C4JSpursJob_Renderer_TextureUpdate(Renderer_TextureUpdate_DataIn* pDataIn) +// : C4JSpursJob() +// { +// extern const CellSpursJobHeader JOBHEADER_SYMBOL(Renderer_TextureUpdate); +// int ret; +// //E create job +// m_job256.header = JOBHEADER_SYMBOL(Renderer_TextureUpdate); +// m_job256.header.sizeStack = (200*1024)>>4; +// m_job256.workArea.userData[0] = (uintptr_t)pDataIn; +// +// assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); +// +// } +// + +C4JSpursJob_Texture_blit::C4JSpursJob_Texture_blit(Texture_blit_DataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(Texture_blit); + //E create job + m_job256.header = JOBHEADER_SYMBOL(Texture_blit); + m_job256.header.sizeStack = (200*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + +C4JSpursJob_CompressedTileStorage_compress::C4JSpursJob_CompressedTileStorage_compress(CompressedTileStorage_compress_dataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(CompressedTileStorage_compress); + //E create job + m_job256.header = JOBHEADER_SYMBOL(CompressedTileStorage_compress); + m_job256.header.sizeStack = (200*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} + +/* +C4JSpursJob_CompressedTileStorage_getData::C4JSpursJob_CompressedTileStorage_getData(unsigned char* pIdxAndData, int dataSize, unsigned char* pDst, unsigned int retOffset) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(CompressedTileStorage_getData); + int ret; + //E create job + m_job256.header = JOBHEADER_SYMBOL(CompressedTileStorage_getData); + m_job256.header.sizeStack = (200*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pIdxAndData; + m_job256.workArea.userData[1] = (uintptr_t)dataSize; + m_job256.workArea.userData[2] = (uintptr_t)pDst; + m_job256.workArea.userData[3] = (uintptr_t)retOffset; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); + +} */ + +// C4JSpursJob_GameRenderer_updateLightTexture::C4JSpursJob_GameRenderer_updateLightTexture(GameRenderer_updateLightTexture_dataIn* pDataIn) +// : C4JSpursJob() +// { +// extern const CellSpursJobHeader JOBHEADER_SYMBOL(GameRenderer_updateLightTexture); +// int ret; +// //E create job +// m_job256.header = JOBHEADER_SYMBOL(GameRenderer_updateLightTexture); +// m_job256.header.sizeStack = (200*1024)>>4; +// m_job256.workArea.userData[0] = (uintptr_t)pDataIn; +// +// assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); +// +// } + +C4JSpursJob_PerlinNoise::C4JSpursJob_PerlinNoise(PerlinNoise_DataIn* pDataIn) + : C4JSpursJob() +{ + extern const CellSpursJobHeader JOBHEADER_SYMBOL(PerlinNoise); + //E create job + m_job256.header = JOBHEADER_SYMBOL(PerlinNoise); + m_job256.header.sizeStack = (200*1024)>>4; + m_job256.workArea.userData[0] = (uintptr_t)pDataIn; + + assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); +} + +// C4JSpursJob_MemSet::C4JSpursJob_MemSet(void* pMem, int numBytes, uint8_t val) +// : C4JSpursJob() +// { +// extern const CellSpursJobHeader JOBHEADER_SYMBOL(SPUMemTools); +// int ret; +// //E create job +// m_job256.header = JOBHEADER_SYMBOL(SPUMemTools); +// m_job256.header.sizeStack = (200*1024)>>4; +// m_job256.workArea.userData[0] = (uintptr_t)e_SPUMemToolsFunc_MemSet; +// m_job256.workArea.userData[1] = (uintptr_t)pMem; +// m_job256.workArea.userData[2] = (uintptr_t)numBytes; +// m_job256.workArea.userData[3] = (uintptr_t)val; +// +// assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); +// } + +// C4JSpursJob_RLECompress::C4JSpursJob_RLECompress(void* pSrc, int srcSize, void* pDst, int* pDstSize) +// : C4JSpursJob() +// { +// extern const CellSpursJobHeader JOBHEADER_SYMBOL(RLECompress); +// int ret; +// //E create job +// m_job256.header = JOBHEADER_SYMBOL(RLECompress); +// m_job256.header.sizeStack = (200*1024)>>4; +// m_job256.workArea.userData[0] = (uintptr_t)pSrc; +// m_job256.workArea.userData[1] = (uintptr_t)srcSize; +// m_job256.workArea.userData[2] = (uintptr_t)pDst; +// m_job256.workArea.userData[3] = (uintptr_t)pDstSize; +// +// assert(cellSpursJobQueueCheckJob(&m_job256, 256, 256) == CELL_OK); +// } +// |