相关疑难解决方法(0)

我偶然发现了什么.起初我认为这可能是分支错误预测的情况,就像在这种情况下一样,但我无法解释为什么分支错误预测应该导致这种现象.

我在Java中实现了两个版本的Bubble Sort并进行了一些性能测试:

import java.util.Random;

public class BubbleSortAnnomaly {

    public static void main(String... args) {
        final int ARRAY_SIZE = Integer.parseInt(args[0]);
        final int LIMIT = Integer.parseInt(args[1]);
        final int RUNS = Integer.parseInt(args[2]);

        int[] a = new int[ARRAY_SIZE];
        int[] b = new int[ARRAY_SIZE];
        Random r = new Random();
        for (int run = 0; RUNS > run; ++run) {
            for (int i = 0; i < ARRAY_SIZE; i++) {
                a[i] = r.nextInt(LIMIT);
                b[i] = a[i];
            }

            System.out.print("Sorting with sortA: ");
            long start …

我知道这是一个微观优化,所以我问出纯粹的好奇心.

逻辑上,微处理器不需要比较相等运算符的两个操作数的所有位以确定"FALSE"结果.

注意,这与编程有关,因为它会影响程序的执行速度.

我不理解JG/JNLE/JL/JNGECMP之后的说明.

例如,如果我有:

CMP al,dl
jg label1

当al=101; dl =200.

我们问jg什么？是al>dl吗？还是al-dl>0？

在下一个代码上相同的prolbem:

test al,dl
jg label1

我不明白我们比较什么,以及我们问什么" jg".

换句话说,我不明白我们何时会跳转到label1,何时不会.

谢谢.

给定一个实数(n),这个实数可以是(上)的最大值,这个实数可以是(更低)的最小值,我们怎样才能最有效地剪切n,使它保持在低位和高位之间？

当然,使用一堆if语句可以做到这一点,但那很无聊!更紧凑,优雅/有趣的解决方案呢？

我自己的快速尝试(C/C++):

float clip( float n, float lower, float upper )
{
    n = ( n > lower ) * n + !( n > lower ) * lower;
    return ( n < upper ) * n + !( n < upper ) * upper;
}

我确信还有其他更好的方法可以做到这一点,这就是为什么我把它放在那里......!

我听过一位老师放弃了这一次,从那以后一直困扰着我.假设我们要检查整数x是否大于或等于0.有两种方法可以检查:

if (x > -1){
    //do stuff
}

和

if (x >= 0){
    //do stuff
} 

根据这个老师>会稍快一点>=.在这种情况下它是Java,但据他说,这也适用于C,c ++和其他语言.这句话有什么道理吗？

变量x是int,带有可能的值:-1, 0, 1, 2, 3.哪个表达式会更快(在CPU滴答中):

1. (x < 0)
2. (x == -1)

语言:C/C++,但我想所有其他语言都是一样的.

PS我个人认为答案是(x < 0).

更广泛的大师:如果x从-1到2^30？

当试图理解汇编(启用编译器优化)时,我看到这种行为:

这样一个非常基本的循环

outside_loop;
while (condition) {
     statements;
}

经常被编译成(伪代码)

    ; outside_loop
    jmp loop_condition    ; unconditional
loop_start:
    loop_statements
loop_condition:
    condition_check
    jmp_if_true loop_start
    ; outside_loop

但是,如果未打开优化,则会编译为通常可理解的代码:

loop_condition:
    condition_check
    jmp_if_false loop_end
    loop_statements
    jmp loop_condition  ; unconditional
loop_end:

根据我的理解,编译后的代码更像是这样的:

goto condition;
do {
    statements;
    condition:
}
while (condition_check);

我看不到巨大的性能提升或代码可读性提升,为什么经常出现这种情况呢？是否有此循环样式的名称,例如"尾随条件检查"？

几个星期前,我已经读过这个帖子<快于<=？关于比较运算符C.据说它们之间的性能没有区别<,<=因为它们被解释为相同/相似的机器命令.

同时,在我们公司的"最佳实践"中,据说我们应该总是使用"==="来比较事物而不是"==".所以,我开始怀疑这是否总是合适的,因为我习惯使用"=="和"typeof ... =="并且不想改变我的写作方式: - ]

请注意,这是在JavaScript的上下文中.

那么,我有一点研究,这里应该在JavaScript比较中使用哪个等于运算符(== vs ===)？据说:

这是因为等于运算符==确实类型强制...意味着解释器隐式尝试转换值然后进行比较.

另一方面,身份运算符===不进行类型强制,因此它在比较时不会转换值的值

我开始怀疑这是否意味着当我使用"==="运算符时,我将获得良好的性能,因为没有资源将用于转换操作数.而所有的代码变成机器命令后,这是否意味着就像存在没有区别C,当你使用<和<=,这是JavaScript和其他语言一样吗？

我在Delphi中编写一个简单的BigInteger类型.它主要由TLimb的动态数组组成,其中TLimb是32位无符号整数,32位大小字段,它还保存BigInteger的符号位.

要添加两个BigIntegers,我创建一个适当大小的新BigInteger然后,在一些簿记之后,调用以下过程,将三个指针传递给左右操作数和结果的数组的相应开始,以及左右肢的数量分别为.

普通代码:

class procedure BigInteger.PlainAdd(Left, Right, Result: PLimb; LSize, RSize: Integer); 
asm
// EAX = Left, EDX = Right, ECX = Result
        PUSH    ESI
        PUSH    EDI
        PUSH    EBX
        MOV     ESI,EAX                 // Left
        MOV     EDI,EDX                 // Right
        MOV     EBX,ECX                 // Result
        MOV     ECX,RSize               // Number of limbs at Left
        MOV     EDX,LSize               // Number of limbs at Right
        CMP     EDX,ECX
        JAE     @SkipSwap
        XCHG    ECX,EDX                 // Left and LSize should be largest
        XCHG    ESI,EDI                 // so swap
@SkipSwap:
        SUB     EDX,ECX                 // …

如果要比较两个整数,运算符是否会影响执行比较所需的时间？例如,给定:

if (x < 60)

和

if (x <= 59)

哪个会提供最佳性能,还是性能差异可以忽略不计？性能结果是否取决于语言？

我经常发现自己在代码中混合使用这些运算符.任何想法将不胜感激.