小编ant*_*oyo的帖子

我看看Rust程序使用了多少RAM(命令RES列top),我想知道为什么他们会使用这么多内存.

这是一个例子:

use std::io;

fn main() {
    println!("What's your name?");
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    println!("Hello {}!", input);
}

我在输入内容之前看到了6 MB的内存.

以下是我编译和执行程序的方法:

cargo build --release
./target/release/main

等效的C程序:

#include <stdio.h>

int main(void) {
    printf("What's your name?\n");
    char input[100] = {0};
    scanf("%s", input);
    printf("Hello %s!\n", input);
    return 0;
}

仅使用0.6 MB.在这种情况下,Rust程序使用10倍的内存.在其他情况下,我看到Rust程序使用了5倍的内存.

我还测试了其他语言进行比较.

OCaml版本:

let () =
    print_endline "What's your name?";
    let line = read_line () in
    print_string "Hello ";
    print_endline line

使用1 MB.

Haskell版本:

main = …

我从源代码安装LLVM(使用CMake和make install)但我无法卸载它,因为没有make uninstall可用的.

这是LLVM版本3.5.2.

我使用ArchLinux.

如何以自动方式卸载LLVM？

当我使用其中一个插件启动vim时:

• TagBar
• 会议

当我打开vim时,我看到缓冲区中有时会出现垃圾字符.

以下是这些字符:

;2R^[[>1;2802;0c

通过卸载这两个插件,我不再看到这些垃圾字符了.

如果我键入dd,它甚至不删除这些字符.Vim说缓冲区是空的.

将此命令放在我的.vimrc的末尾是解决此问题的方法:

autocmd VimEnter * redraw!

这样,这些字符立即被删除.

我该如何解决这个问题？

我有一个包含两个字段的结构,我想使用另一个字段(不可变借用)修改一个字段(可变借用),但是我从借用检查器得到一个错误.

例如,以下代码:

struct Struct {
    field1: Vec<i32>,
    field2: Vec<i32>,
}

fn main() {
    let mut strct = Struct {
        field1: vec![1, 2, 3],
        field2: vec![2, 3, 4],
    };

    strct.field1.retain(|v| !strct.field2.contains(v));

    println!("{:?}", strct.field1);
}

给出以下错误:

error[E0502]: cannot borrow `strct.field1` as mutable because it is also borrowed as immutable
  --> src/main.rs:12:5
   |
12 |     strct.field1.retain(|v| !strct.field2.contains(v));
   |     ^^^^^^^^^^^^^------^---^^-----^^^^^^^^^^^^^^^^^^^^
   |     |            |      |    |
   |     |            |      |    first borrow occurs due to use of `strct` in closure
   |     |            |      immutable borrow …

我尝试使用get_unchecked()而不是[]索引运算符来获得s()我的des箱子功能的性能提升.

但是,即使在我的基准测试中将[](或get_unchecked())函数调用了48亿次,它也不会导致可见的性能提升.我原本认为,调用get_unchecked()48亿次而不是[]将使我的英特尔酷睿2双核2.4 GHz处理器的时间缩短2秒.

我做了这个小基准测试,有一个小代码向您展示:

#![feature(test)]

extern crate test;

fn main() {
}

pub fn s(box_id: usize, block: u64) -> u64 {
    const TABLES: [[[u64; 16]; 4]; 8] =
        [[[ 14,  4, 13, 1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9, 0, 7]
        , [  0, 15,  7, 4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5, 3, 8]
        , …

我正在尝试为宏创建一个包装器.麻烦的是我不想在两个宏中重复相同的规则.有没有办法做到这一点？

这是我尝试过的:

macro_rules! inner {
    ($test:ident) => { stringify!($test) };
    ($test:ident.run()) => { format!("{}.run()", stringify!($test)) };
}

macro_rules! outer {
    ($expression:expr) => {
        println!("{}", inner!($expression));
    }
}

fn main() {
    println!("{}", inner!(test));
    println!("{}", inner!(test.run()));
    outer!(test);
    outer!(test.run());
}

但是我收到以下错误:

src/main.rs:8:31: 8:42 error: expected ident, found test
src/main.rs:8         println!("{}", inner!($expression));
                                            ^~~~~~~~~~~

如果我outer为此更改宏,代码编译:

macro_rules! outer {
    ($expression:expr) => {
        println!("{}", stringify!($expression));
    }
}

我究竟做错了什么？

我能够将结构更新语法与单个结构一起使用，但我无法将它与类似结构的枚举变体一起使用。我也不能使用点语法从类似结构的枚举变体更新字段。

例如：

enum Enum {
    Struct {
        field1: i32,
        field2: i32,
    }
}

fn main() {
    let mut my_enum = Enum::Struct {
        field1: 1,
        field2: 2,
    };

    my_enum = Enum::Struct {
        field1: 1,
        .. my_enum
    };

    my_enum = match my_enum {
        strct@Enum::Struct { field1, field2 } => Enum::Struct {
            field1: 1,
            .. strct
        },
    };
}

两种方式都给我一个错误：

functional record update syntax requires a struct

这段代码：

my_enum.field1 = 3;

给了我以下错误：

attempted access of field `field1` on type `Enum`, but no field …

我开始使用clippy作为linter.有时,它会显示此警告:

writing `&Vec<_>` instead of `&[_]` involves one more reference and cannot be
used with non-Vec-based slices. Consider changing the type to `&[...]`,
#[warn(ptr_arg)] on by default

我将参数更改为切片,但这会在调用端添加样板.例如,代码是:

let names = args.arguments.iter().map(|arg| {
    arg.name.clone()
}).collect();
function(&names);

但现在是:

let names = args.arguments.iter().map(|arg| {
    arg.name.clone()
}).collect::<Vec<_>>();
function(&names);

否则,我收到以下错误:

error: the trait `core::marker::Sized` is not implemented for the type
`[collections::string::String]` [E0277]

所以我想知道是否有办法将a转换Iterator为a slice或避免collect在这种特定情况下必须指定ed类型.

我有以下 LLVM 代码的问题：

    %0 = load i64* %u
    %1 = load i64* %l
    %2 = icmp sgt i64 %1, %1
    br i1 %2, label %L1, label %L2
L2:
    ret void
    br label %L1
L1:

    %3 = load i64* %l
    %4 = sub i64 %3, 1
    store i64 %4, i64* %i

运行时llc，我收到以下错误：

error: instruction expected to be numbered '%4'
%3 = load i64* %l

但我不明白为什么它应该%4在%2. %2和之间没有返回结果的指令%4。

我需要理解这一点，因为我正在编写一个 LLVM 代码生成器。

那么为什么%3在这里使用会出错呢？

我想知道为什么相同的JavaScript代码在FireFox附加组件(使用附加SDK)中比在FireFox中加载的网页中直接运行要慢得多.

例如,这段代码:

function isPrime(number) {
    var i,
        prime = true;
    for(i = 2 ; i < number ; ++i) {
        if(number % i === 0) {
            prime = false;
        }
    }
    return prime;
}

function sumFirstPrimeNumbers(x) {
    var i,
        sum = 0;
    for(i = 1 ; i <= x ; ++i) {
        if(isPrime(i)) {
            sum += i;
        }
    }
    return sum;
}

var sum = sumFirstPrimeNumbers(15000);

console.log(sum);

在FireFox中打开的网页中运行时间不到2秒,但在FireFox附加组件中运行大约需要15秒.

我知道代码可能会更好,但它只是一个示例来说明它有多慢.

为什么FireFox附加组件会变慢？

有没有办法让它更快(不改变这个代码,因为它,如上所述,只是一个例子)？

更新:

它似乎与Add-on SDK有关.我做了另一个测试:我在附加组件中执行相同的代码,该附加组件不使用附加组件SDK,代码在大约3秒内执行.

为什么使用附加SDK的附加组件和不使用它的附加组件之间存在如此巨大的差异(3秒vs 15秒)？