Delphi 汇编学习（十）--- 内存复制的极致优化

最新推荐文章于 2022-11-09 06:02:35 发布
最新推荐文章于 2022-11-09 06:02:35 发布
阅读量987 收藏 2
点赞数 1
分类专栏： SIMD Delphi 图形图像 文章标签： Delphi 图形图像 SIMD 内存复制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dbyoung/article/details/114531662
版权
Delphi 同时被 3 个专栏收录
32 篇文章 6 订阅
订阅专栏
图形图像
17 篇文章 4 订阅
订阅专栏
SIMD
15 篇文章 2 订阅
订阅专栏

在 汇编学习（八）--- 图像水平镜像垂直镜像的极致优化 中，我们使用了 FastMove，来提高内存复制速度。
但 FastMove 不支持 x64。而且很多年没有更新了。我们自己动手来写吧。由简到繁，容易理解。
必须支持：X86、X64。
必须支持：SSE2、SSE4、AVX1、AVX2（包括：内存对齐和未对齐）。


首先写一个最简单的 MOVE 函数。
每一次复制 1 个字节：

{ 每一次复制 1 个字节 <Byte> }
procedure Move_Byte(const src: Pointer; dst: Pointer; const len: NativeInt);
var
  pSrc: PByte;
  pDst: PByte;
  I   : NativeInt;
begin
  pSrc  := PByte(src);     // 取 src 首地址
  pDst  := PByte(dst);     // 取 dst 首地址
  for I := 0 to len - 1 do //
  begin                    //
    pDst^ := pSrc^;        // 把 pSrc 源地址中的值 ---> 赋给 pDst 目地址的值；按字节(BYTE)赋值
    Inc(pSrc);             // 源地址加 1
    Inc(pDst);             // 目地址加 1
  end;
end;

每一次复制 2 个字节：

{ 每一次复制 2 个字节 <WORD> <长度必须是 2 的倍数> }
procedure Move_WORD(const src: Pointer; dst: Pointer; const len: NativeInt);
var
  pSrc: PWORD;
  pDst: PWORD;
  I   : NativeInt;
begin
  pSrc  := PWORD(src);           // 取 src 首地址
  pDst  := PWORD(dst);           // 取 dst 首地址
  for I := 0 to len div 2 - 1 do //
  begin                          //
    pDst^ := pSrc^;              // 把 pSrc 源地址中的值 ---> 赋给 pDst 目地址的值；按双字节(WORD)赋值
    Inc(pSrc);                   // 源地址加 2
    Inc(pDst);                   // 目地址加 2
  end;
end;

每一次复制 4 个字节：

{ 每一次复制 4 个字节 <DWORD> <长度必须是 4 的倍数> }
procedure Move_DWORD(const src: Pointer; dst: Pointer; const len: NativeInt);
var
  pSrc: PDWORD;
  pDst: PDWORD;
  I   : NativeInt;
begin
  pSrc  := PDWORD(src);          // 取 src 首地址
  pDst  := PDWORD(dst);          // 取 dst 首地址
  for I := 0 to len div 4 - 1 do //
  begin                          //
    pDst^ := pSrc^;              // 把 pSrc 源地址中的值 ---> 赋给 pDst 目地址的值；按4字节(DWORD)赋值
    Inc(pSrc);                   // 源地址加 4
    Inc(pDst);                   // 目地址加 4
  end;
end;

每一次复制 8 个字节：

{ 每一次复制 8 个字节 <UINT64> <长度必须是 8 的倍数> }
procedure Move_UINT64(const src: Pointer; dst: Pointer; const len: NativeInt);
var
  pSrc: PUInt64;
  pDst: PUInt64;
  I   : NativeInt;
begin
  pSrc  := PUInt64(src);         // 取 src 首地址
  pDst  := PUInt64(dst);         // 取 dst 首地址
  for I := 0 to len div 8 - 1 do //
  begin                          //
    pDst^ := pSrc^;              // 把 pSrc 源地址中的值 ---> 赋给 pDst 目地址的值；按8字节(UINT64)赋值
    Inc(pSrc);                   // 源地址加 8
    Inc(pDst);                   // 目地址加 8
  end;
end;

每一次复制 16 个字节：

{ 每一次复制 16 个字节 <128 位> <长度必须是 16 的倍数> }
procedure Move_SSE2_16U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  LDDQU   XMM0, [EAX]
  MOVDQU  [EDX], XMM0

  ADD    EAX, 16
  ADD    EDX, 16
  SUB    ECX, 16
  JNZ    @LOOP
end;

每一次复制 32 个字节：

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_SSE2_32U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  LDDQU   XMM0, [EAX+00]
  LDDQU   XMM1, [EAX+16]
  MOVDQU  [EDX+00], XMM0
  MOVDQU  [EDX+16], XMM1

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
end;

每一次复制 64 个字节：

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_SSE2_64U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  LDDQU   XMM0, [EAX+00]
  LDDQU   XMM1, [EAX+16]
  LDDQU   XMM2, [EAX+32]
  LDDQU   XMM3, [EAX+48]
  MOVDQU  [EDX+00], XMM0
  MOVDQU  [EDX+16], XMM1
  MOVDQU  [EDX+32], XMM2
  MOVDQU  [EDX+48], XMM3

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
end;

每一次复制 128 个字节：

{ 每一次复制 128 个字节 <1024 位> <长度必须是 128 的倍数> }
procedure Move_SSE2_128U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  LDDQU   XMM0, [EAX+000]
  LDDQU   XMM1, [EAX+016]
  LDDQU   XMM2, [EAX+032]
  LDDQU   XMM3, [EAX+048]
  LDDQU   XMM4, [EAX+064]
  LDDQU   XMM5, [EAX+080]
  LDDQU   XMM6, [EAX+096]
  LDDQU   XMM7, [EAX+112]
  MOVDQU  [EDX+000], XMM0
  MOVDQU  [EDX+016], XMM1
  MOVDQU  [EDX+032], XMM2
  MOVDQU  [EDX+048], XMM3
  MOVDQU  [EDX+064], XMM4
  MOVDQU  [EDX+080], XMM5
  MOVDQU  [EDX+096], XMM6
  MOVDQU  [EDX+112], XMM7

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
end;

每一次复制 256 个字节：

{ 每一次复制 256 个字节 <2048 位> <长度必须是 256 的倍数> }
procedure Move_SSE2_256U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
@LOOP:
  LDDQU   XMM0,  [EAX+000]
  LDDQU   XMM1,  [EAX+016]
  LDDQU   XMM2,  [EAX+032]
  LDDQU   XMM3,  [EAX+048]
  LDDQU   XMM4,  [EAX+064]
  LDDQU   XMM5,  [EAX+080]
  LDDQU   XMM6,  [EAX+096]
  LDDQU   XMM7,  [EAX+112]
  LDDQU   XMM8,  [EAX+128]
  LDDQU   XMM9,  [EAX+144]
  LDDQU   XMM10, [EAX+160]
  LDDQU   XMM11, [EAX+176]
  LDDQU   XMM12, [EAX+192]
  LDDQU   XMM13, [EAX+208]
  LDDQU   XMM14, [EAX+224]
  LDDQU   XMM15, [EAX+240]

  MOVDQU  [EDX+000],  XMM0
  MOVDQU  [EDX+016],  XMM1
  MOVDQU  [EDX+032],  XMM2
  MOVDQU  [EDX+048],  XMM3
  MOVDQU  [EDX+064],  XMM4
  MOVDQU  [EDX+080],  XMM5
  MOVDQU  [EDX+096],  XMM6
  MOVDQU  [EDX+112],  XMM7
  MOVDQU  [EDX+128],  XMM8
  MOVDQU  [EDX+144],  XMM9
  MOVDQU  [EDX+160], XMM10
  MOVDQU  [EDX+176], XMM11
  MOVDQU  [EDX+192], XMM12
  MOVDQU  [EDX+208], XMM13
  MOVDQU  [EDX+224], XMM14
  MOVDQU  [EDX+240], XMM15
  {$ELSE}
@LOOP:
  LDDQU   XMM0,  [EAX+000]
  LDDQU   XMM1,  [EAX+016]
  LDDQU   XMM2,  [EAX+032]
  LDDQU   XMM3,  [EAX+048]
  LDDQU   XMM4,  [EAX+064]
  LDDQU   XMM5,  [EAX+080]
  LDDQU   XMM6,  [EAX+096]
  LDDQU   XMM7,  [EAX+112]
  MOVDQU [EDX+000],  XMM0
  MOVDQU [EDX+016],  XMM1
  MOVDQU [EDX+032],  XMM2
  MOVDQU [EDX+048],  XMM3
  MOVDQU [EDX+064],  XMM4
  MOVDQU [EDX+080],  XMM5
  MOVDQU [EDX+096],  XMM6
  MOVDQU [EDX+112],  XMM7

  LDDQU   XMM0,  [EAX+128]
  LDDQU   XMM1,  [EAX+144]
  LDDQU   XMM2,  [EAX+160]
  LDDQU   XMM3,  [EAX+176]
  LDDQU   XMM4,  [EAX+192]
  LDDQU   XMM5,  [EAX+208]
  LDDQU   XMM6,  [EAX+224]
  LDDQU   XMM7,  [EAX+240]
  MOVDQU  [EDX+128],  XMM0
  MOVDQU  [EDX+144],  XMM1
  MOVDQU  [EDX+160],  XMM2
  MOVDQU  [EDX+176],  XMM3
  MOVDQU  [EDX+192],  XMM4
  MOVDQU  [EDX+208],  XMM5
  MOVDQU  [EDX+224],  XMM6
  MOVDQU  [EDX+240],  XMM7
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
end;

每一次复制 32 个字节：

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_AVX1_32U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VLDDQU   YMM0, [EAX]
  VMOVDQU  [EDX], YMM0
  {$ENDIF}

  {$IFDEF WIN64}
  DB  $67, $C5, $FF, $F0, $00
  DB  $67, $C5, $FE, $7F, $02
  {$ELSE}
  DB  $C5, $FF, $F0, $00
  DB  $C5, $FE, $7F, $02
  {$ENDIF}

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
end;

每一次复制 64 个字节：

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_AVX1_64U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VLDDQU   YMM0, [EAX+00]
  VLDDQU   YMM1, [EAX+32]
  VMOVDQU  [EDX+00], YMM0
  VMOVDQU  [EDX+32], YMM1
  {$ENDIF}

  {$IFDEF WIN64}
  DB  $67, $C5, $FF, $F0, $00
  DB  $67, $C5, $FF, $F0, $48, $20
  DB  $67, $C5, $FE, $7F, $02
  DB  $67, $C5, $FE, $7F, $4A, $20
  {$ELSE}
  DB  $C5, $FF, $F0, $00
  DB  $C5, $FF, $F0, $48, $20
  DB  $C5, $FE, $7F, $02
  DB  $C5, $FE, $7F, $4A, $20
  {$ENDIF}

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
end;

每一次复制 128 个字节：

{ 每一次复制 128 个字节 <1024 位> <长度必须是 128 的倍数> }
procedure Move_AVX1_128U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VLDDQU   YMM0, [EAX+00]
  VLDDQU   YMM1, [EAX+32]
  VLDDQU   YMM2, [EAX+64]
  VLDDQU   YMM3, [EAX+96]
  VMOVDQU  [EDX+00], YMM0
  VMOVDQU  [EDX+32], YMM1
  VMOVDQU  [EDX+64], YMM2
  VMOVDQU  [EDX+96], YMM3
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FF, $F0, $00
  DB $67, $C5, $FF, $F0, $48, $20
  DB $67, $C5, $FF, $F0, $50, $40
  DB $67, $C5, $FF, $F0, $58, $60
  DB $67, $C5, $FE, $7F, $02
  DB $67, $C5, $FE, $7F, $4A, $20
  DB $67, $C5, $FE, $7F, $52, $40
  DB $67, $C5, $FE, $7F, $5A, $60
  {$ELSE}
  DB $C5, $FF, $F0, $00
  DB $C5, $FF, $F0, $48, $20
  DB $C5, $FF, $F0, $50, $40
  DB $C5, $FF, $F0, $58, $60
  DB $C5, $FE, $7F, $02
  DB $C5, $FE, $7F, $4A, $20
  DB $C5, $FE, $7F, $52, $40
  DB $C5, $FE, $7F, $5A, $60
  {$ENDIF}

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
end;

每一次复制 256 个字节：

{ 每一次复制 256 个字节 <2048 位> <长度必须是 256 的倍数> }
procedure Move_AVX1_256U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VLDDQU   YMM0, [EAX+000]
  VLDDQU   YMM1, [EAX+032]
  VLDDQU   YMM2, [EAX+064]
  VLDDQU   YMM3, [EAX+096]
  VLDDQU   YMM4, [EAX+128]
  VLDDQU   YMM5, [EAX+160]
  VLDDQU   YMM6, [EAX+192]
  VLDDQU   YMM7, [EAX+224]
  VMOVDQU  [EDX+000], YMM0
  VMOVDQU  [EDX+032], YMM1
  VMOVDQU  [EDX+064], YMM2
  VMOVDQU  [EDX+096], YMM3
  VMOVDQU  [EDX+128], YMM4
  VMOVDQU  [EDX+160], YMM5
  VMOVDQU  [EDX+192], YMM6
  VMOVDQU  [EDX+224], YMM7
  {$ENDIF}

  {$IFDEF WIN64}
  DB  $67, $C5, $FF, $F0, $00
  DB  $67, $C5, $FF, $F0, $48, $20
  DB  $67, $C5, $FF, $F0, $50, $40
  DB  $67, $C5, $FF, $F0, $58, $60
  DB  $67, $C5, $FF, $F0, $A0, $80, $00, $00, $00
  DB  $67, $C5, $FF, $F0, $A8, $A0, $00, $00, $00
  DB  $67, $C5, $FF, $F0, $B0, $C0, $00, $00, $00
  DB  $67, $C5, $FF, $F0, $B8, $E0, $00, $00, $00
  DB  $67, $C5, $FE, $7F, $02
  DB  $67, $C5, $FE, $7F, $4A, $20
  DB  $67, $C5, $FE, $7F, $52, $40
  DB  $67, $C5, $FE, $7F, $5A, $60
  DB  $67, $C5, $FE, $7F, $A2, $80, $00, $00, $00
  DB  $67, $C5, $FE, $7F, $AA, $A0, $00, $00, $00
  DB  $67, $C5, $FE, $7F, $B2, $C0, $00, $00, $00
  DB  $67, $C5, $FE, $7F, $BA, $E0, $00, $00, $00
  {$ELSE}
  DB  $C5, $FF, $F0, $00
  DB  $C5, $FF, $F0, $48, $20
  DB  $C5, $FF, $F0, $50, $40
  DB  $C5, $FF, $F0, $58, $60
  DB  $C5, $FF, $F0, $A0, $80, $00, $00, $00
  DB  $C5, $FF, $F0, $A8, $A0, $00, $00, $00
  DB  $C5, $FF, $F0, $B0, $C0, $00, $00, $00
  DB  $C5, $FF, $F0, $B8, $E0, $00, $00, $00
  DB  $C5, $FE, $7F, $02
  DB  $C5, $FE, $7F, $4A, $20
  DB  $C5, $FE, $7F, $52, $40
  DB  $C5, $FE, $7F, $5A, $60
  DB  $C5, $FE, $7F, $A2, $80, $00, $00, $00
  DB  $C5, $FE, $7F, $AA, $A0, $00, $00, $00
  DB  $C5, $FE, $7F, $B2, $C0, $00, $00, $00
  DB  $C5, $FE, $7F, $BA, $E0, $00, $00, $00
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
end;

每一次复制 512 个字节：

{ 每一次复制 512 个字节 <4096 位> <长度必须是 512 的倍数> }
procedure Move_AVX1_512U(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  {$IFDEF WIN64}
  VLDDQU   YMM0,  [EAX+000]
  VLDDQU   YMM1,  [EAX+032]
  VLDDQU   YMM2,  [EAX+064]
  VLDDQU   YMM3,  [EAX+096]
  VLDDQU   YMM4,  [EAX+128]
  VLDDQU   YMM5,  [EAX+160]
  VLDDQU   YMM6,  [EAX+192]
  VLDDQU   YMM7,  [EAX+224]
  VLDDQU   YMM8,  [EAX+256]
  VLDDQU   YMM9,  [EAX+288]
  VLDDQU   YMM10, [EAX+320]
  VLDDQU   YMM11, [EAX+352]
  VLDDQU   YMM12, [EAX+384]
  VLDDQU   YMM13, [EAX+416]
  VLDDQU   YMM14, [EAX+448]
  VLDDQU   YMM15, [EAX+480]
  VMOVDQU  [EDX+000],  YMM0
  VMOVDQU  [EDX+032],  YMM1
  VMOVDQU  [EDX+064],  YMM2
  VMOVDQU  [EDX+096],  YMM3
  VMOVDQU  [EDX+128],  YMM4
  VMOVDQU  [EDX+160],  YMM5
  VMOVDQU  [EDX+192],  YMM6
  VMOVDQU  [EDX+224],  YMM7
  VMOVDQU  [EDX+256],  YMM8
  VMOVDQU  [EDX+288],  YMM9
  VMOVDQU  [EDX+320], YMM10
  VMOVDQU  [EDX+352], YMM11
  VMOVDQU  [EDX+384], YMM12
  VMOVDQU  [EDX+416], YMM13
  VMOVDQU  [EDX+448], YMM14
  VMOVDQU  [EDX+480], YMM15
  {$ELSE}
  VLDDQU   YMM0,  [EAX+000]
  VLDDQU   YMM1,  [EAX+032]
  VLDDQU   YMM2,  [EAX+064]
  VLDDQU   YMM3,  [EAX+096]
  VLDDQU   YMM4,  [EAX+128]
  VLDDQU   YMM5,  [EAX+160]
  VLDDQU   YMM6,  [EAX+192]
  VLDDQU   YMM7,  [EAX+224]
  VMOVDQU  [EDX+000],  YMM0
  VMOVDQU  [EDX+032],  YMM1
  VMOVDQU  [EDX+064],  YMM2
  VMOVDQU  [EDX+096],  YMM3
  VMOVDQU  [EDX+128],  YMM4
  VMOVDQU  [EDX+160],  YMM5
  VMOVDQU  [EDX+192],  YMM6
  VMOVDQU  [EDX+224],  YMM7
  VLDDQU   YMM0, [EAX+256]
  VLDDQU   YMM1, [EAX+288]
  VLDDQU   YMM2, [EAX+320]
  VLDDQU   YMM3, [EAX+352]
  VLDDQU   YMM4, [EAX+384]
  VLDDQU   YMM5, [EAX+416]
  VLDDQU   YMM6, [EAX+448]
  VLDDQU   YMM7, [EAX+480]
  VMOVDQU  [EDX+256], YMM0
  VMOVDQU  [EDX+288], YMM1
  VMOVDQU  [EDX+320], YMM2
  VMOVDQU  [EDX+352], YMM3
  VMOVDQU  [EDX+384], YMM4
  VMOVDQU  [EDX+416], YMM5
  VMOVDQU  [EDX+448], YMM6
  VMOVDQU  [EDX+480], YMM7
  {$ENDIF}
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FF, $F0, $00
  DB $67, $C5, $FF, $F0, $48, $20
  DB $67, $C5, $FF, $F0, $50, $40
  DB $67, $C5, $FF, $F0, $58, $60
  DB $67, $C5, $FF, $F0, $A0, $80, $00, $00, $00
  DB $67, $C5, $FF, $F0, $A8, $A0, $00, $00, $00
  DB $67, $C5, $FF, $F0, $B0, $C0, $00, $00, $00
  DB $67, $C5, $FF, $F0, $B8, $E0, $00, $00, $00
  DB $67, $C5, $7F, $F0, $80, $00, $01, $00, $00
  DB $67, $C5, $7F, $F0, $88, $20, $01, $00, $00
  DB $67, $C5, $7F, $F0, $90, $40, $01, $00, $00
  DB $67, $C5, $7F, $F0, $98, $60, $01, $00, $00
  DB $67, $C5, $7F, $F0, $A0, $80, $01, $00, $00
  DB $67, $C5, $7F, $F0, $A8, $A0, $01, $00, $00
  DB $67, $C5, $7F, $F0, $B0, $C0, $01, $00, $00
  DB $67, $C5, $7F, $F0, $B8, $E0, $01, $00, $00
  DB $67, $C5, $FE, $7F, $02
  DB $67, $C5, $FE, $7F, $4A, $20
  DB $67, $C5, $FE, $7F, $52, $40
  DB $67, $C5, $FE, $7F, $5A, $60
  DB $67, $C5, $FE, $7F, $A2, $80, $00, $00, $00
  DB $67, $C5, $FE, $7F, $AA, $A0, $00, $00, $00
  DB $67, $C5, $FE, $7F, $B2, $C0, $00, $00, $00
  DB $67, $C5, $FE, $7F, $BA, $E0, $00, $00, $00
  DB $67, $C5, $7E, $7F, $82, $00, $01, $00, $00
  DB $67, $C5, $7E, $7F, $8A, $20, $01, $00, $00
  DB $67, $C5, $7E, $7F, $92, $40, $01, $00, $00
  DB $67, $C5, $7E, $7F, $9A, $60, $01, $00, $00
  DB $67, $C5, $7E, $7F, $A2, $80, $01, $00, $00
  DB $67, $C5, $7E, $7F, $AA, $A0, $01, $00, $00
  DB $67, $C5, $7E, $7F, $B2, $C0, $01, $00, $00
  DB $67, $C5, $7E, $7F, $BA, $E0, $01, $00, $00
  {$ELSE}
  DB $C5, $FF, $F0, $00
  DB $C5, $FF, $F0, $48, $20
  DB $C5, $FF, $F0, $50, $40
  DB $C5, $FF, $F0, $58, $60
  DB $C5, $FF, $F0, $A0, $80, $00, $00, $00
  DB $C5, $FF, $F0, $A8, $A0, $00, $00, $00
  DB $C5, $FF, $F0, $B0, $C0, $00, $00, $00
  DB $C5, $FF, $F0, $B8, $E0, $00, $00, $00
  DB $C5, $FE, $7F, $02
  DB $C5, $FE, $7F, $4A, $20
  DB $C5, $FE, $7F, $52, $40
  DB $C5, $FE, $7F, $5A, $60
  DB $C5, $FE, $7F, $A2, $80, $00, $00, $00
  DB $C5, $FE, $7F, $AA, $A0, $00, $00, $00
  DB $C5, $FE, $7F, $B2, $C0, $00, $00, $00
  DB $C5, $FE, $7F, $BA, $E0, $00, $00, $00
  DB $C5, $FF, $F0, $80, $00, $01, $00, $00
  DB $C5, $FF, $F0, $88, $20, $01, $00, $00
  DB $C5, $FF, $F0, $90, $40, $01, $00, $00
  DB $C5, $FF, $F0, $98, $60, $01, $00, $00
  DB $C5, $FF, $F0, $A0, $80, $01, $00, $00
  DB $C5, $FF, $F0, $A8, $A0, $01, $00, $00
  DB $C5, $FF, $F0, $B0, $C0, $01, $00, $00
  DB $C5, $FF, $F0, $B8, $E0, $01, $00, $00
  DB $C5, $FE, $7F, $82, $00, $01, $00, $00
  DB $C5, $FE, $7F, $8A, $20, $01, $00, $00
  DB $C5, $FE, $7F, $92, $40, $01, $00, $00
  DB $C5, $FE, $7F, $9A, $60, $01, $00, $00
  DB $C5, $FE, $7F, $A2, $80, $01, $00, $00
  DB $C5, $FE, $7F, $AA, $A0, $01, $00, $00
  DB $C5, $FE, $7F, $B2, $C0, $01, $00, $00
  DB $C5, $FE, $7F, $BA, $E0, $01, $00, $00
  {$ENDIF}

  ADD    EAX, 512
  ADD    EDX, 512
  SUB    ECX, 512
  JNZ    @LOOP
end;

以上内存复制函数，都是内存未按16字节对齐的情况。
SSE2/SSE4/AVX1/AVX2，还支持字节对齐时的内存复制。效率较高。而且，SSE4 还支持不通过 cache，直接的内存复制。
什么是 16 字节对齐？
  内存地址能被 16 整除。即内存地址的最后一位必须是 0；
  操作的俩个数的内存地址，都要是 16 字节对齐，才能使用 SSE 对齐指令；

什么是 32 字节对齐？
  内存地址能被 32 整除。
  内存地址的最后两位必须类似于： $..20, $..40, $..60, $..80, $..A0, $..C0, $..E0 。
  即内存地址的最后一位必须是 0，倒数第二位必须是偶数。
  操作的俩个数的内存地址，都要是 32 字节对齐，才能使用 AVX 对齐指令；

x64 默认内存地址按 16 字节对齐；
内存复制速度：
  1、16 字节对齐  >  未 16 字节对齐
  2、AVX2 > AVX1 > SSE4 > SSE2


下面是内存对齐时的内存复制函数（SSE2、SSE4：内存必须按 16 字节对齐；AVX1、AVX2：内存必须按 32 字节对齐）：

{ 每一次复制 16 个字节 <128 位> <长度必须是 16 的倍数> }
procedure Move_SSE2_16A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVDQA  XMM0, [EAX]
  MOVDQA [EDX],  XMM0

  ADD    EAX, 16
  ADD    EDX, 16
  SUB    ECX, 16
  JNZ    @LOOP
end;

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_SSE2_32A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVDQA  XMM0, [EAX+00]
  MOVDQA  XMM1, [EAX+16]
  MOVDQA  [EDX+00], XMM0
  MOVDQA  [EDX+16], XMM1

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
end;

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_SSE2_64A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVDQA   XMM0, [EAX+00]
  MOVDQA   XMM1, [EAX+16]
  MOVDQA   XMM2, [EAX+32]
  MOVDQA   XMM3, [EAX+48]
  MOVDQA  [EDX+00],  XMM0
  MOVDQA  [EDX+16],  XMM1
  MOVDQA  [EDX+32],  XMM2
  MOVDQA  [EDX+48],  XMM3

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
end;

{ 每一次复制 128 个字节 <1024 位> <长度必须是 128 的倍数> }
procedure Move_SSE2_128A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVDQA   XMM0, [EAX+000]
  MOVDQA   XMM1, [EAX+016]
  MOVDQA   XMM2, [EAX+032]
  MOVDQA   XMM3, [EAX+048]
  MOVDQA   XMM4, [EAX+064]
  MOVDQA   XMM5, [EAX+080]
  MOVDQA   XMM6, [EAX+096]
  MOVDQA   XMM7, [EAX+112]
  MOVDQA  [EDX+000],  XMM0
  MOVDQA  [EDX+016],  XMM1
  MOVDQA  [EDX+032],  XMM2
  MOVDQA  [EDX+048],  XMM3
  MOVDQA  [EDX+064],  XMM4
  MOVDQA  [EDX+080],  XMM5
  MOVDQA  [EDX+096],  XMM6
  MOVDQA  [EDX+112],  XMM7

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
end;

{ 每一次复制 256 个字节 <2048 位> <长度必须是 256 的倍数> }
procedure Move_SSE2_256A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
@LOOP:
  MOVDQA   XMM0,  [EAX+000]
  MOVDQA   XMM1,  [EAX+016]
  MOVDQA   XMM2,  [EAX+032]
  MOVDQA   XMM3,  [EAX+048]
  MOVDQA   XMM4,  [EAX+064]
  MOVDQA   XMM5,  [EAX+080]
  MOVDQA   XMM6,  [EAX+096]
  MOVDQA   XMM7,  [EAX+112]
  MOVDQA   XMM8,  [EAX+128]
  MOVDQA   XMM9,  [EAX+144]
  MOVDQA   XMM10, [EAX+160]
  MOVDQA   XMM11, [EAX+176]
  MOVDQA   XMM12, [EAX+192]
  MOVDQA   XMM13, [EAX+208]
  MOVDQA   XMM14, [EAX+224]
  MOVDQA   XMM15, [EAX+240]

  MOVDQA  [EDX+000],  XMM0
  MOVDQA  [EDX+016],  XMM1
  MOVDQA  [EDX+032],  XMM2
  MOVDQA  [EDX+048],  XMM3
  MOVDQA  [EDX+064],  XMM4
  MOVDQA  [EDX+080],  XMM5
  MOVDQA  [EDX+096],  XMM6
  MOVDQA  [EDX+112],  XMM7
  MOVDQA  [EDX+128],  XMM8
  MOVDQA  [EDX+144],  XMM9
  MOVDQA  [EDX+160],  XMM10
  MOVDQA  [EDX+176],  XMM11
  MOVDQA  [EDX+192],  XMM12
  MOVDQA  [EDX+208],  XMM13
  MOVDQA  [EDX+224],  XMM14
  MOVDQA  [EDX+240],  XMM15
  {$ELSE}
@LOOP:
  MOVDQA   XMM0,  [EAX+000]
  MOVDQA   XMM1,  [EAX+016]
  MOVDQA   XMM2,  [EAX+032]
  MOVDQA   XMM3,  [EAX+048]
  MOVDQA   XMM4,  [EAX+064]
  MOVDQA   XMM5,  [EAX+080]
  MOVDQA   XMM6,  [EAX+096]
  MOVDQA   XMM7,  [EAX+112]
  MOVDQA   [EDX+000],  XMM0
  MOVDQA   [EDX+016],  XMM1
  MOVDQA   [EDX+032],  XMM2
  MOVDQA   [EDX+048],  XMM3
  MOVDQA   [EDX+064],  XMM4
  MOVDQA   [EDX+080],  XMM5
  MOVDQA   [EDX+096],  XMM6
  MOVDQA   [EDX+112],  XMM7

  MOVDQA   XMM0,  [EAX+128]
  MOVDQA   XMM1,  [EAX+144]
  MOVDQA   XMM2,  [EAX+160]
  MOVDQA   XMM3,  [EAX+176]
  MOVDQA   XMM4,  [EAX+192]
  MOVDQA   XMM5,  [EAX+208]
  MOVDQA   XMM6,  [EAX+224]
  MOVDQA   XMM7,  [EAX+240]
  MOVDQA   [EDX+128],  XMM0
  MOVDQA   [EDX+144],  XMM1
  MOVDQA   [EDX+160],  XMM2
  MOVDQA   [EDX+176],  XMM3
  MOVDQA   [EDX+192],  XMM4
  MOVDQA   [EDX+208],  XMM5
  MOVDQA   [EDX+224],  XMM6
  MOVDQA   [EDX+240],  XMM7
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
end;

{ 每一次复制 16 个字节 <128 位> <长度必须是 16 的倍数> }
procedure Move_SSE4_16A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVNTDQA  XMM0, [EAX]
  MOVNTDQ  [EDX],  XMM0

  ADD    EAX, 16
  ADD    EDX, 16
  SUB    ECX, 16
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_SSE4_32A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVNTDQA  XMM0, [EAX + 00]
  MOVNTDQA  XMM1, [EAX + 16]
  MOVNTDQ  [EDX + 00],  XMM0
  MOVNTDQ  [EDX + 16],  XMM1

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_SSE4_64A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVNTDQA  XMM0, [EAX + 00]
  MOVNTDQA  XMM1, [EAX + 16]
  MOVNTDQA  XMM2, [EAX + 32]
  MOVNTDQA  XMM3, [EAX + 48]
  MOVNTDQ  [EDX + 00],  XMM0
  MOVNTDQ  [EDX + 16],  XMM1
  MOVNTDQ  [EDX + 32],  XMM2
  MOVNTDQ  [EDX + 48],  XMM3

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 128 个字节 <1024 位> <长度必须是 128 的倍数> }
procedure Move_SSE4_128A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  MOVNTDQA  XMM0, [EAX + 00]
  MOVNTDQA  XMM1, [EAX + 16]
  MOVNTDQA  XMM2, [EAX + 32]
  MOVNTDQA  XMM3, [EAX + 48]
  MOVNTDQA  XMM4, [EAX + 64]
  MOVNTDQA  XMM5, [EAX + 80]
  MOVNTDQA  XMM6, [EAX + 96]
  MOVNTDQA  XMM7, [EAX +112]
  MOVNTDQ  [EDX + 00],  XMM0
  MOVNTDQ  [EDX + 16],  XMM1
  MOVNTDQ  [EDX + 32],  XMM2
  MOVNTDQ  [EDX + 48],  XMM3
  MOVNTDQ  [EDX + 64],  XMM4
  MOVNTDQ  [EDX + 80],  XMM5
  MOVNTDQ  [EDX + 96],  XMM6
  MOVNTDQ  [EDX +112],  XMM7

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 256 个字节 <1024 位> <长度必须是 256 的倍数> }
procedure Move_SSE4_256A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
@LOOP:
  MOVNTDQA  XMM0,  [EAX + 00]
  MOVNTDQA  XMM1,  [EAX + 16]
  MOVNTDQA  XMM2,  [EAX + 32]
  MOVNTDQA  XMM3,  [EAX + 48]
  MOVNTDQA  XMM4,  [EAX + 64]
  MOVNTDQA  XMM5,  [EAX + 80]
  MOVNTDQA  XMM6,  [EAX + 96]
  MOVNTDQA  XMM7,  [EAX +112]
  MOVNTDQA  XMM8,  [EAX +128]
  MOVNTDQA  XMM9,  [EAX +144]
  MOVNTDQA  XMM10, [EAX +160]
  MOVNTDQA  XMM11, [EAX +176]
  MOVNTDQA  XMM12, [EAX +192]
  MOVNTDQA  XMM13, [EAX +208]
  MOVNTDQA  XMM14, [EAX +224]
  MOVNTDQA  XMM15, [EAX +240]
  MOVNTDQ   [EDX + 00],  XMM0
  MOVNTDQ   [EDX + 16],  XMM1
  MOVNTDQ   [EDX + 32],  XMM2
  MOVNTDQ   [EDX + 48],  XMM3
  MOVNTDQ   [EDX + 64],  XMM4
  MOVNTDQ   [EDX + 80],  XMM5
  MOVNTDQ   [EDX + 96],  XMM6
  MOVNTDQ   [EDX +112],  XMM7
  MOVNTDQ   [EDX +128],  XMM8
  MOVNTDQ   [EDX +144],  XMM9
  MOVNTDQ   [EDX +160],  XMM10
  MOVNTDQ   [EDX +176],  XMM11
  MOVNTDQ   [EDX +192],  XMM12
  MOVNTDQ   [EDX +208],  XMM13
  MOVNTDQ   [EDX +224],  XMM14
  MOVNTDQ   [EDX +240],  XMM15
  {$ELSE}
@LOOP:
  MOVNTDQA  XMM0,  [EAX + 00]
  MOVNTDQA  XMM1,  [EAX + 16]
  MOVNTDQA  XMM2,  [EAX + 32]
  MOVNTDQA  XMM3,  [EAX + 48]
  MOVNTDQA  XMM4,  [EAX + 64]
  MOVNTDQA  XMM5,  [EAX + 80]
  MOVNTDQA  XMM6,  [EAX + 96]
  MOVNTDQA  XMM7,  [EAX +112]
  MOVNTDQ   [EDX + 00],  XMM0
  MOVNTDQ   [EDX + 16],  XMM1
  MOVNTDQ   [EDX + 32],  XMM2
  MOVNTDQ   [EDX + 48],  XMM3
  MOVNTDQ   [EDX + 64],  XMM4
  MOVNTDQ   [EDX + 80],  XMM5
  MOVNTDQ   [EDX + 96],  XMM6
  MOVNTDQ   [EDX +112],  XMM7
  MOVNTDQA  XMM0,  [EAX +128]
  MOVNTDQA  XMM1,  [EAX +144]
  MOVNTDQA  XMM2,  [EAX +160]
  MOVNTDQA  XMM3,  [EAX +176]
  MOVNTDQA  XMM4,  [EAX +192]
  MOVNTDQA  XMM5,  [EAX +208]
  MOVNTDQA  XMM6,  [EAX +224]
  MOVNTDQA  XMM7,  [EAX +240]
  MOVNTDQ   [EDX +128],  XMM0
  MOVNTDQ   [EDX +144],  XMM1
  MOVNTDQ   [EDX +160],  XMM2
  MOVNTDQ   [EDX +176],  XMM3
  MOVNTDQ   [EDX +192],  XMM4
  MOVNTDQ   [EDX +208],  XMM5
  MOVNTDQ   [EDX +224],  XMM6
  MOVNTDQ   [EDX +240],  XMM7
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_AVX1_32A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVDQA  YMM0, [EAX]
  VMOVDQA  [EDX], YMM0
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FD, $6F, $00
  DB $67, $C5, $FD, $7F, $02
  {$ELSE}
  DB $C5, $FD, $6F, $00
  DB $C5, $FD, $7F, $02
  {$ENDIF}

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
end;

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_AVX1_64A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVDQA   YMM0, [EAX + 00]
  VMOVDQA   YMM1, [EAX + 32]
  VMOVDQA   [EDX + 00], YMM0
  VMOVDQA   [EDX + 32], YMM1
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FD, $6F, $00
  DB $67, $C5, $FD, $6F, $48, $20
  DB $67, $C5, $FD, $7F, $02
  DB $67, $C5, $FD, $7F, $4A, $20
  {$ELSE}
  DB $C5, $FD, $6F, $00
  DB $C5, $FD, $6F, $48, $20
  DB $C5, $FD, $7F, $02
  DB $C5, $FD, $7F, $4A, $20
  {$ENDIF}

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
end;

{ 每一次复制 128 个字节 <1024 位> <长度必须是 128 的倍数> }
procedure Move_AVX1_128A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVDQA   YMM0, [EAX + 00]
  VMOVDQA   YMM1, [EAX + 32]
  VMOVDQA   YMM2, [EAX + 64]
  VMOVDQA   YMM3, [EAX + 96]
  VMOVDQA   [EDX + 00], YMM0
  VMOVDQA   [EDX + 32], YMM1
  VMOVDQA   [EDX + 64], YMM2
  VMOVDQA   [EDX + 96], YMM3
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FD, $6F, $00
  DB $67, $C5, $FD, $6F, $48, $20
  DB $67, $C5, $FD, $6F, $50, $40
  DB $67, $C5, $FD, $6F, $58, $60
  DB $67, $C5, $FD, $7F, $02
  DB $67, $C5, $FD, $7F, $4A, $20
  DB $67, $C5, $FD, $7F, $52, $40
  DB $67, $C5, $FD, $7F, $5A, $60
  {$ELSE}
  DB $C5, $FD, $6F, $00
  DB $C5, $FD, $6F, $48, $20
  DB $C5, $FD, $6F, $50, $40
  DB $C5, $FD, $6F, $58, $60
  DB $C5, $FD, $7F, $02
  DB $C5, $FD, $7F, $4A, $20
  DB $C5, $FD, $7F, $52, $40
  DB $C5, $FD, $7F, $5A, $60
  {$ENDIF}

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
end;

{ 每一次复制 256 个字节 <2048 位> <长度必须是 256 的倍数> }
procedure Move_AVX1_256A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVDQA   YMM0, [EAX+000]
  VMOVDQA   YMM1, [EAX+032]
  VMOVDQA   YMM2, [EAX+064]
  VMOVDQA   YMM3, [EAX+096]
  VMOVDQA   YMM4, [EAX+128]
  VMOVDQA   YMM5, [EAX+160]
  VMOVDQA   YMM6, [EAX+192]
  VMOVDQA   YMM7, [EAX+224]
  VMOVDQA   [EDX+000], YMM0
  VMOVDQA   [EDX+032], YMM1
  VMOVDQA   [EDX+064], YMM2
  VMOVDQA   [EDX+096], YMM3
  VMOVDQA   [EDX+128], YMM4
  VMOVDQA   [EDX+160], YMM5
  VMOVDQA   [EDX+192], YMM6
  VMOVDQA   [EDX+224], YMM7
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FD, $6F, $00
  DB $67, $C5, $FD, $6F, $48, $20
  DB $67, $C5, $FD, $6F, $50, $40
  DB $67, $C5, $FD, $6F, $58, $60
  DB $67, $C5, $FD, $6F, $A0, $80, $00, $00, $00
  DB $67, $C5, $FD, $6F, $A8, $A0, $00, $00, $00
  DB $67, $C5, $FD, $6F, $B0, $C0, $00, $00, $00
  DB $67, $C5, $FD, $6F, $B8, $E0, $00, $00, $00
  DB $67, $C5, $FD, $7F, $02
  DB $67, $C5, $FD, $7F, $4A, $20
  DB $67, $C5, $FD, $7F, $52, $40
  DB $67, $C5, $FD, $7F, $5A, $60
  DB $67, $C5, $FD, $7F, $A2, $80, $00, $00, $00
  DB $67, $C5, $FD, $7F, $AA, $A0, $00, $00, $00
  DB $67, $C5, $FD, $7F, $B2, $C0, $00, $00, $00
  DB $67, $C5, $FD, $7F, $BA, $E0, $00, $00, $00
  {$ELSE}
  DB $C5, $FD, $6F, $00
  DB $C5, $FD, $6F, $48, $20
  DB $C5, $FD, $6F, $50, $40
  DB $C5, $FD, $6F, $58, $60
  DB $C5, $FD, $6F, $A0, $80, $00, $00, $00
  DB $C5, $FD, $6F, $A8, $A0, $00, $00, $00
  DB $C5, $FD, $6F, $B0, $C0, $00, $00, $00
  DB $C5, $FD, $6F, $B8, $E0, $00, $00, $00
  DB $C5, $FD, $7F, $02
  DB $C5, $FD, $7F, $4A, $20
  DB $C5, $FD, $7F, $52, $40
  DB $C5, $FD, $7F, $5A, $60
  DB $C5, $FD, $7F, $A2, $80, $00, $00, $00
  DB $C5, $FD, $7F, $AA, $A0, $00, $00, $00
  DB $C5, $FD, $7F, $B2, $C0, $00, $00, $00
  DB $C5, $FD, $7F, $BA, $E0, $00, $00, $00
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
end;

{ 每一次复制 512 个字节 <4096 位> <长度必须是 512 的倍数> }
procedure Move_AVX1_512A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  {$IFDEF WIN64}
  VMOVDQA   YMM0,  [EAX+000]
  VMOVDQA   YMM1,  [EAX+032]
  VMOVDQA   YMM2,  [EAX+064]
  VMOVDQA   YMM3,  [EAX+096]
  VMOVDQA   YMM4,  [EAX+128]
  VMOVDQA   YMM5,  [EAX+160]
  VMOVDQA   YMM6,  [EAX+192]
  VMOVDQA   YMM7,  [EAX+224]
  VMOVDQA   YMM8,  [EAX+256]
  VMOVDQA   YMM9,  [EAX+288]
  VMOVDQA   YMM10, [EAX+320]
  VMOVDQA   YMM11, [EAX+352]
  VMOVDQA   YMM12, [EAX+384]
  VMOVDQA   YMM13, [EAX+416]
  VMOVDQA   YMM14, [EAX+448]
  VMOVDQA   YMM15, [EAX+480]
  VMOVDQA   [EDX+000],  YMM0
  VMOVDQA   [EDX+032],  YMM1
  VMOVDQA   [EDX+064],  YMM2
  VMOVDQA   [EDX+096],  YMM3
  VMOVDQA   [EDX+128],  YMM4
  VMOVDQA   [EDX+160],  YMM5
  VMOVDQA   [EDX+192],  YMM6
  VMOVDQA   [EDX+224],  YMM7
  VMOVDQA   [EDX+256],  YMM8
  VMOVDQA   [EDX+288],  YMM9
  VMOVDQA   [EDX+320],  YMM10
  VMOVDQA   [EDX+352],  YMM11
  VMOVDQA   [EDX+384],  YMM12
  VMOVDQA   [EDX+416],  YMM13
  VMOVDQA   [EDX+448],  YMM14
  VMOVDQA   [EDX+480],  YMM15
  {$ELSE}
  VMOVDQA   YMM0,  [EAX+000]
  VMOVDQA   YMM1,  [EAX+032]
  VMOVDQA   YMM2,  [EAX+064]
  VMOVDQA   YMM3,  [EAX+096]
  VMOVDQA   YMM4,  [EAX+128]
  VMOVDQA   YMM5,  [EAX+160]
  VMOVDQA   YMM6,  [EAX+192]
  VMOVDQA   YMM7,  [EAX+224]
  VMOVDQA   [EDX+000],  YMM0
  VMOVDQA   [EDX+032],  YMM1
  VMOVDQA   [EDX+064],  YMM2
  VMOVDQA   [EDX+096],  YMM3
  VMOVDQA   [EDX+128],  YMM4
  VMOVDQA   [EDX+160],  YMM5
  VMOVDQA   [EDX+192],  YMM6
  VMOVDQA   [EDX+224],  YMM7
  VMOVDQA   YMM0,  [EAX+256]
  VMOVDQA   YMM1,  [EAX+288]
  VMOVDQA   YMM2,  [EAX+320]
  VMOVDQA   YMM3,  [EAX+352]
  VMOVDQA   YMM4,  [EAX+384]
  VMOVDQA   YMM5,  [EAX+416]
  VMOVDQA   YMM6,  [EAX+448]
  VMOVDQA   YMM7,  [EAX+480]
  VMOVDQA   [EDX+256],  YMM0
  VMOVDQA   [EDX+288],  YMM1
  VMOVDQA   [EDX+320],  YMM2
  VMOVDQA   [EDX+352],  YMM3
  VMOVDQA   [EDX+384],  YMM4
  VMOVDQA   [EDX+416],  YMM5
  VMOVDQA   [EDX+448],  YMM6
  VMOVDQA   [EDX+480],  YMM7
  {$ENDIF}
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C5, $FD, $6F, $00
  DB $67, $C5, $FD, $6F, $48, $20
  DB $67, $C5, $FD, $6F, $50, $40
  DB $67, $C5, $FD, $6F, $58, $60
  DB $67, $C5, $FD, $6F, $A0, $80, $00, $00, $00
  DB $67, $C5, $FD, $6F, $A8, $A0, $00, $00, $00
  DB $67, $C5, $FD, $6F, $B0, $C0, $00, $00, $00
  DB $67, $C5, $FD, $6F, $B8, $E0, $00, $00, $00
  DB $67, $C5, $7D, $6F, $80, $00, $01, $00, $00
  DB $67, $C5, $7D, $6F, $88, $20, $01, $00, $00
  DB $67, $C5, $7D, $6F, $90, $40, $01, $00, $00
  DB $67, $C5, $7D, $6F, $98, $60, $01, $00, $00
  DB $67, $C5, $7D, $6F, $A0, $80, $01, $00, $00
  DB $67, $C5, $7D, $6F, $A8, $A0, $01, $00, $00
  DB $67, $C5, $7D, $6F, $B0, $C0, $01, $00, $00
  DB $67, $C5, $7D, $6F, $B8, $E0, $01, $00, $00
  DB $67, $C5, $FD, $7F, $02
  DB $67, $C5, $FD, $7F, $4A, $20
  DB $67, $C5, $FD, $7F, $52, $40
  DB $67, $C5, $FD, $7F, $5A, $60
  DB $67, $C5, $FD, $7F, $A2, $80, $00, $00, $00
  DB $67, $C5, $FD, $7F, $AA, $A0, $00, $00, $00
  DB $67, $C5, $FD, $7F, $B2, $C0, $00, $00, $00
  DB $67, $C5, $FD, $7F, $BA, $E0, $00, $00, $00
  DB $67, $C5, $7D, $7F, $82, $00, $01, $00, $00
  DB $67, $C5, $7D, $7F, $8A, $20, $01, $00, $00
  DB $67, $C5, $7D, $7F, $92, $40, $01, $00, $00
  DB $67, $C5, $7D, $7F, $9A, $60, $01, $00, $00
  DB $67, $C5, $7D, $7F, $A2, $80, $01, $00, $00
  DB $67, $C5, $7D, $7F, $AA, $A0, $01, $00, $00
  DB $67, $C5, $7D, $7F, $B2, $C0, $01, $00, $00
  DB $67, $C5, $7D, $7F, $BA, $E0, $01, $00, $00
  {$ELSE}
  DB $C5, $FD, $6F, $00
  DB $C5, $FD, $6F, $48, $20
  DB $C5, $FD, $6F, $50, $40
  DB $C5, $FD, $6F, $58, $60
  DB $C5, $FD, $6F, $A0, $80, $00, $00, $00
  DB $C5, $FD, $6F, $A8, $A0, $00, $00, $00
  DB $C5, $FD, $6F, $B0, $C0, $00, $00, $00
  DB $C5, $FD, $6F, $B8, $E0, $00, $00, $00
  DB $C5, $7D, $6F, $80, $00, $01, $00, $00
  DB $C5, $7D, $6F, $88, $20, $01, $00, $00
  DB $C5, $7D, $6F, $90, $40, $01, $00, $00
  DB $C5, $7D, $6F, $98, $60, $01, $00, $00
  DB $C5, $7D, $6F, $A0, $80, $01, $00, $00
  DB $C5, $7D, $6F, $A8, $A0, $01, $00, $00
  DB $C5, $7D, $6F, $B0, $C0, $01, $00, $00
  DB $C5, $7D, $6F, $B8, $E0, $01, $00, $00
  DB $C5, $FD, $7F, $02
  DB $C5, $FD, $7F, $4A, $20
  DB $C5, $FD, $7F, $52, $40
  DB $C5, $FD, $7F, $5A, $60
  DB $C5, $FD, $7F, $A2, $80, $00, $00, $00
  DB $C5, $FD, $7F, $AA, $A0, $00, $00, $00
  DB $C5, $FD, $7F, $B2, $C0, $00, $00, $00
  DB $C5, $FD, $7F, $BA, $E0, $00, $00, $00
  DB $C5, $7D, $7F, $82, $00, $01, $00, $00
  DB $C5, $7D, $7F, $8A, $20, $01, $00, $00
  DB $C5, $7D, $7F, $92, $40, $01, $00, $00
  DB $C5, $7D, $7F, $9A, $60, $01, $00, $00
  DB $C5, $7D, $7F, $A2, $80, $01, $00, $00
  DB $C5, $7D, $7F, $AA, $A0, $01, $00, $00
  DB $C5, $7D, $7F, $B2, $C0, $01, $00, $00
  DB $C5, $7D, $7F, $BA, $E0, $01, $00, $00
  {$ENDIF}

  ADD    EAX, 512
  ADD    EDX, 512
  SUB    ECX, 512
  JNZ    @LOOP
end;

{ 每一次复制 32 个字节 <256 位> <长度必须是 32 的倍数> }
procedure Move_AVX2_32A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVNTDQA  YMM0, [EAX]
  VMOVNTDQ   [EDX], YMM0
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C4, $E2, $7D, $2A, $00
  DB $67, $C5, $FD, $E7, $02
  {$ELSE}
  DB $C4, $E2, $7D, $2A, $00
  DB $C5, $FD, $E7, $02
  {$ENDIF}

  ADD    EAX, 32
  ADD    EDX, 32
  SUB    ECX, 32
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 64 个字节 <512 位> <长度必须是 64 的倍数> }
procedure Move_AVX2_64A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVNTDQA  YMM0, [EAX+00]
  VMOVNTDQA  YMM1, [EAX+32]
  VMOVNTDQ   [EDX+00], YMM0
  VMOVNTDQ   [EDX+32], YMM1
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C4, $E2, $7D, $2A, $00
  DB $67, $C4, $E2, $7D, $2A, $48, $20
  DB $67, $C5, $FD, $E7, $02
  DB $67, $C5, $FD, $E7, $4A, $20
  {$ELSE}
  DB $C4, $E2, $7D, $2A, $00
  DB $C4, $E2, $7D, $2A, $48, $20
  DB $C5, $FD, $E7, $02
  DB $C5, $FD, $E7, $4A, $20
  {$ENDIF}

  ADD    EAX, 64
  ADD    EDX, 64
  SUB    ECX, 64
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 128 个字节 <512 位> <长度必须是 128 的倍数> }
procedure Move_AVX2_128A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVNTDQA  YMM0, [EAX+00]
  VMOVNTDQA  YMM1, [EAX+32]
  VMOVNTDQA  YMM2, [EAX+64]
  VMOVNTDQA  YMM3, [EAX+96]
  VMOVNTDQ   [EDX+00], YMM0
  VMOVNTDQ   [EDX+32], YMM1
  VMOVNTDQ   [EDX+64], YMM2
  VMOVNTDQ   [EDX+96], YMM3
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C4, $E2, $7D, $2A, $00
  DB $67, $C4, $E2, $7D, $2A, $48, $20
  DB $67, $C4, $E2, $7D, $2A, $50, $40
  DB $67, $C4, $E2, $7D, $2A, $58, $60
  DB $67, $C5, $FD, $E7, $02
  DB $67, $C5, $FD, $E7, $4A, $20
  DB $67, $C5, $FD, $E7, $52, $40
  DB $67, $C5, $FD, $E7, $5A, $60
  {$ELSE}
  DB $C4, $E2, $7D, $2A, $00
  DB $C4, $E2, $7D, $2A, $48, $20
  DB $C4, $E2, $7D, $2A, $50, $40
  DB $C4, $E2, $7D, $2A, $58, $60
  DB $C5, $FD, $E7, $02
  DB $C5, $FD, $E7, $4A, $20
  DB $C5, $FD, $E7, $52, $40
  DB $C5, $FD, $E7, $5A, $60
  {$ENDIF}

  ADD    EAX, 128
  ADD    EDX, 128
  SUB    ECX, 128
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 256 个字节 <1024 位> <长度必须是 256 的倍数> }
procedure Move_AVX2_256A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  VMOVNTDQA  YMM0, [EAX+00]
  VMOVNTDQA  YMM1, [EAX+32]
  VMOVNTDQA  YMM2, [EAX+64]
  VMOVNTDQA  YMM3, [EAX+96]
  VMOVNTDQA  YMM4, [EAX+128]
  VMOVNTDQA  YMM5, [EAX+160]
  VMOVNTDQA  YMM6, [EAX+192]
  VMOVNTDQA  YMM7, [EAX+224]
  VMOVNTDQ   [EDX+00],  YMM0
  VMOVNTDQ   [EDX+32],  YMM1
  VMOVNTDQ   [EDX+64],  YMM2
  VMOVNTDQ   [EDX+96],  YMM3
  VMOVNTDQ   [EDX+128], YMM4
  VMOVNTDQ   [EDX+160], YMM5
  VMOVNTDQ   [EDX+192], YMM6
  VMOVNTDQ   [EDX+224], YMM7
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C4, $E2, $7D, $2A, $00
  DB $67, $C4, $E2, $7D, $2A, $48, $20
  DB $67, $C4, $E2, $7D, $2A, $50, $40
  DB $67, $C4, $E2, $7D, $2A, $58, $60
  DB $67, $C4, $E2, $7D, $2A, $A0, $80, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $A8, $A0, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $B0, $C0, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $B8, $E0, $00, $00, $00
  DB $67, $C5, $FD, $E7, $02
  DB $67, $C5, $FD, $E7, $4A, $20
  DB $67, $C5, $FD, $E7, $52, $40
  DB $67, $C5, $FD, $E7, $5A, $60
  DB $67, $C5, $FD, $E7, $A2, $80, $00, $00, $00
  DB $67, $C5, $FD, $E7, $AA, $A0, $00, $00, $00
  DB $67, $C5, $FD, $E7, $B2, $C0, $00, $00, $00
  DB $67, $C5, $FD, $E7, $BA, $E0, $00, $00, $00
  {$ELSE}
  DB $C4, $E2, $7D, $2A, $00
  DB $C4, $E2, $7D, $2A, $48, $20
  DB $C4, $E2, $7D, $2A, $50, $40
  DB $C4, $E2, $7D, $2A, $58, $60
  DB $C4, $E2, $7D, $2A, $A0, $80, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $A8, $A0, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $B0, $C0, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $B8, $E0, $00, $00, $00
  DB $C5, $FD, $E7, $02
  DB $C5, $FD, $E7, $4A, $20
  DB $C5, $FD, $E7, $52, $40
  DB $C5, $FD, $E7, $5A, $60
  DB $C5, $FD, $E7, $A2, $80, $00, $00, $00
  DB $C5, $FD, $E7, $AA, $A0, $00, $00, $00
  DB $C5, $FD, $E7, $B2, $C0, $00, $00, $00
  DB $C5, $FD, $E7, $BA, $E0, $00, $00, $00
  {$ENDIF}

  ADD    EAX, 256
  ADD    EDX, 256
  SUB    ECX, 256
  JNZ    @LOOP
  SFENCE
end;

{ 每一次复制 512 个字节 <1024 位> <长度必须是 512 的倍数> }
procedure Move_AVX2_512A(const src: Pointer; dst: Pointer; const len: NativeInt); assembler; register;
asm
  {$IFDEF WIN64}
  XCHG  RAX, RCX
  {$ENDIF}
@LOOP:
  {$IFDEF FPC}
  {$IFDEF WIN64}
  VMOVNTDQA  YMM0,  [EAX+000]
  VMOVNTDQA  YMM1,  [EAX+032]
  VMOVNTDQA  YMM2,  [EAX+064]
  VMOVNTDQA  YMM3,  [EAX+096]
  VMOVNTDQA  YMM4,  [EAX+128]
  VMOVNTDQA  YMM5,  [EAX+160]
  VMOVNTDQA  YMM6,  [EAX+192]
  VMOVNTDQA  YMM7,  [EAX+224]
  VMOVNTDQA  YMM8,  [EAX+256]
  VMOVNTDQA  YMM9,  [EAX+288]
  VMOVNTDQA  YMM10, [EAX+320]
  VMOVNTDQA  YMM11, [EAX+352]
  VMOVNTDQA  YMM12, [EAX+384]
  VMOVNTDQA  YMM13, [EAX+416]
  VMOVNTDQA  YMM14, [EAX+448]
  VMOVNTDQA  YMM15, [EAX+480]
  VMOVNTDQ   [EDX+000],  YMM0
  VMOVNTDQ   [EDX+032],  YMM1
  VMOVNTDQ   [EDX+064],  YMM2
  VMOVNTDQ   [EDX+096],  YMM3
  VMOVNTDQ   [EDX+128],  YMM4
  VMOVNTDQ   [EDX+160],  YMM5
  VMOVNTDQ   [EDX+192],  YMM6
  VMOVNTDQ   [EDX+224],  YMM7
  VMOVNTDQ   [EDX+256],  YMM8
  VMOVNTDQ   [EDX+288],  YMM9
  VMOVNTDQ   [EDX+320],  YMM10
  VMOVNTDQ   [EDX+352],  YMM11
  VMOVNTDQ   [EDX+384],  YMM12
  VMOVNTDQ   [EDX+416],  YMM13
  VMOVNTDQ   [EDX+448],  YMM14
  VMOVNTDQ   [EDX+480],  YMM15
  {$ELSE}
  VMOVNTDQA  YMM0,  [EAX+000]
  VMOVNTDQA  YMM1,  [EAX+032]
  VMOVNTDQA  YMM2,  [EAX+064]
  VMOVNTDQA  YMM3,  [EAX+096]
  VMOVNTDQA  YMM4,  [EAX+128]
  VMOVNTDQA  YMM5,  [EAX+160]
  VMOVNTDQA  YMM6,  [EAX+192]
  VMOVNTDQA  YMM7,  [EAX+224]
  VMOVNTDQ   [EDX+000],  YMM0
  VMOVNTDQ   [EDX+032],  YMM1
  VMOVNTDQ   [EDX+064],  YMM2
  VMOVNTDQ   [EDX+096],  YMM3
  VMOVNTDQ   [EDX+128],  YMM4
  VMOVNTDQ   [EDX+160],  YMM5
  VMOVNTDQ   [EDX+192],  YMM6
  VMOVNTDQ   [EDX+224],  YMM7
  VMOVNTDQA  YMM0,  [EAX+256]
  VMOVNTDQA  YMM1,  [EAX+288]
  VMOVNTDQA  YMM2,  [EAX+320]
  VMOVNTDQA  YMM3,  [EAX+352]
  VMOVNTDQA  YMM4,  [EAX+384]
  VMOVNTDQA  YMM5,  [EAX+416]
  VMOVNTDQA  YMM6,  [EAX+448]
  VMOVNTDQA  YMM7,  [EAX+480]
  VMOVNTDQ   [EDX+256],  YMM0
  VMOVNTDQ   [EDX+288],  YMM1
  VMOVNTDQ   [EDX+320],  YMM2
  VMOVNTDQ   [EDX+352],  YMM3
  VMOVNTDQ   [EDX+384],  YMM4
  VMOVNTDQ   [EDX+416],  YMM5
  VMOVNTDQ   [EDX+448],  YMM6
  VMOVNTDQ   [EDX+480],  YMM7
  {$ENDIF}
  {$ENDIF}

  {$IFDEF WIN64}
  DB $67, $C4, $E2, $7D, $2A, $00
  DB $67, $C4, $E2, $7D, $2A, $48, $20
  DB $67, $C4, $E2, $7D, $2A, $50, $40
  DB $67, $C4, $E2, $7D, $2A, $58, $60
  DB $67, $C4, $E2, $7D, $2A, $A0, $80, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $A8, $A0, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $B0, $C0, $00, $00, $00
  DB $67, $C4, $E2, $7D, $2A, $B8, $E0, $00, $00, $00
  DB $67, $C4, $62, $7D, $2A, $80, $00, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $88, $20, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $90, $40, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $98, $60, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $A0, $80, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $A8, $A0, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $B0, $C0, $01, $00, $00
  DB $67, $C4, $62, $7D, $2A, $B8, $E0, $01, $00, $00
  DB $67, $C5, $FD, $E7, $02
  DB $67, $C5, $FD, $E7, $4A, $20
  DB $67, $C5, $FD, $E7, $52, $40
  DB $67, $C5, $FD, $E7, $5A, $60
  DB $67, $C5, $FD, $E7, $A2, $80, $00, $00, $00
  DB $67, $C5, $FD, $E7, $AA, $A0, $00, $00, $00
  DB $67, $C5, $FD, $E7, $B2, $C0, $00, $00, $00
  DB $67, $C5, $FD, $E7, $BA, $E0, $00, $00, $00
  DB $67, $C5, $7D, $E7, $82, $00, $01, $00, $00
  DB $67, $C5, $7D, $E7, $8A, $20, $01, $00, $00
  DB $67, $C5, $7D, $E7, $92, $40, $01, $00, $00
  DB $67, $C5, $7D, $E7, $9A, $60, $01, $00, $00
  DB $67, $C5, $7D, $E7, $A2, $80, $01, $00, $00
  DB $67, $C5, $7D, $E7, $AA, $A0, $01, $00, $00
  DB $67, $C5, $7D, $E7, $B2, $C0, $01, $00, $00
  DB $67, $C5, $7D, $E7, $BA, $E0, $01, $00, $00
  {$ELSE}
  DB $C4, $E2, $7D, $2A, $00
  DB $C4, $E2, $7D, $2A, $48, $20
  DB $C4, $E2, $7D, $2A, $50, $40
  DB $C4, $E2, $7D, $2A, $58, $60
  DB $C4, $E2, $7D, $2A, $A0, $80, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $A8, $A0, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $B0, $C0, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $B8, $E0, $00, $00, $00
  DB $C5, $FD, $E7, $02
  DB $C5, $FD, $E7, $4A, $20
  DB $C5, $FD, $E7, $52, $40
  DB $C5, $FD, $E7, $5A, $60
  DB $C5, $FD, $E7, $A2, $80, $00, $00, $00
  DB $C5, $FD, $E7, $AA, $A0, $00, $00, $00
  DB $C5, $FD, $E7, $B2, $C0, $00, $00, $00
  DB $C5, $FD, $E7, $BA, $E0, $00, $00, $00
  DB $C4, $E2, $7D, $2A, $80, $00, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $88, $20, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $90, $40, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $98, $60, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $A0, $80, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $A8, $A0, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $B0, $C0, $01, $00, $00
  DB $C4, $E2, $7D, $2A, $B8, $E, $001, $00, $00
  DB $C5, $FD, $E7, $82, $00, $01, $00, $00
  DB $C5, $FD, $E7, $8A, $20, $01, $00, $00
  DB $C5, $FD, $E7, $92, $40, $01, $00, $00
  DB $C5, $FD, $E7, $9A, $60, $01, $00, $00
  DB $C5, $FD, $E7, $A2, $80, $01, $00, $00
  DB $C5, $FD, $E7, $AA, $A0, $01, $00, $00
  DB $C5, $FD, $E7, $B2, $C0, $01, $00, $00
  DB $C5, $FD, $E7, $BA, $E0, $01, $00, $00
  {$ENDIF}

  ADD    EAX, 512
  ADD    EDX, 512
  SUB    ECX, 512
  JNZ    @LOOP
  SFENCE
end;

水平有限，错误难免。如有错误，还望高手不吝指正。
详细代码：https://github.com/dbyoung720/ImageGray/blob/master/src/db.Memory.Move.pas
qq交流群：101611228




 


 

dbyoung
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
delphi 释放程序内存_优化您的Delphi程序的内存使用率
cumao2792的博客
09-12 1931
delphi 释放程序内存 When writing long-running applications - the kind of programs that will spend most of the day minimized to the taskbar or system tray, it can become important not to let the program 'run...
Delphi 的内存操作函数(5): 复制内存
weixin_34365635的博客
11-14 126
MoveMemory、CopyMemory 的功能类似, 都是复制内存, 都是调用 Move 过程; MoveMemory、CopyMemory 操作指针; Move 操作实体. 还要注意, 它们的参数位置不一样! 举例: {例1} var buf1,buf2: array[0..9] of AnsiChar; begin buf1 := '0123456789...
delphi 的内存复制处理
代码人生
04-25 2772
type  TRecord=record    a:DWord;    b:array [0..99] of Char;  end;procedure TForm1.btn1Click(Sender: TObject);var  buff:array [0..SizeOf(TRecord)-1] of Byte;  a :^TRecord;begin  a:=AllocMem(SizeOf(TRe
(转)DELPHI大内存清零快速算法(Delphi MMX优化算法应用之二)
weixin_34337265的博客
11-04 229
由于DELPHI里面动态数组的初始值并不是时时为0,对于一维数组每次使用前先SetLength后然一般做法都是使用FillChar来清零,但如果是超过几十M的数组如果FillChar来清零效率就很底,为此我专门写了一些清空数组或者内存的优化代码.   1.使用MMX指令优化的清零内存代码:procedure ZeroMemoryMMX(Destination: Pointer; aSize: ...
Delphi 代码优化
siow的程序人生
06-29 3317
 Delphi 代码优化 Come from: http://www.optimalcode.com 文章编目 [显示隐藏]  1. 字符串优化 1.1. 不重复初始化 1.2. 使用SetLength预分配长字符串（AnsiString） 1.3. 字符串与动态数组的线程安全(Thread Safety) 1.4. 避免使用短字符串 1.5. 避免使用copy函数 1.6. 总是使用长字符串，必
delphi教程图文版-新手学习资料.zip
最新发布
03-08
delphi教程图文版-新手学习资料.zipdelphi教程图文版-新手学习资料.zipdelphi教程图文版-新手学习资料.zipdelphi教程图文版-新手学习资料.zipdelphi教程图文版-新手学习资料.zipdelphi教程图文版-新手学习资料....
delphi-modbus-tcp-indy.7z
05-16
这个"delphi-modbus-tcp-indy.7z"压缩包包含的是用Delphi编写的Modbus TCP组件，它基于两个不同的Indy版本——Indy 9和Indy 10。 Indy（Internet Direct）是Delphi和C++Builder中的一套网络库，提供了一组跨平台的...
delphi-C语言到Delphi的转换器-语言转换.zip
02-28
标题中的“delphi-C语言到Delphi的转换器”指的是一个工具或程序，它能够帮助开发者将用C语言编写的代码转换成Delphi语言。在软件开发中，这样的转换可能出于多种原因，如项目迁移、利用Delphi的特定功能或者为了在...
Delphi中-TStringList-的详细用法.doc
04-12
Delphi中-TStringList-的详细用法.doc
FastMM490 ( Delphi\BCB 内存管理、优化工具包)
09-30
A fast replacement memory manager for Borland Delphi Win32 applications that scales well under multi-threaded usage, is not prone to memory fragmentation, and supports shared memory without the use of external .DLL files.
内存自动优化整理小工具，Delphi实例源代码.rar
07-10
内存自动优化整理小工具，Delphi实例源代码，自动整理内存的功能是根据用户自己的选择而开启，可以设定自动优化的百分比。同时程序还适时显示内存使用率、物理内存量、虚拟内存使用等情况。
Delphi中复制带有String的记录结构时不能使用Move之类的内存操作函数 .mht
06-10
Delphi中复制带有String的记录结构时不能使用Move之类的内存操作函数 .mht
delphi 清理程序内存
12-28
使用delphi开发的程序中，可用来清理程序内存，减少资源占用情况。
delphi编译指令
04-08
A.1 使用编译设置对话框 编译器的编译指令是用于指定编译器对项目编译过程的动作和行为。可以通过[Project]->[Options]->[Complier]选项页进行设置，绝大部分的编译环境都可以通过这一对话框进行调整，他包含了对代码、语法、调试信息等的设置。 1.代码设置(Code Generation) Optimization: 代码优化开关 Aligned record fields: 字对齐数据。这个编译指令能够在变量和类型化常量的字节对齐和字对齐之间进行切换，其作用是全局的。
初学 Delphi 嵌入汇编[25] - 在汇编中调用函数
weixin_34184158的博客
01-29 89
//准备一个在汇编中要调用的函数 function DelphiFun(x,y: Integer): Integer; begin Result := x + y; end; //汇编函数 function AsmFun: Integer; asm mov eax, 1 {eax 对应函数的第一个参数, 这里给第一个参数赋值为 1} mov ed...
内存共享【Delphi版】
weixin_34148340的博客
08-14 488
一.原理     通过使用“内存映射文件”，实现内存共享 二.主要操作     共享内存结构： PShareMem = ^TShareMem; TShareMem = Record id:string[10]; name:string[20]; age:Integer; end;     基本变量： shareMemName:string; /...
有关Delphi编译优化的问题
Raoxk的专栏
07-02 1761
Delphi编译器（在编译文件时）能自动去掉死代码（在打开编译优化功能时）．这个非常不错的功能，能够帮助程序员更有效的检查程序．但有时就时这个功能，也可能给程序带来不必要的小Bug．请看以下程序：function PosChar2(ch:Char;chArray:Array of Char):Integer;var  i:Integer;begin    i:=0;　　//这一句不会被编译  
初学 Delphi 嵌入汇编[11] - 用汇编重写一个 Delphi 函数
weixin_33724046的博客
09-26 126
为什么80%的码农都做不了架构师？>>> ...
Delphi(Delphi11) 编译（compiling）参数优化（optimization） 的N小时调试析
Ti-蜗牛的博客
11-09 894
不要为了少定义一个变量，少一行代码而花费几个小时找问题~~~~~~~~~~~~~~~~~~~~~~
《Delphi高手突破》- 面向对象编程与程序构架设计
"DELPHI高手突破PDF" 《DELPHI高手突破》是由申旻编著，清华大学出版社出版的一本深入探讨DELPHI编程技术的专著。这本书旨在帮助已具备一定DELPHI编程基础的读者提升技能，实现编程能力的“突破”。 书中首先介绍...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值