/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/eformat/eformat-00-00-04/eformat/PagedMemory.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-

#ifndef EFORMAT_PAGEDMEMORY_H
#define EFORMAT_PAGEDMEMORY_H

#include <stdint.h>
#include <sys/uio.h>
#include "eformat/util.h"
#include "eformat/TooBigCountIssue.h"
#include "eformat/NotAlignedIssue.h"
#include "eformat/OutOfBoundsIssue.h"

#define CAST32(x) reinterpret_cast<const uint32_t*>(x)

namespace eformat {

  template <unsigned int TMAXPAGES=128> class PagedMemory {

  public: //export template symbol

    static const unsigned int MAXPAGES;

  public: //interface

    PagedMemory (const struct iovec* pages, size_t count);

    inline const struct iovec* pages (void) const { return m_iovec; }

    inline size_t count (void) const { return m_count; }

    inline size_t size (void) const { return m_size; }

  public: //indexing

    typedef struct node_t {
      const struct iovec* page; //a pointer to the page
      size_t start; //the cumulative, logical start of this page in words
      size_t end; //the cumulative, logical end of this page in words
      node_t* previous; //the previos page
      node_t* next; //the next page
    } node_t;

  public: //iteration

    class const_iterator {

    private: //only parent class can use this
      
      friend class PagedMemory;

      const_iterator (const node_t* node, size_t offset)
        : m_node(node), m_off(offset) {}
      

    public: //access methods

      const_iterator () : m_node(), m_off() {}

      const_iterator (const const_iterator& other)
        : m_node(other.m_node), m_off(other.m_off) {}

      ~const_iterator () {}

      const_iterator& operator= (const const_iterator& other);

      bool operator!= (const const_iterator& other) const;

      inline bool operator== (const const_iterator& other) const
      { return !(*this != other); }

      uint32_t operator[] (size_t pos) const;

      uint32_t at (size_t pos) const;

      inline uint32_t operator* (void) const 
      { return CAST32(m_node->page->iov_base)[m_off-m_node->start]; }

      const_iterator& operator++ (void);

      const_iterator& operator-- ();

      const_iterator& operator+= (size_t offset);

      const_iterator& operator-= (size_t offset);

      inline bool operator< (const const_iterator& other) const
      { return m_off < other.m_off; }

      inline bool operator> (const const_iterator& other) const
      { return m_off > other.m_off; }

      inline int32_t operator- (const const_iterator& other) const
      { return (int32_t)m_off - (int32_t)other.m_off; }

    private: //representation

      const node_t* m_node; 
      size_t m_off; 

    };

  public: //more interface declarations

    inline const_iterator begin (void) const 
    { return const_iterator(m_node, 0); }

    inline const_iterator end (void) const
    { return const_iterator(&m_node[m_count], m_size); }

  private: //representation

    const struct iovec* m_iovec; 
    size_t m_count; 
    node_t m_node[TMAXPAGES]; 
    size_t m_size; 

  };

}

template <unsigned int TMAXPAGES> const unsigned int 
eformat::PagedMemory<TMAXPAGES>::MAXPAGES = TMAXPAGES;

template <unsigned int TMAXPAGES> eformat::PagedMemory<TMAXPAGES>::PagedMemory 
(const struct iovec* pages, size_t count)
  : m_iovec(pages),
    m_count(count),
    m_size(0)
{
  if (m_count > MAXPAGES) {
    //Problem, I cannot index this amount of data
    throw EFORMAT_TOO_BIG_COUNT(count, MAXPAGES);
  }
  for (size_t i=0; i<count; ++i) {
    m_node[i].page = &pages[i];
    if (pages[i].iov_len % 4 != 0) {
      //Problem, one of the data blocks is *not* 32-bit aligned
      throw EFORMAT_NOT_ALIGNED(pages[i].iov_base, pages[i].iov_len);
    }
    m_node[i].start = m_size;
    m_size += pages[i].iov_len >> 2;
    m_node[i].end = m_size;
    if (i > 0) m_node[i].previous = &m_node[i-1];
    else m_node[i].previous = 0;
    if (i < (count-1) ) m_node[i].next = &m_node[i+1];
    else m_node[i].next = 0;
  }
}

template <unsigned int TMAXPAGES> typename eformat::PagedMemory<TMAXPAGES>::const_iterator&
eformat::PagedMemory<TMAXPAGES>::const_iterator::operator=
  (const typename eformat::PagedMemory<TMAXPAGES>::const_iterator& other)
{
  m_node = other.m_node;
  m_off = other.m_off;
  return *this;
}

template <unsigned int TMAXPAGES>
bool eformat::PagedMemory<TMAXPAGES>::const_iterator::operator!= 
(const typename eformat::PagedMemory<TMAXPAGES>::const_iterator& other) const
{
  return (m_node == other.m_node && m_off == other.m_off)?false:true;
}

template <unsigned int TMAXPAGES> 
uint32_t eformat::PagedMemory<TMAXPAGES>::const_iterator::operator[] 
(size_t pos) const
{
  if (m_off + pos < m_node->end) { //trying to reach data on the current page
    return CAST32(m_node->page->iov_base)[(m_off+pos)-m_node->start];
  }
  //otherwise it is not on this page, I have to find the page
  const_iterator it = *this;
  it += pos;
  return *it;
}

template <unsigned int TMAXPAGES>
uint32_t eformat::PagedMemory<TMAXPAGES>::const_iterator::at (size_t pos) const
{
  //immediate return (most of the cases)
  if (m_off + pos < m_node->end) { //trying to reach data on the current page
    return CAST32(m_node->page->iov_base)[(m_off+pos)-m_node->start];
  }

  //immediate points of failure
  if (!m_node || (m_node->next == 0 && (m_off+pos) >= m_node->end))
    throw EFORMAT_OUT_OF_BOUNDS(0, pos << 2);

  //if I get here, the data is on another page and the request might still be
  //out of bounds, so watch.
  const_iterator it = *this;
  it += pos;
  return it.at(0);
}

template <unsigned int TMAXPAGES> typename eformat::PagedMemory<TMAXPAGES>::const_iterator&
eformat::PagedMemory<TMAXPAGES>::const_iterator::operator++ (void)
{ 
  ++m_off;
  if ( m_off >= (m_node->end) ) {
    if (!m_node->next) { //it was the last
      m_off = m_node->end;
      return *this;
    }
    m_node = m_node->next;
    m_off = m_node->start;
  }
  return *this; 
}

template <unsigned int TMAXPAGES> typename eformat::PagedMemory<TMAXPAGES>::const_iterator&
eformat::PagedMemory<TMAXPAGES>::const_iterator::operator-- (void)
{ 
  --m_off;
  if ( m_off < (m_node->start) ) {
    if (!m_node->previous) { //it was the last
      m_off = m_node->start;
      return *this;
    }
    m_node = m_node->previous;
    m_off = m_node->end - 1;
  }
  return *this; 
}

template <unsigned int TMAXPAGES> typename eformat::PagedMemory<TMAXPAGES>::const_iterator&
eformat::PagedMemory<TMAXPAGES>::const_iterator::operator+= (size_t offset) 
{
  size_t aim = offset + m_off;
  while (aim >= (m_node->end)) {
    if (m_node->next) m_node = m_node->next;
    else { //it was the last
      m_off = m_node->end;
      return *this;
    }
  }
  m_off = aim;
  return *this;
}

template <unsigned int TMAXPAGES> typename eformat::PagedMemory<TMAXPAGES>::const_iterator&
eformat::PagedMemory<TMAXPAGES>::const_iterator::operator-= (size_t offset) 
{
  size_t aim = m_off - offset;
  while (aim < (m_node->start)) {
    if (m_node->previous) m_node = m_node->previous;
    else { //it was the first
      m_off = m_node->start;
      return *this;
    }
  }
  m_off = aim;
  return *this;
}

#endif /* EFORMAT_PAGEDMEMORY_H */

---