相关疑难解决方法(0)

我想知道某个函数在我的C++程序中执行多长时间才能在Linux上执行.之后,我想进行速度比较.我看到了几个时间功能,但结果来自于boost.计时:

process_user_cpu_clock, captures user-CPU time spent by the current process

现在,我不清楚我是否使用上述功能,我将获得CPU花在该功能上的唯一时间吗？

其次,我找不到任何使用上述功能的例子.任何人都可以帮我如何使用上述功能？

PS:现在,我std::chrono::system_clock::now()用来在几秒钟内获得时间,但由于每次CPU负载不同,这给了我不同的结果.

C++编程语言第4版,第225页读取:只要结果与简单执行顺序的结果相同,编译器就可以重新排序代码以提高性能.一些编译器,例如发布模式下的Visual C++,将重新排序此代码:

#include <time.h>
...
auto t0 = clock();
auto r  = veryLongComputation();
auto t1 = clock();

std::cout << r << "  time: " << t1-t0 << endl;

进入这种形式:

auto t0 = clock();
auto t1 = clock();
auto r  = veryLongComputation();

std::cout << r << "  time: " << t1-t0 << endl;

这保证了与原始代码不同的结果(零与大于零的时间报告).有关详细示例,请参阅我的其他问题 这种行为是否符合C++标准？

我想为Atmel AVR微控制器编写C代码固件.我将使用GCC编译它.此外,我想启用编译器优化(-Os或-O2),因为我认为没有理由不启用它们,并且它们可能比手动编写汇编更快地生成更好的汇编方式.

但我想要一小段没有优化的代码.我想延迟函数的执行一段时间,因此我想写一个do-nothing循环只是为了浪费一些时间.不需要精确,只需等待一段时间.

/* How to NOT optimize this, while optimizing other code? */
unsigned char i, j;
j = 0;
while(--j) {
    i = 0;
    while(--i);
}

由于AVR中的内存访问速度要慢得多,因此我希望i并将j其保存在CPU寄存器中.

更新:我刚刚发现UTIL/delay.h和UTIL/delay_basic.h从AVR libc库.尽管大多数情况下使用这些功能可能更好,但这个问题仍然有效且有趣.

相关问题:

• 如何防止gcc优化C中的一些语句？
• 有没有办法告诉GCC不优化特定的代码？
• 如何不优化远离 - 愚蠢功能的机制

假设我们正在尝试使用tsc进行性能监控,我们希望防止指令重新排序.

这些是我们的选择:

1: rdtscp是序列化调用.它可以防止对rdtscp的调用进行重新排序.

__asm__ __volatile__("rdtscp; "         // serializing read of tsc
                     "shl $32,%%rdx; "  // shift higher 32 bits stored in rdx up
                     "or %%rdx,%%rax"   // and or onto rax
                     : "=a"(tsc)        // output to tsc variable
                     :
                     : "%rcx", "%rdx"); // rcx and rdx are clobbered

但是,rdtscp仅适用于较新的CPU.所以在这种情况下我们必须使用rdtsc.但是rdtsc非序列化,因此单独使用它不会阻止CPU重新排序.

所以我们可以使用这两个选项中的任何一个来防止重新排序:

2:这是一个电话cpuid然后rdtsc.cpuid是一个序列化的电话.

volatile int dont_remove __attribute__((unused)); // volatile to stop optimizing
unsigned tmp;
__cpuid(0, tmp, tmp, tmp, …

GCC,MSVC,LLVM以及可能的其他工具链支持链接时(整个程序)优化,以允许编译单元之间的调用优化.

在编译生产软件时是否有理由不启用此选项？

为什么编译器似乎对没有做任何事情并且不消除它们的循环有礼貌？

C标准是否需要循环需要一些时间？

例如,以下代码:

void foo(void) {
    while(1) {
        for(int k = 0; k < 1000000000; ++k);
        printf("Foo\n");
    }
}

运行速度比这个慢:

void foo(void) {
    while(1) {
        for(int k = 0; k < 1000; ++k);
        printf("Foo\n");
    }
}

即使有-O3优化水平.我希望删除允许的空循环,从而在两个代码上获得相同的速度.

"花费的时间"是否应该由编译器保留的副作用？

我试图找到我最近在stackoverflow上发布的程序的效率.

如何有效地删除给定另一个向量的向量中的元素

为了比较我的代码与其他答案的效率,我正在使用chrono对象.

这是检查运行时效率的正确方法吗？

如果没有,那么请用一个例子来建议一种方法.

Coliru代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <chrono>
#include <ctime>
using namespace std;

void remove_elements(vector<int>& vDestination, const vector<int>& vSource) 
{
    if(!vDestination.empty() && !vSource.empty())
    {
        for(auto i: vSource) {
            vDestination.erase(std::remove(vDestination.begin(), vDestination.end(), i), vDestination.end());
        }
    }
}

int main() {
    vector<int> v1={1,2,3};
    vector<int> v2={4,5,6};
    vector<int> v3={1,2,3,4,5,6,7,8,9};
    std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
    remove_elements(v3,v1);
    remove_elements(v3,v2);
    std::chrono::steady_clock::time_point end= std::chrono::steady_clock::now();
    std::cout << "Time difference = " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count() <<std::endl;
    for(auto i:v3)
        cout << i << endl;
    return …

最近,我开始使用带有g ++ 5.3.1的Ubuntu 16.04并检查我的程序运行速度慢了3倍.在此之前我使用过Ubuntu 14.04,g ++ 4.8.4.我使用相同的命令构建它:CFLAGS = -std=c++11 -Wall -O3.

我的程序包含循环,充满数学调用(sin,cos,exp).你可以在这里找到它.

我尝试使用不同的优化标志(O0,O1,O2,O3,Ofast)进行编译,但在所有情况下都会重现问题(使用Ofast,两种变体运行速度更快,但第一次运行速度仍然慢3倍).

在我使用的程序中libtinyxml-dev,libgslcblas.但是它们在两种情况下都具有相同的版本,并且在性能方面没有在程序中(根据代码和callgrind概要分析)占用任何重要部分.

我已经进行了分析,但它并没有让我知道它为什么会发生. Kcachegrind比较(左边比较慢).我只注意到现在程序使用与Ubuntu 14.04 libm-2.23相比libm-2.19.

我的处理器是i7-5820,Haswell.

我不知道为什么它会变慢.你有什么想法？

PS下面你可以找到最耗时的功能:

void InclinedSum::prepare3D()
{
double buf1, buf2;
double sum_prev1 = 0.0, sum_prev2 = 0.0;
int break_idx1, break_idx2; 
int arr_idx;

for(int seg_idx = 0; seg_idx < props->K; seg_idx++)
{
    const Point& r = well->segs[seg_idx].r_bhp;

    for(int k = 0; k < props->K; k++)
    {
        arr_idx = seg_idx * …

有问题的代码:

#include <atomic>
#include <thread>

std::atomic_bool stop(false);

void wait_on_stop() {
  while (!stop.load(std::memory_order_relaxed));
}

int main() {
  std::thread t(wait_on_stop);
  stop.store(true, std::memory_order_relaxed);
  t.join();
}

由于std::memory_order_relaxed用在这里,我假设编译器可以自由地重新排序stop.store()后t.join().结果,t.join()永远不会回来.这个推理是否正确？

如果是的话,将改变stop.store(true, std::memory_order_relaxed)以stop.store(true)解决这一问题？

有没有一种简单的方法可以在执行C程序时快速计算执行的指令数量(x86指令 - 每个指令的数量和数量)？

我gcc version 4.7.1 (GCC)在x86_64 GNU/Linux机器上使用.