Fix some typos and trailing spaces

Keluaa · Keluaa · commit efdb534e3b25 · 2024-11-28T08:48:48.000+01:00
Signed-off-by: Keluaa &lt;34173752+Keluaa@users.noreply.github.com&gt;
diff --git a/ompi/mca/part/persist/part_persist.h b/ompi/mca/part/persist/part_persist.h
@@ -74,7 +74,7 @@ struct ompi_part_persist_t {
                                                unused in part_comm. */
     ompi_request_t        *part_comm_sreq;
     int32_t                part_comm_sready;
-    int32_t                init_comms;    
+    int32_t                init_comms;
     int32_t                init_world;
     int32_t                my_world_rank; /* Because the back end communicators use a world rank, we need to communicate ours 
                                              to set up the requests. */
@@ -138,12 +138,12 @@ __opal_attribute_always_inline__ static inline void
 mca_part_persist_complete(struct mca_part_persist_request_t* request)
 {
     if(MCA_PART_PERSIST_REQUEST_PRECV == request->req_type) {
-        request->req_ompi.req_status.MPI_SOURCE = request->req_peer; 
+        request->req_ompi.req_status.MPI_SOURCE = request->req_peer;
     } else {
         request->req_ompi.req_status.MPI_SOURCE = request->req_comm->c_my_rank;
     }
     request->req_ompi.req_complete_cb = NULL;
-    request->req_ompi.req_status.MPI_TAG = request->req_tag;  
+    request->req_ompi.req_status.MPI_TAG = request->req_tag;
     request->req_ompi.req_status._ucount = request->req_bytes;
     request->req_ompi.req_status.MPI_ERROR = OMPI_SUCCESS;
     request->req_part_complete = true;
@@ -189,7 +189,6 @@ mca_part_persist_progress(void)
         if(OMPI_SUCCESS != err) goto end_part_progress;
         ompi_part_persist.part_comm_sready = 0;
         ompi_part_persist.init_world = 1;
-
         completed++;
         goto end_part_progress;
     }
@@ -214,16 +213,16 @@ mca_part_persist_progress(void)
     OPAL_LIST_FOREACH(current, ompi_part_persist.progress_list, mca_part_persist_list_t) {
         mca_part_persist_request_t *req = (mca_part_persist_request_t *) current->item;
 
-        /* Check to see if request is initilaized */
+        /* Check to see if request is initialized */
         if(false == req->initialized) {
-            int done = 0; 
-            
+            int done = 0;
+
             if(true == req->flag_post_setup_recv) {
                 err = MCA_PML_CALL(irecv(&(req->setup_info[1]), sizeof(struct ompi_mca_persist_setup_t), MPI_BYTE, OMPI_ANY_SOURCE, req->my_recv_tag, ompi_part_persist.part_comm_setup, &req->setup_req[1]));
                 if(OMPI_SUCCESS != err) goto end_part_progress;
                 req->flag_post_setup_recv = false;
-            } 
- 
+            }
+
             err = ompi_request_test(&(req->setup_req[1]), &done, MPI_STATUS_IGNORE);
             if(OMPI_SUCCESS != err) goto end_part_progress;
 
@@ -233,7 +232,7 @@ mca_part_persist_progress(void)
 
                 if(MCA_PART_PERSIST_REQUEST_PSEND == req->req_type) {
                     /* parse message */
-                    req->world_peer  = req->setup_info[1].world_rank; 
+                    req->world_peer  = req->setup_info[1].world_rank;
 
                     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
                     if(OMPI_SUCCESS != err) goto end_part_progress;
@@ -246,24 +245,22 @@ mca_part_persist_progress(void)
                         void *buf = ((void*) (((char*)req->req_addr) + (bytes * i)));
                         err = MCA_PML_CALL(isend_init(buf, req->real_count, req->req_datatype, req->world_peer, req->my_send_tag+i, MCA_PML_BASE_SEND_STANDARD, ompi_part_persist.part_comm, &(req->persist_reqs[i])));
                         if(OMPI_SUCCESS != err) goto end_part_progress;
-                    }    
+                    }
                 } else {
                     /* parse message */
-                    req->world_peer   = req->setup_info[1].world_rank; 
+                    req->world_peer   = req->setup_info[1].world_rank;
                     req->my_send_tag  = req->setup_info[1].start_tag;
                     req->my_recv_tag  = req->setup_info[1].setup_tag;
                     req->real_parts   = req->setup_info[1].num_parts;
                     req->real_count   = req->setup_info[1].count;
                     req->real_dt_size = req->setup_info[1].dt_size;
 
-
                     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
                     if(OMPI_SUCCESS != err) goto end_part_progress;
                     dt_size = (dt_size_ > (size_t) UINT_MAX) ? MPI_UNDEFINED : (uint32_t) dt_size_;
                     uint32_t bytes = req->real_count * dt_size;
 
-
-                    /* Set up persistent sends */
+                    /* Set up persistent receives */
                     req->persist_reqs = (ompi_request_t**) malloc(sizeof(ompi_request_t*)*(req->real_parts));
                     req->flags = (int*) calloc(req->real_parts,sizeof(int));
                     if(req->real_dt_size == dt_size) {
@@ -293,10 +290,9 @@ mca_part_persist_progress(void)
             }
         } else {
             if(false == req->req_part_complete && REQUEST_COMPLETED != req->req_ompi.req_complete && OMPI_REQUEST_ACTIVE == req->req_ompi.req_state) {
-               for(i = 0; i < req->real_parts; i++) {
-
-                    /* Check to see if partition is queued for being started. Only applicable to sends. */ 
-                    if(-2 ==  req->flags[i]) {
+                for(i = 0; i < req->real_parts; i++) {
+                    /* Check to see if partition is queued for being started. Only applicable to sends. */
+                    if(-2 == req->flags[i]) {
                         err = req->persist_reqs[i]->req_start(1, (&(req->persist_reqs[i])));
                         if(OMPI_SUCCESS != err) goto end_part_progress;
                         req->flags[i] = 0;
@@ -343,7 +339,7 @@ mca_part_persist_progress(void)
 
 __opal_attribute_always_inline__ static inline int
 mca_part_persist_precv_init(void *buf,
-                        size_t parts, 
+                        size_t parts,
                         size_t count,
                         ompi_datatype_t * datatype,
                         int src,
@@ -374,9 +370,9 @@ mca_part_persist_precv_init(void *buf,
 
     mca_part_persist_request_t *req = (mca_part_persist_request_t *) recvreq;
 
-    /* Set lazy initializion flags */
+    /* Set lazy initialization flags */
     req->initialized = false;
-    req->first_send  = true; 
+    req->first_send  = true;
     req->flag_post_setup_recv = false;
     req->flags = NULL;
     /* Non-blocking receive on setup info */
@@ -398,7 +394,7 @@ mca_part_persist_precv_init(void *buf,
     /* Add element to progress engine */
     new_progress_elem = OBJ_NEW(mca_part_persist_list_t);
     new_progress_elem->item = req;
-    req->progress_elem = new_progress_elem; 
+    req->progress_elem = new_progress_elem;
     OPAL_THREAD_LOCK(&ompi_part_persist.lock);
     opal_list_append(ompi_part_persist.progress_list, (opal_list_item_t*)new_progress_elem);
     OPAL_THREAD_UNLOCK(&ompi_part_persist.lock);
@@ -441,7 +437,6 @@ mca_part_persist_psend_init(const void* buf,
     /* Set lazy initialization variables */
     req->initialized = false;
     req->first_send  = true; 
-    
 
     /* Determine total bytes to send. */
     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
@@ -451,7 +446,7 @@ mca_part_persist_psend_init(const void* buf,
 
     /* non-blocking send set-up data */
     req->setup_info[0].world_rank = ompi_comm_rank(&ompi_mpi_comm_world.comm);
-    req->setup_info[0].start_tag = ompi_part_persist.next_send_tag; ompi_part_persist.next_send_tag += parts; 
+    req->setup_info[0].start_tag = ompi_part_persist.next_send_tag; ompi_part_persist.next_send_tag += parts;
     req->my_send_tag = req->setup_info[0].start_tag;
     req->setup_info[0].setup_tag = ompi_part_persist.next_recv_tag; ompi_part_persist.next_recv_tag++;
     req->my_recv_tag = req->setup_info[0].setup_tag;
@@ -475,7 +470,7 @@ mca_part_persist_psend_init(const void* buf,
         req->flag_post_setup_recv = true;
     }
 
-    /* Initilaize completion variables */
+    /* Initialize completion variables */
     sendreq->req_base.req_ompi.req_persistent = true;
     req->req_part_complete = true;
     req->req_ompi.req_complete = REQUEST_COMPLETED;
@@ -522,15 +517,15 @@ mca_part_persist_start(size_t count, ompi_request_t** requests)
                 }
             } else {
                 req->done_count = 0;
-            } 
-        } 
-        req->req_ompi.req_state = OMPI_REQUEST_ACTIVE;    
+            }
+        }
+        req->req_ompi.req_state = OMPI_REQUEST_ACTIVE;
         req->req_ompi.req_status.MPI_TAG = MPI_ANY_TAG;
         req->req_ompi.req_status.MPI_ERROR = OMPI_SUCCESS;
         req->req_ompi.req_status._cancelled = 0;
         req->req_part_complete = false;
         req->req_ompi.req_complete = false;
-        OPAL_ATOMIC_SWAP_PTR(&req->req_ompi.req_complete, REQUEST_PENDING);   
+        OPAL_ATOMIC_SWAP_PTR(&req->req_ompi.req_complete, REQUEST_PENDING);
     }
 
     return err;
@@ -564,7 +559,7 @@ mca_part_persist_pready(size_t min_part,
 __opal_attribute_always_inline__ static inline int
 mca_part_persist_parrived(size_t min_part,
                       size_t max_part,
-                      int* flag, 
+                      int* flag,
                       ompi_request_t* request)
 {
     int err = OMPI_SUCCESS;
@@ -576,7 +571,7 @@ mca_part_persist_parrived(size_t min_part,
         _flag = 1;
         if(req->req_parts == req->real_parts) {
             for(i = min_part; i <= max_part; i++) {
-                _flag = _flag && req->flags[i];            
+                _flag = _flag && req->flags[i];
             }
         } else {
             float convert = ((float)req->real_parts) / ((float)req->req_parts);
@@ -590,7 +585,7 @@ mca_part_persist_parrived(size_t min_part,
 
     if(!_flag) {
         opal_progress();
-    } 
+    }
     *flag = _flag;
     return err;
 }
@@ -614,4 +609,4 @@ mca_part_persist_free(ompi_request_t** request)
 
 END_C_DECLS
 
-#endif  /* PART_PERSIST_H_HAS_BEEN_INCLUDED */
+#endif  /* PART_PERSIST_H */
