Use outpoint_to_value table

src/index/updater.rs

@@ -24,7 +24,7 @@ impl From<Block> for BlockData {
 }
 
 pub(crate) struct Updater {
- cache: HashMap<OutPointArray, Vec<u8>>,
+ range_cache: HashMap<OutPointArray, Vec<u8>>,
  height: u64,
  index_sats: bool,
  sat_ranges_since_flush: u64,
@@ -56,7 +56,7 @@ impl Updater {
  )?;
 
  let mut updater = Self {
- cache: HashMap::new(),
+ range_cache: HashMap::new(),
  height,
  index_sats: index.has_sat_index()?,
  sat_ranges_since_flush: 0,
@@ -93,13 +93,14 @@ impl Updater {
  let rx = Self::fetch_blocks_from(index, self.height, self.index_sats)?;
 
  let mut uncommitted = 0;
+ let mut value_cache = HashMap::new();
  loop {
  let block = match rx.recv() {
  Ok(block) => block,
  Err(mpsc::RecvError) => break,
  };
 
- self.index_block(index, &mut wtx, block)?;
+ self.index_block(index, &mut wtx, block, &mut value_cache)?;
 
  if let Some(progress_bar) = &mut progress_bar {
  progress_bar.inc(1);
@@ -112,7 +113,8 @@ impl Updater {
  uncommitted += 1;
 
  if uncommitted == 5000 {
- self.commit(wtx)?;
+ self.commit(wtx, value_cache)?;
+ value_cache = HashMap::new();
  uncommitted = 0;
  wtx = index.begin_write()?;
  let height = wtx
@@ -144,7 +146,7 @@ impl Updater {
  }
 
  if uncommitted > 0 {
- self.commit(wtx)?;
+ self.commit(wtx, value_cache)?;
  }
 
  if let Some(progress_bar) = &mut progress_bar {
@@ -245,6 +247,7 @@ impl Updater {
  index: &Index,
  wtx: &mut WriteTransaction,
  block: BlockData,
+ value_cache: &mut HashMap<OutPoint, u64>,
  ) -> Result<()> {
  let mut height_to_block_hash = wtx.open_table(HEIGHT_TO_BLOCK_HASH)?;
 
@@ -296,6 +299,7 @@ impl Updater {
  &mut outpoint_to_value,
  &mut sat_to_inscription_id,
  &mut satpoint_to_inscription_id,
+ value_cache,
  )?;
 
  if self.index_sats {
@@ -319,7 +323,7 @@ impl Updater {
  for input in &tx.input {
  let key = encode_outpoint(input.previous_output);
 
- let sat_ranges = match self.cache.remove(&key) {
+ let sat_ranges = match self.range_cache.remove(&key) {
  Some(sat_ranges) => {
  self.outputs_cached += 1;
  sat_ranges
@@ -460,40 +464,47 @@ impl Updater {
 
  *outputs_traversed += 1;
 
- self.cache.insert(encode_outpoint(outpoint), sats);
+ self.range_cache.insert(encode_outpoint(outpoint), sats);
  self.outputs_inserted_since_flush += 1;
  }
 
  Ok(())
  }
 
- fn commit(&mut self, wtx: WriteTransaction) -> Result {
+ fn commit(&mut self, wtx: WriteTransaction, value_cache: HashMap<OutPoint, u64>) -> Result {
  log::info!(
  "Committing at block height {}, {} outputs traversed, {} in map, {} cached",
  self.height,
  self.outputs_traversed,
- self.cache.len(),
+ self.range_cache.len(),
  self.outputs_cached
  );
 
  if self.index_sats {
  log::info!(
  "Flushing {} entries ({:.1}% resulting from {} insertions) from memory to database",
- self.cache.len(),
- self.cache.len() as f64 / self.outputs_inserted_since_flush as f64 * 100.,
+ self.range_cache.len(),
+ self.range_cache.len() as f64 / self.outputs_inserted_since_flush as f64 * 100.,
  self.outputs_inserted_since_flush,
  );
 
  let mut outpoint_to_sat_ranges = wtx.open_table(OUTPOINT_TO_SAT_RANGES)?;
 
- for (k, v) in &self.cache {
- outpoint_to_sat_ranges.insert(k, v)?;
+ for (outpoint, sat_range) in self.range_cache.drain() {
+ outpoint_to_sat_ranges.insert(&outpoint, &sat_range)?;
  }
 
- self.cache.clear();
  self.outputs_inserted_since_flush = 0;
  }
 
+ {
+ let mut outpoint_to_value = wtx.open_table(OUTPOINT_TO_VALUE)?;
+
+ for (outpoint, value) in value_cache {
+ outpoint_to_value.insert(&encode_outpoint(outpoint), &value)?;
+ }
+ }
+
  Index::increment_statistic(&wtx, Statistic::OutputsTraversed, self.outputs_traversed)?;
  self.outputs_traversed = 0;
  Index::increment_statistic(&wtx, Statistic::SatRanges, self.sat_ranges_since_flush)?;

src/index/updater/inscription_updater.rs

@@ -25,6 +25,7 @@ pub(super) struct InscriptionUpdater<'a, 'db, 'tx> {
  reward: u64,
  sat_to_inscription_id: &'a mut Table<'db, 'tx, u64, &'tx InscriptionIdArray>,
  satpoint_to_id: &'a mut Table<'db, 'tx, &'tx SatPointArray, &'tx InscriptionIdArray>,
+ value_cache: &'a mut HashMap<OutPoint, u64>,
 }
 
 impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
@@ -39,6 +40,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
  outpoint_to_value: &'a mut Table<'db, 'tx, &'tx OutPointArray, u64>,
  sat_to_inscription_id: &'a mut Table<'db, 'tx, u64, &'tx InscriptionIdArray>,
  satpoint_to_id: &'a mut Table<'db, 'tx, &'tx SatPointArray, &'tx InscriptionIdArray>,
+ value_cache: &'a mut HashMap<OutPoint, u64>,
  ) -> Result<Self> {
  let next_number = number_to_id
  .iter()?
@@ -61,6 +63,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
  reward: Height(height).subsidy(),
  sat_to_inscription_id,
  satpoint_to_id,
+ value_cache,
  })
  }
 
@@ -94,13 +97,12 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
  origin: Origin::Old(old_satpoint),
  });
  }
- self
- .outpoint_to_value
- .remove(&encode_outpoint(tx_in.previous_output))?;
 
- input_value += if let Some(value) = self
+ input_value += if let Some(value) = self.value_cache.remove(&tx_in.previous_output) {
+ value
+ } else if let Some(value) = self
  .outpoint_to_value
- .get(&encode_outpoint(tx_in.previous_output))?
+ .remove(&encode_outpoint(tx_in.previous_output))?
  {
  value.value()
  } else {
@@ -115,7 +117,7 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
  })?
  .output[usize::try_from(tx_in.previous_output.vout).unwrap()]
  .value
- }
+ };
  }
  }
 
@@ -157,16 +159,14 @@ impl<'a, 'db, 'tx> InscriptionUpdater<'a, 'db, 'tx> {
  }
 
  output_value = end;
- }
 
- for (vout, tx_out) in tx.output.iter().enumerate() {
- self.outpoint_to_value.insert(
- &encode_outpoint(OutPoint {
+ self.value_cache.insert(
+ OutPoint {
  vout: vout.try_into().unwrap(),
  txid,
- }),
- &tx_out.value,
- )?;
+ },
+ tx_out.value,
+ );
  }
 
  if is_coinbase {