Fixed a re-entry condition when trying to use the SysCoreThread::ApplySettings() directly; and fixed some threading issues in the resume code too.

Dev Note: EmuConfig is now *const*, and can *only* be modified by a call to ApplySettings(), which itself cannot be called from its own thread.  This protects against accidental thread-unsafe on-the-fly settings changes.  Amazingly we had only one such settings change in the existing trunk.  I fixed it ;)

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@1903 96395faa-99c1-11dd-bbfe-3dabce05a288

pcsx2/Config.h

@@ -334,7 +334,7 @@ struct SessionOverrideFlags
 		ForceDisableVU1rec:1;
 };
 
-extern Pcsx2Config EmuConfig;
+extern const Pcsx2Config EmuConfig;
 extern SessionOverrideFlags g_Session;
 
 /////////////////////////////////////////////////////////////////////////////////////////

pcsx2/GS.cpp

@@ -87,11 +87,7 @@ void gsSetRegionMode( GS_RegionMode region )
 // Make sure framelimiter options are in sync with the plugin's capabilities.
 void gsInit()
 {
-	if( EmuConfig.Video.EnableFrameSkipping && (GSsetFrameSkip == NULL) )
-	{
-		EmuConfig.Video.EnableFrameSkipping = false;
-		Console::WriteLn("Notice: Disabling frameskipping -- GS plugin does not support it.");
-	}
+	memzero_obj(g_RealGSMem);
 }
 
 void gsReset()

pcsx2/PluginManager.cpp

@@ -145,7 +145,6 @@ _GSprintf      	   GSprintf;
 _GSsetBaseMem 	   GSsetBaseMem;
 _GSsetGameCRC		GSsetGameCRC;
 _GSsetFrameSkip	   GSsetFrameSkip;
-_GSsetFrameLimit   GSsetFrameLimit;
 _GSsetupRecording	GSsetupRecording;
 _GSreset		   GSreset;
 _GSwriteCSR		   GSwriteCSR;
@@ -153,6 +152,7 @@ _GSwriteCSR		   GSwriteCSR;
 static void CALLBACK GS_makeSnapshot(const char *path) {}
 static void CALLBACK GS_setGameCRC(u32 crc, int gameopts) {}
 static void CALLBACK GS_irqCallback(void (*callback)()) {}
+static void CALLBACK GS_setFrameSkip(int frameskip) {}
 static void CALLBACK GS_printf(int timeout, char *fmt, ...)
 {
 	va_list list;
@@ -279,6 +279,8 @@ static const LegacyApi_ReqMethod s_MethMessReq_GS[] =
 	{	"GSsetBaseMem",		(vMeth**)&GSsetBaseMem,		NULL	},
 	{	"GSwriteCSR",		(vMeth**)&GSwriteCSR,		NULL	},
 	{	"GSsetGameCRC",		(vMeth**)&GSsetGameCRC,		(vMeth*)GS_setGameCRC },
+
+	{	"GSsetFrameSkip",	(vMeth**)&GSsetFrameSkip,	(vMeth*)GS_setFrameSkip	},
 	{ NULL }
 };
 
@@ -287,8 +289,6 @@ static const LegacyApi_OptMethod s_MethMessOpt_GS[] =
 	{	"GSopen2",			(vMeth**)&GSopen2			},
 	{	"GSreset",			(vMeth**)&GSreset			},
 	{	"GSsetupRecording",	(vMeth**)&GSsetupRecording	},
-	{	"GSsetFrameSkip",	(vMeth**)&GSsetFrameSkip	},
-	{	"GSsetFrameLimit",	(vMeth**)&GSsetFrameLimit	},
 	{	"GSchangeSaveState",(vMeth**)&GSchangeSaveState	},
 	{	"GSmakeSnapshot2",	(vMeth**)&GSmakeSnapshot2	},
 	{	"GSgifSoftReset",	(vMeth**)&GSgifSoftReset	},

pcsx2/System.cpp

@@ -35,7 +35,7 @@
 
 using namespace std;
 
-Pcsx2Config EmuConfig;
+const Pcsx2Config EmuConfig;
 
 // disable all session overrides by default...
 SessionOverrideFlags	g_Session = {false};

pcsx2/gui/App.h

@@ -443,8 +443,9 @@ public:
 	virtual ~AppEmuThread() throw();
 
 	virtual void Suspend( bool isBlocking=true );
-	virtual void Resume();
 	virtual void StateCheck();
+	virtual void ApplySettings( const Pcsx2Config& src );
+	virtual void OnResumeReady();
 
 protected:
 	sptr ExecuteTask();

pcsx2/gui/AppMain.cpp

@@ -79,23 +79,24 @@ void AppEmuThread::Suspend( bool isBlocking )
 {
 	SysCoreThread::Suspend( isBlocking );
 	AppInvoke( MainFrame, ApplySettings() );
-}
 
-void AppEmuThread::Resume()
-{
-	// Clear the sticky key statuses, because hell knows what's changed while the PAD
-	// plugin was suspended.
+	// Clear the sticky key statuses, because hell knows what'll change while the PAD
+	// plugin is suspended.
 
 	m_kevt.m_shiftDown		= false;
 	m_kevt.m_controlDown	= false;
 	m_kevt.m_altDown		= false;
+}
+
+void AppEmuThread::OnResumeReady()
+{
+	DevAssert( wxThread::IsMain(), "SysCoreThread can only be resumed from the main/gui thread." );
 
 	ApplySettings( g_Conf->EmuOptions );
 
 	if( GSopen2 != NULL )
 		wxGetApp().OpenGsFrame();
 
-	SysCoreThread::Resume();
 	AppInvoke( MainFrame, ApplySettings() );
 }
 
@@ -141,6 +142,18 @@ void AppEmuThread::StateCheck()
 	wxGetApp().PostPadKey( m_kevt );
 }
 
+void AppEmuThread::ApplySettings( const Pcsx2Config& src )
+{
+	// Re-entry guard protects against cases where code wants to manually set core settings
+	// which are not part of g_Conf.  The subsequent call to apply g_Conf settings (which is
+	// usually the desired behavior) will be ignored.
+
+	static int localc = 0;
+	EntryGuard guard( localc );
+	if(guard.IsReentrant()) return;
+	SysCoreThread::ApplySettings( src );
+}
+
 __forceinline bool EmulationInProgress()
 {
 	return wxGetApp().EmuInProgress();

pcsx2/ps2/CoreEmuThread.cpp

@@ -238,6 +238,8 @@ void SysCoreThread::Resume()
 	DevAssert( (m_ExecMode == ExecMode_Suspended) || (m_ExecMode == ExecMode_Idle),
 		"EmuCoreThread is not in a suspended or idle state?  wtf!" );
 
+	OnResumeReady();
+
 	if( m_resetRecompilers || m_resetProfilers )
 	{
 		SysClearExecutionCache();
@@ -285,13 +287,13 @@ void SysCoreThread::ApplySettings( const Pcsx2Config& src )
 {
 	if( src == EmuConfig ) return;
 
-	const bool isRunning = IsRunning();
+	const bool isSuspended = IsSuspended();
 	Suspend();
 
 	m_resetRecompilers = ( src.Cpu != EmuConfig.Cpu ) || ( src.Gamefixes != EmuConfig.Gamefixes ) || ( src.Speedhacks != EmuConfig.Speedhacks );
 	m_resetProfilers = (src.Profiler != EmuConfig.Profiler );
-	EmuConfig = src;
+	const_cast<Pcsx2Config&>(EmuConfig) = src;
 
-	if( isRunning ) Resume();
+	if( !isSuspended ) Resume();
 }
 

pcsx2/ps2/CoreEmuThread.h

@@ -60,6 +60,11 @@ public:
 
 	virtual void DoThreadCleanup();
 
+	// This function is called by Resume immediately prior to releasing the suspension of
+	// the core emulation thread.  You should overload this rather than Resume(), since
+	// Resume() has a lot of checks and balances to prevent re-entrance and race conditions.
+	virtual void OnResumeReady() {};
+
 protected:
 	void CpuInitializeMess();
 	void CpuExecute();