小编Pet*_*des的帖子

考虑以下代码：

bool AllZeroes(const char buf[4])
{
    return buf[0] == 0 &&
           buf[1] == 0 &&
           buf[2] == 0 &&
           buf[3] == 0;
}

Clang 13 的输出组件-O3：

AllZeroes(char const*):                        # @AllZeroes(char const*)
        cmp     byte ptr [rdi], 0
        je      .LBB0_2
        xor     eax, eax
        ret
.LBB0_2:
        cmp     byte ptr [rdi + 1], 0
        je      .LBB0_4
        xor     eax, eax
        ret
.LBB0_4:
        cmp     byte ptr [rdi + 2], 0
        je      .LBB0_6
        xor     eax, eax
        ret
.LBB0_6:
        cmp     byte ptr [rdi + 3], 0 …

我被告知要使用反汇编程序.是否gcc有建于什么？最简单的方法是什么？

这只是为了满足我自己的好奇心。

是否有此实现：

float InvSqrt (float x)
{
   float xhalf = 0.5f*x;
   int i = *(int*)&x;
   i = 0x5f3759df - (i>>1);
   x = *(float*)&i;
   x = x*(1.5f - xhalf*x*x);
   return x;
}

在Rust中？如果存在，则发布代码。

我尝试过但失败了。我不知道如何使用整数格式编码浮点数。这是我的尝试：

fn main() {
    println!("Hello, world!");
    println!("sqrt1: {}, ",sqrt2(100f64));
}

fn sqrt1(x: f64) -> f64 {
    x.sqrt()
}

fn sqrt2(x: f64) -> f64 {
    let mut x = x;
    let xhalf = 0.5*x;
    let mut i = x as i64;
    println!("sqrt1: {}, ", i);

    i = 0x5f375a86 as …

我知道 (-0 === 0) 结果是正确的。我很好奇为什么-0 < 0 会发生？

当我在 stackoverflow 执行上下文中运行此代码时，它返回0.

const arr = [+0, 0, -0];
console.log(Math.min(...arr));

但是当我在浏览器控制台中运行相同的代码时，它返回-0. 这是为什么？我尝试在谷歌上搜索它，但没有找到任何有用的东西。这个问题可能不会给某些实际例子增加价值，我想了解 JS 是如何计算它的。

 const arr = [+0, 0, -0];
    console.log(Math.min(...arr)); // -0

我们遇到了一个与在Advantech POS板上使用Via C3处理器在(相当旧的)FC3下运行的Java应用程序相关的问题.java应用程序有几个已编译的共享库,可通过JNI访问.

通过C3处理器应该是i686兼容.前段时间在使用相同处理器的MiniItx主板上安装Ubuntu 6.10之后,我发现之前的声明并非100%正确.由于缺少C3处理器中i686设置的一些特定和可选指令,Ubuntu内核在启动时挂起.在使用i686优化时,GCC编译器默认使用i686集的C3实现中缺少的这些指令.在这种情况下,解决方案是使用i386编译版本的Ubuntu发行版.

Java应用程序的基本问题是通过克隆另一台PC的HD映像来安装在HD上的FC3发行版,这次是Intel P4.之后,分发需要一些黑客才能让它运行,比如用i386编译的版本替换一些软件包(例如内核).

问题是,工作一段时间后系统完全挂起而没有任何痕迹.我担心一些i686代码会留在系统中的某个地方,并且可以随时随机执行(例如从暂停模式或类似的东西中恢复后).

我的问题是:

• 是否有任何工具或方法可以找出二进制文件(可执行文件或库)所需的特定体系结构扩展？file没有提供足够的信息.

我研究Linux内核并发现,对于int 0x80体系结构,中断syscall不能用于调用系统调用.

问题是:在int 0x80架构的情况下什么是更可取的int 0x80或syscall为什么？

编辑:我使用内核3.4

在某些情况下，您知道某个浮点表达式将始终为非负数。例如，计算一个矢量的长度时，一个做sqrt(a[0]*a[0] + ... + a[N-1]*a[N-1])（NB：我是知道的std::hypot，这是不相关的问题），并且平方根下表达显然是非负的。但是，GCC 为以下输出以下程序集sqrt(x*x)：

        mulss   xmm0, xmm0
        pxor    xmm1, xmm1
        ucomiss xmm1, xmm0
        ja      .L10
        sqrtss  xmm0, xmm0
        ret
.L10:
        jmp     sqrtf

也就是说，它将结果x*x与零进行比较，如果结果为非负数，则执行sqrtss指令，否则调用sqrtf。

因此，我的问题是：如何强制GCC假定该x*x值始终为非负值，从而跳过比较和sqrtf调用，而无需编写内联汇编？

我想强调的是，我对本地解决方案感兴趣，而不是像-ffast-math，-fno-math-errno或那样做-ffinite-math-only（尽管确实可以解决问题，这要归功于ks1322，harold和Eric Postpischil的评论）。

此外，“强制将GCC假定x*x为非负数”应解释为assert(x*x >= 0.f)，因此这也排除了x*xNaN 的情况。

我可以使用特定于编译器，特定于平台，特定于CPU等的解决方案。

我遇到了这两种连接字符串的方法:

共同部分:

char* first= "First";
char* second = "Second";
char* both = malloc(strlen(first) + strlen(second) + 2);

方法1:

strcpy(both, first);
strcat(both, " ");       // or space could have been part of one of the strings
strcat(both, second);

方法2:

sprintf(both, "%s %s", first, second);

在这两种情况下,内容both都是"First Second".

我想知道哪一个更有效(我必须执行几个连接操作),或者如果你知道更好的方法来做到这一点.

作为我研究在流中使用复杂过滤器或多个过滤器之间区别的一部分，我注意到Java 12的性能比Java 8慢。

这些奇怪的结果有什么解释吗？我在这里想念什么吗？

组态：

• Java 8

  • OpenJDK运行时环境（内部版本1.8.0_181-8u181-b13-2〜deb9u1-b13）
  • OpenJDK 64位服务器VM（内部版本25.181-b13，混合模式）

• Java 12

  • OpenJDK运行时环境（内部版本12 + 33）
  • OpenJDK 64位服务器VM（内部版本12 + 33，混合模式，共享）

• VM选项： -XX:+UseG1GC -server -Xmx1024m -Xms1024m

• CPU：8核

JMH吞吐量结果：

• 预热：10次迭代，每次1秒
• 测量：10次迭代，每次1秒
• 线程：1个线程，将同步迭代
• 单位：ops / s

码

流+复杂过滤器

public void complexFilter(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream()
                .filter(d -> d < Math.PI
                        && d > Math.E
                        && d != 3
                        && d != 2)
                .count();

        blackhole.consume(count);
    }

流+多个过滤器

public void multipleFilters(ExecutionPlan plan, Blackhole blackhole) {
        long count = plan.getDoubles()
                .stream() …

#include <stdio.h>

int main() {
    char a = 5;
    char b[2] = "hi"; // No explicit room for `\0`.
    char c = 6;

    return 0;
}

每当我们编写一个用双引号括起来的字符串时，C 都会自动为我们创建一个字符数组，其中包含该字符串，并以 \0 字符结尾 http://www.eskimo.com/~scs/cclass/notes/sx8。 html

在上面的示例中，b只有 2 个字符的空间，因此空终止字符没有位置可放置，但编译器正在重新组织内存存储指令，以便将a和c存储b在内存中，以便为 a 腾出\0空间数组的末尾。

这是预期的还是我遇到了未定义的行为？