Remove branch hints

Profile-guided optimization gives equal or better results

Author: chriso

block.c

@@ -5,7 +5,6 @@
 
 #include "config.h"
 #include "block.h"
-#include "branch.h"
 #include "page.h"
 
 struct block *block_new(size_t page_size) {
@@ -57,22 +56,22 @@ void block_free(struct block *block) {
 
 __attribute__ ((noinline))
 static void *add_page(struct block *block) {
-    if (UNLIKELY(block->count == block->size)) {
+    if (block->count == block->size) {
         size_t new_size = block->size * 2;
         void **pages = realloc(block->pages, sizeof(*pages) * new_size);
-        if (UNLIKELY(!pages)) {
+        if (!pages) {
             return NULL;
         }
         block->pages = pages;
         size_t *offsets = realloc(block->offsets, sizeof(*offsets) * new_size);
-        if (UNLIKELY(!offsets)) {
+        if (!offsets) {
             return NULL;
         }
         block->offsets = offsets;
         block->size = new_size;
     }
     void *page = page_alloc(block->page_size);
-    if (UNLIKELY(!page)) {
+    if (!page) {
         return NULL;
     }
     block->pages[block->count] = page;
@@ -82,14 +81,14 @@ static void *add_page(struct block *block) {
 }
 
 void *block_alloc(struct block *block, size_t size) {
-    if (UNLIKELY(size > block->page_size)) {
+    if (size > block->page_size) {
         return NULL;
     }
     size_t offset = block->offsets[block->count - 1];
     void *page;
-    if (UNLIKELY(block->page_size - offset < size)) {
+    if (block->page_size - offset < size) {
         page = add_page(block);
-        if (UNLIKELY(!page)) {
+        if (!page) {
             return NULL;
         }
         offset = 0;

branch.h

@@ -3,7 +3,6 @@
 
 #include "config.h"
 #include "optimize.h"
-#include "branch.h"
 
 #ifdef INLINE_UNSIGNED
 const static uint32_t unsigned_tag = 0x80000000;
@@ -52,7 +51,7 @@ static bool resize_counts(struct strings_frequency *frequency,
     }
     struct id_count *counts = realloc(frequency->counts,
                                       sizeof(*counts) * new_size);
-    if (UNLIKELY(!counts)) {
+    if (!counts) {
         return false;
     }
     memset(counts + frequency->size, 0,
@@ -92,14 +91,14 @@ bool strings_frequency_add(struct strings_frequency *frequency, uint32_t id) {
         return true;
     }
 #endif
-    if (UNLIKELY(!id)) {
+    if (!id) {
         return true;
     }
-    if (UNLIKELY(frequency->sorted_by_count)) {
+    if (frequency->sorted_by_count) {
         sort_by_id(frequency);
     }
     if (frequency->max_id < id) {
-        if (UNLIKELY(frequency->size < id)) {
+        if (frequency->size < id) {
             if (!resize_counts(frequency, id)) {
                 return false;
             }
@@ -146,7 +145,7 @@ struct strings *strings_optimize(struct strings *strings,
             break;
         }
         const char *string = strings_lookup_id(strings, id_count->id);
-        if (UNLIKELY(!string || !strings_intern(optimized, string))) {
+        if (!string || !strings_intern(optimized, string)) {
             goto error;
         }
     }

optimize.c

@@ -5,7 +5,6 @@
 #include "config.h"
 #include "strings.h"
 #include "tree.h"
-#include "branch.h"
 
 #ifdef INLINE_UNSIGNED
 #include "unsigned.h"
@@ -132,26 +131,26 @@ bool strings_hash_seed(struct strings *strings, uint32_t seed) {
 static tree_node_t *create_node(struct strings *strings, uint32_t hash,
                                 const char *string) {
     tree_node_t *node = block_alloc(strings->index, sizeof(*node));
-    if (UNLIKELY(!node)) {
+    if (!node) {
         return NULL;
     }
     node->hash = hash;
     node->next = NULL;
     node->id = strings->total + 1;
-    if (UNLIKELY(node->id == id_overflow)) {
+    if (node->id == id_overflow) {
         return NULL;
     }
 
     size_t len = strlen(string);
     void *string_ptr = block_alloc(strings->strings, len + 1);
-    if (UNLIKELY(!string_ptr)) {
+    if (!string_ptr) {
         return NULL;
     }
     memcpy(string_ptr, string, len + 1);
     node->string = (const char *)string_ptr;
 
     uint32_t *hash_ptr = block_alloc(strings->hashes, sizeof(*hash_ptr));
-    if (UNLIKELY(!hash_ptr)) {
+    if (!hash_ptr) {
         return NULL;
     }
     *hash_ptr = hash;
@@ -174,7 +173,7 @@ static bool strings_intern_collision(struct strings *strings,
     for (;;) {
         if (!node->next) {
             node = node->next = create_node(strings, hash, string);
-            if (UNLIKELY(!node)) {
+            if (!node) {
                 return 0;
             }
             break;
@@ -195,7 +194,7 @@ uint32_t strings_intern(struct strings *strings, const char *string) {
 #ifdef INLINE_UNSIGNED
     if (is_small_unsigned(string)) {
         uint32_t number = to_unsigned(string);
-        if (LIKELY(number < unsigned_tag)) {
+        if (number < unsigned_tag) {
             return number | unsigned_tag;
         }
     }
@@ -204,11 +203,11 @@ uint32_t strings_intern(struct strings *strings, const char *string) {
     uint32_t hash = strings_hash(strings, string);
     tree_node_t *node = find_node(strings, hash);
     if (node) {
-        if (UNLIKELY(strcmp(node->string, string))) {
+        if (strcmp(node->string, string)) {
             return strings_intern_collision(strings, node, string, hash);
         }
     } else {
-        if (UNLIKELY(!(node = create_node(strings, hash, string)))) {
+        if (!(node = create_node(strings, hash, string))) {
             return 0;
         }
         tree_insert(&strings->hash_map, node);
@@ -221,7 +220,7 @@ uint32_t strings_lookup(const struct strings *strings, const char *string) {
 #ifdef INLINE_UNSIGNED
     if (is_small_unsigned(string)) {
         uint32_t number = to_unsigned(string);
-        if (LIKELY(number < unsigned_tag)) {
+        if (number < unsigned_tag) {
             return number | unsigned_tag;
         }
     }
@@ -231,7 +230,7 @@ uint32_t strings_lookup(const struct strings *strings, const char *string) {
     tree_node_t *node = find_node(strings, hash);
     if (node) {
         do {
-            if (LIKELY(!strcmp(node->string, string))) {
+            if (!strcmp(node->string, string)) {
                 return node->id;
             }
         } while ((node = node->next));
@@ -248,7 +247,7 @@ const char *strings_lookup_id(struct strings *strings, uint32_t id) {
     }
 #endif
 
-    if (UNLIKELY(id > strings->total)) {
+    if (id > strings->total) {
         return NULL;
     }
 
@@ -262,7 +261,7 @@ const char *strings_lookup_id(struct strings *strings, uint32_t id) {
 
     tree_node_t *node = find_node(strings, hash);
     do {
-        if (LIKELY(node->id == id)) {
+        if (node->id == id) {
             return node->string;
         }
     } while ((node = node->next));
@@ -280,16 +279,16 @@ void strings_cursor_init(struct strings_cursor *cursor,
 
 bool strings_cursor_next(struct strings_cursor *cursor) {
     const struct block *block = cursor->strings;
-    if (LIKELY(cursor->id)) {
+    if (cursor->id) {
         const char *string = strings_cursor_string(cursor);
         cursor->offset += strlen(string) + 1;
-        if (UNLIKELY(cursor->offset >= block->offsets[cursor->page])) {
+        if (cursor->offset >= block->offsets[cursor->page]) {
             cursor->page++;
             cursor->offset = 0;
         }
     }
-    if (UNLIKELY(cursor->page >= block->count ||
-            cursor->offset >= block->offsets[cursor->page])) {
+    if (cursor->page >= block->count ||
+            cursor->offset >= block->offsets[cursor->page]) {
         cursor->id = 0;
         return false;
     }
@@ -298,7 +297,7 @@ bool strings_cursor_next(struct strings_cursor *cursor) {
 }
 
 const char *strings_cursor_string(const struct strings_cursor *cursor) {
-    if (UNLIKELY(!cursor->id)) {
+    if (!cursor->id) {
         return NULL;
     }
     const void *page = cursor->strings->pages[cursor->page];
@@ -338,7 +337,7 @@ bool strings_restore(struct strings *strings,
                 offset += sizeof(tree_node_t)) {
             node = (tree_node_t *)((uintptr_t)block->pages[page] + offset);
             existing = find_node(strings, node->hash);
-            if (UNLIKELY(existing)) {
+            if (existing) {
                 while (existing->next) {
                     existing = existing->next;
                 }