/[pcsx2_0.9.7]/trunk/pcsx2/vtlb.cpp
ViewVC logotype

Diff of /trunk/pcsx2/vtlb.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 62 by william, Tue Sep 7 11:08:22 2010 UTC revision 280 by william, Thu Dec 23 12:02:12 2010 UTC
# Line 33  Line 33 
33  #include "Common.h"  #include "Common.h"
34  #include "vtlb.h"  #include "vtlb.h"
35  #include "COP0.h"  #include "COP0.h"
   
36  #include "R5900Exceptions.h"  #include "R5900Exceptions.h"
37    
38    #include "Utilities/MemsetFast.inl"
39    
40  using namespace R5900;  using namespace R5900;
41  using namespace vtlb_private;  using namespace vtlb_private;
42    
# Line 46  namespace vtlb_private Line 47  namespace vtlb_private
47          __aligned(64) MapData vtlbdata;          __aligned(64) MapData vtlbdata;
48  }  }
49    
50  static vtlbHandler vtlbHandlerCount=0;  static vtlbHandler vtlbHandlerCount = 0;
51    
52  static vtlbHandler DefaultPhyHandler;  static vtlbHandler DefaultPhyHandler;
53  static vtlbHandler UnmappedVirtHandler0;  static vtlbHandler UnmappedVirtHandler0;
# Line 78  DataType __fastcall vtlb_memRead(u32 add Line 79  DataType __fastcall vtlb_memRead(u32 add
79    
80          switch( DataSize )          switch( DataSize )
81          {          {
82          case 8: return ((vtlbMemR8FP*)vtlbdata.RWFT[0][0][hand])(paddr);                  case 8: return ((vtlbMemR8FP*)vtlbdata.RWFT[0][0][hand])(paddr);
83          case 16: return ((vtlbMemR16FP*)vtlbdata.RWFT[1][0][hand])(paddr);                  case 16: return ((vtlbMemR16FP*)vtlbdata.RWFT[1][0][hand])(paddr);
84          case 32: return ((vtlbMemR32FP*)vtlbdata.RWFT[2][0][hand])(paddr);                  case 32: return ((vtlbMemR32FP*)vtlbdata.RWFT[2][0][hand])(paddr);
85    
86                  jNO_DEFAULT;                  jNO_DEFAULT;
87          }          }
# Line 147  void __fastcall vtlb_memWrite(u32 addr, Line 148  void __fastcall vtlb_memWrite(u32 addr,
148    
149                  switch( DataSize )                  switch( DataSize )
150                  {                  {
151                  case 8: return ((vtlbMemW8FP*)vtlbdata.RWFT[0][1][hand])(paddr, (u8)data);                          case 8: return ((vtlbMemW8FP*)vtlbdata.RWFT[0][1][hand])(paddr, (u8)data);
152                  case 16: return ((vtlbMemW16FP*)vtlbdata.RWFT[1][1][hand])(paddr, (u16)data);                          case 16: return ((vtlbMemW16FP*)vtlbdata.RWFT[1][1][hand])(paddr, (u16)data);
153                  case 32: return ((vtlbMemW32FP*)vtlbdata.RWFT[2][1][hand])(paddr, (u32)data);                          case 32: return ((vtlbMemW32FP*)vtlbdata.RWFT[2][1][hand])(paddr, (u32)data);
154    
155                          jNO_DEFAULT;                          jNO_DEFAULT;
156                  }                  }
# Line 255  _tmpl(void) vtlbUnmappedPWriteLg(u32 add Line 256  _tmpl(void) vtlbUnmappedPWriteLg(u32 add
256    
257  static mem8_t __fastcall vtlbDefaultPhyRead8(u32 addr)  static mem8_t __fastcall vtlbDefaultPhyRead8(u32 addr)
258  {  {
259          Console.Error("vtlbDefaultPhyRead8: 0x%08X", addr);          pxFailDev(pxsFmt("(VTLB) Attempted read8 from unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted read from an unmapped physical address.");  
260          return 0;          return 0;
261  }  }
262    
263  static mem16_t __fastcall vtlbDefaultPhyRead16(u32 addr)  static mem16_t __fastcall vtlbDefaultPhyRead16(u32 addr)
264  {  {
265          Console.Error("vtlbDefaultPhyRead16: 0x%08X", addr);          pxFailDev(pxsFmt("(VTLB) Attempted read16 from unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted read from an unmapped physical address.");  
266          return 0;          return 0;
267  }  }
268    
269  static mem32_t __fastcall vtlbDefaultPhyRead32(u32 addr)  static mem32_t __fastcall vtlbDefaultPhyRead32(u32 addr)
270  {  {
271          Console.Error("vtlbDefaultPhyRead32: 0x%08X", addr);          pxFailDev(pxsFmt("(VTLB) Attempted read32 from unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted read from an unmapped physical address.");  
272          return 0;          return 0;
273  }  }
274    
275  static void __fastcall vtlbDefaultPhyRead64(u32 addr, mem64_t* dest)  static void __fastcall vtlbDefaultPhyRead64(u32 addr, mem64_t* dest)
276  {  {
277          Console.Error("vtlbDefaultPhyRead64: 0x%08X", addr);          pxFailDev(pxsFmt("(VTLB) Attempted read64 from unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted read from an unmapped physical address.");  
278  }  }
279    
280  static void __fastcall vtlbDefaultPhyRead128(u32 addr, mem128_t* dest)  static void __fastcall vtlbDefaultPhyRead128(u32 addr, mem128_t* dest)
281  {  {
282          Console.Error("vtlbDefaultPhyRead128: 0x%08X", addr);          pxFailDev(pxsFmt("(VTLB) Attempted read128 from unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted read from an unmapped physical address.");  
283  }  }
284    
285  static void __fastcall vtlbDefaultPhyWrite8(u32 addr, mem8_t data)  static void __fastcall vtlbDefaultPhyWrite8(u32 addr, mem8_t data)
286  {  {
287          Console.Error("vtlbDefaultPhyWrite8: 0x%08X",addr);          pxFailDev(pxsFmt("(VTLB) Attempted write8 to unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted write to an unmapped physical address.");  
288  }  }
289    
290  static void __fastcall vtlbDefaultPhyWrite16(u32 addr, mem16_t data)  static void __fastcall vtlbDefaultPhyWrite16(u32 addr, mem16_t data)
291  {  {
292          Console.Error("vtlbDefaultPhyWrite16: 0x%08X",addr);          pxFailDev(pxsFmt("(VTLB) Attempted write16 to unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted write to an unmapped physical address.");  
293  }  }
294    
295  static void __fastcall vtlbDefaultPhyWrite32(u32 addr, mem32_t data)  static void __fastcall vtlbDefaultPhyWrite32(u32 addr, mem32_t data)
296  {  {
297          Console.Error("vtlbDefaultPhyWrite32: 0x%08X",addr);          pxFailDev(pxsFmt("(VTLB) Attempted write32 to unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted write to an unmapped physical address.");  
298  }  }
299    
300  static void __fastcall vtlbDefaultPhyWrite64(u32 addr,const mem64_t* data)  static void __fastcall vtlbDefaultPhyWrite64(u32 addr,const mem64_t* data)
301  {  {
302          Console.Error("vtlbDefaultPhyWrite64: 0x%08X",addr);          pxFailDev(pxsFmt("(VTLB) Attempted write64 to unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted write to an unmapped physical address.");  
303  }  }
304    
305  static void __fastcall vtlbDefaultPhyWrite128(u32 addr,const mem128_t* data)  static void __fastcall vtlbDefaultPhyWrite128(u32 addr,const mem128_t* data)
306  {  {
307          Console.Error("vtlbDefaultPhyWrite128: 0x%08X",addr);          pxFailDev(pxsFmt("(VTLB) Attempted write128 to unmapped physical address @ 0x%08X.", addr));
         pxFailDev("(VTLB) Attempted write to an unmapped physical address.");  
308  }  }
309  #undef _tmpl  #undef _tmpl
310    
# Line 333  __ri void vtlb_ReassignHandler( vtlbHand Line 324  __ri void vtlb_ReassignHandler( vtlbHand
324                                                             vtlbMemR8FP* r8,vtlbMemR16FP* r16,vtlbMemR32FP* r32,vtlbMemR64FP* r64,vtlbMemR128FP* r128,                                                             vtlbMemR8FP* r8,vtlbMemR16FP* r16,vtlbMemR32FP* r32,vtlbMemR64FP* r64,vtlbMemR128FP* r128,
325                                                             vtlbMemW8FP* w8,vtlbMemW16FP* w16,vtlbMemW32FP* w32,vtlbMemW64FP* w64,vtlbMemW128FP* w128 )                                                             vtlbMemW8FP* w8,vtlbMemW16FP* w16,vtlbMemW32FP* w32,vtlbMemW64FP* w64,vtlbMemW128FP* w128 )
326  {  {
327            pxAssume(rv < VTLB_HANDLER_ITEMS);
328    
329          vtlbdata.RWFT[0][0][rv] = (void*)((r8!=0)   ? r8        : vtlbDefaultPhyRead8);          vtlbdata.RWFT[0][0][rv] = (void*)((r8!=0)   ? r8        : vtlbDefaultPhyRead8);
330          vtlbdata.RWFT[1][0][rv] = (void*)((r16!=0)  ? r16       : vtlbDefaultPhyRead16);          vtlbdata.RWFT[1][0][rv] = (void*)((r16!=0)  ? r16       : vtlbDefaultPhyRead16);
331          vtlbdata.RWFT[2][0][rv] = (void*)((r32!=0)  ? r32       : vtlbDefaultPhyRead32);          vtlbdata.RWFT[2][0][rv] = (void*)((r32!=0)  ? r32       : vtlbDefaultPhyRead32);
# Line 348  __ri void vtlb_ReassignHandler( vtlbHand Line 341  __ri void vtlb_ReassignHandler( vtlbHand
341    
342  vtlbHandler vtlb_NewHandler()  vtlbHandler vtlb_NewHandler()
343  {  {
344          pxAssertDev( vtlbHandlerCount < 127, "VTLB allowed handler count exceeded!" );          pxAssertDev( vtlbHandlerCount < VTLB_HANDLER_ITEMS, "VTLB handler count overflow!" );
345          return vtlbHandlerCount++;          return vtlbHandlerCount++;
346  }  }
347    
# Line 362  vtlbHandler vtlb_NewHandler() Line 355  vtlbHandler vtlb_NewHandler()
355  // Returns a handle for the newly created handler  See vtlb_MapHandler for use of the return value.  // Returns a handle for the newly created handler  See vtlb_MapHandler for use of the return value.
356  //  //
357  __ri vtlbHandler vtlb_RegisterHandler(  vtlbMemR8FP* r8,vtlbMemR16FP* r16,vtlbMemR32FP* r32,vtlbMemR64FP* r64,vtlbMemR128FP* r128,  __ri vtlbHandler vtlb_RegisterHandler(  vtlbMemR8FP* r8,vtlbMemR16FP* r16,vtlbMemR32FP* r32,vtlbMemR64FP* r64,vtlbMemR128FP* r128,
358                                                                          vtlbMemW8FP* w8,vtlbMemW16FP* w16,vtlbMemW32FP* w32,vtlbMemW64FP* w64,vtlbMemW128FP* w128)                                                                                  vtlbMemW8FP* w8,vtlbMemW16FP* w16,vtlbMemW32FP* w32,vtlbMemW64FP* w64,vtlbMemW128FP* w128)
359  {  {
360          vtlbHandler rv = vtlb_NewHandler();          vtlbHandler rv = vtlb_NewHandler();
361          vtlb_ReassignHandler( rv, r8, r16, r32, r64, r128, w8, w16, w32, w64, w128 );          vtlb_ReassignHandler( rv, r8, r16, r32, r64, r128, w8, w16, w32, w64, w128 );
# Line 377  __ri vtlbHandler vtlb_RegisterHandler( v Line 370  __ri vtlbHandler vtlb_RegisterHandler( v
370  // function.  // function.
371  //  //
372  // The memory region start and size parameters must be pagesize aligned.  // The memory region start and size parameters must be pagesize aligned.
373  void vtlb_MapHandler(vtlbHandler handler,u32 start,u32 size)  void vtlb_MapHandler(vtlbHandler handler, u32 start, u32 size)
374  {  {
375          verify(0==(start&VTLB_PAGE_MASK));          verify(0==(start&VTLB_PAGE_MASK));
376          verify(0==(size&VTLB_PAGE_MASK) && size>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
         s32 value=handler|0x80000000;  
377    
378          while(size>0)          s32 value = handler | 0x80000000;
379          {          u32 end = start + (size - VTLB_PAGE_SIZE);
380                  vtlbdata.pmap[start>>VTLB_PAGE_BITS]=value;          pxAssume( (end>>VTLB_PAGE_BITS) < ArraySize(vtlbdata.pmap) );
381    
382                  start+=VTLB_PAGE_SIZE;          while (start <= end)
383                  size-=VTLB_PAGE_SIZE;          {
384                    vtlbdata.pmap[start>>VTLB_PAGE_BITS] = value;
385                    start += VTLB_PAGE_SIZE;
386          }          }
387  }  }
388    
389  void vtlb_MapBlock(void* base,u32 start,u32 size,u32 blocksize)  void vtlb_MapBlock(void* base, u32 start, u32 size, u32 blocksize)
390  {  {
         s32 baseint=(s32)base;  
   
391          verify(0==(start&VTLB_PAGE_MASK));          verify(0==(start&VTLB_PAGE_MASK));
392          verify(0==(size&VTLB_PAGE_MASK) && size>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
393          if (blocksize==0)          if (!blocksize)
394                  blocksize=size;                  blocksize = size;
395          verify(0==(blocksize&VTLB_PAGE_MASK) && blocksize>0);          verify(0==(blocksize&VTLB_PAGE_MASK) && blocksize>0);
396          verify(0==(size%blocksize));          verify(0==(size%blocksize));
397    
398          while(size>0)          s32 baseint = (s32)base;
399            u32 end = start + (size - VTLB_PAGE_SIZE);
400            pxAssume( (end>>VTLB_PAGE_BITS) < ArraySize(vtlbdata.pmap) );
401    
402            while (start <= end)
403          {          {
404                  u32 blocksz=blocksize;                  u32 loopsz = blocksize;
405                  s32 ptr=baseint;                  s32 ptr = baseint;
406    
407                  while(blocksz>0)                  while (loopsz > 0)
408                  {                  {
409                          vtlbdata.pmap[start>>VTLB_PAGE_BITS]=ptr;                          vtlbdata.pmap[start>>VTLB_PAGE_BITS] = ptr;
410    
411                          start+=VTLB_PAGE_SIZE;                          start   += VTLB_PAGE_SIZE;
412                          ptr+=VTLB_PAGE_SIZE;                          ptr             += VTLB_PAGE_SIZE;
413                          blocksz-=VTLB_PAGE_SIZE;                          loopsz  -= VTLB_PAGE_SIZE;
                         size-=VTLB_PAGE_SIZE;  
414                  }                  }
415          }          }
416  }  }
# Line 426  void vtlb_Mirror(u32 new_region,u32 star Line 421  void vtlb_Mirror(u32 new_region,u32 star
421          verify(0==(start&VTLB_PAGE_MASK));          verify(0==(start&VTLB_PAGE_MASK));
422          verify(0==(size&VTLB_PAGE_MASK) && size>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
423    
424          while(size>0)          u32 end = start + (size-VTLB_PAGE_SIZE);
425            pxAssume( (end>>VTLB_PAGE_BITS) < ArraySize(vtlbdata.pmap) );
426    
427            while(start <= end)
428          {          {
429                  vtlbdata.pmap[start>>VTLB_PAGE_BITS]=vtlbdata.pmap[new_region>>VTLB_PAGE_BITS];                  vtlbdata.pmap[start>>VTLB_PAGE_BITS] = vtlbdata.pmap[new_region>>VTLB_PAGE_BITS];
430    
431                  start+=VTLB_PAGE_SIZE;                  start           += VTLB_PAGE_SIZE;
432                  new_region+=VTLB_PAGE_SIZE;                  new_region      += VTLB_PAGE_SIZE;
                 size-=VTLB_PAGE_SIZE;  
433          }          }
434  }  }
435    
# Line 446  __fi void* vtlb_GetPhyPtr(u32 paddr) Line 443  __fi void* vtlb_GetPhyPtr(u32 paddr)
443    
444  //virtual mappings  //virtual mappings
445  //TODO: Add invalid paddr checks  //TODO: Add invalid paddr checks
446  void vtlb_VMap(u32 vaddr,u32 paddr,u32 sz)  void vtlb_VMap(u32 vaddr,u32 paddr,u32 size)
447  {  {
448          verify(0==(vaddr&VTLB_PAGE_MASK));          verify(0==(vaddr&VTLB_PAGE_MASK));
449          verify(0==(paddr&VTLB_PAGE_MASK));          verify(0==(paddr&VTLB_PAGE_MASK));
450          verify(0==(sz&VTLB_PAGE_MASK) && sz>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
451    
452          while(sz>0)          while (size > 0)
453          {          {
454                  s32 pme;                  s32 pme;
455                  if (paddr>=VTLB_PMAP_SZ)                  if (paddr >= VTLB_PMAP_SZ)
456                  {                  {
457                          pme=UnmappedPhyHandler0;                          pme = UnmappedPhyHandler0;
458                          if (paddr&0x80000000)                          if (paddr & 0x80000000)
459                                  pme=UnmappedPhyHandler1;                                  pme = UnmappedPhyHandler1;
460                          pme|=0x80000000;                          pme |= 0x80000000;
461                          pme|=paddr;// top bit is set anyway ...                          pme |= paddr;// top bit is set anyway ...
462                  }                  }
463                  else                  else
464                  {                  {
465                          pme=vtlbdata.pmap[paddr>>VTLB_PAGE_BITS];                          pme = vtlbdata.pmap[paddr>>VTLB_PAGE_BITS];
466                          if (pme<0)                          if (pme<0)
467                                  pme|=paddr;// top bit is set anyway ...                                  pme |= paddr;// top bit is set anyway ...
468                  }                  }
469                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS]=pme-vaddr;  
470                  vaddr+=VTLB_PAGE_SIZE;                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS] = pme-vaddr;
471                  paddr+=VTLB_PAGE_SIZE;                  vaddr += VTLB_PAGE_SIZE;
472                  sz-=VTLB_PAGE_SIZE;                  paddr += VTLB_PAGE_SIZE;
473                    size -= VTLB_PAGE_SIZE;
474          }          }
475  }  }
476    
477  void vtlb_VMapBuffer(u32 vaddr,void* buffer,u32 sz)  void vtlb_VMapBuffer(u32 vaddr,void* buffer,u32 size)
478  {  {
479          verify(0==(vaddr&VTLB_PAGE_MASK));          verify(0==(vaddr&VTLB_PAGE_MASK));
480          verify(0==(sz&VTLB_PAGE_MASK) && sz>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
481          u32 bu8=(u32)buffer;  
482          while(sz>0)          u32 bu8 = (u32)buffer;
483            while (size > 0)
484          {          {
485                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS]=bu8-vaddr;                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS] = bu8-vaddr;
486                  vaddr+=VTLB_PAGE_SIZE;                  vaddr += VTLB_PAGE_SIZE;
487                  bu8+=VTLB_PAGE_SIZE;                  bu8 += VTLB_PAGE_SIZE;
488                  sz-=VTLB_PAGE_SIZE;                  size -= VTLB_PAGE_SIZE;
489          }          }
490  }  }
491  void vtlb_VMapUnmap(u32 vaddr,u32 sz)  void vtlb_VMapUnmap(u32 vaddr,u32 size)
492  {  {
493          verify(0==(vaddr&VTLB_PAGE_MASK));          verify(0==(vaddr&VTLB_PAGE_MASK));
494          verify(0==(sz&VTLB_PAGE_MASK) && sz>0);          verify(0==(size&VTLB_PAGE_MASK) && size>0);
495    
496          while(sz>0)          while (size > 0)
497          {          {
498                  u32 handl=UnmappedVirtHandler0;                  u32 handl = UnmappedVirtHandler0;
499                  if (vaddr&0x80000000)                  if (vaddr & 0x80000000)
500                  {                  {
501                          handl=UnmappedVirtHandler1;                          handl = UnmappedVirtHandler1;
502                  }                  }
503                  handl|=vaddr; // top bit is set anyway ...  
504                  handl|=0x80000000;                  handl |= vaddr; // top bit is set anyway ...
505                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS]=handl-vaddr;                  handl |= 0x80000000;
506                  vaddr+=VTLB_PAGE_SIZE;  
507                  sz-=VTLB_PAGE_SIZE;                  vtlbdata.vmap[vaddr>>VTLB_PAGE_BITS] = handl-vaddr;
508                    vaddr += VTLB_PAGE_SIZE;
509                    size -= VTLB_PAGE_SIZE;
510          }          }
511  }  }
512    
# Line 562  void vtlb_Term() Line 563  void vtlb_Term()
563  }  }
564    
565  // Reserves the vtlb core allocation used by various emulation components!  // Reserves the vtlb core allocation used by various emulation components!
566  //  // [TODO] basemem - request allocating memory at the specified virtual location, which can allow
567    //    for easier debugging and/or 3rd party cheat programs.  If 0, the operating system
568    //    default is used.
569  void vtlb_Core_Alloc()  void vtlb_Core_Alloc()
570  {  {
571          if( vtlbdata.alloc_base != NULL ) return;          if (!vtlbdata.vmap)
572            {
573          vtlbdata.alloc_current = 0;                  vtlbdata.vmap = (s32*)_aligned_malloc( VTLB_VMAP_ITEMS * sizeof(*vtlbdata.vmap), 16 );
574                    if (!vtlbdata.vmap)
575  #ifdef __LINUX__                          throw Exception::OutOfMemory( L"VTLB Virtual Address Translation LUT" )
576          vtlbdata.alloc_base = SysMmapEx( 0x16000000, VTLB_ALLOC_SIZE, 0x80000000, "Vtlb" );                                  .SetDiagMsg(pxsFmt("(%u megs)", VTLB_VMAP_ITEMS * sizeof(*vtlbdata.vmap) / _1mb)
577  #else                          );
578          // Win32 just needs this, since malloc always maps below 2GB.          }
         vtlbdata.alloc_base = (u8*)_aligned_malloc( VTLB_ALLOC_SIZE, 4096 );  
         if( vtlbdata.alloc_base == NULL )  
                 throw Exception::OutOfMemory( pxsFmt(L"PS2 mappable system ram (%u megs)", VTLB_ALLOC_SIZE / _1mb) );  
 #endif  
579  }  }
580    
581  void vtlb_Core_Shutdown()  void vtlb_Core_Free()
582  {  {
583          if( vtlbdata.alloc_base == NULL ) return;          safe_aligned_free( vtlbdata.vmap );
584    }
 #ifdef __LINUX__  
         SafeSysMunmap( vtlbdata.alloc_base, VTLB_ALLOC_SIZE );  
 #else  
         // Make sure and unprotect memory first, since CrtDebug will try to write to it.  
         HostSys::MemProtect( vtlbdata.alloc_base, VTLB_ALLOC_SIZE, Protect_ReadWrite );  
         safe_aligned_free( vtlbdata.alloc_base );  
 #endif  
585    
586    static wxString GetHostVmErrorMsg()
587    {
588            return pxE("!Notice:HostVmReserve",
589                    L"Your system is too low on virtual resources for PCSX2 to run.  This can be "
590                    L"caused by having a small or disabled swapfile, or by other programs that are "
591                    L"hogging resources."
592            );
593    }
594    // --------------------------------------------------------------------------------------
595    //  VtlbMemoryReserve  (implementations)
596    // --------------------------------------------------------------------------------------
597    VtlbMemoryReserve::VtlbMemoryReserve( const wxString& name, size_t size )
598            : m_reserve( name, size )
599    {
600            m_reserve.SetPageAccessOnCommit( PageAccess_ReadWrite() );
601  }  }
602    
603  // This function allocates memory block with are compatible with the Vtlb's requirements  void VtlbMemoryReserve::SetBaseAddr( uptr newaddr )
 // for memory locations.  The Vtlb requires the topmost bit (Sign bit) of the memory  
 // pointer to be cleared.  Some operating systems and/or implementations of malloc do that,  
 // but others do not.  So use this instead to allocate the memory correctly for your  
 // platform.  
 //  
 u8* vtlb_malloc( uint size, uint align )  
604  {  {
605          vtlbdata.alloc_current += align-1;          m_reserve.SetBaseAddr( newaddr );
606          vtlbdata.alloc_current &= ~(align-1);  }
607    
608          int rv = vtlbdata.alloc_current;  void VtlbMemoryReserve::Reserve( sptr hostptr )
609          vtlbdata.alloc_current += size;  {
610            if (!m_reserve.ReserveAt( hostptr ))
611            {
612                    throw Exception::OutOfMemory( m_reserve.GetName() )
613                            .SetDiagMsg(L"Vtlb memory could not be reserved.")
614                            .SetUserMsg(GetHostVmErrorMsg());
615            }
616    }
617    
618          pxAssertDev( vtlbdata.alloc_current < VTLB_ALLOC_SIZE, "(vtlb_malloc) memory overflow! Please increase the size of VTLB_ALLOC_SIZE!" );  void VtlbMemoryReserve::Commit()
619          return &vtlbdata.alloc_base[rv];  {
620            if (IsCommitted()) return;
621            if (!m_reserve.Commit())
622            {
623                    throw Exception::OutOfMemory( m_reserve.GetName() )
624                            .SetDiagMsg(L"Vtlb memory could not be committed.")
625                            .SetUserMsg(GetHostVmErrorMsg());
626            }
627  }  }
628    
629  void vtlb_free( void* pmem, uint size )  void VtlbMemoryReserve::Reset()
630  {  {
631          vtlbdata.alloc_current -= size;          Commit();
632            memzero_sse_a(m_reserve.GetPtr(), m_reserve.GetCommittedBytes());
633    }
634    
635          pxAssertDev( vtlbdata.alloc_current >= 0, "(vtlb_free) mismatched calls to vtlb_malloc and free detected via memory underflow." );  void VtlbMemoryReserve::Decommit()
636    {
637            m_reserve.Reset();
638    }
639    
640          return;  void VtlbMemoryReserve::Release()
641    {
642            m_reserve.Release();
643  }  }
644    
645    bool VtlbMemoryReserve::IsCommitted() const
646    {
647            return !!m_reserve.GetCommittedPageCount();
648    }

Legend:
Removed from v.62  
changed lines
  Added in v.280

  ViewVC Help
Powered by ViewVC 1.1.22