mirror of
https://github.com/git/git.git
synced 2024-05-13 01:46:08 +02:00
4fbcca4eff
The can_all_from_reach_with_flags() algorithm is currently quadratic in the worst case, because it calls the reachable() method for every 'from' without tracking which commits have already been walked or which can already reach a commit in 'to'. Rewrite the algorithm to walk each commit a constant number of times. We also add some optimizations that should work for the main consumer of this method: fetch negotitation (haves/wants). The first step includes using a depth-first-search (DFS) from each 'from' commit, sorted by ascending generation number. We do not walk beyond the minimum generation number or the minimum commit date. This DFS is likely to be faster than the existing reachable() method because we expect previous ref values to be along the first-parent history. If we find a target commit, then we mark everything in the DFS stack as a RESULT. This expands the set of targets for the other 'from' commits. We also mark the visited commits using 'assign_flag' to prevent re- walking the same commits. We still need to clear our flags at the end, which is why we will have a total of three visits to each commit. Performance was measured on the Linux repository using 'test-tool reach can_all_from_reach'. The input included rows seeded by tag values. The "small" case included X-rows as v4.[0-9]* and Y-rows as v3.[0-9]*. This mimics a (very large) fetch that says "I have all major v3 releases and want all major v4 releases." The "large" case included X-rows as "v4.*" and Y-rows as "v3.*". This adds all release-candidate tags to the set, which does not greatly increase the number of objects that are considered, but does increase the number of 'from' commits, demonstrating the quadratic nature of the previous code. Small Case: Before: 1.52 s After: 0.26 s Large Case: Before: 3.50 s After: 0.27 s Note how the time increases between the two cases in the two versions. The new code increases relative to the number of commits that need to be walked, but not directly relative to the number of 'from' commits. Signed-off-by: Derrick Stolee <dstolee@microsoft.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
78 lines
2.6 KiB
C
78 lines
2.6 KiB
C
#ifndef __COMMIT_REACH_H__
|
|
#define __COMMIT_REACH_H__
|
|
|
|
#include "commit-slab.h"
|
|
|
|
struct commit;
|
|
struct commit_list;
|
|
struct contains_cache;
|
|
struct ref_filter;
|
|
|
|
struct commit_list *get_merge_bases_many(struct commit *one,
|
|
int n,
|
|
struct commit **twos);
|
|
struct commit_list *get_merge_bases_many_dirty(struct commit *one,
|
|
int n,
|
|
struct commit **twos);
|
|
struct commit_list *get_merge_bases(struct commit *one, struct commit *two);
|
|
struct commit_list *get_octopus_merge_bases(struct commit_list *in);
|
|
|
|
/* To be used only when object flags after this call no longer matter */
|
|
struct commit_list *get_merge_bases_many_dirty(struct commit *one, int n, struct commit **twos);
|
|
|
|
int is_descendant_of(struct commit *commit, struct commit_list *with_commit);
|
|
int in_merge_bases_many(struct commit *commit, int nr_reference, struct commit **reference);
|
|
int in_merge_bases(struct commit *commit, struct commit *reference);
|
|
|
|
/*
|
|
* Takes a list of commits and returns a new list where those
|
|
* have been removed that can be reached from other commits in
|
|
* the list. It is useful for, e.g., reducing the commits
|
|
* randomly thrown at the git-merge command and removing
|
|
* redundant commits that the user shouldn't have given to it.
|
|
*
|
|
* This function destroys the STALE bit of the commit objects'
|
|
* flags.
|
|
*/
|
|
struct commit_list *reduce_heads(struct commit_list *heads);
|
|
|
|
/*
|
|
* Like `reduce_heads()`, except it replaces the list. Use this
|
|
* instead of `foo = reduce_heads(foo);` to avoid memory leaks.
|
|
*/
|
|
void reduce_heads_replace(struct commit_list **heads);
|
|
|
|
int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid);
|
|
|
|
/*
|
|
* Unknown has to be "0" here, because that's the default value for
|
|
* contains_cache slab entries that have not yet been assigned.
|
|
*/
|
|
enum contains_result {
|
|
CONTAINS_UNKNOWN = 0,
|
|
CONTAINS_NO,
|
|
CONTAINS_YES
|
|
};
|
|
|
|
define_commit_slab(contains_cache, enum contains_result);
|
|
|
|
int commit_contains(struct ref_filter *filter, struct commit *commit,
|
|
struct commit_list *list, struct contains_cache *cache);
|
|
|
|
/*
|
|
* Determine if every commit in 'from' can reach at least one commit
|
|
* that is marked with 'with_flag'. As we traverse, use 'assign_flag'
|
|
* as a marker for commits that are already visited. Do not walk
|
|
* commits with date below 'min_commit_date' or generation below
|
|
* 'min_generation'.
|
|
*/
|
|
int can_all_from_reach_with_flag(struct object_array *from,
|
|
unsigned int with_flag,
|
|
unsigned int assign_flag,
|
|
time_t min_commit_date,
|
|
uint32_t min_generation);
|
|
int can_all_from_reach(struct commit_list *from, struct commit_list *to,
|
|
int commit_date_cutoff);
|
|
|
|
#endif
|