g****g
发帖数: 310 | 1 绝对没必要，也不应该写这类代码。根本没有任何速度上的提升。(如果有，那么是在
你做梦的时候)
unsigned long avg1=0, avg2=0;
for (int n=0;n<1000000; n++)
{
int j = 0, i=0;
a = rdtsc();
i+= !(!(j));
b=rdtsc()-a;
avg1+=b;
j=0; i=1;
a = rdtsc();
if( j!=0 ) i++;
b=rdtsc()-a;
avg2+=b;
j++;i++;
}
std::cout << "Take:" << avg1/1000000 << std::endl;
std::cout << "Take:" << avg2/1000000 << std::endl;
两者的结果基本相同。 |
|
g****g
发帖数: 310 | 2 一样的结果，整天讨论哪个快，却自己不去测试一下有意义么？
unsigned long avg1=0, avg2=0;
srand( (unsigned)time( NULL ) );
int j = 0, i=0;
for (int n=0;n<1000000; n++)
{
j = (rand() > RAND_MAX/2) ? 0 : 1;
a = rdtsc();
i+= !(!(j));
b=rdtsc()-a;
avg1+=b;
j=0; i=1;
a = rdtsc();
if( j!=0 ) i++;
b=rdtsc()-a;
avg2+=b;
}
std::cout << "Take:" << avg1/1000000 << std::endl;
std::cout << "Take:" << avg2/1000000 << std: |
|
k**********g
发帖数: 989 | 3
Disclaimer: I don't have good knowledge of Linux. I mostly work with Windows.
Usually, it is based on interpolating some hardware-based time with the CPU
built-in RDTSC instruction.
The hardware time is stored in some kernel memory. It is updated by the
hardware (through memory-mapped hardware I/O, or through DMA) periodically.
It may have very poor resolution (lower than 1000 Hz, for example.)
There might be some other hardware timing sources with higher frequency.
However, when you call the s... 阅读全帖 |
|
x**l
发帖数: 64 | 4
FT，还是错的。请接着改。
---我改为两个lfence夹一个rdtsc,如果你还觉得不正确,麻烦你明示你认为正确的办法.
+++++++++++++
请问你是在 Intel 工作吗？你能用 Intel 内部结构去
推断 CPU 的行为而忽视 Intel 手册。
如果你对 1000 cycle 的误差感兴趣，
为什么你不按照 Intel 建议的方式使用 rdtsc 和 rdtscp?
----我始终不认为这1000个cycle是由于rdtscp/rdtsc造成的,道理很简单,最终计算的
是两次clock值的difference,而不是绝对值,在一个working()和gap()交替执行的循环
中,不管out-of-order execution怎么跳,rdtsc测测了误差都不会造成一种是working()
的时间是
1100左右, 1100左右, 1100左右,1100左右,1100左右,...
另一种是
2500左右, 2500左右, 2500左右, 2500左右, 2500左右, ....
++++++++++++++++++++++++++++++++++++
你前面根本没有给... 阅读全帖 |
|
S*A
发帖数: 7142 | 5 我就简短点说吧，
你的 rdtsc 第一个版本先是有后面的 cpuid 冲掉了前面的 rdtsc 的
EAX EDX 寄存器，
修改改后的第二个版本应该先做 CPUID 然后做 RDTSC。看
Intel 手册。
你的 rdtscp 的汇编版本放开 out of order 不说，rdtscp 会
clobber ECX 寄存器，在里面存 CPU ID。你的汇编没有告诉
gcc 你破坏了 ECX 寄存器。虽然你用了 volatile, 那个只是
告诉 gcc 你有其他的 memory side effect （其实你没有）。
你仍然需要告诉 gcc clobber ECX。
然后正确的读 RDTSC 和 RDTSCP 的嵌入汇编代码在 24 楼
的 Intel pdf 里面都有，我就不重复了。
我没有用虚拟机。
你那个 1000 cycle 的差别不可能是中间被 schedule 其他的
thread。 单单 schedule 一次 task 就要 1000 cycle 这个数
量极。你要换出去换回来是不可能的。而且也不能解释这个
刚刚好每个 work（） 都被抢先 schedule ... 阅读全帖 |
|
J*******i
发帖数: 2162 | 6 要实现高精度时钟,可以读取CPU的tick counter，
每个tick就是 1秒/该CPU的频率，相当精准，附上代码
#ifndef __RDTSC_H_DEFINED__
#define __RDTSC_H_DEFINED__
#if defined(__i386__)
static __inline__ unsigned long long rdtsc(void)
{
unsigned long long int x;
__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
return x;
}
#elif defined(__x86_64__)
static __inline__ unsigned long long rdtsc(void)
{
unsigned hi, lo;
__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
return ( (unsigned long long)lo)|( ((unsigned long long)h |
|
x**l
发帖数: 64 | 7
所以我很迷惑，你似乎知道很多内部细节，但是你又忽律
很多重要的技术细节。你不按照 Intel 建议的方式来测量，
然后抱怨有意想不到的结果。
你现在还是没有论据支持你的1000 cycle 的说法。我对 Intel
CPU 还算比较了解也不敢按照你那样乱推测。我感觉你的
测量就没有可靠性。
----关于测量问题我刚给你回了,请看一下,谢谢
+++++++++++
就算我退一步，按照你的思路，50个pipeline，先假设
Intel CPU 里面就是这样工作的。你的论据也不成立。
rdtsc 单单一个 instruction 就有 250-300 cycle。
你只要pipelien 里面有 4 个 rdtsc 那样的 instruction,
你的误差就有 1000 cycle 了。 50 个 pipeline 里面
出现 4 个 rdtscp 还是有可能的吧，特别是对空循环
的例子。
----不知道你的rdtsc需要250~300cycle是从哪里来的?有reference没有?还是自己测的?
如果我们定义x86指令在pipeline中要占多少级为指令所花的时间,可以重复调用(不... 阅读全帖 |
|
x**l
发帖数: 64 | 8 谢谢回复
测量方式是存在误差，绝对不会产生大于1000个clocks级别的误差，xeon上
instruction pipeline不会超过50级，instruction虽然execution out-of-order, 但
进pipeline(IF)和最后的WB肯定是按序的，所以不会超过50 clocks的误差
当然，为了让结果更准确，可以把rdtsc部分改成这样，这样你应该可以compile了。
asm volatile(
"cpuid;"
"rdtsc;"
"cpuid;"
: "=a" (a), "=d" (d));
即使把代码改成这样，最终结果应该不会有太大变化
而且即使考虑中断或者ISR中的serialize instruction.在两种运行情况下对working()
的影响应该是近似的，而不应该产生1100 vs 2500 clocks的差别。 |
|
S*A
发帖数: 7142 | 9 所以我很迷惑，你似乎知道很多内部细节，但是你又忽律
很多重要的技术细节。你不按照 Intel 建议的方式来测量，
然后抱怨有意想不到的结果。
你现在还是没有论据支持你的1000 cycle 的说法。我对 Intel
CPU 还算比较了解也不敢按照你那样乱推测。我感觉你的
测量就没有可靠性。
就算我退一步，按照你的思路，50个pipeline，先假设
Intel CPU 里面就是这样工作的。你的论据也不成立。
rdtsc 单单一个 instruction 就有 250-300 cycle。
你只要pipelien 里面有 4 个 rdtsc 那样的 instruction,
你的误差就有 1000 cycle 了。 50 个 pipeline 里面
出现 4 个 rdtscp 还是有可能的吧，特别是对空循环
的例子。
你不按照 Intel 建议的方式就没有什么信服力。
而且我的反例也有了。
50。 |
|
x**l
发帖数: 64 | 10 sample code我放在这个link
https://onedrive.live.com/?cid=96AAD7C8AEF82405&id=96AAD7C8AEF82405!108
用这个命令可以在linux上用gcc 4.4或者更高版本build
g++ -O3 -std=c++0x -march=native -ftemplate-depth-1025 main_inline.cpp -o a_
inline_opt.out
参考启动命令分别是这样的
短时延
sudo numactl --physcpubind=3 --membind=0 ./a_inlin_opt.out 1 0
长时延
sudo numactl --physcpubind=3 --membind=0 ./a_inlin_opt.out 1 2999999999
启动后还需要用 "sudo -f -p [priority] 改变调度策略,然后按任意键继续.
谢谢大家了.
编辑:
SSA指出clock测量方法不准确,虽然最后结果还是类似,但为排除意外,我还是将
onedriver上的sample co... 阅读全帖 |
|
x**l
发帖数: 64 | 11 如果你运行了我的代码就知道,schedule会被chrt改为fifo 的 10, 并make sure 这个
core上没有高于这个的thread了.
IRQ handler 通过修改 /proc/irq/* 可以mask掉, numactl决定了这个process没法再
几个core上跳来跳去.
rdtsc/rdtscp是可以在priviledge level 3运行的.
请问在kernel mode里怎么锁住当前cpu,通过numactl/cpuset? |
|
|
i*****s
发帖数: 438 | 13
Then what is the most accurate method under Linux?
With the rdtsc instruction, we can get cycles, but
it's not working with CPU stepping.
How is gettimeofday() implemented? |
|
g****g
发帖数: 310 | 14 今天在我的机器上试验了一把，用rdtsc读取了virtual和non-virutal的call所需要的
时间，大约non-virtual快了大约200个CPU cycles。
因为CPU是3GHz的，分析了一下，把virtual变成non-virtual call的性能差异：
如果一个虚函数每秒调用150,000次的话，那么全部改成non-virtual能提升1%的性能。
几乎可以忽略。 |
|
g****g
发帖数: 310 | 15 Hey, are you using a computer of year 1995???
It's quite outdated. You should write code and test yourself. Easy job:
class Base
{
public:
virtual void say()
{
std::cout<<"say";
}
Base()
{
std::cout<<"Base";
}
~Base()
{
std::cout<<"~Base";
}
};
class Base2
{
public:
void say()
{
b=rdtsc()-a;
std::cout << "Take:" << b << std::endl;
}
Base2()
{
std::cout<<"Base2";
}
~Base |
|
x**l
发帖数: 64 | 16 谢谢你指出错误,匆忙之中修改的,没有测试.
如果你的CPU不支持 rdtscp，请使用这个function
typedef unsigned long long ticks;
static __inline__ ticks getticks(void)
{
unsigned a, d;
asm volatile(
"rdtsc;"
: "=a" (a), "=d" (d)
:
: "memory");
asm volatile("cpuid"
:
:
: "%eax", "%ebx", "%ecx", "%edx");
return ((ticks)a) | (((ticks)d) << 32);
}
你没有用numactl去调用，所以即使修改了代码，结果也不准确。
这是我的sample 输出
$ sudo numactl --physcpubind=3 --membind=0 ./a_i... 阅读全帖 |
|
S*A
发帖数: 7142 | 17 FT，还是错的。请接着改。
请问你是在 Intel 工作吗？你能用 Intel 内部结构去
推断 CPU 的行为而忽视 Intel 手册。
如果你对 1000 cycle 的误差感兴趣，
为什么你不按照 Intel 建议的方式使用 rdtsc 和 rdtscp?
你前面根本没有给出如何用 numctl 所以没有人能重复你的实验。
再说了，你即使用了 process scheduling, 你还是不能避免
non maskable interrupt。所以用了也是白用，你在 user space
是不能保证独占 CPU 的。
用你自己的话说，即使有少量 Interrupt/scheduling, 如何
解释我的两个 run 分布那么均匀？特别是没有循环的那个
Interrupt/scheduling 应该完全没有 Hit 到。那有循环那个
结果一样，应该也是没有 hit 到。不然你如何解释我的实验
结果，即使不改 scheduler ？ |
|
a**a
发帖数: 416 | 18 我在PentiumII上写一了一段C++程序，探索基本的vector运算在上面运行的效率。
程序做两种运算，一种是两个矢量逐个相乘，一种是两个矢量做内积。矢量的
长度在400-1000之间。时间量测是用rdtsc指令计算运行的时钟周期数。
结果出现了比较有意思的现象。
逐个相乘有着非常稳定的平均周期数，大概是8，几乎次次如此。求内积则不然。
不仅平均周期数在浮动漂移，而且有时候会蹦到很大的周期数。一般是11-14，最小
可到9，最大则到24。这可能是什么原因导致的呢？ |
|
