当前位置: 首页 > 知识库问答 >
问题:

对于布尔函数,(p^q)和(p!=q)之间有什么有用的区别吗?

陈飞
2023-03-14

Java有两种方法来检查两个布尔值是否不同。您可以将它们与!=^(异或)进行比较。当然,这两个操作符在所有情况下都产生相同的结果。但是,把它们都包括在内是有意义的,例如,在XOR和not-equal-to之间的区别是什么?。开发人员甚至可以根据上下文选择一个而不是另一个--有时“这两个布尔值中的一个是真的”读起来更好,而有时“这两个布尔值不同吗”能更好地传达意图。那么,或许用哪一种应该是品味和风格的问题。

让我吃惊的是javac并不是一视同仁的对待这些!请考虑此类:

class Test {
  public boolean xor(boolean p, boolean q) {
    return p ^ q;
  }
  public boolean inequal(boolean p, boolean q) {
    return p != q;
  }
}

显然,这两种方法具有相同的可见行为。但它们有不同的字节码:

$ javap -c Test
Compiled from "Test.java"
class Test {
  Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public boolean xor(boolean, boolean);
    Code:
       0: iload_1
       1: iload_2
       2: ixor
       3: ireturn

  public boolean inequal(boolean, boolean);
    Code:
       0: iload_1
       1: iload_2
       2: if_icmpeq     9
       5: iconst_1
       6: goto          10
       9: iconst_0
      10: ireturn
}
user=> (let [t (Test.)] (bench (.xor t true false)))
Evaluation count : 4681301040 in 60 samples of 78021684 calls.
             Execution time mean : 4.273428 ns
    Execution time std-deviation : 0.168423 ns
   Execution time lower quantile : 4.044192 ns ( 2.5%)
   Execution time upper quantile : 4.649796 ns (97.5%)
                   Overhead used : 8.723577 ns

Found 2 outliers in 60 samples (3.3333 %)
    low-severe   2 (3.3333 %)
 Variance from outliers : 25.4745 % Variance is moderately inflated by outliers
user=> (let [t (Test.)] (bench (.inequal t true false)))
Evaluation count : 4570766220 in 60 samples of 76179437 calls.
             Execution time mean : 4.492847 ns
    Execution time std-deviation : 0.162946 ns
   Execution time lower quantile : 4.282077 ns ( 2.5%)
   Execution time upper quantile : 4.813433 ns (97.5%)
                   Overhead used : 8.723577 ns

Found 2 outliers in 60 samples (3.3333 %)
    low-severe   2 (3.3333 %)
 Variance from outliers : 22.2554 % Variance is moderately inflated by outliers

在性能方面1是不是更喜欢编写一个而不是另一个?在某种情况下,它们的实施方式不同,使得一个比另一个更合适?或者,有人知道为什么javac实现这两个相同的操作如此不同吗?

1当然,我不会鲁莽地使用这些信息进行微优化。我只是好奇这一切是怎么运作的。

共有1个答案

令狐新翰
2023-03-14

好吧,我将提供CPU如何转换,并更新文章,但同时,您看到的是太小的差异,不必在意。

java中的字节码并不是一个方法执行速度的指示,有两个JIT编译器,一旦它们足够热,就会使这个方法看起来完全不同。此外,javac编译代码后只进行很少的优化,真正的优化来自JIT

为此,我使用jmh进行了一些测试,或者只使用c1编译器,或者用graalvm替换c2或者根本不使用jit。(下面是大量的测试代码,您可以跳过它,只看结果,这是使用jdk-12btw完成的)。这段代码使用的是JMH-在java微基准测试世界中使用的一个事实上的工具(如果手工完成,这是出了名的容易出错的)。

@Warmup(iterations = 10)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Measurement(iterations = 2, time = 2, timeUnit = TimeUnit.SECONDS)
public class BooleanCompare {

    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
            .include(BooleanCompare.class.getName())
            .build();

        new Runner(opt).run();
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(1)
    public boolean xor(BooleanExecutionPlan plan) {
        return plan.booleans()[0] ^ plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(1)
    public boolean plain(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-Xint")
    public boolean xorNoJIT(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-Xint")
    public boolean plainNoJIT(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-XX:-TieredCompilation")
    public boolean xorC2Only(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-XX:-TieredCompilation")
    public boolean plainC2Only(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-XX:TieredStopAtLevel=1")
    public boolean xorC1Only(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1, jvmArgsAppend = "-XX:TieredStopAtLevel=1")
    public boolean plainC1Only(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1,
        jvmArgsAppend = {
            "-XX:+UnlockExperimentalVMOptions",
            "-XX:+EagerJVMCI",
            "-Dgraal.ShowConfiguration=info",
            "-XX:+UseJVMCICompiler",
            "-XX:+EnableJVMCI"
        })
    public boolean xorGraalVM(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @Fork(value = 1,
        jvmArgsAppend = {
            "-XX:+UnlockExperimentalVMOptions",
            "-XX:+EagerJVMCI",
            "-Dgraal.ShowConfiguration=info",
            "-XX:+UseJVMCICompiler",
            "-XX:+EnableJVMCI"
        })
    public boolean plainGraalVM(BooleanExecutionPlan plan) {
        return plan.booleans()[0] != plan.booleans()[1];
    }

}

和结果:

BooleanCompare.plain         avgt    2    3.125          ns/op
BooleanCompare.xor           avgt    2    2.976          ns/op

BooleanCompare.plainC1Only   avgt    2    3.400          ns/op
BooleanCompare.xorC1Only     avgt    2    3.379          ns/op

BooleanCompare.plainC2Only   avgt    2    2.583          ns/op
BooleanCompare.xorC2Only     avgt    2    2.685          ns/op

BooleanCompare.plainGraalVM  avgt    2    2.980          ns/op
BooleanCompare.xorGraalVM    avgt    2    3.868          ns/op

BooleanCompare.plainNoJIT    avgt    2  243.348          ns/op
BooleanCompare.xorNoJIT      avgt    2  201.342          ns/op

我不是一个多才多艺的人,读汇编程序,虽然我有时喜欢这样做。这里有一些有趣的事情。如果我们这样做:

C1编译器仅使用!=

/*
 * run many iterations of this with :
 *  java -XX:+UnlockDiagnosticVMOptions  
 *       -XX:TieredStopAtLevel=1  
 *       "-XX:CompileCommand=print,com/so/BooleanCompare.compare"  
 *       com.so.BooleanCompare
 */
public static boolean compare(boolean left, boolean right) {
    return left != right;
}
  0x000000010d1b2bc7: push   %rbp
  0x000000010d1b2bc8: sub    $0x30,%rsp  ;*iload_0 {reexecute=0 rethrow=0 return_oop=0}
                                         ; - com.so.BooleanCompare::compare@0 (line 22)

  0x000000010d1b2bcc: cmp    %edx,%esi
  0x000000010d1b2bce: mov    $0x0,%eax
  0x000000010d1b2bd3: je     0x000000010d1b2bde
  0x000000010d1b2bd9: mov    $0x1,%eax
  0x000000010d1b2bde: and    $0x1,%eax
  0x000000010d1b2be1: add    $0x30,%rsp
  0x000000010d1b2be5: pop    %rbp

C1编译器,带有^:

public static boolean compare(boolean left, boolean right) {
     return left ^ right;
}



  # parm0:    rsi       = boolean
  # parm1:    rdx       = boolean
  #           [sp+0x40]  (sp of caller)
  0x000000011326e5c0: mov    %eax,-0x14000(%rsp)
  0x000000011326e5c7: push   %rbp
  0x000000011326e5c8: sub    $0x30,%rsp   ;*iload_0 {reexecute=0 rethrow=0 return_oop=0}
                                          ; - com.so.BooleanCompare::compare@0 (line 22)

  0x000000011326e5cc: xor    %rdx,%rsi
  0x000000011326e5cf: and    $0x1,%esi
  0x000000011326e5d2: mov    %rsi,%rax
  0x000000011326e5d5: add    $0x30,%rsp
  0x000000011326e5d9: pop    %rbp

我真的不知道为什么这里需要和$0x1,%esi,否则我想这也相当简单。

但如果我启用C2编译器,事情就有趣多了。

/**
 * run with java
 * -XX:+UnlockDiagnosticVMOptions
 * -XX:CICompilerCount=2
 * -XX:-TieredCompilation
 * "-XX:CompileCommand=print,com/so/BooleanCompare.compare"
 * com.so.BooleanCompare
 */
public static boolean compare(boolean left, boolean right) {
    return left != right;
}



  # parm0:    rsi       = boolean
  # parm1:    rdx       = boolean
  #           [sp+0x20]  (sp of caller)
  0x000000011a2bbfa0: sub    $0x18,%rsp
  0x000000011a2bbfa7: mov    %rbp,0x10(%rsp)                

  0x000000011a2bbfac: xor    %r10d,%r10d
  0x000000011a2bbfaf: mov    $0x1,%eax
  0x000000011a2bbfb4: cmp    %edx,%esi
  0x000000011a2bbfb6: cmove  %r10d,%eax                     

  0x000000011a2bbfba: add    $0x10,%rsp
  0x000000011a2bbfbe: pop    %rbp
 sub    $0x18,%rsp
 mov    %rbp,0x10(%rsp)

 ....
 add    $0x10,%rsp
 pop    %rbp
xor    %r10d,%r10d // put zero into r10d
mov    $0x1,%eax   // put 1 into eax
cmp    %edx,%esi   // compare edx and esi
cmove  %r10d,%eax  // conditionally move the contents of r10d into eax

AFAIKcmp/cmovecmp/je更好,因为它有分支预测--这至少是我读到的...

使用C2编译器进行异或:

public static boolean compare(boolean left, boolean right) {
    return left ^ right;
}



  0x000000010e6c9a20: sub    $0x18,%rsp
  0x000000010e6c9a27: mov    %rbp,0x10(%rsp)                

  0x000000010e6c9a2c: xor    %edx,%esi
  0x000000010e6c9a2e: mov    %esi,%eax
  0x000000010e6c9a30: and    $0x1,%eax
  0x000000010e6c9a33: add    $0x10,%rsp
  0x000000010e6c9a37: pop    %rbp

它看起来与生成的C1编译器几乎相同。

 类似资料:
  • 本文向大家介绍C中的++ * p,* p ++和* ++ p之间的区别,包括了C中的++ * p,* p ++和* ++ p之间的区别的使用技巧和注意事项,需要的朋友参考一下 指针式 在C语言中,* p表示存储在指针中的值。++是前缀和后缀表达式中使用的增量运算符。*是取消引用运算符。前缀++和*的优先级相同,并且两者从右到左关联。后缀++的优先级高于前缀++和*,并且从左到右具有关联性。请参见以

  • $(\text{KL}(p\|q))$ Minimization One form of variational inference minimizes the Kullback-Leibler divergence from $(p(\mathbf{z} \mid \mathbf{x}))$ to $(q(\mathbf{z}\;;\;\lambda))$, \[\begin{aligned}

  • $(\text{KL}(q\|p))$ Minimization One form of variational inference minimizes the Kullback-Leibler divergence from $(q(\mathbf{z}\;;\;\lambda))$ to $(p(\mathbf{z} \mid \mathbf{x}))$, \[\begin{aligned}

  • 我正在寻找编译过程中使用的默认编译器标志。因此,我使用了命令

  • 问题内容: 我一直在阅读iBooks中的快速编程指南。有人可以向我解释函数和闭包之间的区别是什么。只是它没有名称并且可以在表达式中使用? 问题答案: 函数实际上只是命名为闭包。以下至少在概念上是等效的: 在使用声明方法的情况下,这变得有些复杂,例如,关于自动插入公共命名参数等,添加了一些有趣的糖,例如,变为`func myMethod(foo:Int, #bar:Int, 但是,即使方法只是闭包的

  • 问题内容: OpenAI的强化学习的REINFORCE和actor-critic示例具有以下代码: 加强: 演员评论家: 一种正在使用,另一种正在使用。 据我所知,文档没有对它们之间进行任何明确的区分。 我很高兴知道这些功能之间的区别。 问题答案: 沿着 新的维度 连接张量序列。 在给 定维度上 连接给定序列张量的序列。 因此,如果和具有形状(3,4),则将具有形状(6,4),并将具有形状(2,3