cryptonote::block_queue Class Reference

#include <block_queue.h>

Classes
struct	span

Public Types
typedef std::set< span >	block_map

Public Member Functions
void	add_blocks (uint64_t height, std::vector< cryptonote::block_complete_entry > bcel, const boost::uuids::uuid &connection_id, float rate, size_t size)
void	add_blocks (uint64_t height, uint64_t nblocks, const boost::uuids::uuid &connection_id, boost::posix_time::ptime time=boost::date_time::min_date_time)
void	flush_spans (const boost::uuids::uuid &connection_id, bool all=false)
void	flush_stale_spans (const std::set< boost::uuids::uuid > &live_connections)
bool	remove_span (uint64_t start_block_height, std::vector< crypto::hash > *hashes=NULL)
void	remove_spans (const boost::uuids::uuid &connection_id, uint64_t start_block_height)
uint64_t	get_max_block_height () const
void	print () const
std::string	get_overview (uint64_t blockchain_height) const
bool	has_unpruned_height (uint64_t block_height, uint64_t blockchain_height, uint32_t pruning_seed) const
std::pair< uint64_t, uint64_t >	reserve_span (uint64_t first_block_height, uint64_t last_block_height, uint64_t max_blocks, const boost::uuids::uuid &connection_id, uint32_t pruning_seed, uint64_t blockchain_height, const std::vector< crypto::hash > &block_hashes, boost::posix_time::ptime time=boost::posix_time::microsec_clock::universal_time())
uint64_t	get_next_needed_height (uint64_t blockchain_height) const
std::pair< uint64_t, uint64_t >	get_next_span_if_scheduled (std::vector< crypto::hash > &hashes, boost::uuids::uuid &connection_id, boost::posix_time::ptime &time) const
void	reset_next_span_time (boost::posix_time::ptime t=boost::posix_time::microsec_clock::universal_time())
void	set_span_hashes (uint64_t start_height, const boost::uuids::uuid &connection_id, std::vector< crypto::hash > hashes)
bool	get_next_span (uint64_t &height, std::vector< cryptonote::block_complete_entry > &bcel, boost::uuids::uuid &connection_id, bool filled=true) const
bool	has_next_span (const boost::uuids::uuid &connection_id, bool &filled, boost::posix_time::ptime &time) const
bool	has_next_span (uint64_t height, bool &filled, boost::posix_time::ptime &time, boost::uuids::uuid &connection_id) const
size_t	get_data_size () const
size_t	get_num_filled_spans_prefix () const
size_t	get_num_filled_spans () const
crypto::hash	get_last_known_hash (const boost::uuids::uuid &connection_id) const
bool	has_spans (const boost::uuids::uuid &connection_id) const
float	get_speed (const boost::uuids::uuid &connection_id) const
float	get_download_rate (const boost::uuids::uuid &connection_id) const
bool	foreach (std::function< bool(const span &)> f) const
bool	requested (const crypto::hash &hash) const
bool	have (const crypto::hash &hash) const

Detailed Description

Definition at line 48 of file block_queue.h.

Member Typedef Documentation

block_map

typedef std::set<span> cryptonote::block_queue::block_map

Definition at line 69 of file block_queue.h.

Member Function Documentation

add_blocks() [1/2]

void cryptonote::block_queue::add_blocks	(	uint64_t	height,
		std::vector< cryptonote::block_complete_entry >	bcel,
		const boost::uuids::uuid &	connection_id,
		float	rate,
		size_t	size )

Definition at line 56 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  std::vector<crypto::hash> hashes;
  bool has_hashes = remove_span(height, &hashes);
  blocks.insert(span(height, std::move(bcel), connection_id, rate, size));
  if (has_hashes)
  {
    for (const crypto::hash &h: hashes)
    {
      requested_hashes.insert(h);
      have_blocks.insert(h);
    }
    set_span_hashes(height, connection_id, hashes);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_blocks() [2/2]

void cryptonote::block_queue::add_blocks	(	uint64_t	height,
		uint64_t	nblocks,
		const boost::uuids::uuid &	connection_id,
		boost::posix_time::ptime	time = boost::date_time::min_date_time )

Definition at line 73 of file block_queue.cpp.

{
  CHECK_AND_ASSERT_THROW_MES(nblocks > 0, "Empty span");
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  blocks.insert(span(height, nblocks, connection_id, time));
}

flush_spans()

void cryptonote::block_queue::flush_spans	(	const boost::uuids::uuid &	connection_id,
		bool	all = false )

Definition at line 80 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  block_map::iterator i = blocks.begin();
  while (i != blocks.end())
  {
    block_map::iterator j = i++;
    if (j->connection_id == connection_id && (all || j->blocks.size() == 0))
    {
      erase_block(j);
    }
  }
}

Here is the caller graph for this function:

flush_stale_spans()

void cryptonote::block_queue::flush_stale_spans

(

const std::set< boost::uuids::uuid > &

live_connections

)

Definition at line 105 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  block_map::iterator i = blocks.begin();
  while (i != blocks.end())
  {
    block_map::iterator j = i++;
    if (j->blocks.empty() && live_connections.find(j->connection_id) == live_connections.end())
    {
      erase_block(j);
    }
  }
}

foreach()

bool cryptonote::block_queue::foreach

(

std::function< bool(const span &)>

f

)

const

Definition at line 522 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  block_map::const_iterator i = blocks.begin();
  while (i != blocks.end())
    if (!f(*i++))
      return false;
  return true;
}

Here is the caller graph for this function:

get_data_size()

size_t cryptonote::block_queue::get_data_size

(

)

const

Definition at line 397 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  size_t size = 0;
  for (const auto &span: blocks)
    size += span.size;
  return size;
}

get_download_rate()

float cryptonote::block_queue::get_download_rate

(

const boost::uuids::uuid &

connection_id

)

const

Definition at line 497 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  float conn_rate = -1.f;
  for (const auto &span: blocks)
  {
    if (span.blocks.empty())
      continue;
    if (span.connection_id != connection_id)
      continue;
    // note that the average below does not average over the whole set, but over the
    // previous pseudo average and the latest rate: this gives much more importance
    // to the latest measurements, which is fine here
    if (conn_rate < 0.f)
      conn_rate = span.rate;
    else
      conn_rate = (conn_rate + span.rate) / 2;
  }
 
  if (conn_rate < 0)
    conn_rate = 0.0f;
  MTRACE("Download rate for " << connection_id << ": " << conn_rate << " b/s");
  return conn_rate;
}

get_last_known_hash()

crypto::hash cryptonote::block_queue::get_last_known_hash

(

const boost::uuids::uuid &

connection_id

)

const

Definition at line 432 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  crypto::hash hash = crypto::null_hash;
  uint64_t highest_height = 0;
  for (const auto &span: blocks)
  {
    if (span.connection_id != connection_id)
      continue;
    uint64_t h = span.start_block_height + span.nblocks - 1;
    if (h > highest_height && span.hashes.size() == span.nblocks)
    {
      hash = span.hashes.back();
      highest_height = h;
    }
  }
  return hash;
}

get_max_block_height()

uint64_t cryptonote::block_queue::get_max_block_height

(

)

const

Definition at line 148 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  uint64_t height = 0;
  for (const auto &span: blocks)
  {
    const uint64_t h = span.start_block_height + span.nblocks - 1;
    if (h > height)
      height = h;
  }
  return height;
}

Here is the caller graph for this function:

get_next_needed_height()

uint64_t cryptonote::block_queue::get_next_needed_height

(

uint64_t

blockchain_height

)

const

Definition at line 161 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return blockchain_height;
  uint64_t last_needed_height = blockchain_height;
  bool first = true;
  for (const auto &span: blocks)
  {
    if (span.start_block_height + span.nblocks - 1 < blockchain_height)
      continue;
    if (span.start_block_height != last_needed_height || (first && span.blocks.empty()))
      return last_needed_height;
    last_needed_height = span.start_block_height + span.nblocks;
    first = false;
  }
  return last_needed_height;
}

get_next_span()

bool cryptonote::block_queue::get_next_span	(	uint64_t &	height,
		std::vector< cryptonote::block_complete_entry > &	bcel,
		boost::uuids::uuid &	connection_id,
		bool	filled = true ) const

Definition at line 347 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return false;
  block_map::const_iterator i = blocks.begin();
  for (; i != blocks.end(); ++i)
  {
    if (!filled || !i->blocks.empty())
    {
      height = i->start_block_height;
      bcel = i->blocks;
      connection_id = i->connection_id;
      return true;
    }
  }
  return false;
}

get_next_span_if_scheduled()

std::pair< uint64_t, uint64_t > cryptonote::block_queue::get_next_span_if_scheduled	(	std::vector< crypto::hash > &	hashes,
		boost::uuids::uuid &	connection_id,
		boost::posix_time::ptime &	time ) const

Definition at line 303 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return std::make_pair(0, 0);
  block_map::const_iterator i = blocks.begin();
  if (i == blocks.end())
    return std::make_pair(0, 0);
  if (!i->blocks.empty())
    return std::make_pair(0, 0);
  hashes = i->hashes;
  connection_id = i->connection_id;
  time = i->time;
  return std::make_pair(i->start_block_height, i->nblocks);
}

get_num_filled_spans()

size_t cryptonote::block_queue::get_num_filled_spans

(

)

const

Definition at line 422 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  size_t size = 0;
  for (const auto &span: blocks)
  if (!span.blocks.empty())
    ++size;
  return size;
}

get_num_filled_spans_prefix()

size_t cryptonote::block_queue::get_num_filled_spans_prefix

(

)

const

Definition at line 406 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
 
  if (blocks.empty())
    return 0;
  block_map::const_iterator i = blocks.begin();
  size_t size = 0;
  while (i != blocks.end() && !i->blocks.empty())
  {
    ++i;
    ++size;
  }
  return size;
}

get_overview()

std::string cryptonote::block_queue::get_overview

(

uint64_t

blockchain_height

)

const

Definition at line 188 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return "[]";
  block_map::const_iterator i = blocks.begin();
  std::string s = std::string("[");
  uint64_t expected = blockchain_height;
  while (i != blocks.end())
  {
    if (expected > i->start_block_height)
    {
      s += "<";
    }
    else
    {
      if (expected < i->start_block_height)
        s += std::string(std::max((uint64_t)1, (i->start_block_height - expected) / (i->nblocks ? i->nblocks : 1)), '_');
      s += i->blocks.empty() ? "." : i->start_block_height == blockchain_height ? "m" : "o";
      expected = i->start_block_height + i->nblocks;
    }
    ++i;
  }
  s += "]";
  return s;
}

Here is the caller graph for this function:

get_speed()

float cryptonote::block_queue::get_speed

(

const boost::uuids::uuid &

connection_id

)

const

Definition at line 461 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  std::unordered_map<boost::uuids::uuid, float> speeds;
  for (const auto &span: blocks)
  {
    if (span.blocks.empty())
      continue;
    // note that the average below does not average over the whole set, but over the
    // previous pseudo average and the latest rate: this gives much more importance
    // to the latest measurements, which is fine here
    std::unordered_map<boost::uuids::uuid, float>::iterator i = speeds.find(span.connection_id);
    if (i == speeds.end())
      speeds.insert(std::make_pair(span.connection_id, span.rate));
    else
      i->second = (i->second + span.rate) / 2;
  }
  float conn_rate = -1, best_rate = 0;
  for (const auto &i: speeds)
  {
    if (i.first == connection_id)
      conn_rate = i.second;
    if (i.second > best_rate)
      best_rate = i.second;
  }
 
  if (conn_rate <= 0)
    return 1.0f; // not found, assume good speed
  if (best_rate == 0)
    return 1.0f; // everything dead ? Can't happen, but let's trap anyway
 
  const float speed = conn_rate / best_rate;
  MTRACE(" Relative speed for " << connection_id << ": " << speed << " (" << conn_rate << "/" << best_rate);
  return speed;
}

Here is the caller graph for this function:

has_next_span() [1/2]

bool cryptonote::block_queue::has_next_span	(	const boost::uuids::uuid &	connection_id,
		bool &	filled,
		boost::posix_time::ptime &	time ) const

Definition at line 366 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return false;
  block_map::const_iterator i = blocks.begin();
  if (i == blocks.end())
    return false;
  if (i->connection_id != connection_id)
    return false;
  filled = !i->blocks.empty();
  time = i->time;
  return true;
}

has_next_span() [2/2]

bool cryptonote::block_queue::has_next_span	(	uint64_t	height,
		bool &	filled,
		boost::posix_time::ptime &	time,
		boost::uuids::uuid &	connection_id ) const

Definition at line 381 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  if (blocks.empty())
    return false;
  block_map::const_iterator i = blocks.begin();
  if (i == blocks.end())
    return false;
  if (i->start_block_height > height)
    return false;
  filled = !i->blocks.empty();
  time = i->time;
  connection_id = i->connection_id;
  return true;
}

has_spans()

bool cryptonote::block_queue::has_spans

(

const boost::uuids::uuid &

connection_id

)

const

Definition at line 451 of file block_queue.cpp.

{
  for (const auto &span: blocks)
  {
    if (span.connection_id == connection_id)
      return true;
  }
  return false;
}

has_unpruned_height()

bool cryptonote::block_queue::has_unpruned_height	(	uint64_t	block_height,
		uint64_t	blockchain_height,
		uint32_t	pruning_seed ) const

have()

bool cryptonote::block_queue::have

(

const crypto::hash &

hash

)

const

Definition at line 226 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  return have_blocks.find(hash) != have_blocks.end();
}

print()

void cryptonote::block_queue::print

(

)

const

Definition at line 180 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  MDEBUG("Block queue has " << blocks.size() << " spans");
  for (const auto &span: blocks)
    MDEBUG("  " << span.start_block_height << " - " << (span.start_block_height+span.nblocks-1) << " (" << span.nblocks << ") - " << (span.blocks.empty() ? "scheduled" : "filled    ") << "  " << span.connection_id << " (" << ((unsigned)(span.rate*10/1024.f))/10.f << " kB/s)");
}

remove_span()

bool cryptonote::block_queue::remove_span	(	uint64_t	start_block_height,
		std::vector< crypto::hash > *	hashes = NULL )

Definition at line 119 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  for (block_map::iterator i = blocks.begin(); i != blocks.end(); ++i)
  {
    if (i->start_block_height == start_block_height)
    {
      if (hashes)
        *hashes = std::move(i->hashes);
      erase_block(i);
      return true;
    }
  }
  return false;
}

Here is the caller graph for this function:

remove_spans()

void cryptonote::block_queue::remove_spans	(	const boost::uuids::uuid &	connection_id,
		uint64_t	start_block_height )

Definition at line 135 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  for (block_map::iterator i = blocks.begin(); i != blocks.end(); )
  {
    block_map::iterator j = i++;
    if (j->connection_id == connection_id && j->start_block_height <= start_block_height)
    {
      erase_block(j);
    }
  }
}

requested()

bool cryptonote::block_queue::requested

(

const crypto::hash &

hash

)

const

Definition at line 220 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  return requested_internal(hash);
}

reserve_span()

std::pair< uint64_t, uint64_t > cryptonote::block_queue::reserve_span	(	uint64_t	first_block_height,
		uint64_t	last_block_height,
		uint64_t	max_blocks,
		const boost::uuids::uuid &	connection_id,
		uint32_t	pruning_seed,
		uint64_t	blockchain_height,
		const std::vector< crypto::hash > &	block_hashes,
		boost::posix_time::ptime	time = boost::posix_time::microsec_clock::universal_time() )

Definition at line 232 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
 
  MDEBUG("reserve_span: first_block_height " << first_block_height << ", last_block_height " << last_block_height
      << ", max " << max_blocks << ", seed " << epee::string_tools::to_string_hex(pruning_seed) << ", blockchain_height " <<
      blockchain_height << ", block hashes size " << block_hashes.size());
  if (last_block_height < first_block_height || max_blocks == 0)
  {
    MDEBUG("reserve_span: early out: first_block_height " << first_block_height << ", last_block_height " << last_block_height << ", max_blocks " << max_blocks);
    return std::make_pair(0, 0);
  }
  if (block_hashes.size() > last_block_height)
  {
    MDEBUG("reserve_span: more block hashes than fit within last_block_height: " << block_hashes.size() << " and " << last_block_height);
    return std::make_pair(0, 0);
  }
 
  // skip everything we've already requested
  uint64_t span_start_height = last_block_height - block_hashes.size() + 1;
  std::vector<crypto::hash>::const_iterator i = block_hashes.begin();
  while (i != block_hashes.end() && requested_internal(*i))
  {
    ++i;
    ++span_start_height;
  }
 
  // if the peer's pruned for the starting block and its unpruned stripe comes next, start downloading from there
  const uint32_t next_unpruned_height = tools::get_next_unpruned_block_height(span_start_height, blockchain_height, pruning_seed);
  MDEBUG("reserve_span: next_unpruned_height " << next_unpruned_height << " from " << span_start_height << " and seed "
      << epee::string_tools::to_string_hex(pruning_seed) << ", limit " << span_start_height + CRYPTONOTE_PRUNING_STRIPE_SIZE);
  if (next_unpruned_height > span_start_height && next_unpruned_height < span_start_height + CRYPTONOTE_PRUNING_STRIPE_SIZE)
  {
    MDEBUG("We can download from next span: ideal height " << span_start_height << ", next unpruned height " << next_unpruned_height <<
        "(+" << next_unpruned_height - span_start_height << "), current seed " << pruning_seed);
    span_start_height = next_unpruned_height;
  }
  MDEBUG("span_start_height: " <<span_start_height);
  const uint64_t block_hashes_start_height = last_block_height - block_hashes.size() + 1;
  if (span_start_height >= block_hashes.size() + block_hashes_start_height)
  {
    MDEBUG("Out of hashes, cannot reserve");
    return std::make_pair(0, 0);
  }
 
  i = block_hashes.begin() + span_start_height - block_hashes_start_height;
  while (i != block_hashes.end() && requested_internal(*i))
  {
    ++i;
    ++span_start_height;
  }
 
  uint64_t span_length = 0;
  std::vector<crypto::hash> hashes;
  while (i != block_hashes.end() && span_length < max_blocks && tools::has_unpruned_block(span_start_height + span_length, blockchain_height, pruning_seed))
  {
    hashes.push_back(*i);
    ++i;
    ++span_length;
  }
  if (span_length == 0)
  {
    MDEBUG("span_length 0, cannot reserve");
    return std::make_pair(0, 0);
  }
  MDEBUG("Reserving span " << span_start_height << " - " << (span_start_height + span_length - 1) << " for " << connection_id);
  add_blocks(span_start_height, span_length, connection_id, time);
  set_span_hashes(span_start_height, connection_id, hashes);
  return std::make_pair(span_start_height, span_length);
}

Here is the call graph for this function:

reset_next_span_time()

void cryptonote::block_queue::reset_next_span_time

(

boost::posix_time::ptime

t = boost::posix_time::microsec_clock::universal_time()

)

Definition at line 319 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  CHECK_AND_ASSERT_THROW_MES(!blocks.empty(), "No next span to reset time");
  block_map::iterator i = blocks.begin();
  CHECK_AND_ASSERT_THROW_MES(i != blocks.end(), "No next span to reset time");
  CHECK_AND_ASSERT_THROW_MES(i->blocks.empty(), "Next span is not empty");
  (boost::posix_time::ptime&)i->time = t; // sod off, time doesn't influence sorting
}

set_span_hashes()

void cryptonote::block_queue::set_span_hashes	(	uint64_t	start_height,
		const boost::uuids::uuid &	connection_id,
		std::vector< crypto::hash >	hashes )

Definition at line 329 of file block_queue.cpp.

{
  boost::unique_lock<boost::recursive_mutex> lock(mutex);
  for (block_map::iterator i = blocks.begin(); i != blocks.end(); ++i)
  {
    if (i->start_block_height == start_height && i->connection_id == connection_id)
    {
      span s = *i;
      erase_block(i);
      s.hashes = std::move(hashes);
      for (const crypto::hash &h: s.hashes)
        requested_hashes.insert(h);
      blocks.insert(s);
      return;
    }
  }
}

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_protocol/block_queue.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_protocol/block_queue.cpp