Unverified Commit 03899db5 authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: allow key block without hash in SST files (#88938)

### What?

Change the SST format to allow a variable hash len.
For short keys avoid storing the hashes and recompute them on demand instead.
For short keys use bit rotation instead of a real hash.

This avoid wasting storage for hashes which can be cheaply recomputed
parent d5a88ba4
...@@ -85,7 +85,7 @@ The hashes are sorted. ...@@ -85,7 +85,7 @@ The hashes are sorted.
#### Key Block #### Key Block
- 1 byte block type (1: key block) - 1 byte block type (1: key block with hash, 2: key block without hash)
- 3 bytes entry count - 3 bytes entry count
- foreach entry - foreach entry
- 1 byte type - 1 byte type
...@@ -94,23 +94,30 @@ The hashes are sorted. ...@@ -94,23 +94,30 @@ The hashes are sorted.
A Key block contains n keys, which specify n key value pairs. A Key block contains n keys, which specify n key value pairs.
The block type determines whether the key hash is stored per entry:
- Block type 1 (with hash): Full 8-byte hash stored per entry
- Block type 2 (no hash): No hash stored (for keys ≤ 32 bytes)
During lookup, if block type is 2, the full hash is recomputed from the key data.
Depending on the `type` field entry has a different format: Depending on the `type` field entry has a different format:
- 0: normal key (small value) - 0: normal key (small value)
- 8 bytes key hash - 8 bytes key hash (if block type 1)
- key data - key data
- 2 byte block index - 2 byte block index
- 2 bytes size - 2 bytes size
- 4 bytes position in block - 4 bytes position in block
- 1: blob reference - 1: blob reference
- 8 bytes key hash - 8 bytes key hash (if block type 1)
- key data - key data
- 4 bytes sequence number - 4 bytes sequence number
- 2: deleted key / tombstone (no data) - 2: deleted key / tombstone (no data)
- 8 bytes key hash - 8 bytes key hash (if block type 1)
- key data - key data
- 3: normal key (medium sized value) - 3: normal key (medium sized value)
- 8 bytes key hash - 8 bytes key hash (if block type 1)
- key data - key data
- 2 byte block index - 2 byte block index
- 7: merge key (future) - 7: merge key (future)
...@@ -119,14 +126,12 @@ Depending on the `type` field entry has a different format: ...@@ -119,14 +126,12 @@ Depending on the `type` field entry has a different format:
- 3 bytes size - 3 bytes size
- 4 bytes position in block - 4 bytes position in block
- 8..255: inlined key (future) - 8..255: inlined key (future)
- 8 bytes key hash - 8 bytes key hash (if block type 1)
- key data - key data
- type - 8 bytes value data - type - 8 bytes value data
The entries are sorted by key hash and key. The entries are sorted by key hash and key.
TODO: 8 bytes key hash is a bit inefficient for small keys.
#### Value Block #### Value Block
- no header, all bytes are data referenced by other blocks - no header, all bytes are data referenced by other blocks
......
...@@ -21,8 +21,10 @@ use crate::{ ...@@ -21,8 +21,10 @@ use crate::{
/// The block header for an index block. /// The block header for an index block.
pub const BLOCK_TYPE_INDEX: u8 = 0; pub const BLOCK_TYPE_INDEX: u8 = 0;
/// The block header for a key block. /// The block header for a key block with 8-byte hash per entry.
pub const BLOCK_TYPE_KEY: u8 = 1; pub const BLOCK_TYPE_KEY_WITH_HASH: u8 = 1;
/// The block header for a key block without hash.
pub const BLOCK_TYPE_KEY_NO_HASH: u8 = 2;
/// The tag for a small-sized value. /// The tag for a small-sized value.
pub const KEY_BLOCK_ENTRY_TYPE_SMALL: u8 = 0; pub const KEY_BLOCK_ENTRY_TYPE_SMALL: u8 = 0;
...@@ -152,8 +154,15 @@ impl StaticSortedFile { ...@@ -152,8 +154,15 @@ impl StaticSortedFile {
BLOCK_TYPE_INDEX => { BLOCK_TYPE_INDEX => {
current_block = self.lookup_index_block(block, key_hash)?; current_block = self.lookup_index_block(block, key_hash)?;
} }
BLOCK_TYPE_KEY => { BLOCK_TYPE_KEY_WITH_HASH | BLOCK_TYPE_KEY_NO_HASH => {
return self.lookup_key_block(block, key_hash, key, value_block_cache); let has_hash = block_type == BLOCK_TYPE_KEY_WITH_HASH;
return self.lookup_key_block(
block,
key_hash,
key,
has_hash,
value_block_cache,
);
} }
_ => { _ => {
bail!("Invalid block type"); bail!("Invalid block type");
...@@ -214,8 +223,10 @@ impl StaticSortedFile { ...@@ -214,8 +223,10 @@ impl StaticSortedFile {
mut block: &[u8], mut block: &[u8],
key_hash: u64, key_hash: u64,
key: &K, key: &K,
has_hash: bool,
value_block_cache: &BlockCache, value_block_cache: &BlockCache,
) -> Result<SstLookupResult> { ) -> Result<SstLookupResult> {
let hash_len: u8 = if has_hash { 8 } else { 0 };
let entry_count = block.read_u24::<BE>()? as usize; let entry_count = block.read_u24::<BE>()? as usize;
let offsets = &block[..entry_count * 4]; let offsets = &block[..entry_count * 4];
let entries = &block[entry_count * 4..]; let entries = &block[entry_count * 4..];
...@@ -230,8 +241,11 @@ impl StaticSortedFile { ...@@ -230,8 +241,11 @@ impl StaticSortedFile {
key: mid_key, key: mid_key,
ty, ty,
val: mid_val, val: mid_val,
} = get_key_entry(offsets, entries, entry_count, m)?; } = get_key_entry(offsets, entries, entry_count, m, hash_len)?;
match key_hash.cmp(&mid_hash).then_with(|| key.cmp(mid_key)) {
let comparison = compare_hash_key(mid_hash, mid_key, key_hash, key);
match comparison {
Ordering::Less => { Ordering::Less => {
r = m; r = m;
} }
...@@ -429,6 +443,7 @@ struct CurrentKeyBlock { ...@@ -429,6 +443,7 @@ struct CurrentKeyBlock {
entries: ArcSlice<u8>, entries: ArcSlice<u8>,
entry_count: usize, entry_count: usize,
index: usize, index: usize,
hash_len: u8,
} }
struct CurrentIndexBlock { struct CurrentIndexBlock {
...@@ -461,7 +476,9 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -461,7 +476,9 @@ impl<'l> StaticSortedFileIter<'l> {
index: 0, index: 0,
}); });
} }
BLOCK_TYPE_KEY => { BLOCK_TYPE_KEY_WITH_HASH | BLOCK_TYPE_KEY_NO_HASH => {
let has_hash = block_type == BLOCK_TYPE_KEY_WITH_HASH;
let hash_len = if has_hash { 8 } else { 0 };
let entry_count = block.read_u24::<BE>()? as usize; let entry_count = block.read_u24::<BE>()? as usize;
let offsets_range = 4..4 + entry_count * 4; let offsets_range = 4..4 + entry_count * 4;
let entries_range = 4 + entry_count * 4..block_arc.len(); let entries_range = 4 + entry_count * 4..block_arc.len();
...@@ -472,6 +489,7 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -472,6 +489,7 @@ impl<'l> StaticSortedFileIter<'l> {
entries, entries,
entry_count, entry_count,
index: 0, index: 0,
hash_len,
}); });
} }
_ => { _ => {
...@@ -489,10 +507,17 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -489,10 +507,17 @@ impl<'l> StaticSortedFileIter<'l> {
entries, entries,
entry_count, entry_count,
index, index,
hash_len,
}) = self.current_key_block.take() }) = self.current_key_block.take()
{ {
let GetKeyEntryResult { hash, key, ty, val } = let GetKeyEntryResult { hash, key, ty, val } =
get_key_entry(&offsets, &entries, entry_count, index)?; get_key_entry(&offsets, &entries, entry_count, index, hash_len)?;
// Convert hash slice to u64, computing from key if no hash stored
let full_hash = if hash.is_empty() {
crate::key::hash_key(&key)
} else {
u64::from_be_bytes(hash.try_into().unwrap())
};
let value = if ty == KEY_BLOCK_ENTRY_TYPE_MEDIUM { let value = if ty == KEY_BLOCK_ENTRY_TYPE_MEDIUM {
let mut val = val; let mut val = val;
let block = val.read_u16::<BE>()?; let block = val.read_u16::<BE>()?;
...@@ -508,7 +533,7 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -508,7 +533,7 @@ impl<'l> StaticSortedFileIter<'l> {
LazyLookupValue::Eager(value) LazyLookupValue::Eager(value)
}; };
let entry = LookupEntry { let entry = LookupEntry {
hash, hash: full_hash,
// Safety: The key is a valid slice of the entries. // Safety: The key is a valid slice of the entries.
key: unsafe { ArcSlice::new_unchecked(key, ArcSlice::full_arc(&entries)) }, key: unsafe { ArcSlice::new_unchecked(key, ArcSlice::full_arc(&entries)) },
value, value,
...@@ -519,6 +544,7 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -519,6 +544,7 @@ impl<'l> StaticSortedFileIter<'l> {
entries, entries,
entry_count, entry_count,
index: index + 1, index: index + 1,
hash_len,
}); });
} }
return Ok(Some(entry)); return Ok(Some(entry));
...@@ -546,19 +572,47 @@ impl<'l> StaticSortedFileIter<'l> { ...@@ -546,19 +572,47 @@ impl<'l> StaticSortedFileIter<'l> {
} }
struct GetKeyEntryResult<'l> { struct GetKeyEntryResult<'l> {
hash: u64, hash: &'l [u8],
key: &'l [u8], key: &'l [u8],
ty: u8, ty: u8,
val: &'l [u8], val: &'l [u8],
} }
/// Compares a query (full_hash + query_key) against an entry (entry_hash + entry_key).
/// Returns the ordering of query relative to entry.
/// When entry_hash is empty, computes full hash from entry_key.
fn compare_hash_key<K: QueryKey>(
entry_hash: &[u8],
entry_key: &[u8],
full_hash: u64,
query_key: &K,
) -> Ordering {
if entry_hash.is_empty() {
// No hash stored - compute full hash from entry key
let entry_full_hash = crate::key::hash_key(&entry_key);
match full_hash.cmp(&entry_full_hash) {
Ordering::Equal => query_key.cmp(entry_key),
ord => ord,
}
} else {
// Full 8-byte hash stored - compare hashes first
let full_hash_bytes = full_hash.to_be_bytes();
match full_hash_bytes[..].cmp(entry_hash) {
Ordering::Equal => query_key.cmp(entry_key),
ord => ord,
}
}
}
/// Reads a key entry from a key block. /// Reads a key entry from a key block.
fn get_key_entry<'l>( fn get_key_entry<'l>(
offsets: &[u8], offsets: &[u8],
entries: &'l [u8], entries: &'l [u8],
entry_count: usize, entry_count: usize,
index: usize, index: usize,
hash_len: u8,
) -> Result<GetKeyEntryResult<'l>> { ) -> Result<GetKeyEntryResult<'l>> {
let hash_len_usize = hash_len as usize;
let mut offset = &offsets[index * 4..]; let mut offset = &offsets[index * 4..];
let ty = offset.read_u8()?; let ty = offset.read_u8()?;
let start = offset.read_u24::<BE>()? as usize; let start = offset.read_u24::<BE>()? as usize;
...@@ -567,29 +621,30 @@ fn get_key_entry<'l>( ...@@ -567,29 +621,30 @@ fn get_key_entry<'l>(
} else { } else {
(&offsets[(index + 1) * 4 + 1..]).read_u24::<BE>()? as usize (&offsets[(index + 1) * 4 + 1..]).read_u24::<BE>()? as usize
}; };
let hash = (&entries[start..start + 8]).read_u64::<BE>()?; // Return the raw hash bytes slice (0-8 bytes depending on hash_len)
let hash = &entries[start..start + hash_len_usize];
Ok(match ty { Ok(match ty {
KEY_BLOCK_ENTRY_TYPE_SMALL => GetKeyEntryResult { KEY_BLOCK_ENTRY_TYPE_SMALL => GetKeyEntryResult {
hash, hash,
key: &entries[start + 8..end - 8], key: &entries[start + hash_len_usize..end - 8],
ty, ty,
val: &entries[end - 8..end], val: &entries[end - 8..end],
}, },
KEY_BLOCK_ENTRY_TYPE_MEDIUM => GetKeyEntryResult { KEY_BLOCK_ENTRY_TYPE_MEDIUM => GetKeyEntryResult {
hash, hash,
key: &entries[start + 8..end - 2], key: &entries[start + hash_len_usize..end - 2],
ty, ty,
val: &entries[end - 2..end], val: &entries[end - 2..end],
}, },
KEY_BLOCK_ENTRY_TYPE_BLOB => GetKeyEntryResult { KEY_BLOCK_ENTRY_TYPE_BLOB => GetKeyEntryResult {
hash, hash,
key: &entries[start + 8..end - 4], key: &entries[start + hash_len_usize..end - 4],
ty, ty,
val: &entries[end - 4..end], val: &entries[end - 4..end],
}, },
KEY_BLOCK_ENTRY_TYPE_DELETED => GetKeyEntryResult { KEY_BLOCK_ENTRY_TYPE_DELETED => GetKeyEntryResult {
hash, hash,
key: &entries[start + 8..end], key: &entries[start + hash_len_usize..end],
ty, ty,
val: &[], val: &[],
}, },
......
...@@ -14,8 +14,9 @@ use crate::{ ...@@ -14,8 +14,9 @@ use crate::{
compression::compress_into_buffer, compression::compress_into_buffer,
meta_file::{AmqfBincodeWrapper, MetaEntryFlags}, meta_file::{AmqfBincodeWrapper, MetaEntryFlags},
static_sorted_file::{ static_sorted_file::{
BLOCK_TYPE_INDEX, BLOCK_TYPE_KEY, KEY_BLOCK_ENTRY_TYPE_BLOB, KEY_BLOCK_ENTRY_TYPE_DELETED, BLOCK_TYPE_INDEX, BLOCK_TYPE_KEY_NO_HASH, BLOCK_TYPE_KEY_WITH_HASH,
KEY_BLOCK_ENTRY_TYPE_MEDIUM, KEY_BLOCK_ENTRY_TYPE_SMALL, KEY_BLOCK_ENTRY_TYPE_BLOB, KEY_BLOCK_ENTRY_TYPE_DELETED, KEY_BLOCK_ENTRY_TYPE_MEDIUM,
KEY_BLOCK_ENTRY_TYPE_SMALL,
}, },
}; };
...@@ -45,6 +46,11 @@ const COMPRESSION_DICTIONARY_SAMPLE_PER_ENTRY: usize = 100; ...@@ -45,6 +46,11 @@ const COMPRESSION_DICTIONARY_SAMPLE_PER_ENTRY: usize = 100;
/// The minimum bytes that are used per key entry for a sample. /// The minimum bytes that are used per key entry for a sample.
const MIN_COMPRESSION_DICTIONARY_SAMPLE_PER_ENTRY: usize = 16; const MIN_COMPRESSION_DICTIONARY_SAMPLE_PER_ENTRY: usize = 16;
/// Determines whether to store the hash per entry based on max key length.
fn use_hash(max_key_len: usize) -> bool {
max_key_len > 32
}
/// Trait for entries from that SST files can be created /// Trait for entries from that SST files can be created
pub trait Entry { pub trait Entry {
/// Returns the hash of the key /// Returns the hash of the key
...@@ -431,9 +437,11 @@ fn write_key_blocks_and_compute_amqf( ...@@ -431,9 +437,11 @@ fn write_key_blocks_and_compute_amqf(
} }
let mut current_block_start = 0; let mut current_block_start = 0;
let mut current_block_size = 0; let mut current_block_size = 0;
let mut current_block_max_key_len = 0;
let mut last_hash = 0; let mut last_hash = 0;
for (i, entry) in entries.iter().enumerate() { for (i, entry) in entries.iter().enumerate() {
let key_hash = entry.key_hash(); let key_hash = entry.key_hash();
let key_len = entry.key_len();
// Add to AMQF // Add to AMQF
filter filter
...@@ -443,13 +451,15 @@ fn write_key_blocks_and_compute_amqf( ...@@ -443,13 +451,15 @@ fn write_key_blocks_and_compute_amqf(
// Accumulate until the block is full // Accumulate until the block is full
if current_block_size > 0 if current_block_size > 0
&& (current_block_size + entry.key_len() + KEY_BLOCK_ENTRY_META_OVERHEAD && (current_block_size + key_len + KEY_BLOCK_ENTRY_META_OVERHEAD
> MAX_KEY_BLOCK_SIZE > MAX_KEY_BLOCK_SIZE
|| i - current_block_start >= MAX_KEY_BLOCK_ENTRIES) && || i - current_block_start >= MAX_KEY_BLOCK_ENTRIES) &&
// avoid breaking the block in the middle of a hash conflict // avoid breaking the block in the middle of a hash conflict
last_hash != key_hash last_hash != key_hash
{ {
let mut block = KeyBlockBuilder::new(buffer, (i - current_block_start) as u32); let entry_count = i - current_block_start;
let has_hash = use_hash(current_block_max_key_len);
let mut block = KeyBlockBuilder::new(buffer, entry_count as u32, has_hash);
for j in current_block_start..i { for j in current_block_start..i {
let entry = &entries[j]; let entry = &entries[j];
let value_location = &value_locations[j]; let value_location = &value_locations[j];
...@@ -463,15 +473,19 @@ fn write_key_blocks_and_compute_amqf( ...@@ -463,15 +473,19 @@ fn write_key_blocks_and_compute_amqf(
writer.write_key_block(buffer, key_compression_dictionary)?; writer.write_key_block(buffer, key_compression_dictionary)?;
buffer.clear(); buffer.clear();
current_block_size = 0; current_block_size = 0;
current_block_max_key_len = 0;
current_block_start = i; current_block_start = i;
} }
current_block_size += entry.key_len() + KEY_BLOCK_ENTRY_META_OVERHEAD; current_block_size += entry.key_len() + KEY_BLOCK_ENTRY_META_OVERHEAD;
current_block_max_key_len = current_block_max_key_len.max(key_len);
last_hash = key_hash; last_hash = key_hash;
} }
// Finish the last block // Finish the last block
if current_block_size > 0 { if current_block_size > 0 {
let mut block = KeyBlockBuilder::new(buffer, (entries.len() - current_block_start) as u32); let entry_count = entries.len() - current_block_start;
let has_hash = use_hash(current_block_max_key_len);
let mut block = KeyBlockBuilder::new(buffer, entry_count as u32, has_hash);
for j in current_block_start..entries.len() { for j in current_block_start..entries.len() {
let entry = &entries[j]; let entry = &entries[j];
let value_location = &value_locations[j]; let value_location = &value_locations[j];
...@@ -510,20 +524,26 @@ fn write_key_blocks_and_compute_amqf( ...@@ -510,20 +524,26 @@ fn write_key_blocks_and_compute_amqf(
pub struct KeyBlockBuilder<'l> { pub struct KeyBlockBuilder<'l> {
current_entry: usize, current_entry: usize,
header_size: usize, header_size: usize,
has_hash: bool,
buffer: &'l mut Vec<u8>, buffer: &'l mut Vec<u8>,
} }
/// The size of the key block header. /// The size of the key block header (block type + entry count).
const KEY_BLOCK_HEADER_SIZE: usize = 4; const KEY_BLOCK_HEADER_SIZE: usize = 4;
impl<'l> KeyBlockBuilder<'l> { impl<'l> KeyBlockBuilder<'l> {
/// Creates a new key block builder for the number of entries. /// Creates a new key block builder for the number of entries.
pub fn new(buffer: &'l mut Vec<u8>, entry_count: u32) -> Self { pub fn new(buffer: &'l mut Vec<u8>, entry_count: u32, has_hash: bool) -> Self {
debug_assert!(entry_count < (1 << 24)); debug_assert!(entry_count < (1 << 24));
const ESTIMATED_KEY_SIZE: usize = 16; const ESTIMATED_KEY_SIZE: usize = 16;
buffer.reserve(entry_count as usize * ESTIMATED_KEY_SIZE); buffer.reserve(entry_count as usize * ESTIMATED_KEY_SIZE);
buffer.write_u8(BLOCK_TYPE_KEY).unwrap(); let block_type = if has_hash {
BLOCK_TYPE_KEY_WITH_HASH
} else {
BLOCK_TYPE_KEY_NO_HASH
};
buffer.write_u8(block_type).unwrap();
buffer.write_u24::<BE>(entry_count).unwrap(); buffer.write_u24::<BE>(entry_count).unwrap();
for _ in 0..entry_count { for _ in 0..entry_count {
buffer.write_u32::<BE>(0).unwrap(); buffer.write_u32::<BE>(0).unwrap();
...@@ -531,10 +551,19 @@ impl<'l> KeyBlockBuilder<'l> { ...@@ -531,10 +551,19 @@ impl<'l> KeyBlockBuilder<'l> {
Self { Self {
current_entry: 0, current_entry: 0,
header_size: buffer.len(), header_size: buffer.len(),
has_hash,
buffer, buffer,
} }
} }
/// Writes the 8-byte hash if `has_hash` is true.
fn write_hash<E: Entry>(&mut self, entry: &E) {
if self.has_hash {
let hash_bytes = entry.key_hash().to_be_bytes();
self.buffer.extend_from_slice(&hash_bytes);
}
}
/// Writes a small-sized value to the buffer. /// Writes a small-sized value to the buffer.
pub fn put_small<E: Entry>( pub fn put_small<E: Entry>(
&mut self, &mut self,
...@@ -548,7 +577,7 @@ impl<'l> KeyBlockBuilder<'l> { ...@@ -548,7 +577,7 @@ impl<'l> KeyBlockBuilder<'l> {
let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_SMALL as u32) << 24); let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_SMALL as u32) << 24);
BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header); BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header);
self.buffer.write_u64::<BE>(entry.key_hash()).unwrap(); self.write_hash(entry);
entry.write_key_to(self.buffer); entry.write_key_to(self.buffer);
self.buffer.write_u16::<BE>(value_block).unwrap(); self.buffer.write_u16::<BE>(value_block).unwrap();
self.buffer.write_u16::<BE>(value_size).unwrap(); self.buffer.write_u16::<BE>(value_size).unwrap();
...@@ -564,7 +593,7 @@ impl<'l> KeyBlockBuilder<'l> { ...@@ -564,7 +593,7 @@ impl<'l> KeyBlockBuilder<'l> {
let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_MEDIUM as u32) << 24); let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_MEDIUM as u32) << 24);
BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header); BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header);
self.buffer.write_u64::<BE>(entry.key_hash()).unwrap(); self.write_hash(entry);
entry.write_key_to(self.buffer); entry.write_key_to(self.buffer);
self.buffer.write_u16::<BE>(value_block).unwrap(); self.buffer.write_u16::<BE>(value_block).unwrap();
...@@ -578,7 +607,7 @@ impl<'l> KeyBlockBuilder<'l> { ...@@ -578,7 +607,7 @@ impl<'l> KeyBlockBuilder<'l> {
let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_DELETED as u32) << 24); let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_DELETED as u32) << 24);
BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header); BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header);
self.buffer.write_u64::<BE>(entry.key_hash()).unwrap(); self.write_hash(entry);
entry.write_key_to(self.buffer); entry.write_key_to(self.buffer);
self.current_entry += 1; self.current_entry += 1;
...@@ -591,7 +620,7 @@ impl<'l> KeyBlockBuilder<'l> { ...@@ -591,7 +620,7 @@ impl<'l> KeyBlockBuilder<'l> {
let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_BLOB as u32) << 24); let header = (pos as u32) | ((KEY_BLOCK_ENTRY_TYPE_BLOB as u32) << 24);
BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header); BE::write_u32(&mut self.buffer[header_offset..header_offset + 4], header);
self.buffer.write_u64::<BE>(entry.key_hash()).unwrap(); self.write_hash(entry);
entry.write_key_to(self.buffer); entry.write_key_to(self.buffer);
self.buffer.write_u32::<BE>(blob).unwrap(); self.buffer.write_u32::<BE>(blob).unwrap();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment