You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 lines
7.0 KiB
175 lines
7.0 KiB
//========== Copyright © Valve Corporation, All rights reserved. ========
|
|
|
|
#include "ps3/vjobchain4.h"
|
|
|
|
vec_uint4 g_cellSpursJts16 = ( vec_uint4 ){ uint( CELL_SPURS_JOB_COMMAND_JTS >> 32 ), uint( CELL_SPURS_JOB_COMMAND_JTS ), uint( CELL_SPURS_JOB_COMMAND_JTS >> 32 ), uint( CELL_SPURS_JOB_COMMAND_JTS ) };
|
|
|
|
#ifndef SPU
|
|
|
|
#include "ps3/vjobutils.h"
|
|
#include "vjobs/root.h"
|
|
#include "tier1/strtools.h"
|
|
#include "tier0/miniprofiler.h"
|
|
|
|
int VjobChain4::Init( VJobsRoot * pRoot, uint nMaxContention, uint nMinCommandsPerBuffer, uint8_t nVjobChainPriority[8], uint nSizeOfJobDescriptor, uint nMaxGrabbedJob, const char* pName, uint nDmaTags )
|
|
{
|
|
m_pName = pName;
|
|
m_eaThis = this;
|
|
// we need at least 4 commands
|
|
uint nBufferSize = sizeof( VjobChain4BufferHeader_t ) + sizeof( uint64 ) * MAX( nMinCommandsPerBuffer, VjobChain4Buffer_t::VERBATIM_COMMAND_COUNT + 2 ); // +2 is for user's command and JTN
|
|
nBufferSize = AlignValue( nBufferSize, 128 );
|
|
m_nMaxCommandsPerBuffer = ( nBufferSize - sizeof( VjobChain4BufferHeader_t ) ) / sizeof( uint64 );
|
|
|
|
uint nAllocationSize = sizeof( cell::Spurs::JobChain ) + nBufferSize * BUFFER_COUNT;
|
|
m_pSpursJobChain = ( cell::Spurs::JobChain* )MemAlloc_AllocAligned( nAllocationSize, 128 );
|
|
V_memset( m_pSpursJobChain, 0, nAllocationSize );
|
|
m_pBuffers[0] = ( VjobChain4Buffer_t * )( m_pSpursJobChain + 1 );
|
|
m_nFrontBuffer = 0;
|
|
m_pFrontBuffer = m_pBuffers[0];
|
|
for( int i = 1; i < BUFFER_COUNT; ++i )
|
|
{
|
|
m_pBuffers[i] = ( VjobChain4Buffer_t * )( uintp( m_pBuffers[ i - 1 ] ) + nBufferSize );
|
|
}
|
|
|
|
cell::Spurs::JobChainAttribute attr;
|
|
attr.initialize( &attr, m_pFrontBuffer->m_spursCommands, nSizeOfJobDescriptor, nMaxGrabbedJob, nVjobChainPriority, nMaxContention, true, nDmaTags, nDmaTags + 1, false, Max<uint>( 256, nSizeOfJobDescriptor ), 1 );
|
|
attr.setName( pName );
|
|
CELL_MUST_SUCCEED( JobChain::createWithAttribute( &pRoot->m_spurs, m_pSpursJobChain, &attr ) );
|
|
|
|
for( int i = 0; i < BUFFER_COUNT; ++i )
|
|
{
|
|
Assert( !( uintp( m_pBuffers[i] ) & 0x7F ) );
|
|
m_pBuffers[i]->Init( pRoot, m_pSpursJobChain, m_nMaxCommandsPerBuffer );
|
|
}
|
|
|
|
*StartCommandBuffer( 0 ) = CELL_SPURS_JOB_COMMAND_NOP;
|
|
CELL_MUST_SUCCEED( m_pSpursJobChain->run() );
|
|
|
|
#ifdef _DEBUG
|
|
sys_timer_usleep( 100 );
|
|
#endif
|
|
|
|
m_nSpinWaitNotify = 0;
|
|
return CELL_OK;
|
|
}
|
|
|
|
|
|
|
|
void VjobChain4Buffer_t::Init( VJobsRoot * pRoot, cell::Spurs::JobChain * pSpursJobChain, uint nMaxCommandsPerBuffer )
|
|
{
|
|
Assert( 0 == ( 0x7F & uintp( &m_jobNotify ) ) );
|
|
m_jobNotify.header = *( pRoot->m_pJobNotify );
|
|
m_jobNotify.header.useInOutBuffer = 1;
|
|
AddInputDma( &m_jobNotify, sizeof( m_notifyArea ), &m_notifyArea );
|
|
m_notifyArea.m_nCopyFrom = 1;
|
|
// SPU will mark copyTo = 1, PPU will mark it back to 0; at this time, we may actually mark the notify as completed; 1 means "previous buffer is free"
|
|
// Then we'll start command buffer, which will reset the ready flag. But then we run the jobchain, which will run job_notify and set the flag back again, thus starting the ring
|
|
m_notifyArea.m_nCopyTo = 1;
|
|
m_jobNotify.workArea.userData[1] = 0; // function: default
|
|
|
|
uint nCommands = 0;
|
|
m_spursCommands[nCommands++] = CELL_SPURS_JOB_COMMAND_SYNC; // wait for all previous list commands to finish
|
|
m_spursCommands[nCommands++] = CELL_SPURS_JOB_COMMAND_JOB( &m_jobNotify );
|
|
Assert( nCommands == VjobChain4Buffer_t::VERBATIM_COMMAND_COUNT );
|
|
while( nCommands < nMaxCommandsPerBuffer )
|
|
{
|
|
m_spursCommands[nCommands++] = CELL_SPURS_JOB_COMMAND_JTS;
|
|
}
|
|
}
|
|
|
|
|
|
void VjobChain4::End()
|
|
{
|
|
Assert( m_nFrontBufferCommandCount < m_nMaxCommandsPerBuffer );
|
|
m_pFrontBuffer->m_spursCommands[ m_nFrontBufferCommandCount ] = CELL_SPURS_JOB_COMMAND_END;
|
|
m_pSpursJobChain->shutdown();
|
|
}
|
|
|
|
void VjobChain4::Join()
|
|
{
|
|
Assert( m_pFrontBuffer->m_spursCommands[ m_nFrontBufferCommandCount ] == CELL_SPURS_JOB_COMMAND_END );
|
|
m_pSpursJobChain->join();
|
|
|
|
MemAlloc_FreeAligned( m_pSpursJobChain );
|
|
m_pSpursJobChain = NULL;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
void VjobChain4::WaitForEntryNotify( VjobChain4Buffer_t * eaBuffer )
|
|
{
|
|
volatile job_notify::NotifyArea_t *eaNotify = &eaBuffer->m_notifyArea;
|
|
// it doesn't matter what DMA tag we'll use for synchronous DMA get
|
|
Assert( VjobDmaGetUint32( (uint)&eaNotify->m_nCopyFrom, DMATAG_SYNC, 0, 0 ) );
|
|
while( !VjobDmaGetUint32( (uint)&eaNotify->m_nCopyTo, DMATAG_SYNC, 0, 0 ) )
|
|
{
|
|
++m_nSpinWaitNotify;
|
|
#ifndef SPU
|
|
sys_timer_usleep( 30 );
|
|
#endif
|
|
}
|
|
if( m_nSpinWaitNotify )
|
|
{
|
|
VjobSpuLog( "VjobChain: stall in WaitForEntryNotify, %d spins\n", m_nSpinWaitNotify );
|
|
m_nSpinWaitNotify = 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
uint64* VjobChain4::SwapCommandBuffer( )
|
|
{
|
|
uint64 * eaSpursIsSpinningHere = &m_pFrontBuffer->m_spursCommands[ m_nFrontBufferCommandCount ];
|
|
|
|
Assert( m_nFrontBufferCommandCount < m_nMaxCommandsPerBuffer );
|
|
uint nNext1Buffer = ( m_nFrontBuffer + 1 ) % BUFFER_COUNT, nNext2Buffer = ( m_nFrontBuffer + 2 ) % BUFFER_COUNT;
|
|
VjobChain4Buffer_t * eaNext1Buffer = m_pBuffers[ nNext1Buffer ], * eaNext2Buffer = m_pBuffers[ nNext2Buffer ];
|
|
|
|
// before we can declare the next1 buffer "front", we need to make sure it's fully ready to accept commands, i.e. that it was fully read by SPURS
|
|
// for that, we check the next2 buffer notification area
|
|
|
|
WaitForEntryNotify( eaNext1Buffer );
|
|
WaitForEntryNotify( eaNext2Buffer );
|
|
|
|
// if next2 buffer has been notified, next1 must have been notified long ago
|
|
Assert( VjobDmaGetUint32( (uint)&eaNext1Buffer->m_notifyArea.m_nCopyTo, DMATAG_SYNC, 0, 0 ) );
|
|
uint64* pInsertionPoint = StartCommandBuffer( nNext1Buffer );
|
|
Assert( eaNext1Buffer == m_pFrontBuffer );
|
|
// implicit lwsync is here
|
|
VjobDmaPutfUint64( CELL_SPURS_JOB_COMMAND_NEXT( eaNext1Buffer->m_spursCommands ), (uint)eaSpursIsSpinningHere, DMATAG_SYNC ); // jump to the next buffer
|
|
|
|
return pInsertionPoint;
|
|
}
|
|
|
|
#ifndef SPU
|
|
void FillSpursJts( uint64 * eaCommands, uint nBufferCount )
|
|
{
|
|
for( uint i = 0; i < nBufferCount; ++i )
|
|
eaCommands[ i ] = CELL_SPURS_JOB_COMMAND_JTS;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Initializes the buffer BEFORE the jobchain can jump to it. It's important to only jump to the next buffer
|
|
// after this function returns (either by inserting NEXT into previous buffer, or by call Run() on the jobchain)
|
|
// because this function lacks the necessary synchronization to operate safely on a buffer in-flight
|
|
//
|
|
uint64* VjobChain4::StartCommandBuffer( uint nNext1Buffer )
|
|
{
|
|
m_nFrontBuffer = nNext1Buffer;
|
|
m_pFrontBuffer = m_pBuffers[ nNext1Buffer ];
|
|
// the ready marker is presumed to be present; SPURS must have gone through this buffer in the previous ring, otherwise we can't use it
|
|
Assert( VjobDmaGetUint32( (uint)&m_pFrontBuffer->m_notifyArea.m_nCopyTo, DMATAG_SYNC, 0, 0) == 1 );
|
|
// reset the ready marker; SPURS didn't get to this buffer yet (we're about to reuse them and we didn't jump to it yet)
|
|
VjobDmaPutfUint32( 0, (uint)&m_pFrontBuffer->m_notifyArea.m_nCopyTo, DMATAG_SYNC );
|
|
uint64 * eaCommand = &m_pFrontBuffer->m_spursCommands[ VjobChain4Buffer_t::VERBATIM_COMMAND_COUNT ];
|
|
//VjobDmaPutfUint64( nInsertCommand, (uint)eaCommand, DMATAG_SYNC );
|
|
|
|
FillSpursJts( eaCommand, m_nMaxCommandsPerBuffer - VjobChain4Buffer_t::VERBATIM_COMMAND_COUNT );
|
|
m_nFrontBufferCommandCount = VjobChain4Buffer_t::VERBATIM_COMMAND_COUNT + 1;
|
|
LWSYNC_PPU_ONLY();
|
|
return eaCommand;
|
|
}
|
|
|
|
|