我编写了两个程序来检查clflush是否从缓存中清除了我的数据。在我编写的两个程序中，只有一个给出了正确的结果(按照我的期望，在clflush之后，访问时间必须比刷新之前要长)。
这是我获得预期结果的Program1。
#include <stdio.h>
#include <stdint.h>
inline void clflush(volatile void *p)
{
asm volatile ("clflush (%0)" :: "r"(p));
}
inline uint64_t rdtsc()
{
unsigned long a, d;
asm volatile ("cpuid; rdtsc" : "=a" (a), "=d" (d) : : "ebx", "ecx");
return a | ((uint64_t)d << 32);
}
static int i=10; // static variable
inline void test()
{
uint64_t start, end;
int j;
start = rdtsc();
j = i;
end = rdtsc();
printf("took %lu ticks\n", end - start);
}
int main(int ac, char **av)
{
test();
test();
printf("flush: ");
clflush((void *)&i);
test();
test();
return 0;
}
这是我的输出(按预期)
took 314 ticks
took 282 ticks
flush: took 442 ticks
took 272 ticks
这是另一个程序，其中我没有得到预期的结果。
#include <stdio.h>
#include <stdint.h>
inline void clflush(volatile void *p)
{
asm volatile ("clflush (%0)" :: "r"(p));
}
inline uint64_t rdtsc()
{
unsigned long a, d;
asm volatile ("cpuid; rdtsc" : "=a" (a), "=d" (d) : : "ebx", "ecx");
return a | ((uint64_t)d << 32);
}
static const int i=10; // I make this as constant
inline void test()
{
uint64_t start, end;
int j;
start = rdtsc();
j = i;
end = rdtsc();
printf("took %lu ticks\n", end - start);
}
int main(int ac, char **av)
{
test();
test();
printf("flush: ");
clflush((void *)&i);
test();
test();
return 0;
}
这是我的输出(按预期)
took 314 ticks
took 282 ticks
flush: took 282 ticks // same as previous
took 272 ticks
--------
took 314 ticks
took 282 ticks
flush: took 272 ticks // lower than previous
took 272 ticks
如果我将static int设为10，变成静态const int i = 10;那么结果就不是我的预期。 clflush后，我得到的值(value)较低/访问时间相等。
谁能解释为什么会这样？如何按我的期望(在clflush作为program1后需要更长的访问时间)实现它(在C或C++中)？
我在Fedora19 linux下使用GCC。任何帮助将不胜感激。
最佳答案
我很确定这里的问题是，与“之间的指令”相比，CPUID + RDTSC太长了。
我得到非常不同的结果，大概取决于代码最终运行在哪个实际CPU上的“运气”，其他CPU在做什么，等等。
这是第二个程序连续运行的三个程序:
took 92 ticks
took 75 ticks
flush: took 75 ticks
took 474 ticks
took 221 ticks
took 243 ticks
flush: took 221 ticks
took 242 ticks
took 221 ticks
took 221 ticks
flush: took 221 ticks
took 230 ticks
但是，我认为我们不能由此得出“clflush无效”的结论。只是处理器中有足够的时钟周期和足够多的无序执行来克服缓存刷新和重新加载数据的问题。
如果您有大量数据(例如几千字节)，则可能会获得更明显的效果。我会做一些实验，但是现在我需要一些食物...
#include <stdio.h>
#include <stdint.h>
inline void clflush(volatile void *p)
{
__asm volatile ("clflush (%0)" :: "r"(p));
}
inline uint64_t rdtsc()
{
unsigned long a, d;
__asm volatile ("rdtsc" : "=a" (a), "=d" (d) : : "ebx", "ecx");
return a | ((uint64_t)d << 32);
}
static int v[1024];
uint64_t t[5];
int r[5];
int ti = 0;
static inline void test()
{
uint64_t start, end;
int j;
start = rdtsc();
for(int i = 0; i < 1024; i++)
{
j += v[i];
}
end = rdtsc();
r[ti] = j;
t[ti++] = end - start;
}
int main(int ac, char **av)
{
for(int i = 0; i < 1024; i++)
{
v[i] = i;
}
test();
test();
t[ti++] = 0;
for(int i = 0; i < 1024; i+=4)
{
clflush((void *)&v[i]);
}
test();
test();
for(int i = 0; i < ti; i++)
{
if (t[i] == 0)
{
printf("flush\n");
}
else
{
printf("Test %lu [res=%d]\n", t[i], r[i]);
}
}
printf("\n");
return 0;
}
我将printf移出了测试路径，以减少在那里花费的时间，并使冲洗区域更大。这样可以延长运行时间，这无疑有助于测量。
Test 2538 [res=523776]
Test 2593 [res=523776]
flush
Test 4845 [res=523776]
Test 2592 [res=523776]
Test 2550 [res=523776]
Test 2771 [res=523776]
flush
Test 4782 [res=523776]
Test 2513 [res=523776]
Test 2550 [res=523776]
Test 2708 [res=523776]
flush
Test 4356 [res=523776]
Test 2593 [res=523776]
如您所见，刷新后，数据的获取时间是第一次访问的两倍。
编辑:
像这样使用const
static const int v[1024] =
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
/* snip 62 lines equal to this */
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
};
给出以下结果:
Test 14139 [res=8704]
Test 2639 [res=8704]
flush
Test 5287 [res=8704]
Test 2597 [res=8704]
Test 12983 [res=8704]
Test 2652 [res=8704]
flush
Test 4859 [res=8704]
Test 2550 [res=8704]
Test 12911 [res=8704]
Test 2581 [res=8704]
flush
Test 4705 [res=8704]
Test 2649 [res=8704]
如您所见，第三次访问显然比第二次和第四次慢。第一次访问较慢，因为第一次访问时缓存中根本没有任何内容(包括页面表等)。