メインページ | アルファベット順一覧 | データ構造 | ファイル一覧 | データフィールド | グローバル | 関連ページ

# memory.h

memory.hの代わり [詳細]

`#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.hの代わり

作者:
  d金魚

から:
  2005/01/17

覚え書き:
  memcpyにこだわる人にオススメ。 memcpy郡にはmemory copy code benchmarkのソースコードを流用しました。 以下が使用条件の原文です

      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/

You can use this source code for any purpose without permission. Notes that this source code is not supported the processing of fraction bytes.

- SSE系の命令は16byteアライメントされたデータでないと例外が発生します。 - SSE系の関数でmovupsが付いているものはアラインメント考慮の必要がありません。 - FPU系の命令は8byteアライメントされたデータでないとエラーが発生します。 - aling()系関数（例：dkcstd_check_align()）はsizeof(void *) == sizeof(size_t)を前提として処理しています。 memory.h で定義されています。

## 型定義

typedef struct dkcstd_aligned_memory_result DKCSTD_ALIGNED_MEM

## 関数

DKC_EXTERN BOOL dkcstd_check_align | ( | const void * | src,
|  | size_t | bytes
| ) |

DKC_EXTERN void dkcstd_get_memory_align | ( | DKCSTD_ALIGNED_MEM * | r,
|  | const void * | src,
|  | size_t | srcsize,
|  | size_t | align_offset
| ) |

| memory.c の 22 行で定義されています。 参照先 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 }

DKC_EXTERN void* dkcstd_memchr | ( | const void * | buf,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 751 行で定義されています。 参照先 dkcstd_memchr8().
    00751                                                            {
    00752     return dkcstd_memchr8( buf,  c,  count );
    00753 }

DKC_EXTERN int dkcstd_memcmp | ( | const void * | buf1,
|  | const void * | buf2,
|  | size_t | count
| ) |

| memory.c の 721 行で定義されています。 参照先 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 }

DKC_EXTERN void* dkcstd_memcpy | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| どんな環境でも動く単純なmemcpy() memory.c の 702 行で定義されています。 参照先 dkcstd_memcpy64(). 参照元 dkcstd_bcopy().
    00702                                                                 {
    00703     return dkcstd_memcpy64(dest,src,count);
    00704 }

DKC_EXTERN void* dkcstd_memcpy32 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 32bit毎にコピー memory.c の 636 行で定義されています。
    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 }

DKC_EXTERN void* dkcstd_memcpy64 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 64bit毎にコピー memory.c の 676 行で定義されています。 参照先 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 }

DKC_EXTERN void* dkcstd_memcpy64f | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 64bit毎(double *にキャストして)にコピー memory.c の 656 行で定義されています。 参照先 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 }

DKC_EXTERN void* dkcstd_memcpy8 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 8bit毎にコピー memory.c の 64 行で定義されています。
    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 }

DKC_EXTERN void* dkcstd_memmove | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| TODO: filter部のオーバーフローをチェックする事 TODO: filter部のオーバーフローをチェックする事 memory.c の 593 行で定義されています。 参照先 memcpy, と NULL.
    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 }

DKC_EXTERN void* dkcstd_memset | ( | void * | dest,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 707 行で定義されています。 参照先 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 }

DKC_EXTERN size_t dkcstd_offset_align | ( | const void * | src,
|  | size_t | align_offset
| ) |

| memory.c の 39 行で定義されています。 参照元 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 }

DKC_EXTERN void* dkcstd_pointer_align | ( | const void * | src,
|  | size_t | align_offset
| ) |

| memory.c の 35 行で定義されています。 参照先 dkcstd_offset_align(). 参照元 aligned_malloc_calc().
    00035                                                                            {
    00036     return ((uint8 *)src) + dkcstd_offset_align(src,align_offset);
    00037 }