#include "stdafx.h"
#include "Emu/System.h"
#include "Emu/system_config.h"
#include "Emu/Memory/vm_reservation.h"
#include "Emu/Cell/PPUModule.h"
#include "Emu/Cell/SPUThread.h"
#include "Emu/Cell/lv2/sys_lwmutex.h"
#include "Emu/Cell/lv2/sys_lwcond.h"
#include "Emu/Cell/lv2/sys_spu.h"
#include "Emu/Cell/lv2/sys_ppu_thread.h"
#include "Emu/Cell/lv2/sys_memory.h"
#include "Emu/Cell/lv2/sys_process.h"
#include "Emu/Cell/lv2/sys_semaphore.h"
#include "Emu/Cell/lv2/sys_event.h"
#include "sysPrxForUser.h"
#include "cellSpurs.h"

#include "util/asm.hpp"
#include "util/v128.hpp"
#include "util/simd.hpp"

LOG_CHANNEL(cellSpurs);

template <>
void fmt_class_string<CellSpursCoreError>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto error)
		{
			switch (error)
			{
				STR_CASE(CELL_SPURS_CORE_ERROR_AGAIN);
				STR_CASE(CELL_SPURS_CORE_ERROR_INVAL);
				STR_CASE(CELL_SPURS_CORE_ERROR_NOMEM);
				STR_CASE(CELL_SPURS_CORE_ERROR_SRCH);
				STR_CASE(CELL_SPURS_CORE_ERROR_PERM);
				STR_CASE(CELL_SPURS_CORE_ERROR_BUSY);
				STR_CASE(CELL_SPURS_CORE_ERROR_STAT);
				STR_CASE(CELL_SPURS_CORE_ERROR_ALIGN);
				STR_CASE(CELL_SPURS_CORE_ERROR_NULL_POINTER);
			}

			return unknown;
		});
}

template <>
void fmt_class_string<CellSpursPolicyModuleError>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto error)
		{
			switch (error)
			{
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_AGAIN);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_INVAL);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_NOSYS);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_NOMEM);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_SRCH);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_NOENT);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_NOEXEC);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_DEADLK);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_PERM);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_BUSY);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_ABORT);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_FAULT);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_CHILD);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_STAT);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_ALIGN);
				STR_CASE(CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER);
			}

			return unknown;
		});
}

template <>
void fmt_class_string<CellSpursTaskError>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto error)
		{
			switch (error)
			{
				STR_CASE(CELL_SPURS_TASK_ERROR_AGAIN);
				STR_CASE(CELL_SPURS_TASK_ERROR_INVAL);
				STR_CASE(CELL_SPURS_TASK_ERROR_NOSYS);
				STR_CASE(CELL_SPURS_TASK_ERROR_NOMEM);
				STR_CASE(CELL_SPURS_TASK_ERROR_SRCH);
				STR_CASE(CELL_SPURS_TASK_ERROR_NOEXEC);
				STR_CASE(CELL_SPURS_TASK_ERROR_PERM);
				STR_CASE(CELL_SPURS_TASK_ERROR_BUSY);
				STR_CASE(CELL_SPURS_TASK_ERROR_FAULT);
				STR_CASE(CELL_SPURS_TASK_ERROR_ALIGN);
				STR_CASE(CELL_SPURS_TASK_ERROR_STAT);
				STR_CASE(CELL_SPURS_TASK_ERROR_NULL_POINTER);
				STR_CASE(CELL_SPURS_TASK_ERROR_FATAL);
				STR_CASE(CELL_SPURS_TASK_ERROR_SHUTDOWN);
			}

			return unknown;
		});
}

template <>
void fmt_class_string<CellSpursJobError>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto error)
		{
			switch (error)
			{
				STR_CASE(CELL_SPURS_JOB_ERROR_AGAIN);
				STR_CASE(CELL_SPURS_JOB_ERROR_INVAL);
				STR_CASE(CELL_SPURS_JOB_ERROR_NOSYS);
				STR_CASE(CELL_SPURS_JOB_ERROR_NOMEM);
				STR_CASE(CELL_SPURS_JOB_ERROR_SRCH);
				STR_CASE(CELL_SPURS_JOB_ERROR_NOENT);
				STR_CASE(CELL_SPURS_JOB_ERROR_NOEXEC);
				STR_CASE(CELL_SPURS_JOB_ERROR_DEADLK);
				STR_CASE(CELL_SPURS_JOB_ERROR_PERM);
				STR_CASE(CELL_SPURS_JOB_ERROR_BUSY);
				STR_CASE(CELL_SPURS_JOB_ERROR_JOB_DESCRIPTOR);
				STR_CASE(CELL_SPURS_JOB_ERROR_JOB_DESCRIPTOR_SIZE);
				STR_CASE(CELL_SPURS_JOB_ERROR_FAULT);
				STR_CASE(CELL_SPURS_JOB_ERROR_CHILD);
				STR_CASE(CELL_SPURS_JOB_ERROR_STAT);
				STR_CASE(CELL_SPURS_JOB_ERROR_ALIGN);
				STR_CASE(CELL_SPURS_JOB_ERROR_NULL_POINTER);
				STR_CASE(CELL_SPURS_JOB_ERROR_MEMORY_CORRUPTED);
				STR_CASE(CELL_SPURS_JOB_ERROR_MEMORY_SIZE);
				STR_CASE(CELL_SPURS_JOB_ERROR_UNKNOWN_COMMAND);
				STR_CASE(CELL_SPURS_JOB_ERROR_JOBLIST_ALIGNMENT);
				STR_CASE(CELL_SPURS_JOB_ERROR_JOB_ALIGNMENT);
				STR_CASE(CELL_SPURS_JOB_ERROR_CALL_OVERFLOW);
				STR_CASE(CELL_SPURS_JOB_ERROR_ABORT);
				STR_CASE(CELL_SPURS_JOB_ERROR_DMALIST_ELEMENT);
				STR_CASE(CELL_SPURS_JOB_ERROR_NUM_CACHE);
				STR_CASE(CELL_SPURS_JOB_ERROR_INVALID_BINARY);
			}

			return unknown;
		});
}

template <>
void fmt_class_string<SpursWorkloadState>::format(std::string& out, u64 arg)
{
	format_enum(out, arg, [](auto error)
		{
			switch (error)
			{
			case SPURS_WKL_STATE_NON_EXISTENT: return "Non-existent";
			case SPURS_WKL_STATE_PREPARING: return "Preparing";
			case SPURS_WKL_STATE_RUNNABLE: return "Runnable";
			case SPURS_WKL_STATE_SHUTTING_DOWN: return "In-shutdown";
			case SPURS_WKL_STATE_REMOVABLE: return "Removable";
			case SPURS_WKL_STATE_INVALID: break;
			}

			return unknown;
		});
}

error_code sys_spu_image_close(ppu_thread&, vm::ptr<sys_spu_image> img);

// Temporarily
#ifndef _MSC_VER
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif

//----------------------------------------------------------------------------
// Function prototypes
//----------------------------------------------------------------------------

bool spursKernelEntry(spu_thread& spu);

// SPURS Internals
namespace _spurs
{
	// Get the version of SDK used by this process
	s32 get_sdk_version();

	// Check whether libprof is loaded
	bool is_libprof_loaded();

	// Create an LV2 event queue and attach it to the SPURS instance
	s32 create_lv2_eq(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> queueId, vm::ptr<u8> port, s32 size, const sys_event_queue_attribute_t& name);

	// Attach an LV2 event queue to the SPURS instance
	s32 attach_lv2_eq(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic, bool spursCreated);

	// Detach an LV2 event queue from the SPURS instance
	s32 detach_lv2_eq(vm::ptr<CellSpurs> spurs, u8 spuPort, bool spursCreated);

	// Wait until a workload in the SPURS instance becomes ready
	void handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Entry point of the SPURS handler thread. This thread is responsible for starting the SPURS SPU thread group.
	void handler_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Create the SPURS handler thread
	s32 create_handler(vm::ptr<CellSpurs> spurs, u32 ppuPriority);

	// Invoke event handlers
	s32 invoke_event_handlers(ppu_thread& ppu, vm::ptr<CellSpurs::EventPortMux> eventPortMux);

	// Invoke workload shutdown completion callbacks
	s32 wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid);

	// Entry point of the SPURS event helper thread
	void event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Create the SPURS event helper thread
	s32 create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 ppuPriority);

	// Initialise the event port multiplexor structure
	void init_event_port_mux(vm::ptr<CellSpurs::EventPortMux> eventPortMux, u8 spuPort, u32 eventPort, u32 unknown);

	// Enable the system workload
	s32 add_default_syswkl(vm::ptr<CellSpurs> spurs, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem);

	// Destroy the SPURS SPU threads and thread group
	s32 finalize_spu(ppu_thread&, vm::ptr<CellSpurs> spurs);

	// Stop the event helper thread
	s32 stop_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Signal to the SPURS handler thread
	s32 signal_to_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Join the SPURS handler thread
	s32 join_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Initialise SPURS
	s32 initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision, u32 sdkVersion, s32 nSpus, s32 spuPriority, s32 ppuPriority, u32 flags, vm::cptr<char> prefix, u32 prefixSize, u32 container, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem);
} // namespace _spurs

//
// SPURS Core Functions
//

// s32 cellSpursInitialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork);
// s32 cellSpursInitializeWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr);
// s32 cellSpursInitializeWithAttribute2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr);
// s32 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork);
// s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container);
// s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::cptr<char> prefix, u32 size);
// s32 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr<CellSpursAttribute> attr);
// s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s32 type);
// s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::cptr<u8[8]> priority, u32 maxSpu, vm::cptr<b8[8]> isPreemptible);
// s32 cellSpursFinalize(vm::ptr<CellSpurs> spurs);
// s32 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> group);
// s32 cellSpursGetNumSpuThread(vm::ptr<CellSpurs> spurs, vm::ptr<u32> nThreads);
// s32 cellSpursGetSpuThreadId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> thread, vm::ptr<u32> nThreads);
// s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 wid, u32 maxContention);
// s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> priorities);
// s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<b8> isPreemptible);
// s32 cellSpursAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic);
// s32 cellSpursDetachLv2EventQueue(vm::ptr<CellSpurs> spurs, u8 port);

// Enable the SPU exception event handler
s32 cellSpursEnableExceptionEventHandler(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, b8 flag);

// s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursGlobalExceptionEventHandler> eaHandler, vm::ptr<void> arg);
// s32 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs);
// s32 cellSpursGetInfo(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursInfo> info);

//
// SPURS SPU GUID functions
//

// s32 cellSpursGetSpuGuid();

//
// SPURS trace functions
//

namespace _spurs
{
	// Signal SPUs to update trace status
	void trace_status_update(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

	// Initialize SPURS trace
	s32 trace_initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> buffer, u32 size, u32 mode, u32 updateStatus);

	// Start SPURS trace
	s32 trace_start(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStatus);

	// Stop SPURS trace
	s32 trace_stop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStatus);
} // namespace _spurs

// s32 cellSpursTraceInitialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> buffer, u32 size, u32 mode);
// s32 cellSpursTraceFinalize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);
// s32 cellSpursTraceStart(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);
// s32 cellSpursTraceStop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

//
// SPURS policy module functions
//

namespace _spurs
{
	// Add workload
	s32 add_workload(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8 (&priorityTable)[8], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg);
} // namespace _spurs

// s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt);
// s32 cellSpursWorkloadAttributeSetName(vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance);
// s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWorkloadAttribute> attr, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> arg);
// s32 cellSpursAddWorkload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt);
// s32 cellSpursAddWorkloadWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<CellSpursWorkloadAttribute> attr);
// s32 cellSpursShutdownWorkload();
// s32 cellSpursWaitForWorkloadShutdown();
// s32 cellSpursRemoveWorkload();

// Activate the SPURS kernel
s32 cellSpursWakeUp(ppu_thread& ppu, vm::ptr<CellSpurs> spurs);

s32 cellSpursSendWorkloadSignal(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid);
// s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloadFlag> flag);
s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 value);
s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap);
s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap);
s32 cellSpursReadyCountAdd(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value);
// s32 cellSpursGetWorkloadData(vm::ptr<CellSpurs> spurs, vm::ptr<u64> data, u32 wid);
// s32 cellSpursGetWorkloadInfo();
// s32 cellSpursSetExceptionEventHandler();
// s32 cellSpursUnsetExceptionEventHandler();
s32 _cellSpursWorkloadFlagReceiver(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set);
// s32 _cellSpursWorkloadFlagReceiver2();
// error_code cellSpursRequestIdleSpu();

//
// SPURS taskset functions
//

namespace _spurs
{
	// Create taskset
	s32 create_taskset(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 max_contention, vm::cptr<char> name, u32 size, s32 enable_clear_ls);
} // namespace _spurs

// s32 cellSpursCreateTasksetWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute> attr);
// s32 cellSpursCreateTaskset(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 maxContention);
// s32 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset);
// s32 cellSpursGetTasksetId(vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> wid);
// s32 cellSpursShutdownTaskset(vm::ptr<CellSpursTaskset> taskset);
// s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm::cptr<char> name);
// s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> attr, u32 size);
// s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr<CellSpursTasksetAttribute> attr, s32 enable);
// s32 _cellSpursTasksetAttribute2Initialize(vm::ptr<CellSpursTasksetAttribute2> attribute, u32 revision);
// s32 cellSpursCreateTaskset2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute2> attr);
// s32 cellSpursDestroyTaskset2();
// s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetExceptionEventHandler> handler, vm::ptr<u64> arg);
// s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset);

// Get taskset instance from the workload ID
s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id);

// s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<u32> spurs);
// s32 cellSpursGetTasksetInfo();
// s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attribute, u32 revision, u32 sdk_version, u64 args, vm::cptr<u8> priority, u32 max_contention);

//
// SPURS task functions
//

namespace _spurs
{
	// Create task
	s32 create_task(vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> task_id, vm::cptr<void> elf, vm::cptr<void> context, u32 size, vm::ptr<CellSpursTaskLsPattern> ls_pattern, vm::ptr<CellSpursTaskArgument> arg);

	// Start task
	s32 task_start(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, u32 taskId);
} // namespace _spurs

// s32 cellSpursCreateTask(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> taskId, vm::cptr<void> elf, vm::cptr<void> context, u32 size, vm::ptr<CellSpursTaskLsPattern> lsPattern, vm::ptr<CellSpursTaskArgument> argument);

// Sends a signal to the task
s32 _cellSpursSendSignal(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, u32 taskId);

// s32 cellSpursCreateTaskWithAttribute();
// s32 cellSpursTaskExitCodeGet();
// s32 cellSpursTaskExitCodeInitialize();
// s32 cellSpursTaskExitCodeTryGet();
// s32 cellSpursTaskGetLoadableSegmentPattern();
// s32 cellSpursTaskGetReadOnlyAreaPattern();
// s32 cellSpursTaskGenerateLsPattern();
// s32 _cellSpursTaskAttributeInitialize();
// s32 cellSpursTaskAttributeSetExitCodeContainer();
// s32 _cellSpursTaskAttribute2Initialize(vm::ptr<CellSpursTaskAttribute2> attribute, u32 revision);
// s32 cellSpursTaskGetContextSaveAreaSize();
// s32 cellSpursCreateTask2();
// s32 cellSpursJoinTask2();
// s32 cellSpursTryJoinTask2();
// s32 cellSpursCreateTask2WithBinInfo();

//
// SPURS event flag functions
//

namespace _spurs
{
	// Wait for SPURS event flag
	s32 event_flag_wait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode, u32 block);
} // namespace _spurs

// s32 _cellSpursEventFlagInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection);
// s32 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits);
// s32 cellSpursEventFlagSet(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, u16 bits);
// s32 cellSpursEventFlagWait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode);
// s32 cellSpursEventFlagTryWait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode);
// s32 cellSpursEventFlagAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag);
// s32 cellSpursEventFlagDetachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag);
// s32 cellSpursEventFlagGetDirection(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> direction);
// s32 cellSpursEventFlagGetClearMode(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> clear_mode);
// s32 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, vm::pptr<CellSpursTaskset> taskset);

//
// SPURS lock free queue functions
//

// s32 _cellSpursLFQueueInitialize(vm::ptr<void> pTasksetOrSpurs, vm::ptr<CellSpursLFQueue> pQueue, vm::cptr<void> buffer, u32 size, u32 depth, u32 direction);
// s32 _cellSpursLFQueuePushBody();
// s32 cellSpursLFQueueAttachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue);
// s32 cellSpursLFQueueDetachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue);
// s32 _cellSpursLFQueuePopBody();
// s32 cellSpursLFQueueGetTasksetAddress();

//
// SPURS queue functions
//

// s32 _cellSpursQueueInitialize();
// s32 cellSpursQueuePopBody();
// s32 cellSpursQueuePushBody();
// s32 cellSpursQueueAttachLv2EventQueue();
// s32 cellSpursQueueDetachLv2EventQueue();
// s32 cellSpursQueueGetTasksetAddress();
// s32 cellSpursQueueClear();
// s32 cellSpursQueueDepth();
// s32 cellSpursQueueGetEntrySize();
// s32 cellSpursQueueSize();
// s32 cellSpursQueueGetDirection();

//
// SPURS barrier functions
//

// s32 cellSpursBarrierInitialize();
// s32 cellSpursBarrierGetTasksetAddress();

//
// SPURS semaphore functions
//

// s32 _cellSpursSemaphoreInitialize();
// s32 cellSpursSemaphoreGetTasksetAddress();

//
// SPURS job chain functions
//

namespace _spurs
{
	s32 check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob, u64 priorities, u32 maxContention, u8 autoSpuCount, u32 tag1, u32 tag2, u8 isFixedMemAlloc, u32 maxSizeJob, u32 initSpuCount);

	s32 create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 sizeJob, u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 autoReadyCount, u32 tag1, u32 tag2, u32 HaltOnError, vm::cptr<char> name, u32 param_13, u32 param_14);

} // namespace _spurs

// s32 cellSpursCreateJobChainWithAttribute();
// s32 cellSpursCreateJobChain();
// s32 cellSpursJoinJobChain();
s32 cellSpursKickJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain, u8 numReadyCount);
// s32 _cellSpursJobChainAttributeInitialize();
// s32 cellSpursGetJobChainId();
// s32 cellSpursJobChainSetExceptionEventHandler();
// s32 cellSpursJobChainUnsetExceptionEventHandler();
// s32 cellSpursGetJobChainInfo();
// s32 cellSpursJobChainGetSpursAddress();
// s32 cellSpursJobGuardInitialize();
// s32 cellSpursJobChainAttributeSetName();
// s32 cellSpursShutdownJobChain();
// s32 cellSpursJobChainAttributeSetHaltOnError();
// s32 cellSpursJobChainAttributeSetJobTypeMemoryCheck();
// s32 cellSpursJobGuardNotify();
// s32 cellSpursJobGuardReset();
s32 cellSpursRunJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain);
// s32 cellSpursJobChainGetError();
// s32 cellSpursGetJobPipelineInfo();
// s32 cellSpursJobSetMaxGrab();
// s32 cellSpursJobHeaderSetJobbin2Param();
// s32 cellSpursAddUrgentCommand();
// s32 cellSpursAddUrgentCall();

//----------------------------------------------------------------------------
// SPURS utility functions
//----------------------------------------------------------------------------

s32 _spurs::get_sdk_version()
{
	const s32 version = static_cast<s32>(g_ps3_process_info.sdk_ver);
	return version == -1 ? 0x485000 : version;
}

bool _spurs::is_libprof_loaded()
{
	return false;
}

//----------------------------------------------------------------------------
// SPURS core functions
//----------------------------------------------------------------------------

s32 _spurs::create_lv2_eq(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> queueId, vm::ptr<u8> port, s32 size, const sys_event_queue_attribute_t& attr)
{
	if (s32 rc = sys_event_queue_create(ppu, queueId, vm::make_var(attr), SYS_EVENT_QUEUE_LOCAL, size))
	{
		static_cast<void>(ppu.test_stopped());
		return rc;
	}

	if (_spurs::attach_lv2_eq(ppu, spurs, *queueId, port, 1, true))
	{
		sys_event_queue_destroy(ppu, *queueId, SYS_EVENT_QUEUE_DESTROY_FORCE);
		static_cast<void>(ppu.test_stopped());
	}

	return CELL_OK;
}

s32 _spurs::attach_lv2_eq(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic, bool spursCreated)
{
	if (!spurs || !port)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	u8 _port = 0x3f;
	u64 portMask = 0;

	if (isDynamic == 0)
	{
		_port = *port;
		if (_port > 0x3f)
		{
			return CELL_SPURS_CORE_ERROR_INVAL;
		}

		if (_spurs::get_sdk_version() >= 0x180000 && _port > 0xf)
		{
			return CELL_SPURS_CORE_ERROR_PERM;
		}
	}

	for (u32 i = isDynamic ? 0x10 : _port; i <= _port; i++)
	{
		portMask |= 1ull << (i);
	}

	if (s32 res = sys_spu_thread_group_connect_event_all_threads(ppu, spurs->spuTG, queue, portMask, port))
	{
		if (res + 0u == CELL_EISCONN)
		{
			return CELL_SPURS_CORE_ERROR_BUSY;
		}

		return res;
	}

	if (!spursCreated)
	{
		spurs->spuPortBits |= 1ull << *port;
	}

	return CELL_OK;
}

s32 _spurs::detach_lv2_eq(vm::ptr<CellSpurs> spurs, u8 spuPort, bool spursCreated)
{
	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (!spursCreated && spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (spuPort > 0x3F)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if (!spursCreated)
	{
		if (!spurs->spuPortBits.bit_test_reset(spuPort) && _spurs::get_sdk_version() >= 0x180000)
		{
			return CELL_SPURS_CORE_ERROR_SRCH;
		}
	}

	return CELL_OK;
}

void _spurs::handler_wait_ready(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	ensure(ppu_execute<&sys_lwmutex_lock>(ppu, spurs.ptr(&CellSpurs::mutex), 0) == 0);
	static_cast<void>(ppu.test_stopped());

	while (true)
	{
		if (spurs->handlerExiting)
		{
			ensure(ppu_execute<&sys_lwmutex_unlock>(ppu, spurs.ptr(&CellSpurs::mutex)) == 0);

			return sys_ppu_thread_exit(ppu, 0);
		}

		// Find a runnable workload
		spurs->handlerDirty = 0;
		if (spurs->exception == 0u)
		{
			bool foundRunnableWorkload = false;
			for (u32 i = 0; i < 16; i++)
			{
				if (spurs->wklState1[i] == SPURS_WKL_STATE_RUNNABLE &&
					std::bit_cast<u64>(spurs->wklInfo1[i].priority) != 0 &&
					spurs->wklMaxContention[i] & 0x0F)
				{
					if (spurs->wklReadyCount1[i] ||
						spurs->wklSignal1.load() & (0x8000u >> i) ||
						(spurs->wklFlag.flag.load() == 0u &&
							spurs->wklFlagReceiver == static_cast<u8>(i)))
					{
						foundRunnableWorkload = true;
						break;
					}
				}
			}

			if (spurs->flags1 & SF1_32_WORKLOADS)
			{
				for (u32 i = 0; i < 16; i++)
				{
					if (spurs->wklState2[i] == SPURS_WKL_STATE_RUNNABLE &&
						std::bit_cast<u64>(spurs->wklInfo2[i].priority) != 0 &&
						spurs->wklMaxContention[i] & 0xF0)
					{
						if (spurs->wklIdleSpuCountOrReadyCount2[i] ||
							spurs->wklSignal2.load() & (0x8000u >> i) ||
							(spurs->wklFlag.flag.load() == 0u &&
								spurs->wklFlagReceiver == static_cast<u8>(i) + 0x10))
						{
							foundRunnableWorkload = true;
							break;
						}
					}
				}
			}

			if (foundRunnableWorkload)
			{
				break;
			}
		}

		// If we reach it means there are no runnable workloads in this SPURS instance.
		// Wait until some workload becomes ready.
		spurs->handlerWaiting = 1;
		if (spurs->handlerDirty == 0)
		{
			ensure(ppu_execute<&sys_lwcond_wait>(ppu, spurs.ptr(&CellSpurs::cond), 0) == 0);
			static_cast<void>(ppu.test_stopped());
		}

		spurs->handlerWaiting = 0;
	}

	// If we reach here then a runnable workload was found
	ensure(ppu_execute<&sys_lwmutex_unlock>(ppu, spurs.ptr(&CellSpurs::mutex)) == 0);
	static_cast<void>(ppu.test_stopped());
}

void _spurs::handler_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	if (spurs->flags & SAF_UNKNOWN_FLAG_30)
	{
		return sys_ppu_thread_exit(ppu, 0);
	}

	while (true)
	{
		if (spurs->flags1 & SF1_EXIT_IF_NO_WORK)
		{
			_spurs::handler_wait_ready(ppu, spurs);
		}

		ensure(sys_spu_thread_group_start(ppu, spurs->spuTG) == 0);

		const s32 rc = sys_spu_thread_group_join(ppu, spurs->spuTG, vm::null, vm::null);
		static_cast<void>(ppu.test_stopped());

		if (rc + 0u != CELL_EFAULT)
		{
			if (rc + 0u == CELL_ESTAT)
			{
				return sys_ppu_thread_exit(ppu, 0);
			}

			ensure(rc + 0u == CELL_EFAULT);
		}

		if ((spurs->flags1 & SF1_EXIT_IF_NO_WORK) == 0)
		{
			ensure((spurs->handlerExiting == 1));

			return sys_ppu_thread_exit(ppu, 0);
		}
	}
}

s32 _spurs::create_handler(vm::ptr<CellSpurs> spurs, u32 ppuPriority)
{
	struct handler_thread : ppu_thread
	{
		using ppu_thread::ppu_thread;

		void non_task()
		{
			// BIND_FUNC(_spurs::handler_entry)(*this);
		}
	};

	// auto eht = idm::make_ptr<ppu_thread, handler_thread>(std::string(spurs->prefix, spurs->prefixSize) + "SpursHdlr0", ppuPriority, 0x4000);

	// spurs->ppu0 = eht->id;

	// eht->gpr[3] = spurs.addr();
	// eht->run();

	return CELL_OK;
}

s32 _spurs::invoke_event_handlers(ppu_thread& ppu, vm::ptr<CellSpurs::EventPortMux> eventPortMux)
{
	if (eventPortMux->reqPending.exchange(0))
	{
		for (auto node = eventPortMux->handlerList.exchange(vm::null); node; node = node->next)
		{
			node->handler(ppu, eventPortMux, node->data);
		}
	}

	return CELL_OK;
}

s32 _spurs::wakeup_shutdown_completion_waiter(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
{
	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->wklState(wid) != SPURS_WKL_STATE_REMOVABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	const auto wklF = wid < CELL_SPURS_MAX_WORKLOAD ? &spurs->wklF1[wid] : &spurs->wklF2[wid & 0x0F];
	const auto wklEvent = &spurs->wklEvent(wid);

	if (wklF->hook)
	{
		wklF->hook(ppu, spurs, wid, wklF->hookArg);

		ensure((wklEvent->load() & 0x01));
		ensure((wklEvent->load() & 0x02));
		ensure((wklEvent->load() & 0x20) == 0);
		wklEvent->fetch_or(0x20);
	}

	s32 rc = CELL_OK;
	if (!wklF->hook || wklEvent->load() & 0x10)
	{
		ensure((wklF->x28 == 2u));
		rc = sys_semaphore_post(ppu, static_cast<u32>(wklF->sem), 1);
		static_cast<void>(ppu.test_stopped());
	}

	return rc;
}

void _spurs::event_helper_entry(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	vm::var<sys_event_t[]> events(8);
	vm::var<u32> count;

	while (true)
	{
		ensure(sys_event_queue_receive(ppu, spurs->eventQueue, vm::null, 0) == 0);
		static_cast<void>(ppu.test_stopped());

		const u64 event_src = ppu.gpr[4];
		const u64 event_data1 = ppu.gpr[5];
		const u64 event_data2 = ppu.gpr[6];
		const u64 event_data3 = ppu.gpr[7];

		if (event_src == SYS_SPU_THREAD_EVENT_EXCEPTION_KEY)
		{
			spurs->exception = 1;

			events[0].source = event_src;
			events[0].data1 = event_data1;
			events[0].data2 = event_data2;
			events[0].data3 = event_data3;

			if (sys_event_queue_tryreceive(ppu, spurs->eventQueue, events + 1, 7, count) != CELL_OK)
			{
				continue;
			}

			// TODO: Examine LS and dump exception details

			for (u32 i = 0; i < CELL_SPURS_MAX_WORKLOAD; i++)
			{
				sys_semaphore_post(ppu, static_cast<u32>(spurs->wklF1[i].sem), 1);

				if (spurs->flags1 & SF1_32_WORKLOADS)
				{
					sys_semaphore_post(ppu, static_cast<u32>(spurs->wklF2[i].sem), 1);
				}
			}

			static_cast<void>(ppu.test_stopped());
		}
		else
		{
			const u32 data0 = event_data2 & 0x00FFFFFF;

			if (data0 == 1)
			{
				return;
			}
			else if (data0 < 1)
			{
				const u32 shutdownMask = static_cast<u32>(event_data3);

				for (u32 wid = 0; wid < CELL_SPURS_MAX_WORKLOAD; wid++)
				{
					if (shutdownMask & (0x80000000u >> wid))
					{
						ensure(_spurs::wakeup_shutdown_completion_waiter(ppu, spurs, wid) == 0);
					}

					if ((spurs->flags1 & SF1_32_WORKLOADS) && (shutdownMask & (0x8000 >> wid)))
					{
						ensure(_spurs::wakeup_shutdown_completion_waiter(ppu, spurs, wid + 0x10) == 0);
					}
				}
			}
			else if (data0 == 2)
			{
				ensure(sys_semaphore_post(ppu, static_cast<u32>(spurs->semPrv), 1) == 0);
				static_cast<void>(ppu.test_stopped());
			}
			else if (data0 == 3)
			{
				ensure(_spurs::invoke_event_handlers(ppu, spurs.ptr(&CellSpurs::eventPortMux)) == 0);
			}
			else
			{
				fmt::throw_exception("data0=0x%x", data0);
			}
		}
	}
}

s32 _spurs::create_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 ppuPriority)
{
	if (s32 rc = _spurs::create_lv2_eq(ppu, spurs, spurs.ptr(&CellSpurs::eventQueue), spurs.ptr(&CellSpurs::spuPort), 0x2A, sys_event_queue_attribute_t{SYS_SYNC_PRIORITY, SYS_PPU_QUEUE, {"_spuPrv\0"_u64}}))
	{
		return rc;
	}

	if (sys_event_port_create(ppu, spurs.ptr(&CellSpurs::eventPort), SYS_EVENT_PORT_LOCAL, SYS_EVENT_PORT_NO_NAME))
	{
		if (_spurs::detach_lv2_eq(spurs, spurs->spuPort, true))
		{
			return CELL_SPURS_CORE_ERROR_AGAIN;
		}

		sys_event_queue_destroy(ppu, spurs->eventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE);
		return CELL_SPURS_CORE_ERROR_AGAIN;
	}

	if (sys_event_port_connect_local(ppu, spurs->eventPort, spurs->eventQueue))
	{
		sys_event_port_destroy(ppu, spurs->eventPort);

		if (_spurs::detach_lv2_eq(spurs, spurs->spuPort, true))
		{
			return CELL_SPURS_CORE_ERROR_STAT;
		}

		sys_event_queue_destroy(ppu, spurs->eventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE);
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	struct event_helper_thread : ppu_thread
	{
		using ppu_thread::ppu_thread;

		void non_task()
		{
			// BIND_FUNC(_spurs::event_helper_entry)(*this);
		}
	};

	// auto eht = idm::make_ptr<ppu_thread, event_helper_thread>(std::string(spurs->prefix, spurs->prefixSize) + "SpursHdlr1", ppuPriority, 0x8000);

	// if (!eht)
	{
		sys_event_port_disconnect(ppu, spurs->eventPort);
		sys_event_port_destroy(ppu, spurs->eventPort);

		if (_spurs::detach_lv2_eq(spurs, spurs->spuPort, true))
		{
			return CELL_SPURS_CORE_ERROR_STAT;
		}

		sys_event_queue_destroy(ppu, spurs->eventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE);
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	// eht->gpr[3] = spurs.addr();
	// eht->run();

	// spurs->ppu1 = eht->id;
	return CELL_OK;
}

void _spurs::init_event_port_mux(vm::ptr<CellSpurs::EventPortMux> eventPortMux, u8 spuPort, u32 eventPort, u32 unknown)
{
	memset(eventPortMux.get_ptr(), 0, sizeof(CellSpurs::EventPortMux));
	eventPortMux->spuPort = spuPort;
	eventPortMux->eventPort = eventPort;
	eventPortMux->x08 = unknown;
}

s32 _spurs::add_default_syswkl(vm::ptr<CellSpurs> spurs, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem)
{
	// TODO: Implement this
	return CELL_OK;
}

s32 _spurs::finalize_spu(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	if (spurs->flags & SAF_UNKNOWN_FLAG_7 || spurs->flags & SAF_UNKNOWN_FLAG_8)
	{
		while (true)
		{
			ensure(sys_spu_thread_group_join(ppu, spurs->spuTG, vm::null, vm::null) + 0u == CELL_EFAULT);

			if (s32 rc = sys_spu_thread_group_destroy(ppu, spurs->spuTG))
			{
				if (rc + 0u == CELL_EBUSY)
				{
					continue;
				}

				ensure(rc == CELL_OK);
			}

			break;
		}
	}
	else
	{
		if (s32 rc = sys_spu_thread_group_destroy(ppu, spurs->spuTG))
		{
			return rc;
		}
	}

	ensure(ppu_execute<&sys_spu_image_close>(ppu, spurs.ptr(&CellSpurs::spuImg)) == 0);

	return CELL_OK;
}

s32 _spurs::stop_event_helper(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	if (spurs->ppu1 == 0xFFFFFFFF)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (sys_event_port_send(spurs->eventPort, 0, 1, 0) != CELL_OK)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (sys_ppu_thread_join(ppu, static_cast<u32>(spurs->ppu1), vm::var<u64>{}) != CELL_OK)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	spurs->ppu1 = 0xFFFFFFFF;

	ensure(sys_event_port_disconnect(ppu, spurs->eventPort) == 0);
	ensure(sys_event_port_destroy(ppu, spurs->eventPort) == 0);
	ensure(_spurs::detach_lv2_eq(spurs, spurs->spuPort, true) == 0);
	ensure(sys_event_queue_destroy(ppu, spurs->eventQueue, SYS_EVENT_QUEUE_DESTROY_FORCE) == 0);

	return CELL_OK;
}

s32 _spurs::signal_to_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	ensure(ppu_execute<&sys_lwmutex_lock>(ppu, spurs.ptr(&CellSpurs::mutex), 0) == 0);
	ensure(ppu_execute<&sys_lwcond_signal>(ppu, spurs.ptr(&CellSpurs::cond)) == 0);
	ensure(ppu_execute<&sys_lwmutex_unlock>(ppu, spurs.ptr(&CellSpurs::mutex)) == 0);

	return CELL_OK;
}

s32 _spurs::join_handler_thread(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	if (spurs->ppu0 == 0xFFFFFFFF)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	ensure(sys_ppu_thread_join(ppu, static_cast<u32>(spurs->ppu0), vm::var<u64>{}) == 0);

	spurs->ppu0 = 0xFFFFFFFF;
	return CELL_OK;
}

s32 _spurs::initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 revision, u32 sdkVersion, s32 nSpus, s32 spuPriority, s32 ppuPriority, u32 flags, vm::cptr<char> prefix, u32 prefixSize, u32 container, vm::cptr<u8> swlPriority, u32 swlMaxSpu, u32 swlIsPreem)
{
	vm::var<u32> sem;
	vm::var<sys_semaphore_attribute_t> semAttr;
	vm::var<char[]> spuTgName(128);
	vm::var<sys_spu_thread_group_attribute> spuTgAttr;
	vm::var<sys_spu_thread_argument> spuThArgs;
	vm::var<sys_spu_thread_attribute> spuThAttr;
	vm::var<char[]> spuThName(128);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (prefixSize > CELL_SPURS_NAME_MAX_LENGTH)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if (process_is_spu_lock_line_reservation_address(spurs.addr(), SYS_MEMORY_ACCESS_RIGHT_SPU_THR))
	{
		return CELL_SPURS_CORE_ERROR_PERM;
	}

	// Intialise SPURS context
	const bool isSecond = (flags & SAF_SECOND_VERSION) != 0;

	auto rollback = [&]
	{
		if (spurs->semPrv)
		{
			sys_semaphore_destroy(ppu, ::narrow<u32>(+spurs->semPrv));
		}

		for (u32 i = 0; i < CELL_SPURS_MAX_WORKLOAD; i++)
		{
			if (spurs->wklF1[i].sem)
			{
				sys_semaphore_destroy(ppu, ::narrow<u32>(+spurs->wklF1[i].sem));
			}

			if (isSecond)
			{
				if (spurs->wklF2[i].sem)
				{
					sys_semaphore_destroy(ppu, ::narrow<u32>(+spurs->wklF2[i].sem));
				}
			}
		}
	};

	std::memset(spurs.get_ptr(), 0, isSecond ? CELL_SPURS_SIZE2 : CELL_SPURS_SIZE);
	spurs->revision = revision;
	spurs->sdkVersion = sdkVersion;
	spurs->ppu0 = 0xffffffffull;
	spurs->ppu1 = 0xffffffffull;
	spurs->flags = flags;
	spurs->prefixSize = static_cast<u8>(prefixSize);
	std::memcpy(spurs->prefix, prefix.get_ptr(), prefixSize);

	if (!isSecond)
	{
		spurs->wklEnabled = 0xffff;
	}

	// Initialise trace
	spurs->sysSrvTrace.store({});

	for (u32 i = 0; i < 8; i++)
	{
		spurs->sysSrvPreemptWklId[i] = -1;
	}

	// Import default system workload
	spurs->wklInfoSysSrv.addr.set(SPURS_IMG_ADDR_SYS_SRV_WORKLOAD);
	spurs->wklInfoSysSrv.size = 0x2200;
	spurs->wklInfoSysSrv.arg = 0;
	spurs->wklInfoSysSrv.uniqueId = 0xff;

	// Create semaphores for each workload
	semAttr->protocol = SYS_SYNC_PRIORITY;
	semAttr->pshared = SYS_SYNC_NOT_PROCESS_SHARED;
	semAttr->ipc_key = 0;
	semAttr->flags = 0;
	semAttr->name_u64 = "_spuWkl\0"_u64;

	for (u32 i = 0; i < CELL_SPURS_MAX_WORKLOAD; i++)
	{
		if (s32 rc = sys_semaphore_create(ppu, sem, semAttr, 0, 1))
		{
			return rollback(), rc;
		}

		spurs->wklF1[i].sem = *sem;

		if (isSecond)
		{
			if (s32 rc = sys_semaphore_create(ppu, sem, semAttr, 0, 1))
			{
				return rollback(), rc;
			}

			spurs->wklF2[i].sem = *sem;
		}
	}

	// Create semaphore
	semAttr->name_u64 = "_spuPrv\0"_u64;
	if (s32 rc = sys_semaphore_create(ppu, sem, semAttr, 0, 1))
	{
		return rollback(), rc;
	}

	spurs->semPrv = *sem;

	spurs->unk11 = -1;
	spurs->unk12 = -1;
	spurs->unk13 = 0;
	spurs->nSpus = nSpus;
	spurs->spuPriority = spuPriority;

	// Import SPURS kernel
	spurs->spuImg.type = SYS_SPU_IMAGE_TYPE_USER;
	spurs->spuImg.segs = vm::null;
	spurs->spuImg.entry_point = isSecond ? CELL_SPURS_KERNEL2_ENTRY_ADDR : CELL_SPURS_KERNEL1_ENTRY_ADDR;
	spurs->spuImg.nsegs = 0;

	// Create a thread group for this SPURS context
	std::memcpy(spuTgName.get_ptr(), spurs->prefix, spurs->prefixSize);
	std::memcpy(spuTgName.get_ptr() + spurs->prefixSize, "CellSpursKernelGroup", 21);

	spuTgAttr->name = spuTgName;
	spuTgAttr->nsize = static_cast<u32>(std::strlen(spuTgAttr->name.get_ptr())) + 1;
	spuTgAttr->type = SYS_SPU_THREAD_GROUP_TYPE_NORMAL;

	if (spurs->flags & SAF_UNKNOWN_FLAG_0)
	{
		spuTgAttr->type = 0x0C00 | SYS_SPU_THREAD_GROUP_TYPE_SYSTEM;
	}
	else if (flags & SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT)
	{
		spuTgAttr->type = SYS_SPU_THREAD_GROUP_TYPE_EXCLUSIVE_NON_CONTEXT;
	}
	else
	{
		spuTgAttr->type = SYS_SPU_THREAD_GROUP_TYPE_NORMAL;
	}

	if (spurs->flags & SAF_SPU_MEMORY_CONTAINER_SET)
	{
		spuTgAttr->type |= SYS_SPU_THREAD_GROUP_TYPE_MEMORY_FROM_CONTAINER;
		spuTgAttr->ct = container;
	}

	if (flags & SAF_UNKNOWN_FLAG_7)
		spuTgAttr->type |= 0x0100 | SYS_SPU_THREAD_GROUP_TYPE_SYSTEM;
	if (flags & SAF_UNKNOWN_FLAG_8)
		spuTgAttr->type |= 0x0C00 | SYS_SPU_THREAD_GROUP_TYPE_SYSTEM;
	if (flags & SAF_UNKNOWN_FLAG_9)
		spuTgAttr->type |= 0x0800;
	if (flags & SAF_SYSTEM_WORKLOAD_ENABLED)
		spuTgAttr->type |= SYS_SPU_THREAD_GROUP_TYPE_COOPERATE_WITH_SYSTEM;

	if (s32 rc = sys_spu_thread_group_create(ppu, spurs.ptr(&CellSpurs::spuTG), nSpus, spuPriority, spuTgAttr))
	{
		ppu_execute<&sys_spu_image_close>(ppu, spurs.ptr(&CellSpurs::spuImg));
		return rollback(), rc;
	}

	// Initialise all SPUs in the SPU thread group
	std::memcpy(spuThName.get_ptr(), spurs->prefix, spurs->prefixSize);
	std::memcpy(spuThName.get_ptr() + spurs->prefixSize, "CellSpursKernel", 16);

	spuThAttr->name = spuThName;
	spuThAttr->name_len = static_cast<u32>(std::strlen(spuThName.get_ptr())) + 2;
	spuThAttr->option = SYS_SPU_THREAD_OPTION_DEC_SYNC_TB_ENABLE;
	spuThName[spuThAttr->name_len - 1] = '\0';

	for (s32 num = 0; num < nSpus; num++)
	{
		spuThName[spuThAttr->name_len - 2] = '0' + num;
		spuThArgs->arg1 = static_cast<u64>(num) << 32;
		spuThArgs->arg2 = spurs.addr();

		if (s32 rc = sys_spu_thread_initialize(ppu, spurs.ptr(&CellSpurs::spus, num), spurs->spuTG, num, spurs.ptr(&CellSpurs::spuImg), spuThAttr, spuThArgs))
		{
			sys_spu_thread_group_destroy(ppu, spurs->spuTG);
			ppu_execute<&sys_spu_image_close>(ppu, spurs.ptr(&CellSpurs::spuImg));
			return rollback(), rc;
		}

		// entry point cannot be initialized immediately because SPU LS will be rewritten by sys_spu_thread_group_start()
		// idm::get_unlocked<named_thread<spu_thread>>(spurs->spus[num])->custom_task = [entry = spurs->spuImg.entry_point](spu_thread& spu)
		{
			// Disabled
		    // spu.RegisterHleFunction(entry, spursKernelEntry);
		};
	}

	// Start the SPU printf server if required
	if (flags & SAF_SPU_PRINTF_ENABLED)
	{
		// spu_printf: attach group
		if (!g_spu_printf_agcb || g_spu_printf_agcb(ppu, spurs->spuTG) != CELL_OK)
		{
			// remove flag if failed
			spurs->flags &= ~SAF_SPU_PRINTF_ENABLED;
		}
	}

	const auto lwMutex = spurs.ptr(&CellSpurs::mutex);
	const auto lwCond = spurs.ptr(&CellSpurs::cond);

	// Create a mutex to protect access to SPURS handler thread data
	if (vm::var<sys_lwmutex_attribute_t> attr({SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, {"_spuPrv\0"_u64}});
		s32 rc = ppu_execute<&sys_lwmutex_create>(ppu, lwMutex, +attr))
	{
		_spurs::finalize_spu(ppu, spurs);
		return rollback(), rc;
	}

	// Create condition variable to signal the SPURS handler thread
	if (vm::var<sys_lwcond_attribute_t> attr({"_spuPrv\0"_u64});
		s32 rc = ppu_execute<&sys_lwcond_create>(ppu, lwCond, lwMutex, +attr))
	{
		ppu_execute<&sys_lwmutex_destroy>(ppu, lwMutex);
		_spurs::finalize_spu(ppu, spurs);
		return rollback(), rc;
	}

	spurs->flags1 = (flags & SAF_EXIT_IF_NO_WORK ? SF1_EXIT_IF_NO_WORK : 0) | (isSecond ? SF1_32_WORKLOADS : 0);
	spurs->wklFlagReceiver = 0xff;
	spurs->wklFlag.flag = -1;
	spurs->handlerDirty = 0;
	spurs->handlerWaiting = 0;
	spurs->handlerExiting = 0;
	spurs->ppuPriority = ppuPriority;

	// Create the SPURS event helper thread
	if (s32 rc = _spurs::create_event_helper(ppu, spurs, ppuPriority))
	{
		ppu_execute<&sys_lwcond_destroy>(ppu, lwCond);
		ppu_execute<&sys_lwmutex_destroy>(ppu, lwMutex);
		_spurs::finalize_spu(ppu, spurs);
		return rollback(), rc;
	}

	// Create the SPURS handler thread
	if (s32 rc = _spurs::create_handler(spurs, ppuPriority))
	{
		_spurs::stop_event_helper(ppu, spurs);
		ppu_execute<&sys_lwcond_destroy>(ppu, lwCond);
		ppu_execute<&sys_lwmutex_destroy>(ppu, lwMutex);
		_spurs::finalize_spu(ppu, spurs);
		return rollback(), rc;
	}

	// Enable SPURS exception handler
	if (s32 rc = cellSpursEnableExceptionEventHandler(ppu, spurs, true /*enable*/))
	{
		_spurs::signal_to_handler_thread(ppu, spurs);
		_spurs::join_handler_thread(ppu, spurs);
		_spurs::stop_event_helper(ppu, spurs);
		ppu_execute<&sys_lwcond_destroy>(ppu, lwCond);
		ppu_execute<&sys_lwmutex_destroy>(ppu, lwMutex);
		_spurs::finalize_spu(ppu, spurs);
		return rollback(), rc;
	}

	spurs->traceBuffer = vm::null;
	// TODO: Register libprof for user trace

	// Initialise the event port multiplexor
	_spurs::init_event_port_mux(spurs.ptr(&CellSpurs::eventPortMux), spurs->spuPort, spurs->eventPort, 3);

	// Enable the default system workload if required
	if (flags & SAF_SYSTEM_WORKLOAD_ENABLED)
	{
		ensure(_spurs::add_default_syswkl(spurs, swlPriority, swlMaxSpu, swlIsPreem) == 0);
		return CELL_OK;
	}
	else if (flags & SAF_EXIT_IF_NO_WORK)
	{
		return cellSpursWakeUp(ppu, spurs);
	}

	return CELL_OK;
}

/// Initialize SPURS
s32 cellSpursInitialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork)
{
	cellSpurs.warning("cellSpursInitialize(spurs=*0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs, nSpus, spuPriority, ppuPriority, exitIfNoWork);

	return _spurs::initialize(ppu, spurs, 0, 0, nSpus, spuPriority, ppuPriority, exitIfNoWork ? SAF_EXIT_IF_NO_WORK : SAF_NONE, vm::null, 0, 0, vm::null, 0, 0);
}

/// Initialise SPURS
s32 cellSpursInitializeWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
{
	cellSpurs.warning("cellSpursInitializeWithAttribute(spurs=*0x%x, attr=*0x%x)", spurs, attr);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (attr->revision > 2)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	return _spurs::initialize(
		ppu,
		spurs,
		attr->revision,
		attr->sdkVersion,
		attr->nSpus,
		attr->spuPriority,
		attr->ppuPriority,
		attr->flags | (attr->exitIfNoWork ? SAF_EXIT_IF_NO_WORK : 0),
		attr.ptr(&CellSpursAttribute::prefix, 0),
		attr->prefixSize,
		attr->container,
		attr.ptr(&CellSpursAttribute::swlPriority, 0),
		attr->swlMaxSpu,
		attr->swlIsPreem);
}

/// Initialise SPURS
s32 cellSpursInitializeWithAttribute2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
{
	cellSpurs.warning("cellSpursInitializeWithAttribute2(spurs=*0x%x, attr=*0x%x)", spurs, attr);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (attr->revision > 2)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	return _spurs::initialize(
		ppu,
		spurs,
		attr->revision,
		attr->sdkVersion,
		attr->nSpus,
		attr->spuPriority,
		attr->ppuPriority,
		attr->flags | (attr->exitIfNoWork ? SAF_EXIT_IF_NO_WORK : 0) | SAF_SECOND_VERSION,
		attr.ptr(&CellSpursAttribute::prefix, 0),
		attr->prefixSize,
		attr->container,
		attr.ptr(&CellSpursAttribute::swlPriority, 0),
		attr->swlMaxSpu,
		attr->swlIsPreem);
}

/// Initialise SPURS attribute
s32 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork)
{
	cellSpurs.warning("_cellSpursAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
		attr, revision, sdkVersion, nSpus, spuPriority, ppuPriority, exitIfNoWork);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	memset(attr.get_ptr(), 0, sizeof(CellSpursAttribute));
	attr->revision = revision;
	attr->sdkVersion = sdkVersion;
	attr->nSpus = nSpus;
	attr->spuPriority = spuPriority;
	attr->ppuPriority = ppuPriority;
	attr->exitIfNoWork = exitIfNoWork;
	return CELL_OK;
}

/// Set memory container ID for creating the SPU thread group
s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container)
{
	cellSpurs.warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr=*0x%x, container=0x%x)", attr, container);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (attr->flags & SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	attr->container = container;
	attr->flags |= SAF_SPU_MEMORY_CONTAINER_SET;
	return CELL_OK;
}

/// Set the prefix for SPURS
s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::cptr<char> prefix, u32 size)
{
	cellSpurs.warning("cellSpursAttributeSetNamePrefix(attr=*0x%x, prefix=%s, size=%d)", attr, prefix, size);

	if (!attr || !prefix)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (size > CELL_SPURS_NAME_MAX_LENGTH)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	memcpy(attr->prefix, prefix.get_ptr(), size);
	attr->prefixSize = size;
	return CELL_OK;
}

/// Enable spu_printf()
s32 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr<CellSpursAttribute> attr)
{
	cellSpurs.warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr=*0x%x)", attr);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	attr->flags |= SAF_SPU_PRINTF_ENABLED;
	return CELL_OK;
}

/// Set the type of SPU thread group
s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s32 type)
{
	cellSpurs.warning("cellSpursAttributeSetSpuThreadGroupType(attr=*0x%x, type=%d)", attr, type);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (type == SYS_SPU_THREAD_GROUP_TYPE_EXCLUSIVE_NON_CONTEXT)
	{
		if (attr->flags & SAF_SPU_MEMORY_CONTAINER_SET)
		{
			return CELL_SPURS_CORE_ERROR_STAT;
		}
		attr->flags |= SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT; // set
	}
	else if (type == SYS_SPU_THREAD_GROUP_TYPE_NORMAL)
	{
		attr->flags &= ~SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT; // clear
	}
	else
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	return CELL_OK;
}

/// Enable the system workload
s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::cptr<u8[8]> priority, u32 maxSpu, vm::cptr<b8[8]> isPreemptible)
{
	cellSpurs.warning("cellSpursAttributeEnableSystemWorkload(attr=*0x%x, priority=*0x%x, maxSpu=%d, isPreemptible=*0x%x)", attr, priority, maxSpu, isPreemptible);

	if (!attr)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	const u32 nSpus = attr->nSpus;

	if (!nSpus)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	for (u32 i = 0; i < nSpus; i++)
	{
		if ((*priority)[i] == 1)
		{
			if (!maxSpu)
			{
				return CELL_SPURS_CORE_ERROR_INVAL;
			}

			if (nSpus == 1 || attr->exitIfNoWork)
			{
				return CELL_SPURS_CORE_ERROR_PERM;
			}

			if (attr->flags & SAF_SYSTEM_WORKLOAD_ENABLED)
			{
				return CELL_SPURS_CORE_ERROR_BUSY;
			}

			attr->flags |= SAF_SYSTEM_WORKLOAD_ENABLED; // set flag
			std::memcpy(attr->swlPriority, priority.get_ptr(), 8);

			u32 isPreem = 0; // generate mask from isPreemptible values
			for (u32 j = 0; j < nSpus; j++)
			{
				if ((*isPreemptible)[j])
				{
					isPreem |= (1 << j);
				}
			}

			attr->swlMaxSpu = maxSpu;   // write max spu for system workload
			attr->swlIsPreem = isPreem; // write isPreemptible mask
			return CELL_OK;
		}
	}

	return CELL_SPURS_CORE_ERROR_INVAL;
}

/// Release resources allocated for SPURS
s32 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
{
	cellSpurs.todo("cellSpursFinalize(spurs=*0x%x)", spurs);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (spurs->handlerExiting)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	[[maybe_unused]] u32 wklEnabled = spurs->wklEnabled.load();

	if (spurs->flags1 & SF1_32_WORKLOADS)
	{
		wklEnabled &= 0xFFFF0000;
	}

	if (spurs->flags & SAF_SYSTEM_WORKLOAD_ENABLED)
	{
	}

	// TODO: Implement the rest of this function
	return CELL_OK;
}

/// Get the SPU thread group ID
s32 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> group)
{
	cellSpurs.warning("cellSpursGetSpuThreadGroupId(spurs=*0x%x, group=*0x%x)", spurs, group);

	if (!spurs || !group)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	*group = spurs->spuTG;
	return CELL_OK;
}

// Get the number of SPU threads
s32 cellSpursGetNumSpuThread(vm::ptr<CellSpurs> spurs, vm::ptr<u32> nThreads)
{
	cellSpurs.warning("cellSpursGetNumSpuThread(spurs=*0x%x, nThreads=*0x%x)", spurs, nThreads);

	if (!spurs || !nThreads)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	*nThreads = spurs->nSpus;
	return CELL_OK;
}

/// Get SPU thread ids
s32 cellSpursGetSpuThreadId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> thread, vm::ptr<u32> nThreads)
{
	cellSpurs.warning("cellSpursGetSpuThreadId(spurs=*0x%x, thread=*0x%x, nThreads=*0x%x)", spurs, thread, nThreads);

	if (!spurs || !thread || !nThreads)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	const u32 count = std::min<u32>(*nThreads, spurs->nSpus);

	for (u32 i = 0; i < count; i++)
	{
		thread[i] = spurs->spus[i];
	}

	*nThreads = count;
	return CELL_OK;
}

/// Set the maximum contention for a workload
s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 wid, u32 maxContention)
{
	cellSpurs.warning("cellSpursSetMaxContention(spurs=*0x%x, wid=%d, maxContention=%d)", spurs, wid, maxContention);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_CORE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (maxContention > CELL_SPURS_MAX_SPU)
	{
		maxContention = CELL_SPURS_MAX_SPU;
	}

	vm::atomic_op(spurs->wklMaxContention[wid % CELL_SPURS_MAX_WORKLOAD], [&](u8& value)
		{
			value &= wid < CELL_SPURS_MAX_WORKLOAD ? 0xF0 : 0x0F;
			value |= wid < CELL_SPURS_MAX_WORKLOAD ? maxContention : maxContention << 4;
		});

	return CELL_OK;
}

/// Set the priority of a workload on each SPU
s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8[8]> priorities)
{
	cellSpurs.trace("cellSpursSetPriorities(spurs=*0x%x, wid=%d, priorities=*0x%x)", spurs, wid, priorities);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_CORE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (spurs->flags & SAF_SYSTEM_WORKLOAD_ENABLED)
	{
		// TODO: Implement this
	}

	const u64 prio = std::bit_cast<u64>(*priorities);

	// Test if any of the value >= CELL_SPURS_MAX_PRIORITY
	if (prio & 0xf0f0f0f0f0f0f0f0)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	vm::light_op(spurs->wklInfo(wid).prio64, [&](atomic_t<u64>& v)
		{
			v.release(prio);
		});
	vm::light_op(spurs->sysSrvMsgUpdateWorkload, [](atomic_t<u8>& v)
		{
			v.release(0xff);
		});
	vm::light_op(spurs->sysSrvMessage, [](atomic_t<u8>& v)
		{
			v.release(0xff);
		});
	return CELL_OK;
}

/// Set the priority of a workload for the specified SPU
s32 cellSpursSetPriority(vm::ptr<CellSpurs> spurs, u32 wid, u32 spuId, u32 priority)
{
	cellSpurs.trace("cellSpursSetPriority(spurs=*0x%x, wid=%d, spuId=%d, priority=%d)", spurs, wid, spuId, priority);

	if (!spurs)
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_CORE_ERROR_ALIGN;

	if (wid >= spurs->max_workloads())
		return CELL_SPURS_CORE_ERROR_INVAL;

	if (priority >= CELL_SPURS_MAX_PRIORITY || spuId >= spurs->nSpus)
		return CELL_SPURS_CORE_ERROR_INVAL;

	if ((spurs->wklEnabled & (0x80000000u >> wid)) == 0u)
		return CELL_SPURS_CORE_ERROR_SRCH;

	if (spurs->exception)
		return CELL_SPURS_CORE_ERROR_STAT;

	vm::light_op<true>(spurs->wklInfo(wid).priority[spuId], [&](u8& v)
		{
			atomic_storage<u8>::release(v, priority);
		});
	vm::light_op<true>(spurs->sysSrvMsgUpdateWorkload, [&](atomic_t<u8>& v)
		{
			v.bit_test_set(spuId);
		});
	vm::light_op<true>(spurs->sysSrvMessage, [&](atomic_t<u8>& v)
		{
			v.bit_test_set(spuId);
		});
	return CELL_OK;
}

/// Set preemption victim SPU
s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<b8> isPreemptible)
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

/// Attach an LV2 event queue to a SPURS instance
s32 cellSpursAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic)
{
	cellSpurs.warning("cellSpursAttachLv2EventQueue(spurs=*0x%x, queue=0x%x, port=*0x%x, isDynamic=%d)", spurs, queue, port, isDynamic);

	return _spurs::attach_lv2_eq(ppu, spurs, queue, port, isDynamic, false);
}

/// Detach an LV2 event queue from a SPURS instance
s32 cellSpursDetachLv2EventQueue(vm::ptr<CellSpurs> spurs, u8 port)
{
	cellSpurs.warning("cellSpursDetachLv2EventQueue(spurs=*0x%x, port=%d)", spurs, port);

	return _spurs::detach_lv2_eq(spurs, port, false);
}

s32 cellSpursEnableExceptionEventHandler(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, b8 flag)
{
	cellSpurs.warning("cellSpursEnableExceptionEventHandler(spurs=*0x%x, flag=%d)", spurs, flag);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	s32 rc = CELL_OK;
	auto oldEnableEH = spurs->enableEH.exchange(flag ? 1u : 0u);
	if (flag)
	{
		if (oldEnableEH == 0u)
		{
			rc = sys_spu_thread_group_connect_event(ppu, spurs->spuTG, spurs->eventQueue, SYS_SPU_THREAD_GROUP_EVENT_EXCEPTION);
		}
	}
	else
	{
		if (oldEnableEH == 1u)
		{
			rc = sys_spu_thread_group_disconnect_event(ppu, spurs->eventQueue, SYS_SPU_THREAD_GROUP_EVENT_EXCEPTION);
		}
	}

	return rc;
}

/// Set the global SPU exception event handler
s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursGlobalExceptionEventHandler> eaHandler, vm::ptr<void> arg)
{
	cellSpurs.warning("cellSpursSetGlobalExceptionEventHandler(spurs=*0x%x, eaHandler=*0x%x, arg=*0x%x)", spurs, eaHandler, arg);

	if (!spurs || !eaHandler)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	auto handler = spurs->globalSpuExceptionHandler.compare_and_swap(0, 1);
	if (handler)
	{
		return CELL_SPURS_CORE_ERROR_BUSY;
	}

	spurs->globalSpuExceptionHandlerArgs = arg.addr();
	spurs->globalSpuExceptionHandler.exchange(eaHandler.addr());
	return CELL_OK;
}

/// Remove the global SPU exception event handler
s32 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs)
{
	cellSpurs.warning("cellSpursUnsetGlobalExceptionEventHandler(spurs=*0x%x)", spurs);

	if (!spurs)
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_CORE_ERROR_ALIGN;

	if (spurs->exception)
		return CELL_SPURS_CORE_ERROR_STAT;

	spurs->globalSpuExceptionHandlerArgs = 0;
	spurs->globalSpuExceptionHandler.exchange(0);
	return CELL_OK;
}

/// Get internal information of a SPURS instance
s32 cellSpursGetInfo(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursInfo> info)
{
	cellSpurs.trace("cellSpursGetInfo(spurs=*0x%x, info=*0x%x)", spurs, info);

	if (!spurs || !info)
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_CORE_ERROR_ALIGN;

	const auto flags = spurs->flags;
	info->nSpus = spurs->nSpus;
	info->spuThreadGroupPriority = spurs->spuPriority;
	info->ppuThreadPriority = spurs->ppuPriority;
	info->exitIfNoWork = !!(flags & SAF_EXIT_IF_NO_WORK);
	info->spurs2 = !!(flags & SAF_SECOND_VERSION);
	info->spuThreadGroup = spurs->spuTG;
	std::memcpy(&info->spuThreads, &spurs->spus, sizeof(s32) * 8);
	info->spursHandlerThread0 = spurs->ppu0;
	info->spursHandlerThread1 = spurs->ppu1;
	info->traceBufferSize = spurs->traceDataSize;

	const auto trace_addr = vm::cast(spurs->traceBuffer.addr());
	info->traceBuffer = vm::addr_t{trace_addr & ~3};
	info->traceMode = trace_addr & 3;

	const u8 name_size = spurs->prefixSize;
	std::memcpy(&info->namePrefix, spurs->prefix, name_size);
	info->namePrefix[name_size] = '\0';
	info->namePrefixLength = name_size;

	// TODO: Should call sys_spu_thread_group_syscall_253 for specific SPU group types
	info->deadlineMeetCounter = 0;
	info->deadlineMissCounter = 0;
	return CELL_OK;
}

//----------------------------------------------------------------------------
// SPURS SPU GUID functions
//----------------------------------------------------------------------------

/// Get the SPU GUID from a .SpuGUID section
s32 cellSpursGetSpuGuid(vm::cptr<void> guid, vm::ptr<u64> dst)
{
	cellSpurs.trace("cellSpursGetSpuGuid(guid=*0x%x, dst=*0x%x)", guid, dst);

	if (!guid || !dst)
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;

	if (!dst.aligned())
		return CELL_SPURS_CORE_ERROR_ALIGN;

	return CELL_OK;
}

//----------------------------------------------------------------------------
// SPURS trace functions
//----------------------------------------------------------------------------

void _spurs::trace_status_update(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	u8 init;

	vm::atomic_op(spurs->sysSrvTrace, [spurs, &init](CellSpurs::SrvTraceSyncVar& data)
		{
			if ((init = data.sysSrvTraceInitialised))
			{
				data.sysSrvNotifyUpdateTraceComplete = 1;
				data.sysSrvMsgUpdateTrace = (1 << spurs->nSpus) - 1;
			}
		});

	if (init)
	{
		vm::light_op<true>(spurs->sysSrvMessage, [&](atomic_t<u8>& v)
			{
				v.release(0xff);
			});
		ensure(sys_semaphore_wait(ppu, static_cast<u32>(spurs->semPrv), 0) == 0);
		static_cast<void>(ppu.test_stopped());
	}
}

s32 _spurs::trace_initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> buffer, u32 size, u32 mode, u32 updateStatus)
{
	if (!spurs || !buffer)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned() || !buffer.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (size < sizeof(CellSpursTraceInfo) || mode & ~(CELL_SPURS_TRACE_MODE_FLAG_MASK))
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if (spurs->traceBuffer)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	spurs->traceDataSize = size - u32{sizeof(CellSpursTraceInfo)};
	for (u32 i = 0; i < 8; i++)
	{
		buffer->spuThread[i] = spurs->spus[i];
		buffer->count[i] = 0;
	}

	buffer->spuThreadGroup = spurs->spuTG;
	buffer->numSpus = spurs->nSpus;
	spurs->traceBuffer.set(buffer.addr() | (mode & CELL_SPURS_TRACE_MODE_FLAG_WRAP_BUFFER ? 1 : 0));
	spurs->traceMode = mode;

	u32 spuTraceDataCount = ::narrow<u32>((spurs->traceDataSize / sizeof(CellSpursTracePacket)) / spurs->nSpus);
	for (u32 i = 0, j = 8; i < 6; i++)
	{
		spurs->traceStartIndex[i] = j;
		j += spuTraceDataCount;
	}

	spurs->sysSrvTraceControl = 0;
	if (updateStatus)
	{
		_spurs::trace_status_update(ppu, spurs);
	}

	return CELL_OK;
}

/// Initialize SPURS trace
s32 cellSpursTraceInitialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> buffer, u32 size, u32 mode)
{
	cellSpurs.warning("cellSpursTraceInitialize(spurs=*0x%x, buffer=*0x%x, size=0x%x, mode=0x%x)", spurs, buffer, size, mode);

	if (_spurs::is_libprof_loaded())
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	return _spurs::trace_initialize(ppu, spurs, buffer, size, mode, 1);
}

/// Finalize SPURS trace
s32 cellSpursTraceFinalize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	cellSpurs.warning("cellSpursTraceFinalize(spurs=*0x%x)", spurs);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (!spurs->traceBuffer)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	spurs->sysSrvTraceControl = 0;
	spurs->traceMode = 0;
	spurs->traceBuffer = vm::null;

	_spurs::trace_status_update(ppu, spurs);

	return CELL_OK;
}

s32 _spurs::trace_start(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStatus)
{
	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (!spurs->traceBuffer)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	spurs->sysSrvTraceControl = 1;
	if (updateStatus)
	{
		_spurs::trace_status_update(ppu, spurs);
	}

	return CELL_OK;
}

/// Start SPURS trace
s32 cellSpursTraceStart(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	cellSpurs.warning("cellSpursTraceStart(spurs=*0x%x)", spurs);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	return _spurs::trace_start(ppu, spurs, spurs->traceMode & CELL_SPURS_TRACE_MODE_FLAG_SYNCHRONOUS_START_STOP);
}

s32 _spurs::trace_stop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStatus)
{
	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	if (!spurs->traceBuffer)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	spurs->sysSrvTraceControl = 2;
	if (updateStatus)
	{
		_spurs::trace_status_update(ppu, spurs);
	}

	return CELL_OK;
}

/// Stop SPURS trace
s32 cellSpursTraceStop(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	cellSpurs.warning("cellSpursTraceStop(spurs=*0x%x)", spurs);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	return _spurs::trace_stop(ppu, spurs, spurs->traceMode & CELL_SPURS_TRACE_MODE_FLAG_SYNCHRONOUS_START_STOP);
}

//----------------------------------------------------------------------------
// SPURS policy module functions
//----------------------------------------------------------------------------

/// Initialize attributes of a workload
s32 _cellSpursWorkloadAttributeInitialize(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
{
	cellSpurs.warning("_cellSpursWorkloadAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
		attr, revision, sdkVersion, pm, size, data, priority, minCnt, maxCnt);

	if (!attr)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (!pm)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!pm.aligned(16))
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	// Load packed priorities (endian-agnostic)
	const u64 prio = std::bit_cast<u64>(*priority);

	// check if some priority > 15
	if (minCnt == 0 || prio & 0xf0f0f0f0f0f0f0f0)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	std::memset(attr.get_ptr(), 0, sizeof(CellSpursWorkloadAttribute));
	attr->revision = revision;
	attr->sdkVersion = sdkVersion;
	attr->pm = pm;
	attr->size = size;
	attr->data = data;
	std::memcpy(attr->priority, &prio, 8);
	attr->minContention = minCnt;
	attr->maxContention = maxCnt;
	return CELL_OK;
}

/// Set the name of a workload
s32 cellSpursWorkloadAttributeSetName(ppu_thread& ppu, vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
{
	cellSpurs.warning("cellSpursWorkloadAttributeSetName(attr=*0x%x, nameClass=%s, nameInstance=%s)", attr, nameClass, nameInstance);

	if (!attr)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	attr->nameClass = nameClass;
	attr->nameInstance = nameInstance;
	return CELL_OK;
}

/// Set a hook function for shutdown completion event of a workload
s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWorkloadAttribute> attr, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> arg)
{
	cellSpurs.warning("cellSpursWorkloadAttributeSetShutdownCompletionEventHook(attr=*0x%x, hook=*0x%x, arg=*0x%x)", attr, hook, arg);

	if (!attr || !hook)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	attr->hook = hook;
	attr->hookArg = arg;
	return CELL_OK;
}

s32 _spurs::add_workload(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, const u8 (&priorityTable)[8], u32 minContention, u32 maxContention, vm::cptr<char> nameClass, vm::cptr<char> nameInstance, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> hookArg)
{
	if (!spurs || !wid || !pm)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned() || !pm.aligned(16))
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (minContention == 0 || std::bit_cast<u64>(priorityTable) & 0xf0f0f0f0f0f0f0f0ull) // check if some priority > 15
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	u32 wnum;
	const u32 wmax = spurs->flags1 & SF1_32_WORKLOADS ? CELL_SPURS_MAX_WORKLOAD2 : CELL_SPURS_MAX_WORKLOAD; // TODO: check if can be changed

	vm::fetch_op(spurs->wklEnabled, [&](be_t<u32>& value)
		{
			wnum = std::countl_one<u32>(value); // found empty position

			if (wnum < wmax)
			{
				value |= (0x80000000 >> wnum); // set workload bit
			}
		});

	*wid = wnum; // store workload id
	if (wnum >= wmax)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_AGAIN;
	}

	auto& spurs_res = vm::reservation_acquire(spurs.addr());
	auto& spurs_res2 = vm::reservation_acquire(spurs.addr() + 0x80);

	if (!spurs_res2.fetch_op([&](u64& r)
					   {
						   if (r & vm::rsrv_unique_lock)
						   {
							   return false;
						   }

						   r += 1;
						   return true;
					   })
			.second)
	{
		vm::reservation_shared_lock_internal(spurs_res2);
	}

	if (!spurs_res.fetch_op([&](u64& r)
					  {
						  if (r & vm::rsrv_unique_lock)
						  {
							  return false;
						  }

						  r += 1;
						  return true;
					  })
			.second)
	{
		vm::reservation_shared_lock_internal(spurs_res);
	}

	u32 index = wnum & 0xf;
	if (wnum <= 15)
	{
		ensure((spurs->wklCurrentContention[wnum] & 0xf) == 0);
		ensure((spurs->wklPendingContention[wnum] & 0xf) == 0);
		spurs->wklState1[wnum].release(SPURS_WKL_STATE_PREPARING);
		spurs->wklStatus1[wnum] = 0;
		spurs->wklEvent1[wnum].release(0);
		spurs->wklInfo1[wnum].addr = pm;
		spurs->wklInfo1[wnum].arg = data;
		spurs->wklInfo1[wnum].size = size;

		for (u32 i = 0; i < 8; i++)
		{
			spurs->wklInfo1[wnum].priority[i] = priorityTable[i];
		}

		spurs->wklH1[wnum].nameClass = nameClass;
		spurs->wklH1[wnum].nameInstance = nameInstance;
		memset(spurs->wklF1[wnum].unk0, 0, 0x20); // clear struct preserving semaphore id
		memset(&spurs->wklF1[wnum].x28, 0, 0x58);

		if (hook)
		{
			spurs->wklF1[wnum].hook = hook;
			spurs->wklF1[wnum].hookArg = hookArg;
			spurs->wklEvent1[wnum] |= 2;
		}

		if ((spurs->flags1 & SF1_32_WORKLOADS) == 0)
		{
			spurs->wklIdleSpuCountOrReadyCount2[wnum] = 0;
			spurs->wklMinContention[wnum] = minContention > 8 ? 8 : minContention;
		}

		spurs->wklReadyCount1[wnum].release(0);
	}
	else
	{
		ensure((spurs->wklCurrentContention[index] & 0xf0) == 0);
		ensure((spurs->wklPendingContention[index] & 0xf0) == 0);
		spurs->wklState2[index].release(SPURS_WKL_STATE_PREPARING);
		spurs->wklStatus2[index] = 0;
		spurs->wklEvent2[index].release(0);
		spurs->wklInfo2[index].addr = pm;
		spurs->wklInfo2[index].arg = data;
		spurs->wklInfo2[index].size = size;

		for (u32 i = 0; i < 8; i++)
		{
			spurs->wklInfo2[index].priority[i] = priorityTable[i];
		}

		spurs->wklH2[index].nameClass = nameClass;
		spurs->wklH2[index].nameInstance = nameInstance;
		memset(spurs->wklF2[index].unk0, 0, 0x20); // clear struct preserving semaphore id
		memset(&spurs->wklF2[index].x28, 0, 0x58);

		if (hook)
		{
			spurs->wklF2[index].hook = hook;
			spurs->wklF2[index].hookArg = hookArg;
			spurs->wklEvent2[index] |= 2;
		}

		spurs->wklIdleSpuCountOrReadyCount2[wnum].release(0);
	}

	spurs->wklMaxContention[index].atomic_op([&](u8& v)
		{
			v &= (wnum <= 15 ? 0xf0 : 0x0f);
			v |= (maxContention > 8 ? 8 : maxContention) << (wnum < CELL_SPURS_MAX_WORKLOAD ? 0 : 4);
		});

	(wnum <= 15 ? spurs->wklSignal1 : spurs->wklSignal2).atomic_op([&](be_t<u16>& data)
		{
			data &= ~(0x8000 >> index);
		});

	// Attempt to avoid CAS
	if (spurs->wklFlagReceiver == wnum && spurs->wklFlagReceiver.compare_and_swap(wnum, 0xff))
	{
		//
	}

	spurs_res += 127;
	spurs_res2 += 127;

	spurs_res.notify_all();
	spurs_res2.notify_all();

	u32 res_wkl;
	const auto wkl = &spurs->wklInfo(wnum);
	vm::reservation_op(ppu, vm::unsafe_ptr_cast<spurs_wkl_state_op>(spurs.ptr(&CellSpurs::wklState1)), [&](spurs_wkl_state_op& op)
		{
			const u32 mask = op.wklMskB & ~(0x80000000u >> wnum);
			res_wkl = 0;

			for (u32 i = 0, m = 0x80000000, k = 0; i < 32; i++, m >>= 1)
			{
				if (mask & m)
				{
					const auto current = &spurs->wklInfo(i);
					if (current->addr == wkl->addr)
					{
						// if a workload with identical policy module found
						res_wkl = current->uniqueId;
						break;
					}
					else
					{
						k |= 0x80000000 >> current->uniqueId;
						res_wkl = std::countl_one<u32>(k);
					}
				}
			}

			wkl->uniqueId.release(static_cast<u8>(res_wkl));
			op.wklMskB = mask | (0x80000000u >> wnum);
			(wnum < CELL_SPURS_MAX_WORKLOAD ? op.wklState1[wnum] : op.wklState2[wnum % 16]) = SPURS_WKL_STATE_RUNNABLE;
		});

	ensure((res_wkl <= 31));
	vm::light_op<true>(spurs->sysSrvMsgUpdateWorkload, [](atomic_t<u8>& v)
		{
			v.release(0xff);
		});
	vm::light_op<true>(spurs->sysSrvMessage, [](atomic_t<u8>& v)
		{
			v.release(0xff);
		});
	return CELL_OK;
}

/// Add workload
s32 cellSpursAddWorkload(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
{
	cellSpurs.trace("cellSpursAddWorkload(spurs=*0x%x, wid=*0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
		spurs, wid, pm, size, data, priority, minCnt, maxCnt);

	return _spurs::add_workload(ppu, spurs, wid, pm, size, data, *priority, minCnt, maxCnt, vm::null, vm::null, vm::null, vm::null);
}

/// Add workload
s32 cellSpursAddWorkloadWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<CellSpursWorkloadAttribute> attr)
{
	cellSpurs.trace("cellSpursAddWorkloadWithAttribute(spurs=*0x%x, wid=*0x%x, attr=*0x%x)", spurs, wid, attr);

	if (!attr)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (attr->revision != 1u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	return _spurs::add_workload(ppu, spurs, wid, attr->pm, attr->size, attr->data, attr->priority, attr->minContention, attr->maxContention, attr->nameClass, attr->nameInstance, attr->hook, attr->hookArg);
}

/// Request workload shutdown
s32 cellSpursShutdownWorkload(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
{
	cellSpurs.trace("cellSpursShutdownWorkload(spurs=*0x%x, wid=0x%x)", spurs, wid);

	if (!spurs)
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;

	if (wid >= spurs->max_workloads())
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;

	if (spurs->exception)
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;

	bool send_event;
	s32 rc, old_state;
	if (!vm::reservation_op(ppu, vm::unsafe_ptr_cast<spurs_wkl_state_op>(spurs.ptr(&CellSpurs::wklState1)), [&](spurs_wkl_state_op& op)
			{
				auto& state = wid < CELL_SPURS_MAX_WORKLOAD ? op.wklState1[wid] : op.wklState2[wid % 16];

				if (state <= SPURS_WKL_STATE_PREPARING)
				{
					rc = CELL_SPURS_POLICY_MODULE_ERROR_STAT;
					return false;
				}

				if (state == SPURS_WKL_STATE_SHUTTING_DOWN || state == SPURS_WKL_STATE_REMOVABLE)
				{
					rc = CELL_OK;
					return false;
				}

				auto& status = wid < CELL_SPURS_MAX_WORKLOAD ? op.wklStatus1[wid] : op.wklStatus2[wid % 16];

				old_state = state = status ? SPURS_WKL_STATE_SHUTTING_DOWN : SPURS_WKL_STATE_REMOVABLE;

				if (state == SPURS_WKL_STATE_SHUTTING_DOWN)
				{
					op.sysSrvMsgUpdateWorkload = -1;
					rc = CELL_OK;
					return true;
				}

				auto& event = wid < CELL_SPURS_MAX_WORKLOAD ? op.wklEvent1[wid] : op.wklEvent2[wid % 16];
				send_event = event & 0x12 && !(event & 1);
				event |= 1;
				rc = CELL_OK;
				return true;
			}))
	{
		return rc;
	}

	if (old_state == SPURS_WKL_STATE_SHUTTING_DOWN)
	{
		vm::light_op<true>(spurs->sysSrvMessage, [&](atomic_t<u8>& v)
			{
				v.release(0xff);
			});
		return CELL_OK;
	}

	if (send_event && sys_event_port_send(spurs->eventPort, 0, 0, (1u << 31) >> wid))
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	return CELL_OK;
}

/// Wait for workload shutdown
s32 cellSpursWaitForWorkloadShutdown(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
{
	cellSpurs.trace("cellSpursWaitForWorkloadShutdown(spurs=*0x%x, wid=0x%x)", spurs, wid);

	if (!spurs)
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;

	if (wid >= spurs->max_workloads())
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;

	if (!(spurs->wklEnabled & (0x80000000u >> wid)))
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;

	if (spurs->exception)
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;

	auto& info = spurs->wklSyncInfo(wid);

	const auto [_old0, ok] = vm::fetch_op(info.x28, [](be_t<u32>& val)
		{
			if (val)
			{
				return false;
			}

			val = 2;
			return true;
		});

	if (!ok)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	const auto [_old1, wait_sema] = vm::fetch_op<true>(spurs->wklEvent(wid), [](u8& event)
		{
			if ((event & 1) == 0 || (event & 0x22) == 0x2)
			{
				event |= 0x10;
				return true;
			}

			return false;
		});

	if (wait_sema)
	{
		ensure(sys_semaphore_wait(ppu, static_cast<u32>(info.sem), 0) == 0);
	}

	// Reverified
	if (spurs->exception)
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;

	return CELL_OK;
}

s32 cellSpursRemoveSystemWorkloadForUtility()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

/// Remove workload
s32 cellSpursRemoveWorkload(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
{
	cellSpurs.trace("cellSpursRemoveWorkload(spurs=*0x%x, wid=%u)", spurs, wid);

	if (!spurs)
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;

	if (!spurs.aligned())
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2 || (wid >= CELL_SPURS_MAX_WORKLOAD && (spurs->flags1 & SF1_32_WORKLOADS) == 0))
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;

	if (!(spurs->wklEnabled.load() & (0x80000000u >> wid)))
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;

	if (spurs->exception)
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;

	switch (spurs->wklState(wid))
	{
	case SPURS_WKL_STATE_SHUTTING_DOWN: return CELL_SPURS_POLICY_MODULE_ERROR_BUSY;
	case SPURS_WKL_STATE_REMOVABLE: break;
	default: return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	if (spurs->wklFlagReceiver == wid)
	{
		ensure(ppu_execute<&_cellSpursWorkloadFlagReceiver>(ppu, spurs, wid, 0) == 0);
	}

	s32 rc;
	vm::reservation_op(ppu, vm::unsafe_ptr_cast<spurs_wkl_state_op>(spurs.ptr(&CellSpurs::wklState1)), [&](spurs_wkl_state_op& op)
		{
			auto& state = wid < CELL_SPURS_MAX_WORKLOAD ? op.wklState1[wid] : op.wklState2[wid % 16];

			// Re-verification, does not exist on realfw
			switch (state)
			{
			case SPURS_WKL_STATE_SHUTTING_DOWN: rc = CELL_SPURS_POLICY_MODULE_ERROR_BUSY; return false;
			case SPURS_WKL_STATE_REMOVABLE: break;
			default: rc = CELL_SPURS_POLICY_MODULE_ERROR_STAT; return false;
			}

			state = SPURS_WKL_STATE_NON_EXISTENT;

			op.wklEnabled &= ~(0x80000000u >> wid);
			op.wklMskB &= ~(0x80000000u >> wid);
			rc = CELL_OK;
			return true;
		});

	return rc;
}

s32 cellSpursWakeUp(ppu_thread& ppu, vm::ptr<CellSpurs> spurs)
{
	cellSpurs.warning("cellSpursWakeUp(spurs=*0x%x)", spurs);

	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	spurs->handlerDirty.exchange(1);

	if (spurs->handlerWaiting)
	{
		_spurs::signal_to_handler_thread(ppu, spurs);
	}

	return CELL_OK;
}

/// Send a workload signal
s32 cellSpursSendWorkloadSignal(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid)
{
	cellSpurs.warning("cellSpursSendWorkloadSignal(spurs=*0x%x, wid=%d)", spurs, wid);

	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= CELL_SPURS_MAX_WORKLOAD2 || (wid >= CELL_SPURS_MAX_WORKLOAD && (spurs->flags1 & SF1_32_WORKLOADS) == 0))
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if (!(spurs->wklEnabled.load() & (0x80000000u >> wid)))
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	if (spurs->wklState(wid) != SPURS_WKL_STATE_RUNNABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	vm::light_op<true>(wid < CELL_SPURS_MAX_WORKLOAD ? spurs->wklSignal1 : spurs->wklSignal2, [&](atomic_be_t<u16>& sig)
		{
			sig |= 0x8000 >> (wid % 16);
		});

	return CELL_OK;
}

/// Get the address of the workload flag
s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloadFlag> flag)
{
	cellSpurs.warning("cellSpursGetWorkloadFlag(spurs=*0x%x, flag=**0x%x)", spurs, flag);

	if (!spurs || !flag)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	*flag = spurs.ptr(&CellSpurs::wklFlag);
	return CELL_OK;
}

/// Set ready count
s32 cellSpursReadyCountStore(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
{
	cellSpurs.trace("cellSpursReadyCountStore(spurs=*0x%x, wid=%d, value=0x%x)", spurs, wid, value);

	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads() || value > 0xffu)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception || spurs->wklState(wid) != SPURS_WKL_STATE_RUNNABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	vm::light_op<true>(spurs->readyCount(wid), [&](atomic_t<u8>& v)
		{
			v.release(static_cast<u8>(value));
		});

	return CELL_OK;
}

/// Swap ready count
s32 cellSpursReadyCountSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 swap)
{
	cellSpurs.trace("cellSpursReadyCountSwap(spurs=*0x%x, wid=%d, old=*0x%x, swap=0x%x)", spurs, wid, old, swap);

	if (!spurs || !old)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads() || swap > 0xffu)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception || spurs->wklState(wid) != SPURS_WKL_STATE_RUNNABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	*old = vm::light_op(spurs->readyCount(wid), [&](atomic_t<u8>& v)
		{
			return v.exchange(static_cast<u8>(swap));
		});

	return CELL_OK;
}

/// Compare and swap ready count
s32 cellSpursReadyCountCompareAndSwap(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, u32 compare, u32 swap)
{
	cellSpurs.trace("cellSpursReadyCountCompareAndSwap(spurs=*0x%x, wid=%d, old=*0x%x, compare=0x%x, swap=0x%x)", spurs, wid, old, compare, swap);

	if (!spurs || !old)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads() || (swap | compare) > 0xffu)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception || spurs->wklState(wid) != SPURS_WKL_STATE_RUNNABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	u8 temp = static_cast<u8>(compare);

	vm::light_op(spurs->readyCount(wid), [&](atomic_t<u8>& v)
		{
			v.compare_exchange(temp, static_cast<u8>(swap));
		});

	*old = temp;
	return CELL_OK;
}

/// Increase or decrease ready count
s32 cellSpursReadyCountAdd(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<u32> old, s32 value)
{
	cellSpurs.trace("cellSpursReadyCountAdd(spurs=*0x%x, wid=%d, old=*0x%x, value=0x%x)", spurs, wid, old, value);

	if (!spurs || !old)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception || spurs->wklState(wid) != SPURS_WKL_STATE_RUNNABLE)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	*old = vm::fetch_op(spurs->readyCount(wid), [&](u8& val)
		{
			val = static_cast<u8>(std::clamp<s32>(val + static_cast<u32>(value), 0, 255));
		});

	return CELL_OK;
}

/// Get workload's data to be passed to policy module
s32 cellSpursGetWorkloadData(vm::ptr<CellSpurs> spurs, vm::ptr<u64> data, u32 wid)
{
	cellSpurs.trace("cellSpursGetWorkloadData(spurs=*0x%x, data=*0x%x, wid=%d)", spurs, data, wid);

	if (!spurs || !data)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= CELL_SPURS_MAX_WORKLOAD2 || (wid >= CELL_SPURS_MAX_WORKLOAD && (spurs->flags1 & SF1_32_WORKLOADS) == 0))
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	if (wid >= CELL_SPURS_MAX_WORKLOAD)
	{
		*data = spurs->wklInfo2[wid & 0x0F].arg;
	}
	else
	{
		*data = spurs->wklInfo1[wid].arg;
	}

	return CELL_OK;
}

/// Get workload information
s32 cellSpursGetWorkloadInfo(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<CellSpursWorkloadInfo> info)
{
	cellSpurs.todo("cellSpursGetWorkloadInfo(spurs=*0x%x, wid=0x%x, info=*0x%x)", spurs, wid, info);
	return CELL_OK;
}

/// Set the SPU exception event handler
s32 cellSpursSetExceptionEventHandler()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

/// Disable the SPU exception event handler
s32 cellSpursUnsetExceptionEventHandler()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

/// Set/unset the recipient of the workload flag
s32 _cellSpursWorkloadFlagReceiver(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set)
{
	cellSpurs.warning("_cellSpursWorkloadFlagReceiver(spurs=*0x%x, wid=%d, is_set=%d)", spurs, wid, is_set);

	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	atomic_fence_acq_rel();

	struct alignas(128) wklFlagOp
	{
		u8 uns[0x6C];
		be_t<u32> Flag; // 0x6C
		u8 uns2[0x7];
		u8 FlagReceiver; // 0x77
	};

	s32 res = CELL_OK;

	vm::reservation_op(ppu, vm::unsafe_ptr_cast<wklFlagOp>(spurs), [&](wklFlagOp& val)
		{
			if (is_set)
			{
				if (val.FlagReceiver != 0xff)
				{
					res = CELL_SPURS_POLICY_MODULE_ERROR_BUSY;
					return;
				}
			}
			else
			{
				if (val.FlagReceiver != wid)
				{
					res = CELL_SPURS_POLICY_MODULE_ERROR_PERM;
					return;
				}
			}

			val.Flag = -1;

			if (is_set)
			{
				if (val.FlagReceiver == 0xff)
				{
					val.FlagReceiver = static_cast<u8>(wid);
				}
			}
			else
			{
				if (val.FlagReceiver == wid)
				{
					val.FlagReceiver = 0xff;
				}
			}

			res = CELL_OK;
		});

	return res;
}

/// Set/unset the recipient of the workload flag
s32 _cellSpursWorkloadFlagReceiver2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set, u32 print_debug_output)
{
	cellSpurs.warning("_cellSpursWorkloadFlagReceiver2(spurs=*0x%x, wid=%d, is_set=%d, print_debug_output=%d)", spurs, wid, is_set, print_debug_output);

	if (!spurs)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
	}

	if (wid >= spurs->max_workloads())
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_POLICY_MODULE_ERROR_STAT;
	}

	atomic_fence_acq_rel();

	s32 res = CELL_OK;

	vm::atomic_op<true>(spurs->wklFlagReceiver, [&](u8& FlagReceiver)
		{
			if (is_set)
			{
				if (FlagReceiver != 0xff)
				{
					res = CELL_SPURS_POLICY_MODULE_ERROR_BUSY;
					return;
				}
			}
			else
			{
				if (FlagReceiver != wid)
				{
					res = CELL_SPURS_POLICY_MODULE_ERROR_PERM;
					return;
				}
			}

			if (is_set)
			{
				if (FlagReceiver == 0xff)
				{
					FlagReceiver = static_cast<u8>(wid);
				}
			}
			else
			{
				if (FlagReceiver == wid)
				{
					FlagReceiver = 0xff;
				}
			}

			res = CELL_OK;
		});

	return res;
}

/// Request assignment of idle SPUs
s32 cellSpursRequestIdleSpu(vm::ptr<CellSpurs> spurs, u32 wid, u32 count)
{
	cellSpurs.trace("cellSpursRequestIdleSpu(spurs=*0x%x, wid=%d, count=%d)", spurs, wid, count);

	if (!spurs)
	{
		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned())
	{
		return CELL_SPURS_CORE_ERROR_ALIGN;
	}

	// Old API: This function doesn't support 32 workloads
	if (spurs->flags1 & SF1_32_WORKLOADS)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (wid >= CELL_SPURS_MAX_WORKLOAD || count >= CELL_SPURS_MAX_SPU)
	{
		return CELL_SPURS_CORE_ERROR_INVAL;
	}

	if ((spurs->wklEnabled.load() & (0x80000000u >> wid)) == 0u)
	{
		return CELL_SPURS_CORE_ERROR_SRCH;
	}

	if (spurs->exception)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	vm::light_op<true>(spurs->wklIdleSpuCountOrReadyCount2[wid], FN(x.release(static_cast<u8>(count))));
	return CELL_OK;
}

//----------------------------------------------------------------------------
// SPURS event flag functions
//----------------------------------------------------------------------------

/// Initialize a SPURS event flag
s32 _cellSpursEventFlagInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
{
	cellSpurs.warning("_cellSpursEventFlagInitialize(spurs=*0x%x, taskset=*0x%x, eventFlag=*0x%x, flagClearMode=%d, flagDirection=%d)", spurs, taskset, eventFlag, flagClearMode, flagDirection);

	if ((!taskset && !spurs) || !eventFlag)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned() || !taskset.aligned() || !eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (taskset && taskset->wid >= CELL_SPURS_MAX_WORKLOAD2)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	if (flagDirection > CELL_SPURS_EVENT_FLAG_LAST || flagClearMode > CELL_SPURS_EVENT_FLAG_CLEAR_LAST)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	memset(eventFlag.get_ptr(), 0, sizeof(CellSpursEventFlag));
	eventFlag->direction = flagDirection;
	eventFlag->clearMode = flagClearMode;
	eventFlag->spuPort = CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT;

	if (taskset)
	{
		eventFlag->addr = taskset.addr();
	}
	else
	{
		eventFlag->isIwl = 1;
		eventFlag->addr = spurs.addr();
	}

	return CELL_OK;
}

/// Reset a SPURS event flag
s32 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
{
	cellSpurs.warning("cellSpursEventFlagClear(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);

	if (!eventFlag)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	eventFlag->events &= ~bits;
	return CELL_OK;
}

/// Set a SPURS event flag
s32 cellSpursEventFlagSet(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
{
	cellSpurs.trace("cellSpursEventFlagSet(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);

	if (!eventFlag)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (auto dir = eventFlag->direction; dir != CELL_SPURS_EVENT_FLAG_SPU2PPU && dir != CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		return CELL_SPURS_TASK_ERROR_PERM;
	}

	bool send;
	u8 ppuWaitSlot;
	u16 ppuEvents;
	u16 pendingRecv;
	u16 pendingRecvTaskEvents[16];

	vm::reservation_op(ppu, vm::unsafe_ptr_cast<CellSpursEventFlag_x00>(eventFlag), [bits, &send, &ppuWaitSlot, &ppuEvents, &pendingRecv, &pendingRecvTaskEvents](CellSpursEventFlag_x00& eventFlag)
		{
			send = false;
			ppuWaitSlot = 0;
			ppuEvents = 0;
			pendingRecv = 0;

			u16 eventsToClear = 0;

			auto& ctrl = eventFlag.ctrl;
			if (eventFlag.direction == CELL_SPURS_EVENT_FLAG_ANY2ANY && ctrl.ppuWaitMask)
			{
				u16 ppuRelevantEvents = (ctrl.events | bits) & ctrl.ppuWaitMask;

				// Unblock the waiting PPU thread if either all the bits being waited by the thread have been set or
			    // if the wait mode of the thread is OR and atleast one bit the thread is waiting on has been set
				if ((ctrl.ppuWaitMask & ~ppuRelevantEvents) == 0 ||
					((ctrl.ppuWaitSlotAndMode & 0x0F) == CELL_SPURS_EVENT_FLAG_OR && ppuRelevantEvents != 0))
				{
					ctrl.ppuPendingRecv = 1;
					ctrl.ppuWaitMask = 0;
					ppuEvents = ppuRelevantEvents;
					eventsToClear = ppuRelevantEvents;
					ppuWaitSlot = ctrl.ppuWaitSlotAndMode >> 4;
					send = true;
				}
			}

			s32 i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
			s32 j = 0;
			u16 relevantWaitSlots = eventFlag.spuTaskUsedWaitSlots & ~ctrl.spuTaskPendingRecv;
			while (relevantWaitSlots)
			{
				if (relevantWaitSlots & 0x0001)
				{
					u16 spuTaskRelevantEvents = (ctrl.events | bits) & eventFlag.spuTaskWaitMask[i];

					// Unblock the waiting SPU task if either all the bits being waited by the task have been set or
				    // if the wait mode of the task is OR and atleast one bit the thread is waiting on has been set
					if ((eventFlag.spuTaskWaitMask[i] & ~spuTaskRelevantEvents) == 0 ||
						(((eventFlag.spuTaskWaitMode >> j) & 0x0001) == CELL_SPURS_EVENT_FLAG_OR && spuTaskRelevantEvents != 0))
					{
						eventsToClear |= spuTaskRelevantEvents;
						pendingRecv |= 1 << j;
						pendingRecvTaskEvents[j] = spuTaskRelevantEvents;
					}
				}

				relevantWaitSlots >>= 1;
				i--;
				j++;
			}

			ctrl.events |= bits;
			ctrl.spuTaskPendingRecv |= pendingRecv;

			// If the clear flag is AUTO then clear the bits comnsumed by all tasks marked to be unblocked
			if (eventFlag.clearMode == CELL_SPURS_EVENT_FLAG_CLEAR_AUTO)
			{
				ctrl.events &= ~eventsToClear;
			}

			// eventFlagControl = ((u64)events << 48) | ((u64)spuTaskPendingRecv << 32) | ((u64)ppuWaitMask << 16) | ((u64)ppuWaitSlotAndMode << 8) | (u64)ppuPendingRecv;
		});

	if (send)
	{
		// Signal the PPU thread to be woken up
		eventFlag->pendingRecvTaskEvents[ppuWaitSlot] = ppuEvents;

		ensure(sys_event_port_send(eventFlag->eventPortId, 0, 0, 0) == 0);
		static_cast<void>(ppu.test_stopped());
	}

	if (pendingRecv)
	{
		// Signal each SPU task whose conditions have been met to be woken up
		for (s32 i = 0; i < CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS; i++)
		{
			if (pendingRecv & (0x8000 >> i))
			{
				eventFlag->pendingRecvTaskEvents[i] = pendingRecvTaskEvents[i];
				vm::var<vm::ptr<CellSpursTaskset>> taskset;
				if (eventFlag->isIwl)
				{
					cellSpursLookUpTasksetAddress(ppu, vm::cast(eventFlag->addr), taskset, eventFlag->waitingTaskWklId[i]);
				}
				else
				{
					*taskset = vm::cast(eventFlag->addr);
				}

				auto rc = _cellSpursSendSignal(ppu, *taskset, eventFlag->waitingTaskId[i]);
				if (rc + 0u == CELL_SPURS_TASK_ERROR_INVAL || rc + 0u == CELL_SPURS_TASK_ERROR_STAT)
				{
					return CELL_SPURS_TASK_ERROR_FATAL;
				}

				ensure(rc == CELL_OK);
			}
		}
	}

	return CELL_OK;
}

s32 _spurs::event_flag_wait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode, u32 block)
{
	if (!eventFlag || !mask)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (mode > CELL_SPURS_EVENT_FLAG_WAIT_MODE_LAST)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	if (auto dir = eventFlag->direction; dir != CELL_SPURS_EVENT_FLAG_SPU2PPU && dir != CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		return CELL_SPURS_TASK_ERROR_PERM;
	}

	if (block && eventFlag->spuPort == CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT)
	{
		return CELL_SPURS_TASK_ERROR_STAT;
	}

	if (eventFlag->ctrl.raw().ppuWaitMask || eventFlag->ctrl.raw().ppuPendingRecv)
	{
		return CELL_SPURS_TASK_ERROR_BUSY;
	}

	bool recv;
	s32 rc;
	u16 receivedEvents;
	vm::atomic_op(eventFlag->ctrl, [eventFlag, mask, mode, block, &recv, &rc, &receivedEvents](CellSpursEventFlag::ControlSyncVar& ctrl)
		{
			u16 relevantEvents = ctrl.events & *mask;
			if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
			{
				// Make sure the wait mask and mode specified does not conflict with that of the already waiting tasks.
			    // Conflict scenarios:
			    // OR  vs OR  - A conflict never occurs
			    // OR  vs AND - A conflict occurs if the masks for the two tasks overlap
			    // AND vs AND - A conflict occurs if the masks for the two tasks are not the same

				// Determine the set of all already waiting tasks whose wait mode/mask can possibly conflict with the specified wait mode/mask.
			    // This set is equal to 'set of all tasks waiting' - 'set of all tasks whose wait conditions have been met'.
			    // If the wait mode is OR, we prune the set of all tasks that are waiting in OR mode from the set since a conflict cannot occur
			    // with an already waiting task in OR mode.
				u16 relevantWaitSlots = eventFlag->spuTaskUsedWaitSlots & ~ctrl.spuTaskPendingRecv;
				if (mode == CELL_SPURS_EVENT_FLAG_OR)
				{
					relevantWaitSlots &= eventFlag->spuTaskWaitMode;
				}

				s32 i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
				while (relevantWaitSlots)
				{
					if (relevantWaitSlots & 0x0001)
					{
						if (eventFlag->spuTaskWaitMask[i] & *mask && eventFlag->spuTaskWaitMask[i] != *mask)
						{
							rc = CELL_SPURS_TASK_ERROR_AGAIN;
							return;
						}
					}

					relevantWaitSlots >>= 1;
					i--;
				}
			}

			// There is no need to block if all bits required by the wait operation have already been set or
		    // if the wait mode is OR and atleast one of the bits required by the wait operation has been set.
			if ((*mask & ~relevantEvents) == 0 || (mode == CELL_SPURS_EVENT_FLAG_OR && relevantEvents))
			{
				// If the clear flag is AUTO then clear the bits comnsumed by this thread
				if (eventFlag->clearMode == CELL_SPURS_EVENT_FLAG_CLEAR_AUTO)
				{
					ctrl.events &= ~relevantEvents;
				}

				recv = false;
				receivedEvents = relevantEvents;
			}
			else
			{
				// If we reach here it means that the conditions for this thread have not been met.
			    // If this is a try wait operation then do not block but return an error code.
				if (block == 0)
				{
					rc = CELL_SPURS_TASK_ERROR_BUSY;
					return;
				}

				ctrl.ppuWaitSlotAndMode = 0;
				if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
				{
					// Find an unsed wait slot
					s32 i = 0;
					u16 spuTaskUsedWaitSlots = eventFlag->spuTaskUsedWaitSlots;
					while (spuTaskUsedWaitSlots & 0x0001)
					{
						spuTaskUsedWaitSlots >>= 1;
						i++;
					}

					if (i == CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS)
					{
						// Event flag has no empty wait slots
						rc = CELL_SPURS_TASK_ERROR_BUSY;
						return;
					}

					// Mark the found wait slot as used by this thread
					ctrl.ppuWaitSlotAndMode = (CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1 - i) << 4;
				}

				// Save the wait mask and mode for this thread
				ctrl.ppuWaitSlotAndMode |= mode;
				ctrl.ppuWaitMask = *mask;

				recv = true;
			}

			// eventFlagControl = ((u64)events << 48) | ((u64)spuTaskPendingRecv << 32) | ((u64)ppuWaitMask << 16) | ((u64)ppuWaitSlotAndMode << 8) | (u64)ppuPendingRecv;
			rc = CELL_OK;
		});

	if (rc != CELL_OK)
	{
		return rc;
	}

	if (recv)
	{
		// Block till something happens
		ensure(sys_event_queue_receive(ppu, eventFlag->eventQueueId, vm::null, 0) == 0);
		static_cast<void>(ppu.test_stopped());

		s32 i = 0;
		if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
		{
			i = eventFlag->ctrl.raw().ppuWaitSlotAndMode >> 4;
		}

		*mask = eventFlag->pendingRecvTaskEvents[i];
		vm::atomic_op(eventFlag->ctrl, [](CellSpursEventFlag::ControlSyncVar& ctrl)
			{
				ctrl.ppuPendingRecv = 0;
			});
	}

	*mask = receivedEvents;
	return CELL_OK;
}

/// Wait for SPURS event flag
s32 cellSpursEventFlagWait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode)
{
	cellSpurs.warning("cellSpursEventFlagWait(eventFlag=*0x%x, mask=*0x%x, mode=%d)", eventFlag, mask, mode);

	return _spurs::event_flag_wait(ppu, eventFlag, mask, mode, 1);
}

/// Check SPURS event flag
s32 cellSpursEventFlagTryWait(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode)
{
	cellSpurs.warning("cellSpursEventFlagTryWait(eventFlag=*0x%x, mask=*0x%x, mode=0x%x)", eventFlag, mask, mode);

	return _spurs::event_flag_wait(ppu, eventFlag, mask, mode, 0);
}

/// Attach an LV2 event queue to a SPURS event flag
s32 cellSpursEventFlagAttachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag)
{
	cellSpurs.warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag=*0x%x)", eventFlag);

	if (!eventFlag)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_AGAIN;
	}

	if (eventFlag->direction != CELL_SPURS_EVENT_FLAG_SPU2PPU && eventFlag->direction != CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		return CELL_SPURS_TASK_ERROR_PERM;
	}

	if (eventFlag->spuPort != CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT)
	{
		return CELL_SPURS_TASK_ERROR_STAT;
	}

	vm::ptr<CellSpurs> spurs;
	if (eventFlag->isIwl == 1)
	{
		spurs = vm::cast(eventFlag->addr);
	}
	else
	{
		auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr));
		spurs = taskset->spurs;
	}

	vm::var<u32> eventQueueId;
	vm::var<u8> port;

	auto failure = [](s32 rc) -> s32
	{
		// Return rc if its an error code from SPURS otherwise convert the error code to a SPURS task error code
		return (rc & 0x0FFF0000) == 0x00410000 ? rc : (0x80410900 | (rc & 0xFF));
	};

	if (s32 rc = _spurs::create_lv2_eq(ppu, spurs, eventQueueId, port, 1, sys_event_queue_attribute_t{SYS_SYNC_PRIORITY, SYS_PPU_QUEUE, {"_spuEvF\0"_u64}}))
	{
		return failure(rc);
	}

	auto success = [&]
	{
		eventFlag->eventQueueId = *eventQueueId;
		eventFlag->spuPort = *port;
	};

	if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		vm::var<u32> eventPortId;

		s32 rc = sys_event_port_create(ppu, eventPortId, SYS_EVENT_PORT_LOCAL, 0);
		if (rc == CELL_OK)
		{
			rc = sys_event_port_connect_local(ppu, *eventPortId, *eventQueueId);
			if (rc == CELL_OK)
			{
				eventFlag->eventPortId = *eventPortId;
				return success(), CELL_OK;
			}

			sys_event_port_destroy(ppu, *eventPortId);
		}

		if (_spurs::detach_lv2_eq(spurs, *port, true) == CELL_OK)
		{
			sys_event_queue_destroy(ppu, *eventQueueId, SYS_EVENT_QUEUE_DESTROY_FORCE);
		}

		return failure(rc);
	}

	return success(), CELL_OK;
}

/// Detach an LV2 event queue from SPURS event flag
s32 cellSpursEventFlagDetachLv2EventQueue(ppu_thread& ppu, vm::ptr<CellSpursEventFlag> eventFlag)
{
	cellSpurs.warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag=*0x%x)", eventFlag);

	if (!eventFlag)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_AGAIN;
	}

	if (eventFlag->direction != CELL_SPURS_EVENT_FLAG_SPU2PPU && eventFlag->direction != CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		return CELL_SPURS_TASK_ERROR_PERM;
	}

	if (eventFlag->spuPort == CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT)
	{
		return CELL_SPURS_TASK_ERROR_STAT;
	}

	if (eventFlag->ctrl.raw().ppuWaitMask || eventFlag->ctrl.raw().ppuPendingRecv)
	{
		return CELL_SPURS_TASK_ERROR_BUSY;
	}

	const u8 port = eventFlag->spuPort;

	eventFlag->spuPort = CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT;

	vm::ptr<CellSpurs> spurs;
	if (eventFlag->isIwl == 1)
	{
		spurs = vm::cast(eventFlag->addr);
	}
	else
	{
		auto taskset = vm::ptr<CellSpursTaskset>::make(vm::cast(eventFlag->addr));
		spurs = taskset->spurs;
	}

	if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
	{
		sys_event_port_disconnect(ppu, eventFlag->eventPortId);
		sys_event_port_destroy(ppu, eventFlag->eventPortId);
	}

	s32 rc = _spurs::detach_lv2_eq(spurs, port, true);

	if (rc == CELL_OK)
	{
		rc = sys_event_queue_destroy(ppu, eventFlag->eventQueueId, SYS_EVENT_QUEUE_DESTROY_FORCE);
	}

	return CELL_OK;
}

/// Get send-receive direction of the SPURS event flag
s32 cellSpursEventFlagGetDirection(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> direction)
{
	cellSpurs.warning("cellSpursEventFlagGetDirection(eventFlag=*0x%x, direction=*0x%x)", eventFlag, direction);

	if (!eventFlag || !direction)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	*direction = eventFlag->direction;
	return CELL_OK;
}

/// Get clearing mode of SPURS event flag
s32 cellSpursEventFlagGetClearMode(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> clear_mode)
{
	cellSpurs.warning("cellSpursEventFlagGetClearMode(eventFlag=*0x%x, clear_mode=*0x%x)", eventFlag, clear_mode);

	if (!eventFlag || !clear_mode)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	*clear_mode = eventFlag->clearMode;
	return CELL_OK;
}

/// Get address of taskset to which the SPURS event flag belongs
s32 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, vm::pptr<CellSpursTaskset> taskset)
{
	cellSpurs.warning("cellSpursEventFlagGetTasksetAddress(eventFlag=*0x%x, taskset=**0x%x)", eventFlag, taskset);

	if (!eventFlag || !taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!eventFlag.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	taskset->set(eventFlag->isIwl ? 0u : vm::cast(eventFlag->addr));
	return CELL_OK;
}

static inline s32 SyncErrorToSpursError(s32 res)
{
	return res < 0 ? 0x80410900 | (res & 0xff) : res;
}

s32 _cellSpursLFQueueInitialize(vm::ptr<void> pTasksetOrSpurs, vm::ptr<CellSpursLFQueue> pQueue, vm::cptr<void> buffer, u32 size, u32 depth, u32 direction)
{
	cellSpurs.todo("_cellSpursLFQueueInitialize(pTasksetOrSpurs=*0x%x, pQueue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x, direction=%d)", pTasksetOrSpurs, pQueue, buffer, size, depth, direction);

	return SyncErrorToSpursError(cellSyncLFQueueInitialize(pQueue, buffer, size, depth, direction, pTasksetOrSpurs));
}

s32 _cellSpursLFQueuePushBody()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursLFQueueAttachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursLFQueueDetachLv2EventQueue(vm::ptr<CellSyncLFQueue> queue)
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _cellSpursLFQueuePopBody()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursLFQueueGetTasksetAddress()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _cellSpursQueueInitialize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueuePopBody()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueuePushBody()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueAttachLv2EventQueue()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueDetachLv2EventQueue()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueGetTasksetAddress()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueClear()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueDepth()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueGetEntrySize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueSize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursQueueGetDirection()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _spurs::create_taskset(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 max_contention, vm::cptr<char> name, u32 size, s32 enable_clear_ls)
{
	if (!spurs || !taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!spurs.aligned() || !taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	memset(taskset.get_ptr(), 0, size);

	taskset->spurs = spurs;
	taskset->args = args;
	taskset->enable_clear_ls = enable_clear_ls > 0 ? 1 : 0;
	taskset->size = size;

	vm::var<CellSpursWorkloadAttribute> wkl_attr;
	_cellSpursWorkloadAttributeInitialize(ppu, wkl_attr, 1, SYS_PROCESS_PARAM_VERSION_330_0, vm::cptr<void>::make(SPURS_IMG_ADDR_TASKSET_PM), 0x1E40 /*pm_size*/,
		taskset.addr(), priority, 8, max_contention);
	// TODO: Check return code

	cellSpursWorkloadAttributeSetName(ppu, wkl_attr, vm::null, name);
	// TODO: Check return code

	// TODO: cellSpursWorkloadAttributeSetShutdownCompletionEventHook(wkl_attr, hook, taskset);
	// TODO: Check return code

	vm::var<u32> wid;
	cellSpursAddWorkloadWithAttribute(ppu, spurs, wid, wkl_attr);
	// TODO: Check return code

	taskset->wkl_flag_wait_task = 0x80;
	taskset->wid = *wid;
	// TODO: cellSpursSetExceptionEventHandler(spurs, wid, hook, taskset);
	// TODO: Check return code

	return CELL_OK;
}

s32 cellSpursCreateTasksetWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute> attr)
{
	cellSpurs.warning("cellSpursCreateTasksetWithAttribute(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);

	if (!attr)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (attr->revision != CELL_SPURS_TASKSET_ATTRIBUTE_REVISION)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	auto rc = _spurs::create_taskset(ppu, spurs, taskset, attr->args, attr.ptr(&CellSpursTasksetAttribute::priority), attr->max_contention, attr->name, attr->taskset_size, attr->enable_clear_ls);

	if (attr->taskset_size >= sizeof(CellSpursTaskset2))
	{
		// TODO: Implement this
	}

	return rc;
}

s32 cellSpursCreateTaskset(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 maxContention)
{
	cellSpurs.warning("cellSpursCreateTaskset(spurs=*0x%x, taskset=*0x%x, args=0x%llx, priority=*0x%x, maxContention=%d)", spurs, taskset, args, priority, maxContention);

	return _spurs::create_taskset(ppu, spurs, taskset, args, priority, maxContention, vm::null, sizeof(CellSpursTaskset), 0);
}

s32 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset)
{
	cellSpurs.warning("cellSpursJoinTaskset(taskset=*0x%x)", taskset);

	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursGetTasksetId(vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> wid)
{
	cellSpurs.warning("cellSpursGetTasksetId(taskset=*0x%x, wid=*0x%x)", taskset, wid);

	if (!taskset || !wid)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	// Does not check its validity
	*wid = taskset->wid;
	return CELL_OK;
}

s32 cellSpursShutdownTaskset(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset)
{
	cellSpurs.warning("cellSpursShutdownTaskset(taskset=*0x%x)", taskset);

	if (!taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	const u32 wid = taskset->wid;

	if (wid >= CELL_SPURS_MAX_WORKLOAD)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	const auto spurs = +taskset->spurs;
	u32 shutdown_error = ppu_execute<&cellSpursShutdownWorkload>(ppu, spurs, wid);

	if (shutdown_error == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
	{
		shutdown_error = CELL_SPURS_TASK_ERROR_STAT;
	}
	else if (shutdown_error == CELL_SPURS_POLICY_MODULE_ERROR_ALIGN || shutdown_error == CELL_SPURS_POLICY_MODULE_ERROR_SRCH)
	{
		// printf is used on fw in this case
		cellSpurs.error("cellSpursShutdownTaskset(taskset=*0x%x): Failed with %s (spurs=0x%x, wid=%d)", CellError{shutdown_error}, spurs, wid);
	}

	return shutdown_error;
}

s32 _spurs::create_task(vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> task_id, vm::cptr<void> elf, vm::cptr<void> context, u32 size, vm::ptr<CellSpursTaskLsPattern> ls_pattern, vm::ptr<CellSpursTaskArgument> arg)
{
	if (!taskset || !elf)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!elf.aligned(16))
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (_spurs::get_sdk_version() < 0x27FFFF)
	{
		if (!context.aligned(16))
		{
			return CELL_SPURS_TASK_ERROR_ALIGN;
		}
	}
	else
	{
		if (!context.aligned(128))
		{
			return CELL_SPURS_TASK_ERROR_ALIGN;
		}
	}

	u32 alloc_ls_blocks = 0;

	if (context)
	{
		if (size < CELL_SPURS_TASK_EXECUTION_CONTEXT_SIZE)
		{
			return CELL_SPURS_TASK_ERROR_INVAL;
		}

		alloc_ls_blocks = size > 0x3D400 ? 0x7A : ((size - 0x400) >> 11);
		if (ls_pattern)
		{
			v128 ls_pattern_128 = v128::from64r(ls_pattern->_u64[0], ls_pattern->_u64[1]);

			const u32 ls_blocks = utils::popcnt128(ls_pattern_128._u);

			if (ls_blocks > alloc_ls_blocks)
			{
				return CELL_SPURS_TASK_ERROR_INVAL;
			}

			v128 _0 = v128::from32(0);
			if ((ls_pattern_128 & v128::from32r(0xFC000000)) != _0)
			{
				// Prevent save/restore to SPURS management area
				return CELL_SPURS_TASK_ERROR_INVAL;
			}
		}
	}
	else
	{
		alloc_ls_blocks = 0;
	}

	// TODO: Verify the ELF header is proper and all its load segments are at address >= 0x3000

	u32 tmp_task_id;

	vm::light_op(vm::_ref<atomic_be_t<v128>>(taskset.ptr(&CellSpursTaskset::enabled).addr()), [&](atomic_be_t<v128>& ptr)
		{
			// NOTE: Realfw processes this using 4 32-bits atomic loops
		    // But here its processed within a single 128-bit atomic op
			ptr.fetch_op([&](be_t<v128>& value)
				{
					auto value0 = value.value();

					if (auto pos = std::countl_one(+value0._u64[0]); pos != 64)
					{
						tmp_task_id = pos;
						value0._u64[0] |= (1ull << 63) >> pos;
						value = value0;
						return true;
					}

					if (auto pos = std::countl_one(+value0._u64[1]); pos != 64)
					{
						tmp_task_id = pos + 64;
						value0._u64[1] |= (1ull << 63) >> pos;
						value = value0;
						return true;
					}

					tmp_task_id = CELL_SPURS_MAX_TASK;
					return false;
				});
		});

	if (tmp_task_id >= CELL_SPURS_MAX_TASK)
	{
		return CELL_SPURS_TASK_ERROR_AGAIN;
	}

	taskset->task_info[tmp_task_id].elf = elf;
	taskset->task_info[tmp_task_id].context_save_storage_and_alloc_ls_blocks = (context.addr() | alloc_ls_blocks);
	taskset->task_info[tmp_task_id].args = *arg;
	if (ls_pattern)
	{
		taskset->task_info[tmp_task_id].ls_pattern = *ls_pattern;
	}

	*task_id = tmp_task_id;
	return CELL_OK;
}

s32 _spurs::task_start(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, u32 taskId)
{
	vm::light_op(taskset->pending_ready, [&](CellSpursTaskset::atomic_tasks_bitset& v)
		{
			v.values[taskId / 32] |= (1u << 31) >> (taskId % 32);
		});

	auto spurs = +taskset->spurs;
	ppu_execute<&cellSpursSendWorkloadSignal>(ppu, spurs, +taskset->wid);

	if (s32 rc = ppu_execute<&cellSpursWakeUp>(ppu, spurs))
	{
		if (rc + 0u == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
		{
			rc = CELL_SPURS_TASK_ERROR_STAT;
		}
		else
		{
			ensure(rc == CELL_OK);
		}
	}

	return CELL_OK;
}

s32 cellSpursCreateTask(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> taskId, vm::cptr<void> elf, vm::cptr<void> context, u32 size, vm::ptr<CellSpursTaskLsPattern> lsPattern, vm::ptr<CellSpursTaskArgument> argument)
{
	cellSpurs.warning("cellSpursCreateTask(taskset=*0x%x, taskID=*0x%x, elf=*0x%x, context=*0x%x, size=0x%x, lsPattern=*0x%x, argument=*0x%x)", taskset, taskId, elf, context, size, lsPattern, argument);

	if (!taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	auto rc = _spurs::create_task(taskset, taskId, elf, context, size, lsPattern, argument);
	if (rc != CELL_OK)
	{
		return rc;
	}

	rc = _spurs::task_start(ppu, taskset, *taskId);
	if (rc != CELL_OK)
	{
		return rc;
	}

	return CELL_OK;
}

s32 _cellSpursSendSignal(ppu_thread& ppu, vm::ptr<CellSpursTaskset> taskset, u32 taskId)
{
	cellSpurs.trace("_cellSpursSendSignal(taskset=*0x%x, taskId=0x%x)", taskset, taskId);

	if (!taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (taskId >= CELL_SPURS_MAX_TASK || taskset->wid >= CELL_SPURS_MAX_WORKLOAD2)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	int signal;

	vm::reservation_op(ppu, vm::unsafe_ptr_cast<spurs_taskset_signal_op>(taskset), [&](spurs_taskset_signal_op& op)
		{
			const u32 signalled = op.signalled[taskId / 32];
			const u32 running = op.running[taskId / 32];
			const u32 ready = op.ready[taskId / 32];
			const u32 waiting = op.waiting[taskId / 32];
			const u32 enabled = op.enabled[taskId / 32];
			const u32 pready = op.pending_ready[taskId / 32];

			const u32 mask = (1u << 31) >> (taskId % 32);

			if ((running & waiting) || (ready & pready) ||
				((signalled | waiting | pready | running | ready) & ~enabled) || !(enabled & mask))
			{
				// Error conditions:
			    // 1) Cannot have a waiting bit and running bit set at the same time
			    // 2) Cannot have a read bit and pending_ready bit at the same time
			    // 3) Any disabled bit in enabled mask must be not set
			    // 4) Specified task must be enabled
				signal = -1;
				return false;
			}

			signal = !!(~signalled & waiting & mask);
			op.signalled[taskId / 32] = signalled | mask;
			return true;
		});

	switch (signal)
	{
	case 0: break;
	case 1:
	{
		auto spurs = +taskset->spurs;

		ppu_execute<&cellSpursSendWorkloadSignal>(ppu, spurs, +taskset->wid);
		auto rc = ppu_execute<&cellSpursWakeUp>(ppu, spurs);
		if (rc + 0u == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
		{
			return CELL_SPURS_TASK_ERROR_STAT;
		}

		return rc;
	}
	default: return CELL_SPURS_TASK_ERROR_SRCH;
	}

	return CELL_OK;
}

s32 cellSpursCreateTaskWithAttribute()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm::cptr<char> name)
{
	cellSpurs.warning("cellSpursTasksetAttributeSetName(attr=*0x%x, name=%s)", attr, name);

	if (!attr || !name)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	attr->name = name;
	return CELL_OK;
}

s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> attr, u32 size)
{
	cellSpurs.warning("cellSpursTasksetAttributeSetTasksetSize(attr=*0x%x, size=0x%x)", attr, size);

	if (!attr)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (size != sizeof(CellSpursTaskset) && size != sizeof(CellSpursTaskset2))
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	attr->taskset_size = size;
	return CELL_OK;
}

s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr<CellSpursTasksetAttribute> attr, s32 enable)
{
	cellSpurs.warning("cellSpursTasksetAttributeEnableClearLS(attr=*0x%x, enable=%d)", attr, enable);

	if (!attr)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!attr.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	attr->enable_clear_ls = enable ? 1 : 0;
	return CELL_OK;
}

s32 _cellSpursTasksetAttribute2Initialize(vm::ptr<CellSpursTasksetAttribute2> attribute, u32 revision)
{
	cellSpurs.warning("_cellSpursTasksetAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);

	std::memset(attribute.get_ptr(), 0, attribute.size());
	attribute->revision = revision;
	attribute->name = vm::null;
	attribute->args = 0;

	for (s32 i = 0; i < 8; i++)
	{
		attribute->priority[i] = 1;
	}

	attribute->max_contention = 8;
	attribute->enable_clear_ls = 0;
	attribute->task_name_buffer.set(0);
	return CELL_OK;
}

s32 cellSpursTaskExitCodeGet()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskExitCodeInitialize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskExitCodeTryGet()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskGetLoadableSegmentPattern()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskGetReadOnlyAreaPattern()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskGenerateLsPattern()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _cellSpursTaskAttributeInitialize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTaskAttributeSetExitCodeContainer()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _cellSpursTaskAttribute2Initialize(vm::ptr<CellSpursTaskAttribute2> attribute, u32 revision)
{
	cellSpurs.warning("_cellSpursTaskAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);

	attribute->revision = revision;
	attribute->sizeContext = 0;
	attribute->eaContext = 0;

	for (s32 c = 0; c < 4; c++)
	{
		attribute->lsPattern._u32[c] = 0;
	}

	attribute->name = vm::null;

	return CELL_OK;
}

s32 cellSpursTaskGetContextSaveAreaSize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursCreateTaskset2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute2> attr)
{
	cellSpurs.warning("cellSpursCreateTaskset2(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);

	vm::var<CellSpursTasksetAttribute2> tmp_attr;

	if (!attr)
	{
		attr = tmp_attr;
		_cellSpursTasksetAttribute2Initialize(attr, 0);
	}

	if (s32 rc = _spurs::create_taskset(ppu, spurs, taskset, attr->args, attr.ptr(&CellSpursTasksetAttribute2::priority), attr->max_contention, attr->name, sizeof(CellSpursTaskset2), attr->enable_clear_ls))
	{
		return rc;
	}

	if (!attr->task_name_buffer.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	// TODO: Implement rest of the function
	return CELL_OK;
}

s32 cellSpursCreateTask2()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursJoinTask2()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTryJoinTask2()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursDestroyTaskset2()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursCreateTask2WithBinInfo()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetExceptionEventHandler> handler, vm::ptr<u64> arg)
{
	cellSpurs.warning("cellSpursTasksetSetExceptionEventHandler(taskset=*0x%x, handler=*0x%x, arg=*0x%x)", taskset, handler, arg);

	if (!taskset || !handler)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (taskset->wid >= CELL_SPURS_MAX_WORKLOAD)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	if (taskset->exception_handler)
	{
		return CELL_SPURS_TASK_ERROR_BUSY;
	}

	taskset->exception_handler = handler;
	taskset->exception_handler_arg = arg;
	return CELL_OK;
}

s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset)
{
	cellSpurs.warning("cellSpursTasksetUnsetExceptionEventHandler(taskset=*0x%x)", taskset);

	if (!taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (taskset->wid >= CELL_SPURS_MAX_WORKLOAD)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	taskset->exception_handler.set(0);
	taskset->exception_handler_arg.set(0);
	return CELL_OK;
}

s32 cellSpursLookUpTasksetAddress(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
{
	cellSpurs.warning("cellSpursLookUpTasksetAddress(spurs=*0x%x, taskset=**0x%x, id=0x%x)", spurs, taskset, id);

	if (!taskset)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	vm::var<u64> data;
	if (s32 rc = cellSpursGetWorkloadData(spurs, data, id))
	{
		// Convert policy module error code to a task error code
		return rc ^ 0x100;
	}

	*taskset = vm::cast(*data);
	return CELL_OK;
}

s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<u32> spurs)
{
	cellSpurs.warning("cellSpursTasksetGetSpursAddress(taskset=*0x%x, spurs=**0x%x)", taskset, spurs);

	if (!taskset || !spurs)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!taskset.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	if (taskset->wid >= CELL_SPURS_MAX_WORKLOAD)
	{
		return CELL_SPURS_TASK_ERROR_INVAL;
	}

	*spurs = vm::cast(taskset->spurs.addr());
	return CELL_OK;
}

s32 cellSpursGetTasksetInfo()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attribute, u32 revision, u32 sdk_version, u64 args, vm::cptr<u8> priority, u32 max_contention)
{
	cellSpurs.warning("_cellSpursTasksetAttributeInitialize(attribute=*0x%x, revision=%d, skd_version=0x%x, args=0x%llx, priority=*0x%x, max_contention=%d)",
		attribute, revision, sdk_version, args, priority, max_contention);

	if (!attribute)
	{
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;
	}

	if (!attribute.aligned())
	{
		return CELL_SPURS_TASK_ERROR_ALIGN;
	}

	for (u32 i = 0; i < 8; i++)
	{
		if (priority[i] > 0xF)
		{
			return CELL_SPURS_TASK_ERROR_INVAL;
		}
	}

	std::memset(attribute.get_ptr(), 0, attribute.size());
	attribute->revision = revision;
	attribute->sdk_version = sdk_version;
	attribute->args = args;
	std::memcpy(attribute->priority, priority.get_ptr(), 8);
	attribute->taskset_size = 6400 /*CellSpursTaskset::size*/;
	attribute->max_contention = max_contention;
	return CELL_OK;
}

s32 _spurs::check_job_chain_attribute(u32 sdkVer, vm::cptr<u64> jcEntry, u16 sizeJobDescr, u16 maxGrabbedJob, u64 priorities, u32 maxContention, u8 autoSpuCount, u32 tag1, u32 tag2, u8 isFixedMemAlloc, u32 maxSizeJob, u32 initSpuCount)
{
	if (!jcEntry)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jcEntry.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (!maxGrabbedJob || maxGrabbedJob > 0x10u)
		return CELL_SPURS_JOB_ERROR_INVAL;

	// Tag 31 is not allowed from version 1.90 for some reason
	if (u32 max_tag = sdkVer < 0x19000 ? 31 : 30; tag1 > max_tag || tag2 > max_tag)
		return CELL_SPURS_JOB_ERROR_INVAL;

	// Test if any of the value >= CELL_SPURS_MAX_PRIORITY
	if (priorities & 0xf0f0f0f0f0f0f0f0)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (sizeJobDescr % 0x80 && sizeJobDescr != 64u)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (autoSpuCount && initSpuCount > 0xffu)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (maxSizeJob <= 0xffu || maxSizeJob > 0x400u || maxSizeJob % 0x80)
		return CELL_SPURS_JOB_ERROR_INVAL;

	return CELL_OK;
}

s32 _spurs::create_job_chain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 sizeJob, u16 maxGrabbedJob, vm::cptr<u8[8]> prio, u32 maxContention, b8 autoReadyCount, u32 tag1, u32 tag2, u32 HaltOnError, vm::cptr<char> name, u32 param_13, u32 param_14)
{
	const s32 sdkVer = _spurs::get_sdk_version();
	jobChain->spurs = spurs;
	jobChain->jmVer = sdkVer > 0x14ffff ? CELL_SPURS_JOB_REVISION_1 : CELL_SPURS_JOB_REVISION_0;

	// Real hack in firmware
	jobChain->val2F = Emu.GetTitleID() == "BLJM60093" ? 1 : 0;
	jobChain->tag1 = static_cast<u8>(tag1);
	jobChain->tag2 = static_cast<u8>(tag2);
	jobChain->isHalted = false;
	jobChain->maxGrabbedJob = maxGrabbedJob;
	jobChain->pc = jobChainEntry;

	auto as_job_error = [](s32 error) -> s32
	{
		switch (error + 0u)
		{
		case CELL_SPURS_POLICY_MODULE_ERROR_AGAIN: return CELL_SPURS_JOB_ERROR_AGAIN;
		case CELL_SPURS_POLICY_MODULE_ERROR_INVAL: return CELL_SPURS_JOB_ERROR_INVAL;
		case CELL_SPURS_POLICY_MODULE_ERROR_STAT: return CELL_SPURS_JOB_ERROR_STAT;
		default: return error;
		}
	};

	vm::var<CellSpursWorkloadAttribute> attr_wkl;
	vm::var<u32> wid;

	// TODO
	if (auto err = _cellSpursWorkloadAttributeInitialize(ppu, +attr_wkl, 1, SYS_PROCESS_PARAM_VERSION_330_0, vm::null, 0, jobChain.addr(), prio, 1, maxContention))
	{
		return as_job_error(err);
	}

	ppu_execute<&cellSpursWorkloadAttributeSetName>(ppu, +attr_wkl, +vm::make_str("JobChain"), name);

	if (auto err = ppu_execute<&cellSpursAddWorkloadWithAttribute>(ppu, spurs, +wid, +attr_wkl))
	{
		return as_job_error(err);
	}

	jobChain->cause = vm::null;
	jobChain->error = 0;
	jobChain->workloadId = *wid;
	return CELL_OK;
}

s32 cellSpursCreateJobChainWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::ptr<CellSpursJobChainAttribute> attr)
{
	cellSpurs.warning("cellSpursCreateJobChainWithAttribute(spurs=*0x%x, jobChain=*0x%x, attr=*0x%x)", spurs, jobChain, attr);

	if (!attr)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!attr.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u64 prio = std::bit_cast<u64>(attr->priorities);

	if (auto err = _spurs::check_job_chain_attribute(attr->sdkVer, attr->jobChainEntry, attr->sizeJobDescriptor, attr->maxGrabbedJob, prio, attr->maxContention, attr->autoSpuCount, attr->tag1, attr->tag2, attr->isFixedMemAlloc, attr->maxSizeJobDescriptor, attr->initSpuCount))
	{
		return err;
	}

	if (!jobChain || !spurs)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned() || !spurs.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	std::memset(jobChain.get_ptr(), 0, 0x110);

	// Only allowed revisions in this function
	if (auto ver = attr->jmVer; ver != CELL_SPURS_JOB_REVISION_2 && ver != CELL_SPURS_JOB_REVISION_3)
	{
		return CELL_SPURS_JOB_ERROR_INVAL;
	}

	jobChain->val2C = +attr->isFixedMemAlloc << 7 | (((attr->maxSizeJobDescriptor - 0x100) / 128 & 7) << 4);

	if (auto err = _spurs::create_job_chain(ppu, spurs, jobChain, attr->jobChainEntry, attr->sizeJobDescriptor, attr->maxGrabbedJob, attr.ptr(&CellSpursJobChainAttribute::priorities), attr->maxContention, attr->autoSpuCount, attr->tag1, attr->tag2, attr->haltOnError, attr->name, 0, 0))
	{
		return err;
	}

	jobChain->initSpuCount = attr->initSpuCount;
	jobChain->jmVer = attr->jmVer;
	jobChain->sdkVer = attr->sdkVer;
	jobChain->jobMemoryCheck = +attr->jobMemoryCheck << 1;
	return CELL_OK;
}

s32 cellSpursCreateJobChain(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<u64> jobChainEntry, u16 sizeJobDescriptor, u16 maxGrabbedJob, vm::cptr<u8[8]> priorities, u32 maxContention, b8 autoReadyCount, u32 tag1, u32 tag2)
{
	cellSpurs.warning("cellSpursCreateJobChain(spurs=*0x%x, jobChain=*0x%x, jobChainEntry=*0x%x, sizeJobDescriptor=0x%x"
					  ", maxGrabbedJob=0x%x, priorities=*0x%x, maxContention=%u, autoReadyCount=%s, tag1=%u, %u)",
		spurs, jobChain, jobChainEntry, sizeJobDescriptor, maxGrabbedJob, priorities, maxContention, autoReadyCount, tag1, tag2);

	const u64 prio = std::bit_cast<u64>(*priorities);

	if (auto err = _spurs::check_job_chain_attribute(-1, jobChainEntry, sizeJobDescriptor, maxGrabbedJob, prio, maxContention, autoReadyCount, tag1, tag2, 0, 0, 0))
	{
		return err;
	}

	std::memset(jobChain.get_ptr(), 0, 0x110);

	if (auto err = _spurs::create_job_chain(ppu, spurs, jobChain, jobChainEntry, sizeJobDescriptor, maxGrabbedJob, priorities, maxContention, autoReadyCount, tag1, tag2, 0, vm::null, 0, 0))
	{
		return err;
	}

	return CELL_OK;
}

s32 cellSpursJoinJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain)
{
	cellSpurs.trace("cellSpursJoinJobChain(jobChain=*0x%x)", jobChain);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u32 wid = jobChain->workloadId;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	auto as_job_error = [](s32 error) -> s32
	{
		switch (error + 0u)
		{
		case CELL_SPURS_POLICY_MODULE_ERROR_STAT: return CELL_SPURS_JOB_ERROR_STAT;
		default: return error;
		}
	};

	if (auto err = ppu_execute<&cellSpursWaitForWorkloadShutdown>(ppu, +jobChain->spurs, wid))
	{
		return as_job_error(err);
	}

	if (auto err = ppu_execute<&cellSpursRemoveWorkload>(ppu, +jobChain->spurs, wid))
	{
		// Returned as is
		return err;
	}

	jobChain->workloadId = CELL_SPURS_MAX_WORKLOAD2;
	return jobChain->error;
}

s32 cellSpursKickJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain, u8 numReadyCount)
{
	cellSpurs.trace("cellSpursKickJobChain(jobChain=*0x%x, numReadyCount=0x%x)", jobChain, numReadyCount);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u32 wid = jobChain->workloadId;
	const auto spurs = +jobChain->spurs;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (jobChain->jmVer > CELL_SPURS_JOB_REVISION_1)
		return CELL_SPURS_JOB_ERROR_PERM;

	if (jobChain->autoReadyCount)
		ppu_execute<&cellSpursReadyCountStore>(ppu, spurs, wid, numReadyCount);
	else
		ppu_execute<&cellSpursReadyCountCompareAndSwap>(ppu, spurs, wid, +vm::var<u32>{}, 0, 1);

	const auto err = ppu_execute<&cellSpursWakeUp>(ppu, spurs);

	if (err + 0u == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
	{
		return CELL_SPURS_JOB_ERROR_STAT;
	}

	return err;
}

s32 _cellSpursJobChainAttributeInitialize(u32 jmRevsion, u32 sdkRevision, vm::ptr<CellSpursJobChainAttribute> attr, vm::cptr<u64> jobChainEntry, u16 sizeJobDescriptor, u16 maxGrabbedJob, vm::cptr<u8[8]> priorityTable, u32 maxContention, b8 autoRequestSpuCount, u32 tag1, u32 tag2, b8 isFixedMemAlloc, u32 maxSizeJobDescriptor, u32 initialRequestSpuCount)
{
	cellSpurs.trace("_cellSpursJobChainAttributeInitialize(jmRevsion=0x%x, sdkRevision=0x%x, attr=*0x%x, jobChainEntry=*0x%x, sizeJobDescriptor=0x%x, maxGrabbedJob=0x%x, priorityTable=*0x%x"
					", maxContention=%u, autoRequestSpuCount=%s, tag1=0x%x, tag2=0x%x, isFixedMemAlloc=%s, maxSizeJobDescriptor=0x%x, initialRequestSpuCount=%u)",
		jmRevsion, sdkRevision, attr, jobChainEntry, sizeJobDescriptor, maxGrabbedJob, priorityTable, maxContention, autoRequestSpuCount, tag1, tag2, isFixedMemAlloc, maxSizeJobDescriptor, initialRequestSpuCount);

	if (!attr)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!attr.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u64 prio = std::bit_cast<u64>(*priorityTable);

	if (auto err = _spurs::check_job_chain_attribute(sdkRevision, jobChainEntry, sizeJobDescriptor, maxGrabbedJob, prio, maxContention, autoRequestSpuCount, tag1, tag2, isFixedMemAlloc, maxSizeJobDescriptor, initialRequestSpuCount))
	{
		return err;
	}

	attr->jmVer = jmRevsion;
	attr->sdkVer = sdkRevision;
	attr->jobChainEntry = jobChainEntry;
	attr->sizeJobDescriptor = sizeJobDescriptor;
	attr->maxGrabbedJob = maxGrabbedJob;
	std::memcpy(&attr->priorities, &prio, 8);
	attr->maxContention = maxContention;
	attr->autoSpuCount = autoRequestSpuCount;
	attr->tag1 = tag1;
	attr->tag2 = tag2;
	attr->isFixedMemAlloc = isFixedMemAlloc;
	attr->maxSizeJobDescriptor = maxSizeJobDescriptor;
	attr->initSpuCount = initialRequestSpuCount;
	attr->haltOnError = 0;
	attr->name = vm::null;
	attr->jobMemoryCheck = false;
	return CELL_OK;
}

s32 cellSpursGetJobChainId(vm::ptr<CellSpursJobChain> jobChain, vm::ptr<u32> id)
{
	cellSpurs.trace("cellSpursGetJobChainId(jobChain=*0x%x, id=*0x%x)", jobChain, id);

	if (!jobChain || !id)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	*id = jobChain->workloadId;
	return CELL_OK;
}

s32 cellSpursJobChainSetExceptionEventHandler(vm::ptr<CellSpursJobChain> jobChain, vm::ptr<CellSpursJobChainExceptionEventHandler> handler, vm::ptr<void> arg)
{
	cellSpurs.trace("cellSpursJobChainSetExceptionEventHandler(jobChain=*0x%x, handler=*0x%x, arg=*0x%x)", jobChain, handler, arg);

	if (!jobChain || !handler)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (jobChain->workloadId >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (jobChain->exceptionEventHandler)
		return CELL_SPURS_JOB_ERROR_BUSY;

	jobChain->exceptionEventHandlerArgument = arg;
	jobChain->exceptionEventHandler.set(handler.addr());
	return CELL_OK;
}

s32 cellSpursJobChainUnsetExceptionEventHandler(vm::ptr<CellSpursJobChain> jobChain)
{
	cellSpurs.trace("cellSpursJobChainUnsetExceptionEventHandler(jobChain=*0x%x)", jobChain);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (jobChain->workloadId >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	jobChain->exceptionEventHandler = vm::null;
	jobChain->exceptionEventHandlerArgument = vm::null;
	return CELL_OK;
}

s32 cellSpursGetJobChainInfo(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain, vm::ptr<CellSpursJobChainInfo> info)
{
	cellSpurs.trace("cellSpursGetJobChainInfo(jobChain=*0x%x, info=*0x%x)", jobChain, info);

	if (!jobChain || !info)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u32 wid = jobChain->workloadId;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	vm::var<CellSpursWorkloadInfo> wklInfo;

	if (auto err = ppu_execute<&cellSpursGetWorkloadInfo>(ppu, +jobChain->spurs, wid, +wklInfo))
	{
		if (err + 0u == CELL_SPURS_POLICY_MODULE_ERROR_SRCH)
		{
			return CELL_SPURS_JOB_ERROR_INVAL;
		}

		return err;
	}

	// Read the commands queue atomically
	CellSpursJobChain data;
	vm::peek_op(ppu, vm::unsafe_ptr_cast<CellSpursJobChain_x00>(jobChain), [&](const CellSpursJobChain_x00& jch)
		{
			std::memcpy(&data, &jch, sizeof(jch));
		});

	info->linkRegister[0] = +data.linkRegister[0];
	info->linkRegister[1] = +data.linkRegister[1];
	info->linkRegister[2] = +data.linkRegister[2];
	std::memcpy(&info->urgentCommandSlot, &data.urgentCmds, sizeof(info->urgentCommandSlot));
	info->programCounter = +data.pc;
	info->idWorkload = wid;
	info->maxSizeJobDescriptor = (data.val2C & 0x70u) * 8 + 0x100;
	info->isHalted.set(data.isHalted); // Boolean truncation (non-zero becomes 1)
	info->autoReadyCount.set(data.autoReadyCount);
	info->isFixedMemAlloc = !!(data.val2C & 0x80);
	info->name = wklInfo->nameInstance;
	info->statusCode = jobChain->error;
	info->cause = jobChain->cause;
	info->exceptionEventHandler = +jobChain->exceptionEventHandler;
	info->exceptionEventHandlerArgument = +jobChain->exceptionEventHandlerArgument;
	return CELL_OK;
}

s32 cellSpursJobChainGetSpursAddress(vm::ptr<CellSpursJobChain> jobChain, vm::pptr<CellSpurs> spurs)
{
	cellSpurs.trace("cellSpursJobChainGetSpursAddress(jobChain=*0x%x, spurs=*0x%x)", jobChain, spurs);

	if (!jobChain || !spurs)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	*spurs = +jobChain->spurs;
	return CELL_OK;
}

s32 cellSpursJobGuardInitialize(vm::ptr<CellSpursJobChain> jobChain, vm::ptr<CellSpursJobGuard> jobGuard, u32 notifyCount, u8 requestSpuCount, u8 autoReset)
{
	cellSpurs.trace("cellSpursJobGuardInitialize(jobChain=*0x%x, jobGuard=*0x%x, notifyCount=0x%x, requestSpuCount=0x%x, autoReset=0x%x)", jobChain, jobGuard, notifyCount, requestSpuCount, autoReset);

	if (!jobChain || !jobGuard)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned() || !jobGuard.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (jobChain->workloadId >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	std::memset(jobGuard.get_ptr(), 0, jobGuard.size());
	jobGuard->zero = 0;
	jobGuard->ncount0 = notifyCount;
	jobGuard->ncount1 = notifyCount;
	jobGuard->requestSpuCount = requestSpuCount;
	jobGuard->autoReset = autoReset;
	jobGuard->jobChain = jobChain;
	return CELL_OK;
}

s32 cellSpursJobChainAttributeSetName(vm::ptr<CellSpursJobChainAttribute> attr, vm::cptr<char> name)
{
	cellSpurs.trace("cellSpursJobChainAttributeSetName(attr=*0x%x, name=*0x%x %s)", attr, name, name);

	if (!attr || !name)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!attr.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	attr->name = name;
	return CELL_OK;
}

s32 cellSpursShutdownJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain)
{
	cellSpurs.trace("cellSpursShutdownJobChain(jobChain=*0x%x)", jobChain);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u32 wid = jobChain->workloadId;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	const auto err = ppu_execute<&cellSpursShutdownWorkload>(ppu, +jobChain->spurs, wid);

	if (err + 0u == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
	{
		return CELL_SPURS_JOB_ERROR_STAT;
	}

	return err;
}

s32 cellSpursJobChainAttributeSetHaltOnError(vm::ptr<CellSpursJobChainAttribute> attr)
{
	cellSpurs.trace("cellSpursJobChainAttributeSetHaltOnError(attr=*0x%x)", attr);

	if (!attr)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!attr.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	attr->haltOnError = true;
	return CELL_OK;
}

s32 cellSpursJobChainAttributeSetJobTypeMemoryCheck(vm::ptr<CellSpursJobChainAttribute> attr)
{
	cellSpurs.trace("cellSpursJobChainAttributeSetJobTypeMemoryCheck(attr=*0x%x)", attr);

	if (!attr)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!attr.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	attr->jobMemoryCheck = true;
	return CELL_OK;
}

s32 cellSpursJobGuardNotify(ppu_thread& ppu, vm::ptr<CellSpursJobGuard> jobGuard)
{
	cellSpurs.trace("cellSpursJobGuardNotify(jobGuard=*0x%x)", jobGuard);

	if (!jobGuard)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobGuard.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	u32 allow_jobchain_run = 0; // Affects cellSpursJobChainRun execution
	u32 old = 0;

	const bool ok = vm::reservation_op(ppu, vm::unsafe_ptr_cast<CellSpursJobGuard_x00>(jobGuard), [&](CellSpursJobGuard_x00& jg)
		{
			allow_jobchain_run = jg.zero;
			old = jg.ncount0;

			if (!jg.ncount0)
			{
				return false;
			}

			jg.ncount0--;
			return true;
		});

	if (!ok)
	{
		return CELL_SPURS_CORE_ERROR_STAT;
	}

	if (old > 1u)
	{
		return CELL_OK;
	}

	auto jobChain = +jobGuard->jobChain;

	if (jobChain->jmVer <= CELL_SPURS_JOB_REVISION_1)
	{
		ppu_execute<&cellSpursKickJobChain>(ppu, jobChain, static_cast<u8>(jobGuard->requestSpuCount));
	}
	else if (allow_jobchain_run)
	{
		ppu_execute<&cellSpursRunJobChain>(ppu, jobChain);
	}

	return CELL_OK;
}

s32 cellSpursJobGuardReset(vm::ptr<CellSpursJobGuard> jobGuard)
{
	cellSpurs.trace("cellSpursJobGuardReset(jobGuard=*0x%x)", jobGuard);

	if (!jobGuard)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobGuard.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	vm::light_op(jobGuard->ncount0, [&](atomic_be_t<u32>& ncount0)
		{
			ncount0 = jobGuard->ncount1;
		});

	return CELL_OK;
}

s32 cellSpursRunJobChain(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain)
{
	cellSpurs.trace("cellSpursRunJobChain(jobChain=*0x%x)", jobChain);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const u32 wid = jobChain->workloadId;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	if (jobChain->jmVer <= CELL_SPURS_JOB_REVISION_1)
		return CELL_SPURS_JOB_ERROR_PERM;

	const auto spurs = +jobChain->spurs;
	ppu_execute<&cellSpursSendWorkloadSignal>(ppu, spurs, wid);

	const auto err = ppu_execute<&cellSpursWakeUp>(ppu, spurs);

	if (err + 0u == CELL_SPURS_POLICY_MODULE_ERROR_STAT)
	{
		return CELL_SPURS_JOB_ERROR_STAT;
	}

	return err;
}

s32 cellSpursJobChainGetError(vm::ptr<CellSpursJobChain> jobChain, vm::pptr<void> cause)
{
	cellSpurs.trace("cellSpursJobChainGetError(jobChain=*0x%x, cause=*0x%x)", jobChain, cause);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	const s32 error = jobChain->error;
	*cause = (error ? jobChain->cause : vm::null);
	return error;
}

s32 cellSpursGetJobPipelineInfo()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursJobSetMaxGrab(vm::ptr<CellSpursJobChain> jobChain, u32 maxGrabbedJob)
{
	cellSpurs.trace("cellSpursJobSetMaxGrab(jobChain=*0x%x, maxGrabbedJob=*0x%x)", jobChain, maxGrabbedJob);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (!maxGrabbedJob || maxGrabbedJob > 0x10u)
		return CELL_SPURS_JOB_ERROR_INVAL;

	const auto spurs = jobChain->spurs;

	// All of these are ERROR_STAT checks unexpectedly
	if (!spurs || !spurs.aligned())
		return CELL_SPURS_JOB_ERROR_STAT;

	const u32 wid = jobChain->workloadId;

	if (wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_STAT;

	if ((spurs->wklEnabled & (0x80000000u >> wid)) == 0u)
		return CELL_SPURS_JOB_ERROR_STAT;

	vm::light_op(jobChain->maxGrabbedJob, [&](atomic_be_t<u16>& v)
		{
			v.release(static_cast<u16>(maxGrabbedJob));
		});

	return CELL_OK;
}

s32 cellSpursJobHeaderSetJobbin2Param()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursAddUrgentCommand(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain, u64 newCmd)
{
	cellSpurs.trace("cellSpursAddUrgentCommand(jobChain=*0x%x, newCmd=0x%llx)", jobChain, newCmd);

	if (!jobChain)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!jobChain.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	if (jobChain->workloadId >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_JOB_ERROR_INVAL;

	s32 result = CELL_OK;

	vm::reservation_op(ppu, vm::unsafe_ptr_cast<CellSpursJobChain_x00>(jobChain), [&](CellSpursJobChain_x00& jch)
		{
			for (auto& cmd : jch.urgentCmds)
			{
				if (!cmd)
				{
					cmd = newCmd;
					return true;
				}
			}

			// Considered unlikely so unoptimized
			result = CELL_SPURS_JOB_ERROR_BUSY;
			return false;
		});

	return result;
}

s32 cellSpursAddUrgentCall(ppu_thread& ppu, vm::ptr<CellSpursJobChain> jobChain, vm::ptr<u64> commandList)
{
	cellSpurs.trace("cellSpursAddUrgentCall(jobChain=*0x%x, commandList=*0x%x)", jobChain, commandList);

	if (!commandList)
		return CELL_SPURS_JOB_ERROR_NULL_POINTER;

	if (!commandList.aligned())
		return CELL_SPURS_JOB_ERROR_ALIGN;

	return cellSpursAddUrgentCommand(ppu, jobChain, commandList.addr() | CELL_SPURS_JOB_OPCODE_CALL);
}

s32 cellSpursBarrierInitialize(vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursBarrier> barrier, u32 total)
{
	cellSpurs.trace("cellSpursBarrierInitialize(taskset=*0x%x, barrier=*0x%x, total=0x%x)", taskset, barrier, total);

	if (!taskset || !barrier)
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;

	if (!taskset.aligned() || !barrier.aligned())
		return CELL_SPURS_TASK_ERROR_ALIGN;

	if (!total || total > 128u)
		return CELL_SPURS_TASK_ERROR_INVAL;

	if (taskset->wid >= CELL_SPURS_MAX_WORKLOAD2)
		return CELL_SPURS_TASK_ERROR_INVAL;

	std::memset(barrier.get_ptr(), 0, barrier.size());
	barrier->zero = 0;
	barrier->remained = total;
	barrier->taskset = taskset;
	return CELL_OK;
}

s32 cellSpursBarrierGetTasksetAddress(vm::ptr<CellSpursBarrier> barrier, vm::pptr<CellSpursTaskset> taskset)
{
	cellSpurs.trace("cellSpursBarrierGetTasksetAddress(barrier=*0x%x, taskset=*0x%x)", barrier, taskset);

	if (!taskset || !barrier)
		return CELL_SPURS_TASK_ERROR_NULL_POINTER;

	if (!barrier.aligned())
		return CELL_SPURS_TASK_ERROR_ALIGN;

	*taskset = barrier->taskset;
	return CELL_OK;
}

s32 _cellSpursSemaphoreInitialize()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

s32 cellSpursSemaphoreGetTasksetAddress()
{
	UNIMPLEMENTED_FUNC(cellSpurs);
	return CELL_OK;
}

DECLARE(ppu_module_manager::cellSpurs)("cellSpurs", [](ppu_static_module* _this)
	{
		// Core
		REG_FUNC(cellSpurs, cellSpursInitialize);
		REG_FUNC(cellSpurs, cellSpursInitializeWithAttribute);
		REG_FUNC(cellSpurs, cellSpursInitializeWithAttribute2);
		REG_FUNC(cellSpurs, cellSpursFinalize);
		REG_FUNC(cellSpurs, _cellSpursAttributeInitialize);
		REG_FUNC(cellSpurs, cellSpursAttributeSetMemoryContainerForSpuThread);
		REG_FUNC(cellSpurs, cellSpursAttributeSetNamePrefix);
		REG_FUNC(cellSpurs, cellSpursAttributeEnableSpuPrintfIfAvailable);
		REG_FUNC(cellSpurs, cellSpursAttributeSetSpuThreadGroupType);
		REG_FUNC(cellSpurs, cellSpursAttributeEnableSystemWorkload);
		REG_FUNC(cellSpurs, cellSpursGetSpuThreadGroupId);
		REG_FUNC(cellSpurs, cellSpursGetNumSpuThread);
		REG_FUNC(cellSpurs, cellSpursGetSpuThreadId);
		REG_FUNC(cellSpurs, cellSpursGetInfo);
		REG_FUNC(cellSpurs, cellSpursSetMaxContention);
		REG_FUNC(cellSpurs, cellSpursSetPriorities);
		REG_FUNC(cellSpurs, cellSpursSetPriority);
		REG_FUNC(cellSpurs, cellSpursSetPreemptionVictimHints);
		REG_FUNC(cellSpurs, cellSpursAttachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursDetachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursEnableExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursSetGlobalExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursUnsetGlobalExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursSetExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursUnsetExceptionEventHandler);

		// Event flag
		REG_FUNC(cellSpurs, _cellSpursEventFlagInitialize);
		REG_FUNC(cellSpurs, cellSpursEventFlagAttachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursEventFlagDetachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursEventFlagWait);
		REG_FUNC(cellSpurs, cellSpursEventFlagClear);
		REG_FUNC(cellSpurs, cellSpursEventFlagSet);
		REG_FUNC(cellSpurs, cellSpursEventFlagTryWait);
		REG_FUNC(cellSpurs, cellSpursEventFlagGetDirection);
		REG_FUNC(cellSpurs, cellSpursEventFlagGetClearMode);
		REG_FUNC(cellSpurs, cellSpursEventFlagGetTasksetAddress);

		// Taskset
		REG_FUNC(cellSpurs, cellSpursCreateTaskset);
		REG_FUNC(cellSpurs, cellSpursCreateTasksetWithAttribute);
		REG_FUNC(cellSpurs, _cellSpursTasksetAttributeInitialize);
		REG_FUNC(cellSpurs, _cellSpursTasksetAttribute2Initialize);
		REG_FUNC(cellSpurs, cellSpursTasksetAttributeSetName);
		REG_FUNC(cellSpurs, cellSpursTasksetAttributeSetTasksetSize);
		REG_FUNC(cellSpurs, cellSpursTasksetAttributeEnableClearLS);
		REG_FUNC(cellSpurs, cellSpursJoinTaskset);
		REG_FUNC(cellSpurs, cellSpursGetTasksetId);
		REG_FUNC(cellSpurs, cellSpursShutdownTaskset);
		REG_FUNC(cellSpurs, cellSpursCreateTask);
		REG_FUNC(cellSpurs, cellSpursCreateTaskWithAttribute);
		REG_FUNC(cellSpurs, _cellSpursTaskAttributeInitialize);
		REG_FUNC(cellSpurs, _cellSpursTaskAttribute2Initialize);
		REG_FUNC(cellSpurs, cellSpursTaskAttributeSetExitCodeContainer);
		REG_FUNC(cellSpurs, cellSpursTaskExitCodeGet);
		REG_FUNC(cellSpurs, cellSpursTaskExitCodeInitialize);
		REG_FUNC(cellSpurs, cellSpursTaskExitCodeTryGet);
		REG_FUNC(cellSpurs, cellSpursTaskGetLoadableSegmentPattern);
		REG_FUNC(cellSpurs, cellSpursTaskGetReadOnlyAreaPattern);
		REG_FUNC(cellSpurs, cellSpursTaskGenerateLsPattern);
		REG_FUNC(cellSpurs, cellSpursTaskGetContextSaveAreaSize);
		REG_FUNC(cellSpurs, _cellSpursSendSignal);
		REG_FUNC(cellSpurs, cellSpursCreateTaskset2);
		REG_FUNC(cellSpurs, cellSpursCreateTask2);
		REG_FUNC(cellSpurs, cellSpursJoinTask2);
		REG_FUNC(cellSpurs, cellSpursTryJoinTask2);
		REG_FUNC(cellSpurs, cellSpursDestroyTaskset2);
		REG_FUNC(cellSpurs, cellSpursCreateTask2WithBinInfo);
		REG_FUNC(cellSpurs, cellSpursLookUpTasksetAddress);
		REG_FUNC(cellSpurs, cellSpursTasksetGetSpursAddress);
		REG_FUNC(cellSpurs, cellSpursGetTasksetInfo);
		REG_FUNC(cellSpurs, cellSpursTasksetSetExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursTasksetUnsetExceptionEventHandler);

		// Job Chain
		REG_FUNC(cellSpurs, cellSpursCreateJobChain);
		REG_FUNC(cellSpurs, cellSpursCreateJobChainWithAttribute);
		REG_FUNC(cellSpurs, cellSpursShutdownJobChain);
		REG_FUNC(cellSpurs, cellSpursJoinJobChain);
		REG_FUNC(cellSpurs, cellSpursKickJobChain);
		REG_FUNC(cellSpurs, cellSpursRunJobChain);
		REG_FUNC(cellSpurs, cellSpursJobChainGetError);
		REG_FUNC(cellSpurs, _cellSpursJobChainAttributeInitialize);
		REG_FUNC(cellSpurs, cellSpursJobChainAttributeSetName);
		REG_FUNC(cellSpurs, cellSpursJobChainAttributeSetHaltOnError);
		REG_FUNC(cellSpurs, cellSpursJobChainAttributeSetJobTypeMemoryCheck);
		REG_FUNC(cellSpurs, cellSpursGetJobChainId);
		REG_FUNC(cellSpurs, cellSpursJobChainSetExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursJobChainUnsetExceptionEventHandler);
		REG_FUNC(cellSpurs, cellSpursGetJobChainInfo);
		REG_FUNC(cellSpurs, cellSpursJobChainGetSpursAddress);

		// Job Guard
		REG_FUNC(cellSpurs, cellSpursJobGuardInitialize);
		REG_FUNC(cellSpurs, cellSpursJobGuardNotify);
		REG_FUNC(cellSpurs, cellSpursJobGuardReset);

		// LFQueue
		REG_FUNC(cellSpurs, _cellSpursLFQueueInitialize);
		REG_FUNC(cellSpurs, _cellSpursLFQueuePushBody);
		REG_FUNC(cellSpurs, cellSpursLFQueueAttachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursLFQueueDetachLv2EventQueue);
		REG_FUNC(cellSpurs, _cellSpursLFQueuePopBody);
		REG_FUNC(cellSpurs, cellSpursLFQueueGetTasksetAddress);

		// Queue
		REG_FUNC(cellSpurs, _cellSpursQueueInitialize);
		REG_FUNC(cellSpurs, cellSpursQueuePopBody);
		REG_FUNC(cellSpurs, cellSpursQueuePushBody);
		REG_FUNC(cellSpurs, cellSpursQueueAttachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursQueueDetachLv2EventQueue);
		REG_FUNC(cellSpurs, cellSpursQueueGetTasksetAddress);
		REG_FUNC(cellSpurs, cellSpursQueueClear);
		REG_FUNC(cellSpurs, cellSpursQueueDepth);
		REG_FUNC(cellSpurs, cellSpursQueueGetEntrySize);
		REG_FUNC(cellSpurs, cellSpursQueueSize);
		REG_FUNC(cellSpurs, cellSpursQueueGetDirection);

		// Workload
		REG_FUNC(cellSpurs, cellSpursWorkloadAttributeSetName);
		REG_FUNC(cellSpurs, cellSpursWorkloadAttributeSetShutdownCompletionEventHook);
		REG_FUNC(cellSpurs, cellSpursAddWorkloadWithAttribute);
		REG_FUNC(cellSpurs, cellSpursAddWorkload);
		REG_FUNC(cellSpurs, cellSpursShutdownWorkload);
		REG_FUNC(cellSpurs, cellSpursWaitForWorkloadShutdown);
		REG_FUNC(cellSpurs, cellSpursRemoveSystemWorkloadForUtility);
		REG_FUNC(cellSpurs, cellSpursRemoveWorkload);
		REG_FUNC(cellSpurs, cellSpursReadyCountStore);
		REG_FUNC(cellSpurs, cellSpursGetWorkloadFlag);
		REG_FUNC(cellSpurs, _cellSpursWorkloadFlagReceiver);
		REG_FUNC(cellSpurs, _cellSpursWorkloadAttributeInitialize);
		REG_FUNC(cellSpurs, cellSpursSendWorkloadSignal);
		REG_FUNC(cellSpurs, cellSpursGetWorkloadData);
		REG_FUNC(cellSpurs, cellSpursReadyCountAdd);
		REG_FUNC(cellSpurs, cellSpursReadyCountCompareAndSwap);
		REG_FUNC(cellSpurs, cellSpursReadyCountSwap);
		REG_FUNC(cellSpurs, cellSpursRequestIdleSpu);
		REG_FUNC(cellSpurs, cellSpursGetWorkloadInfo);
		REG_FUNC(cellSpurs, cellSpursGetSpuGuid);
		REG_FUNC(cellSpurs, _cellSpursWorkloadFlagReceiver2);
		REG_FUNC(cellSpurs, cellSpursGetJobPipelineInfo);
		REG_FUNC(cellSpurs, cellSpursJobSetMaxGrab);
		REG_FUNC(cellSpurs, cellSpursJobHeaderSetJobbin2Param);

		REG_FUNC(cellSpurs, cellSpursWakeUp);
		REG_FUNC(cellSpurs, cellSpursAddUrgentCommand);
		REG_FUNC(cellSpurs, cellSpursAddUrgentCall);

		REG_FUNC(cellSpurs, cellSpursBarrierInitialize);
		REG_FUNC(cellSpurs, cellSpursBarrierGetTasksetAddress);

		REG_FUNC(cellSpurs, _cellSpursSemaphoreInitialize);
		REG_FUNC(cellSpurs, cellSpursSemaphoreGetTasksetAddress);

		// Trace
		REG_FUNC(cellSpurs, cellSpursTraceInitialize);
		REG_FUNC(cellSpurs, cellSpursTraceStart);
		REG_FUNC(cellSpurs, cellSpursTraceStop);
		REG_FUNC(cellSpurs, cellSpursTraceFinalize);

		_this->add_init_func([](ppu_static_module*)
			{
				const auto val = g_cfg.core.spu_accurate_reservations ? MFF_PERFECT : MFF_FORCED_HLE;

				REINIT_FUNC(cellSpursSetPriorities).flag(val);
				REINIT_FUNC(cellSpursAddWorkload).flag(val);
				REINIT_FUNC(cellSpursAddWorkloadWithAttribute).flag(val);
				REINIT_FUNC(cellSpursShutdownWorkload).flag(val);
				REINIT_FUNC(cellSpursReadyCountStore).flag(val);
				REINIT_FUNC(cellSpursSetPriority).flag(val);
				REINIT_FUNC(cellSpursTraceInitialize).flag(val);
				REINIT_FUNC(cellSpursWaitForWorkloadShutdown).flag(val);
				REINIT_FUNC(cellSpursRequestIdleSpu).flag(val);
				REINIT_FUNC(cellSpursRemoveWorkload).flag(val);
			});
	});
