mirror of
https://github.com/git/git
synced 2024-08-26 11:09:18 +00:00
![Derrick Stolee](/assets/img/avatar_default.png)
The remove_redundant_with_gen() algorithm performs a depth-first-search to find commits in the 'array' list, starting at the parents of each commit in 'array'. The result is that commits in 'array' are marked STALE when they are reachable from another commit in 'array'. This depth-first-search is fast when commits lie on or near the first-parent history of the higher commits. The search terminates early if all but one commit becomes marked STALE. However, it is possible that there are two independent commits with high generation number. In that case, the depth-first-search might languish by searching in lower generations due to the fixed min_generation used throughout the method. With the expectation that commits with lower generation are expected to become STALE more often, we can optimize further by increasing that min_generation boundary upon discovery of the commit with minimum generation. We must first sort the commits in 'array' by generation. We cannot sort 'array' itself since it must preserve relative order among the returned results (see revision.c:mark_redundant_parents() for an example). This simplifies the initialization of min_generation, but it also allows us to increase the new min_generation when we find the commit with smallest generation remaining. This requires more than two commits in order to test, so I used the Linux kernel repository with a few commits that are slightly off of the first-parent history. I timed the following command: git merge-base --independent 2ecedd756908 d2360a398f0b \ 1253935ad801 160bab43419e 0e2209629fec 1d0e16ac1a9e The first two commits have similar generation and are near the v5.10 tag. Commit 160bab43419e is off of the first-parent history behind v5.5, while the others are scattered somewhere reachable from v5.9. This is designed to demonstrate the optimization, as that commit within v5.5 would normally cause a lot of extra commit walking. Since remove_redundant_with_alg() is called only when at least one of the input commits has a finite generation number, this algorithm is tested with a commit-graph generated starting at a number of different tags, the earliest being v5.5. commit-graph at v5.5: | Method | Time | |-----------------------+-------| | *_no_gen() | 864ms | | *_with_gen() (before) | 858ms | | *_with_gen() (after) | 810ms | commit-graph at v5.7: | Method | Time | |-----------------------+-------| | *_no_gen() | 625ms | | *_with_gen() (before) | 572ms | | *_with_gen() (after) | 517ms | commit-graph at v5.9: | Method | Time | |-----------------------+-------| | *_no_gen() | 268ms | | *_with_gen() (before) | 224ms | | *_with_gen() (after) | 202ms | commit-graph at v5.10: | Method | Time | |-----------------------+-------| | *_no_gen() | 72ms | | *_with_gen() (before) | 37ms | | *_with_gen() (after) | 9ms | Note that these are only modest improvements for the case where the two independent commits are not in the commit-graph (not until v5.10). All algorithms get faster as more commits are indexed, which is not a surprise. However, the cost of walking extra commits is more and more prevalent in relative terms as more commits are indexed. Finally, the last case allows us to jump to the minimum generation between the last two commits (that are actually independent) so we greatly reduce the cost in that case. Signed-off-by: Derrick Stolee <dstolee@microsoft.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
945 lines
24 KiB
C
945 lines
24 KiB
C
#include "cache.h"
|
|
#include "commit.h"
|
|
#include "commit-graph.h"
|
|
#include "decorate.h"
|
|
#include "prio-queue.h"
|
|
#include "tree.h"
|
|
#include "ref-filter.h"
|
|
#include "revision.h"
|
|
#include "tag.h"
|
|
#include "commit-reach.h"
|
|
|
|
/* Remember to update object flag allocation in object.h */
|
|
#define PARENT1 (1u<<16)
|
|
#define PARENT2 (1u<<17)
|
|
#define STALE (1u<<18)
|
|
#define RESULT (1u<<19)
|
|
|
|
static const unsigned all_flags = (PARENT1 | PARENT2 | STALE | RESULT);
|
|
|
|
static int compare_commits_by_gen(const void *_a, const void *_b)
|
|
{
|
|
const struct commit *a = *(const struct commit * const *)_a;
|
|
const struct commit *b = *(const struct commit * const *)_b;
|
|
|
|
timestamp_t generation_a = commit_graph_generation(a);
|
|
timestamp_t generation_b = commit_graph_generation(b);
|
|
|
|
if (generation_a < generation_b)
|
|
return -1;
|
|
if (generation_a > generation_b)
|
|
return 1;
|
|
if (a->date < b->date)
|
|
return -1;
|
|
if (a->date > b->date)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int queue_has_nonstale(struct prio_queue *queue)
|
|
{
|
|
int i;
|
|
for (i = 0; i < queue->nr; i++) {
|
|
struct commit *commit = queue->array[i].data;
|
|
if (!(commit->object.flags & STALE))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* all input commits in one and twos[] must have been parsed! */
|
|
static struct commit_list *paint_down_to_common(struct repository *r,
|
|
struct commit *one, int n,
|
|
struct commit **twos,
|
|
timestamp_t min_generation)
|
|
{
|
|
struct prio_queue queue = { compare_commits_by_gen_then_commit_date };
|
|
struct commit_list *result = NULL;
|
|
int i;
|
|
timestamp_t last_gen = GENERATION_NUMBER_INFINITY;
|
|
|
|
if (!min_generation && !corrected_commit_dates_enabled(r))
|
|
queue.compare = compare_commits_by_commit_date;
|
|
|
|
one->object.flags |= PARENT1;
|
|
if (!n) {
|
|
commit_list_append(one, &result);
|
|
return result;
|
|
}
|
|
prio_queue_put(&queue, one);
|
|
|
|
for (i = 0; i < n; i++) {
|
|
twos[i]->object.flags |= PARENT2;
|
|
prio_queue_put(&queue, twos[i]);
|
|
}
|
|
|
|
while (queue_has_nonstale(&queue)) {
|
|
struct commit *commit = prio_queue_get(&queue);
|
|
struct commit_list *parents;
|
|
int flags;
|
|
timestamp_t generation = commit_graph_generation(commit);
|
|
|
|
if (min_generation && generation > last_gen)
|
|
BUG("bad generation skip %"PRItime" > %"PRItime" at %s",
|
|
generation, last_gen,
|
|
oid_to_hex(&commit->object.oid));
|
|
last_gen = generation;
|
|
|
|
if (generation < min_generation)
|
|
break;
|
|
|
|
flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
|
|
if (flags == (PARENT1 | PARENT2)) {
|
|
if (!(commit->object.flags & RESULT)) {
|
|
commit->object.flags |= RESULT;
|
|
commit_list_insert_by_date(commit, &result);
|
|
}
|
|
/* Mark parents of a found merge stale */
|
|
flags |= STALE;
|
|
}
|
|
parents = commit->parents;
|
|
while (parents) {
|
|
struct commit *p = parents->item;
|
|
parents = parents->next;
|
|
if ((p->object.flags & flags) == flags)
|
|
continue;
|
|
if (repo_parse_commit(r, p))
|
|
return NULL;
|
|
p->object.flags |= flags;
|
|
prio_queue_put(&queue, p);
|
|
}
|
|
}
|
|
|
|
clear_prio_queue(&queue);
|
|
return result;
|
|
}
|
|
|
|
static struct commit_list *merge_bases_many(struct repository *r,
|
|
struct commit *one, int n,
|
|
struct commit **twos)
|
|
{
|
|
struct commit_list *list = NULL;
|
|
struct commit_list *result = NULL;
|
|
int i;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
if (one == twos[i])
|
|
/*
|
|
* We do not mark this even with RESULT so we do not
|
|
* have to clean it up.
|
|
*/
|
|
return commit_list_insert(one, &result);
|
|
}
|
|
|
|
if (repo_parse_commit(r, one))
|
|
return NULL;
|
|
for (i = 0; i < n; i++) {
|
|
if (repo_parse_commit(r, twos[i]))
|
|
return NULL;
|
|
}
|
|
|
|
list = paint_down_to_common(r, one, n, twos, 0);
|
|
|
|
while (list) {
|
|
struct commit *commit = pop_commit(&list);
|
|
if (!(commit->object.flags & STALE))
|
|
commit_list_insert_by_date(commit, &result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
struct commit_list *get_octopus_merge_bases(struct commit_list *in)
|
|
{
|
|
struct commit_list *i, *j, *k, *ret = NULL;
|
|
|
|
if (!in)
|
|
return ret;
|
|
|
|
commit_list_insert(in->item, &ret);
|
|
|
|
for (i = in->next; i; i = i->next) {
|
|
struct commit_list *new_commits = NULL, *end = NULL;
|
|
|
|
for (j = ret; j; j = j->next) {
|
|
struct commit_list *bases;
|
|
bases = get_merge_bases(i->item, j->item);
|
|
if (!new_commits)
|
|
new_commits = bases;
|
|
else
|
|
end->next = bases;
|
|
for (k = bases; k; k = k->next)
|
|
end = k;
|
|
}
|
|
ret = new_commits;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int remove_redundant_no_gen(struct repository *r,
|
|
struct commit **array, int cnt)
|
|
{
|
|
struct commit **work;
|
|
unsigned char *redundant;
|
|
int *filled_index;
|
|
int i, j, filled;
|
|
|
|
work = xcalloc(cnt, sizeof(*work));
|
|
redundant = xcalloc(cnt, 1);
|
|
ALLOC_ARRAY(filled_index, cnt - 1);
|
|
|
|
for (i = 0; i < cnt; i++)
|
|
repo_parse_commit(r, array[i]);
|
|
for (i = 0; i < cnt; i++) {
|
|
struct commit_list *common;
|
|
timestamp_t min_generation = commit_graph_generation(array[i]);
|
|
|
|
if (redundant[i])
|
|
continue;
|
|
for (j = filled = 0; j < cnt; j++) {
|
|
timestamp_t curr_generation;
|
|
if (i == j || redundant[j])
|
|
continue;
|
|
filled_index[filled] = j;
|
|
work[filled++] = array[j];
|
|
|
|
curr_generation = commit_graph_generation(array[j]);
|
|
if (curr_generation < min_generation)
|
|
min_generation = curr_generation;
|
|
}
|
|
common = paint_down_to_common(r, array[i], filled,
|
|
work, min_generation);
|
|
if (array[i]->object.flags & PARENT2)
|
|
redundant[i] = 1;
|
|
for (j = 0; j < filled; j++)
|
|
if (work[j]->object.flags & PARENT1)
|
|
redundant[filled_index[j]] = 1;
|
|
clear_commit_marks(array[i], all_flags);
|
|
clear_commit_marks_many(filled, work, all_flags);
|
|
free_commit_list(common);
|
|
}
|
|
|
|
/* Now collect the result */
|
|
COPY_ARRAY(work, array, cnt);
|
|
for (i = filled = 0; i < cnt; i++)
|
|
if (!redundant[i])
|
|
array[filled++] = work[i];
|
|
free(work);
|
|
free(redundant);
|
|
free(filled_index);
|
|
return filled;
|
|
}
|
|
|
|
static int remove_redundant_with_gen(struct repository *r,
|
|
struct commit **array, int cnt)
|
|
{
|
|
int i, count_non_stale = 0, count_still_independent = cnt;
|
|
timestamp_t min_generation = GENERATION_NUMBER_INFINITY;
|
|
struct commit **walk_start, **sorted;
|
|
size_t walk_start_nr = 0, walk_start_alloc = cnt;
|
|
int min_gen_pos = 0;
|
|
|
|
/*
|
|
* Sort the input by generation number, ascending. This allows
|
|
* us to increase the "min_generation" limit when we discover
|
|
* the commit with lowest generation is STALE. The index
|
|
* min_gen_pos points to the current position within 'array'
|
|
* that is not yet known to be STALE.
|
|
*/
|
|
ALLOC_ARRAY(sorted, cnt);
|
|
COPY_ARRAY(sorted, array, cnt);
|
|
QSORT(sorted, cnt, compare_commits_by_gen);
|
|
min_generation = commit_graph_generation(sorted[0]);
|
|
|
|
ALLOC_ARRAY(walk_start, walk_start_alloc);
|
|
|
|
/* Mark all parents of the input as STALE */
|
|
for (i = 0; i < cnt; i++) {
|
|
struct commit_list *parents;
|
|
|
|
repo_parse_commit(r, array[i]);
|
|
array[i]->object.flags |= RESULT;
|
|
parents = array[i]->parents;
|
|
|
|
while (parents) {
|
|
repo_parse_commit(r, parents->item);
|
|
if (!(parents->item->object.flags & STALE)) {
|
|
parents->item->object.flags |= STALE;
|
|
ALLOC_GROW(walk_start, walk_start_nr + 1, walk_start_alloc);
|
|
walk_start[walk_start_nr++] = parents->item;
|
|
}
|
|
parents = parents->next;
|
|
}
|
|
}
|
|
|
|
QSORT(walk_start, walk_start_nr, compare_commits_by_gen);
|
|
|
|
/* remove STALE bit for now to allow walking through parents */
|
|
for (i = 0; i < walk_start_nr; i++)
|
|
walk_start[i]->object.flags &= ~STALE;
|
|
|
|
/*
|
|
* Start walking from the highest generation. Hopefully, it will
|
|
* find all other items during the first-parent walk, and we can
|
|
* terminate early. Otherwise, we will do the same amount of work
|
|
* as before.
|
|
*/
|
|
for (i = walk_start_nr - 1; i >= 0 && count_still_independent > 1; i--) {
|
|
/* push the STALE bits up to min generation */
|
|
struct commit_list *stack = NULL;
|
|
|
|
commit_list_insert(walk_start[i], &stack);
|
|
walk_start[i]->object.flags |= STALE;
|
|
|
|
while (stack) {
|
|
struct commit_list *parents;
|
|
struct commit *c = stack->item;
|
|
|
|
repo_parse_commit(r, c);
|
|
|
|
if (c->object.flags & RESULT) {
|
|
c->object.flags &= ~RESULT;
|
|
if (--count_still_independent <= 1)
|
|
break;
|
|
if (oideq(&c->object.oid, &sorted[min_gen_pos]->object.oid)) {
|
|
while (min_gen_pos < cnt - 1 &&
|
|
(sorted[min_gen_pos]->object.flags & STALE))
|
|
min_gen_pos++;
|
|
min_generation = commit_graph_generation(sorted[min_gen_pos]);
|
|
}
|
|
}
|
|
|
|
if (commit_graph_generation(c) < min_generation) {
|
|
pop_commit(&stack);
|
|
continue;
|
|
}
|
|
|
|
parents = c->parents;
|
|
while (parents) {
|
|
if (!(parents->item->object.flags & STALE)) {
|
|
parents->item->object.flags |= STALE;
|
|
commit_list_insert(parents->item, &stack);
|
|
break;
|
|
}
|
|
parents = parents->next;
|
|
}
|
|
|
|
/* pop if all parents have been visited already */
|
|
if (!parents)
|
|
pop_commit(&stack);
|
|
}
|
|
free_commit_list(stack);
|
|
}
|
|
free(sorted);
|
|
|
|
/* clear result */
|
|
for (i = 0; i < cnt; i++)
|
|
array[i]->object.flags &= ~RESULT;
|
|
|
|
/* rearrange array */
|
|
for (i = count_non_stale = 0; i < cnt; i++) {
|
|
if (!(array[i]->object.flags & STALE))
|
|
array[count_non_stale++] = array[i];
|
|
}
|
|
|
|
/* clear marks */
|
|
clear_commit_marks_many(walk_start_nr, walk_start, STALE);
|
|
free(walk_start);
|
|
|
|
return count_non_stale;
|
|
}
|
|
|
|
static int remove_redundant(struct repository *r, struct commit **array, int cnt)
|
|
{
|
|
/*
|
|
* Some commit in the array may be an ancestor of
|
|
* another commit. Move the independent commits to the
|
|
* beginning of 'array' and return their number. Callers
|
|
* should not rely upon the contents of 'array' after
|
|
* that number.
|
|
*/
|
|
if (generation_numbers_enabled(r)) {
|
|
int i;
|
|
|
|
/*
|
|
* If we have a single commit with finite generation
|
|
* number, then the _with_gen algorithm is preferred.
|
|
*/
|
|
for (i = 0; i < cnt; i++) {
|
|
if (commit_graph_generation(array[i]) < GENERATION_NUMBER_INFINITY)
|
|
return remove_redundant_with_gen(r, array, cnt);
|
|
}
|
|
}
|
|
|
|
return remove_redundant_no_gen(r, array, cnt);
|
|
}
|
|
|
|
static struct commit_list *get_merge_bases_many_0(struct repository *r,
|
|
struct commit *one,
|
|
int n,
|
|
struct commit **twos,
|
|
int cleanup)
|
|
{
|
|
struct commit_list *list;
|
|
struct commit **rslt;
|
|
struct commit_list *result;
|
|
int cnt, i;
|
|
|
|
result = merge_bases_many(r, one, n, twos);
|
|
for (i = 0; i < n; i++) {
|
|
if (one == twos[i])
|
|
return result;
|
|
}
|
|
if (!result || !result->next) {
|
|
if (cleanup) {
|
|
clear_commit_marks(one, all_flags);
|
|
clear_commit_marks_many(n, twos, all_flags);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* There are more than one */
|
|
cnt = commit_list_count(result);
|
|
rslt = xcalloc(cnt, sizeof(*rslt));
|
|
for (list = result, i = 0; list; list = list->next)
|
|
rslt[i++] = list->item;
|
|
free_commit_list(result);
|
|
|
|
clear_commit_marks(one, all_flags);
|
|
clear_commit_marks_many(n, twos, all_flags);
|
|
|
|
cnt = remove_redundant(r, rslt, cnt);
|
|
result = NULL;
|
|
for (i = 0; i < cnt; i++)
|
|
commit_list_insert_by_date(rslt[i], &result);
|
|
free(rslt);
|
|
return result;
|
|
}
|
|
|
|
struct commit_list *repo_get_merge_bases_many(struct repository *r,
|
|
struct commit *one,
|
|
int n,
|
|
struct commit **twos)
|
|
{
|
|
return get_merge_bases_many_0(r, one, n, twos, 1);
|
|
}
|
|
|
|
struct commit_list *repo_get_merge_bases_many_dirty(struct repository *r,
|
|
struct commit *one,
|
|
int n,
|
|
struct commit **twos)
|
|
{
|
|
return get_merge_bases_many_0(r, one, n, twos, 0);
|
|
}
|
|
|
|
struct commit_list *repo_get_merge_bases(struct repository *r,
|
|
struct commit *one,
|
|
struct commit *two)
|
|
{
|
|
return get_merge_bases_many_0(r, one, 1, &two, 1);
|
|
}
|
|
|
|
/*
|
|
* Is "commit" a descendant of one of the elements on the "with_commit" list?
|
|
*/
|
|
int repo_is_descendant_of(struct repository *r,
|
|
struct commit *commit,
|
|
struct commit_list *with_commit)
|
|
{
|
|
if (!with_commit)
|
|
return 1;
|
|
|
|
if (generation_numbers_enabled(the_repository)) {
|
|
struct commit_list *from_list = NULL;
|
|
int result;
|
|
commit_list_insert(commit, &from_list);
|
|
result = can_all_from_reach(from_list, with_commit, 0);
|
|
free_commit_list(from_list);
|
|
return result;
|
|
} else {
|
|
while (with_commit) {
|
|
struct commit *other;
|
|
|
|
other = with_commit->item;
|
|
with_commit = with_commit->next;
|
|
if (repo_in_merge_bases_many(r, other, 1, &commit))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Is "commit" an ancestor of one of the "references"?
|
|
*/
|
|
int repo_in_merge_bases_many(struct repository *r, struct commit *commit,
|
|
int nr_reference, struct commit **reference)
|
|
{
|
|
struct commit_list *bases;
|
|
int ret = 0, i;
|
|
timestamp_t generation, max_generation = GENERATION_NUMBER_ZERO;
|
|
|
|
if (repo_parse_commit(r, commit))
|
|
return ret;
|
|
for (i = 0; i < nr_reference; i++) {
|
|
if (repo_parse_commit(r, reference[i]))
|
|
return ret;
|
|
|
|
generation = commit_graph_generation(reference[i]);
|
|
if (generation > max_generation)
|
|
max_generation = generation;
|
|
}
|
|
|
|
generation = commit_graph_generation(commit);
|
|
if (generation > max_generation)
|
|
return ret;
|
|
|
|
bases = paint_down_to_common(r, commit,
|
|
nr_reference, reference,
|
|
generation);
|
|
if (commit->object.flags & PARENT2)
|
|
ret = 1;
|
|
clear_commit_marks(commit, all_flags);
|
|
clear_commit_marks_many(nr_reference, reference, all_flags);
|
|
free_commit_list(bases);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Is "commit" an ancestor of (i.e. reachable from) the "reference"?
|
|
*/
|
|
int repo_in_merge_bases(struct repository *r,
|
|
struct commit *commit,
|
|
struct commit *reference)
|
|
{
|
|
int res;
|
|
struct commit_list *list = NULL;
|
|
struct commit_list **next = &list;
|
|
|
|
next = commit_list_append(commit, next);
|
|
res = repo_is_descendant_of(r, reference, list);
|
|
free_commit_list(list);
|
|
|
|
return res;
|
|
}
|
|
|
|
struct commit_list *reduce_heads(struct commit_list *heads)
|
|
{
|
|
struct commit_list *p;
|
|
struct commit_list *result = NULL, **tail = &result;
|
|
struct commit **array;
|
|
int num_head, i;
|
|
|
|
if (!heads)
|
|
return NULL;
|
|
|
|
/* Uniquify */
|
|
for (p = heads; p; p = p->next)
|
|
p->item->object.flags &= ~STALE;
|
|
for (p = heads, num_head = 0; p; p = p->next) {
|
|
if (p->item->object.flags & STALE)
|
|
continue;
|
|
p->item->object.flags |= STALE;
|
|
num_head++;
|
|
}
|
|
array = xcalloc(num_head, sizeof(*array));
|
|
for (p = heads, i = 0; p; p = p->next) {
|
|
if (p->item->object.flags & STALE) {
|
|
array[i++] = p->item;
|
|
p->item->object.flags &= ~STALE;
|
|
}
|
|
}
|
|
num_head = remove_redundant(the_repository, array, num_head);
|
|
for (i = 0; i < num_head; i++)
|
|
tail = &commit_list_insert(array[i], tail)->next;
|
|
free(array);
|
|
return result;
|
|
}
|
|
|
|
void reduce_heads_replace(struct commit_list **heads)
|
|
{
|
|
struct commit_list *result = reduce_heads(*heads);
|
|
free_commit_list(*heads);
|
|
*heads = result;
|
|
}
|
|
|
|
int ref_newer(const struct object_id *new_oid, const struct object_id *old_oid)
|
|
{
|
|
struct object *o;
|
|
struct commit *old_commit, *new_commit;
|
|
struct commit_list *old_commit_list = NULL;
|
|
int ret;
|
|
|
|
/*
|
|
* Both new_commit and old_commit must be commit-ish and new_commit is descendant of
|
|
* old_commit. Otherwise we require --force.
|
|
*/
|
|
o = deref_tag(the_repository, parse_object(the_repository, old_oid),
|
|
NULL, 0);
|
|
if (!o || o->type != OBJ_COMMIT)
|
|
return 0;
|
|
old_commit = (struct commit *) o;
|
|
|
|
o = deref_tag(the_repository, parse_object(the_repository, new_oid),
|
|
NULL, 0);
|
|
if (!o || o->type != OBJ_COMMIT)
|
|
return 0;
|
|
new_commit = (struct commit *) o;
|
|
|
|
if (parse_commit(new_commit) < 0)
|
|
return 0;
|
|
|
|
commit_list_insert(old_commit, &old_commit_list);
|
|
ret = repo_is_descendant_of(the_repository,
|
|
new_commit, old_commit_list);
|
|
free_commit_list(old_commit_list);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Mimicking the real stack, this stack lives on the heap, avoiding stack
|
|
* overflows.
|
|
*
|
|
* At each recursion step, the stack items points to the commits whose
|
|
* ancestors are to be inspected.
|
|
*/
|
|
struct contains_stack {
|
|
int nr, alloc;
|
|
struct contains_stack_entry {
|
|
struct commit *commit;
|
|
struct commit_list *parents;
|
|
} *contains_stack;
|
|
};
|
|
|
|
static int in_commit_list(const struct commit_list *want, struct commit *c)
|
|
{
|
|
for (; want; want = want->next)
|
|
if (oideq(&want->item->object.oid, &c->object.oid))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Test whether the candidate is contained in the list.
|
|
* Do not recurse to find out, though, but return -1 if inconclusive.
|
|
*/
|
|
static enum contains_result contains_test(struct commit *candidate,
|
|
const struct commit_list *want,
|
|
struct contains_cache *cache,
|
|
timestamp_t cutoff)
|
|
{
|
|
enum contains_result *cached = contains_cache_at(cache, candidate);
|
|
|
|
/* If we already have the answer cached, return that. */
|
|
if (*cached)
|
|
return *cached;
|
|
|
|
/* or are we it? */
|
|
if (in_commit_list(want, candidate)) {
|
|
*cached = CONTAINS_YES;
|
|
return CONTAINS_YES;
|
|
}
|
|
|
|
/* Otherwise, we don't know; prepare to recurse */
|
|
parse_commit_or_die(candidate);
|
|
|
|
if (commit_graph_generation(candidate) < cutoff)
|
|
return CONTAINS_NO;
|
|
|
|
return CONTAINS_UNKNOWN;
|
|
}
|
|
|
|
static void push_to_contains_stack(struct commit *candidate, struct contains_stack *contains_stack)
|
|
{
|
|
ALLOC_GROW(contains_stack->contains_stack, contains_stack->nr + 1, contains_stack->alloc);
|
|
contains_stack->contains_stack[contains_stack->nr].commit = candidate;
|
|
contains_stack->contains_stack[contains_stack->nr++].parents = candidate->parents;
|
|
}
|
|
|
|
static enum contains_result contains_tag_algo(struct commit *candidate,
|
|
const struct commit_list *want,
|
|
struct contains_cache *cache)
|
|
{
|
|
struct contains_stack contains_stack = { 0, 0, NULL };
|
|
enum contains_result result;
|
|
timestamp_t cutoff = GENERATION_NUMBER_INFINITY;
|
|
const struct commit_list *p;
|
|
|
|
for (p = want; p; p = p->next) {
|
|
timestamp_t generation;
|
|
struct commit *c = p->item;
|
|
load_commit_graph_info(the_repository, c);
|
|
generation = commit_graph_generation(c);
|
|
if (generation < cutoff)
|
|
cutoff = generation;
|
|
}
|
|
|
|
result = contains_test(candidate, want, cache, cutoff);
|
|
if (result != CONTAINS_UNKNOWN)
|
|
return result;
|
|
|
|
push_to_contains_stack(candidate, &contains_stack);
|
|
while (contains_stack.nr) {
|
|
struct contains_stack_entry *entry = &contains_stack.contains_stack[contains_stack.nr - 1];
|
|
struct commit *commit = entry->commit;
|
|
struct commit_list *parents = entry->parents;
|
|
|
|
if (!parents) {
|
|
*contains_cache_at(cache, commit) = CONTAINS_NO;
|
|
contains_stack.nr--;
|
|
}
|
|
/*
|
|
* If we just popped the stack, parents->item has been marked,
|
|
* therefore contains_test will return a meaningful yes/no.
|
|
*/
|
|
else switch (contains_test(parents->item, want, cache, cutoff)) {
|
|
case CONTAINS_YES:
|
|
*contains_cache_at(cache, commit) = CONTAINS_YES;
|
|
contains_stack.nr--;
|
|
break;
|
|
case CONTAINS_NO:
|
|
entry->parents = parents->next;
|
|
break;
|
|
case CONTAINS_UNKNOWN:
|
|
push_to_contains_stack(parents->item, &contains_stack);
|
|
break;
|
|
}
|
|
}
|
|
free(contains_stack.contains_stack);
|
|
return contains_test(candidate, want, cache, cutoff);
|
|
}
|
|
|
|
int commit_contains(struct ref_filter *filter, struct commit *commit,
|
|
struct commit_list *list, struct contains_cache *cache)
|
|
{
|
|
if (filter->with_commit_tag_algo)
|
|
return contains_tag_algo(commit, list, cache) == CONTAINS_YES;
|
|
return repo_is_descendant_of(the_repository, commit, list);
|
|
}
|
|
|
|
int can_all_from_reach_with_flag(struct object_array *from,
|
|
unsigned int with_flag,
|
|
unsigned int assign_flag,
|
|
time_t min_commit_date,
|
|
timestamp_t min_generation)
|
|
{
|
|
struct commit **list = NULL;
|
|
int i;
|
|
int nr_commits;
|
|
int result = 1;
|
|
|
|
ALLOC_ARRAY(list, from->nr);
|
|
nr_commits = 0;
|
|
for (i = 0; i < from->nr; i++) {
|
|
struct object *from_one = from->objects[i].item;
|
|
|
|
if (!from_one || from_one->flags & assign_flag)
|
|
continue;
|
|
|
|
from_one = deref_tag(the_repository, from_one,
|
|
"a from object", 0);
|
|
if (!from_one || from_one->type != OBJ_COMMIT) {
|
|
/*
|
|
* no way to tell if this is reachable by
|
|
* looking at the ancestry chain alone, so
|
|
* leave a note to ourselves not to worry about
|
|
* this object anymore.
|
|
*/
|
|
from->objects[i].item->flags |= assign_flag;
|
|
continue;
|
|
}
|
|
|
|
list[nr_commits] = (struct commit *)from_one;
|
|
if (parse_commit(list[nr_commits]) ||
|
|
commit_graph_generation(list[nr_commits]) < min_generation) {
|
|
result = 0;
|
|
goto cleanup;
|
|
}
|
|
|
|
nr_commits++;
|
|
}
|
|
|
|
QSORT(list, nr_commits, compare_commits_by_gen);
|
|
|
|
for (i = 0; i < nr_commits; i++) {
|
|
/* DFS from list[i] */
|
|
struct commit_list *stack = NULL;
|
|
|
|
list[i]->object.flags |= assign_flag;
|
|
commit_list_insert(list[i], &stack);
|
|
|
|
while (stack) {
|
|
struct commit_list *parent;
|
|
|
|
if (stack->item->object.flags & (with_flag | RESULT)) {
|
|
pop_commit(&stack);
|
|
if (stack)
|
|
stack->item->object.flags |= RESULT;
|
|
continue;
|
|
}
|
|
|
|
for (parent = stack->item->parents; parent; parent = parent->next) {
|
|
if (parent->item->object.flags & (with_flag | RESULT))
|
|
stack->item->object.flags |= RESULT;
|
|
|
|
if (!(parent->item->object.flags & assign_flag)) {
|
|
parent->item->object.flags |= assign_flag;
|
|
|
|
if (parse_commit(parent->item) ||
|
|
parent->item->date < min_commit_date ||
|
|
commit_graph_generation(parent->item) < min_generation)
|
|
continue;
|
|
|
|
commit_list_insert(parent->item, &stack);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!parent)
|
|
pop_commit(&stack);
|
|
}
|
|
|
|
if (!(list[i]->object.flags & (with_flag | RESULT))) {
|
|
result = 0;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
clear_commit_marks_many(nr_commits, list, RESULT | assign_flag);
|
|
free(list);
|
|
|
|
for (i = 0; i < from->nr; i++)
|
|
from->objects[i].item->flags &= ~assign_flag;
|
|
|
|
return result;
|
|
}
|
|
|
|
int can_all_from_reach(struct commit_list *from, struct commit_list *to,
|
|
int cutoff_by_min_date)
|
|
{
|
|
struct object_array from_objs = OBJECT_ARRAY_INIT;
|
|
time_t min_commit_date = cutoff_by_min_date ? from->item->date : 0;
|
|
struct commit_list *from_iter = from, *to_iter = to;
|
|
int result;
|
|
timestamp_t min_generation = GENERATION_NUMBER_INFINITY;
|
|
|
|
while (from_iter) {
|
|
add_object_array(&from_iter->item->object, NULL, &from_objs);
|
|
|
|
if (!parse_commit(from_iter->item)) {
|
|
timestamp_t generation;
|
|
if (from_iter->item->date < min_commit_date)
|
|
min_commit_date = from_iter->item->date;
|
|
|
|
generation = commit_graph_generation(from_iter->item);
|
|
if (generation < min_generation)
|
|
min_generation = generation;
|
|
}
|
|
|
|
from_iter = from_iter->next;
|
|
}
|
|
|
|
while (to_iter) {
|
|
if (!parse_commit(to_iter->item)) {
|
|
timestamp_t generation;
|
|
if (to_iter->item->date < min_commit_date)
|
|
min_commit_date = to_iter->item->date;
|
|
|
|
generation = commit_graph_generation(to_iter->item);
|
|
if (generation < min_generation)
|
|
min_generation = generation;
|
|
}
|
|
|
|
to_iter->item->object.flags |= PARENT2;
|
|
|
|
to_iter = to_iter->next;
|
|
}
|
|
|
|
result = can_all_from_reach_with_flag(&from_objs, PARENT2, PARENT1,
|
|
min_commit_date, min_generation);
|
|
|
|
while (from) {
|
|
clear_commit_marks(from->item, PARENT1);
|
|
from = from->next;
|
|
}
|
|
|
|
while (to) {
|
|
clear_commit_marks(to->item, PARENT2);
|
|
to = to->next;
|
|
}
|
|
|
|
object_array_clear(&from_objs);
|
|
return result;
|
|
}
|
|
|
|
struct commit_list *get_reachable_subset(struct commit **from, int nr_from,
|
|
struct commit **to, int nr_to,
|
|
unsigned int reachable_flag)
|
|
{
|
|
struct commit **item;
|
|
struct commit *current;
|
|
struct commit_list *found_commits = NULL;
|
|
struct commit **to_last = to + nr_to;
|
|
struct commit **from_last = from + nr_from;
|
|
timestamp_t min_generation = GENERATION_NUMBER_INFINITY;
|
|
int num_to_find = 0;
|
|
|
|
struct prio_queue queue = { compare_commits_by_gen_then_commit_date };
|
|
|
|
for (item = to; item < to_last; item++) {
|
|
timestamp_t generation;
|
|
struct commit *c = *item;
|
|
|
|
parse_commit(c);
|
|
generation = commit_graph_generation(c);
|
|
if (generation < min_generation)
|
|
min_generation = generation;
|
|
|
|
if (!(c->object.flags & PARENT1)) {
|
|
c->object.flags |= PARENT1;
|
|
num_to_find++;
|
|
}
|
|
}
|
|
|
|
for (item = from; item < from_last; item++) {
|
|
struct commit *c = *item;
|
|
if (!(c->object.flags & PARENT2)) {
|
|
c->object.flags |= PARENT2;
|
|
parse_commit(c);
|
|
|
|
prio_queue_put(&queue, *item);
|
|
}
|
|
}
|
|
|
|
while (num_to_find && (current = prio_queue_get(&queue)) != NULL) {
|
|
struct commit_list *parents;
|
|
|
|
if (current->object.flags & PARENT1) {
|
|
current->object.flags &= ~PARENT1;
|
|
current->object.flags |= reachable_flag;
|
|
commit_list_insert(current, &found_commits);
|
|
num_to_find--;
|
|
}
|
|
|
|
for (parents = current->parents; parents; parents = parents->next) {
|
|
struct commit *p = parents->item;
|
|
|
|
parse_commit(p);
|
|
|
|
if (commit_graph_generation(p) < min_generation)
|
|
continue;
|
|
|
|
if (p->object.flags & PARENT2)
|
|
continue;
|
|
|
|
p->object.flags |= PARENT2;
|
|
prio_queue_put(&queue, p);
|
|
}
|
|
}
|
|
|
|
clear_commit_marks_many(nr_to, to, PARENT1);
|
|
clear_commit_marks_many(nr_from, from, PARENT2);
|
|
|
|
return found_commits;
|
|
}
|