RSX/SPU: Accurate reservation access (non-TSX)

rpcs3/Emu/Cell/Modules/cellGcmSys.cpp

@@ -93,13 +93,12 @@ void InitOffsetTable()
 {
 	const auto cfg = g_fxo->get<gcm_config>();
 
-	cfg->offsetTable.ioAddress.set(vm::alloc(3072 * sizeof(u16), vm::main));
-	cfg->offsetTable.eaAddress.set(vm::alloc(512 * sizeof(u16), vm::main));
+	const u32 addr = vm::alloc((3072 + 512) * sizeof(u16), vm::main);
 
-	std::memset(cfg->offsetTable.ioAddress.get_ptr(), 0xFF, 3072 * sizeof(u16));
-	std::memset(cfg->offsetTable.eaAddress.get_ptr(), 0xFF, 512 * sizeof(u16));
+	cfg->offsetTable.ioAddress.set(addr);
+	cfg->offsetTable.eaAddress.set(addr + (3072 * sizeof(u16)));
 
-	cfg->reserved_size = 0;
+	std::memset(vm::base(addr), 0xFF, (3072 + 512) * sizeof(u16));
 }
 
 //----------------------------------------------------------------------------
@@ -1076,16 +1075,11 @@ error_code cellGcmReserveIoMapSize(u32 size)
 	return CELL_OK;
 }
 
-error_code cellGcmUnmapEaIoAddress(u32 ea)
+error_code GcmUnmapIoAddress(gcm_config* cfg, u32 io)
 {
-	cellGcmSys.warning("cellGcmUnmapEaIoAddress(ea=0x%x)", ea);
-
-	const auto cfg = g_fxo->get<gcm_config>();
-	std::lock_guard lock(cfg->gcmio_mutex);
-
-	if (u32 size = cfg->IoMapTable[ea >>= 20], io = cfg->offsetTable.ioAddress[ea]; size && io <= 0xBFF)
+	if (u32 ea = cfg->offsetTable.eaAddress[io >>= 20], size = cfg->IoMapTable[ea]; size)
 	{
-		if (auto error = sys_rsx_context_iounmap(0x55555555, io << 20, size << 20))
+		if (auto error = sys_rsx_context_iounmap(0x55555555, io, size << 20))
 		{
 			return error;
 		}
@@ -1105,34 +1099,40 @@ error_code cellGcmUnmapEaIoAddress(u32 ea)
 	return CELL_GCM_ERROR_FAILURE;
 }
 
-error_code cellGcmUnmapIoAddress(u32 io)
+error_code cellGcmUnmapEaIoAddress(u32 ea)
 {
-	cellGcmSys.warning("cellGcmUnmapIoAddress(io=0x%x)", io);
+	cellGcmSys.warning("cellGcmUnmapEaIoAddress(ea=0x%x)", ea);
 
-	const auto cfg = g_fxo->get<gcm_config>();
-	std::lock_guard lock(cfg->gcmio_mutex);
+	// Ignores lower bits
+	ea >>= 20;
 
-	if (u32 ea = cfg->offsetTable.eaAddress[io >>= 20], size = cfg->IoMapTable[ea]; size)
+	if (ea > 0xBFF)
 	{
-		if (auto error = sys_rsx_context_iounmap(0x55555555, io, size << 20))
-		{
-			return error;
-		}
+		return CELL_GCM_ERROR_FAILURE;
+	}
 
-		const auto render = rsx::get_current_renderer();
-		for (u32 i = 0; i < size; i++)
-		{
-			cfg->offsetTable.ioAddress[ea + i] = 0xFFFF;
-			cfg->offsetTable.eaAddress[io + i] = 0xFFFF;
-		}
+	const auto cfg = g_fxo->get<gcm_config>();
+	std::lock_guard lock(cfg->gcmio_mutex);
 
-		cfg->IoMapTable[ea] = 0;
-		return CELL_OK;
+	if (const u32 io = cfg->offsetTable.ioAddress[ea] << 20;
+		io < rsx::get_current_renderer()->main_mem_size)
+	{
+		return GcmUnmapIoAddress(cfg, io);
 	}
 
 	return CELL_GCM_ERROR_FAILURE;
 }
 
+error_code cellGcmUnmapIoAddress(u32 io)
+{
+	cellGcmSys.warning("cellGcmUnmapIoAddress(io=0x%x)", io);
+
+	const auto cfg = g_fxo->get<gcm_config>();
+	std::lock_guard lock(cfg->gcmio_mutex);
+
+	return GcmUnmapIoAddress(cfg, io);
+}
+
 error_code cellGcmUnreserveIoMapSize(u32 size)
 {
 	cellGcmSys.trace("cellGcmUnreserveIoMapSize(size=0x%x)", size);

rpcs3/Emu/Cell/Modules/cellGcmSys.h

@@ -30,7 +30,7 @@ struct gcm_config
 	CellGcmContextData current_context;
 	gcmInfo gcm_info;
 
-	CellGcmOffsetTable offsetTable;
+	CellGcmOffsetTable offsetTable{};
 	u16 IoMapTable[0xC00]{};
 	shared_mutex gcmio_mutex;
 

rpcs3/Emu/Cell/SPUThread.cpp

@@ -5,6 +5,7 @@
 #include "Emu/Memory/vm_reservation.h"
 
 #include "Emu/IdManager.h"
+#include "Emu/RSX/RSXThread.h"
 #include "Emu/Cell/PPUThread.h"
 #include "Emu/Cell/ErrorCodes.h"
 #include "Emu/Cell/lv2/sys_spu.h"
@@ -67,6 +68,26 @@ static FORCE_INLINE void mov_rdata(decltype(spu_thread::rdata)& dst, const declt
 	}
 }
 
+// Returns nullptr if rsx does not need pausing on reservations op, rsx ptr otherwise
+static FORCE_INLINE rsx::thread* get_rsx_if_needs_res_pause(u32 addr)
+{
+	if (!g_cfg.core.rsx_accurate_res_access) [[likely]]
+	{
+		return {};
+	}
+
+	const auto render = rsx::get_current_renderer();
+
+	ASSUME(render);
+
+	if (render->iomap_table.io[addr >> 20] == -1) [[likely]]
+	{
+		return {};
+	}
+
+	return render;
+}
+
 extern u64 get_timebased_time();
 extern u64 get_system_time();
 
@@ -1655,12 +1676,20 @@ void spu_thread::do_putlluc(const spu_mfc_cmd& args)
 
 		if (g_cfg.core.spu_accurate_putlluc)
 		{
-			// Full lock (heavyweight)
-			// TODO: vm::check_addr
+			const auto render = get_rsx_if_needs_res_pause(addr);
+
+			if (render) render->pause();
+
 			auto& super_data = *vm::get_super_ptr<decltype(rdata)>(addr);
-			vm::writer_lock lock(addr);
-			mov_rdata(super_data, to_write);
-			res.release(res.load() + 127);
+			{
+				// Full lock (heavyweight)
+				// TODO: vm::check_addr
+				vm::writer_lock lock(addr);
+				mov_rdata(super_data, to_write);
+				res.release(res.load() + 127);
+			}
+
+			if (render) render->unpause();
 		}
 		else
 		{
@@ -1868,15 +1897,23 @@ bool spu_thread::process_mfc_cmd()
 			if (g_cfg.core.spu_accurate_getllar)
 			{
 				*reinterpret_cast<atomic_t<u32>*>(&data) += 0;
+
+				const auto render = get_rsx_if_needs_res_pause(addr);
+
+				if (render) render->pause();
+
 				const auto& super_data = *vm::get_super_ptr<decltype(rdata)>(addr);
+				{
+					// Full lock (heavyweight)
+					// TODO: vm::check_addr
+					vm::writer_lock lock(addr);
 
-				// Full lock (heavyweight)
-				// TODO: vm::check_addr
-				vm::writer_lock lock(addr);
+					ntime = old_time;
+					mov_rdata(dst, super_data);
+					res.release(old_time);
+				}
 
-				ntime = old_time;
-				mov_rdata(dst, super_data);
-				res.release(old_time);
+				if (render) render->unpause();
 			}
 			else
 			{
@@ -1969,22 +2006,29 @@ bool spu_thread::process_mfc_cmd()
 					{
 						*reinterpret_cast<atomic_t<u32>*>(&data) += 0;
 
-						auto& super_data = *vm::get_super_ptr<decltype(rdata)>(addr);
+						const auto render = get_rsx_if_needs_res_pause(addr);
 
-						// Full lock (heavyweight)
-						// TODO: vm::check_addr
-						vm::writer_lock lock(addr);
+						if (render) render->pause();
 
-						if (cmp_rdata(rdata, super_data))
-						{
-							mov_rdata(super_data, to_write);
-							res.release(old_time + 128);
-							result = 1;
-						}
-						else
+						auto& super_data = *vm::get_super_ptr<decltype(rdata)>(addr);
 						{
-							res.release(old_time);
+							// Full lock (heavyweight)
+							// TODO: vm::check_addr
+							vm::writer_lock lock(addr);
+
+							if (cmp_rdata(rdata, super_data))
+							{
+								mov_rdata(super_data, to_write);
+								res.release(old_time + 128);
+								result = 1;
+							}
+							else
+							{
+								res.release(old_time);
+							}
 						}
+
+						if (render) render->unpause();
 					}
 					else
 					{

rpcs3/Emu/RSX/RSXThread.cpp

@@ -615,9 +615,7 @@ namespace rsx
 			// Wait for external pause events
 			if (external_interrupt_lock)
 			{
-				external_interrupt_ack.store(true);
-
-				while (external_interrupt_lock) _mm_pause();
+				wait_pause();
 			}
 
 			// Note a possible rollback address
@@ -2468,10 +2466,7 @@ namespace rsx
 	//Pause/cont wrappers for FIFO ctrl. Never call this from rsx thread itself!
 	void thread::pause()
 	{
-		while (external_interrupt_lock.exchange(true)) [[unlikely]]
-		{
-			_mm_pause();
-		}
+		external_interrupt_lock++;
 
 		while (!external_interrupt_ack)
 		{
@@ -2480,14 +2475,34 @@ namespace rsx
 
 			_mm_pause();
 		}
-
-		external_interrupt_ack.store(false);
 	}
 
 	void thread::unpause()
 	{
 		// TODO: Clean this shit up
-		external_interrupt_lock.store(false);
+		external_interrupt_lock--;
+	}
+
+	void thread::wait_pause()
+	{
+		do
+		{
+			if (g_cfg.video.multithreaded_rsx)
+			{
+				g_dma_manager.sync();
+			}
+
+			external_interrupt_ack.store(true);
+
+			while (external_interrupt_lock)
+			{
+				// TODO: Investigate non busy-spinning method
+				_mm_pause();
+			}
+
+			external_interrupt_ack.store(false);
+		}
+		while (external_interrupt_lock);
 	}
 
 	u32 thread::get_load()

rpcs3/Emu/RSX/RSXThread.h

@@ -599,7 +599,7 @@ namespace rsx
 		RsxDmaControl* ctrl = nullptr;
 		rsx_iomap_table iomap_table;
 		u32 restore_point = 0;
-		atomic_t<bool> external_interrupt_lock{ false };
+		atomic_t<u32> external_interrupt_lock{ 0 };
 		atomic_t<bool> external_interrupt_ack{ false };
 		void flush_fifo();
 		void recover_fifo();
@@ -899,6 +899,7 @@ namespace rsx
 
 		void pause();
 		void unpause();
+		void wait_pause();
 
 		// Get RSX approximate load in %
 		u32 get_load();

rpcs3/Emu/RSX/rsx_methods.cpp

@@ -98,17 +98,26 @@ namespace rsx
 				if (Emu.IsStopped())
 					return;
 
+				// Wait for external pause events
+				if (rsx->external_interrupt_lock)
+				{
+					rsx->wait_pause();
+					continue;
+				}
+
 				if (const auto tdr = static_cast<u64>(g_cfg.video.driver_recovery_timeout))
 				{
 					if (Emu.IsPaused())
 					{
+						const u64 start0 = get_system_time();
+
 						while (Emu.IsPaused())
 						{
 							std::this_thread::sleep_for(1ms);
 						}
 
 						// Reset
-						start = get_system_time();
+						start += get_system_time() - start0;
 					}
 					else
 					{
@@ -827,6 +836,8 @@ namespace rsx
 				const u32 pixel_offset = (method_registers.blit_engine_output_pitch_nv3062() * y) + (x * write_len);
 				u32 address = get_address(method_registers.blit_engine_output_offset_nv3062() + pixel_offset + (index * write_len), method_registers.blit_engine_output_location_nv3062(), HERE);
 
+				//auto res = vm::passive_lock(address, address + write_len);
+
 				switch (write_len)
 				{
 				case 4:
@@ -839,6 +850,7 @@ namespace rsx
 					fmt::throw_exception("Unreachable" HERE);
 				}
 
+				//res->release(0);
 				rsx->m_graphics_state |= rsx::pipeline_state::fragment_program_dirty;
 			}
 		};
@@ -980,6 +992,9 @@ namespace rsx
 			const u32 dst_address = get_address(dst_offset, dst_dma, HERE);
 
 			const u32 src_line_length = (in_w * in_bpp);
+
+			//auto res = vm::passive_lock(dst_address, dst_address + (in_pitch * (in_h - 1) + src_line_length));
+
 			if (is_block_transfer && (clip_h == 1 || (in_pitch == out_pitch && src_line_length == in_pitch)))
 			{
 				const u32 nb_lines = std::min(clip_h, in_h);
@@ -1347,6 +1362,8 @@ namespace rsx
 				}
 			}
 
+			//auto res = vm::passive_lock(write_address, data_length + write_address);
+
 			u8 *dst = vm::_ptr<u8>(write_address);
 			const u8 *src = vm::_ptr<u8>(read_address);
 
@@ -1402,6 +1419,8 @@ namespace rsx
 					}
 				}
 			}
+
+			//res->release(0);
 		}
 	}
 

rpcs3/Emu/system_config.h

@@ -38,6 +38,7 @@ struct cfg_root : cfg::node
 		cfg::_enum<spu_block_size_type> spu_block_size{ this, "SPU Block Size", spu_block_size_type::safe };
 		cfg::_bool spu_accurate_getllar{ this, "Accurate GETLLAR", false };
 		cfg::_bool spu_accurate_putlluc{ this, "Accurate PUTLLUC", false };
+		cfg::_bool rsx_accurate_res_access{this, "Accurate RSX reservation access", false, true};
 		cfg::_bool spu_verification{ this, "SPU Verification", true }; // Should be enabled
 		cfg::_bool spu_cache{ this, "SPU Cache", true };
 		cfg::_bool spu_prof{ this, "SPU Profiler", false };