blob: db44f5ca9f73a75cc266d9b45eda0aca56dd1ede [file] [log] [blame]
 /* * Copyright (c) 2005, Jon Seymour * * For more information about epoch theory on which this module is based, * refer to http://blackcubes.dyndns.org/epoch/. That web page defines * terms such as "epoch" and "minimal, non-linear epoch" and provides rationales * for some of the algorithms used here. * */ #include /* Provides arbitrary precision integers required to accurately represent * fractional mass: */ #include #include "cache.h" #include "commit.h" #include "epoch.h" struct fraction { BIGNUM numerator; BIGNUM denominator; }; #define HAS_EXACTLY_ONE_PARENT(n) ((n)->parents && !(n)->parents->next) static BN_CTX *context = NULL; static struct fraction *one = NULL; static struct fraction *zero = NULL; static BN_CTX *get_BN_CTX(void) { if (!context) { context = BN_CTX_new(); } return context; } static struct fraction *new_zero(void) { struct fraction *result = xmalloc(sizeof(*result)); BN_init(&result->numerator); BN_init(&result->denominator); BN_zero(&result->numerator); BN_one(&result->denominator); return result; } static void clear_fraction(struct fraction *fraction) { BN_clear(&fraction->numerator); BN_clear(&fraction->denominator); } static struct fraction *divide(struct fraction *result, struct fraction *fraction, int divisor) { BIGNUM bn_divisor; BN_init(&bn_divisor); BN_set_word(&bn_divisor, divisor); BN_copy(&result->numerator, &fraction->numerator); BN_mul(&result->denominator, &fraction->denominator, &bn_divisor, get_BN_CTX()); BN_clear(&bn_divisor); return result; } static struct fraction *init_fraction(struct fraction *fraction) { BN_init(&fraction->numerator); BN_init(&fraction->denominator); BN_zero(&fraction->numerator); BN_one(&fraction->denominator); return fraction; } static struct fraction *get_one(void) { if (!one) { one = new_zero(); BN_one(&one->numerator); } return one; } static struct fraction *get_zero(void) { if (!zero) { zero = new_zero(); } return zero; } static struct fraction *copy(struct fraction *to, struct fraction *from) { BN_copy(&to->numerator, &from->numerator); BN_copy(&to->denominator, &from->denominator); return to; } static struct fraction *add(struct fraction *result, struct fraction *left, struct fraction *right) { BIGNUM a, b, gcd; BN_init(&a); BN_init(&b); BN_init(&gcd); BN_mul(&a, &left->numerator, &right->denominator, get_BN_CTX()); BN_mul(&b, &left->denominator, &right->numerator, get_BN_CTX()); BN_mul(&result->denominator, &left->denominator, &right->denominator, get_BN_CTX()); BN_add(&result->numerator, &a, &b); BN_gcd(&gcd, &result->denominator, &result->numerator, get_BN_CTX()); BN_div(&result->denominator, NULL, &result->denominator, &gcd, get_BN_CTX()); BN_div(&result->numerator, NULL, &result->numerator, &gcd, get_BN_CTX()); BN_clear(&a); BN_clear(&b); BN_clear(&gcd); return result; } static int compare(struct fraction *left, struct fraction *right) { BIGNUM a, b; int result; BN_init(&a); BN_init(&b); BN_mul(&a, &left->numerator, &right->denominator, get_BN_CTX()); BN_mul(&b, &left->denominator, &right->numerator, get_BN_CTX()); result = BN_cmp(&a, &b); BN_clear(&a); BN_clear(&b); return result; } struct mass_counter { struct fraction seen; struct fraction pending; }; static struct mass_counter *new_mass_counter(struct commit *commit, struct fraction *pending) { struct mass_counter *mass_counter = xmalloc(sizeof(*mass_counter)); memset(mass_counter, 0, sizeof(*mass_counter)); init_fraction(&mass_counter->seen); init_fraction(&mass_counter->pending); copy(&mass_counter->pending, pending); copy(&mass_counter->seen, get_zero()); if (commit->object.util) { die("multiple attempts to initialize mass counter for %s", sha1_to_hex(commit->object.sha1)); } commit->object.util = mass_counter; return mass_counter; } static void free_mass_counter(struct mass_counter *counter) { clear_fraction(&counter->seen); clear_fraction(&counter->pending); free(counter); } /* * Finds the base commit of a list of commits. * * One property of the commit being searched for is that every commit reachable * from the base commit is reachable from the commits in the starting list only * via paths that include the base commit. * * This algorithm uses a conservation of mass approach to find the base commit. * * We start by injecting one unit of mass into the graph at each * of the commits in the starting list. Injecting mass into a commit * is achieved by adding to its pending mass counter and, if it is not already * enqueued, enqueuing the commit in a list of pending commits, in latest * commit date first order. * * The algorithm then preceeds to visit each commit in the pending queue. * Upon each visit, the pending mass is added to the mass already seen for that * commit and then divided into N equal portions, where N is the number of * parents of the commit being visited. The divided portions are then injected * into each of the parents. * * The algorithm continues until we discover a commit which has seen all the * mass originally injected or until we run out of things to do. * * If we find a commit that has seen all the original mass, we have found * the common base of all the commits in the starting list. * * The algorithm does _not_ depend on accurate timestamps for correct operation. * However, reasonably sane (e.g. non-random) timestamps are required in order * to prevent an exponential performance characteristic. The occasional * timestamp inaccuracy will not dramatically affect performance but may * result in more nodes being processed than strictly necessary. * * This procedure sets *boundary to the address of the base commit. It returns * non-zero if, and only if, there was a problem parsing one of the * commits discovered during the traversal. */ static int find_base_for_list(struct commit_list *list, struct commit **boundary) { int ret = 0; struct commit_list *cleaner = NULL; struct commit_list *pending = NULL; struct fraction injected; init_fraction(&injected); *boundary = NULL; for (; list; list = list->next) { struct commit *item = list->item; if (!item->object.util) { new_mass_counter(list->item, get_one()); add(&injected, &injected, get_one()); commit_list_insert(list->item, &cleaner); commit_list_insert(list->item, &pending); } } while (!*boundary && pending && !ret) { struct commit *latest = pop_commit(&pending); struct mass_counter *latest_node = (struct mass_counter *) latest->object.util; int num_parents; if ((ret = parse_commit(latest))) continue; add(&latest_node->seen, &latest_node->seen, &latest_node->pending); num_parents = count_parents(latest); if (num_parents) { struct fraction distribution; struct commit_list *parents; divide(init_fraction(&distribution), &latest_node->pending, num_parents); for (parents = latest->parents; parents; parents = parents->next) { struct commit *parent = parents->item; struct mass_counter *parent_node = (struct mass_counter *) parent->object.util; if (!parent_node) { parent_node = new_mass_counter(parent, &distribution); insert_by_date(parent, &pending); commit_list_insert(parent, &cleaner); } else { if (!compare(&parent_node->pending, get_zero())) insert_by_date(parent, &pending); add(&parent_node->pending, &parent_node->pending, &distribution); } } clear_fraction(&distribution); } if (!compare(&latest_node->seen, &injected)) *boundary = latest; copy(&latest_node->pending, get_zero()); } while (cleaner) { struct commit *next = pop_commit(&cleaner); free_mass_counter((struct mass_counter *) next->object.util); next->object.util = NULL; } if (pending) free_commit_list(pending); clear_fraction(&injected); return ret; } /* * Finds the base of an minimal, non-linear epoch, headed at head, by * applying the find_base_for_list to a list consisting of the parents */ static int find_base(struct commit *head, struct commit **boundary) { int ret = 0; struct commit_list *pending = NULL; struct commit_list *next; for (next = head->parents; next; next = next->next) { commit_list_insert(next->item, &pending); } ret = find_base_for_list(pending, boundary); free_commit_list(pending); return ret; } /* * This procedure traverses to the boundary of the first epoch in the epoch * sequence of the epoch headed at head_of_epoch. This is either the end of * the maximal linear epoch or the base of a minimal non-linear epoch. * * The queue of pending nodes is sorted in reverse date order and each node * is currently in the queue at most once. */ static int find_next_epoch_boundary(struct commit *head_of_epoch, struct commit **boundary) { int ret; struct commit *item = head_of_epoch; ret = parse_commit(item); if (ret) return ret; if (HAS_EXACTLY_ONE_PARENT(item)) { /* * We are at the start of a maximimal linear epoch. * Traverse to the end. */ while (HAS_EXACTLY_ONE_PARENT(item) && !ret) { item = item->parents->item; ret = parse_commit(item); } *boundary = item; } else { /* * Otherwise, we are at the start of a minimal, non-linear * epoch - find the common base of all parents. */ ret = find_base(item, boundary); } return ret; } /* * Returns non-zero if parent is known to be a parent of child. */ static int is_parent_of(struct commit *parent, struct commit *child) { struct commit_list *parents; for (parents = child->parents; parents; parents = parents->next) { if (!memcmp(parent->object.sha1, parents->item->object.sha1, sizeof(parents->item->object.sha1))) return 1; } return 0; } /* * Pushes an item onto the merge order stack. If the top of the stack is * marked as being a possible "break", we check to see whether it actually * is a break. */ static void push_onto_merge_order_stack(struct commit_list **stack, struct commit *item) { struct commit_list *top = *stack; if (top && (top->item->object.flags & DISCONTINUITY)) { if (is_parent_of(top->item, item)) { top->item->object.flags &= ~DISCONTINUITY; } } commit_list_insert(item, stack); } /* * Marks all interesting, visited commits reachable from this commit * as uninteresting. We stop recursing when we reach the epoch boundary, * an unvisited node or a node that has already been marking uninteresting. * * This doesn't actually mark all ancestors between the start node and the * epoch boundary uninteresting, but does ensure that they will eventually * be marked uninteresting when the main sort_first_epoch() traversal * eventually reaches them. */ static void mark_ancestors_uninteresting(struct commit *commit) { unsigned int flags = commit->object.flags; int visited = flags & VISITED; int boundary = flags & BOUNDARY; int uninteresting = flags & UNINTERESTING; struct commit_list *next; commit->object.flags |= UNINTERESTING; /* * We only need to recurse if * we are not on the boundary and * we have not already been marked uninteresting and * we have already been visited. * * The main sort_first_epoch traverse will mark unreachable * all uninteresting, unvisited parents as they are visited * so there is no need to duplicate that traversal here. * * Similarly, if we are already marked uninteresting * then either all ancestors have already been marked * uninteresting or will be once the sort_first_epoch * traverse reaches them. */ if (uninteresting || boundary || !visited) return; for (next = commit->parents; next; next = next->next) mark_ancestors_uninteresting(next->item); } /* * Sorts the nodes of the first epoch of the epoch sequence of the epoch headed at head * into merge order. */ static void sort_first_epoch(struct commit *head, struct commit_list **stack) { struct commit_list *parents; head->object.flags |= VISITED; /* * TODO: By sorting the parents in a different order, we can alter the * merge order to show contemporaneous changes in parallel branches * occurring after "local" changes. This is useful for a developer * when a developer wants to see all changes that were incorporated * into the same merge as her own changes occur after her own * changes. */ for (parents = head->parents; parents; parents = parents->next) { struct commit *parent = parents->item; if (head->object.flags & UNINTERESTING) { /* * Propagates the uninteresting bit to all parents. * if we have already visited this parent, then * the uninteresting bit will be propagated to each * reachable commit that is still not marked * uninteresting and won't otherwise be reached. */ mark_ancestors_uninteresting(parent); } if (!(parent->object.flags & VISITED)) { if (parent->object.flags & BOUNDARY) { if (*stack) { die("something else is on the stack - %s", sha1_to_hex((*stack)->item->object.sha1)); } push_onto_merge_order_stack(stack, parent); parent->object.flags |= VISITED; } else { sort_first_epoch(parent, stack); if (parents) { /* * This indicates a possible * discontinuity it may not be be * actual discontinuity if the head * of parent N happens to be the tail * of parent N+1. * * The next push onto the stack will * resolve the question. */ (*stack)->item->object.flags |= DISCONTINUITY; } } } } push_onto_merge_order_stack(stack, head); } /* * Emit the contents of the stack. * * The stack is freed and replaced by NULL. * * Sets the return value to STOP if no further output should be generated. */ static int emit_stack(struct commit_list **stack, emitter_func emitter, int include_last) { unsigned int seen = 0; int action = CONTINUE; while (*stack && (action != STOP)) { struct commit *next = pop_commit(stack); seen |= next->object.flags; if (*stack || include_last) { if (!*stack) next->object.flags |= BOUNDARY; action = emitter(next); } } if (*stack) { free_commit_list(*stack); *stack = NULL; } return (action == STOP || (seen & UNINTERESTING)) ? STOP : CONTINUE; } /* * Sorts an arbitrary epoch into merge order by sorting each epoch * of its epoch sequence into order. * * Note: this algorithm currently leaves traces of its execution in the * object flags of nodes it discovers. This should probably be fixed. */ static int sort_in_merge_order(struct commit *head_of_epoch, emitter_func emitter) { struct commit *next = head_of_epoch; int ret = 0; int action = CONTINUE; ret = parse_commit(head_of_epoch); next->object.flags |= BOUNDARY; while (next && next->parents && !ret && (action != STOP)) { struct commit *base = NULL; ret = find_next_epoch_boundary(next, &base); if (ret) return ret; next->object.flags |= BOUNDARY; if (base) base->object.flags |= BOUNDARY; if (HAS_EXACTLY_ONE_PARENT(next)) { while (HAS_EXACTLY_ONE_PARENT(next) && (action != STOP) && !ret) { if (next->object.flags & UNINTERESTING) { action = STOP; } else { action = emitter(next); } if (action != STOP) { next = next->parents->item; ret = parse_commit(next); } } } else { struct commit_list *stack = NULL; sort_first_epoch(next, &stack); action = emit_stack(&stack, emitter, (base == NULL)); next = base; } } if (next && (action != STOP) && !ret) { emitter(next); } return ret; } /* * Sorts the nodes reachable from a starting list in merge order, we * first find the base for the starting list and then sort all nodes * in this subgraph using the sort_first_epoch algorithm. Once we have * reached the base we can continue sorting using sort_in_merge_order. */ int sort_list_in_merge_order(struct commit_list *list, emitter_func emitter) { struct commit_list *stack = NULL; struct commit *base; int ret = 0; int action = CONTINUE; struct commit_list *reversed = NULL; for (; list; list = list->next) commit_list_insert(list->item, &reversed); if (!reversed) return ret; else if (!reversed->next) { /* * If there is only one element in the list, we can sort it * using sort_in_merge_order. */ base = reversed->item; } else { /* * Otherwise, we search for the base of the list. */ ret = find_base_for_list(reversed, &base); if (ret) return ret; if (base) base->object.flags |= BOUNDARY; while (reversed) { struct commit * next = pop_commit(&reversed); if (!(next->object.flags & VISITED) && next!=base) { sort_first_epoch(next, &stack); if (reversed) { /* * If we have more commits * to push, then the first * push for the next parent may * (or may * not) represent a * discontinuity with respect * to the parent currently on * the top of the stack. * * Mark it for checking here, * and check it with the next * push. See sort_first_epoch() * for more details. */ stack->item->object.flags |= DISCONTINUITY; } } } action = emit_stack(&stack, emitter, (base==NULL)); } if (base && (action != STOP)) { ret = sort_in_merge_order(base, emitter); } return ret; }