coordinator.h

/*
//@HEADER
// *****************************************************************************
//                                coordinator.h
//                       DARMA/loc => Location Coordinator
//         Copyright 2019-2024 NTESS (see LICENSE for full details)
// *****************************************************************************
//@HEADER
*/
 
#if !defined INCLUDED_LOC_COORDINATOR_H
#define INCLUDED_LOC_COORDINATOR_H
 
#include "loc/common.h"
#include "loc/communicator.h"
#include "loc/lookup/lookup.h"
#include "loc/record/record.h"
 
#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace loc {

template <typename EntityID, typename Comm>
struct Coordinator {
  static_assert(
    Communicator<Comm, Coordinator<EntityID, Comm>>,
    "Coordinator requires a Comm satisfying loc::Communicator"
  );
 
  using ThisType = Coordinator<EntityID, Comm>;
  using LocRecType = LocRecord<EntityID>;
  using HandleType = typename Comm::template HandleType<ThisType>;
  using NodeAction = std::function<void(NodeType)>;
  using ExistsAction = std::function<void(bool, NodeType)>;

  explicit Coordinator(
    Comm& in_comm, LocationSizeType in_max_cache_size = default_max_cache_size
  );
 
  Coordinator(Coordinator const&) = delete;
  Coordinator(Coordinator&&) = delete;
  Coordinator& operator=(Coordinator const&) = delete;

  void registerEntity(EntityID const& id, NodeType home);

  void entityImmigrated(EntityID const& id, NodeType home, NodeType from);

  void entityEmigrated(EntityID const& id, NodeType new_node);

  void unregisterEntity(EntityID const& id);

  void getLocation(EntityID const& id, NodeType home, NodeAction action);

  void entityExists(EntityID const& id, NodeType home, ExistsAction action);

  bool isCached(EntityID const& id) const;

  void clearCache();

  NodeType thisNode() const;
 
public:
  //
  // Control-plane RPC handlers. These are invoked by the communicator on
  // message receipt (via Comm::send<&handler>); they are not part of the
  // user-facing API but must be public so their member-pointers are usable.
  //

  void updateHome(EntityID id, NodeType node);

  void locationRequest(EntityID id, NodeType requester);

  void resolveResponse(EntityID id, NodeType node);

  void existsRequest(EntityID id, NodeType requester);

  void existsResponse(EntityID id, bool exists, NodeType node);
 
private:
  LocRecType makeRec(EntityID const& id, NodeType node) const;

  static void flushPending(
    std::unordered_map<EntityID, std::vector<NodeAction>>& map,
    EntityID const& id, NodeType node
  );

  void announceLocation(EntityID const& id, NodeType node);
 
private:
  Comm& comm_;
  NodeType this_node_ = no_node;
  HandleType handle_{};

  std::unordered_set<EntityID> local_registered_;

  LocLookup<EntityID, LocRecType> recs_;

  std::unordered_map<EntityID, std::vector<NodeAction>> pending_;

  std::unordered_map<EntityID, std::vector<ExistsAction>> pending_exists_;

  std::unordered_map<EntityID, std::vector<NodeType>> pending_home_;

  std::unordered_map<EntityID, std::unordered_set<NodeType>> loc_asks_;
};
 
} /* end namespace loc */
 
#include "loc/coordinator.impl.h"
 
#endif /*INCLUDED_LOC_COORDINATOR_H*/