mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
This shrinks "struct object" by a small amount, by getting rid of the "struct type *" pointer and replacing it with a 3-bit bitfield instead. In addition, we merge the bitfields and the "flags" field, which incidentally should also remove a useless 4-byte padding from the object when in 64-bit mode. Now, our "struct object" is still too damn large, but it's now less obviously bloated, and of the remaining fields, only the "util" (which is not used by most things) is clearly something that should be eventually discarded. This shrinks the "git-rev-list --all" memory use by about 2.5% on the kernel archive (and, perhaps more importantly, on the larger mozilla archive). That may not sound like much, but I suspect it's more on a 64-bit platform. There are other remaining inefficiencies (the parent lists, for example, probably have horrible malloc overhead), but this was pretty obvious. Most of the patch is just changing the comparison of the "type" pointer from one of the constant string pointers to the appropriate new TYPE_xxx small integer constant. Signed-off-by: Linus Torvalds <torvalds@osdl.org> Signed-off-by: Junio C Hamano <junkio@cox.net>
267 lines
5.2 KiB
C
267 lines
5.2 KiB
C
#include "fetch.h"
|
|
|
|
#include "cache.h"
|
|
#include "commit.h"
|
|
#include "tree.h"
|
|
#include "tree-walk.h"
|
|
#include "tag.h"
|
|
#include "blob.h"
|
|
#include "refs.h"
|
|
|
|
const char *write_ref = NULL;
|
|
const char *write_ref_log_details = NULL;
|
|
|
|
int get_tree = 0;
|
|
int get_history = 0;
|
|
int get_all = 0;
|
|
int get_verbosely = 0;
|
|
int get_recover = 0;
|
|
static unsigned char current_commit_sha1[20];
|
|
|
|
void pull_say(const char *fmt, const char *hex)
|
|
{
|
|
if (get_verbosely)
|
|
fprintf(stderr, fmt, hex);
|
|
}
|
|
|
|
static void report_missing(const char *what, const unsigned char *missing)
|
|
{
|
|
char missing_hex[41];
|
|
|
|
strcpy(missing_hex, sha1_to_hex(missing));;
|
|
fprintf(stderr,
|
|
"Cannot obtain needed %s %s\nwhile processing commit %s.\n",
|
|
what, missing_hex, sha1_to_hex(current_commit_sha1));
|
|
}
|
|
|
|
static int process(struct object *obj);
|
|
|
|
static int process_tree(struct tree *tree)
|
|
{
|
|
struct tree_desc desc;
|
|
struct name_entry entry;
|
|
|
|
if (parse_tree(tree))
|
|
return -1;
|
|
|
|
desc.buf = tree->buffer;
|
|
desc.size = tree->size;
|
|
while (tree_entry(&desc, &entry)) {
|
|
struct object *obj = NULL;
|
|
|
|
if (S_ISDIR(entry.mode)) {
|
|
struct tree *tree = lookup_tree(entry.sha1);
|
|
if (tree)
|
|
obj = &tree->object;
|
|
}
|
|
else {
|
|
struct blob *blob = lookup_blob(entry.sha1);
|
|
if (blob)
|
|
obj = &blob->object;
|
|
}
|
|
if (!obj || process(obj))
|
|
return -1;
|
|
}
|
|
free(tree->buffer);
|
|
tree->buffer = NULL;
|
|
tree->size = 0;
|
|
return 0;
|
|
}
|
|
|
|
#define COMPLETE (1U << 0)
|
|
#define SEEN (1U << 1)
|
|
#define TO_SCAN (1U << 2)
|
|
|
|
static struct commit_list *complete = NULL;
|
|
|
|
static int process_commit(struct commit *commit)
|
|
{
|
|
if (parse_commit(commit))
|
|
return -1;
|
|
|
|
while (complete && complete->item->date >= commit->date) {
|
|
pop_most_recent_commit(&complete, COMPLETE);
|
|
}
|
|
|
|
if (commit->object.flags & COMPLETE)
|
|
return 0;
|
|
|
|
memcpy(current_commit_sha1, commit->object.sha1, 20);
|
|
|
|
pull_say("walk %s\n", sha1_to_hex(commit->object.sha1));
|
|
|
|
if (get_tree) {
|
|
if (process(&commit->tree->object))
|
|
return -1;
|
|
if (!get_all)
|
|
get_tree = 0;
|
|
}
|
|
if (get_history) {
|
|
struct commit_list *parents = commit->parents;
|
|
for (; parents; parents = parents->next) {
|
|
if (process(&parents->item->object))
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int process_tag(struct tag *tag)
|
|
{
|
|
if (parse_tag(tag))
|
|
return -1;
|
|
return process(tag->tagged);
|
|
}
|
|
|
|
static struct object_list *process_queue = NULL;
|
|
static struct object_list **process_queue_end = &process_queue;
|
|
|
|
static int process_object(struct object *obj)
|
|
{
|
|
if (obj->type == TYPE_COMMIT) {
|
|
if (process_commit((struct commit *)obj))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
if (obj->type == TYPE_TREE) {
|
|
if (process_tree((struct tree *)obj))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
if (obj->type == TYPE_BLOB) {
|
|
return 0;
|
|
}
|
|
if (obj->type == TYPE_TAG) {
|
|
if (process_tag((struct tag *)obj))
|
|
return -1;
|
|
return 0;
|
|
}
|
|
return error("Unable to determine requirements "
|
|
"of type %s for %s",
|
|
typename(obj->type), sha1_to_hex(obj->sha1));
|
|
}
|
|
|
|
static int process(struct object *obj)
|
|
{
|
|
if (obj->flags & SEEN)
|
|
return 0;
|
|
obj->flags |= SEEN;
|
|
|
|
if (has_sha1_file(obj->sha1)) {
|
|
/* We already have it, so we should scan it now. */
|
|
obj->flags |= TO_SCAN;
|
|
}
|
|
else {
|
|
if (obj->flags & COMPLETE)
|
|
return 0;
|
|
prefetch(obj->sha1);
|
|
}
|
|
|
|
object_list_insert(obj, process_queue_end);
|
|
process_queue_end = &(*process_queue_end)->next;
|
|
return 0;
|
|
}
|
|
|
|
static int loop(void)
|
|
{
|
|
struct object_list *elem;
|
|
|
|
while (process_queue) {
|
|
struct object *obj = process_queue->item;
|
|
elem = process_queue;
|
|
process_queue = elem->next;
|
|
free(elem);
|
|
if (!process_queue)
|
|
process_queue_end = &process_queue;
|
|
|
|
/* If we are not scanning this object, we placed it in
|
|
* the queue because we needed to fetch it first.
|
|
*/
|
|
if (! (obj->flags & TO_SCAN)) {
|
|
if (fetch(obj->sha1)) {
|
|
report_missing(typename(obj->type), obj->sha1);
|
|
return -1;
|
|
}
|
|
}
|
|
if (!obj->type)
|
|
parse_object(obj->sha1);
|
|
if (process_object(obj))
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int interpret_target(char *target, unsigned char *sha1)
|
|
{
|
|
if (!get_sha1_hex(target, sha1))
|
|
return 0;
|
|
if (!check_ref_format(target)) {
|
|
if (!fetch_ref(target, sha1)) {
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int mark_complete(const char *path, const unsigned char *sha1)
|
|
{
|
|
struct commit *commit = lookup_commit_reference_gently(sha1, 1);
|
|
if (commit) {
|
|
commit->object.flags |= COMPLETE;
|
|
insert_by_date(commit, &complete);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int pull(char *target)
|
|
{
|
|
struct ref_lock *lock = NULL;
|
|
unsigned char sha1[20];
|
|
char *msg;
|
|
int ret;
|
|
|
|
save_commit_buffer = 0;
|
|
track_object_refs = 0;
|
|
if (write_ref) {
|
|
lock = lock_ref_sha1(write_ref, NULL, 0);
|
|
if (!lock) {
|
|
error("Can't lock ref %s", write_ref);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (!get_recover)
|
|
for_each_ref(mark_complete);
|
|
|
|
if (interpret_target(target, sha1)) {
|
|
error("Could not interpret %s as something to pull", target);
|
|
if (lock)
|
|
unlock_ref(lock);
|
|
return -1;
|
|
}
|
|
if (process(lookup_unknown_object(sha1))) {
|
|
if (lock)
|
|
unlock_ref(lock);
|
|
return -1;
|
|
}
|
|
if (loop()) {
|
|
if (lock)
|
|
unlock_ref(lock);
|
|
return -1;
|
|
}
|
|
|
|
if (write_ref) {
|
|
if (write_ref_log_details) {
|
|
msg = xmalloc(strlen(write_ref_log_details) + 12);
|
|
sprintf(msg, "fetch from %s", write_ref_log_details);
|
|
}
|
|
else
|
|
msg = NULL;
|
|
ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
|
|
if (msg)
|
|
free(msg);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|