[PATCH v2 00/18] Read loose references lazily

* [PATCH v2 00/18] Read loose references lazily
@ 2012-04-26 22:26 mhagger
  2012-04-26 22:26 ` [PATCH v2 01/18] get_ref_dir(): return early if directory cannot be read mhagger
                   ` (17 more replies)
  0 siblings, 18 replies; 26+ messages in thread
From: mhagger @ 2012-04-26 22:26 UTC (permalink / raw)
  To: Junio C Hamano
  Cc: git, Jeff King, Jakub Narebski, Heiko Voigt, Johan Herland,
	Christian Couder, Michael Haggerty

From: Michael Haggerty <mhagger@alum.mit.edu>

This is the next installment of the ref-api saga.  The main result of
this patch series is to teach git to read loose references one
directory at a time, only when they are needed.

This version of the patch series differs from v1 by avoiding the
conversion of code from using (struct ref_dir *) to (struct ref_entry
*).  As Junio rightly pointed out, the use of ref_entry as the data
type for dealing with directory entries was awkward and error-prone.

This version also changes how bits in ref_entry::flag are assigned,
also at Junio's suggestion.

The first nine patches are unchanged from v1 except for a trivial
change to a commit message.  These patches convert get_ref_dir() and
do_for_each_reflog() to use strbufs and to tighten up their
specifications.

Patch 10 fixes a git_path() related bug in bisect.c.  A filename
obtained from git_path() was being used long after it was created.
With the changes later in this patch series, the
lazy-loose-reference-reading code will be activated while
check_good_are_ancestors_of_bad() is still holding on to the filename.
Therefore, this fix is a prerequisite to the later patches.

[I am nervous that there might be analogous bugs elsewhere in the
code.  Since the lazy-loose-reference-reading code can now spring to
life in many situations where references are used, it might flush out
problems in sloppy code elsewhere.  But what can we do, short of
getting rid of get_pathname() once and for all?]

Patch 11 Converts find_containing_dir() to use a strbuf.  It makes the
code a bit more straightforward but is otherwise not very interesting.

The rest of the patches teach the code to read loose references
lazily.  This is done by setting a REF_INCOMPLETE bit in
ref_entry::flag for loose directory entries that haven't been read
yet.  The entries are read when they are accessed, namely when
get_ref_dir() is called to extract a ref_dir from a directory
ref_entry.

This patch series depends on mh/ref-api, which just recently made it
to master.  It passes all tests.

Michael Haggerty (18):
  get_ref_dir(): return early if directory cannot be read
  get_ref_dir(): use a strbuf to hold refname
  get_ref_dir(): rename "base" parameter to "dirname"
  get_ref_dir(): require that the dirname argument ends in '/'
  refs.c: extract function search_for_subdir()
  get_ref_dir(): take the containing directory as argument
  do_for_each_reflog(): return early on error
  do_for_each_reflog(): use a strbuf to hold logfile name
  do_for_each_reflog(): reuse strbuf across recursive function calls
  bisect: copy filename string obtained from git_path()
  find_containing_dir(): use strbuf in implementation of this function
  refs: wrap top-level ref_dirs in ref_entries
  read_loose_refs(): rename function from get_ref_dir()
  get_ref_dir(): add function for getting a ref_dir from a ref_entry
  search_for_subdir(): return (ref_dir *) instead of (ref_entry *)
  struct ref_dir: store a reference to the enclosing ref_cache
  read_loose_refs(): eliminate ref_cache argument
  refs: read loose references lazily

 bisect.c |    8 +-
 refs.c   |  378 ++++++++++++++++++++++++++++++++++++++++----------------------
 2 files changed, 247 insertions(+), 139 deletions(-)

-- 
1.7.10

^ permalink raw reply	[flat|nested] 26+ messages in thread