Support data member inquiry API functions & internal C++ conveniences

include/fenix.h

@@ -610,10 +610,23 @@ int Fenix_Data_subset_createv(int num_blocks, int *array_start_offsets,
  */
 int Fenix_Data_subset_delete(Fenix_Data_subset *subset_specifier);
 
-//!@unimplemented Get the number of members in a data group.
+/**
+ * @brief Get the number of members in a data group.
+ *
+ * @param[in] group_id The group to query
+ * @param[out] number_of_members Number of members in the group
+ */
 int Fenix_Data_group_get_number_of_members(int group_id, int *number_of_members);
 
-//!@unimplemented Get member ID based on member index
+/**
+ * @brief Get member ID based on member index
+ *
+ * See #Fenix_Data_group_get_number_of_members
+ *
+ * @param[in] group_id The group to query
+ * @param[out] member_id The member id at this index in the group
+ * @param[in] position The position to check, [0, number_of_members)
+ */
 int Fenix_Data_group_get_member_at_position(int group_id, int *member_id,
                                             int position);
 

include/fenix_data_group.hpp

@@ -60,6 +60,7 @@
 
 #include <mpi.h>
 #include "fenix.h"
+#include "fenix_ext.hpp"
 #include "fenix_data_member.hpp"
 #include "fenix_data_packet.hpp"
 #include "fenix_util.hpp"
@@ -71,6 +72,13 @@ typedef struct __fenix_group_vtbl fenix_group_vtbl_t;
 typedef struct __fenix_group fenix_group_t;
 
 
+namespace fenix::data {
+
+using member_iterator = std::pair<int, fenix_member_entry_t*>;
+
+} //end namespace fenix::data
+
+
 //This defines the functions which must be implemented by the group
 typedef struct __fenix_group_vtbl {
    int (*group_delete)(fenix_group_t* group);
@@ -140,7 +148,12 @@ typedef struct __fenix_group {
     int timestamp;
     int depth;
     int policy_name;
-    fenix_member_t *member;
+    std::vector<fenix_member_entry_t> members;
+
+    //Search for id, returning {-1, nullptr} if not found.
+    fenix::data::member_iterator search_member(int id);
+    //As search_member, but print an error message is id not found.
+    fenix::data::member_iterator find_member(int id);
 } fenix_group_t;
 
 typedef struct __fenix_data_recovery {
@@ -172,4 +185,12 @@ int __fenix_search_groupid( int key, fenix_data_recovery_t *dr);
 
 int __fenix_find_next_group_position( fenix_data_recovery_t *dr );
 
+namespace fenix::data {
+
+using group_iterator = std::pair<int, fenix_group_t*>;
+
+group_iterator find_group(int id, fenix_data_recovery_t *dr = fenix_rt.data_recovery);
+
+} //end namespace fenix::data
+
 #endif // FENIX_DATA_GROUP_H

include/fenix_data_member.hpp

@@ -63,42 +63,32 @@
 
 #define __FENIX_DEFAULT_MEMBER_SIZE 512
 
+typedef struct __fenix_group fenix_group_t;
+
 typedef struct __fenix_member_entry {
-    int memberid;
+    int memberid = -1;
     enum states state;
-    void *user_data;
+    void *user_data = nullptr;
     int datatype_size;
     int current_count;
 } fenix_member_entry_t;
 
-typedef struct __fenix_member {
-    size_t count;
-    size_t total_size;
-    fenix_member_entry_t *member_entry;
-} fenix_member_t;
-
 typedef struct __member_entry_packet {
     int memberid;
     int datatype_size;
     int current_count;
 } fenix_member_entry_packet_t;
 
-fenix_member_t *__fenix_data_member_init( );
-void __fenix_data_member_destroy( fenix_member_t *member ) ;
-
-void __fenix_ensure_member_capacity( fenix_member_t *m );
-void __fenix_ensure_version_capacity_from_member( fenix_member_t *m );
-
-fenix_member_entry_t* __fenix_data_member_add_entry(fenix_member_t* member, 
+fenix_member_entry_t* __fenix_data_member_add_entry(fenix_group_t* group,
         int memberid, void* data, int count, int datatype_size);
 
 int __fenix_data_member_send_metadata(int groupid, int memberid, int dest_rank);
 int __fenix_data_member_recv_metadata(int groupid, int src_rank, 
         fenix_member_entry_packet_t* packet);
 
-int __fenix_search_memberid(fenix_member_t* member, int memberid);
-int __fenix_find_next_member_position(fenix_member_t *m);
+int __fenix_search_memberid(fenix_group_t* group, int memberid);
 
-void __fenix_data_member_reinit(fenix_member_t *m, fenix_two_container_packet_t packet,
+void __fenix_data_member_reinit(fenix_group_t *group, fenix_two_container_packet_t packet,
                    enum states mystatus);
+
 #endif // FENIX_DATA_MEMBER_H

include/fenix_ext.hpp

@@ -61,9 +61,10 @@
 #include <vector>
 #include "fenix.h"
 #include "fenix_opt.hpp"
-#include "fenix_data_group.hpp"
 #include "fenix_process_recovery.hpp"
 
+typedef struct __fenix_data_recovery fenix_data_recovery_t;
+
 typedef struct {
     int num_inital_ranks;     // Keeps the global MPI rank ID at Fenix_init
     int num_survivor_ranks;   // Keeps the global information on the number of survived MPI ranks after failure

src/fenix.cpp

@@ -161,11 +161,11 @@ int Fenix_Data_subset_delete(Fenix_Data_subset *subset_specifier) {
 }
 
 int Fenix_Data_group_get_number_of_members(int group_id, int *number_of_members) {
-    return 0;
+    return __fenix_get_number_of_members(group_id, number_of_members);
 }
 
 int Fenix_Data_group_get_member_at_position(int group_id, int *member_id, int position) {
-    return 0;
+    return __fenix_get_member_at_position(group_id, member_id, position);
 }
 
 int Fenix_Data_group_get_number_of_snapshots(int group_id, int *number_of_snapshots) {

src/fenix_data_group.cpp

@@ -61,7 +61,35 @@
 #include "fenix_data_member.hpp"
 #include "fenix_data_packet.hpp"
 
+namespace fenix::data {
 
+group_iterator find_group(int id, fenix_data_recovery_t* dr){
+  int index = __fenix_search_groupid(id, dr);
+  if(index == -1){
+    debug_print("ERROR: group_id <%d> does not exist\n", id);
+    return {index, nullptr};
+  }
+  return {index, dr->group[index]};
+}
+
+} //end namespace fenix::data
+
+using namespace fenix::data;
+
+member_iterator fenix_group_t::search_member(int id){
+  for(int i = 0; i < members.size(); i++){
+    if(members[i].memberid == id){
+      return {i, &(members[i])};
+    }
+  }
+  return {-1, nullptr};
+}
+
+member_iterator fenix_group_t::find_member(int id){
+  auto it = search_member(id);
+  if(it.first == -1) debug_print("ERROR group <%d>: member_id <%d> does not exist\n", groupid, id);
+  return it;
+}
 
 /**
  * @brief
@@ -85,51 +113,30 @@ fenix_data_recovery_t * __fenix_data_recovery_init() {
 }
 
 int __fenix_member_delete(int groupid, int memberid) {
-  int retval = -1;
-  int group_index = __fenix_search_groupid(groupid, fenix_rt.data_recovery );
-  int member_index = -1;
-  if(group_index !=-1){
-    member_index = __fenix_search_memberid(fenix_rt.data_recovery->group[group_index]->member, memberid);
-  }
+  auto [group_index, group] = find_group(groupid);
+  if(!group) return FENIX_ERROR_INVALID_GROUPID;
+
+  auto [member_index, mentry] = group->find_member(memberid);
+  if(!mentry) return FENIX_ERROR_INVALID_MEMBERID;
 
   if (fenix_rt.options.verbose == 38) {
     verbose_print("c-rank: %d, role: %d, group_index: %d, member_index: %d\n",
                     __fenix_get_current_rank(fenix_rt.new_world), fenix_rt.role, group_index,
                   member_index);
   }
 
-  if (group_index == -1) {
-    debug_print("ERROR Fenix_Data_member_delete: group_id <%d> does not exist\n",
-                groupid);
-    retval = FENIX_ERROR_INVALID_GROUPID;
-  } else if (member_index == -1) {
-    debug_print("ERROR Fenix_Data_member_delete: memberid <%d> does not exist\n",
-                memberid);
-    retval = FENIX_ERROR_INVALID_MEMBERID;
-  } else {
-    fenix_data_recovery_t *data_recovery = fenix_rt.data_recovery;
-    fenix_group_t *group = (data_recovery->group[group_index]);
-
-    retval = group->vtbl.member_delete(group, memberid);
-
-    if(retval == FENIX_SUCCESS){
-      fenix_member_t *member = group->member;
-      member->count--;
-      fenix_member_entry_t *mentry = &(member->member_entry[member_index]);
-      mentry->state = DELETED;
-    }
+  int retval = group->vtbl.member_delete(group, memberid);
 
-    if (fenix_rt.options.verbose == 38) {
-      fenix_member_t *member = group->member;
-      fenix_member_entry_t *mentry = &(member->member_entry[member_index]);
-
-      verbose_print("c-rank: %d, role: %d, m-count: %zu, m-state: %d",
-                      __fenix_get_current_rank(fenix_rt.new_world), fenix_rt.role,
-                    member->count, mentry->state);
-    }
+  if(retval == FENIX_SUCCESS){
+    group->members.erase(group->members.begin()+member_index);
+  }
 
-    retval = FENIX_SUCCESS;
+  if (fenix_rt.options.verbose == 38) {
+    verbose_print("c-rank: %d, role: %d, m-count: %zu",
+                    __fenix_get_current_rank(fenix_rt.new_world), fenix_rt.role,
+                  group->members.size());
   }
+
   return retval;
 }
 
@@ -150,8 +157,10 @@ int __fenix_group_delete_direct(fenix_group_t* group){
     return group->vtbl.group_delete(group);
 }
 
-int __fenix_data_recovery_remove_group(fenix_data_recovery_t* data_recovery, int group_index){
+int __fenix_data_recovery_remove_group(int group_index){
     int retval = !FENIX_SUCCESS;
+    auto data_recovery = fenix_rt.data_recovery;
+
     if(group_index != -1){
         for(int index = group_index; index < data_recovery->count-1; index++){
             data_recovery->group[index] = data_recovery->group[index+1];
@@ -167,28 +176,21 @@ int __fenix_data_recovery_remove_group(fenix_data_recovery_t* data_recovery, int
  * @param group_id
  */
 int __fenix_group_delete(int groupid) {
-  int retval = -1;
-  int group_index = __fenix_search_groupid(groupid, fenix_rt.data_recovery );
+  auto [group_index, group] = find_group(groupid);
+  if(!group) return FENIX_ERROR_INVALID_GROUPID;
 
   if (fenix_rt.options.verbose == 37) {
     verbose_print("c-rank: %d, group_index: %d\n",
                     __fenix_get_current_rank(fenix_rt.new_world), group_index);
   }
 
-  if (group_index == -1) {
-    debug_print("ERROR Fenix_Data_group_delete: group_id <%d> does not exist\n", groupid);
-    retval = FENIX_ERROR_INVALID_GROUPID;
-  } else {
-    /* Delete Process */
-    fenix_data_recovery_t *data_recovery = fenix_rt.data_recovery;
-    fenix_group_t *group = (data_recovery->group[group_index]);
-    retval = __fenix_group_delete_direct(group);
-
-    if(retval == FENIX_SUCCESS){ 
-        retval = __fenix_data_recovery_remove_group(data_recovery, group_index);
-    }
+  /* Delete Process */
+  int retval = __fenix_group_delete_direct(group);
 
+  if(retval == FENIX_SUCCESS){
+      retval = __fenix_data_recovery_remove_group(group_index);
   }
+
   return retval;
 }