Fix various warnings from the nvc compiler.

Author: insertinterestingnamehere

include/qt_alloc.h

@@ -27,6 +27,6 @@ void INTERNAL qt_internal_alignment_init(void);
 #pragma warning(disable : 191)
 #endif
 extern size_t _pagesize;
-#define pagesize ((const size_t)_pagesize)
+#define pagesize ((size_t)_pagesize)
 #endif // ifndef HAVE_QT_ALIGNED_ALLOC_H
 /* vim:set expandtab: */

src/affinity/hwloc.c

@@ -233,21 +233,21 @@ void INTERNAL qt_affinity_init(qthread_shepherd_id_t *nbshepherds,
       /* first, look for an exact match in width and find the proper depth */
       unsigned int maxdepth = hwloc_topology_get_depth(topology);
       unsigned int realdepth;
-      unsigned int fl_depth = -1; // first depth with #objs larger than nbsheps
+      unsigned int fl_depth = (unsigned int)-1; // first depth with #objs larger than nbsheps
       for (realdepth = 0; realdepth < maxdepth && shep_depth == -1;
            ++realdepth) {
         unsigned int num = num_usable_by_depth(realdepth);
         if (num == *nbshepherds) {
           shep_depth = realdepth;
-        } else if ((num > *nbshepherds) && (fl_depth == -1)) {
+        } else if ((num > *nbshepherds) && (fl_depth == (unsigned int)-1)) {
           fl_depth = realdepth;
         }
       }
       /* second, if we failed, try an approximate match... */
       /* should we use the last _smaller_, or the first _larger_ ? */
       /* first option means overlapping but we can use all the cores */
       /* second option means no overlapping, but cores will go unused */
-      if ((shep_depth == -1) && (fl_depth != -1)) {
+      if ((shep_depth == -1) && (fl_depth != (unsigned int)-1)) {
         /* first larger then */
         shep_depth = fl_depth;
       }

src/barrier/feb.c

@@ -91,7 +91,7 @@ void API_FUNC qt_barrier_enter(qt_barrier_t *b) {
     qthread_readFF(NULL, &b->out_gate);
   }
   /* I'm on the way out, so decrement the blocker count */
-  waiters = qthread_incr(&b->blockers, -1) - 1;
+  waiters = qthread_incr(&b->blockers, (aligned_t)-1) - 1u;
   if (waiters == 0) {
     /* last guy out of the barrier, close the out_gate, open the in_gate */
     qthread_empty(&b->out_gate);
@@ -119,7 +119,7 @@ void qt_global_barrier(void) {
 
 void qt_global_barrier_init(size_t size, int debug) {
   if (global_barrier == NULL) {
-    global_barrier = qt_barrier_create(size, 0);
+    global_barrier = qt_barrier_create(size, REGION_BARRIER);
     assert(global_barrier);
   }
 }

src/ds/dictionary/dictionary_shavit.c

@@ -386,7 +386,7 @@ static inline int qt_hash_remove(qt_hash h, qt_key_t const key) {
                          h->op_cleanup)) {
     return 0;
   }
-  qthread_incr(&h->count, -1);
+  qthread_incr(&h->count, (aligned_t)-1);
   return 1;
 }
 

src/ds/qarray.c

@@ -422,7 +422,7 @@ void qarray_destroy(qarray *a) { /*{{{ */
         qthread_incr(
           &chunk_distribution_tracker[qarray_internal_segment_shep_read(
             a, segmenthead)],
-          -1);
+          (aligned_t)-1);
       }
       break;
     }
@@ -435,14 +435,14 @@ void qarray_destroy(qarray *a) { /*{{{ */
       for (segment = 0; segment < segment_count; segment++) {
         qthread_incr(&chunk_distribution_tracker[qarray_internal_shepof_segidx(
                        a, segment)],
-                     -1);
+                     (aligned_t)-1);
       }
       break;
     }
     case ALL_SAME:
       qthread_incr(&chunk_distribution_tracker[a->dist_specific.dist_shep],
-                   -1 * (a->count / a->segment_size +
-                         ((a->count % a->segment_size) ? 1 : 0)));
+                   ((aligned_t)-1) * (a->count / a->segment_size +
+                                     ((a->count % a->segment_size) ? 1 : 0)));
       break;
   }
 #ifdef QTHREAD_HAVE_MEM_AFFINITY
@@ -1202,7 +1202,7 @@ void qarray_set_shepof(qarray *a,
 #endif /* ifdef QTHREAD_HAVE_MEM_AFFINITY */
         qthread_incr(&chunk_distribution_tracker[shep], segment_count);
         qthread_incr(&chunk_distribution_tracker[a->dist_specific.dist_shep],
-                     -1 * segment_count);
+                     ((aligned_t)-1) * segment_count);
         a->dist_specific.dist_shep = shep;
       }
       return;
@@ -1223,7 +1223,7 @@ void qarray_set_shepof(qarray *a,
         }
 #endif /* ifdef QTHREAD_HAVE_MEM_AFFINITY */
         qthread_incr(&chunk_distribution_tracker[shep], 1);
-        qthread_incr(&chunk_distribution_tracker[cur_shep], -1);
+        qthread_incr(&chunk_distribution_tracker[cur_shep], (aligned_t)-1);
         qarray_internal_segment_shep_write(a, seghead, shep);
       }
     }

src/qloop.c

@@ -1017,7 +1017,7 @@ static aligned_t qqloop_wrapper(void *arg_void) { /*{{{*/
       if (!qthread_shep_ok()) {
         /* my shepherd has been disabled while I was running */
         safeexit = 0;
-        qthread_incr(&(stat->activesheps), -1);
+        qthread_incr(&(stat->activesheps), (aligned_t)-1);
         break;
       }
     } while (get_iters(iq, stat, &range));
@@ -1131,7 +1131,7 @@ void API_FUNC qt_loop_queue_addworker(
   if (loop->stat.donecount == 0) {
     qthread_fork_to((qthread_f)qqloop_wrapper, loop->qwa + shep, NULL, shep);
   } else {
-    qthread_incr(&(loop->stat.activesheps), -1);
+    qthread_incr(&(loop->stat.activesheps), (aligned_t)-1);
   }
 } /*}}}*/
 

src/qthread.c

@@ -694,7 +694,7 @@ int API_FUNC qthread_initialize(void) { /*{{{ */
 
   /* initialize the shepherds as having no affinity */
   for (i = 0; i < nshepherds; i++) {
-    qlib->shepherds[i].node = -1;
+    qlib->shepherds[i].node = UINT32_MAX;
     qlib->shepherds[i].shep_dists = NULL;
     qlib->shepherds[i].sorted_sheplist = NULL;
     qlib->shepherds[i].workers =
@@ -1287,7 +1287,7 @@ API_FUNC void *qthread_tos(void) {
 API_FUNC void *qthread_bos(void) {
   qthread_t const *f = qthread_internal_self();
 
-  return f->rdata->stack + qlib->qthread_stack_size;
+  return (void *)((char *)f->rdata->stack + qlib->qthread_stack_size);
 }
 
 size_t API_FUNC qthread_stackleft(void) { /*{{{ */

src/queue.c

@@ -110,7 +110,7 @@ int API_FUNC qthread_queue_release_one(qthread_queue_t q) {
       break;
     case NEMESIS_LENGTH:
       t = qthread_queue_internal_NEMESIS_dequeue(&q->q.nemesis);
-      qthread_incr(&q->q.nemesis.length, -1);
+      qthread_incr(&q->q.nemesis.length, (aligned_t)-1);
       break;
     case CAPPED: t = qthread_queue_internal_capped_dequeue(&q->q.capped); break;
     default: QTHREAD_TRAP();
@@ -284,7 +284,7 @@ void INTERNAL qthread_queue_internal_capped_enqueue(qthread_queue_capped_t *q,
   offset = qthread_incr(&q->membercount, 1);
   qassert_retvoid(offset >= q->maxmembers);
   q->members[offset] = t;
-  qthread_incr(&q->busy, -1);
+  qthread_incr(&q->busy, (aligned_t)-1);
 }
 
 qthread_t INTERNAL *

src/shepherds.c

@@ -159,7 +159,7 @@ qthread_disable_shepherd(qthread_shepherd_id_t const shep) { /*{{{ */
     return QTHREAD_NOT_ALLOWED;
   }
   qthread_internal_incr(
-    &(qlib->nshepherds_active), &(qlib->nshepherds_active_lock), -1);
+    &(qlib->nshepherds_active), &(qlib->nshepherds_active_lock), (aligned_t)-1);
   (void)QT_CAS(qlib->shepherds[shep].active, 1, 0);
   return QTHREAD_SUCCESS;
 } /*}}} */

src/sincs/donecount.c

@@ -292,7 +292,7 @@ void API_FUNC qt_sinc_submit(qt_sinc_t *restrict sinc_,
   }
 
   // Update counter
-  qt_sinc_count_t count = qthread_incr(&sinc->counter, -1);
+  qt_sinc_count_t count = qthread_incr(&sinc->counter, (aligned_t)-1);
   assert(count > 0);
   if (1 == count) { // This is the final submit
     qt_sinc_internal_collate(sinc_);