Optimize size computations, use ceilinged_add, style.

include/bitcoin/system/chain/block.hpp

@@ -43,7 +43,6 @@ class BC_API block
 public:
  DEFAULT_COPY_MOVE_DESTRUCT(block);
 
- typedef std_vector<size_t> sizes;
  typedef std::shared_ptr<const block> cptr;
 
  static bool is_malleable64(const transaction_cptrs& txs) NOEXCEPT;
@@ -167,6 +166,7 @@ class BC_API block
  bool is_unspent_coinbase_collision() const NOEXCEPT;
 
 private:
+ typedef struct { size_t nominal; size_t witnessed; } sizes;
  using point_cref = std::reference_wrapper<const point>;
  using point_hash = std::hash<std::reference_wrapper<const point>>;
  using hash_cref = std::reference_wrapper<const hash_digest>;
@@ -180,6 +180,7 @@ class BC_API block
  std::unordered_set<hash_cref, hash_hash>;
 
  static block from_data(reader& source, bool witness) NOEXCEPT;
+ static sizes serialized_size(const chain::transaction_cptrs& txs) NOEXCEPT;
 
  // context free
  hash_digest generate_merkle_root(bool witness) const NOEXCEPT;
@@ -202,8 +203,7 @@ class BC_API block
 
  // Cache.
  bool valid_;
- ////size_t nominal_size_;
- ////size_t witness_size_;
+ sizes size_;
 };
 
 typedef std::vector<block> blocks;

include/bitcoin/system/chain/input.hpp

@@ -119,15 +119,22 @@ class BC_API input
  bool is_locked(size_t height, uint32_t median_time_past) const NOEXCEPT;
 
 protected:
- // So that witness may be set late in deserialization.
- friend class transaction;
-
  input(const chain::point::cptr& point, const chain::script::cptr& script,
  const chain::witness::cptr& witness, uint32_t sequence,
  bool valid) NOEXCEPT;
 
 private:
+ // So that witness may be set late in deserialization.
+ friend class transaction;
+ size_t nominal_size() const NOEXCEPT;
+ size_t witnessed_size() const NOEXCEPT;
+ void set_witness(reader& source) NOEXCEPT;
+
+ typedef struct { size_t nominal; size_t witnessed; } sizes;
+
  static input from_data(reader& source) NOEXCEPT;
+ static sizes serialized_size(const chain::script& script,
+ const chain::witness& witness) NOEXCEPT;
  bool extract_sigop_script(chain::script& out,
  const chain::script& prevout_script) const NOEXCEPT;
 
@@ -141,7 +148,7 @@ class BC_API input
 
  // Cache.
  bool valid_;
- ////size_t size_;
+ sizes size_;
 
 public:
  /// Public mutable metadata access, copied but not compared for equality.

include/bitcoin/system/chain/operation.hpp

@@ -156,6 +156,7 @@ class BC_API operation
 private:
  // So script may call count_op.
  friend class script;
+ static bool count_op(reader& source) NOEXCEPT;
 
  static operation from_data(reader& source) NOEXCEPT;
  static operation from_push_data(const chunk_cptr& data,
@@ -166,7 +167,6 @@ class BC_API operation
 
  static chunk_cptr no_data_ptr() NOEXCEPT;
  static chunk_cptr any_data_ptr() NOEXCEPT;
- static bool count_op(reader& source) NOEXCEPT;
  static uint32_t read_data_size(opcode code, reader& source) NOEXCEPT;
 
  static inline opcode opcode_from_data(const data_chunk& push_data,

include/bitcoin/system/chain/output.hpp

@@ -96,6 +96,8 @@ class BC_API output
 
 private:
  static output from_data(reader& source) NOEXCEPT;
+ static size_t serialized_size(const chain::script& script,
+ uint64_t value) NOEXCEPT;
 
  // Output should be stored as shared (adds 16 bytes).
  // copy: 3 * 64 + 1 = 25 bytes (vs. 16 when shared).
@@ -104,7 +106,7 @@ class BC_API output
 
  // Cache.
  bool valid_;
- ////size_t size_;
+ size_t size_;
 };
 
 typedef std::vector<output> outputs;

include/bitcoin/system/chain/script.hpp

@@ -180,7 +180,7 @@ class BC_API script
  static size_t serialized_size(const operations& ops) NOEXCEPT;
  static inline size_t op_size(size_t total, const operation& op) NOEXCEPT
  {
- return total + op.serialized_size();
+ return ceilinged_add(total, op.serialized_size());
  };
 
  // Script should be stored as shared.

include/bitcoin/system/chain/transaction.hpp

@@ -224,6 +224,7 @@ class BC_API transaction
  bool is_confirmed_double_spend(size_t height) const NOEXCEPT;
 
 private:
+ typedef struct { size_t nominal; size_t witnessed; } sizes;
  typedef struct
  {
  hash_digest outputs;
@@ -234,6 +235,8 @@ class BC_API transaction
  static transaction from_data(reader& source, bool witness) NOEXCEPT;
  static bool segregated(const chain::inputs& inputs) NOEXCEPT;
  static bool segregated(const chain::input_cptrs& inputs) NOEXCEPT;
+ static sizes serialized_size(const chain::input_cptrs& inputs,
+ const chain::output_cptrs& outputs, bool segregated) NOEXCEPT;
 
  // signature hash
  hash_digest output_hash(const input_iterator& input) const NOEXCEPT;
@@ -268,8 +271,7 @@ class BC_API transaction
  // Cache.
  bool segregated_;
  bool valid_;
- ////size_t nominal_size_;
- ////size_t witness_size_;
+ sizes size_;
 
  // TODO: use std::optional to avoid these pointer allocations (0.16%).
  // Signature and identity hash caching (witness hash if witnessed).

include/bitcoin/system/intrinsics/haves.hpp

@@ -178,23 +178,23 @@ inline bool have_avx512() NOEXCEPT
 inline bool have_avx2() NOEXCEPT
 {
  if constexpr (with_avx2)
- return try_avx2();
+ return true;//// try_avx2();
  else
  return false;
 }
 
 inline bool have_sse41() NOEXCEPT
 {
  if constexpr (with_sse41)
- return try_sse41();
+ return true;//// try_sse41();
  else
  return false;
 }
 
 inline bool have_neon() NOEXCEPT
 {
- if constexpr (with_shani)
- return try_shani();
+ if constexpr (with_neon)
+ return try_neon();
  else
  return false;
 }

src/chain/block.cpp

@@ -111,7 +111,10 @@ block::block(reader& source, bool witness) NOEXCEPT
 // protected
 block::block(const chain::header::cptr& header,
  const chain::transactions_cptr& txs, bool valid) NOEXCEPT
- : header_(header), txs_(txs), valid_(valid)
+ : header_(header),
+ txs_(txs),
+ valid_(valid),
+ size_(serialized_size(*txs))
 {
 }
 
@@ -213,7 +216,7 @@ const chain::header::cptr block::header_ptr() const NOEXCEPT
 const inputs_cptr block::inputs_ptr() const NOEXCEPT
 {
  const auto inputs = std::make_shared<input_cptrs>();
- const auto append_ins = [&inputs](const transaction::cptr& tx) NOEXCEPT
+ const auto append_ins = [&inputs](const auto& tx) NOEXCEPT
  {
  const auto& tx_ins = *tx->inputs_ptr();
  inputs->insert(inputs->end(), tx_ins.begin(), tx_ins.end());
@@ -240,7 +243,7 @@ hashes block::transaction_hashes(bool witness) const NOEXCEPT
  // Vector capacity is never reduced when resizing to smaller size.
  out.resize(count);
 
- const auto hash = [witness](const transaction::cptr& tx) NOEXCEPT
+ const auto hash = [witness](const auto& tx) NOEXCEPT
  {
  return tx->hash(witness);
  };
@@ -255,18 +258,35 @@ hash_digest block::hash() const NOEXCEPT
  return header_->hash();
 }
 
-// TODO: this is expensive.
-size_t block::serialized_size(bool witness) const NOEXCEPT
+// static/private
+block::sizes block::serialized_size(
+ const chain::transaction_cptrs& txs) NOEXCEPT
 {
- // Overflow returns max_size_t.
- const auto sum = [=](size_t total, const transaction::cptr& tx) NOEXCEPT
+ sizes size{};
+ std::for_each(txs.begin(), txs.end(), [&](const auto& tx) NOEXCEPT
  {
- return ceilinged_add(total, tx->serialized_size(witness));
- };
+ size.nominal = ceilinged_add(size.nominal, tx->serialized_size(false));
+ size.witnessed = ceilinged_add(size.witnessed, tx->serialized_size(true));
+ });
+
+ const auto common_size = ceilinged_add(
+ header::serialized_size(),
+ variable_size(txs.size()));
+
+ const auto nominal_size = ceilinged_add(
+ common_size,
+ size.nominal);
 
- return header::serialized_size()
- + variable_size(txs_->size())
- + std::accumulate(txs_->begin(), txs_->end(), zero, sum);
+ const auto witnessed_size = ceilinged_add(
+ common_size,
+ size.witnessed);
+
+ return { nominal_size, witnessed_size };
+}
+
+size_t block::serialized_size(bool witness) const NOEXCEPT
+{
+ return witness ? size_.witnessed : size_.nominal;
 }
 
 // Connect.
@@ -294,7 +314,7 @@ bool block::is_extra_coinbases() const NOEXCEPT
  if (txs_->empty())
  return false;
 
- const auto value = [](const transaction::cptr& tx) NOEXCEPT
+ const auto value = [](const auto& tx) NOEXCEPT
  {
  return tx->is_coinbase();
  };
@@ -318,7 +338,7 @@ bool block::is_forward_reference() const NOEXCEPT
  return hashes.find(std::ref(input->point().hash())) != hashes.end();
  };
 
- const auto spend = [&spent, &hashes](const transaction::cptr& tx) NOEXCEPT
+ const auto spend = [&spent, &hashes](const auto& tx) NOEXCEPT
  {
  const auto& ins = *tx->inputs_ptr();
  const auto forward = std::any_of(ins.begin(), ins.end(), spent);
@@ -338,7 +358,7 @@ bool block::is_internal_double_spend() const NOEXCEPT
  return false;
 
  // Overflow returns max_size_t.
- const auto sum_ins = [](size_t total, const transaction::cptr& tx) NOEXCEPT
+ const auto sum_ins = [](size_t total, const auto& tx) NOEXCEPT
  {
  return ceilinged_add(total, tx->inputs());
  };
@@ -351,7 +371,7 @@ bool block::is_internal_double_spend() const NOEXCEPT
  return !points.emplace(in->point()).second;
  };
 
- const auto double_spent = [&spent](const transaction::cptr& tx) NOEXCEPT
+ const auto double_spent = [&spent](const auto& tx) NOEXCEPT
  {
  const auto& ins = *tx->inputs_ptr();
  return std::any_of(ins.begin(), ins.end(), spent);
@@ -377,8 +397,9 @@ bool block::is_invalid_merkle_root() const NOEXCEPT
 size_t block::weight() const NOEXCEPT
 {
  // Block weight is 3 * nominal size * + 1 * witness size (bip141).
- return base_size_contribution * serialized_size(false) +
- total_size_contribution * serialized_size(true);
+ return ceilinged_add(
+ ceilinged_multiply(base_size_contribution, serialized_size(false)),
+ ceilinged_multiply(total_size_contribution, serialized_size(true)));
 }
 
 bool block::is_overweight() const NOEXCEPT
@@ -484,7 +505,7 @@ bool block::is_malleable64() const NOEXCEPT
 // This form of malleability does not imply current block instance is invalid.
 bool block::is_malleable64(const transaction_cptrs& txs) NOEXCEPT
 {
- const auto two_leaves = [](const transaction::cptr& tx) NOEXCEPT
+ const auto two_leaves = [](const auto& tx) NOEXCEPT
  {
  return tx->serialized_size(false) == two * hash_size;
  };
@@ -494,7 +515,7 @@ bool block::is_malleable64(const transaction_cptrs& txs) NOEXCEPT
 
 bool block::is_segregated() const NOEXCEPT
 {
- const auto segregated = [](const transaction::cptr& tx) NOEXCEPT
+ const auto segregated = [](const auto& tx) NOEXCEPT
  {
  return tx->is_segregated();
  };
@@ -547,7 +568,7 @@ static uint64_t block_subsidy(size_t height, uint64_t subsidy_interval,
 uint64_t block::fees() const NOEXCEPT
 {
  // Overflow returns max_uint64.
- const auto value = [](uint64_t total, const transaction::cptr& tx) NOEXCEPT
+ const auto value = [](uint64_t total, const auto& tx) NOEXCEPT
  {
  return ceilinged_add(total, tx->fee());
  };
@@ -578,7 +599,7 @@ bool block::is_overspent(size_t height, uint64_t subsidy_interval,
 size_t block::signature_operations(bool bip16, bool bip141) const NOEXCEPT
 {
  // Overflow returns max_size_t.
- const auto value = [=](size_t total, const transaction::cptr& tx) NOEXCEPT
+ const auto value = [=](size_t total, const auto& tx) NOEXCEPT
  {
  return ceilinged_add(total, tx->signature_operations(bip16, bip141));
  };

src/chain/input.cpp

@@ -154,7 +154,8 @@ input::input(const chain::point::cptr& point, const chain::script::cptr& script,
  script_(script),
  witness_(witness),
  sequence_(sequence),
- valid_(valid)
+ valid_(valid),
+ size_(serialized_size(*script, *witness))
 {
 }
 
@@ -216,16 +217,52 @@ void input::to_data(writer& sink) const NOEXCEPT
  sink.write_4_bytes_little_endian(sequence_);
 }
 
+// static/private
+input::sizes input::serialized_size(const chain::script& script,
+ const chain::witness& witness) NOEXCEPT
+{
+ constexpr auto const_size = ceilinged_add(
+ point::serialized_size(),
+ sizeof(sequence_));
+
+ const auto nominal_size = ceilinged_add(
+ const_size,
+ script.serialized_size(true));
+
+ const auto witnessed_size = ceilinged_add(
+ nominal_size,
+ witness.serialized_size(true));
+
+ return { nominal_size, witnessed_size };
+}
+
+// input.serialized_size(witness) provides sizing for witness, however
+// witnesses are serialized by the transaction. This is an ugly hack as a
+// consequence of bip144 not serializing witnesses as part of inputs, which
+// is logically the proper association.
 size_t input::serialized_size(bool witness) const NOEXCEPT
 {
- // input.serialized_size(witness) provides sizing for witness, however
- // witnesses are serialized by the transaction. This is an ugly hack as a
- // consequence of bip144 not serializing witnesses as part of inputs, which
- // is logically the proper association.
- return point::serialized_size()
- + script_->serialized_size(true)
- + (witness ? witness_->serialized_size(true) : zero)
- + sizeof(sequence_);
+ return witness ? size_.witnessed : size_.nominal;
+}
+
+// Friend accessors (private).
+// ----------------------------------------------------------------------------
+
+size_t input::nominal_size() const NOEXCEPT
+{
+ return size_.nominal;
+}
+
+size_t input::witnessed_size() const NOEXCEPT
+{
+ return size_.witnessed;
+}
+
+void input::set_witness(reader& source) NOEXCEPT
+{
+ witness_ = to_shared<chain::witness>(source, true);
+ size_.witnessed = ceilinged_add(size_.nominal,
+ witness_->serialized_size(true));
 }
 
 // Properties.