//========== 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;
}