B计划之大整数的内存复制

liangbch

原帖由 无心人 于 2008-4-30 15:16 发表
复制存在一个问题

块小了用movdqa快， 大了用movntdq快

不知道如何判断

  大体规则为：
    当源内存块 + 目标内存块 < L2 cache size, 使用movdqa,这是写操作主要在 L2 cache 中进行，当然RAM 也会同步更新，但 L2 cache 几乎不会发生换入换出操作。
    当源内存块 + 目标内存块 > L2 cache size, 如果使用movdqa，L2 cache 经常发生换入换出操作，效率很低。这时使用写透方式，直接更新RAM 而不更新L2 cache 有较好的性能。

无心人

我也知道这么做

你如何获得L2 Cache大小？

gxqcn

用 CPUID 指令啊。。。
我的 HugeCalc.ini 中的信息都是这么来的。

无心人

我也知道用那个啊

不过，似乎CPUID里的L2信息不同的CPU其表达是不同的
我在别的帖子里求过例程
没有多少人回应

你有详细做法？

liangbch

幸运的是，我去年曾经写过获取CPU信息的代码，这里一并贡献出来，下面的代码仅列出获取CPU Cache size 的代码，通过getCacheSize 函数可得到Intel或者AMD Cpu L2 cache2的大小。

1. typedef struct _cpuReg
   
2. {
   
3.         DWORD eax;
   
4.         DWORD ebx;
   
5.         DWORD ecx;
   
6.         DWORD edx;
   
7. }CPU_REG;
   
8. 
   
9. 
   
10. typedef unsigned long DWORD;
    
11. typedef unsigned char BYTE;
    
12. 
    
13. typedef struct _cpuInfo
    
14. {
    
15.         DWORD version;
    
16.         DWORD featureID;
    
17.         DWORD extFeatureID;
    
18.         DWORD L1_inst_cache;
    
19.         DWORD L1_data_cache;
    
20.         DWORD L2_cache;
    
21.         DWORD brandIdx;
    
22. 
    
23.         char vendor[16];
    
24.         char brand[64];
    
25.         char name[64];
    
26. 
    
27.         char type;
    
28.         char family;
    
29.         char model;
    
30.         char stepping;
    
31.        
    
32.         char support_MMX;
    
33.         char support_SSE;
    
34.         char support_SSE2;
    
35.         char support_SSE3;
    
36.         char no[32];
    
37. }CPU_INFO;
    
38. 
    
39. void getIntelCPUCacheSize(CPU_INFO *p)
    
40. {       
    
41.         CPU_REG cpuReg;
    
42.         BYTE cacheDesTab[32];
    
43.         BYTE *pt;
    
44.         int i,idx;
    
45.         //---------------------
    
46.         idx=0;
    
47.         CPUID(2,&cpuReg);
    
48.         for (i=0;i<4;i++)
    
49.         {
    
50.                 switch(i)
    
51.                 {
    
52.                 case 0: pt=(BYTE *)(&(cpuReg.eax)); break;
    
53.                 case 1: pt=(BYTE *)(&(cpuReg.ebx)); break;
    
54.                 case 2: pt=(BYTE *)(&(cpuReg.ecx)); break;
    
55.                 case 3: pt=(BYTE *)(&(cpuReg.edx)); break;
    
56.                 }
    
57. 
    
58.                 if ( (pt[3] & 128) ==0)
    
59.                 {
    
60.                         if (pt[0] !=0)
    
61.                                 cacheDesTab[idx++]=pt[0];
    
62.                         if (pt[1] !=0)
    
63.                                 cacheDesTab[idx++]=pt[1];
    
64.                         if (pt[2] !=0)
    
65.                                 cacheDesTab[idx++]=pt[2];
    
66.                         if (pt[3] !=0)
    
67.                                 cacheDesTab[idx++]=pt[3];
    
68.                 }
    
69.        
    
70.         }
    
71.        
    
72.         for (i=0;i<idx;i++)
    
73.         {
    
74.                 BYTE flag;
    
75.                 flag= cacheDesTab[i];
    
76.                 switch (flag)
    
77.                 {
    
78.                 case 6:                p->L1_inst_cache=8;                break;
    
79.                 case 8:                p->L1_inst_cache=16;        break;
    
80.                 case 0x0a:  p->L1_data_cache=8;                break;
    
81.                 case 0x0c:  p->L1_data_cache=16;        break;
    
82.                 case 0x2c:  p->L1_data_cache=32;        break;
    
83.                 case 0x30:  p->L1_inst_cache=32;        break;
    
84.                 case 0x41:  p->L2_cache =128;        break;
    
85.                 case 0x42:  p->L2_cache =256;        break;
    
86.                 case 0x43:  p->L2_cache =512;        break;
    
87.                 case 0x44:  p->L2_cache =1024;        break;
    
88.                 case 0x45:  p->L2_cache =2048;        break;
    
89.                 case 0x66:  p->L1_data_cache=8;        break;
    
90.                 case 0x67:  p->L1_data_cache=16;        break;
    
91.                 case 0x68:  p->L1_data_cache=32;        break;
    
92.                
    
93.                 case 0x70:
    
94.                         if ( p->L1_inst_cache==0 )   //have not been set
    
95.                                 p->L1_inst_cache=12;       
    
96.                         break;
    
97. 
    
98.                 case 0x71:
    
99.                         if ( p->L1_inst_cache==0 ) //have not been set
    
100.                                 p->L1_inst_cache=16;       
     
101.                         break;
     
102. 
     
103.                 case 0x72:
     
104.                         if ( p->L1_inst_cache==0 ) //have not been set
     
105.                                 p->L1_inst_cache=32;       
     
106.                         break;
     
107. 
     
108.                 case 0x78:  p->L2_cache=1024;        break;
     
109.                 case 0x79:  p->L2_cache=128;        break;
     
110.                 case 0x7A:  p->L2_cache=256;        break;
     
111.                 case 0x7B:  p->L2_cache=512;        break;
     
112.                 case 0x7C:  p->L2_cache=1024;        break;
     
113.                 case 0x7D:  p->L2_cache=2048;        break;
     
114.                 case 0x82:  p->L2_cache=256;        break;
     
115.                 case 0x83:  p->L2_cache=512;        break;
     
116.                 case 0x84:  p->L2_cache=1024;        break;
     
117.                 case 0x85:  p->L2_cache=2048;        break;
     
118.                 case 0x86:  p->L2_cache=512;        break;
     
119.                 case 0x87:  p->L2_cache=1024;        break;
     
120.                 }
     
121.         }
     
122. }
     
123. 
     
124. 
     
125. void getAMDCPUCacheSize(CPU_INFO *p)
     
126. {
     
127.         DWORD maxCPUFunction;
     
128.         CPU_REG cpuReg;
     
129.         //----------------------------
     
130.         CPUID(0x80000000,&cpuReg);
     
131.         maxCPUFunction=cpuReg.eax;
     
132.        
     
133.         if (maxCPUFunction>=0x80000005)
     
134.         {
     
135.                 CPUID(0x80000005,&cpuReg);
     
136.                 /*
     
137.                 ECX 31:24 L1DcSize. L1 data cache size in KB.
     
138.                 EDX 31:24 L1IcSize. L1 instruction cache size KB.
     
139.                 */
     
140.                 p->L1_data_cache= (cpuReg.ecx >> 24);
     
141.                 p->L1_inst_cache= (cpuReg.edx >> 24);
     
142.         }
     
143.        
     
144.         if (maxCPUFunction>=0x80000006)
     
145.         {
     
146.                 CPUID(0x80000006,&cpuReg);
     
147.                 //ECX 31:16 L2Size. L2 cache size in KB.
     
148.                 p->L2_cache = (cpuReg.ecx >> 16);
     
149.         }
     
150. }
     
151. 
     
152. 
     
153. void getCacheSize(CPU_INFO *p)
     
154. {
     
155.         CPU_REG cpuReg;
     
156.         BYTE cacheDesTab[32];
     
157.         BYTE *pt;
     
158.         int i,idx;
     
159.        
     
160.         memset(cacheDesTab,0,sizeof(cacheDesTab));
     
161.         p->L1_data_cache=0;
     
162.         p->L1_inst_cache=0;
     
163.         p->L2_cache=0;
     
164. 
     
165.         if (strcmp(p->vendor,"GenuineIntel")==0)
     
166.         {
     
167.                 getIntelCPUCacheSize(p);
     
168.         }
     
169.         else if ( strcmp(p->vendor,"AuthenticAMD")==0 )
     
170.         {
     
171.                 getAMDCPUCacheSize(p);
     
172.         }
     
173.         else //for other CPU
     
174.         {
     
175. 
     
176.         }
     
177. }

复制代码

liangbch

补上 楼上漏掉的一个函数

1. void CPUID(int no,CPU_REG *result)
   
2. {
   
3.         _asm
   
4.         {
   
5.                 push ebx
   
6.                 push esi
   
7.                
   
8.                 mov eax,no
   
9.                 mov esi,result
   
10.                
    
11.                 _emit 0x0f                                        ; cpuid
    
12.                 _emit 0xa2
    
13.                
    
14.                 mov dword ptr [esi+0],eax
    
15.                 mov dword ptr [esi+4],ebx
    
16.                 mov dword ptr [esi+8],ecx
    
17.                 mov dword ptr [esi+12],edx
    
18.                
    
19.                 pop esi
    
20.                 pop ebx
    
21.         }
    
22. }

复制代码

无心人

首先谢谢你共享你的代码

其次诅咒万恶的Intel

最后你的函数还需要更新
缺少Core 2的信息

无心人

我清零的测试表明
在超越L2 Cache的边界的时候
两种不同做法的差别是很大的
超过50%的差异

另外，测试表明，并不是正好在L2 cache尺寸的边界发生变化
复制也许稍微不同，但是估计也会发生这种情况

即尺寸边界大于L2 Cache大小，但也绝不是L2 Cache +  L1 Cache
这是我目前尚未得到答案的问题之一

你能得到解决的方法么？

附上清零的测试程序
ZeroMemory.rar (1.24 KB, 下载次数: 2)

2008-4-30 17:20 上传

点击文件名下载附件

liangbch

我用的关于 Intel CPU spec 的手册是2007.5发布的，但依然没有关于Core 2 L2 cache 的spec，哪位有更新的spec，告诉我一声。

liangbch

基于下面的两个原因，我不考虑使用 movntdq 指令，也不去花时间去尝试他。
   1.使用 movntdq  会造成兼容性问题。
   2.我主要想设计一个速度一流的大数运算库，在做大数运算时，特别大的内存块复制并不常用，也非大数运算的瓶颈。

我的观点是有所为，有所不为，尽量集中精力做重要的工作，而不是广种薄收。