/[pcsx2_0.9.7]/trunk/common/include/Utilities/win_memzero.h
ViewVC logotype

Diff of /trunk/common/include/Utilities/win_memzero.h

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

revision 61 by william, Tue Sep 7 03:24:11 2010 UTC revision 62 by william, Tue Sep 7 11:08:22 2010 UTC
# Line 60  Line 60 
60    
61  // This is an implementation of the memzero_ptr fast memset routine (for zero-clears only).  // This is an implementation of the memzero_ptr fast memset routine (for zero-clears only).
62  template< size_t _bytes >  template< size_t _bytes >
63  static __forceinline void memzero_ptr( void *dest )  static __fi void memzero_ptr( void *dest )
64  {  {
65          if( MZFbytes == 0 ) return;          if( MZFbytes == 0 ) return;
66    
# Line 73  static __forceinline void memzero_ptr( v Line 73  static __forceinline void memzero_ptr( v
73                  return;                  return;
74          }          }
75    
76    #if 0
77            // SSE-based memory clear.  Currently disabled so to avoid unnecessary dependence on
78            // SSE cpu instruction sets.  (memzero typically isn't used in any performance critical
79            // situations anyway)
80          enum          enum
81          {          {
82                  remainder = MZFbytes & 127,                  remainder = MZFbytes & 127,
# Line 86  static __forceinline void memzero_ptr( v Line 90  static __forceinline void memzero_ptr( v
90    
91          if( (MZFbytes & 0xf) == 0 )          if( (MZFbytes & 0xf) == 0 )
92          {          {
                 u64 _xmm_backup[2];  
   
93                  if( ((uptr)dest & 0xf) != 0 )                  if( ((uptr)dest & 0xf) != 0 )
94                  {                  {
95                          // UNALIGNED COPY MODE.                          // UNALIGNED COPY MODE.
# Line 97  static __forceinline void memzero_ptr( v Line 99  static __forceinline void memzero_ptr( v
99                          {                          {
100                                  __asm                                  __asm
101                                  {                                  {
                                         movups _xmm_backup,xmm0;  
102                                          mov ecx,dest                                          mov ecx,dest
103                                          pxor xmm0,xmm0                                          pxor xmm0,xmm0
104                                          mov eax,bytes128                                          mov eax,bytes128
105    
                                         align 16  
   
106                                  _loop_6:                                  _loop_6:
107                                          movups [ecx],xmm0;                                          movups [ecx],xmm0
108                                          movups [ecx+0x10],xmm0;                                          movups [ecx+0x10],xmm0
109                                          movups [ecx+0x20],xmm0;                                          movups [ecx+0x20],xmm0
110                                          movups [ecx+0x30],xmm0;                                          movups [ecx+0x30],xmm0
111                                          movups [ecx+0x40],xmm0;                                          movups [ecx+0x40],xmm0
112                                          movups [ecx+0x50],xmm0;                                          movups [ecx+0x50],xmm0
113                                          movups [ecx+0x60],xmm0;                                          movups [ecx+0x60],xmm0
114                                          movups [ecx+0x70],xmm0;                                          movups [ecx+0x70],xmm0
115                                          sub ecx,-128                                          sub ecx,-128
116                                          dec eax;                                          sub eax,1
117                                          jnz _loop_6;                                          jnz _loop_6;
118                                  }                                  }
119                                  if( remainder != 0 )                                  if( remainder != 0 )
# Line 130  static __forceinline void memzero_ptr( v Line 129  static __forceinline void memzero_ptr( v
129                                                  jnz _loop_5;                                                  jnz _loop_5;
130                                          }                                          }
131                                  }                                  }
                                 __asm  
                                 {  
                                         movups xmm0,[_xmm_backup];  
                                 }  
132                                  return;                                  return;
133                          }                          }
134                  }                  }
# Line 145  static __forceinline void memzero_ptr( v Line 140  static __forceinline void memzero_ptr( v
140    
141                          __asm                          __asm
142                          {                          {
                                 movups _xmm_backup,xmm0;  
143                                  mov ecx,dest                                  mov ecx,dest
144                                  pxor xmm0,xmm0                                  pxor xmm0,xmm0
145                                  mov eax,bytes128                                  mov eax,bytes128
146    
                                 align 16  
   
147                          _loop_8:                          _loop_8:
148                                  movaps [ecx],xmm0;                                  movaps [ecx],xmm0
149                                  movaps [ecx+0x10],xmm0;                                  movaps [ecx+0x10],xmm0
150                                  movaps [ecx+0x20],xmm0;                                  movaps [ecx+0x20],xmm0
151                                  movaps [ecx+0x30],xmm0;                                  movaps [ecx+0x30],xmm0
152                                  movaps [ecx+0x40],xmm0;                                  movaps [ecx+0x40],xmm0
153                                  movaps [ecx+0x50],xmm0;                                  movaps [ecx+0x50],xmm0
154                                  movaps [ecx+0x60],xmm0;                                  movaps [ecx+0x60],xmm0
155                                  movaps [ecx+0x70],xmm0;                                  movaps [ecx+0x70],xmm0
156                                  sub ecx,-128                                  sub ecx,-128
157                                  dec eax;                                  sub eax,1
158                                  jnz _loop_8;                                  jnz _loop_8;
159                          }                          }
160                          if( remainder != 0 )                          if( remainder != 0 )
# Line 173  static __forceinline void memzero_ptr( v Line 165  static __forceinline void memzero_ptr( v
165                                          mov eax, remainder                                          mov eax, remainder
166    
167                                  _loop_10:                                  _loop_10:
168                                          movaps [ecx+eax],xmm0;                                          movaps [ecx+eax],xmm0
169                                          sub eax,16;                                          sub eax,16;
170                                          jnz _loop_10;                                          jnz _loop_10;
171                                  }                                  }
172                          }                          }
                         __asm  
                         {  
                                 movups xmm0,[_xmm_backup];  
                         }  
173                          return;                          return;
174                  }                  }
175          }          }
176            #endif
177    
178          // This function only works on 32-bit alignments.          // This function only works on 32-bit alignments.
179          jASSUME( (MZFbytes & 0x3) == 0 );          pxAssume( (MZFbytes & 0x3) == 0 );
180          jASSUME( ((uptr)dest & 0x3) == 0 );          pxAssume( ((uptr)dest & 0x3) == 0 );
181    
182          enum          enum
183          {          {
# Line 258  static __forceinline void memzero_ptr( v Line 247  static __forceinline void memzero_ptr( v
247    
248  // An optimized memset for 8 bit destination data.  // An optimized memset for 8 bit destination data.
249  template< u8 data, size_t _bytes >  template< u8 data, size_t _bytes >
250  static __forceinline void memset_8( void *dest )  static __fi void memset_8( void *dest )
251  {  {
252          if( MZFbytes == 0 ) return;          if( MZFbytes == 0 ) return;
253    
# Line 271  static __forceinline void memset_8( void Line 260  static __forceinline void memset_8( void
260                  return;                  return;
261          }          }
262    
         //u64 _xmm_backup[2];  
   
263          /*static const size_t remainder = MZFbytes & 127;          /*static const size_t remainder = MZFbytes & 127;
264          static const size_t bytes128 = MZFbytes / 128;          static const size_t bytes128 = MZFbytes / 128;
265          if( bytes128 > 32 )          if( bytes128 > 32 )
266          {          {
267                  // This function only works on 128-bit alignments.                  // This function only works on 128-bit alignments.
268                  jASSUME( (MZFbytes & 0xf) == 0 );                  pxAssume( (MZFbytes & 0xf) == 0 );
269                  jASSUME( ((uptr)dest & 0xf) == 0 );                  pxAssume( ((uptr)dest & 0xf) == 0 );
270    
271                  __asm                  __asm
272                  {                  {
                         movups _xmm_backup,xmm0;  
273                          mov eax,bytes128                          mov eax,bytes128
274                          mov ecx,dest                          mov ecx,dest
275                          movss xmm0,data                          movss xmm0,data
# Line 316  static __forceinline void memset_8( void Line 302  static __forceinline void memset_8( void
302                                  jnz _loop_10;                                  jnz _loop_10;
303                          }                          }
304                  }                  }
                 __asm  
                 {  
                         movups xmm0,[_xmm_backup];  
                 }  
305          }*/          }*/
306    
307          // This function only works on 32-bit alignments of data copied.          // This function only works on 32-bit alignments of data copied.
308          jASSUME( (MZFbytes & 0x3) == 0 );          pxAssume( (MZFbytes & 0x3) == 0 );
309    
310          enum          enum
311          {          {
# Line 392  static __forceinline void memset_8( void Line 374  static __forceinline void memset_8( void
374  }  }
375    
376  template< u16 data, size_t _bytes >  template< u16 data, size_t _bytes >
377  static __forceinline void memset_16( void *dest )  static __fi void memset_16( void *dest )
378  {  {
379          if( MZFbytes == 0 ) return;          if( MZFbytes == 0 ) return;
380    
381          if( (MZFbytes & 0x1) != 0 )          // Assertion: data length must be a multiple of 16 or 32 bits
382                  throw Exception::LogicError( "Invalid parameter passed to memset_16 - data length is not a multiple of 16 or 32 bits." );          pxAssume( (MZFbytes & 0x1) == 0 );
383    
384          if( (MZFbytes & 0x3) != 0 )          if( (MZFbytes & 0x3) != 0 )
385          {          {
# Line 411  static __forceinline void memset_16( voi Line 393  static __forceinline void memset_16( voi
393          //u64 _xmm_backup[2];          //u64 _xmm_backup[2];
394    
395          // This function only works on 32-bit alignments of data copied.          // This function only works on 32-bit alignments of data copied.
396          jASSUME( (MZFbytes & 0x3) == 0 );          pxAssume( (MZFbytes & 0x3) == 0 );
397    
398          enum          enum
399          {          {
# Line 480  static __forceinline void memset_16( voi Line 462  static __forceinline void memset_16( voi
462  }  }
463    
464  template< u32 data, size_t MZFbytes >  template< u32 data, size_t MZFbytes >
465  static __forceinline void memset_32( void *dest )  static __fi void memset_32( void *dest )
466  {  {
467          if( MZFbytes == 0 ) return;          if( MZFbytes == 0 ) return;
468    
469          if( (MZFbytes & 0x3) != 0 )          // Assertion: data length must be a multiple of 32 bits
470                  throw Exception::LogicError( "Invalid parameter passed to memset_32 - data length is not a multiple of 32 bits." );          pxAssume( (MZFbytes & 0x3) == 0 );
   
471    
472          //u64 _xmm_backup[2];          //u64 _xmm_backup[2];
473    
# Line 494  static __forceinline void memset_32( voi Line 475  static __forceinline void memset_32( voi
475          // If the data length is not a factor of 32 bits, the C++ optimizing compiler will          // If the data length is not a factor of 32 bits, the C++ optimizing compiler will
476          // probably just generate mysteriously broken code in Release builds. ;)          // probably just generate mysteriously broken code in Release builds. ;)
477    
478          jASSUME( (MZFbytes & 0x3) == 0 );          pxAssume( (MZFbytes & 0x3) == 0 );
479    
480          enum          enum
481          {          {
# Line 566  static __forceinline void memset_32( voi Line 547  static __forceinline void memset_32( voi
547  // Structures, static arrays, etc.  No need to include sizeof() crap, this does it automatically  // Structures, static arrays, etc.  No need to include sizeof() crap, this does it automatically
548  // for you!  // for you!
549  template< typename T >  template< typename T >
550  static __forceinline void memzero( T& object )  static __fi void memzero( T& object )
551  {  {
552          memzero_ptr<sizeof(T)>( &object );          memzero_ptr<sizeof(T)>( &object );
553  }  }
554    
555  // This method clears an object with the given 8 bit value.  // This method clears an object with the given 8 bit value.
556  template< u8 data, typename T >  template< u8 data, typename T >
557  static __forceinline void memset8( T& object )  static __fi void memset8( T& object )
558  {  {
559          memset_8<data, sizeof(T)>( &object );          memset_8<data, sizeof(T)>( &object );
560  }  }
561    
562  // This method clears an object with the given 16 bit value.  // This method clears an object with the given 16 bit value.
563  template< u16 data, typename T >  template< u16 data, typename T >
564  static __forceinline void memset16( T& object )  static __fi void memset16( T& object )
565  {  {
566          memset_16<data, sizeof(T)>( &object );          memset_16<data, sizeof(T)>( &object );
567  }  }
568    
569  // This method clears an object with the given 32 bit value.  // This method clears an object with the given 32 bit value.
570  template< u32 data, typename T >  template< u32 data, typename T >
571  static __forceinline void memset32( T& object )  static __fi void memset32( T& object )
572  {  {
573          memset_32<data, sizeof(T)>( &object );          memset_32<data, sizeof(T)>( &object );
574  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.22