This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9860

rust: replace Node::encode_hex with std::fmt::LowerHex
ClosedPublic

Authored by SimonSapin on Jan 25 2021, 4:12 PM.

Details

Reviewers
pulkit
Alphare
Group Reviewers
hg-reviewers
Commits
rHG6380efb82191: rust: replace Node::encode_hex with std::fmt::LowerHex
Summary

This avoids allocating intermediate strings.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Jan 25 2021, 4:12 PM
pulkit accepted this revision.Jan 27 2021, 5:34 AM
This revision is now accepted and ready to land.Jan 27 2021, 5:34 AM
SimonSapin updated this revision to Diff 25348.Jan 28 2021, 2:38 PM
Alphare accepted this revision.Jan 29 2021, 6:32 AM

Revision Contents
Changeset List

Diff 25242

rust/hg-core/examples/nodemap/main.rs

index index
.node((rng.gen::<u32>() % len) as Revision) .node((rng.gen::<u32>() % len) as Revision)
.unwrap() .unwrap()
.clone() .clone()
}) })
.collect(); .collect();
if queries < 10 { if queries < 10 {
let nodes_hex: Vec<String> = let nodes_hex: Vec<String> =
nodes.iter().map(|n| n.encode_hex()).collect(); nodes.iter().map(|n| format!("{:x}", n)).collect();
println!("Nodes: {:?}", nodes_hex); println!("Nodes: {:?}", nodes_hex);
} }
let mut last: Option<Revision> = None; let mut last: Option<Revision> = None;
let start = Instant::now(); let start = Instant::now();
for node in nodes.iter() { for node in nodes.iter() {
last = nm.find_bin(index, node.into()).unwrap(); last = nm.find_bin(index, node.into()).unwrap();
} }
let elapsed = start.elapsed(); let elapsed = start.elapsed();
println!( println!(
"Did {} queries in {:?} (mean {:?}), last was {:?} with result {:?}", "Did {} queries in {:?} (mean {:?}), last was {:x} with result {:?}",
queries, queries,
elapsed, elapsed,
elapsed / (queries as u32), elapsed / (queries as u32),
nodes.last().unwrap().encode_hex(), nodes.last().unwrap(),
last last
); );
} }
fn main() { fn main() {
let matches = App::new("Nodemap pure Rust example") let matches = App::new("Nodemap pure Rust example")
.arg( .arg(
Arg::with_name("REPOSITORY") Arg::with_name("REPOSITORY")

rust/hg-core/src/revlog/node.rs

// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Definitions and utilities for Revision nodes //! Definitions and utilities for Revision nodes
//! //!
//! In Mercurial code base, it is customary to call "a node" the binary SHA //! In Mercurial code base, it is customary to call "a node" the binary SHA
//! of a revision. //! of a revision.
use hex::{self, FromHex, FromHexError}; use hex::{self, FromHex, FromHexError};
use std::convert::{TryFrom, TryInto}; use std::convert::{TryFrom, TryInto};
use std::fmt;
/// The length in bytes of a `Node` /// The length in bytes of a `Node`
/// ///
/// This constant is meant to ease refactors of this module, and /// This constant is meant to ease refactors of this module, and
/// are private so that calling code does not expect all nodes have /// are private so that calling code does not expect all nodes have
/// the same size, should we support several formats concurrently in /// the same size, should we support several formats concurrently in
/// the future. /// the future.
pub const NODE_BYTES_LENGTH: usize = 20; pub const NODE_BYTES_LENGTH: usize = 20;
fn try_from(bytes: &'a [u8]) -> Result<&'a Node, Self::Error> { fn try_from(bytes: &'a [u8]) -> Result<&'a Node, Self::Error> {
let data = bytes.try_into()?; let data = bytes.try_into()?;
// Safety: `#[repr(transparent)]` makes it ok to "wrap" the target // Safety: `#[repr(transparent)]` makes it ok to "wrap" the target
// of a reference to the type of the single field. // of a reference to the type of the single field.
Ok(unsafe { std::mem::transmute::<&NodeData, &Node>(data) }) Ok(unsafe { std::mem::transmute::<&NodeData, &Node>(data) })
} }
} }
impl fmt::LowerHex for Node {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for &byte in &self.data {
write!(f, "{:02x}", byte)?
}
Ok(())
}
}
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum NodeError { pub enum NodeError {
ExactLengthRequired(usize, String), ExactLengthRequired(usize, String),
PrefixTooLong(String), PrefixTooLong(String),
HexError(FromHexError, String), HexError(FromHexError, String),
} }
/// Low level utility function, also for prefixes /// Low level utility function, also for prefixes
/// To be used in FFI and I/O only, in order to facilitate future /// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format. /// changes of hash format.
pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> { pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Node, NodeError> {
Ok(NodeData::from_hex(hex.as_ref()) Ok(NodeData::from_hex(hex.as_ref())
.map_err(|e| NodeError::from((e, hex)))? .map_err(|e| NodeError::from((e, hex)))?
.into()) .into())
} }
/// Convert to hexadecimal string representation
///
/// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format.
pub fn encode_hex(&self) -> String {
hex::encode(self.data)
}
/// Provide access to binary data /// Provide access to binary data
/// ///
/// This is needed by FFI layers, for instance to return expected /// This is needed by FFI layers, for instance to return expected
/// binary values to Python. /// binary values to Python.
pub fn as_bytes(&self) -> &[u8] { pub fn as_bytes(&self) -> &[u8] {
&self.data &self.data
} }
} }
FromHexError::InvalidHexCharacter { c: '.', index: 3 }, FromHexError::InvalidHexCharacter { c: '.', index: 3 },
not_hex, not_hex,
)), )),
); );
} }
#[test] #[test]
fn test_node_encode_hex() { fn test_node_encode_hex() {
assert_eq!(sample_node().encode_hex(), sample_node_hex()); assert_eq!(format!("{:x}", sample_node()), sample_node_hex());
} }
#[test] #[test]
fn test_prefix_from_hex() -> Result<(), NodeError> { fn test_prefix_from_hex() -> Result<(), NodeError> {
assert_eq!( assert_eq!(
NodePrefix::from_hex("0e1")?, NodePrefix::from_hex("0e1")?,
NodePrefix { NodePrefix {
buf: vec![14, 16], buf: vec![14, 16],
fn test_prefix_from_hex_errors() { fn test_prefix_from_hex_errors() {
assert_eq!( assert_eq!(
NodePrefix::from_hex("testgr"), NodePrefix::from_hex("testgr"),
Err(NodeError::HexError( Err(NodeError::HexError(
FromHexError::InvalidHexCharacter { c: 't', index: 0 }, FromHexError::InvalidHexCharacter { c: 't', index: 0 },
"testgr".to_string() "testgr".to_string()
)) ))
); );
let mut long = NULL_NODE.encode_hex(); let mut long = format!("{:x}", NULL_NODE);
long.push('c'); long.push('c');
match NodePrefix::from_hex(&long) match NodePrefix::from_hex(&long)
.expect_err("should be refused as too long") .expect_err("should be refused as too long")
{ {
NodeError::PrefixTooLong(s) => assert_eq!(s, long), NodeError::PrefixTooLong(s) => assert_eq!(s, long),
err => panic!(format!("Should have been TooLong, got {:?}", err)), err => panic!(format!("Should have been TooLong, got {:?}", err)),
} }
} }