undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fetch: replace string-list used as a look-up table with a hashmap

Browse Source 
In find_non_local_tags() helper function (used to implement the
"follow tags"), we use string_list_has_string() on two string lists
as a way to see if a refname has already been processed, etc.

All this code predates more modern in-core lookup API like hashmap;
replace them with two hashmaps and one string list---the hashmaps
are used for look-ups and the string list is to keep the order of
items in the returned result stable (which is the only single thing
hashmap does worse than lookups on string-list).

Similarly, get_ref_map() uses another string-list as a look-up table
for existing refs.  Replace it with a hashmap.

Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Junio C Hamano 2018-09-25 13:25:04 -07:00
parent fe8321ec05
commit e198b3a740
1 changed files with 100 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
builtin/fetch.c
View File

@ -223,18 +223,6 @@ static void add_merge_config(struct ref **head,
} }
} }
static int add_existing(const char *refname, const struct object_id *oid,
int flag, void *cbdata)
{
struct string_list *list = (struct string_list *)cbdata;
struct string_list_item *item = string_list_insert(list, refname);
struct object_id *old_oid = xmalloc(sizeof(*old_oid));
oidcpy(old_oid, oid);
item->util = old_oid;
return 0;
}
static int will_fetch(struct ref **head, const unsigned char *sha1) static int will_fetch(struct ref **head, const unsigned char *sha1)
{ {
struct ref *rm = *head; struct ref *rm = *head;
@ -246,16 +234,72 @@ static int will_fetch(struct ref **head, const unsigned char *sha1)
return 0; return 0;
} }
struct refname_hash_entry {
struct hashmap_entry ent; /* must be the first member */
struct object_id oid;
char refname[FLEX_ARRAY];
};
static int refname_hash_entry_cmp(const void *hashmap_cmp_fn_data,
const void *e1_,
const void *e2_,
const void *keydata)
{
const struct refname_hash_entry *e1 = e1_;
const struct refname_hash_entry *e2 = e2_;
return strcmp(e1->refname, keydata ? keydata : e2->refname);
}
static struct refname_hash_entry *refname_hash_add(struct hashmap *map,
const char *refname,
const struct object_id *oid)
{
struct refname_hash_entry *ent;
size_t len = strlen(refname);
FLEX_ALLOC_MEM(ent, refname, refname, len);
hashmap_entry_init(ent, strhash(refname));
oidcpy(&ent->oid, oid);
hashmap_add(map, ent);
return ent;
}
static int add_one_refname(const char *refname,
const struct object_id *oid,
int flag, void *cbdata)
{
struct hashmap *refname_map = cbdata;
(void) refname_hash_add(refname_map, refname, oid);
return 0;
}
static void refname_hash_init(struct hashmap *map)
{
hashmap_init(map, refname_hash_entry_cmp, NULL, 0);
}
static int refname_hash_exists(struct hashmap *map, const char *refname)
{
return !!hashmap_get_from_hash(map, strhash(refname), refname);
}
static void find_non_local_tags(const struct ref *refs, static void find_non_local_tags(const struct ref *refs,
struct ref **head, struct ref **head,
struct ref ***tail) struct ref ***tail)
{ {
struct string_list existing_refs = STRING_LIST_INIT_DUP; struct hashmap existing_refs;
struct string_list remote_refs = STRING_LIST_INIT_NODUP; struct hashmap remote_refs;
struct string_list remote_refs_list = STRING_LIST_INIT_NODUP;
struct string_list_item *remote_ref_item;
const struct ref *ref; const struct ref *ref;
struct string_list_item *item = NULL; struct refname_hash_entry *item = NULL;
for_each_ref(add_existing, &existing_refs); refname_hash_init(&existing_refs);
refname_hash_init(&remote_refs);
for_each_ref(add_one_refname, &existing_refs);
for (ref = refs; ref; ref = ref->next) { for (ref = refs; ref; ref = ref->next) {
if (!starts_with(ref->name, "refs/tags/")) if (!starts_with(ref->name, "refs/tags/"))
continue; continue;
@ -271,10 +315,10 @@ static void find_non_local_tags(const struct ref *refs,
!has_object_file_with_flags(&ref->old_oid, !has_object_file_with_flags(&ref->old_oid,
OBJECT_INFO_QUICK) && OBJECT_INFO_QUICK) &&
!will_fetch(head, ref->old_oid.hash) && !will_fetch(head, ref->old_oid.hash) &&
!has_sha1_file_with_flags(item->util, !has_sha1_file_with_flags(item->oid.hash,
OBJECT_INFO_QUICK) && OBJECT_INFO_QUICK) &&
!will_fetch(head, item->util)) !will_fetch(head, item->oid.hash))
item->util = NULL; oidclr(&item->oid);
item = NULL; item = NULL;
continue; continue;
} }
@ -286,48 +330,53 @@ static void find_non_local_tags(const struct ref *refs,
* fetch. * fetch.
*/ */
if (item && if (item &&
!has_sha1_file_with_flags(item->util, OBJECT_INFO_QUICK) && !has_sha1_file_with_flags(item->oid.hash, OBJECT_INFO_QUICK) &&
!will_fetch(head, item->util)) !will_fetch(head, item->oid.hash))
item->util = NULL; oidclr(&item->oid);
item = NULL; item = NULL;
/* skip duplicates and refs that we already have */ /* skip duplicates and refs that we already have */
if (string_list_has_string(&remote_refs, ref->name) || if (refname_hash_exists(&remote_refs, ref->name) ||
string_list_has_string(&existing_refs, ref->name)) refname_hash_exists(&existing_refs, ref->name))
continue; continue;
item = string_list_insert(&remote_refs, ref->name); item = refname_hash_add(&remote_refs, ref->name, &ref->old_oid);
item->util = (void *)&ref->old_oid; string_list_insert(&remote_refs_list, ref->name);
} }
string_list_clear(&existing_refs, 1); hashmap_free(&existing_refs, 1);
/* /*
* We may have a final lightweight tag that needs to be * We may have a final lightweight tag that needs to be
* checked to see if it needs fetching. * checked to see if it needs fetching.
*/ */
if (item && if (item &&
!has_sha1_file_with_flags(item->util, OBJECT_INFO_QUICK) && !has_sha1_file_with_flags(item->oid.hash, OBJECT_INFO_QUICK) &&
!will_fetch(head, item->util)) !will_fetch(head, item->oid.hash))
item->util = NULL; oidclr(&item->oid);
/* /*
* For all the tags in the remote_refs string list, * For all the tags in the remote_refs_list,
* add them to the list of refs to be fetched * add them to the list of refs to be fetched
*/ */
for_each_string_list_item(item, &remote_refs) { for_each_string_list_item(remote_ref_item, &remote_refs_list) {
const char *refname = remote_ref_item->string;
item = hashmap_get_from_hash(&remote_refs, strhash(refname), refname);
if (!item)
BUG("unseen remote ref?");
/* Unless we have already decided to ignore this item... */ /* Unless we have already decided to ignore this item... */
if (item->util) if (!is_null_oid(&item->oid)) {
{ struct ref *rm = alloc_ref(item->refname);
struct ref *rm = alloc_ref(item->string); rm->peer_ref = alloc_ref(item->refname);
rm->peer_ref = alloc_ref(item->string); oidcpy(&rm->old_oid, &item->oid);
oidcpy(&rm->old_oid, item->util);
**tail = rm; **tail = rm;
*tail = &rm->next; *tail = &rm->next;
} }
} }
hashmap_free(&remote_refs, 1);
string_list_clear(&remote_refs, 0); string_list_clear(&remote_refs_list, 0);
} }
static struct ref *get_ref_map(struct remote *remote, static struct ref *get_ref_map(struct remote *remote,
@ -343,7 +392,7 @@ static struct ref *get_ref_map(struct remote *remote,
/* opportunistically-updated references: */ /* opportunistically-updated references: */
struct ref *orefs = NULL, **oref_tail = &orefs; struct ref *orefs = NULL, **oref_tail = &orefs;
struct string_list existing_refs = STRING_LIST_INIT_DUP; struct hashmap existing_refs;
if (rs->nr) { if (rs->nr) {
struct refspec *fetch_refspec; struct refspec *fetch_refspec;
@ -437,19 +486,24 @@ static struct ref *get_ref_map(struct remote *remote,
ref_map = ref_remove_duplicates(ref_map); ref_map = ref_remove_duplicates(ref_map);
for_each_ref(add_existing, &existing_refs); refname_hash_init(&existing_refs);
for_each_ref(add_one_refname, &existing_refs);
for (rm = ref_map; rm; rm = rm->next) { for (rm = ref_map; rm; rm = rm->next) {
if (rm->peer_ref) { if (rm->peer_ref) {
struct string_list_item *peer_item = const char *refname = rm->peer_ref->name;
string_list_lookup(&existing_refs, struct refname_hash_entry *peer_item;
rm->peer_ref->name);
peer_item = hashmap_get_from_hash(&existing_refs,
strhash(refname),
refname);
if (peer_item) { if (peer_item) {
struct object_id *old_oid = peer_item->util; struct object_id *old_oid = &peer_item->oid;
oidcpy(&rm->peer_ref->old_oid, old_oid); oidcpy(&rm->peer_ref->old_oid, old_oid);
} }
} }
} }
string_list_clear(&existing_refs, 1); hashmap_free(&existing_refs, 1);
return ref_map; return ref_map;
} }