Merge pull request #8647 from hjelmn/master_format_opal

opal: run clang-format on all of opal

Author: hjelmn

opal/class/opal_bitmap.c

@@ -23,44 +23,38 @@
 
 #include "opal_config.h"
 
-#include <stdio.h>
 #include <limits.h>
+#include <stdio.h>
 
-#include "opal/constants.h"
 #include "opal/class/opal_bitmap.h"
+#include "opal/constants.h"
 
 /* The number of bits in the underlying type of the bitmap field
  * in the opal_bitmap_t struct
  */
-#define SIZE_OF_BASE_TYPE  64
+#define SIZE_OF_BASE_TYPE 64
 
 static void opal_bitmap_construct(opal_bitmap_t *bm);
 static void opal_bitmap_destruct(opal_bitmap_t *bm);
 
-OBJ_CLASS_INSTANCE(opal_bitmap_t, opal_object_t,
-                   opal_bitmap_construct, opal_bitmap_destruct);
-
+OBJ_CLASS_INSTANCE(opal_bitmap_t, opal_object_t, opal_bitmap_construct, opal_bitmap_destruct);
 
-static void
-opal_bitmap_construct(opal_bitmap_t *bm)
+static void opal_bitmap_construct(opal_bitmap_t *bm)
 {
     bm->bitmap = NULL;
     bm->array_size = 0;
     bm->max_size = INT_MAX;
 }
 
-
-static void
-opal_bitmap_destruct(opal_bitmap_t *bm)
+static void opal_bitmap_destruct(opal_bitmap_t *bm)
 {
     if (NULL != bm->bitmap) {
         free(bm->bitmap);
         bm->bitmap = NULL;
     }
 }
 
-
-int opal_bitmap_set_max_size (opal_bitmap_t *bm, int max_size)
+int opal_bitmap_set_max_size(opal_bitmap_t *bm, int max_size)
 {
     if (NULL == bm) {
         return OPAL_ERR_BAD_PARAM;
@@ -71,14 +65,12 @@ int opal_bitmap_set_max_size (opal_bitmap_t *bm, int max_size)
      * we set it (in numbers of bits!), otherwise it is
      * set to INT_MAX in the constructor.
      */
-    bm->max_size = (int)(((size_t)max_size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
+    bm->max_size = (int) (((size_t) max_size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
 
     return OPAL_SUCCESS;
 }
 
-
-int
-opal_bitmap_init(opal_bitmap_t *bm, int size)
+int opal_bitmap_init(opal_bitmap_t *bm, int size)
 {
     /*
      * Only if the caller set the maximum size before initializing,
@@ -89,13 +81,14 @@ opal_bitmap_init(opal_bitmap_t *bm, int size)
         return OPAL_ERR_BAD_PARAM;
     }
 
-    bm->array_size = (int)(((size_t)size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
-    if( NULL != bm->bitmap ) {
+    bm->array_size = (int) (((size_t) size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
+    if (NULL != bm->bitmap) {
         free(bm->bitmap);
-        if(bm->max_size < bm->array_size)
+        if (bm->max_size < bm->array_size) {
             bm->max_size = bm->array_size;
+        }
     }
-    bm->bitmap = (uint64_t*) malloc(bm->array_size * sizeof(uint64_t));
+    bm->bitmap = (uint64_t *) malloc(bm->array_size * sizeof(uint64_t));
     if (NULL == bm->bitmap) {
         return OPAL_ERR_OUT_OF_RESOURCE;
     }
@@ -104,9 +97,7 @@ opal_bitmap_init(opal_bitmap_t *bm, int size)
     return OPAL_SUCCESS;
 }
 
-
-int
-opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
+int opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
 {
     int index, offset, new_size;
 
@@ -124,12 +115,13 @@ opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
          valid and we simply expand the bitmap */
 
         new_size = index + 1;
-        if( new_size > bm->max_size )
+        if (new_size > bm->max_size) {
             new_size = bm->max_size;
+        }
 
         /* New size is just a multiple of the original size to fit in
          the index. */
-        bm->bitmap = (uint64_t*)realloc(bm->bitmap, new_size*sizeof(uint64_t));
+        bm->bitmap = (uint64_t *) realloc(bm->bitmap, new_size * sizeof(uint64_t));
         if (NULL == bm->bitmap) {
             return OPAL_ERR_OUT_OF_RESOURCE;
         }
@@ -147,9 +139,7 @@ opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
     return OPAL_SUCCESS;
 }
 
-
-int
-opal_bitmap_clear_bit(opal_bitmap_t *bm, int bit)
+int opal_bitmap_clear_bit(opal_bitmap_t *bm, int bit)
 {
     int index, offset;
 
@@ -164,9 +154,7 @@ opal_bitmap_clear_bit(opal_bitmap_t *bm, int bit)
     return OPAL_SUCCESS;
 }
 
-
-bool
-opal_bitmap_is_set_bit(opal_bitmap_t *bm, int bit)
+bool opal_bitmap_is_set_bit(opal_bitmap_t *bm, int bit)
 {
     int index, offset;
 
@@ -184,9 +172,7 @@ opal_bitmap_is_set_bit(opal_bitmap_t *bm, int bit)
     return false;
 }
 
-
-int
-opal_bitmap_clear_all_bits(opal_bitmap_t *bm)
+int opal_bitmap_clear_all_bits(opal_bitmap_t *bm)
 {
     if (NULL == bm) {
         return OPAL_ERR_BAD_PARAM;
@@ -196,9 +182,7 @@ opal_bitmap_clear_all_bits(opal_bitmap_t *bm)
     return OPAL_SUCCESS;
 }
 
-
-int
-opal_bitmap_set_all_bits(opal_bitmap_t *bm)
+int opal_bitmap_set_all_bits(opal_bitmap_t *bm)
 {
     if (NULL == bm) {
         return OPAL_ERR_BAD_PARAM;
@@ -209,9 +193,7 @@ opal_bitmap_set_all_bits(opal_bitmap_t *bm)
     return OPAL_SUCCESS;
 }
 
-
-int
-opal_bitmap_find_and_set_first_unset_bit(opal_bitmap_t *bm, int *position)
+int opal_bitmap_find_and_set_first_unset_bit(opal_bitmap_t *bm, int *position)
 {
     int i = 0;
     uint64_t temp, all_ones = 0xffffffffffffffffUL;
@@ -222,7 +204,7 @@ opal_bitmap_find_and_set_first_unset_bit(opal_bitmap_t *bm, int *position)
 
     /* Neglect all which don't have an unset bit */
     *position = 0;
-    while((i < bm->array_size) && (bm->bitmap[i] == all_ones)) {
+    while ((i < bm->array_size) && (bm->bitmap[i] == all_ones)) {
         ++i;
     }
 
@@ -236,8 +218,8 @@ opal_bitmap_find_and_set_first_unset_bit(opal_bitmap_t *bm, int *position)
 
     temp = bm->bitmap[i];
     bm->bitmap[i] |= (bm->bitmap[i] + 1); /* Set the first zero bit */
-    temp ^= bm->bitmap[i];  /* Compute the change: the first unset bit in the original number */
-    while( !(temp & 0x1) ) {
+    temp ^= bm->bitmap[i]; /* Compute the change: the first unset bit in the original number */
+    while (!(temp & 0x1)) {
         ++(*position);
         temp >>= 1;
     }
@@ -253,17 +235,17 @@ int opal_bitmap_bitwise_and_inplace(opal_bitmap_t *dest, opal_bitmap_t *right)
     /*
      * Sanity check
      */
-    if( NULL == dest || NULL == right ) {
+    if (NULL == dest || NULL == right) {
         return OPAL_ERR_BAD_PARAM;
     }
-    if( dest->array_size != right->array_size ) {
+    if (dest->array_size != right->array_size) {
         return OPAL_ERR_BAD_PARAM;
     }
 
     /*
      * Bitwise AND
      */
-    for(i = 0; i < dest->array_size; ++i) {
+    for (i = 0; i < dest->array_size; ++i) {
         dest->bitmap[i] &= right->bitmap[i];
     }
 
@@ -277,17 +259,17 @@ int opal_bitmap_bitwise_or_inplace(opal_bitmap_t *dest, opal_bitmap_t *right)
     /*
      * Sanity check
      */
-    if( NULL == dest || NULL == right ) {
+    if (NULL == dest || NULL == right) {
         return OPAL_ERR_BAD_PARAM;
     }
-    if( dest->array_size != right->array_size ) {
+    if (dest->array_size != right->array_size) {
         return OPAL_ERR_BAD_PARAM;
     }
 
     /*
      * Bitwise OR
      */
-    for(i = 0; i < dest->array_size; ++i) {
+    for (i = 0; i < dest->array_size; ++i) {
         dest->bitmap[i] |= right->bitmap[i];
     }
 
@@ -301,17 +283,17 @@ int opal_bitmap_bitwise_xor_inplace(opal_bitmap_t *dest, opal_bitmap_t *right)
     /*
      * Sanity check
      */
-    if( NULL == dest || NULL == right ) {
+    if (NULL == dest || NULL == right) {
         return OPAL_ERR_BAD_PARAM;
     }
-    if( dest->array_size != right->array_size ) {
+    if (dest->array_size != right->array_size) {
         return OPAL_ERR_BAD_PARAM;
     }
 
     /*
      * Bitwise XOR
      */
-    for(i = 0; i < dest->array_size; ++i) {
+    for (i = 0; i < dest->array_size; ++i) {
         dest->bitmap[i] ^= right->bitmap[i];
     }
 
@@ -325,32 +307,32 @@ bool opal_bitmap_are_different(opal_bitmap_t *left, opal_bitmap_t *right)
     /*
      * Sanity check
      */
-    if( NULL == left || NULL == right ) {
+    if (NULL == left || NULL == right) {
         return OPAL_ERR_BAD_PARAM;
     }
 
-    if( opal_bitmap_size(left) != opal_bitmap_size(right) ) {
+    if (opal_bitmap_size(left) != opal_bitmap_size(right)) {
         return true;
     }
 
     /*
      * Direct comparison
      */
-    for(i = 0; i < left->array_size; ++i) {
-        if( left->bitmap[i] != right->bitmap[i] ) {
+    for (i = 0; i < left->array_size; ++i) {
+        if (left->bitmap[i] != right->bitmap[i]) {
             return true;
         }
     }
 
     return false;
 }
 
-char * opal_bitmap_get_string(opal_bitmap_t *bitmap)
+char *opal_bitmap_get_string(opal_bitmap_t *bitmap)
 {
     int i;
     char *bitmap_str = NULL;
 
-    if( NULL == bitmap) {
+    if (NULL == bitmap) {
         return NULL;
     }
 
@@ -360,8 +342,8 @@ char * opal_bitmap_get_string(opal_bitmap_t *bitmap)
     }
     bitmap_str[bitmap->array_size * SIZE_OF_BASE_TYPE] = '\0';
 
-    for( i = 0; i < (bitmap->array_size * SIZE_OF_BASE_TYPE); ++i) {
-        if( opal_bitmap_is_set_bit(bitmap, i) ) {
+    for (i = 0; i < (bitmap->array_size * SIZE_OF_BASE_TYPE); ++i) {
+        if (opal_bitmap_is_set_bit(bitmap, i)) {
             bitmap_str[i] = 'X';
         } else {
             bitmap_str[i] = '_';
@@ -387,12 +369,14 @@ int opal_bitmap_num_set_bits(opal_bitmap_t *bm, int len)
     }
 #endif
 
-    for(i = 0; i < len; ++i) {
-        if( 0 == (val = bm->bitmap[i]) ) continue;
+    for (i = 0; i < len; ++i) {
+        if (0 == (val = bm->bitmap[i])) {
+            continue;
+        }
         /*  Peter Wegner in CACM 3 (1960), 322. This method goes through as many
          *  iterations as there are set bits. */
-        for( ; val; cnt++ ) {
-            val &= val - 1;  /* clear the least significant bit set */
+        for (; val; cnt++) {
+            val &= val - 1; /* clear the least significant bit set */
         }
     }