diff options
Diffstat (limited to 'epoch.c')
| -rw-r--r-- | epoch.c | 639 |
1 files changed, 639 insertions, 0 deletions
@@ -0,0 +1,639 @@ +/* + * 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 <stdlib.h> + +/* Provides arbitrary precision integers required to accurately represent + * fractional mass: */ +#include <openssl/bn.h> + +#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; +} |