Initial import

third_party/dlmalloc/dlindependent_calloc.c

@@ -0,0 +1,228 @@
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+#include "third_party/dlmalloc/dlmalloc.h"
+
+/*
+  Common support for independent_X routines, handling
+    all of the combinations that can result.
+  The opts arg has:
+    bit 0 set if all elements are same size (using sizes[0])
+    bit 1 set if elements should be zeroed
+*/
+static void **ialloc(mstate m, size_t n_elements, size_t *sizes, int opts,
+                     void *chunks[]) {
+  size_t element_size;   /* chunksize of each element, if all same */
+  size_t contents_size;  /* total size of elements */
+  size_t array_size;     /* request size of pointer array */
+  void *mem;             /* malloced aggregate space */
+  mchunkptr p;           /* corresponding chunk */
+  size_t remainder_size; /* remaining bytes while splitting */
+  void **marray;         /* either "chunks" or malloced ptr array */
+  mchunkptr array_chunk; /* chunk for malloced ptr array */
+  flag_t was_enabled;    /* to disable mmap */
+  size_t size;
+  size_t i;
+
+  ensure_initialization();
+  /* compute array length, if needed */
+  if (chunks != 0) {
+    if (n_elements == 0) return chunks; /* nothing to do */
+    marray = chunks;
+    array_size = 0;
+  } else {
+    /* if empty req, must still return chunk representing empty array */
+    if (n_elements == 0) return (void **)dlmalloc(0);
+    marray = 0;
+    array_size = request2size(n_elements * (sizeof(void *)));
+  }
+
+  /* compute total element size */
+  if (opts & 0x1) { /* all-same-size */
+    element_size = request2size(*sizes);
+    contents_size = n_elements * element_size;
+  } else { /* add up all the sizes */
+    element_size = 0;
+    contents_size = 0;
+    for (i = 0; i != n_elements; ++i) contents_size += request2size(sizes[i]);
+  }
+
+  size = contents_size + array_size;
+
+  /*
+     Allocate the aggregate chunk.  First disable direct-mmapping so
+     malloc won't use it, since we would not be able to later
+     free/realloc space internal to a segregated mmap region.
+  */
+  was_enabled = use_mmap(m);
+  disable_mmap(m);
+  mem = dlmalloc(size - CHUNK_OVERHEAD);
+  if (was_enabled) enable_mmap(m);
+  if (mem == 0) return 0;
+
+  if (PREACTION(m)) return 0;
+  p = mem2chunk(mem);
+  remainder_size = chunksize(p);
+
+  assert(!is_mmapped(p));
+
+  if (opts & 0x2) { /* optionally clear the elements */
+    memset((size_t *)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
+  }
+
+  /* If not provided, allocate the pointer array as final part of chunk */
+  if (marray == 0) {
+    size_t array_chunk_size;
+    array_chunk = chunk_plus_offset(p, contents_size);
+    array_chunk_size = remainder_size - contents_size;
+    marray = ADDRESS_BIRTH_ACTION((void **)(chunk2mem(array_chunk)));
+    set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
+    remainder_size = contents_size;
+  }
+
+  /* split out elements */
+  for (i = 0;; ++i) {
+    marray[i] = ADDRESS_BIRTH_ACTION(chunk2mem(p));
+    if (i != n_elements - 1) {
+      if (element_size != 0)
+        size = element_size;
+      else
+        size = request2size(sizes[i]);
+      remainder_size -= size;
+      set_size_and_pinuse_of_inuse_chunk(m, p, size);
+      p = chunk_plus_offset(p, size);
+    } else { /* the final element absorbs any overallocation slop */
+      set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
+      break;
+    }
+  }
+
+#if DEBUG + MODE_DBG + 0
+  if (marray != chunks) {
+    /* final element must have exactly exhausted chunk */
+    if (element_size != 0) {
+      assert(remainder_size == element_size);
+    } else {
+      assert(remainder_size == request2size(sizes[i]));
+    }
+    check_inuse_chunk(m, mem2chunk(marray));
+  }
+  for (i = 0; i != n_elements; ++i) check_inuse_chunk(m, mem2chunk(marray[i]));
+
+#endif /* DEBUG */
+
+  POSTACTION(m);
+  return marray;
+}
+
+/**
+ * independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
+ *
+ * independent_calloc is similar to calloc, but instead of returning a
+ * single cleared space, it returns an array of pointers to n_elements
+ * independent elements that can hold contents of size elem_size, each
+ * of which starts out cleared, and can be independently freed,
+ * realloc'ed etc. The elements are guaranteed to be adjacently
+ * allocated (this is not guaranteed to occur with multiple callocs or
+ * mallocs), which may also improve cache locality in some applications.
+ *
+ * The "chunks" argument is optional (i.e., may be null, which is
+ * probably the most typical usage). If it is null, the returned array
+ * is itself dynamically allocated and should also be freed when it is
+ * no longer needed. Otherwise, the chunks array must be of at least
+ * n_elements in length. It is filled in with the pointers to the
+ * chunks.
+ *
+ * In either case, independent_calloc returns this pointer array, or
+ * null if the allocation failed. * If n_elements is zero and "chunks"
+ * is null, it returns a chunk representing an array with zero elements
+ * (which should be freed if not wanted).
+ *
+ * Each element must be freed when it is no longer needed. This can be
+ * done all at once using bulk_free.
+ *
+ * independent_calloc simplifies and speeds up implementations of many
+ * kinds of pools. * It may also be useful when constructing large data
+ * structures that initially have a fixed number of fixed-sized nodes,
+ * but the number is not known at compile time, and some of the nodes
+ * may later need to be freed. For example:
+ *
+ *   struct Node { int item; struct Node* next; };
+ *   struct Node* build_list() {
+ *     struct Node **pool;
+ *     int n = read_number_of_nodes_needed();
+ *     if (n <= 0) return 0;
+ *     pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
+ *     if (pool == 0) die();
+ *     // organize into a linked list...
+ *     struct Node* first = pool[0];
+ *     for (i = 0; i < n-1; ++i)
+ *     pool[i]->next = pool[i+1];
+ *     free(pool); * // Can now free the array (or not, if it is needed later)
+ *     return first;
+ *   }
+ */
+void **dlindependent_calloc(size_t n_elements, size_t elem_size,
+                            void *chunks[]) {
+  size_t sz = elem_size; /* serves as 1-element array */
+  return ialloc(gm, n_elements, &sz, 3, chunks);
+}
+
+/**
+ * independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
+ *
+ * independent_comalloc allocates, all at once, a set of n_elements
+ * chunks with sizes indicated in the "sizes" array. It returns an array
+ * of pointers to these elements, each of which can be independently
+ * freed, realloc'ed etc. The elements are guaranteed to be adjacently
+ * allocated (this is not guaranteed to occur with multiple callocs or
+ * mallocs), which may also improve cache locality in some applications.
+ *
+ * The "chunks" argument is optional (i.e., may be null). If it is null
+ * the returned array is itself dynamically allocated and should also
+ * be freed when it is no longer needed. Otherwise, the chunks array
+ * must be of at least n_elements in length. It is filled in with the
+ * pointers to the chunks.
+ *
+ * In either case, independent_comalloc returns this pointer array, or
+ * null if the allocation failed.  If n_elements is zero and chunks is
+ * null, it returns a chunk representing an array with zero elements
+ * (which should be freed if not wanted).
+ *
+ * Each element must be freed when it is no longer needed. This can be
+ * done all at once using bulk_free.
+ *
+ * independent_comallac differs from independent_calloc in that each
+ * element may have a different size, and also that it does not
+ * automatically clear elements.
+ *
+ * independent_comalloc can be used to speed up allocation in cases
+ * where several structs or objects must always be allocated at the
+ * same time.  For example:
+ *
+ *   struct Head { ... }
+ *   struct Foot { ... }
+ *
+ *   void send_message(char* msg) {
+ *     int msglen = strlen(msg);
+ *     size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
+ *     void* chunks[3];
+ *     if (independent_comalloc(3, sizes, chunks) == 0)
+ *       die();
+ *     struct Head* head = (struct Head*)(chunks[0]);
+ *     char*        body = (char*)(chunks[1]);
+ *     struct Foot* foot = (struct Foot*)(chunks[2]);
+ *     // ...
+ *   }
+ *
+ * In general though, independent_comalloc is worth using only for
+ * larger values of n_elements. For small values, you probably won't
+ * detect enough difference from series of malloc calls to bother.
+ *
+ * Overuse of independent_comalloc can increase overall memory usage,
+ * since it cannot reuse existing noncontiguous small chunks that might
+ * be available for some of the elements.
+ */
+void **dlindependent_comalloc(size_t n_elements, size_t sizes[],
+                              void *chunks[]) {
+  return ialloc(gm, n_elements, sizes, 0, chunks);
+}