make name of aggregation scheme more precise

AxelSchneewind · AxelSchneewind · commit 83a4131e3cd1 · 2025-12-17T12:50:52.000+01:00
Signed-off-by: Axel Schneewind &lt;axel.schneewind@hlrs.de&gt;
diff --git a/ompi/mca/part/persist_aggregated/Makefile.am b/ompi/mca/part/persist_aggregated/Makefile.am
@@ -38,7 +38,7 @@ local_sources = \
 	part_persist_aggregated_request.c \
 	part_persist_aggregated_sendreq.h \
 	part_persist_aggregated_sendreq.c \
-	schemes/part_persist_aggregated_scheme_simple.c
+	schemes/part_persist_aggregated_scheme_regular.c
 
 mcacomponentdir = $(ompilibdir)
 mcacomponent_LTLIBRARIES = $(component_install)
diff --git a/ompi/mca/part/persist_aggregated/part_persist_aggregated.h b/ompi/mca/part/persist_aggregated/part_persist_aggregated.h
@@ -161,7 +161,7 @@ mca_part_persist_aggregated_free_req(struct mca_part_persist_aggregated_request_
     // if on sender side, free aggregation state
     if (MCA_PART_PERSIST_AGGREGATED_REQUEST_PSEND == req->req_type) {
         mca_part_persist_aggregated_psend_request_t *sendreq = (mca_part_persist_aggregated_psend_request_t *) req;
-        part_persist_aggregate_simple_free(&sendreq->aggregation_state);
+        part_persist_aggregate_regular_free(&sendreq->aggregation_state);
     }
 
     for(i = 0; i < req->real_parts; i++) {
@@ -532,7 +532,7 @@ mca_part_persist_aggregated_psend_init(const void* buf,
     opal_output_verbose(5, ompi_part_base_framework.framework_output, "mapped given %lu*%lu partitioning to internal partitioning of %lu*%lu + %lu\n", parts, count, req->real_parts - 1, req->real_count, req->real_remainder);
 
     // init aggregation state
-    part_persist_aggregate_simple_init(&sendreq->aggregation_state, req->real_parts, factor, remaining_partitions);
+    part_persist_aggregate_regular_init(&sendreq->aggregation_state, req->real_parts, factor, remaining_partitions);
 
     /* non-blocking send set-up data */
     req->setup_info[0].dt_size = dt_size;
@@ -590,7 +590,7 @@ mca_part_persist_aggregated_start(size_t count, ompi_request_t** requests)
         // reset aggregation state here
         if (MCA_PART_PERSIST_AGGREGATED_REQUEST_PSEND == req->req_type) {
             mca_part_persist_aggregated_psend_request_t *sendreq = (mca_part_persist_aggregated_psend_request_t *)(req);
-            part_persist_aggregate_simple_reset(&sendreq->aggregation_state);
+            part_persist_aggregate_regular_reset(&sendreq->aggregation_state);
         }
 
         /* First use is a special case, to support lazy initialization */
@@ -648,7 +648,7 @@ mca_part_persist_aggregated_pready(size_t min_part,
     mca_part_persist_aggregated_psend_request_t *sendreq = (mca_part_persist_aggregated_psend_request_t *)(req);
     int internal_part_ready;
     for(i = min_part; i <= max_part && OMPI_SUCCESS == err; i++) {
-        part_persist_aggregate_simple_pready(&sendreq->aggregation_state, i, &internal_part_ready);
+        part_persist_aggregate_regular_pready(&sendreq->aggregation_state, i, &internal_part_ready);
 
         if (-1 != internal_part_ready) {
             if(true == req->initialized)
diff --git a/ompi/mca/part/persist_aggregated/part_persist_aggregated_sendreq.h b/ompi/mca/part/persist_aggregated/part_persist_aggregated_sendreq.h
@@ -28,7 +28,7 @@
 #ifndef PART_PERSIST_AGGREGATED_PSENDREQ_H
 #define PART_PERSIST_AGGREGATED_PSENDREQ_H
 
-#include "ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_simple.h"
+#include "ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_regular.h"
 
 #include "ompi/mca/part/persist_aggregated/part_persist_aggregated_request.h"
 #include "ompi/mca/part/base/part_base_psendreq.h"
diff --git a/ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_regular.c b/ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_regular.c
@@ -10,7 +10,7 @@
  *
  */
 
-#include "part_persist_aggregated_scheme_simple.h"
+#include "part_persist_aggregated_scheme_regular.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -21,7 +21,7 @@ static int internal_partition(struct part_persist_aggregation_state *state, int
     return public_part / state->aggregation_count;
 }
 
-void part_persist_aggregate_simple_init(struct part_persist_aggregation_state *state,
+void part_persist_aggregate_regular_init(struct part_persist_aggregation_state *state,
                                         int internal_partition_count, int factor, int last_internal_partition_size)
 {
     state->public_partition_count = (internal_partition_count - 1) * factor + last_internal_partition_size;
@@ -37,7 +37,7 @@ void part_persist_aggregate_simple_init(struct part_persist_aggregation_state *s
                                                                  sizeof(opal_atomic_uint32_t));
 }
 
-void part_persist_aggregate_simple_reset(struct part_persist_aggregation_state *state)
+void part_persist_aggregate_regular_reset(struct part_persist_aggregation_state *state)
 {
     // reset flags
     if (NULL != state->public_parts_ready) {
@@ -53,7 +53,7 @@ static inline int num_public_parts(struct part_persist_aggregation_state *state,
     return is_last_partition(state, partition) ? state->last_internal_partition_size : state->aggregation_count;
 }
 
-void part_persist_aggregate_simple_pready(struct part_persist_aggregation_state *state, int partition, int* available_partition)
+void part_persist_aggregate_regular_pready(struct part_persist_aggregation_state *state, int partition, int* available_partition)
 {
     int internal_part = internal_partition(state, partition);
 
@@ -68,7 +68,7 @@ void part_persist_aggregate_simple_pready(struct part_persist_aggregation_state
     }
 }
 
-void part_persist_aggregate_simple_free(struct part_persist_aggregation_state *state)
+void part_persist_aggregate_regular_free(struct part_persist_aggregation_state *state)
 {
     if (state->public_parts_ready != NULL)
         free((void*)state->public_parts_ready);
diff --git a/ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_regular.h b/ompi/mca/part/persist_aggregated/schemes/part_persist_aggregated_scheme_regular.h
@@ -18,8 +18,8 @@
  * where k can be selected to optimize internal partition size.
  */
 
-#ifndef PART_PERSIST_AGGREGATED_SCHEME_SIMPLE_H
-#define PART_PERSIST_AGGREGATED_SCHEME_SIMPLE_H
+#ifndef PART_PERSIST_AGGREGATED_SCHEME_REGULAR_H
+#define PART_PERSIST_AGGREGATED_SCHEME_REGULAR_H
 
 #include "ompi_config.h"
 
@@ -53,7 +53,7 @@ struct part_persist_aggregation_state {
  * @param[in] last_internal_partition_size  number of public partitions corresponding to last
  * internal partition
  */
-OMPI_DECLSPEC void part_persist_aggregate_simple_init(struct part_persist_aggregation_state *state,
+OMPI_DECLSPEC void part_persist_aggregate_regular_init(struct part_persist_aggregation_state *state,
                                                       int internal_partition_count,
                                                       int factor,
                                                       int last_internal_partition_size);
@@ -64,7 +64,7 @@ OMPI_DECLSPEC void part_persist_aggregate_simple_init(struct part_persist_aggreg
  * @param[out] state                pointer to aggregation state object
  */
 OMPI_DECLSPEC void
-part_persist_aggregate_simple_reset(struct part_persist_aggregation_state *state);
+part_persist_aggregate_regular_reset(struct part_persist_aggregation_state *state);
 
 /**
  * @brief marks a public partition as ready
@@ -73,14 +73,14 @@ part_persist_aggregate_simple_reset(struct part_persist_aggregation_state *state
  * @param[in] partition             index of the public partition to mark ready
  * @param[out] available_partition  index of the internal partition if it is ready, otherwise -1
  */
-OMPI_DECLSPEC void part_persist_aggregate_simple_pready(struct part_persist_aggregation_state *state,
+OMPI_DECLSPEC void part_persist_aggregate_regular_pready(struct part_persist_aggregation_state *state,
                                                       int partition, int* available_partition);
 
 /**
  * @brief destroys the aggregation scheme
  *
  * @param[in,out] state             pointer to aggregation state object
  */
-OMPI_DECLSPEC void part_persist_aggregate_simple_free(struct part_persist_aggregation_state *state);
+OMPI_DECLSPEC void part_persist_aggregate_regular_free(struct part_persist_aggregation_state *state);
 
 #endif

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`*`
`11`	`11`	`*/`
`12`	`12`
`13`		`-#include "part_persist_aggregated_scheme_simple.h"`
	`13`	`+#include "part_persist_aggregated_scheme_regular.h"`
`14`	`14`
`15`	`15`	`#include <stdlib.h>`
`16`	`16`	`#include <string.h>`
`@@ -21,7 +21,7 @@ static int internal_partition(struct part_persist_aggregation_state *state, int`
`21`	`21`	`return public_part / state->aggregation_count;`
`22`	`22`	`}`
`23`	`23`
`24`		`-void part_persist_aggregate_simple_init(struct part_persist_aggregation_state *state,`
	`24`	`+void part_persist_aggregate_regular_init(struct part_persist_aggregation_state *state,`
`25`	`25`	`int internal_partition_count, int factor, int last_internal_partition_size)`
`26`	`26`	`{`
`27`	`27`	`state->public_partition_count = (internal_partition_count - 1) * factor + last_internal_partition_size;`
`@@ -37,7 +37,7 @@ void part_persist_aggregate_simple_init(struct part_persist_aggregation_state *s`
`37`	`37`	`sizeof(opal_atomic_uint32_t));`
`38`	`38`	`}`
`39`	`39`
`40`		`-void part_persist_aggregate_simple_reset(struct part_persist_aggregation_state *state)`
	`40`	`+void part_persist_aggregate_regular_reset(struct part_persist_aggregation_state *state)`
`41`	`41`	`{`
`42`	`42`	`// reset flags`
`43`	`43`	`if (NULL != state->public_parts_ready) {`
`@@ -53,7 +53,7 @@ static inline int num_public_parts(struct part_persist_aggregation_state *state,`
`53`	`53`	`return is_last_partition(state, partition) ? state->last_internal_partition_size : state->aggregation_count;`
`54`	`54`	`}`
`55`	`55`
`56`		`-void part_persist_aggregate_simple_pready(struct part_persist_aggregation_state state, int partition, int available_partition)`
	`56`	`+void part_persist_aggregate_regular_pready(struct part_persist_aggregation_state state, int partition, int available_partition)`
`57`	`57`	`{`
`58`	`58`	`int internal_part = internal_partition(state, partition);`
`59`	`59`
`@@ -68,7 +68,7 @@ void part_persist_aggregate_simple_pready(struct part_persist_aggregation_state`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-void part_persist_aggregate_simple_free(struct part_persist_aggregation_state *state)`
	`71`	`+void part_persist_aggregate_regular_free(struct part_persist_aggregation_state *state)`
`72`	`72`	`{`
`73`	`73`	`if (state->public_parts_ready != NULL)`
`74`	`74`	`free((void*)state->public_parts_ready);`