相关疑难解决方法(0)

我有一个在Linux上运行的C++应用程序,我正在优化它.如何确定代码的哪些区域运行缓慢？

我为Project Euler Q14编写了这两个解决方案,在汇编和C++中.它们是用于测试Collat​​z猜想的相同蛮力方法.装配解决方案与组装

nasm -felf64 p14.asm && gcc p14.o -o p14

C++是用.编译的

g++ p14.cpp -o p14

部件, p14.asm

section .data
    fmt db "%d", 10, 0

global main
extern printf

section .text

main:
    mov rcx, 1000000
    xor rdi, rdi        ; max i
    xor rsi, rsi        ; i

l1:
    dec rcx
    xor r10, r10        ; count
    mov rax, rcx

l2:
    test rax, 1
    jpe even

    mov rbx, 3
    mul rbx
    inc rax
    jmp c1

even:
    mov rbx, 2 …

我试图比较内联汇编语言和C++代码的性能,所以我写了一个函数,添加两个大小为2000的数组,持续100000次.这是代码:

#define TIMES 100000
void calcuC(int *x,int *y,int length)
{
    for(int i = 0; i < TIMES; i++)
    {
        for(int j = 0; j < length; j++)
            x[j] += y[j];
    }
}


void calcuAsm(int *x,int *y,int lengthOfArray)
{
    __asm
    {
        mov edi,TIMES
        start:
        mov esi,0
        mov ecx,lengthOfArray
        label:
        mov edx,x
        push edx
        mov eax,DWORD PTR [edx + esi*4]
        mov edx,y
        mov ebx,DWORD PTR [edx + esi*4]
        add eax,ebx
        pop edx
        mov [edx + esi*4],eax
        inc esi
        loop label
        dec edi …

还有哪些程序与 gprof 做同样的事情？

for (;;) {
    //Something to be done repeatedly
}

我已经看到这种东西使用了很多,但我觉得它很奇怪......说再说清楚while(true),还是沿着这些方向做些什么？

我猜这(因为许多程序员采用神秘的代码的原因)这是一个微小的利润更快？

为什么,它真的值得吗？如果是这样,为什么不这样定义它:

#define while(true) for(;;)

另请参见:哪个更快:while(1)或while(2)？

我们都知道,过早优化是所有邪恶的根源,因为它会导致不可读/不可维护的代码.更糟糕的是悲观化,当有人实施"优化",因为他们认为它会更快,但它最终会变慢,而且变得越来越慢,不可维护等等.你看到的最荒谬的例子是什么？ ？

许多年前,C编译器并不是特别聪明.作为一种解决方法,K&R发明了register关键字,提示编译器,将这个变量保存在内部寄存器中可能是一个好主意.他们还使第三级运营商帮助生成更好的代码.

随着时间的推移,编译器逐渐成熟.他们变得非常聪明,他们的流量分析使他们能够更好地决定寄存器中的值,而不是你可能做的.register关键字变得不重要了.

由于别名问题,FORTRAN对于某些操作可能比C更快.从理论上讲,仔细编码可以解决这个限制,使优化器能够生成更快的代码.

有哪些编码实践可以使编译器/优化器生成更快的代码？

• 确定您使用的平台和编译器,将不胜感激.
• 为什么这项技术似乎有效？
• 鼓励使用示例代码.

这是一个相关的问题

[编辑] 这个问题不是关于分析和优化的整个过程.假设程序编写正确,编译完全优化,测试并投入生产.您的代码中可能有一些构造禁止优化器尽其所能地完成最佳工作.您可以做什么来重构将删除这些禁令,并允许优化器生成更快的代码？

[编辑] 偏移相关链接

我一直试图通过循环展开来优化一些极其性能关键的代码(一种快速排序算法,在蒙特卡罗模拟中被称为数百万次).这是我试图加速的内循环:

// Search for elements to swap.
while(myArray[++index1] < pivot) {}
while(pivot < myArray[--index2]) {}

我尝试展开类似的东西:

while(true) {
    if(myArray[++index1] < pivot) break;
    if(myArray[++index1] < pivot) break;
    // More unrolling
}


while(true) {
    if(pivot < myArray[--index2]) break;
    if(pivot < myArray[--index2]) break;
    // More unrolling
}

这完全没有区别所以我把它改成了更易读的形式.我曾经尝试过循环展开,但我有类似的经历.鉴于现代硬件上的分支预测器的质量,何时(如果有的话)循环展开仍然是一个有用的优化？

我需要一个C#profiler.

虽然我不反对支付一个,但是免费或者至少试用版的东西是理想的,因为提交采购订单需要时间.

有什么建议？

从StringJava中删除所有不可打印字符的最快方法是什么？

到目前为止,我已经尝试并测量了138字节,131个字符的字符串:

• 字符串replaceAll()- 最慢的方法
  • 517009结果/秒
• 预编译模式,然后使用匹配器 replaceAll()
  • 637836结果/秒
• 使用StringBuffer,codepointAt()逐个获取代码点并附加到StringBuffer
  • 711946结果/秒
• 使用StringBuffer,charAt()逐个获取字符并附加到StringBuffer
  • 1052964结果/秒
• 预分配char[]缓冲区,charAt()逐个获取字符并填充此缓冲区,然后转换回String
  • 2022653结果/秒
• 预分配2个char[]缓冲区 - 旧的和新的,一次获取现有String的所有字符,getChars()逐个迭代旧缓冲区并填充新缓冲区,然后将新缓冲区转换为String - 我自己的最快版本
  • 2502502结果/秒
• 与2个缓冲区相同的东西 - 仅使用byte[],getBytes()并指定编码为"utf-8"
  • 857485结果/秒
• 具有2个byte[]缓冲区的相同内容,但将编码指定为常量Charset.forName("utf-8")
  • 791076结果/秒
• 与2个byte[]缓冲区相同的东西,但指定编码为1字节本地编码(几乎没有理智的事情要做)
  • 370164结果/秒

我最好的尝试如下:

    char[] oldChars = new char[s.length()];
    s.getChars(0, s.length(), oldChars, 0);
    char[] newChars = new char[s.length()];
    int newLen = 0;
    for (int j = 0; j < s.length(); …