#include "os.h"
#include "cpu.h"
#include "x86_optimized_memcpy.h"
memory.hのインクルード依存関係図
このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。
データ構造 | |
struct | dkcstd_aligned_memory_result |
型定義 | |
typedef dkcstd_aligned_memory_result | DKCSTD_ALIGNED_MEM |
関数 | |
DKC_EXTERN void | dkcstd_get_memory_align (DKCSTD_ALIGNED_MEM *r, const void *src, size_t srcsize, size_t align_offset) |
DKC_EXTERN void * | dkcstd_pointer_align (const void *src, size_t align_offset) |
DKC_EXTERN size_t | dkcstd_offset_align (const void *src, size_t align_offset) |
DKC_EXTERN BOOL | dkcstd_check_align (const void *src, size_t bytes) |
DKC_EXTERN void * | dkcstd_memcpy (void *dest, const void *src, size_t count) |
どんな環境でも動く単純なmemcpy() | |
DKC_EXTERN void * | dkcstd_memcpy8 (void *dest, const void *src, size_t count) |
8bit毎にコピー | |
DKC_EXTERN void * | dkcstd_memcpy32 (void *dest, const void *src, size_t count) |
32bit毎にコピー | |
DKC_EXTERN void * | dkcstd_memcpy64 (void *dest, const void *src, size_t count) |
64bit毎にコピー | |
DKC_EXTERN void * | dkcstd_memcpy64f (void *dest, const void *src, size_t count) |
64bit毎(double *にキャストして)にコピー | |
DKC_EXTERN void * | dkcstd_memmove (void *dest, const void *src, size_t count) |
DKC_EXTERN void * | dkcstd_memset (void *dest, int c, size_t count) |
DKC_EXTERN int | dkcstd_memcmp (const void *buf1, const void *buf2, size_t count) |
DKC_EXTERN void * | dkcstd_memchr (const void *buf, int c, size_t count) |
memory copy code benchmark source code for Visual C++ 6.0 + Service Pack 4 + Processor Pack copyright(C) 2001 XELF. All rights reserved. http://www.cyborg.ne.jp/~xelf/
- SSE系の命令は16byteアライメントされたデータでないと例外が発生します。 - SSE系の関数でmovupsが付いているものはアラインメント考慮の必要がありません。 - FPU系の命令は8byteアライメントされたデータでないとエラーが発生します。 - aling()系関数(例:dkcstd_check_align())はsizeof(void *) == sizeof(size_t)を前提として処理しています。 memory.h で定義されています。
|
|
|
|
|
参照先 dkcstd_aligned_memory_result::access_permit_from_mem, dkcstd_offset_align(), dkcstd_size_align(), dkcstd_aligned_memory_result::mem, と dkcstd_aligned_memory_result::offset_from_original. 00023 { 00024 size_t o = dkcstd_offset_align(src,align_offset); 00025 BYTE *t = (BYTE *)src; 00026 size_t m = srcsize - o; 00027 r->access_permit_from_mem = dkcstd_size_align(m,align_offset); 00028 00029 r->mem = t + o; 00030 r->offset_from_original = o; 00031 }
|
|
参照先 dkcstd_memchr8(). 00751 { 00752 return dkcstd_memchr8( buf, c, count ); 00753 }
|
|
参照先 dkcstd_memcmp8(). 参照元 dkcstd_bcmp(). 00721 { 00722 size_t i; 00723 const size_t *d,*s; 00724 size_t cnt = count / sizeof(size_t); 00725 //size_t mod_ = count - cnt * sizeof(size_t); 00726 size_t mod_ = count % sizeof(size_t); 00727 d = (const size_t *)buf1; 00728 s = (const size_t *)buf2; 00729 for(i=0;i<cnt;i++){ 00730 if(d[i] != s[i]){ 00731 /*if(d[i] > s[i]){ 00732 return d[i] - s[i]; 00733 }else{ 00734 s[i] - d[i]; 00735 }*/ 00736 00737 const int *a,*b; 00738 a = &d[i]; 00739 b = &s[i]; 00740 return *a - *b; 00741 //return ((int *)&d[i]) - ((int *)&s[i]); 00742 00743 } 00744 } 00745 cnt = count - mod_; 00746 return dkcstd_memcmp8(buf1,buf2,count); 00747 }
|
|
どんな環境でも動く単純なmemcpy()
参照先 dkcstd_memcpy64(). 参照元 dkcstd_bcopy(). 00702 { 00703 return dkcstd_memcpy64(dest,src,count); 00704 }
|
|
32bit毎にコピー
00636 { 00637 00638 size_t i; 00639 size_t *d,*s; 00640 size_t cnt = count / sizeof(size_t); 00641 //size_t mod_ = count - cnt * sizeof(size_t); 00642 size_t mod_ = count % sizeof(size_t);//多分、上記よりはイイコードを吐く & 3みたいな? 00643 d = (size_t *)dest; 00644 s = (size_t *)src; 00645 for(i=0;i<cnt;i++){ 00646 d[i] = s[i]; 00647 } 00648 00649 cnt = count - mod_; 00650 for(i=0;i<mod_;i++){ 00651 (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]); 00652 } 00653 return dest; 00654 }
|
|
64bit毎にコピー
参照先 dkcd64BIT_T, と dkcstd_memcpy64f(). 参照元 dkcstd_memcpy(). 00676 { 00677 #ifndef WIN32 00678 return dkcstd_memcpy64f(dest,src,count); 00679 #else 00680 00681 #undef dkcd64BIT_T 00682 #define dkcd64BIT_T ULONGLONG 00683 size_t i; 00684 dkcd64BIT_T *d,*s; 00685 size_t cnt = count / sizeof(dkcd64BIT_T); 00686 //size_t mod_ = count - cnt * sizeof(dkcd64BIT_T); 00687 size_t mod_ = count % sizeof(dkcd64BIT_T); 00688 d = (dkcd64BIT_T *)dest; 00689 s = (dkcd64BIT_T *)src; 00690 for(i=0;i<cnt;i++){ 00691 d[i] = s[i]; 00692 } 00693 00694 cnt = count - mod_; 00695 for(i=0;i<mod_;i++){ 00696 (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]); 00697 } 00698 return dest; 00699 #endif 00700 }
|
|
64bit毎(double *にキャストして)にコピー
参照先 dkcd64BIT_T. 参照元 dkcstd_memcpy64(). 00656 { 00657 #define dkcd64BIT_T double 00658 size_t i; 00659 dkcd64BIT_T *d,*s; 00660 size_t cnt = count / sizeof(dkcd64BIT_T); 00661 //size_t mod_ = count - cnt * sizeof(dkcd64BIT_T); 00662 size_t mod_ = count % sizeof(dkcd64BIT_T); 00663 d = (dkcd64BIT_T *)dest; 00664 s = (dkcd64BIT_T *)src; 00665 for(i=0;i<cnt;i++){ 00666 d[i] = s[i]; 00667 } 00668 00669 cnt = count - mod_; 00670 for(i=0;i<mod_;i++){ 00671 (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]); 00672 } 00673 return dest; 00674 }
|
|
8bit毎にコピー
00064 { 00065 size_t i; 00066 uint8 *d; 00067 const uint8 *s; 00068 00069 d = dest; 00070 s = src; 00071 00072 for(i=0;i<count;i++){ 00073 d[i] = s[i]; 00074 } 00075 return dest; 00076 }
|
|
00593 { 00594 uint8 *d = (uint8 *)dest; 00595 const uint8 *s = (const uint8 *)src; 00596 size_t i; 00597 00598 uint8 *pb; 00599 //filter 00600 size_t alloc_offset; 00601 00602 00603 pb = (uint8*)s + count;//ここ、オーバーフロー? 00604 if((void *)pb > dest){ 00605 alloc_offset = (size_t)(uint8*)(pb - d); 00606 pb = (uint8*)malloc(alloc_offset); 00607 //dest は srcの最後の部分と重なっているから・・・。 00608 memcpy(pb,dest,alloc_offset); 00609 }else{ 00610 alloc_offset = 0; 00611 pb = NULL; 00612 } 00613 00614 00615 //process 00616 { 00617 size_t c = count - alloc_offset; 00618 for(i=0;i<c;i++){ 00619 d[i] = s[i]; 00620 } 00621 d += i; 00622 for(i=0;i<alloc_offset;i++){ 00623 d[i] = pb[i]; 00624 } 00625 } 00626 00627 00628 if(pb){ 00629 free(pb); 00630 } 00631 return dest; 00632 }
|
|
参照先 dkcstd_memset8(). 参照元 dkcstd_bzero(). 00707 { 00708 uint8 cc = (uint8)c; 00709 uint32 ccc = cc | (cc << 8) | (cc << 16) | (cc << 24); 00710 size_t i; 00711 size_t cnt = count / sizeof(uint32);// >> 2か?まぁ、最適化頼みって事で 00712 size_t mod = count % sizeof(uint32); 00713 size_t *d = dest; 00714 for(i=0;i<cnt;i++){ 00715 d[i] = ccc; 00716 } 00717 dkcstd_memset8(&d[i],c,mod); 00718 return dest; 00719 }
|
|
参照元 dkcstd_get_memory_align(), と dkcstd_pointer_align(). 00039 { 00040 size_t force = (size_t)src; 00041 size_t save = force; 00042 while((force % align_offset )!= 0){ 00043 force++; 00044 #ifdef WIN32 00045 //(確かWin32の場合、0x7FFFFFFFより上の領域は返さないはずだが・・・ 00046 //if(0x7FFFFFFF<=force){ 00047 if(0x80000000 <= force){ 00048 break; 00049 } 00050 #else 00051 if(0==force){//安全策 00052 break; 00053 } 00054 #endif 00055 } 00056 return force - save; 00057 }
|
|
00035 { 00036 return ((uint8 *)src) + dkcstd_offset_align(src,align_offset); 00037 }
|