Remove comparisons of signed to unsigned values

src/ipc/backend_ipc.cpp

@@ -137,7 +137,7 @@ IPCBackend::~IPCBackend() {
 
 void IPCBackend::setup_ctxs() {
   CHECK_HIP(hipMalloc(&ctx_array, sizeof(IPCContext) * maximum_num_contexts_));
-  for (int i = 0; i < maximum_num_contexts_; i++) {
+  for (size_t i = 0; i < maximum_num_contexts_; i++) {
     new (&ctx_array[i]) IPCContext(this);
     ctx_free_list.get()->push_back(ctx_array + i);
   }
@@ -367,7 +367,7 @@ void IPCBackend::init_wrk_sync_buffer() {
    * For all local processing elements, initialize the device-side array
    * with the IPC work/sync buffer addresses.
    */
-  for (size_t i = 0; i < num_pes; i++) {
+  for (int i = 0; i < num_pes; i++) {
     if (i != my_pe) {
       CHECK_HIP(hipIpcOpenMemHandle(
           reinterpret_cast<void**>(&Wrk_Sync_buffer_bases_[i]),
@@ -380,7 +380,7 @@ void IPCBackend::init_wrk_sync_buffer() {
 }
 
 void IPCBackend::cleanup_wrk_sync_buffer() {
-  for (size_t i = 0; i < num_pes; i++) {
+  for (int i = 0; i < num_pes; i++) {
     if (i != my_pe) {
       CHECK_HIP(hipIpcCloseMemHandle(Wrk_Sync_buffer_bases_[i]));
     }
@@ -444,7 +444,7 @@ void IPCBackend::teams_init() {
 
   /* Accommodating for largest possible data type for pWrk */
   pWrk_pool = reinterpret_cast<void *>(temp_Wrk_Sync_buff_ptr_);
-  temp_Wrk_Sync_buff_ptr_ += sizeof(double) * ROCSHMEM_REDUCE_MIN_WRKDATA_SIZE 
+  temp_Wrk_Sync_buff_ptr_ += sizeof(double) * ROCSHMEM_REDUCE_MIN_WRKDATA_SIZE
                             * max_num_teams;
 
 
@@ -466,16 +466,16 @@ void IPCBackend::teams_init() {
     alltoall_pSync = reinterpret_cast<long *>(
         &alltoall_pSync_pool[team_i * ROCSHMEM_ALLTOALL_SYNC_SIZE]);
 
-    for (int i = 0; i < ROCSHMEM_BARRIER_SYNC_SIZE; i++) {
+    for (size_t i = 0; i < ROCSHMEM_BARRIER_SYNC_SIZE; i++) {
       barrier_pSync[i] = ROCSHMEM_SYNC_VALUE;
     }
-    for (int i = 0; i < ROCSHMEM_REDUCE_SYNC_SIZE; i++) {
+    for (size_t i = 0; i < ROCSHMEM_REDUCE_SYNC_SIZE; i++) {
       reduce_pSync[i] = ROCSHMEM_SYNC_VALUE;
     }
-    for (int i = 0; i < ROCSHMEM_BCAST_SYNC_SIZE; i++) {
+    for (size_t i = 0; i < ROCSHMEM_BCAST_SYNC_SIZE; i++) {
       bcast_pSync[i] = ROCSHMEM_SYNC_VALUE;
     }
-    for (int i = 0; i < ROCSHMEM_ALLTOALL_SYNC_SIZE; i++) {
+    for (size_t i = 0; i < ROCSHMEM_ALLTOALL_SYNC_SIZE; i++) {
       alltoall_pSync[i] = ROCSHMEM_SYNC_VALUE;
     }
   }

src/ipc/context_ipc_device_coll.cpp

@@ -38,14 +38,14 @@ __device__ void IPCContext::internal_direct_barrier(int pe, int PE_start,
 #if defined(__gfx90a__)
     __threadfence_system();
 #endif /* __gfx90a__ */
-    for (size_t i = 1; i < n_pes; i++) {
+    for (int i = 1; i < n_pes; i++) {
       wait_until(&pSync[i], ROCSHMEM_CMP_EQ, flag_val);
       pSync[i] = ROCSHMEM_SYNC_VALUE;
     }
     threadfence_system();
 
     // Announce to other PEs that all have reached
-    for (size_t i = 1, j = PE_start + stride; i < n_pes; ++i, j += stride) {
+    for (int i = 1, j = PE_start + stride; i < n_pes; ++i, j += stride) {
       internal_putmem(&pSync[0], &flag_val, sizeof(*pSync), j);
 #if defined(__gfx90a__)
         __threadfence_system();
@@ -73,7 +73,7 @@ __device__ void IPCContext::internal_atomic_barrier(int pe, int PE_start,
     pSync[0] = ROCSHMEM_SYNC_VALUE;
     threadfence_system();
 
-    for (size_t i = 1, j = PE_start + stride; i < n_pes; ++i, j += stride) {
+    for (int i = 1, j = PE_start + stride; i < n_pes; ++i, j += stride) {
       internal_putmem(&pSync[0], &flag_val, sizeof(*pSync), j);
     }
   } else {

src/ipc/context_ipc_tmpl_device.hpp

@@ -156,7 +156,7 @@ __device__ T IPCContext::amo_fetch_cas(void *dest, T value, T cond, int pe) {
 template <typename T, ROCSHMEM_OP Op>
 __device__ void compute_reduce(T *src, T *dst, int size, int wg_id,
                                int wg_size) {
-  for (size_t i = wg_id; i < size; i += wg_size) {
+  for (int i = wg_id; i < size; i += wg_size) {
     OpWrap<Op>::Calc(src, dst, i);
   }
   __syncthreads();
@@ -299,12 +299,12 @@ __device__ void IPCContext::internal_ring_allreduce(
   int wg_size = get_flat_block_size();
   int wg_id = get_flat_block_id();
 
-  for (size_t i = wg_id; i < nelems; i += wg_size) {
+  for (int i = wg_id; i < nelems; i += wg_size) {
     dst[i] = src[i];
   }
   __syncthreads();
 
-  for (size_t seg = 0; seg < n_seg; seg++) {
+  for (int seg = 0; seg < n_seg; seg++) {
     off_seg = seg * seg_size;
     // Loop 2 in the algorithm above
     for (int iter = 0; iter < PE_size - 1; iter++) {
@@ -331,7 +331,7 @@ __device__ void IPCContext::internal_ring_allreduce(
     }
 
     // Loop 2 in the example above
-    for (size_t iter = PE_size - 1; iter < 2 * PE_size - 2; iter++) {
+    for (int iter = PE_size - 1; iter < 2 * PE_size - 2; iter++) {
       off_send = (((my_pe_in_team + 1 - iter + 2 * PE_size) % PE_size) * chunk_size);
       putmem_nbi_wg(reinterpret_cast<void *>(&dst[off_send + off_seg]),
                     reinterpret_cast<void *>(&dst[off_send + off_seg]),
@@ -351,7 +351,7 @@ __device__ void IPCContext::internal_ring_allreduce(
   }
   __syncthreads();
 
-  for (size_t i = wg_id; i < 2 * num_pes - 2; i += wg_size) {
+  for (int i = wg_id; i < 2 * num_pes - 2; i += wg_size) {
     pSync[i] = ROCSHMEM_SYNC_VALUE;
   }
   __syncthreads();