ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

mVU: minor cleanups... 

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@2680 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
cottonvibes 2010-03-07 02:44:32 +00:00
parent 0244097a26
commit 8064d9a4d4
2 changed files with 26 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
pcsx2/x86/microVU.cpp
View File

@ -171,13 +171,15 @@ _f void mVUclear(mV, u32 addr, u32 size) {
// Micro VU - Private Functions // Micro VU - Private Functions
//------------------------------------------------------------------ //------------------------------------------------------------------
// Finds and Ages/Kills Programs if they haven't been used in a while.
_f void mVUvsyncUpdate(mV) {
//mVU->prog.curFrame++;
}
// Clears program data // Clears program data
_mVUt _f void mVUclearProg(microProgram& program, bool deleteBlocks) { _mVUt _f void mVUclearProg(microProgram& program, u32 startPC, bool deleteBlocks) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
program.used = 0; program.startPC = startPC;
program.age = isDead;
program.frame = mVU->prog.curFrame;
program.startPC = 0x7fffffff;
for (int j = 0; j <= program.ranges.max; j++) { for (int j = 0; j <= program.ranges.max; j++) {
program.ranges.range[j][0] = -1; // Set range to program.ranges.range[j][0] = -1; // Set range to
program.ranges.range[j][1] = -1; // indeterminable status program.ranges.range[j][1] = -1; // indeterminable status
@ -193,11 +195,8 @@ _mVUt _f microProgram* mVUcreateProg(int startPC) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
microProgram* prog = (microProgram*)_aligned_malloc(sizeof(microProgram), 64); microProgram* prog = (microProgram*)_aligned_malloc(sizeof(microProgram), 64);
memzero_ptr<sizeof(microProgram)>(prog); memzero_ptr<sizeof(microProgram)>(prog);
mVUclearProg<vuIndex>(*prog); prog->idx = mVU->prog.total++;
prog->age = isYoung; mVUclearProg<vuIndex>(*prog, startPC);
prog->used = 1;
prog->idx = mVU->prog.total++;
prog->startPC = startPC;
mVUcacheProg<vuIndex>(*prog); // Cache Micro Program mVUcacheProg<vuIndex>(*prog); // Cache Micro Program
float cacheSize = (float)((u32)mVU->prog.x86end - (u32)mVU->prog.x86start); float cacheSize = (float)((u32)mVU->prog.x86end - (u32)mVU->prog.x86start);
float cacheUsed =((float)((u32)mVU->prog.x86ptr - (u32)mVU->prog.x86start)) / cacheSize * 100; float cacheUsed =((float)((u32)mVU->prog.x86ptr - (u32)mVU->prog.x86start)) / cacheSize * 100;
@ -215,30 +214,7 @@ _mVUt _f void mVUcacheProg(microProgram& prog) {
mVUdumpProg(prog); mVUdumpProg(prog);
} }
// Finds and Ages/Kills Programs if they haven't been used in a while. // Compare partial program by only checking compiled ranges...
_f void mVUvsyncUpdate(mV) {
/*for (int i = 0; i <= mVU->prog.max; i++) {
if (mVU->prog.prog[i].age == isDead) continue;
if (mVU->prog.prog[i].used) {
mVU->prog.prog[i].used = 0;
mVU->prog.prog[i].frame = mVU->prog.curFrame;
}
else { // Age Micro Program that wasn't used
s32 diff = mVU->prog.curFrame - mVU->prog.prog[i].frame;
if (diff >= (60 * 1)) {
if (i == mVU->prog.cur) continue; // Don't Age/Kill last used program
mVU->prog.total--;
if (!mVU->index) mVUclearProg<0>(i);
else mVUclearProg<1>(i);
DevCon.WriteLn("microVU%d: Killing Dead Program [%03d]", mVU->index, i+1);
}
//elif(diff >= (60 * 1)) { mVU->prog.prog[i].age = isOld; }
//elif(diff >= (20 * 1)) { mVU->prog.prog[i].age = isAged; }
}
}
mVU->prog.curFrame++;*/
}
_mVUt _f bool mVUcmpPartial(microProgram& prog) { _mVUt _f bool mVUcmpPartial(microProgram& prog) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
for (int i = 0; i <= prog.ranges.total; i++) { for (int i = 0; i <= prog.ranges.total; i++) {
@ -254,14 +230,11 @@ _mVUt _f bool mVUcmpPartial(microProgram& prog) {
// Compare Cached microProgram to mVU->regs->Micro // Compare Cached microProgram to mVU->regs->Micro
_mVUt _f bool mVUcmpProg(microProgram& prog, const bool cmpWholeProg) { _mVUt _f bool mVUcmpProg(microProgram& prog, const bool cmpWholeProg) {
microVU* mVU = mVUx; microVU* mVU = mVUx;
if (prog.age == isDead) return 0;
if ((cmpWholeProg && !memcmp_mmx((u8*)prog.data, mVU->regs->Micro, mVU->microMemSize)) if ((cmpWholeProg && !memcmp_mmx((u8*)prog.data, mVU->regs->Micro, mVU->microMemSize))
|| (!cmpWholeProg && mVUcmpPartial<vuIndex>(prog))) { || (!cmpWholeProg && mVUcmpPartial<vuIndex>(prog))) {
mVU->prog.cleared = 0; mVU->prog.cleared = 0;
mVU->prog.cur =&prog; mVU->prog.cur = &prog;
mVU->prog.isSame = cmpWholeProg ? 1 : -1; mVU->prog.isSame = cmpWholeProg ? 1 : -1;
prog.used = 1;
prog.age = isYoung;
return 1; return 1;
} }
return 0; return 0;
@ -283,21 +256,20 @@ _mVUt _f void* mVUsearchProg(u32 startPC, uptr pState) {
return mVUentryGet(mVU, quick.block, startPC, pState); return mVUentryGet(mVU, quick.block, startPC, pState);
} }
} }
mVU->prog.cur = mVUcreateProg<vuIndex>(startPC/8); // If cleared and program not found, make a new program instance // If cleared and program not found, make a new program instance
mVU->prog.cleared = 0; mVU->prog.cleared = 0;
mVU->prog.isSame = 1; mVU->prog.isSame = 1;
mVUcurProg.startPC = startPC / 8; mVU->prog.cur = mVUcreateProg<vuIndex>(startPC/8);
void* entryPoint = mVUblockFetch(mVU, startPC, pState); void* entryPoint = mVUblockFetch(mVU, startPC, pState);
quick.block = mVUcurProg.block[startPC/8]; quick.block = mVU->prog.cur->block[startPC/8];
quick.prog = &mVUcurProg; quick.prog = mVU->prog.cur;
list.list->push_front(&mVUcurProg); list.list->push_front(mVU->prog.cur);
return entryPoint; return entryPoint;
} }
// If list.quick, then we've already found and recompiled the program ;)
mVU->prog.isSame = -1; mVU->prog.isSame = -1;
mVU->prog.cur = quick.prog; mVU->prog.cur = quick.prog;
//mVU->prog.cur->used = 1; return mVUentryGet(mVU, quick.block, startPC, pState);
//mVU->prog.cur->age = isYoung;
return mVUentryGet(mVU, quick.block, startPC, pState); // If list.quick, then we've already found and recompiled the program ;)
} }
//------------------------------------------------------------------ //------------------------------------------------------------------

9
pcsx2/x86/microVU.h
View File

@ -128,11 +128,8 @@ struct microProgram {
u32 data [mProgSize]; // Holds a copy of the VU microProgram u32 data [mProgSize]; // Holds a copy of the VU microProgram
microBlockManager* block[mProgSize/2]; // Array of Block Managers microBlockManager* block[mProgSize/2]; // Array of Block Managers
microRange ranges; // The ranges of the microProgram that have already been recompiled microRange ranges; // The ranges of the microProgram that have already been recompiled
u32 frame; // Frame # the program was last used on u32 startPC; // Start PC of this program
u32 used; // Program was used this frame? int idx; // Program index
int age; // Program age... Young, Aged, Old, or Dead...
int idx; // Program idx in array[mMaxProg]
u32 startPC; // Start PC of this program
}; };
struct microProgramList { struct microProgramList {
@ -217,7 +214,7 @@ mVUop(mVUopU);
mVUop(mVUopL); mVUop(mVUopL);
// Private Functions // Private Functions
_mVUt _f void mVUclearProg(microProgram& prog, bool deleteBlocks = 1); _mVUt _f void mVUclearProg(microProgram& prog, u32 startPC = -1, bool deleteBlocks = 1);
_mVUt _f void mVUcacheProg(microProgram& prog); _mVUt _f void mVUcacheProg(microProgram& prog);
_mVUt _f void* mVUsearchProg(u32 startPC, uptr pState); _mVUt _f void* mVUsearchProg(u32 startPC, uptr pState);
_mVUt _f microProgram* mVUfindLeastUsedProg(); _mVUt _f microProgram* mVUfindLeastUsedProg();