Rust: 高性能序列化库Fury PK bincode

news2024/11/16 3:50:57

在序列化库中，传统的有Json,XML，性能好的有thrift，protobuf等。
对于二进制库来讲，据Fury官网的介绍，Fury性能要远远好于protobuf，且不象protobuf还需要定义IDL(即写.proto文件)，非常轻便，随取随用。
此外，bincode是rust的常见的二进制库，也是非常轻巧。今天来比较一下。

今天来尝试一下。

一、cargo.toml
找到对应github官网，地址如下：

https://github.com/apache/fury

1、Fury下载到本地
把对应rust对应文件部分内容（主要包括fury及fury-derive两个文件夹及内容）下载到本地。

(base) PS D:\rust_program> tree
卷 新加卷 的文件夹 PATH 列表
卷序列号为 6E25-CA92        
D:.
├─fury-project
│  └─src
└─rust
    ├─fury
    │  ├─src
    │  │  └─row
    │  └─tests
    ├─fury-derive
    │  └─src
    └─tests
        └─tests

目前Rust Fury库，还是初期，还是建议在github官网中，下载到本地。
其中，上面rust目录下的文件夹及内容，来自于github Fury项目。

2、toml文件，及Fury对应的Path

cargo.toml文件详细如下：

[package]
name = "fury-project"
version = "0.1.0"
edition = "2021"

[dependencies]
fury = { path = "../rust/fury" } # 对应于Fury项目
fury-derive = { path = "../rust/fury-derive" } # 对应于Fury-derive项目
lazy_static ="1.5" # Fury需要
bincode = {version = "1.3.3"} # bincode二进制库
serde ="1.x" # bincode库需要
serde_derive="1" # bincode库需要

在上面，fury,fury-derive，lazy_static对Fury库是必需的；bincode、serde和serde_derive对bincode库是必需的。

在这里插入图片描述
二、main.rs

main.rs如下：


use fury::{from_buffer, to_buffer, Fury};
use std::time::Instant;
use serde_derive::{Serialize,Deserialize};

#[derive(Serialize,Deserialize)]
#[derive(Fury,PartialEq,Debug)]
#[tag("bar.foo")]
struct Bar{
    code:String,
    date:String,
    open:f32,
    high:f32,
    close:f32,
    low:f32,
    volume:f32,
    amount:f32,
    is_fq:bool,
}

impl Bar{
    fn default() -> Bar{  
        Bar{
            code : String::from("600036.XSHG"),
            date : String::from("2021-01-05"),
            open: 19.95,
            high: 20.02,
            close: 19.99,
            low: 19.89,
            volume: 6900.0,
            amount: 6900.0 * 19.99,
            is_fq: false,
        }
    }
}

#[derive(Fury, Debug, PartialEq)]
#[tag("vec_bar.foo")]
struct VecBar{
    data: Vec<Bar>,
}
fn main() {
    let time0 = Instant::now();
    let bar1   = Bar::default();
    let bars1 : Vec<Bar>= vec![bar1];
    let vec_bars = VecBar{data:bars1};
    
    let binary_vec_bar: Vec<u8> = to_buffer(&vec_bars);
    println!("vec_bar serialize  cost time : {:?} seconds",time0.elapsed().as_secs_f32());
    let time1 = Instant::now();
    let vec_bar_obj: VecBar = from_buffer(&binary_vec_bar).expect("should success");
    println!("vec_bar deserialize  cost time : {:?} seconds",time1.elapsed().as_secs_f32());
    assert_eq!(vec_bars, vec_bar_obj);

    let time2 = Instant::now();
    let bars2 = vec![Bar::default() ]; 
    let binary_bars  = to_buffer(&bars2);
    println!("bars serialize  cost time : {:?} seconds",time2.elapsed().as_secs_f32());

    let time3 = Instant::now();
    let bars_obj: Vec<Bar> = from_buffer(&binary_bars).expect("should success");
    println!("bars deserialize  cost time : {:?} seconds",time3.elapsed().as_secs_f32());
    assert_eq!(bars2, bars_obj);
    // bincode 序列化

    let time4 = Instant::now();

    let bincode_encoded: Vec<u8> = bincode::serialize(&bars2).unwrap();
    println!("bars bincode serialize  cost time : {:?} seconds",time4.elapsed().as_secs_f32());
    let time5= Instant::now();
    
    let bincode_decoded: Vec<Bar> = bincode::deserialize(&bincode_encoded[..]).unwrap();
    println!("bars bincode deserialize  cost time : {:?} seconds",time5.elapsed().as_secs_f32());
    assert_eq!(bincode_decoded,bars2);
    // 比较序列化内容
    println!("bars2序列化内容比较：");
    println!("Fury库     binary ->: {:?}",binary_bars);
    println!("Fury库    binary len: {:?}",binary_bars.len());
    println!("bincode库  binary ->: {:?}",bincode_encoded);
    println!("bincode库 binary len: {:?}",bincode_encoded.len());

}

可以看出，Fury库序列化和反序列化和bincode一样的简洁！就是简单的一行代码。不象protobuf等一样，根本不需要写.proto文件，写build.rs。

三、输出

vec_bar serialize  cost time : 2.47e-5 seconds
vec_bar deserialize  cost time : 2.6e-5 seconds
bars serialize  cost time : 4.3e-6 seconds
bars deserialize  cost time : 2.3e-6 seconds
bars bincode serialize  cost time : 8e-7 seconds
bars bincode deserialize  cost time : 1.4e-6 seconds
bars2序列化内容比较：
Fury库     binary ->: [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 255, 25, 0, 1, 255, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 98, 97, 114, 46, 102, 111, 111, 118, 154, 59, 33, 255, 11, 0, 192, 178, 6, 72, 255, 11, 0, 133, 235, 159, 65, 255, 13, 0, 11, 54, 48, 48, 48, 51, 54, 46, 88, 83, 72, 71, 255, 13, 0, 10, 50, 48, 50, 49, 45, 48, 49, 45, 48, 53, 255, 11, 0, 246, 40, 160, 65, 255, 1, 0, 0, 255, 11, 0, 184, 30, 159, 65, 255, 11, 0, 154, 153, 159, 65, 255, 11, 0, 0, 160, 215, 69]
Fury库    binary len: 114
bincode库  binary ->: [1, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 54, 48, 48, 48, 51, 54, 46, 88, 83, 72, 71, 10, 0, 0, 0, 0, 0, 0, 0, 50, 48, 50, 49, 45, 48, 49, 45, 48, 53, 154, 153, 159, 65, 246, 40, 160, 65, 133, 235, 159, 65, 184, 30, 159, 65, 0, 160, 215, 69, 192, 178, 6, 72, 0]
bincode库 binary len: 70