fc::message_buffer< buffer_len > Class Template Reference

abstraction for a message buffer that spans a chain of physical buffers More...

#include <message_buffer.hpp>

Public Types
typedef std::pair< uint32_t, uint32_t >	index_t

Public Member Functions
	message_buffer ()
	~message_buffer ()
index_t	read_index () const
index_t	write_index () const
char *	read_ptr ()
char *	write_ptr ()
void	add_buffer_to_chain ()
void	add_space (uint32_t bytes)
void	reset ()
uint32_t	bytes_to_read () const
uint32_t	bytes_to_read_from_index (const index_t &ind) const
uint32_t	bytes_to_write () const
uint32_t	total_bytes () const
void	advance_read_ptr (uint32_t bytes)
void	advance_write_ptr (uint32_t bytes)
std::vector< boost::asio::mutable_buffer >	get_buffer_sequence_for_boost_async_read ()
bool	read (void *s, uint32_t size)
bool	peek (void *s, uint32_t size, index_t &index) const
mb_datastream< buffer_len >	create_datastream ()
mb_peek_datastream< buffer_len >	create_peek_datastream ()

Static Public Member Functions
static void	advance_index (index_t &index, uint32_t bytes)

Detailed Description

template<uint32_t buffer_len>
class fc::message_buffer< buffer_len >

This message buffer abstraction will allocate individual character arrays of size buffer_len from a boost::singleton_pool. It supports creation of a vector of boost::mutable_buffer for use with async_read() and async_read_some(). It also supports use with the fc unpack() functionality via a datastream helper class.

Definition at line 25 of file message_buffer.hpp.

Member Typedef Documentation

index_t

template<uint32_t buffer_len>

std::pair<uint32_t, uint32_t> fc::message_buffer< buffer_len >::index_t

Definition at line 32 of file message_buffer.hpp.

Constructor & Destructor Documentation

message_buffer()

template<uint32_t buffer_len>

fc::message_buffer< buffer_len >::message_buffer ( )

inline

Definition at line 34 of file message_buffer.hpp.

: buffers{malloc()}, read_ind{0,0}, write_ind{0,0}, sanity_check (1) { }

~message_buffer()

template<uint32_t buffer_len>

fc::message_buffer< buffer_len >::~message_buffer ( )

inline

Definition at line 36 of file message_buffer.hpp.

                      {
      while (buffers.size() > 0) {
        free(buffers.back());
        buffers.pop_back();
      }
    }

Member Function Documentation

add_buffer_to_chain()

template<uint32_t buffer_len>

void fc::message_buffer< buffer_len >::add_buffer_to_chain ( )

inline

Definition at line 75 of file message_buffer.hpp.

                               {
      sanity_check++;
      buffers.push_back(malloc());
    }

Here is the caller graph for this function:

add_space()

template<uint32_t buffer_len>

void fc::message_buffer< buffer_len >::add_space ( uint32_t bytes )

inline

Definition at line 85 of file message_buffer.hpp.

                                   {
      int buffers_to_add = bytes / buffer_len + 1;
      for (int i = 0; i < buffers_to_add; i++) {
        sanity_check++;
        buffers.push_back(malloc());
      }
    }

Here is the caller graph for this function:

advance_index()

template<uint32_t buffer_len>

static void fc::message_buffer< buffer_len >::advance_index ( index_t & index, uint32_t bytes )

inlinestatic

Definition at line 249 of file message_buffer.hpp.

                                                               {
        index.first += (bytes + index.second) / buffer_len;
        index.second = (bytes + index.second) % buffer_len;
     }

Here is the caller graph for this function:

advance_read_ptr()

template<uint32_t buffer_len>

void fc::message_buffer< buffer_len >::advance_read_ptr ( uint32_t bytes )

inline

Definition at line 159 of file message_buffer.hpp.

                                          {
      advance_index(read_ind, bytes);
      if (read_ind == write_ind) {
        reset();
      } else if (read_ind.first > 0) {
        while (read_ind.first > 0) {
          free(buffers.front());
          buffers.pop_front();
          sanity_check--;
          read_ind.first--;
          write_ind.first--;
        }
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

advance_write_ptr()

template<uint32_t buffer_len>

void fc::message_buffer< buffer_len >::advance_write_ptr ( uint32_t bytes )

inline

Definition at line 178 of file message_buffer.hpp.

                                           {
      advance_index(write_ind, bytes);
      while (write_ind.first >= buffers.size()) {
        sanity_check++;
        buffers.push_back(malloc());
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bytes_to_read()

template<uint32_t buffer_len>

uint32_t fc::message_buffer< buffer_len >::bytes_to_read ( ) const

inline

Definition at line 122 of file message_buffer.hpp.

                                   {
      return bytes_to_read_from_index(read_ind);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bytes_to_read_from_index()

template<uint32_t buffer_len>

uint32_t fc::message_buffer< buffer_len >::bytes_to_read_from_index ( const index_t & ind ) const

inline

Definition at line 130 of file message_buffer.hpp.

                                                                {
      return (write_ind.first - ind.first) * buffer_len + write_ind.second - ind.second;
    }

Here is the caller graph for this function:

bytes_to_write()

template<uint32_t buffer_len>

uint32_t fc::message_buffer< buffer_len >::bytes_to_write ( ) const

inline

Definition at line 140 of file message_buffer.hpp.

                                    {
      return total_bytes() - write_ind.first * buffer_len - write_ind.second;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

create_datastream()

template<uint32_t buffer_len>

mb_datastream< buffer_len > fc::message_buffer< buffer_len >::create_datastream ( )

inline

Definition at line 313 of file message_buffer.hpp.

                                                                                 {
    return mb_datastream<buffer_len>(*this);
  }

Here is the caller graph for this function:

create_peek_datastream()

template<uint32_t buffer_len>

mb_peek_datastream< buffer_len > fc::message_buffer< buffer_len >::create_peek_datastream ( )

inline

Definition at line 348 of file message_buffer.hpp.

                                                                                           {
     return mb_peek_datastream<buffer_len>( *this );
  }

Here is the caller graph for this function:

get_buffer_sequence_for_boost_async_read()

template<uint32_t buffer_len>

std::vector< boost::asio::mutable_buffer > fc::message_buffer< buffer_len >::get_buffer_sequence_for_boost_async_read ( )

inline

Definition at line 192 of file message_buffer.hpp.

                                                                                  {
      std::vector<boost::asio::mutable_buffer> seq;
      FC_ASSERT(write_ind.first < buffers.size());
      seq.push_back(boost::asio::buffer(&buffers[write_ind.first]->at(write_ind.second),
                                                buffer_len - write_ind.second));
      for (std::size_t i = write_ind.first + 1; i < buffers.size(); i++) {
        seq.push_back(boost::asio::buffer(&buffers[i]->at(0), buffer_len));
      }
      return seq;
    }

Here is the caller graph for this function:

peek()

template<uint32_t buffer_len>

bool fc::message_buffer< buffer_len >::peek ( void * s, uint32_t size, index_t & index ) const

inline

Definition at line 228 of file message_buffer.hpp.

                                                            {
      if (bytes_to_read_from_index(index) < size) {
        FC_THROW_EXCEPTION( out_of_range_exception, "tried to peek ${r} but only ${s} left",
                            ("r", size)( "s", bytes_to_read_from_index( index ) ) );
      }
      if (index.second + size <= buffer_len) {
        memcpy(s, get_ptr(index), size);
        advance_index(index, size);
      } else {
        uint32_t num_in_buffer = buffer_len - index.second;
        memcpy(s, get_ptr(index), num_in_buffer);
        advance_index(index, num_in_buffer);
        peek((char*)s + num_in_buffer, size - num_in_buffer, index);
      }
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

read()

template<uint32_t buffer_len>

bool fc::message_buffer< buffer_len >::read ( void * s, uint32_t size )

inline

Definition at line 207 of file message_buffer.hpp.

                                      {
      if (bytes_to_read() < size) {
        FC_THROW_EXCEPTION( out_of_range_exception, "tried to read ${r} but only ${s} left",
                            ("r", size)( "s", bytes_to_read() ) );
      }
      if (read_ind.second + size <= buffer_len) {
        memcpy(s, read_ptr(), size);
        advance_read_ptr(size);
      } else {
        uint32_t num_in_buffer = buffer_len - read_ind.second;
        memcpy(s, read_ptr(), num_in_buffer);
        advance_read_ptr(num_in_buffer);
        read((char*)s + num_in_buffer, size - num_in_buffer);
      }
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

read_index()

template<uint32_t buffer_len>

index_t fc::message_buffer< buffer_len >::read_index ( ) const

inline

Definition at line 47 of file message_buffer.hpp.

{ return read_ind; }

Here is the caller graph for this function:

read_ptr()

template<uint32_t buffer_len>

char * fc::message_buffer< buffer_len >::read_ptr ( )

inline

Definition at line 59 of file message_buffer.hpp.

                     {
      return &buffers[read_ind.first]->at(read_ind.second);
    }

Here is the caller graph for this function:

reset()

template<uint32_t buffer_len>

void fc::message_buffer< buffer_len >::reset ( )

inline

Definition at line 97 of file message_buffer.hpp.

                 {
      // some condition exists that can send *both* buffers.size() and sanity_check to well over 10^6.
      // this seems to be related to some sort of memory overrun possibly. By forcing an exit here, an
      // external watchdog can be used to restart the process and avoid hanging.
      if( buffers.size() != sanity_check || buffers.size() > 1000000) {
         elog( "read_ind = ${r1}, ${r2} write_ind = ${w1}, ${w2}, buff.size = ${bs}, sanity = ${s}",
               ( "r1", read_ind.first )( "r2", read_ind.second )( "w1", write_ind.first )( "w2", write_ind.second )
               ( "bs", buffers.size() )( "s", sanity_check ) );
        elog("Buffer manager overwrite detected. Terminating to allow external restart");
        exit(1);
      }
      while (buffers.size() > 1) {
        sanity_check--;
        free(buffers.back());
        buffers.pop_back();
      }
 
      read_ind = { 0, 0 };
      write_ind = { 0, 0 };
    }

Here is the caller graph for this function:

total_bytes()

template<uint32_t buffer_len>

uint32_t fc::message_buffer< buffer_len >::total_bytes ( ) const

inline

Definition at line 147 of file message_buffer.hpp.

                                 {
      return buffer_len * buffers.size();
    }

Here is the caller graph for this function:

write_index()

template<uint32_t buffer_len>

index_t fc::message_buffer< buffer_len >::write_index ( ) const

inline

Definition at line 53 of file message_buffer.hpp.

{ return write_ind; }

Here is the caller graph for this function:

write_ptr()

template<uint32_t buffer_len>

char * fc::message_buffer< buffer_len >::write_ptr ( )

inline

Definition at line 67 of file message_buffer.hpp.

                      {
      return &buffers[write_ind.first]->at(write_ind.second);
    }

Here is the caller graph for this function:

---

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

• libraries/fc/include/fc/network/message_buffer.hpp