ghs.h

Go to the documentation of this file.

 
#ifndef GHS_H
#define GHS_H
 
#include "ghs/msg.h"
#include "ghs/agent.h"
#include "ghs/level.h"
#include "ghs/edge.h"
#include "le/errno.h"
#include "seque/static_queue.h"
#include <array>
 
using seque::StaticQueue;
 
namespace le{
 
  namespace ghs{
 
    template <std::size_t NUM_AGENTS, std::size_t MSG_Q_SIZE>
      class GhsState
      {
 
        public:
 
          GhsState(agent_t my_id, Edge* edges, size_t num_edges);
          ~GhsState(); 
 
          le::Errno start_round(StaticQueue<Msg, MSG_Q_SIZE> &outgoing_msgs, size_t&);
 
          le::Errno process(const Msg &msg, StaticQueue<Msg, MSG_Q_SIZE> &outgoing_buffer, size_t& sz);
 
          bool is_converged() const;
 
          size_t get_n_peers() const { return n_peers; }
 
 
 
          le::Errno get_edge(const agent_t& to, Edge& out) const;
 
          bool has_edge( const agent_t to) const;
 
          le::Errno get_edge_status(const agent_t&to, status_t& out) const;
 
 
          le::Errno get_edge_metric(const agent_t &to, metric_t& m) const;
 
 
          le::Errno is_waiting_for(const agent_t& who, bool & out_waiting_for);
 
          le::Errno is_response_required(const agent_t &who, bool & response_required);
 
          le::Errno get_response_prompt(const agent_t &who, msg::InPartPayload &m);
 
          agent_t get_id() const;
 
          agent_t get_parent_id() const;
 
 
          agent_t get_leader_id() const;
 
          level_t get_level() const;
 
          size_t waiting_count() const;
 
          size_t delayed_count() const;
 
          Edge mwoe() const;
 
          
          le::Errno                 checked_index_of(const agent_t&, size_t& ) const;
 
 
 
          le::Errno mst_broadcast(const msg::Type, const msg::Data&, StaticQueue<Msg, MSG_Q_SIZE> &buf, size_t&) const;
 
 
          le::Errno mst_convergecast(const msg::Type, const msg::Data&, StaticQueue<Msg, MSG_Q_SIZE>&buf, size_t&)const;
 
          le::Errno typecast(const status_t status, const msg::Type, const msg::Data&, StaticQueue<Msg, MSG_Q_SIZE> &buf, size_t&) const;
 
 
        private:
 
 
          le::Errno set_edge(const Edge &e);
 
          le::Errno add_edge(const Edge &e){ return set_edge(e);}
 
          le::Errno set_edge_status(const agent_t &to, const status_t &status);
          
          le::Errno set_edge_metric(const agent_t &to, const metric_t m);
 
          le::Errno set_leader_id(const agent_t &leader);
  
          le::Errno set_level(const level_t &level);
 
          le::Errno set_waiting_for(const agent_t &who, const bool waiting_for);
          
          le::Errno set_response_required(const agent_t &who, const bool response_required);
 
          le::Errno set_response_prompt(const agent_t &who, const msg::InPartPayload& m);
 
          le::Errno set_parent_id(const agent_t& id);
 
 
          le::Errno reset();
 
 
 
          le::Errno process_srch(        agent_t from, const msg::SrchPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
          le::Errno process_srch_ret(    agent_t from, const msg::SrchRetPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
          le::Errno process_in_part(     agent_t from, const msg::InPartPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
          le::Errno process_ack_part(    agent_t from, const msg::AckPartPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
          le::Errno process_nack_part(   agent_t from, const msg::NackPartPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
          le::Errno process_noop( StaticQueue<Msg, MSG_Q_SIZE>&,  size_t&);
          
          le::Errno check_search_status( StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
 
          /* Join / Merge / Absorb stage message */
          //join_us does some heavy lifting to determine how partitions should be restructured and joined
          le::Errno process_join_us(     agent_t from, const msg::JoinUsPayload&, StaticQueue<Msg, MSG_Q_SIZE>&, size_t&);
 
          le::Errno check_new_level( StaticQueue<Msg, MSG_Q_SIZE>&, size_t& );
 
          le::Errno                  respond_later(const agent_t&, const msg::InPartPayload);
          
          le::Errno                  respond_no_mwoe( StaticQueue<Msg, MSG_Q_SIZE>&, size_t & );
 
 
          agent_t                  my_id;
          agent_t                  my_leader;
          level_t                  my_level;
          bool                     algorithm_converged;
          
          Edge                     best_edge;
 
          size_t                                n_peers;
          std::array<agent_t,NUM_AGENTS>        peers;
          std::array<bool,NUM_AGENTS>           waiting_for_response;
          std::array<Edge,NUM_AGENTS>           outgoing_edges;
          std::array<msg::InPartPayload,NUM_AGENTS>  response_prompt;
          std::array<bool,NUM_AGENTS>           response_required;
 
      };
 
#include "ghs_impl.hpp"
 
  }
}
 
#endif