说起来，

这篇文章根据原英文博客 Small strings in Rust 完整翻译

起因

这篇文章源于一条推文：

作者接受了这个邀约。但按自己的规则来：

• 只对比前两个，不搞“可能还有其他”。
• 允许至少三次题外话。

事不宜迟，先建一个新项目：

$ cargo new small
Created binary `small` package

项目脚手架

这个小项目会不断 所以先搭好框架。使用 argh 来解析命令行参数：

$ cargo add argh
Adding argh v0.1.8 to dependencies

设置子命令结构。目前只有一个叫 sample 的子命令，放进独立模块：

// src/main.rs
pub mod sample;use argh::FromArgs;#
/// Small string demo args
pub struct Args {
#
subcommand: Subcommand,}
#
#
enum Subcommand {
Sample。}
impl Subcommand {
fn run {
match self {
Subcommand::Sample => x.run,}
}
}
fn main {
至于argh:，from_env::.subcommand.run;}

// src/sample.rs
use argh::FromArgs;#
/// Run sample code
#
pub struct Sample {}
impl Sample {
pub fn run {
todo!}
}

说到跑一下，

$ cargo run -- sample
Finished dev target in 0.02s
Running `target/debug/small sample`
thread 'main' panicked at 'not yet implemented'。src/sample.rs:5:9
note的观点是，run with `RUST_BACKTRACE=1` environment variable to display a backtrace

框架搭好了目前为止一切正常。

解析 JSON 数据集

痛点：手动读取、过滤大量字段非常繁琐且易出错。

再看今天的任务是，从 JSON 文件里解析出美国最大的 100 个城市的列表。

使用 serde 和 serde_json这件事变得比较简单：

# Cargo.toml
argh = "0.1"
serde = { version = "1.0",features = }
serde_json = "1.0"

数据集里包含很多信息：人口增长、地理坐标、人口数量、排名等。我们只关心城市名和州名：

// src/sample.rs
impl Sample {
pub fn run {
self.read_records;}
fn read_records {
use serde::Deserialize;#
struct Record {
#
说到city，String。#
state这方面，String,}
use std::fs::File;let f = File::open.unwrap;let records: Vec = serde_json::from_reader.unwrap;println，);}
}

$ cargo run -- sample
Read 100 records

顺利。

追踪内存分配

痛点：不知道代码到底用了多少堆内存，哪儿出现了频繁分配导致卡顿。

接下来要关注的是：程序用了多少内存，还有发生了多少次分配和释放。

不用 Valgrind 的 Massif，而是自己写一个追踪分配器.

至于第一步先。包装程序分配器

// src/alloc.rs
use std::alloc::{GlobalAlloc,System};不过，pub struct Tracing {
pub inner: System。}
impl Tracing {
pub const fn new -> Self {
Self { inner: System }
}
}
unsafe impl GlobalAlloc for Tracing {
unsafe fn alloc -> *mut u8 {
self.inner.alloc
}
unsafe fn dealloc {
self.inner.dealloc
}
}

这里用到的是 Rust stable，没有任何不稳定特性。

接下来让程序使用这个自定义分配器：

// src/main.rs
#
pub static ALLOCATOR: alloc::Tracing = alloc::Tracing::new;

$ cargo run -- sample
Read 100 records

从接下来来看。让分配器说点有用的话

A. 直接使用 : 会导致死锁，因为标准输出内部会 触发内存分配。

unsafe impl GlobalAlloc for Tracing {
unsafe fn alloc -> *mut u8 {
println!)，self.inner.alloc
}
}

$ cargo run -- sample # 程序卡住…^C # 按 Ctrl+C 强制退出
程序卡死了无论是 debug 还是 release 都一样。卡在哪里，卡在尝试获取 stdout 的锁 . *mut u8 {
// 字面量，不涉及堆分配
let s = b"allocating!"，libc::write as _,s.len as _);self.inner.alloc
}
}
但只打印 “allocating!” 信息量太少，于是继续改进。其实，

：输出结构化的 JSON 事件 

Aim的观点是。每一次 alloc/dealloc 都向 stderr 写入一条 JSON 对象，便于后续分析。
rust
// src/alloc.rs
use serde::{Deserialize,Serialize};怎么说呢，pub enum Event{
Alloc{ addr : usize,size : usize },Freed{ addr : usize。size : usize },}
rust
impl Tracing{
fn write_ev{
let mut buf =;let mut cursor = std :: io :: Cursor ::new;serde_json ::to_writer .unwrap;let end = cursor.position as usize;self.write，self.write;}
fn write{
unsafe{
libc ::write as _,s .len as _);}
}
}
在 `alloc` 与 `dealloc` 中加入事件记录：
rust
unsafe impl GlobalAlloc for Tracing{
unsafe fn alloc-> *mut u8{
let res=self.inner.alloc;self.write_ev});res
}
unsafe fn dealloc{
self.write_ev});self.inner.dealloc;不过，}
}
运行时把 stderr 重定向到文件：
bash
$ cargo build && ./target/debug/small sample>!events.ldjson
$ head -n 5 events.ldjson
{"Alloc":{"addr":140732784800640。"size":1024}}
{"Alloc":{"addr":140732784801664,"size":2048}}
{"Freed":{"addr":140732784800640,"size":1024}}…

再看第四步。添加开关 

Avoid recording allocations that happen during command‑line parsing or or warm‑up phases.
rust
// src/alloc.rs
use std :: sync :: atomic::{AtomicBool,Ordering};按理说，pub struct Tracing{
pub inner:System,pub active:AtomicBool,}
impl Tracing{
pub const fn new->Self{
Self{inner:System。active:AtomicBool::new}
}
pub fn set_active{
self.active.store;}
}
在 `GlobalAlloc` 实现里只在激活状态下写入事件：
rust
unsafe impl GlobalAlloc for Tracing{
unsafe fn alloc->*mut u8{
let res=self.inner.alloc;if self.active.load{
self.write_ev});}
res
}
unsafe fn dealloc{
if self.active.load{
self.write_ev});}
self.inner.dealloc;}
}
在读取 JSON 前后打开/关闭记录：
rust
// src/sample.rs
let f = File::open.unwrap;
crate::ALLOCATOR.set_active;按理说，let records: Vec = serde_json::from_reader.unwrap;crate::ALLOCATOR.set_active;println，);现在可以使用专门的 **report** 子命令来分析事件文件。

report  子命令 
rust
// src/main.rs
pub mod report;enum Subcommand{
Sample,Report,}
impl Subcommand{
fn run{
match self{
Subcommand::Sample=>x.run,Subcommand::Report=>x.run。}
}
}
报告工具需求清单：


统计峰值内存用量 

统计总分配次数和释放次数 

以 B、KiB 等单位格式化大小 

画出内存随时间变化的折线图 

依赖两款辅助库：
bash
$ cargo add bytesize
Adding bytesize v1.10 to dependencies
$ cargo add textplots
Adding textplots v0.8 to dependencies
**为什么先把事件写文件，再用另一个子命令分析？**
因为在全局分配器内部收集事件到内存极其困难——需要提前准备固定大小缓冲区并自行加锁，而之前已经踩过 “println!卡死” 的坑，拆成两步虽然稍显麻烦，却让实现保持简洁可靠。完整实现这方面，rust
// src/report.rs
use crate::alloc::{Event};use argh::FromArgs;use bytesize ::ByteSize;use std::{fs ::File,io::{BufRead。BufReader},path ::PathBuf};use textplots::{Chart,Plot,Shape};/// Analyze report
pub struct Report{
#
再看path。PathBuf,}
trait Delta{
fn delta->isize;}
impl Delta for Event{
fn delta->isize{
match self{
Event:这方面，Alloc{size,..}=> size as isize。Event::Freed{size,..}=> -,}
}
}
impl Report{
pub fn run{
let f=BufReader::new.unwrap);let mut events=Vec::::new;
 for line in f.lines{
let line=line.unwrap;let ev:Event=serde_json ::from_str.unwrap;不过，events.push;怎么说呢，}
println!)，// statistics ---------------------------------------------------------
let mut points=Vec::<>::new;let mut curr_bytes:isize=0;let mut peak_bytes:isize=0;let mut alloc_events=0usize;老实说，let mut alloc_bytes=0usize;let mut freed_events=0usize;let mut freed_bytes=0usize;for in events.iter.enumerate{
curr_bytes+=ev.delta;points.push);if peak_bytes{
alloc_events+=1;alloc_bytes+=*size;},Event::_Freed{size。..}=>{
freed_events+=1;freed_bytes+=*size;},}
}
// draw simple ascii chart -------------------------------------------
Chart:的观点是。new as f32)
.lineplot)
.nice;// print summary ------------------------------------------------------
println!)，不过，println!)，println!，println!，println!)，println!，println!，println!)，说起来，}


}


从运行基准线来看。

bash 

$ cargo build && ./target/debug/small sample>!其实，events.ldjson \
&& ./target/debug/small report events.ldjson
Read 100 records
found 20000 events
total events | 20000
peak bytes | 123 KiB
...


从折线图可以明显看到 Vec 扩容时产生的尖峰 —— 每次容量翻倍都会临时占用两倍甚至更多的堆空间。

尽量减少内存分配 


最快的代码，是根本不执行的代码。少一次 allocation。就少一次 allocator 开销，性能自然提高。

如果输入文件不是很大，可以一次性读入全部字节。接下来让 serde **借用** 而不是复制为 `String`。按理说，

这种做法把总 allocation 次数压到几乎最低。但代价是必须保证源缓冲区在整个生命周期内保持有效。怎么说呢，

对于 GB 级别的大文件，这种“一口气读入”显然不可行。只能回到流式方案，并借助小字符串类型来降低每条记录的 allocation 开销。


再看示例代码，

rust 

// src/sample.rs 

fn read_records{
use serde::{Deserialize};
#
struct Record<'a>{
#
# // 告诉 serde 借用而不是复制
从city来看。&'a str,#
说到state，&'a str,}
crate:这方面，ALLOCATOR.set_active;// 一次性读进内存，接下来借用切片进行反序列化。

let input = std ::fs ::readtostring.unwrap;let records: Vec;records = serde_json  ​  ​ ​ ​ ​​ ​ ​ ​⟦​⟧⁇ ​ ​​‍​​​⁦⟧ ​​ ​​ ‌​​‍⁤⟦⟧​​​‍‌⁢​‌⁣?，

再看crate:，