Skip to content
This repository has been archived by the owner on Nov 15, 2023. It is now read-only.

chore: reduce copy times for bytes in core-hashing #13519

Merged
merged 6 commits into from
Mar 6, 2023
Merged

chore: reduce copy times for bytes in core-hashing #13519

Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
2b4cece
chore: reduce copy bytes for core-hashing
yjhmelody Mar 3, 2023
58ad855
improve by suggestions and remove unused `xx_into`
yjhmelody Mar 3, 2023
da00eef
chore: replace sha2 crate by `sp_core::hashing` for pallet-alliance
yjhmelody Mar 3, 2023
10e9e0c
fix features
yjhmelody Mar 3, 2023
7c0a91c
use sp-core-hashing directly
yjhmelody Mar 3, 2023
f8bfbbb
add to dev-dep
yjhmelody Mar 3, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
51 changes: 27 additions & 24 deletions primitives/core/hashing/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,48 +35,51 @@ pub fn blake2_512_into(data: &[u8], dest: &mut [u8; 64]) {

/// Do a Blake2 512-bit hash and return result.
pub fn blake2_512(data: &[u8]) -> [u8; 64] {
let mut r = [0; 64];
blake2_512_into(data, &mut r);
r
let mut h = blake2::Blake2b512::new();
h.update(data);
h.finalize().into()
}

type Blake2b256 = blake2::Blake2b<U32>;

/// Do a Blake2 256-bit hash and place result in `dest`.
pub fn blake2_256_into(data: &[u8], dest: &mut [u8; 32]) {
type Blake2b256 = blake2::Blake2b<U32>;
dest.copy_from_slice(Blake2b256::digest(data).as_slice());
}

/// Do a Blake2 256-bit hash and return result.
pub fn blake2_256(data: &[u8]) -> [u8; 32] {
let mut r = [0; 32];
blake2_256_into(data, &mut r);
r
let mut h = Blake2b256::new();
h.update(data);
h.finalize().into()
}

type Blake2b128 = blake2::Blake2b<U16>;

/// Do a Blake2 128-bit hash and place result in `dest`.
pub fn blake2_128_into(data: &[u8], dest: &mut [u8; 16]) {
type Blake2b128 = blake2::Blake2b<U16>;
dest.copy_from_slice(Blake2b128::digest(data).as_slice());
}

/// Do a Blake2 128-bit hash and return result.
pub fn blake2_128(data: &[u8]) -> [u8; 16] {
let mut r = [0; 16];
blake2_128_into(data, &mut r);
r
let mut h = Blake2b128::new();
h.update(data);
h.finalize().into()
yjhmelody marked this conversation as resolved.
Show resolved Hide resolved
}

type Blake2b64 = blake2::Blake2b<U8>;

/// Do a Blake2 64-bit hash and place result in `dest`.
pub fn blake2_64_into(data: &[u8], dest: &mut [u8; 8]) {
type Blake2b64 = blake2::Blake2b<U8>;
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Are the *_into(data, dest) family of functions relevant?
Looks like are not used anywere in the codebase and is some user requires something like that it can easily construct it

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Do you means that should I remove these xx_into functions?

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I usually tend to follow YAGNI principle.
But with that I'm not saying that should be a dogma.
I have the (maybe bad?!) attitude to remove unused code especially the trivial bloat that can be trivially implemented using a line of code by the user 😃

dest.copy_from_slice(Blake2b64::digest(data).as_slice());
}

/// Do a Blake2 64-bit hash and return result.
pub fn blake2_64(data: &[u8]) -> [u8; 8] {
let mut r = [0; 8];
blake2_64_into(data, &mut r);
r
let mut h = Blake2b64::new();
h.update(data);
h.finalize().into()
}

/// Do a XX 64-bit hash and place result in `dest`.
Expand Down Expand Up @@ -128,21 +131,21 @@ pub fn twox_256(data: &[u8]) -> [u8; 32] {

/// Do a keccak 256-bit hash and return result.
pub fn keccak_256(data: &[u8]) -> [u8; 32] {
let mut output = [0u8; 32];
output.copy_from_slice(sha3::Keccak256::digest(data).as_slice());
output
let mut h = sha3::Keccak256::new();
h.update(data);
h.finalize().into()
}

/// Do a keccak 512-bit hash and return result.
pub fn keccak_512(data: &[u8]) -> [u8; 64] {
let mut output = [0u8; 64];
output.copy_from_slice(sha3::Keccak512::digest(data).as_slice());
output
let mut h = sha3::Keccak512::new();
h.update(data);
h.finalize().into()
}

/// Do a sha2 256-bit hash and return result.
pub fn sha2_256(data: &[u8]) -> [u8; 32] {
let mut output = [0u8; 32];
output.copy_from_slice(sha2::Sha256::digest(data).as_slice());
output
let mut h = sha2::Sha256::new();
h.update(data);
h.finalize().into()
}