Protobuf vs Bincode vs CBOR

serialize.rs

/*

test serialize_bincode_block  ... bench:   2,187,247 ns/iter (+/- 305,944)
test serialize_bincode_block2 ... bench:   2,214,480 ns/iter (+/- 359,709)
test serialize_bincode_tx     ... bench:       2,280 ns/iter (+/- 222)
test serialize_cbor_block     ... bench:   1,950,128 ns/iter (+/- 188,149)
test serialize_cbor_tx        ... bench:       2,182 ns/iter (+/- 334)
test serialize_proto_block    ... bench:   3,688,611 ns/iter (+/- 541,517)
test serialize_proto_tx       ... bench:       3,567 ns/iter (+/- 449)

*/


#[macro_use]
extern crate bencher;

use bencher::Bencher;

use near_protos::chain as chain_proto;
use near_protos::signed_transaction as transaction_proto;

use near_primitives::crypto::signature::{PublicKey, DEFAULT_SIGNATURE};
use near_primitives::transaction::{Action, SignedTransaction, Transaction, TransferAction};

use chrono::Utc;
use near_primitives::block::Block;
use near_primitives::crypto::signer::InMemorySigner;
use near_primitives::hash::CryptoHash;
use near_primitives::types::MerkleHash;
use protobuf::Message;
use std::collections::HashMap;
use std::sync::Arc;

fn create_transaction() -> SignedTransaction {
    let mut actions = vec![];
    for _ in 0..10 {
        actions.push(Action::Transfer(TransferAction { deposit: 1_000_000_000 }));
    }
    SignedTransaction::new(
        DEFAULT_SIGNATURE,
        Transaction {
            signer_id: "123213123123".to_string(),
            public_key: PublicKey::empty(),
            nonce: 123,
            receiver_id: "1231231232131".to_string(),
            actions,
        },
    )
}

fn create_block() -> Block {
    let transactions = (0..1000).map(|_| create_transaction()).collect::<Vec<_>>();
    let genesis = Block::genesis(MerkleHash::default(), Utc::now());
    let signer = Arc::new(InMemorySigner::from_random());
    Block::produce(
        &genesis.header,
        10,
        MerkleHash::default(),
        CryptoHash::default(),
        transactions,
        HashMap::default(),
        vec![],
        signer.clone(),
    )
}

fn serialize_proto_tx(bench: &mut Bencher) {
    let t = create_transaction();
    bench.iter(|| {
        let proto: transaction_proto::SignedTransaction = t.clone().into();
        let bytes = proto.write_to_bytes().unwrap();
        assert!(bytes.len() > 0);
    });
}

fn serialize_bincode_tx(bench: &mut Bencher) {
    let t = create_transaction();
    bench.iter(|| {
        let bytes = bincode::serialize(&t).unwrap();
        assert!(bytes.len() > 0);
    });
}

fn serialize_cbor_tx(bench: &mut Bencher) {
    let t = create_transaction();
    bench.iter(|| {
        let bytes = serde_cbor::to_vec(&t).unwrap();
        assert!(bytes.len() > 0);
    });
}

fn serialize_proto_block(bench: &mut Bencher) {
    let b = create_block();
    bench.iter(|| {
        let proto: chain_proto::Block = b.clone().into();
        let bytes = proto.write_to_bytes().unwrap();
        assert!(bytes.len() > 0);
    });
}

fn serialize_bincode_block(bench: &mut Bencher) {
    let b = create_block();
    bench.iter(|| {
        let bytes = bincode::serialize(&b).unwrap();
        assert!(bytes.len() > 0);
    });
}

fn serialize_cbor_block(bench: &mut Bencher) {
    let b = create_block();
    bench.iter(|| {
        let bytes = serde_cbor::to_vec(&b).unwrap();
        assert!(bytes.len() > 0);
    });
}

benchmark_group!(
    benches,
    serialize_proto_tx,
    serialize_bincode_tx,
    serialize_cbor_tx,
    serialize_proto_block,
    serialize_bincode_block,
    serialize_cbor_block
);
benchmark_main!(benches);