rdtsc

I am trying to use RDTSC but it seems like my approach may be wrong to get the core speed: #include "stdafx.h" #include <windows.h> #include <process.h> #include <iostream> using namespace std; struct Core { int CoreNumber; }; static void startMonitoringCoreSpeeds(void *param) { Core core = *((Core *)param); SetThreadAffinityMask(GetCurrentThread(), 1 << core.CoreNumber); while (true) { DWORD64 first = __rdtsc(); Sleep(1000); DWORD64 second = __rdtsc(); cout << "Core " << core.CoreNumber << " has frequency " << ((second - first)*pow(10, -6)) << " MHz" << endl; } } int GetNumberOfProcessorCores

It seems most newer CPUs from both AMD and Intel implement rdtsc as a constant rate counter, avoiding the issues caused by frequency changing as a result of things like TurboBoost or power saving settings. As rdtsc is a lot more suitable for performance measurements than QueryPerformanceCounter because of its much lower overhead, I would like to use it whenever possible. How can I detect reliably if the rdtsc is a constant rate counter or not? You can use CPUID to tell you. From the docs on CPUID Fn8000_0007_EDX bit 8: TscInvariant: TSC invariant . The TSC rate is ensured to be invariant

#include <stdio.h> static inline unsigned long long tick() { unsigned long long d; __asm__ __volatile__ ("rdtsc" : "=A" (d) ); return d; } int main() { long long res; res=tick(); res=tick()-res; printf("%d",res); return 0; } I have compiled this code with gcc with -O0 -O1 -O2 -O3 optimizations. And I always get 2000-2500 cycles. Can anyone explain the reason for this output? How to spend these cycles? First function "tick" is wrong. This is right . Another version of function "tick" static __inline__ unsigned long long tick() { unsigned hi, lo; __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi

I'm constructing a micro-benchmark to measure performance changes as I experiment with the use of SIMD instruction intrinsics in some primitive image processing operations. However, writing useful micro-benchmarks is difficult, so I'd like to first understand (and if possible eliminate) as many sources of variation and error as possible. One factor that I have to account for is the overhead of the measurement code itself. I'm measuring with RDTSC, and I'm using the following code to find the measurement overhead: extern inline unsigned long long __attribute__((always_inline)) rdtsc64() {

I tried to test rdtsc on VisualStudio 2010. Heres my code: #include <iostream> #include <windows.h> #include <intrin.h> using namespace std; uint64_t rdtsc() { return __rdtsc(); } int main() { cout << rdtsc() << "\n"; cin.get(); return 0; } But I got errors: ------ Build started: Project: test_rdtsc, Configuration: Debug Win32 ------ main.cpp c:\documents and settings\student\desktop\test_rdtsc\test_rdtsc\main.cpp(12): error C2146: syntax error : missing ';' before identifier 'rdtsc' c:\documents and settings\student\desktop\test_rdtsc\test_rdtsc\main.cpp(12): error C4430: missing type

Sometimes I encounter code that reads TSC with rdtsc instruction, but calls cpuid right before. Why is calling cpuid necessary? I realize it may have something to do with different cores having TSC values, but what exactly happens when you call those two instructions in sequence? It's to prevent out-of-order execution. From a link that has now disappeared from the web (but which was fortuitously copied here before it disappeared), this text is from an article entitled "Performance monitoring" by one John Eckerdal: The Pentium Pro and Pentium II processors support out-of-order execution