PPPPPPPUUUUUUUU

Author: elad335

rpcs3/Emu/Cell/SPUThread.cpp

@@ -425,6 +425,28 @@ extern void mov_rdata_nt(spu_rdata_t& _dst, const spu_rdata_t& _src)
 #endif
 }
 
+static inline u32 cmp16_rdata(const decltype(spu_thread::rdata)& rdata, const decltype(spu_thread::rdata)& to_write)
+{
+	u32 diffcnt = 0;
+	u32 pos = 0;
+
+	for (u32 i = 0; i < 8; i++)
+	{
+		if (std::memcmp(rdata + (i * 16), to_write + (i * 16), 16))
+		{
+			diffcnt++;
+			pos = i;
+		}
+	};
+
+	if (diffcnt == 1)
+	{
+		return pos;
+	}
+
+	return -1;
+}
+
 #if defined(_MSC_VER)
 #define mwaitx_func
 #define waitpkg_func
@@ -3968,17 +3990,52 @@ bool spu_thread::do_putllc(const spu_mfc_cmd& args)
 		auto& super_data = *vm::get_super_ptr<spu_rdata_t>(addr);
 		const bool success = [&]()
 		{
-			// Full lock (heavyweight)
-			// TODO: vm::check_addr
-			vm::writer_lock lock(addr, range_lock);
-
-			if (cmp_rdata(rdata, super_data))
+			if (int pos = cmp16_rdata(rdata, to_write); addr != spurs_addr && pos != -1)
 			{
-				mov_rdata(super_data, to_write);
-				return true;
+				auto& bits = *utils::bless<atomic_t<u64>>(vm::g_reservations + ((addr & 0xff80) / 2 + 32));
+				const auto bits_val = +bits;
+
+				// Full lock (heavyweight)
+				// TODO: vm::check_addr
+				const bool halt_ppus = bits_val == umax || bits_val < 0x100000;
+
+				if (vm::writer_lock lock(addr, range_lock, halt_ppus); cmp_rdata(rdata, super_data))
+				{
+					auto cast_as = [](void* ptr, usz pos){ return reinterpret_cast<u128*>(ptr) + pos; };
+					auto cast_as_const = [](const void* ptr, usz pos){ return reinterpret_cast<const u128*>(ptr) + pos; };
+
+					if (halt_ppus)
+					{
+						*cast_as(super_data, pos) = *cast_as_const(to_write, pos);
+						bits.try_inc(u64{umax});
+						return true;
+					}
+					else if (atomic_storage<u128>::compare_exchange(*cast_as(super_data, pos), *cast_as(rdata, pos), *cast_as_const(to_write, pos)))
+					{
+						bits.try_inc(u64{umax});
+						*cast_as(rdata, pos) = *cast_as_const(to_write, pos);
+						ensure(cmp_rdata(rdata, super_data));
+						return true;
+					}
+				}
+
+				bits = u64{umax};
+				return false;
 			}
+			else
+			{
+				// Full lock (heavyweight)
+				// TODO: vm::check_addr
+				vm::writer_lock lock(addr, range_lock);
 
-			return false;
+				if (cmp_rdata(rdata, super_data))
+				{
+					mov_rdata(super_data, to_write);
+					return true;
+				}
+
+				return false;
+			}
 		}();
 
 		res += success ? 64 : 0 - 64;

rpcs3/Emu/Memory/vm.cpp

@@ -8,6 +8,7 @@
 #include "Utilities/address_range.h"
 #include "Emu/CPU/CPUThread.h"
 #include "Emu/RSX/RSXThread.h"
+#include "Emu/Cell/PPUThread.h"
 #include "Emu/Cell/SPURecompiler.h"
 #include "Emu/perf_meter.hpp"
 #include <deque>
@@ -402,7 +403,7 @@ namespace vm
 					return;
 				}
 
-				if (i < 100)
+				if (1 || i < 100)
 					busy_wait(200);
 				else
 					std::this_thread::yield();
@@ -455,14 +456,57 @@ namespace vm
 		}
 	}
 
+	void check_locked_ppu()
+	{
+		return;
+		while (true)
+		{
+			const u64 tsc = utils::get_tsc();
+
+			for (auto lock = g_locks.cbegin(), end = lock + g_cfg.core.ppu_threads; lock != end; lock++)
+			{
+				if (auto ptr = static_cast<named_thread<ppu_thread>*>(lock->load()))
+				{
+					const u32 cia = ptr->cia;
+					const u32 ctr = ptr->ctr;
+					const u32 r0 = ptr->gpr[0];
+					bool added_temp = false;
+
+					for (utils::pause(); cpu_flag::wait - ptr->state && cia == ptr->cia && ctr == ptr->ctr && r0 == ptr->gpr[0]; )
+					{
+						if (!added_temp)
+						{
+							ptr->state.test_and_set(cpu_flag::measure);
+							added_temp = true;
+						}
+
+						utils::pause();
+
+						if (added_temp && cpu_flag::measure - ptr->state)
+						{
+							break;
+						}
+					}
+				}
+			}
+
+			//f (utils::get_tsc() - tsc < 7000)
+				break;
+		}
+	}
+
 	writer_lock::writer_lock() noexcept
 		: writer_lock(0, nullptr, 1)
 	{
 	}
 
-	writer_lock::writer_lock(u32 const addr, atomic_t<u64, 64>* range_lock, u32 const size, u64 const flags) noexcept
+	writer_lock::writer_lock(u32 const addr, atomic_t<u64, 64>* range_lock, bool halt_ppus) noexcept
 		: range_lock(range_lock)
 	{
+		// Constant-ized arguments
+		constexpr u32 size = 128;
+		constexpr u64 flags = vm::range_locked;
+
 		cpu_thread* cpu{};
 
 		if (g_tls_locked)
@@ -578,17 +622,17 @@ namespace vm
 				utils::pause();
 			}
 
-			for (auto lock = g_locks.cbegin(), end = lock + g_cfg.core.ppu_threads; lock != end; lock++)
+			for (auto lock = g_locks.cbegin(), end = lock + g_cfg.core.ppu_threads; halt_ppus && lock != end; lock++)
 			{
 				if (auto ptr = +*lock; ptr && ptr->state.none_of(cpu_flag::wait + cpu_flag::memory))
 				{
 					ptr->state.test_and_set(cpu_flag::memory);
 				}
 			}
 
-			for (auto lock = g_locks.cbegin(), end = lock + g_cfg.core.ppu_threads; lock != end; lock++)
+			for (auto lock = g_locks.cbegin(), end = lock + g_cfg.core.ppu_threads; halt_ppus && lock != end; lock++)
 			{
-				if (auto ptr = +*lock)
+				if (auto ptr = static_cast<named_thread<ppu_thread>*>(lock->load()))
 				{
 					while (!(ptr->state & cpu_flag::wait))
 					{

rpcs3/Emu/Memory/vm_locking.h

@@ -96,7 +96,7 @@ namespace vm
 		writer_lock(const writer_lock&) = delete;
 		writer_lock& operator=(const writer_lock&) = delete;
 		writer_lock() noexcept;
-		writer_lock(u32 addr, atomic_t<u64, 64>* range_lock = nullptr, u32 size = 128, u64 flags = range_locked) noexcept;
+		writer_lock(u32 addr, atomic_t<u64, 64>* range_lock = nullptr, bool halt_ppus = true) noexcept;
 		~writer_lock() noexcept;
 	};
 } // namespace vm