pcl_communication_structs.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__PCL__PCL_COMMUNICATION_STRUCTS__
#define __H__PCL__PCL_COMMUNICATION_STRUCTS__
 
#include <iterator>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include "common/util/smart_pointer.h"
#include "common/util/binary_buffer.h"
#include "common/error.h"
 
namespace pcl
{
 
 
//  type-traits
 
template <class TType>
struct type_traits
{
  typedef TType Elem; 
};
 
 
//  Interface Categories
namespace interface_tags
{
class basic_interface_tag                 {};
 
class ordered_interface_tag : public basic_interface_tag  {};
}// end of namespace interface_tags
 
 
//  BasicInterface
 
template <class TType,
      template <class T, class Alloc> class TContainer = std::vector,
      template <class T> class TAlloc = std::allocator>
class BasicInterface
{
  protected:
    typedef typename type_traits<TType>::Elem   TElem;
    typedef TContainer<TElem, TAlloc<TElem> >   ElemContainer;
 
  public:
    typedef interface_tags::basic_interface_tag   category_tag;
 
    typedef TType                 Type;
    typedef typename type_traits<TType>::Elem   Element;
    typedef typename ElemContainer::iterator    iterator;
    typedef typename ElemContainer::const_iterator  const_iterator;
 
  public:
    BasicInterface(int targetProc = -1) : m_size(0), m_targetProc(targetProc) {};
 
    inline iterator push_back(const Element& elem)  {++m_size; return m_elements.insert(m_elements.end(), elem);}
    inline iterator erase(iterator iter)        {--m_size; return m_elements.erase(iter);}
 
    inline iterator begin()   {return m_elements.begin();}
    inline iterator end()   {return m_elements.end();}
    inline const_iterator begin() const   {return m_elements.begin();}
    inline const_iterator end() const   {return m_elements.end();}
 
    inline Element& get_element(iterator iter)            {return *iter;}
    inline const Element& get_element(const_iterator iter) const  {return *iter;}
 
    inline size_t size() const          {return m_size;}
    inline bool empty() const         {return size() == 0;}
 
    int get_target_proc() const         {return m_targetProc;}
 
 
    void swap(BasicInterface& interface)
    {
      using std::swap;
      m_elements.swap(interface.m_elements);
      swap(m_size, interface.m_size);
      swap(m_targetProc, interface.m_targetProc);
    }
 
    template <class TCompare>
    void sort(TCompare cmp)
    {
      using std::sort;
      m_elements.sort(cmp);
    }
 
  protected:
    ElemContainer m_elements;
    size_t      m_size;
    int       m_targetProc;
};
 
//  OrderedInterface
 
template <class TType,
      template <class T, class Alloc> class TContainer = std::vector,
      template <class T> class TAlloc = std::allocator>
class OrderedInterface
{
  protected:
    typedef typename type_traits<TType>::Elem TElem;
 
    struct InterfaceEntry
    {
      InterfaceEntry(TElem e, size_t locID) : elem(e), localID(locID) {}
 
      TElem elem;
      size_t  localID;
    };
 
    template <class TElemCmp>
    struct InterfaceEntryCmp{
      InterfaceEntryCmp(TElemCmp elemCmp) : m_elemCmp(elemCmp) {}
      bool operator()(InterfaceEntry const& e1, InterfaceEntry const& e2)
      {return m_elemCmp(e1.elem, e2.elem);}
      TElemCmp  m_elemCmp;
    };
 
    typedef TContainer<InterfaceEntry, TAlloc<InterfaceEntry> >
                            ElemContainer;
 
  public:
    typedef TType                 Type;
    typedef typename type_traits<TType>::Elem   Element;
 
    typedef interface_tags::ordered_interface_tag category_tag;
 
    typedef typename ElemContainer::iterator    iterator;
    typedef typename ElemContainer::const_iterator  const_iterator;
 
  public:
    OrderedInterface(int targetProc = -1) :
      m_size(0),
      m_targetProc(targetProc),
      m_idCounter(1)  {}
 
    inline iterator push_back(const Element& elem)
    {
      ++m_size;
      return m_elements.insert(m_elements.end(),
                  (InterfaceEntry(elem, get_free_id())));
    }
 
    inline iterator insert(const Element& elem, iterator insertBefore)
    {
      ++m_size;
 
      size_t startNumber = 0;
      if (insertBefore != end())
        startNumber = insertBefore->localID;
 
      iterator it = m_elements.insert(insertBefore, (InterfaceEntry(elem, get_free_id())));
 
      if (startNumber)
      {
        //  we have to reset all local indices
        --startNumber;
        for (iterator iter = it; iter != m_elements.end(); ++iter)
            (*iter).localID = ++startNumber;
      }
 
      return it;
    }
 
    inline iterator erase(iterator iter)
    {
      --m_size;
      return m_elements.erase(iter);
    }
 
    inline iterator begin()   {return m_elements.begin();}
    inline iterator end()   {return m_elements.end();}
 
    inline const_iterator begin() const {return m_elements.begin();}
    inline const_iterator end() const {return m_elements.end();}
 
    inline Element& get_element(iterator iter)  {return (*iter).elem;}
    inline size_t get_local_id(iterator iter) {return (*iter).localID;}
 
    inline const Element& get_element(const_iterator iter) const  {return (*iter).elem;}
    inline size_t get_local_id(const_iterator iter) const       {return (*iter).localID;}
 
 
    inline size_t size() const          {return m_size;}
    inline bool empty() const         {return size() == 0;}
 
    int get_target_proc() const         {return m_targetProc;}
 
    static inline bool cmp(iterator iter1, iterator iter2,
                const std::input_iterator_tag&)
    {
      return (*iter1).localID < (*iter2).localID;
    }
 
 
    void swap(OrderedInterface& interface)
    {
      using std::swap;
      m_elements.swap(interface.m_elements);
      swap(m_size, interface.m_size);
      swap(m_targetProc, interface.m_targetProc);
      swap(m_idCounter, interface.m_idCounter);
    }
    
    template <class TCompare>
    void sort(TCompare cmp)
    {
      using std::sort;
      InterfaceEntryCmp<TCompare> ieCmp(cmp);
      m_elements.sort(ieCmp);
 
    //  we have to reset all local indices
      m_idCounter = 1;
      for(iterator iter = m_elements.begin(); iter != m_elements.end(); ++iter)
        (*iter).localID = m_idCounter++;
    }
 
    template <class TCompare>
    iterator find_insert_pos_sorted(const Element e, TCompare cmp)
    {
      InterfaceEntryCmp<TCompare> ieCmp(cmp);
      iterator it_begin = m_elements.begin();
      iterator it_end = m_elements.end();
      InterfaceEntry iEntry(e, 0);
      return std::lower_bound(it_begin, it_end, iEntry, ieCmp);
    }
 
 
  protected:
 
    size_t get_free_id()
    {
      if(m_idCounter == 0)
      {
        m_idCounter = 1;
      //  we have to reset all entries
        for(iterator iter = begin(); iter != end(); ++iter)
          (*iter).localID = m_idCounter++;
      }
 
      return m_idCounter++;
    }
 
  protected:
    ElemContainer m_elements;
    size_t m_size;
    int m_targetProc;
    size_t m_idCounter;
};
 
 
//  Layout Categories
namespace layout_tags
{
 
class single_level_layout_tag {};
 
 
class multi_level_layout_tag  {};
 
}// end of namespace layout_tags
 
 
//  SingleLevelLayout
 
template <class TInterface>
class SingleLevelLayout
{
  public:
    SingleLevelLayout()   {}
 
  //  typedefs required by implementation
    typedef std::map<int, TInterface> InterfaceMap;
 
  //  typedefs required by layout-tag
    typedef layout_tags::single_level_layout_tag  category_tag;
 
    typedef TInterface            Interface;
 
    typedef typename Interface::Type    Type;
 
    typedef typename Interface::Element   Element;
 
    typedef typename InterfaceMap::iterator     iterator;
    typedef typename InterfaceMap::const_iterator const_iterator;
 
  public:
  //  methods required by the layout-tag
 
 
    inline iterator begin(size_t level = 0)         {return m_interfaceMap.begin();}
    inline const_iterator begin(size_t level = 0) const   {return m_interfaceMap.begin();}
 
 
    inline iterator end(size_t level = 0)         {return m_interfaceMap.end();}
    inline const_iterator end(size_t level = 0) const   {return m_interfaceMap.end();}
 
 
    inline bool empty(size_t level = 0) const         {return begin() == end();}
    
    inline size_t num_levels() const            {return 1;}
    
    inline Interface& interface(iterator iter)            {return iter->second;}
    inline const Interface& interface(const_iterator iter) const  {return iter->second;}
 
    inline int proc_id(iterator iter) const         {return iter->first;}
    inline int proc_id(const_iterator iter) const     {return iter->first;}
 
 
    inline iterator erase(iterator iter, size_t level = 0)
      {
        iterator tIter = iter++;
        m_interfaceMap.erase(tIter);
        return iter;
      }
    
    void clear()                      {m_interfaceMap.clear();}
 
 
    inline Interface& interface(int procID, size_t level = 0)
    {
      iterator iter = m_interfaceMap.find(procID);
      if(iter != m_interfaceMap.end())
        return iter->second;
      return m_interfaceMap.insert(make_pair(procID, Interface(procID))).first->second;
    }
 
    inline const Interface& interface(int procID, size_t level = 0) const
    {
      const_iterator iter = m_interfaceMap.find(procID);
      UG_ASSERT(iter != m_interfaceMap.end(), "trying to access an non-existing interface in a constant layout");
      return iter->second;
    }
 
    inline bool interface_exists(int procID, size_t level = 0) const
      {return m_interfaceMap.find(procID) != m_interfaceMap.end();}
 
    inline size_t num_interface_elements() const
    {
      size_t sum = 0;
      for(const_iterator iter = begin(); iter != end(); ++iter)
        sum += interface(iter).size();
      return sum;
    }
 
    inline bool has_interface_elements() const
    {
      for(iterator iter = begin(); iter != end(); ++iter){
        if(!interface(iter).empty())
          return true;
      }
      return false;
    }
 
    inline size_t num_interfaces(size_t level = 0) const
    {
      return m_interfaceMap.size();
    }
 
    template <class TCompare>
    void sort_interface_entries(TCompare cmp)
    {
      for(iterator iter = begin(); iter != end(); ++iter)
        interface(iter).sort(cmp);
    }
 
  private:
/*
    SingleLevelLayout(const SingleLevelLayout& sll);
 
    SingleLevelLayout& operator = (const SingleLevelLayout& sll);
*/
  protected:
    InterfaceMap  m_interfaceMap;
};
 
//  MultiLevelLayout
 
template <class TInterface>
class MultiLevelLayout
{
  public:
  //  typedefs required by implementation
    typedef SingleLevelLayout<TInterface>   LevelLayout;
 
  //  typedefs required by layout-tag
    typedef layout_tags::multi_level_layout_tag category_tag;
 
    typedef TInterface              Interface;
 
    typedef typename Interface::Type      Type;
 
    typedef typename Interface::Element     Element;
 
    typedef typename LevelLayout::iterator      iterator;
    typedef typename LevelLayout::const_iterator  const_iterator;
 
  public:
    MultiLevelLayout()                {}
    MultiLevelLayout(const MultiLevelLayout& mll) {assign_layout(mll);}
 
    ~MultiLevelLayout()               {clear();}
 
    MultiLevelLayout& operator = (const MultiLevelLayout& mll)
    {
      assign_layout(mll);
      return *this;
    }
 
  //  methods required by the layout-tag
 
 
    inline iterator begin(size_t level)       {require_level(level); return m_vLayouts[level]->begin();}
    inline const_iterator begin(size_t level) const {require_level(level); return m_vLayouts[level]->begin();}
 
 
    inline iterator end(size_t level)       {require_level(level); return m_vLayouts[level]->end();}
    inline const_iterator end(size_t level) const {require_level(level); return m_vLayouts[level]->end();}
 
 
    inline bool empty(size_t level)         {return begin(level) == end(level);}
    inline bool empty(size_t level) const     {return begin(level) == end(level);}
 
 
    inline bool empty() const           {for(size_t l = 0; l < num_levels(); ++l){if(!empty(l)) return false;} return true;}
 
    inline Interface& interface(iterator iter)            {return iter->second;}
    inline const Interface& interface(const_iterator iter) const  {return iter->second;}
 
    inline int proc_id(const_iterator iter) const         {return iter->first;}
 
 
    inline iterator erase(iterator iter, size_t level)  {return m_vLayouts[level]->erase(iter);}
    
    inline size_t num_levels()  const         {return m_vLayouts.size();}
 
  //  methods that enhance the layout-tag
    void clear()
    {
      for(size_t i = 0; i < m_vLayouts.size(); ++i)
        delete m_vLayouts[i];
      m_vLayouts.clear();
    }
 
 
    inline Interface& interface(int procID, size_t level)       {require_level(level); return m_vLayouts[level]->interface(procID);}
    inline const Interface& interface(int procID, size_t level) const {require_level(level); return m_vLayouts[level]->interface(procID);}
 
    inline bool interface_exists(int procID, size_t level)      {require_level(level); return m_vLayouts[level]->interface_exists(procID);}
    inline bool interface_exists(int procID, size_t level) const  {require_level(level); return m_vLayouts[level]->interface_exists(procID);}
 
    inline bool interface_exists(int procID)        {for(size_t i = 0; i < num_levels(); ++i){if(m_vLayouts[i]->interface_exists(procID)) return true;} return false;}
    inline bool interface_exists(int procID) const      {for(size_t i = 0; i < num_levels(); ++i){if(m_vLayouts[i]->interface_exists(procID)) return true;} return false;}
 
 
    inline LevelLayout& layout_on_level(int level)        {require_level(level); return *m_vLayouts[level];}
    inline const LevelLayout& layout_on_level(int level) const  {require_level(level); return *m_vLayouts[level];}
 
    inline size_t num_interface_elements() const
    {
      size_t sum = 0;
      for(size_t lvl = 0; lvl < num_levels(); ++lvl){
        for(iterator iter = begin(lvl); iter != end(lvl); ++iter)
          sum += interface(iter).size();
      }
      return sum;
    }
 
    inline bool has_interface_elements() const
    {
      for(size_t lvl = 0; lvl < num_levels(); ++lvl){
        for(iterator iter = begin(lvl); iter != end(lvl); ++iter){
          if(!interface(iter).empty())
            return true;
        }
      }
      return false;
    }
 
    inline size_t num_interfaces(size_t level) const
    {
      return m_vLayouts[level].size();
    }
 
    template <class TCompare>
    void sort_interface_entries(TCompare cmp)
    {
      for(size_t lvl = 0; lvl < num_levels(); ++lvl)
        layout_on_level(lvl).sort_interface_entries(cmp);
    }
 
  protected:
    inline void new_levels(size_t num)    {for(size_t i = 0; i < num; ++i) m_vLayouts.push_back(new LevelLayout());}
 
    inline void require_level(size_t level)     {if(level >= num_levels()) new_levels(level - num_levels() + 1);}
    inline void require_level(size_t level) const {if(level >= num_levels()){UG_THROW("Level too high: " << level << ", while num_levels == " << num_levels());}}
 
    void assign_layout(const MultiLevelLayout& mll)
    {
      clear();
      for(size_t i = 0; i < mll.m_vLayouts.size(); ++i)
        m_vLayouts.push_back(new LevelLayout(*mll.m_vLayouts[i]));
    }
 
  protected:
    std::vector<LevelLayout*> m_vLayouts;
};
 
//  ICommunicationPolicy
 
template <class TLayout>
class ICommunicationPolicy
{
  public:
    typedef TLayout           Layout;
    typedef typename Layout::Interface  Interface;
 
    virtual ~ICommunicationPolicy() {}
 
  //  COLLECT AND EXTRACT
 
    virtual int
    get_required_buffer_size(const Interface& interface)  {return -1;}
    
  //  COLLECT
 
    virtual bool
    begin_layout_collection(const Layout* pLayout)      {return true;}
 
 
    virtual bool
    end_layout_collection(const Layout* pLayout)      {return true;}
 
    virtual bool
    collect(ug::BinaryBuffer& buff, const Interface& interface) = 0;
 
  //  EXTRACT
 
    virtual bool
    begin_layout_extraction(const Layout* pLayout)      {return true;}
 
 
    virtual bool
    end_layout_extraction(const Layout* pLayout)      {return true;}
 
 
    virtual void begin_level_extraction(int level)      {}
 
 
    virtual bool
    extract(ug::BinaryBuffer& buff, const Interface& interface) = 0;
};
 
// end group pcl
 
}// end of namespace pcl
 
#endif