exchange.h

Go to the documentation of this file.

#ifndef EXCHANGE_T_H
#define EXCHANGE_T_H
 
// STL includes
#include <vector>
 
// Wm includes
#include "lib/wmudgfunctions.h"
#include "lib/wmunstructuredpatch.h"
#include <dfem/array/patch_array.h>
#include <dfem/variable/distributed_variable.h>
 
namespace wxm
{
namespace dfem
{
namespace sync
{
namespace tools
{
 
struct sync_link_t
{
public:
    sync_link_t(const WmUnstructuredPatchLink& link)
        : _link(link),
          _from_patch_index(link.from_patch().getPatchIndex()),
          _to_patch_index(link.to_patch().getPatchIndex()),
          _from_element_indexes(link.from_indexes()),
          _to_element_indexes(link.to_indexes()),
          _num_transfer_elements(link.getNumElements()),
          _to_rank(link.to_patch().getProcID()),
          _from_rank(link.from_patch().getProcID())
 
    {
    }
 
    const WmUnstructuredPatchLink& _link;
    int _from_patch_index;
    int _to_patch_index;
    const std::vector<int>& _from_element_indexes;
    const std::vector<int>& _to_element_indexes;
    int _num_transfer_elements;
    int _to_rank;
    int _from_rank;
 
protected:
};
 
typedef std::vector<sync_link_t*> sync_links_t;
 
class sync_chunk_t
{
public:
    sync_chunk_t()
    {
    }
 
    virtual ~sync_chunk_t()
    {
        for (size_t child_index = 0; child_index < _children.size(); child_index++)
        {
            SAFE_DELETE(_children[child_index]);
        }
    }
 
    virtual size_t size()
    {
        const int num_children = _children.size();
        _children_offsets.resize(num_children + 1, 0);
        for (int child_index = 0; child_index < num_children; child_index++)
        {
            sync_chunk_t& child = *_children[child_index];
            _children_offsets[child_index + 1] =
                _children_offsets[child_index] + child.size();
        }
        return _children_offsets.back();
    }
 
    //    /**
    //     * @brief Used to exchange between two local patches
    //     */
    //    virtual void direct_write()
    //    {
    //        for(int child_index = 0; child_index < _children.size(); child_index++){
    //            sync_chunk_t & child = *_children[child_index];
    //            child.direct_write();
    //        }
    //    }
 
    virtual void read(const real* from_data)
    {
        for (size_t child_index = 0; child_index < _children.size(); child_index++)
        {
            sync_chunk_t& child = *_children[child_index];
            child.read(from_data + _children_offsets[child_index]);
        }
    }
 
    virtual void write(real* to_data, size_t buf_size)
    {
        for (size_t child_index = 0; child_index < _children.size(); child_index++)
        {
            sync_chunk_t& child = *_children[child_index];
            if (buf_size < _children_offsets[child_index])
            {
                std::cerr << "buffer is too small\n";
                throw -1;
            }
            child.write(to_data + _children_offsets[child_index],
                        buf_size - _children_offsets[child_index]);
        }
    }
 
protected:
    std::vector<int> _children_offsets;
 
    std::vector<sync_chunk_t*> _children;
};
 
class component_patch_exchange_t : public sync_chunk_t
{
public:
    component_patch_exchange_t(const sync_link_t& link,
                               wxm::dfem::variable::distributed_variable_t& variable,
                               const int component_index);
 
    //    /**
    //     * @brief Used to exchange between two local patches
    //     */
    //    void direct_write();
 
    // debugging stuff
    void print_geometry_information();
 
    void read(const real* from_data);
 
    void write(real* to_data, size_t buf_size);
 
    size_t size()
    {
        return _link._num_transfer_elements * _element_size;
    }
 
protected:
    wxm::dfem::variable::distributed_variable_t& _variable;
 
    size_t _element_size;
 
    int _component_index;
 
    const sync_link_t& _link;
};
 
class component_exchange_t : public sync_chunk_t
{
public:
    component_exchange_t(const sync_links_t& sync_links,
                         wxm::dfem::variable::distributed_variable_t& variable,
                         const int component_index);
 
protected:
    const sync_links_t& _sync_links;
 
private:
};
 
class rank_exchange_t : public sync_chunk_t
{
public:
    rank_exchange_t(const WmDomain& domain, int from_rank, int to_rank);
 
    ~rank_exchange_t();
 
    size_t size();
 
    void add_component(wxm::dfem::variable::distributed_variable_t& variable,
                       const int component_index);
 
    void send();
 
    void recv_init();
 
    void recv_wait();
 
    void send_init();
 
    void send_wait();
 
protected:
    sync_links_t _sync_links;
 
    const WmDomain& _domain;
 
    std::vector<real> _buffer_allocation;
 
    int _to_rank;
 
    int _from_rank;
 
    int _msg_tag;
 
    const WxMsgBase& _msg;
 
    WxMsgStatus recv_status = nullptr;
 
    WxMsgStatus send_status = nullptr;
};
 
typedef std::vector<rank_exchange_t*> rank_exchanges_t;
 
class patch_exchange_t : public sync_chunk_t
{
public:
    patch_exchange_t(const WmUnstructuredPatchLink& link, const int tag_seed);
 
    ~patch_exchange_t();
 
    void add_component(wxm::dfem::variable::distributed_variable_t& variable,
                       const int component_index);
 
    size_t size();
 
    void send();
 
    void send_init();
 
    void send_wait();
 
    void recv_init();
 
    void recv_wait();
 
protected:
    sync_link_t _sync_link;
 
    std::vector<real> _buffer_allocation;
 
    int _msg_tag;
 
    const WxMsgBase& _msg;
 
    WxMsgStatus send_status = nullptr;
    WxMsgStatus recv_status = nullptr;
};
 
typedef std::vector<patch_exchange_t*> patch_exchanges_t;
} // namespace tools
} // namespace sync
} // namespace dfem
} // namespace wxm
 
#endif // EXCHANGE_T_H