thodg/libgit2/src/stdalloc.c

• Show log

  Commit

• Hash : 08b318c0
  Author :
  Date : 2018-03-14T10:43:00
  

  stdalloc: extend allocators by file and line
  
  Our desired architecture would make allocators completely pluggable,
  such that users of libgit2 can swap out memory allocators at runtime.
  While making e.g. debugging easier by not having to do a separate build,
  this feature can also help maintainers of bindings for libgit2 by tying
  the memory allocations into the other language's memory system.
  
  In order to do so, though, we first need to make our two different
  pre-existing allocators "stdalloc" and "crtdbg" have the same function
  signatures, as the "crtdbg" allocators all have an additional file and
  line argument. This is required to build correct stack traces for
  debugging memory allocations. As that feature may also be interesting to
  authors of other applications for debugging libgit2, we now simply add
  these arguments to our standard allocators.
  
  Obviously, this may come with a performance penalty. During some simple
  benchmarks no real impact could be measured though in contrast to a
  simple pluggable allocator. The following table summarizes the
  benchmarks. There were three different builds with our current standard
  allocator ("standard"), with pluggable authenticators accessed via
  function pointers ("pluggable") and for pluggable authenticators with
  file and line being added ("fileline"). Furthermore, there were three
  scenarios for 100.000.000 allocations of 100B ("small alloc"),
  100.000.000 allocations of 100KB ("medium alloc"), and 1.000.000
  allocations of 100MB. All results are best of 10 runs.
  
  |------------|-------------------|-------------------|-------------------|
  | build/test | small alloc       | medium alloc      | big alloc         |
  |------------|-------------------|-------------------|-------------------|
  | standard   | 4539779566, +0.0% | 5912927186, +0.0% | 5166935308, +0.0% |
  |------------|-------------------|-------------------|-------------------|
  | pluggable  | 4611074505, +1.5% | 5979185308, +1.1% | 5388776352, +4.2% |
  |------------|-------------------|-------------------|-------------------|
  | fileline   | 4588338192, +1.1% | 6004951910, +1.5% | 4942528135, -4.4% |
  |------------|-------------------|-------------------|-------------------|
  
  As can be seen, there is a performance overhead for pluggable
  allocators. Furthermore, it can also be seen that there is some big
  variance between runs, especially in the "big alloc" scenario. This is
  probably being caused by nondeterministic behaviour in the kernel for
  dynamic allocations. Still, it can be observed that there should be no
  real difference between the "pluggable" and "fileline" allocators.
  

Download

• src/stdalloc.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  
  #include "stdalloc.h"
  
  static void *stdalloc__malloc(size_t len, const char *file, int line)
  {
  	void *ptr = malloc(len);
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	if (!ptr) giterr_set_oom();
  	return ptr;
  }
  
  static void *stdalloc__calloc(size_t nelem, size_t elsize, const char *file, int line)
  {
  	void *ptr = calloc(nelem, elsize);
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	if (!ptr) giterr_set_oom();
  	return ptr;
  }
  
  static char *stdalloc__strdup(const char *str, const char *file, int line)
  {
  	char *ptr = strdup(str);
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	if (!ptr) giterr_set_oom();
  	return ptr;
  }
  
  static char *stdalloc__strndup(const char *str, size_t n, const char *file, int line)
  {
  	size_t length = 0, alloclength;
  	char *ptr;
  
  	length = p_strnlen(str, n);
  
  	if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
  		!(ptr = stdalloc__malloc(alloclength, file, line)))
  		return NULL;
  
  	if (length)
  		memcpy(ptr, str, length);
  
  	ptr[length] = '\0';
  
  	return ptr;
  }
  
  static char *stdalloc__substrdup(const char *start, size_t n, const char *file, int line)
  {
  	char *ptr;
  	size_t alloclen;
  
  	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
  		!(ptr = stdalloc__malloc(alloclen, file, line)))
  		return NULL;
  
  	memcpy(ptr, start, n);
  	ptr[n] = '\0';
  	return ptr;
  }
  
  static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int line)
  {
  	void *new_ptr = realloc(ptr, size);
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	if (!new_ptr) giterr_set_oom();
  	return new_ptr;
  }
  
  static void *stdalloc__reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
  {
  	size_t newsize;
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	return GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize) ?
  		NULL : realloc(ptr, newsize);
  }
  
  static void *stdalloc__mallocarray(size_t nelem, size_t elsize, const char *file, int line)
  {
  	return stdalloc__reallocarray(NULL, nelem, elsize, file, line);
  }
  
  static void stdalloc__free(void *ptr)
  {
  	free(ptr);
  }
  
  int git_stdalloc_init_allocator(git_allocator *allocator)
  {
  	allocator->gmalloc = stdalloc__malloc;
  	allocator->gcalloc = stdalloc__calloc;
  	allocator->gstrdup = stdalloc__strdup;
  	allocator->gstrndup = stdalloc__strndup;
  	allocator->gsubstrdup = stdalloc__substrdup;
  	allocator->grealloc = stdalloc__realloc;
  	allocator->greallocarray = stdalloc__reallocarray;
  	allocator->gmallocarray = stdalloc__mallocarray;
  	allocator->gfree = stdalloc__free;
  	return 0;
  }
  

Download