cgraph: inline 'bitarray_new' into 'bitarray_new_or_exit' and rename

All clients of this functionality were calling `bitarray_new_or_exit`. That is,
none of them could cope with failure. In the intervening time since this API was
added, several other exit-on-failure functions have sprung up. For example,
`gv_alloc`. It seems reasonable to now abbreviate this, leading to lesser code
to maintain, with the “or exit” now implicit.

diff --git a/lib/cgraph/bitarray.h b/lib/cgraph/bitarray.h
index 54c3ef697fcbc99205ff6965b8a8d37b36130938..a8e698ccc6f006bdb1cc5ebfa61292f85a1730da 100644 (file)
--- a/lib/cgraph/bitarray.h
+++ b/lib/cgraph/bitarray.h
@@ -22,12 +22,10 @@
 #pragma once
 
 #include <assert.h>
-#include <cgraph/likely.h>
-#include <errno.h>
+#include <cgraph/alloc.h>
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -45,39 +43,18 @@ typedef struct {
 } bitarray_t;
 
 /// create an array of the given element length
-static inline int bitarray_new(bitarray_t *self, size_t size_bits) {
-  assert(self != NULL);
-  assert(self->size_bits == 0);
+static inline bitarray_t bitarray_new(size_t size_bits) {
+
+  bitarray_t ba = {.size_bits = size_bits};
 
   // if the array is small enough, we can use inline storage
-  if (size_bits <= sizeof(self->block) * 8) {
-    memset(self->block, 0, sizeof(self->block));
+  if (size_bits <= sizeof(ba.block) * 8) {
+    // nothing to be done
 
     // otherwise we need to heap-allocate
   } else {
     size_t capacity = size_bits / 8 + (size_bits % 8 == 0 ? 0 : 1);
-    uint8_t *base = calloc(capacity, sizeof(self->base[0]));
-    if (UNLIKELY(base == NULL))
-      return ENOMEM;
-
-    self->base = base;
-  }
-
-  self->size_bits = size_bits;
-
-  return 0;
-}
-
-/// `bitarray_new` for callers who cannot handle failure
-static inline bitarray_t bitarray_new_or_exit(size_t size_bits) {
-
-  bitarray_t ba;
-  memset(&ba, 0, sizeof(ba));
-
-  int error = bitarray_new(&ba, size_bits);
-  if (UNLIKELY(error != 0)) {
-    fprintf(stderr, "out of memory\n");
-    exit(EXIT_FAILURE);
+    ba.base = gv_calloc(capacity, sizeof(uint8_t));
   }
 
   return ba;

diff --git a/lib/cgraph/test_bitarray.c b/lib/cgraph/test_bitarray.c
index 093b94913962ed13cd76999d7cec8492f2c01768..ce87f9a30b5adc8f04425e37591a436706954e5e 100644 (file)
--- a/lib/cgraph/test_bitarray.c
+++ b/lib/cgraph/test_bitarray.c
@@ -10,14 +10,10 @@
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 // helper for basic construction and destruction, with nothing in-between
 static void create_reset(size_t size) {
-  bitarray_t b;
-  memset(&b, 0, sizeof(b));
-  int r = bitarray_new(&b, size);
-  assert(r == 0);
+  bitarray_t b = bitarray_new(size);
   bitarray_reset(&b);
 }
 
@@ -30,10 +26,7 @@ static void test_create_reset_large(void) { create_reset(1023); }
 // setting and unsetting of all bits
 static void set_unset(size_t size) {
 
-  bitarray_t b;
-  memset(&b, 0, sizeof(b));
-  int r = bitarray_new(&b, size);
-  assert(r == 0);
+  bitarray_t b = bitarray_new(size);
 
   // set and unset each bit
   for (size_t i = 0; i < size; ++i) {
@@ -100,10 +93,7 @@ static void test_reuse(void) {
 
   size_t size = 10;
 
-  bitarray_t b;
-  memset(&b, 0, sizeof(b));
-  int r = bitarray_new(&b, size);
-  assert(r == 0);
+  bitarray_t b = bitarray_new(size);
 
   // set and unset each bit
   for (size_t i = 0; i < size; ++i) {
@@ -121,8 +111,7 @@ static void test_reuse(void) {
 
   // reuse it with a different size
   size = 1023;
-  r = bitarray_new(&b, size);
-  assert(r == 0);
+  b = bitarray_new(size);
 
   // set and unset each bit
   for (size_t i = 0; i < size; ++i) {
@@ -142,10 +131,7 @@ static void test_reuse(void) {
 // redundant write to a bit
 static void double_set(size_t size, bool value) {
 
-  bitarray_t b;
-  memset(&b, 0, sizeof(b));
-  int r = bitarray_new(&b, size);
-  assert(r == 0);
+  bitarray_t b = bitarray_new(size);
 
   static const size_t index = 7;
   assert(!bitarray_get(b, index));

diff --git a/lib/dotgen/aspect.c b/lib/dotgen/aspect.c
index 7457a7e2b72d60d6169ca9e51724de78d3b6d78c..7afb4eaf98bf22120fc6f2d669347bfd89dc6c47 100644 (file)
--- a/lib/dotgen/aspect.c
+++ b/lib/dotgen/aspect.c
@@ -201,7 +201,7 @@ static void computeLayerWidths(graph_t * g)
        layerWidthInfo[i].nodeGroupsInLayer = gv_calloc(nNodeGroups, sizeof(nodeGroup_t*));
 
        assert(nNodeGroups >= 0);
-       layerWidthInfo[i].removed = bitarray_new_or_exit((size_t)nNodeGroups);
+       layerWidthInfo[i].removed = bitarray_new((size_t)nNodeGroups);
 
        layerWidthInfo[i].layerNumber = i;
        layerWidthInfo[i].nNodeGroupsInLayer = 0;

diff --git a/lib/neatogen/dijkstra.c b/lib/neatogen/dijkstra.c
index 99e81811fff838d537aa699b0473c5131df38bc7..10d3f1bdeac2017fdda89ab3e2a7034ea970c1bd 100644 (file)
--- a/lib/neatogen/dijkstra.c
+++ b/lib/neatogen/dijkstra.c
@@ -199,7 +199,7 @@ dijkstra_bounded(int vertex, vtx_data * graph, int n, DistType * dist,
     }
     num_visited_nodes =
        bfs_bounded(vertex, graph, dist, &Q, bound, visited_nodes);
-    bitarray_t node_in_neighborhood = bitarray_new_or_exit(n);
+    bitarray_t node_in_neighborhood = bitarray_new(n);
     for (i = 0; i < num_visited_nodes; i++) {
        bitarray_set(&node_in_neighborhood, visited_nodes[i], true);
     }

diff --git a/lib/neatogen/neatoinit.c b/lib/neatogen/neatoinit.c
index 470c940e72336c8be99240e60ee9fc6af51e7fef..6ef199695336ff6e558d9e3ab6d019e23f24b0dd 100644 (file)
--- a/lib/neatogen/neatoinit.c
+++ b/lib/neatogen/neatoinit.c
@@ -187,7 +187,7 @@ static cluster_data* cluster_map(graph_t *mastergraph, graph_t *g)
      /* array of arrays of node indices in each cluster */
     int **cs,*cn;
     int i,j,nclusters=0;
-    bitarray_t assigned = bitarray_new_or_exit(agnnodes(g));
+    bitarray_t assigned = bitarray_new(agnnodes(g));
     cluster_data *cdata = GNEW(cluster_data);
 
     cdata->ntoplevel = agnnodes(g);

diff --git a/lib/neatogen/sgd.c b/lib/neatogen/sgd.c
index 8ee6d26a6128726516483f639b8363776df24e37..304160e2da9e17e0ed8339724e005570832056e0 100644 (file)
--- a/lib/neatogen/sgd.c
+++ b/lib/neatogen/sgd.c
@@ -52,7 +52,7 @@ static graph_sgd * extract_adjacency(graph_t *G, int model) {
     }
     graph_sgd *graph = N_NEW(1, graph_sgd);
     graph->sources = N_NEW(n_nodes + 1, size_t);
-    graph->pinneds = bitarray_new_or_exit(n_nodes);
+    graph->pinneds = bitarray_new(n_nodes);
     graph->targets = N_NEW(n_edges, size_t);
     graph->weights = N_NEW(n_edges, float);
 
@@ -87,8 +87,8 @@ static graph_sgd * extract_adjacency(graph_t *G, int model) {
     } else if (model == MODEL_SUBSET) {
         // i,j,k refer to actual node indices, while x,y refer to edge indices in graph->targets
         // initialise to no neighbours
-        bitarray_t neighbours_i = bitarray_new_or_exit(graph->n);
-        bitarray_t neighbours_j = bitarray_new_or_exit(graph->n);
+        bitarray_t neighbours_i = bitarray_new(graph->n);
+        bitarray_t neighbours_j = bitarray_new(graph->n);
         for (size_t i = 0; i < graph->n; i++) {
             int deg_i = 0;
             for (size_t x = graph->sources[i]; x < graph->sources[i + 1]; x++) {

diff --git a/lib/ortho/partition.c b/lib/ortho/partition.c
index 2c7cc00ff871c84f4674a4c619e81d20640db8fd..3e9cb0e9725b6676773734cfd63a913a7931a7ba 100644 (file)
--- a/lib/ortho/partition.c
+++ b/lib/ortho/partition.c
@@ -596,7 +596,7 @@ monotonate_trapezoids(int nsegs, segment_t *seg, traps_t *tr,
     int flip, boxes_t *decomp) {
     int i;
     int tr_start;
-    bitarray_t visited = bitarray_new_or_exit(tr->length);
+    bitarray_t visited = bitarray_new(tr->length);
 
     mchain = gv_calloc(tr->length, sizeof(monchain_t));
     vert = gv_calloc(nsegs + 1, sizeof(vertexchain_t));

diff --git a/lib/sfdpgen/spring_electrical.c b/lib/sfdpgen/spring_electrical.c
index 321ac0b6a75b99b634cf12e16ac6b910ed415726..3c5f8b587093ed3a97d4f3411f22ce723f104dbf 100644 (file)
--- a/lib/sfdpgen/spring_electrical.c
+++ b/lib/sfdpgen/spring_electrical.c
@@ -372,7 +372,7 @@ static void beautify_leaves(int dim, SparseMatrix A, double *x){
 
   assert(!SparseMatrix_has_diagonal(A));
 
-  bitarray_t checked = bitarray_new_or_exit(m);
+  bitarray_t checked = bitarray_new(m);
   angles = gv_calloc(nangles_max, sizeof(double));
   leaves = gv_calloc(nleaves_max, sizeof(int));