/[pcsx2_0.9.7]/trunk/pcsx2/VUmicro.h
ViewVC logotype

Contents of /trunk/pcsx2/VUmicro.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 280 - (show annotations) (download)
Thu Dec 23 12:02:12 2010 UTC (9 years, 6 months ago) by william
File MIME type: text/plain
File size: 9816 byte(s)
re-commit (had local access denied errors when committing)
1 /* PCSX2 - PS2 Emulator for PCs
2 * Copyright (C) 2002-2010 PCSX2 Dev Team
3 *
4 * PCSX2 is free software: you can redistribute it and/or modify it under the terms
5 * of the GNU Lesser General Public License as published by the Free Software Found-
6 * ation, either version 3 of the License, or (at your option) any later version.
7 *
8 * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 * PURPOSE. See the GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License along with PCSX2.
13 * If not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #pragma once
17
18 #include "VU.h"
19 #include "VUops.h"
20 #include "R5900.h"
21
22 static const uint VU0_MEMSIZE = 0x1000; // 4kb
23 static const uint VU0_PROGSIZE = 0x1000; // 4kb
24 static const uint VU1_MEMSIZE = 0x4000; // 16kb
25 static const uint VU1_PROGSIZE = 0x4000; // 16kb
26
27 static const uint VU0_MEMMASK = VU0_MEMSIZE-1;
28 static const uint VU0_PROGMASK = VU0_PROGSIZE-1;
29 static const uint VU1_MEMMASK = VU1_MEMSIZE-1;
30 static const uint VU1_PROGMASK = VU1_PROGSIZE-1;
31
32 #define vuRunCycles (512*12) // Cycles to run ExecuteBlockJIT() for (called from within recs)
33 #define vu0RunCycles (512*12) // Cycles to run vu0 for whenever ExecuteBlock() is called
34 #define vu1RunCycles (3000000) // mVU1 uses this for inf loop detection on dev builds
35
36 // --------------------------------------------------------------------------------------
37 // BaseCpuProvider
38 // --------------------------------------------------------------------------------------
39 //
40 // Design Note: This class is only partial C++ style. It still relies on Alloc and Shutdown
41 // calls for memory and resource management. This is because the underlying implementations
42 // of our CPU emulators don't have properly encapsulated objects yet -- if we allocate ram
43 // in a constructor, it won't get free'd if an exception occurs during object construction.
44 // Once we've resolved all the 'dangling pointers' and stuff in the recompilers, Alloc
45 // and Shutdown can be removed in favor of constructor/destructor syntax.
46 //
47 class BaseCpuProvider
48 {
49 protected:
50 // allocation counter for multiple calls to Reserve. Most implementations should utilize
51 // this variable for sake of robustness.
52 u32 m_Reserved;
53
54 public:
55 // this boolean indicates to some generic logging facilities if the VU's registers
56 // are valid for logging or not. (see DisVU1Micro.cpp, etc) [kinda hacky, might
57 // be removed in the future]
58 bool IsInterpreter;
59
60 public:
61 BaseCpuProvider()
62 {
63 m_Reserved = 0;
64 }
65
66 virtual ~BaseCpuProvider() throw()
67 {
68 if( m_Reserved != 0 )
69 Console.Warning( "Cleanup miscount detected on CPU provider. Count=%d", m_Reserved );
70 }
71
72 virtual const char* GetShortName() const=0;
73 virtual wxString GetLongName() const=0;
74
75 // returns the number of bytes committed to the working caches for this CPU
76 // provider (typically this refers to recompiled code caches, but could also refer
77 // to other optional growable allocations).
78 virtual size_t GetCommittedCache() const
79 {
80 return 0;
81 }
82
83 virtual void Reserve()=0;
84 virtual void Shutdown()=0;
85 virtual void Reset()=0;
86 virtual void Execute(u32 cycles)=0;
87 virtual void ExecuteBlock(bool startUp)=0;
88
89 virtual void Step()=0;
90 virtual void Clear(u32 Addr, u32 Size)=0;
91
92 // C++ Calling Conventions are unstable, and some compilers don't even allow us to take the
93 // address of C++ methods. We need to use a wrapper function to invoke the ExecuteBlock from
94 // recompiled code.
95 static void __fastcall ExecuteBlockJIT( BaseCpuProvider* cpu )
96 {
97 cpu->Execute(1024);
98 }
99
100 // Gets the current cache reserve allocated to this CPU (value returned in megabytes)
101 virtual uint GetCacheReserve() const=0;
102
103 // Specifies the maximum cache reserve amount for this CPU (value in megabytes).
104 // CPU providers are allowed to reset their reserves (recompiler resets, etc) if such is
105 // needed to conform to the new amount requested.
106 virtual void SetCacheReserve( uint reserveInMegs ) const=0;
107
108 };
109
110 // --------------------------------------------------------------------------------------
111 // BaseVUmicroCPU
112 // --------------------------------------------------------------------------------------
113 // Layer class for possible future implementation (currently is nothing more than a type-safe
114 // type define).
115 //
116 class BaseVUmicroCPU : public BaseCpuProvider {
117 public:
118 int m_Idx;
119 u32 m_lastEEcycles;
120
121 BaseVUmicroCPU() {
122 m_Idx = 0;
123 m_lastEEcycles = 0;
124 }
125 virtual ~BaseVUmicroCPU() throw() {}
126
127 // Called by the PS2 VM's event manager for every internal vertical sync (occurs at either
128 // 50hz (pal) or 59.94hz (NTSC).
129 //
130 // Exceptions:
131 // This method is not allowed to throw exceptions, since exceptions may not propagate
132 // safely from the context of recompiled code stackframes.
133 //
134 // Thread Affinity:
135 // Called from the EEcore thread. No locking is performed, so any necessary locks must
136 // be implemented by the CPU provider manually.
137 //
138 virtual void Vsync() throw() { }
139
140 virtual void Step() {
141 // Ideally this would fall back on interpretation for executing single instructions
142 // for all CPU types, but due to VU complexities and large discrepancies between
143 // clamping in recs and ints, it's not really worth bothering with yet.
144 }
145
146 // Execute VU for the number of VU cycles (recs might go over 0~30 cycles)
147 // virtual void Execute(u32 cycles)=0;
148
149 // Executes a Block based on static preset cycles OR
150 // Executes a Block based on EE delta time (see VUmicro.cpp)
151 virtual void ExecuteBlock(bool startUp=0);
152
153 static void __fastcall ExecuteBlockJIT(BaseVUmicroCPU* cpu);
154 };
155
156
157 // --------------------------------------------------------------------------------------
158 // InterpVU0 / InterpVU1
159 // --------------------------------------------------------------------------------------
160 class InterpVU0 : public BaseVUmicroCPU
161 {
162 public:
163 InterpVU0();
164 virtual ~InterpVU0() throw() { Shutdown(); }
165
166 const char* GetShortName() const { return "intVU0"; }
167 wxString GetLongName() const { return L"VU0 Interpreter"; }
168
169 void Reserve() { }
170 void Shutdown() throw() { }
171 void Reset() { }
172
173 void Step();
174 void Execute(u32 cycles);
175 void Clear(u32 addr, u32 size) {}
176
177 uint GetCacheReserve() const { return 0; }
178 void SetCacheReserve( uint reserveInMegs ) const {}
179 };
180
181 class InterpVU1 : public BaseVUmicroCPU
182 {
183 public:
184 InterpVU1();
185 virtual ~InterpVU1() throw() { Shutdown(); }
186
187 const char* GetShortName() const { return "intVU1"; }
188 wxString GetLongName() const { return L"VU1 Interpreter"; }
189
190 void Reserve() { }
191 void Shutdown() throw() { }
192 void Reset() { }
193
194 void Step();
195 void Execute(u32 cycles);
196 void Clear(u32 addr, u32 size) {}
197
198 uint GetCacheReserve() const { return 0; }
199 void SetCacheReserve( uint reserveInMegs ) const {}
200 };
201
202 // --------------------------------------------------------------------------------------
203 // recMicroVU0 / recMicroVU1
204 // --------------------------------------------------------------------------------------
205 class recMicroVU0 : public BaseVUmicroCPU
206 {
207 public:
208 recMicroVU0();
209 virtual ~recMicroVU0() throw() { Shutdown(); }
210
211 const char* GetShortName() const { return "mVU0"; }
212 wxString GetLongName() const { return L"microVU0 Recompiler"; }
213
214 void Reserve();
215 void Shutdown() throw();
216
217 void Reset();
218 void Execute(u32 cycles);
219 void Clear(u32 addr, u32 size);
220 void Vsync() throw();
221
222 uint GetCacheReserve() const;
223 void SetCacheReserve( uint reserveInMegs ) const;
224 };
225
226 class recMicroVU1 : public BaseVUmicroCPU
227 {
228 public:
229 recMicroVU1();
230 virtual ~recMicroVU1() throw() { Shutdown(); }
231
232 const char* GetShortName() const { return "mVU1"; }
233 wxString GetLongName() const { return L"microVU1 Recompiler"; }
234
235 void Reserve();
236 void Shutdown() throw();
237 void Reset();
238 void Execute(u32 cycles);
239 void Clear(u32 addr, u32 size);
240 void Vsync() throw();
241
242 uint GetCacheReserve() const;
243 void SetCacheReserve( uint reserveInMegs ) const;
244 };
245
246 // --------------------------------------------------------------------------------------
247 // recSuperVU0 / recSuperVU1
248 // --------------------------------------------------------------------------------------
249
250 class recSuperVU0 : public BaseVUmicroCPU
251 {
252 public:
253 recSuperVU0();
254
255 const char* GetShortName() const { return "sVU0"; }
256 wxString GetLongName() const { return L"SuperVU0 Recompiler"; }
257
258 void Reserve();
259 void Shutdown() throw();
260 void Reset();
261 void Execute(u32 cycles);
262 void Clear(u32 Addr, u32 Size);
263
264 uint GetCacheReserve() const;
265 void SetCacheReserve( uint reserveInMegs ) const;
266 };
267
268 class recSuperVU1 : public BaseVUmicroCPU
269 {
270 public:
271 recSuperVU1();
272
273 const char* GetShortName() const { return "sVU1"; }
274 wxString GetLongName() const { return L"SuperVU1 Recompiler"; }
275
276 void Reserve();
277 void Shutdown() throw();
278 void Reset();
279 void Execute(u32 cycles);
280 void Clear(u32 Addr, u32 Size);
281
282 uint GetCacheReserve() const;
283 void SetCacheReserve( uint reserveInMegs ) const;
284 };
285
286 extern BaseVUmicroCPU* CpuVU0;
287 extern BaseVUmicroCPU* CpuVU1;
288
289
290 // VU0
291 extern void vu0ResetRegs();
292 extern void __fastcall vu0ExecMicro(u32 addr);
293 extern void vu0Exec(VURegs* VU);
294 extern void vu0Finish();
295 extern void iDumpVU0Registers();
296
297 // VU1
298 extern void vu1Finish();
299 extern void vu1ResetRegs();
300 extern void __fastcall vu1ExecMicro(u32 addr);
301 extern void vu1Exec(VURegs* VU);
302 extern void iDumpVU1Registers();
303
304 #ifdef VUM_LOG
305
306 #define IdebugUPPER(VU) \
307 VUM_LOG("%s", dis##VU##MicroUF(VU.code, VU.VI[REG_TPC].UL));
308 #define IdebugLOWER(VU) \
309 VUM_LOG("%s", dis##VU##MicroLF(VU.code, VU.VI[REG_TPC].UL));
310 #define _vuExecMicroDebug(VU) \
311 VUM_LOG("_vuExecMicro: %8.8x", VU.VI[REG_TPC].UL);
312
313 #else
314
315 #define IdebugUPPER(VU)
316 #define IdebugLOWER(VU)
317 #define _vuExecMicroDebug(VU)
318
319 #endif

  ViewVC Help
Powered by ViewVC 1.1.22