Início / user-9676875

Serdar Didan's questions

Martin Hope
Serdar Didan
Asked: 2025-04-16 07:35:01 +0800 CST
  • 6

Eu escrevo alguns pequenos programas que fazem a mesma coisa em diversas linguagens de programação. Comparo o desempenho e o consumo de RAM. Este é um dos programas que escrevi para teste.

Ambos os programas leem o mesmo arquivo. O arquivo contém dados concatenados com os caracteres \t(tab) e \n(enter). O conteúdo é semelhante ao seguinte.

aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh\n
aaaa\tbbb\tccc\tddd\teee\tfff\tggg\thhh

O arquivo que criei tem 14 colunas e 63 linhas. Esses números podem mudar. Isso não é importante, pois estou testando.

Obtenho as linhas com split('\n'). E obtenho os campos na linha com split('\t'). Uma desserialização bem simples. O programa lê o arquivo uma vez e o desserializa 200.000 vezes. Em seguida, imprime a hora no console.

Ir:

package main

import (
    "fmt"
    "os"
    "strings"
    "time"
)

type Datatable struct {
    id   int
    rows [][]string
}

func main() {
    start := time.Now()

    dat, err := os.ReadFile("C:\\Temp\\test1.txt")
    if err != nil {
        panic("file not found")
    }
    str := string(dat)

    count := 200_000
    tables := make([]Datatable, count)

    for i := 0; i < count; i++ {
        table := Datatable{i, nil}
        var lines []string = strings.Split(str, "\n")
        table.rows = make([][]string, len(lines))
        for j, l := range lines {
            table.rows[j] = strings.Split(l, "\t")
        }
        tables[i] = table
    }

    end := time.Now()
    elapsed := end.Sub(start)
    fmt.Println("Time: ", elapsed)

    var b []byte = make([]byte, 1)
    os.Stdin.Read(b)
}

Ferrugem:

use std::fs;
use std::time::SystemTime;
use std::io::{self, BufRead};

struct Table<'a>{
    id: usize,
    rows: Vec<Vec<&'a str>>,
}
fn main() {
    let start = SystemTime::now();
    let str = fs::read_to_string("C:\\Temp\\test1.txt")
        .expect("read_to_string: failed");

    let count = 200_000;
    let mut tables = Vec::with_capacity(count);
    for i in 0..count {
        let lines = str.split('\n');
        let mut table = Table {
            id : i,
            rows : Vec::with_capacity(lines.size_hint().0),
        };
        for item in lines {
            table.rows.push(item.split('\t').collect::<Vec<&str>>());
        }
        tables.push(table);
    }
    println!("Time: {}", start.elapsed().expect("elapsed: failed").as_millis());

    let mut line = String::new();
    let stdin = io::stdin();
    stdin.lock().read_line(&mut line).expect("read_line: failed");
}
  • vá versão go1.24.2 windows/amd64
  • rustc 1.85.1 (4eb161250 2025-03-15)
  • SO: Windows 11

Comandos de construção:

go build -ldflags "-s -w"
cargo build --release

Os resultados no meu computador são os seguintes:

Ir:

Time     : 4510 milis
RAM usage: 3217 MB

Ferrugem

Time     : 5845 milis
RAM usage: 3578 MB

Tentei escrever o código o mais simples possível. Você pode tentar copiando e colando.

O código Rust funciona. Mas é mais lento que o Go e consome mais RAM. Antes de escrever o código, eu esperava que o Rust fosse mais rápido. Talvez haja algo que eu não saiba.

Usar arrays em structs em Rust pode torná-lo mais rápido. Mas não tenho certeza se isso é possível. O que eu quero saber é como posso escrever esse código em Rust para torná-lo mais rápido?

arrays