kmx git

Commit	Date	Message
0c7f49dd	2017-06-30T13:39:01	Make sure to always include "common.h" first 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.
2480d0eb	2017-06-30T13:34:05	Add missing license headers Some implementation files were missing the license headers. This commit adds them.
ed0571f8	2016-01-12T16:08:38	Add a new build flag to disable the pool allocator and pass all git_pool_malloc calls straight to git__malloc
7ff7ca62	2015-11-12T20:51:01	pool: Never return unaligned buffers
d3416dfe	2015-10-28T10:50:25	pool: Dot not assume mallocs are zeroed out
410efda8	2015-10-28T10:28:43	pool: Take into account malloc overhead & pool page size
1e5e02b4	2015-10-27T17:26:04	pool: Simplify implementation
f1453c59	2015-02-12T12:19:37	Make our overflow check look more like gcc/clang's Make our overflow checking look more like gcc and clang's, so that we can substitute it out with the compiler instrinsics on platforms that support it. This means dropping the ability to pass `NULL` as an out parameter. As a result, the macros also get updated to reflect this as well.
2884cc42	2015-02-11T09:39:38	overflow checking: don't make callers set oom Have the ALLOC_OVERFLOW testing macros also simply set_oom in the case where a computation would overflow, so that callers don't need to.
392702ee	2015-02-09T23:41:13	allocations: test for overflow of requested size Introduce some helper macros to test integer overflow from arithmetic and set error message appropriately.
9ae4ad2d	2015-01-20T23:26:55	Treat a NULL string as if it's empty
b874629b	2014-12-04T21:06:59	Spelling fixes
177a29d8	2014-10-27T10:39:45	Merge commit 'refs/pull/2366/head' of github.com:libgit2/libgit2
ad8c8d93	2014-09-25T12:05:48	Ensure pool data is aligned on an 8 byte boundary
5fa8cda9	2014-06-30T12:05:25	Round up pool alloc sizes for alignment 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.
62e562f9	2014-05-18T07:54:41	Fix compiler warning (git_off_t cast to size_t). Use size_t for page size, instead of long. Check result of sysconf. Use size_t for page offset so no cast to size_t (second arg to p_mmap). Use mod instead div/mult pair, so no cast to size_t is necessary.
437f7d69	2013-12-13T12:41:22	pool: Correct overflow checks 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.
ce33645f	2013-12-13T12:25:48	pool: Cleanup error handling in pool_strdup 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.
96869a4e	2013-12-03T16:45:39	Improve GIT_EUSER handling 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.
2d160ef7	2013-05-29T16:03:30	allow (ignore) bare slash in gitignore
f16fb099	2013-03-15T12:11:02	pool: Internal struct name
14bedad9	2013-03-14T15:08:04	Added pool freelist struct for readability 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.
0c468633	2013-03-14T13:40:15	Improved tree iterator internals 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).
71d27358	2012-07-19T10:23:45	Fix bug with merging diffs with null options A diff that is created with a NULL options parameter could result in a NULL prefix string, but diff merge was unconditionally strdup'ing it. I added a test to replicate the issue and then a new method that does the right thing with NULL values.
a8df98c6	2012-06-14T18:57:24	Updates from comments on OS4 compatibility pull request http://github.com/libgit2/libgit2/pull/766
6b5db63c	2012-06-07T21:40:07	random page size for os4
821f6bc7	2012-04-26T13:04:54	Fix Win32 warnings
da3b391c	2012-04-18T10:57:08	Convert revwalk to use git_pool This removes the custom paged allocator from revwalk and replaces it with a `git_pool`.
2bc8fa02	2012-04-17T10:14:24	Implement git_pool paged memory allocator 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.
19fa2bc1	2012-04-17T15:12:50	Convert attrs and diffs to use string pools 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.

0c7f49dd

2017-06-30T13:39:01

Make sure to always include "common.h" first 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.

2480d0eb

2017-06-30T13:34:05

Add missing license headers Some implementation files were missing the license headers. This commit adds them.

ed0571f8

2016-01-12T16:08:38

Add a new build flag to disable the pool allocator and pass all git_pool_malloc calls straight to git__malloc

7ff7ca62

2015-11-12T20:51:01

pool: Never return unaligned buffers

d3416dfe

2015-10-28T10:50:25

pool: Dot not assume mallocs are zeroed out

410efda8

2015-10-28T10:28:43

pool: Take into account malloc overhead & pool page size

1e5e02b4

2015-10-27T17:26:04

pool: Simplify implementation

f1453c59

2015-02-12T12:19:37

Make our overflow check look more like gcc/clang's Make our overflow checking look more like gcc and clang's, so that we can substitute it out with the compiler instrinsics on platforms that support it. This means dropping the ability to pass `NULL` as an out parameter. As a result, the macros also get updated to reflect this as well.

2884cc42

2015-02-11T09:39:38

overflow checking: don't make callers set oom Have the ALLOC_OVERFLOW testing macros also simply set_oom in the case where a computation would overflow, so that callers don't need to.

392702ee

2015-02-09T23:41:13

allocations: test for overflow of requested size Introduce some helper macros to test integer overflow from arithmetic and set error message appropriately.

9ae4ad2d

2015-01-20T23:26:55

Treat a NULL string as if it's empty

b874629b

2014-12-04T21:06:59

Spelling fixes

177a29d8

2014-10-27T10:39:45

Merge commit 'refs/pull/2366/head' of github.com:libgit2/libgit2

ad8c8d93

2014-09-25T12:05:48

Ensure pool data is aligned on an 8 byte boundary

5fa8cda9

2014-06-30T12:05:25

Round up pool alloc sizes for alignment 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.

62e562f9

2014-05-18T07:54:41

Fix compiler warning (git_off_t cast to size_t). Use size_t for page size, instead of long. Check result of sysconf. Use size_t for page offset so no cast to size_t (second arg to p_mmap). Use mod instead div/mult pair, so no cast to size_t is necessary.

437f7d69

2013-12-13T12:41:22

pool: Correct overflow checks 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.

ce33645f

2013-12-13T12:25:48

pool: Cleanup error handling in pool_strdup 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.

96869a4e

2013-12-03T16:45:39

Improve GIT_EUSER handling 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.

2d160ef7

2013-05-29T16:03:30

allow (ignore) bare slash in gitignore

f16fb099

2013-03-15T12:11:02

pool: Internal struct name

14bedad9

2013-03-14T15:08:04

Added pool freelist struct for readability 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.

0c468633

2013-03-14T13:40:15

Improved tree iterator internals 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).

71d27358

2012-07-19T10:23:45

Fix bug with merging diffs with null options A diff that is created with a NULL options parameter could result in a NULL prefix string, but diff merge was unconditionally strdup'ing it. I added a test to replicate the issue and then a new method that does the right thing with NULL values.

a8df98c6

2012-06-14T18:57:24

Updates from comments on OS4 compatibility pull request http://github.com/libgit2/libgit2/pull/766

6b5db63c

2012-06-07T21:40:07

random page size for os4

821f6bc7

2012-04-26T13:04:54

Fix Win32 warnings

da3b391c

2012-04-18T10:57:08

Convert revwalk to use git_pool This removes the custom paged allocator from revwalk and replaces it with a `git_pool`.

2bc8fa02

2012-04-17T10:14:24

Implement git_pool paged memory allocator 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.

19fa2bc1

2012-04-17T15:12:50

Convert attrs and diffs to use string pools 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.

thodg/libgit2/src/pool.c

src/pool.c

Log