Enforce consistent style

Author: jserv

.clang-format

@@ -0,0 +1,15 @@
+BasedOnStyle: Chromium
+Language: Cpp
+MaxEmptyLinesToKeep: 3
+IndentCaseLabels: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+DerivePointerAlignment: false
+PointerAlignment: Right
+SpaceAfterCStyleCast: true
+TabWidth: 4
+UseTab: Never
+IndentWidth: 4
+BreakBeforeBraces: Linux
+AccessModifierOffset: -4

bench.c

@@ -4,7 +4,6 @@
  * Use of this source code is governed by a BSD-style license.
  */
 
-#include "tlsf.h"
 #include <assert.h>
 #include <errno.h>
 #include <sched.h>
@@ -16,37 +15,45 @@
 #include <time.h>
 #include <unistd.h>
 
+#include "tlsf.h"
+
 static tlsf t = TLSF_INIT;
 
-static void usage(const char* name) {
- printf("run a malloc benchmark.\n"
- "usage: %s [-s blk-size|blk-min:blk-max] [-l loop-count] "
- "[-n num-blocks] [-c]\n",
- name);
+static void usage(const char *name)
+{
+ printf(
+ "run a malloc benchmark.\n"
+ "usage: %s [-s blk-size|blk-min:blk-max] [-l loop-count] "
+ "[-n num-blocks] [-c]\n",
+ name);
  exit(-1);
 }
 
 /* Parse an integer argument. */
-static size_t parse_int_arg(const char* arg, const char* exe_name) {
+static size_t parse_int_arg(const char *arg, const char *exe_name)
+{
  long ret = strtol(arg, NULL, 0);
  if (errno)
  usage(exe_name);
 
- return (size_t)ret;
+ return (size_t) ret;
 }
 
 /* Parse a size argument, which is either an integer or two integers
  separated by a colon, denoting a range. */
-static void parse_size_arg(const char* arg, const char* exe_name, size_t* blk_min,
- size_t* blk_max) {
- char* endptr;
- *blk_min = (size_t)strtol(arg, &endptr, 0);
+static void parse_size_arg(const char *arg,
+ const char *exe_name,
+ size_t *blk_min,
+ size_t *blk_max)
+{
+ char *endptr;
+ *blk_min = (size_t) strtol(arg, &endptr, 0);
 
  if (errno)
  usage(exe_name);
 
  if (endptr && *endptr == ':') {
- *blk_max = (size_t)strtol(endptr + 1, NULL, 0);
+ *blk_max = (size_t) strtol(endptr + 1, NULL, 0);
  if (errno)
  usage(exe_name);
  }
@@ -56,29 +63,39 @@ static void parse_size_arg(const char* arg, const char* exe_name, size_t* blk_mi
 }
 
 /* Get a random block size between blk_min and blk_max. */
-static size_t get_random_block_size(size_t blk_min, size_t blk_max) {
+static size_t get_random_block_size(size_t blk_min, size_t blk_max)
+{
  if (blk_max > blk_min)
- return blk_min + ((size_t)rand() % (blk_max - blk_min));
+ return blk_min + ((size_t) rand() % (blk_max - blk_min));
  return blk_min;
 }
 
-static void run_alloc_benchmark(size_t loops, size_t blk_min, size_t blk_max, void** blk_array,
- size_t num_blks, bool clear) {
+static void run_alloc_benchmark(size_t loops,
+ size_t blk_min,
+ size_t blk_max,
+ void **blk_array,
+ size_t num_blks,
+ bool clear)
+{
  while (loops--) {
- size_t next_idx = (size_t)rand() % num_blks;
+ size_t next_idx = (size_t) rand() % num_blks;
  size_t blk_size = get_random_block_size(blk_min, blk_max);
 
  if (blk_array[next_idx]) {
  if (rand() % 10 == 0) {
- /* Insert the newly alloced block into the array at a random point. */
- blk_array[next_idx] = tlsf_realloc(&t, blk_array[next_idx], blk_size);
+ /* Insert the newly alloced block into the array at a random
+ * point. */
+ blk_array[next_idx] =
+ tlsf_realloc(&t, blk_array[next_idx], blk_size);
  } else {
  tlsf_free(&t, blk_array[next_idx]);
- /* Insert the newly alloced block into the array at a random point. */
+ /* Insert the newly alloced block into the array at a random
+ * point. */
  blk_array[next_idx] = tlsf_malloc(&t, blk_size);
  }
  } else {
- /* Insert the newly alloced block into the array at a random point. */
+ /* Insert the newly alloced block into the array at a random point.
+ */
  blk_array[next_idx] = tlsf_malloc(&t, blk_size);
  }
  if (clear)
@@ -93,34 +110,48 @@ static void run_alloc_benchmark(size_t loops, size_t blk_min, size_t blk_max, vo
 }
 
 static size_t max_size;
-static void* mem = 0;
+static void *mem = 0;
 
-void* tlsf_resize(tlsf* _t, size_t req_size) {
- (void)_t;
+void *tlsf_resize(tlsf *_t, size_t req_size)
+{
+ (void) _t;
  return req_size <= max_size ? mem : 0;
 }
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv)
+{
  size_t blk_min = 512, blk_max = 512, num_blks = 10000;
  size_t loops = 10000000;
  bool clear = false;
  int opt;
 
  while ((opt = getopt(argc, argv, "s:l:r:t:n:b:ch")) > 0) {
  switch (opt) {
- case 's': parse_size_arg(optarg, argv[0], &blk_min, &blk_max); break;
- case 'l': loops = parse_int_arg(optarg, argv[0]); break;
- case 'n': num_blks = parse_int_arg(optarg, argv[0]); break;
- case 'c': clear = true; break;
- case 'h': usage(argv[0]); break;
- default: usage(argv[0]); break;
+ case 's':
+ parse_size_arg(optarg, argv[0], &blk_min, &blk_max);
+ break;
+ case 'l':
+ loops = parse_int_arg(optarg, argv[0]);
+ break;
+ case 'n':
+ num_blks = parse_int_arg(optarg, argv[0]);
+ break;
+ case 'c':
+ clear = true;
+ break;
+ case 'h':
+ usage(argv[0]);
+ break;
+ default:
+ usage(argv[0]);
+ break;
  }
  }
 
  max_size = blk_max * num_blks;
  mem = malloc(max_size);
 
- void** blk_array = (void**)calloc(num_blks, sizeof(void*));
+ void **blk_array = (void **) calloc(num_blks, sizeof(void *));
  assert(blk_array);
 
  struct timespec start, end;
@@ -136,18 +167,20 @@ int main(int argc, char** argv) {
  assert(err == 0);
  free(blk_array);
 
- double elapsed =
- (double)(end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) * 1e-9;
+ double elapsed = (double) (end.tv_sec - start.tv_sec) +
+  (double) (end.tv_nsec - start.tv_nsec) * 1e-9;
 
  struct rusage usage;
  err = getrusage(RUSAGE_SELF, &usage);
  assert(err == 0);
 
  /* Dump both machine and human readable versions */
- printf("%zu:%zu:%zu:%u:%lu:%.6f: took %.6f s for %zu malloc/free\nbenchmark loops of %zu-%zu "
- "bytes. ~%.3f us per loop\n",
- blk_min, blk_max, loops, clear, usage.ru_maxrss, elapsed, elapsed, loops, blk_min,
- blk_max, elapsed / (double)loops * 1e6);
+ printf(
+ "%zu:%zu:%zu:%u:%lu:%.6f: took %.6f s for %zu malloc/free\nbenchmark "
+ "loops of %zu-%zu "
+ "bytes. ~%.3f us per loop\n",
+ blk_min, blk_max, loops, clear, usage.ru_maxrss, elapsed, elapsed,
+ loops, blk_min, blk_max, elapsed / (double) loops * 1e6);
 
  return 0;
 }

test.c

@@ -4,7 +4,6 @@
  * Use of this source code is governed by a BSD-style license.
  */
 
-#include "tlsf.h"
 #include <assert.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -15,13 +14,16 @@
 #include <time.h>
 #include <unistd.h>
 
+#include "tlsf.h"
+
 static size_t PAGE;
 static size_t MAX_PAGES;
 static size_t curr_pages = 0;
-static void* start_addr = 0;
+static void *start_addr = 0;
 
-void* tlsf_resize(tlsf* t, size_t req_size) {
- (void)t;
+void *tlsf_resize(tlsf *t, size_t req_size)
+{
+ (void) t;
 
  if (!start_addr)
  start_addr = mmap(0, MAX_PAGES * PAGE, PROT_READ | PROT_WRITE,
@@ -33,53 +35,55 @@ void* tlsf_resize(tlsf* t, size_t req_size) {
 
  if (req_pages != curr_pages) {
  if (req_pages < curr_pages)
- madvise((char*)start_addr + PAGE * req_pages, (size_t)(curr_pages - req_pages) * PAGE,
- MADV_DONTNEED);
+ madvise((char *) start_addr + PAGE * req_pages,
+ (size_t) (curr_pages - req_pages) * PAGE, MADV_DONTNEED);
  curr_pages = req_pages;
  }
 
  return start_addr;
 }
 
-static void random_test(tlsf* t, size_t spacelen, const size_t cap) {
+static void random_test(tlsf *t, size_t spacelen, const size_t cap)
+{
  const size_t maxitems = 2 * spacelen;
 
- void** p = (void**)malloc(maxitems * sizeof(void*));
+ void **p = (void **) malloc(maxitems * sizeof(void *));
  assert(p);
 
  /*
  * Allocate random sizes up to the cap threshold.
  * Track them in an array.
  */
- int64_t rest = (int64_t)spacelen * (rand() % 6 + 1);
+ int64_t rest = (int64_t) spacelen * (rand() % 6 + 1);
  unsigned i = 0;
  while (rest > 0) {
- size_t len = ((size_t)rand() % cap) + 1;
+ size_t len = ((size_t) rand() % cap) + 1;
  if (rand() % 2 == 0) {
  p[i] = tlsf_malloc(t, len);
  } else {
  size_t align = 1U << (rand() % 20);
  if (cap < align)
  align = 0;
  else
- len = align * (((size_t)rand() % (cap / align)) + 1);
- p[i] = !align || !len ? tlsf_malloc(t, len) : tlsf_aalloc(t, align, len);
+ len = align * (((size_t) rand() % (cap / align)) + 1);
+ p[i] = !align || !len ? tlsf_malloc(t, len)
+ : tlsf_aalloc(t, align, len);
  if (align)
- assert(!((size_t)p[i] % align));
+ assert(!((size_t) p[i] % align));
  }
  assert(p[i]);
- rest -= (int64_t)len;
+ rest -= (int64_t) len;
 
  if (rand() % 10 == 0) {
- len = ((size_t)rand() % cap) + 1;
+ len = ((size_t) rand() % cap) + 1;
  p[i] = tlsf_realloc(t, p[i], len);
  assert(p[i]);
  }
 
  tlsf_check(t);
 
  /* Fill with magic (only when testing up to 1MB). */
- uint8_t* data = (uint8_t*)p[i];
+ uint8_t *data = (uint8_t *) p[i];
  if (spacelen <= 1024 * 1024)
  memset(data, 0, len);
  data[0] = 0xa5;
@@ -93,10 +97,10 @@ static void random_test(tlsf* t, size_t spacelen, const size_t cap) {
  * The free space should match the free space after initialisation.
  */
  for (unsigned n = i; n;) {
- size_t target = (size_t)rand() % i;
+ size_t target = (size_t) rand() % i;
  if (p[target] == NULL)
  continue;
- uint8_t* data = (uint8_t*)p[target];
+ uint8_t *data = (uint8_t *) p[target];
  assert(data[0] == 0xa5);
  tlsf_free(t, p[target]);
  p[target] = NULL;
@@ -110,27 +114,30 @@ static void random_test(tlsf* t, size_t spacelen, const size_t cap) {
 
 #define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
 
-static void random_sizes_test(tlsf* t) {
- const size_t sizes[] = { 16, 32, 64, 128, 256, 512, 1024, 1024 * 1024 }; //, 128 * 1024 * 1024};
+static void random_sizes_test(tlsf *t)
+{
+ const size_t sizes[] = {16, 32, 64, 128, 256,
+ 512, 1024, 1024 * 1024}; //, 128 * 1024 * 1024};
 
  for (unsigned i = 0; i < __arraycount(sizes); i++) {
  unsigned n = 1024;
 
  while (n--) {
- size_t cap = (size_t)rand() % sizes[i] + 1;
+ size_t cap = (size_t) rand() % sizes[i] + 1;
  printf("sizes = %zu, cap = %zu\n", sizes[i], cap);
  random_test(t, sizes[i], cap);
  }
  }
 }
 
-static void large_alloc(tlsf* t, size_t s) {
+static void large_alloc(tlsf *t, size_t s)
+{
  printf("large alloc %zu\n", s);
  for (size_t d = 0; d < 100 && d < s; ++d) {
- void* p = tlsf_malloc(t, s - d);
+ void *p = tlsf_malloc(t, s - d);
  assert(p);
 
- void* q = tlsf_malloc(t, s - d);
+ void *q = tlsf_malloc(t, s - d);
  assert(q);
  tlsf_free(t, q);
 
@@ -143,7 +150,8 @@ static void large_alloc(tlsf* t, size_t s) {
  }
 }
 
-static void large_size_test(tlsf* t) {
+static void large_size_test(tlsf *t)
+{
  size_t s = 1;
  while (s <= TLSF_MAX_SIZE) {
  large_alloc(t, s);
@@ -157,11 +165,12 @@ static void large_size_test(tlsf* t) {
  }
 }
 
-int main(void) {
- PAGE = (size_t)sysconf(_SC_PAGESIZE);
+int main(void)
+{
+ PAGE = (size_t) sysconf(_SC_PAGESIZE);
  MAX_PAGES = 20 * TLSF_MAX_SIZE / PAGE;
  tlsf t = TLSF_INIT;
- srand((unsigned int)time(0));
+ srand((unsigned int) time(0));
  large_size_test(&t);
  random_sizes_test(&t);
  puts("OK!");