1. 23 Feb, 2022 2 commits
  2. 27 Nov, 2020 1 commit
  3. 08 Oct, 2020 2 commits
    • Avoid using atomics in pool.c · 03c0938f
      Instead, globally initialize the system page size.
      lhchavez committed
    • Improve the support of atomics · cc1d7f5c
      This change:
      
      * Starts using GCC's and clang's `__atomic_*` intrinsics instead of the
        `__sync_*` ones, since the former supercede the latter (and can be
        safely replaced by their equivalent `__atomic_*` version with the
        sequentially consistent model).
      * Makes `git_atomic64`'s value `volatile`. Otherwise, this will make
        ThreadSanitizer complain.
      * Adds ways to load the values from atomics. As it turns out,
        unsynchronized read are okay only in some architectures, but if we
        want to be correct (and make ThreadSanitizer happy), those loads
        should also be performed with the atomic builtins.
      * Fixes two ThreadSanitizer warnings, as a proof-of-concept that this
        works:
        - Avoid directly accessing `git_refcount`'s `owner` directly, and
          instead makes all callers go through the `GIT_REFCOUNT_*()` macros,
          which also use the atomic utilities.
        - Makes `pool_system_page_size()` race-free.
      
      Part of: #5592
      lhchavez committed
  4. 09 Jun, 2020 1 commit
  5. 23 May, 2020 1 commit
  6. 24 Jun, 2019 2 commits
  7. 03 Jul, 2017 2 commits
    • Make sure to always include "common.h" first · 0c7f49dd
      Next to including several files, our "common.h" header also declares
      various macros which are then used throughout the project. As such, we
      have to make sure to always include this file first in all
      implementation files. Otherwise, we might encounter problems or even
      silent behavioural differences due to macros or defines not being
      defined as they should be. So in fact, our header and implementation
      files should make sure to always include "common.h" first.
      
      This commit does so by establishing a common include pattern. Header
      files inside of "src" will now always include "common.h" as its first
      other file, separated by a newline from all the other includes to make
      it stand out as special. There are two cases for the implementation
      files. If they do have a matching header file, they will always include
      this one first, leading to "common.h" being transitively included as
      first file. If they do not have a matching header file, they instead
      include "common.h" as first file themselves.
      
      This fixes the outlined problems and will become our standard practice
      for header and source files inside of the "src/" from now on.
      Patrick Steinhardt committed
    • Add missing license headers · 2480d0eb
      Some implementation files were missing the license headers. This commit
      adds them.
      Patrick Steinhardt committed
  8. 12 Jan, 2016 1 commit
  9. 13 Nov, 2015 1 commit
  10. 28 Oct, 2015 3 commits
  11. 13 Feb, 2015 3 commits
  12. 20 Jan, 2015 1 commit
  13. 05 Dec, 2014 1 commit
  14. 25 Sep, 2014 1 commit
  15. 30 Jun, 2014 1 commit
    • Round up pool alloc sizes for alignment · 5fa8cda9
      To make sure that items returned from pool allocations are aligned
      on nice boundaries, this rounds up all pool allocation sizes to a
      multiple of 8.  This adds a small amount of overhead to each item.
      
      The rounding up could be made optional with an extra parameter to
      the pool initialization that turned on rounding only for pools
      where item alignment actually matters, but I think for the extra
      code and complexity that would be involved, that it makes sense
      just to burn a little bit of extra memory and enable this all the
      time.
      Russell Belfer committed
  16. 20 May, 2014 1 commit
  17. 13 Dec, 2013 2 commits
    • pool: Correct overflow checks · 437f7d69
      Ok, scrap the previous commit. This is the right overflow check that
      takes care of 64 bit overflow **and** 32-bit overflow, which needs to be
      considered because the pool malloc can only allocate 32-bit elements in
      one go.
      Vicent Marti committed
    • pool: Cleanup error handling in pool_strdup · ce33645f
      Note that `git_pool_strdup` cannot really return any error codes,
       because the pool doesn't set errors on OOM.
      
       The only place where `giterr_set_oom` is called is in
       `git_pool_strndup`, in a conditional check that is always optimized
       away. `n + 1` cannot be zero if `n` is unsigned because the compiler
       doesn't take wraparound into account.
      
       This check has been removed altogether because `size_t` is not
       particularly going to overflow.
      Vicent Marti committed
  18. 11 Dec, 2013 1 commit
    • Improve GIT_EUSER handling · 96869a4e
      This adds giterr_user_cancel to return GIT_EUSER and clear any
      error message that is sitting around.  As a result of using that
      in places, we need to be more thorough with capturing errors that
      happen inside a callback when used internally.  To help with that,
      this also adds giterr_capture and giterr_restore so that when we
      internally use a foreach-type function that clears errors and
      converts them to GIT_EUSER, it is easier to restore not just the
      return value, but the actual error message text.
      Russell Belfer committed
  19. 29 May, 2013 1 commit
  20. 15 Mar, 2013 1 commit
  21. 14 Mar, 2013 2 commits
    • Added pool freelist struct for readability · 14bedad9
      This adds a git_pool_freelist_item struct that makes it a little
      easier to follow what's going on with the pool free list block
      management code.  It is functionally neutral.
      Russell Belfer committed
    • Improved tree iterator internals · 0c468633
      This updates the tree iterator internals to be more efficient.
      
      The tree_iterator_entry objects are now kept as pointers that are
      allocated from a git_pool, so that we may use git__tsort_r for
      sorting (which is better than qsort, given that the tree is
      likely mostly ordered already).
      
      Those tree_iterator_entry objects now keep direct pointers to the
      data they refer to instead of keeping indirect index values.  This
      simplifies a lot of the data structure traversal code.
      
      This also adds bsearch to find the start item position for range-
      limited tree iterators, and is more explicit about using
      git_path_cmp instead of reimplementing it.  The git_path_cmp
      changed a bit to make it easier for tree_iterators to use it (but
      it was barely being used previously, so not a big deal).
      
      This adds a git_pool_free_array function that efficiently frees a
      list of pool allocated pointers (which the tree_iterator keeps).
      Also, added new tests for the git_pool free list functionality
      that was not previously being tested (or used).
      Russell Belfer committed
  22. 19 Jul, 2012 1 commit
  23. 14 Jun, 2012 1 commit
  24. 07 Jun, 2012 1 commit
  25. 26 Apr, 2012 1 commit
  26. 25 Apr, 2012 3 commits
    • Convert revwalk to use git_pool · da3b391c
      This removes the custom paged allocator from revwalk and
      replaces it with a `git_pool`.
      Russell Belfer committed
    • Convert attrs and diffs to use string pools · 19fa2bc1
      This converts the git attr related code (including ignores) and
      the git diff related code (and implicitly the status code) to use
      `git_pools` for storing strings.  This reduces the number of small
      blocks allocated dramatically.
      Russell Belfer committed
    • Implement git_pool paged memory allocator · 2bc8fa02
      This adds a `git_pool` object that can do simple paged memory
      allocation with free for the entire pool at once.  Using this,
      you can replace many small allocations with large blocks that
      can then cheaply be doled out in small pieces.  This is best
      used when you plan to free the small blocks all at once - for
      example, if they represent the parsed state from a file or data
      stream that are either all kept or all discarded.
      
      There are two real patterns of usage for `git_pools`: either
      for "string" allocation, where the item size is a single byte
      and you end up just packing the allocations in together, or for
      "fixed size" allocation where you are allocating a large object
      (e.g. a `git_oid`) and you generally just allocation single
      objects that can be tightly packed.  Of course, you can use it
      for other things, but those two cases are the easiest.
      Russell Belfer committed