benchtests/bench-malloc-simple.c

   1 /* Benchmark malloc and free functions.
   2    Copyright (C) 2019-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <pthread.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <malloc.h>
  23 #include <sys/resource.h>
  24 #include "bench-timing.h"
  25 #include "json-lib.h"
  26
  27 /* Benchmark the malloc/free performance of a varying number of blocks of a
  28    given size.  This enables performance tracking of the t-cache and fastbins.
  29    It tests 3 different scenarios: single-threaded using main arena,
  30    multi-threaded using thread-arena, and main arena with SINGLE_THREAD_P
  31    false.  */
  32
  33 #define NUM_ITERS 200000
  34 #define NUM_ALLOCS 4
  35 #define MAX_ALLOCS 1600
  36
  37 typedef struct
  38 {
  39   size_t iters;
  40   size_t size;
  41   int n;
  42   timing_t elapsed;
  43 } malloc_args;
  44
  45 static void
  46 do_benchmark (malloc_args *args, int **arr)
  47 {
  48   timing_t start, stop;
  49   size_t iters = args->iters;
  50   size_t size = args->size;
  51   int n = args->n;
  52
  53   TIMING_NOW (start);
  54
  55   for (int j = 0; j < iters; j++)
  56     {
  57       for (int i = 0; i < n; i++)
  58         arr[i] = malloc (size);
  59
  60       for (int i = 0; i < n; i++)
  61         free (arr[i]);
  62     }
  63
  64   TIMING_NOW (stop);
  65
  66   TIMING_DIFF (args->elapsed, start, stop);
  67 }
  68
  69 static malloc_args tests[3][NUM_ALLOCS];
  70 static int allocs[NUM_ALLOCS] = { 25, 100, 400, MAX_ALLOCS };
  71
  72 static void *
  73 thread_test (void *p)
  74 {
  75   int **arr = (int**)p;
  76
  77   /* Run benchmark multi-threaded.  */
  78   for (int i = 0; i < NUM_ALLOCS; i++)
  79     do_benchmark (&tests[2][i], arr);
  80
  81   return p;
  82 }
  83
  84 void
  85 bench (unsigned long size)
  86 {
  87   size_t iters = NUM_ITERS;
  88   int **arr = (int**) malloc (MAX_ALLOCS * sizeof (void*));
  89
  90   for (int t = 0; t < 3; t++)
  91     for (int i = 0; i < NUM_ALLOCS; i++)
  92       {
  93         tests[t][i].n = allocs[i];
  94         tests[t][i].size = size;
  95         tests[t][i].iters = iters / allocs[i];
  96
  97         /* Do a quick warmup run.  */
  98         if (t == 0)
  99           do_benchmark (&tests[0][i], arr);
 100       }
 101
 102   /* Run benchmark single threaded in main_arena.  */
 103   for (int i = 0; i < NUM_ALLOCS; i++)
 104     do_benchmark (&tests[0][i], arr);
 105
 106   /* Run benchmark in a thread_arena.  */
 107   pthread_t t;
 108   pthread_create (&t, NULL, thread_test, (void*)arr);
 109   pthread_join (t, NULL);
 110
 111   /* Repeat benchmark in main_arena with SINGLE_THREAD_P == false.  */
 112   for (int i = 0; i < NUM_ALLOCS; i++)
 113     do_benchmark (&tests[1][i], arr);
 114
 115   free (arr);
 116
 117   json_ctx_t json_ctx;
 118
 119   json_init (&json_ctx, 0, stdout);
 120
 121   json_document_begin (&json_ctx);
 122
 123   json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
 124
 125   json_attr_object_begin (&json_ctx, "functions");
 126
 127   json_attr_object_begin (&json_ctx, "malloc");
 128
 129   char s[100];
 130   double iters2 = iters;
 131
 132   json_attr_object_begin (&json_ctx, "");
 133   json_attr_double (&json_ctx, "malloc_block_size", size);
 134
 135   struct rusage usage;
 136   getrusage (RUSAGE_SELF, &usage);
 137   json_attr_double (&json_ctx, "max_rss", usage.ru_maxrss);
 138
 139   for (int i = 0; i < NUM_ALLOCS; i++)
 140     {
 141       sprintf (s, "main_arena_st_allocs_%04d_time", allocs[i]);
 142       json_attr_double (&json_ctx, s, tests[0][i].elapsed / iters2);
 143     }
 144
 145   for (int i = 0; i < NUM_ALLOCS; i++)
 146     {
 147       sprintf (s, "main_arena_mt_allocs_%04d_time", allocs[i]);
 148       json_attr_double (&json_ctx, s, tests[1][i].elapsed / iters2);
 149     }
 150
 151   for (int i = 0; i < NUM_ALLOCS; i++)
 152     {
 153       sprintf (s, "thread_arena__allocs_%04d_time", allocs[i]);
 154       json_attr_double (&json_ctx, s, tests[2][i].elapsed / iters2);
 155     }
 156
 157   json_attr_object_end (&json_ctx);
 158
 159   json_attr_object_end (&json_ctx);
 160
 161   json_attr_object_end (&json_ctx);
 162
 163   json_document_end (&json_ctx);
 164 }
 165
 166 static void usage (const char *name)
 167 {
 168   fprintf (stderr, "%s: <alloc_size>\n", name);
 169   exit (1);
 170 }
 171
 172 int
 173 main (int argc, char **argv)
 174 {
 175   long val = 16;
 176   if (argc == 2)
 177     val = strtol (argv[1], NULL, 0);
 178
 179   if (argc > 2 || val <= 0)
 180     usage (argv[0]);
 181
 182   bench (val);
 183
 184   return 0;
 185 }