mru: use double-linked list from list.h

Simplify mru.[ch] and related code by reusing the double-linked list
implementation from list.h instead of a custom one.
This commit is an intermediate step. Our final goal is to get rid of
mru.[ch] at all and inline all logic.

Mentored-by: Christian Couder <christian.couder@gmail.com>
Mentored by: Jeff King <peff@peff.net>
Signed-off-by: Olga Telezhnaia <olyatelezhnaya@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index f721137eaf88143aa2ae3f8c67b97fbceccbb6cf..ba812349e0aab35c2a009fe3c7da407ec8b7f48c 100644 (file)
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -995,8 +995,8 @@ static int want_object_in_pack(const unsigned char *sha1,
                               struct packed_git **found_pack,
                               off_t *found_offset)
 {
                               struct packed_git **found_pack,
                               off_t *found_offset)
 {

-       struct mru_entry *entry;

        int want;
        int want;

+       struct list_head *pos;

 
        if (!exclude && local && has_loose_object_nonlocal(sha1))
                return 0;
 
        if (!exclude && local && has_loose_object_nonlocal(sha1))
                return 0;


@@ -1012,7 +1012,8 @@ static int want_object_in_pack(const unsigned char *sha1,
                        return want;
        }
 
                        return want;
        }
 

-       for (entry = packed_git_mru.head; entry; entry = entry->next) {
+       list_for_each(pos, &packed_git_mru.list) {
+               struct mru *entry = list_entry(pos, struct mru, list);

                struct packed_git *p = entry->item;
                off_t offset;
 
                struct packed_git *p = entry->item;
                off_t offset;
 

diff --git a/mru.c b/mru.c
index 9dedae0287ed2988437a56b307d7262a4953d9eb..8f3f34c5ba91dae7dea4b9fb2a72dc63581f4e78 100644 (file)
--- a/mru.c
+++ b/mru.c
@@ -1,50 +1,27 @@
 #include "cache.h"
 #include "mru.h"
 
 #include "cache.h"
 #include "mru.h"
 

-void mru_append(struct mru *mru, void *item)
+void mru_append(struct mru *head, void *item)

 {
 {

-       struct mru_entry *cur = xmalloc(sizeof(*cur));
+       struct mru *cur = xmalloc(sizeof(*cur));

        cur->item = item;
        cur->item = item;

-       cur->prev = mru->tail;
-       cur->next = NULL;
-
-       if (mru->tail)
-               mru->tail->next = cur;
-       else
-               mru->head = cur;
-       mru->tail = cur;
+       list_add_tail(&cur->list, &head->list);

 }
 
 }
 

-void mru_mark(struct mru *mru, struct mru_entry *entry)
+void mru_mark(struct mru *head, struct mru *entry)

 {
 {

-       /* If we're already at the front of the list, nothing to do */
-       if (mru->head == entry)
-               return;
-
-       /* Otherwise, remove us from our current slot... */
-       if (entry->prev)
-               entry->prev->next = entry->next;
-       if (entry->next)
-               entry->next->prev = entry->prev;
-       else
-               mru->tail = entry->prev;
-
-       /* And insert us at the beginning. */
-       entry->prev = NULL;
-       entry->next = mru->head;
-       if (mru->head)
-               mru->head->prev = entry;
-       mru->head = entry;
+       /* To mark means to put at the front of the list. */
+       list_del(&entry->list);
+       list_add(&entry->list, &head->list);

 }
 
 }
 

-void mru_clear(struct mru *mru)
+void mru_clear(struct mru *head)

 {
 {

-       struct mru_entry *p = mru->head;
+       struct list_head *pos;
+       struct list_head *tmp;

 
 

-       while (p) {
-               struct mru_entry *to_free = p;
-               p = p->next;
-               free(to_free);
+       list_for_each_safe(pos, tmp, &head->list) {
+               free(list_entry(pos, struct mru, list));

        }
        }

-       mru->head = mru->tail = NULL;
+       INIT_LIST_HEAD(&head->list);

 }
 }

diff --git a/mru.h b/mru.h
index 42e4aeaa1098af8e1460e33933106e32e74affea..80a589eb4c0ebef4d65351418673379fbd6fcc7c 100644 (file)
--- a/mru.h
+++ b/mru.h
@@ -1,6 +1,8 @@
 #ifndef MRU_H
 #define MRU_H
 
 #ifndef MRU_H
 #define MRU_H
 

+#include "list.h"
+

 /**
  * A simple most-recently-used cache, backed by a doubly-linked list.
  *
 /**
  * A simple most-recently-used cache, backed by a doubly-linked list.
  *


@@ -8,18 +10,15 @@
  *
  *   // Create a list.  Zero-initialization is required.
  *   static struct mru cache;
  *
  *   // Create a list.  Zero-initialization is required.
  *   static struct mru cache;

- *   mru_append(&cache, item);
- *   ...
+ *   INIT_LIST_HEAD(&cache.list);

  *
  *

- *   // Iterate in MRU order.
- *   struct mru_entry *p;
- *   for (p = cache.head; p; p = p->next) {
- *     if (matches(p->item))
- *             break;
- *   }
+ *   // Add new item to the end of the list.
+ *   void *item;
+ *   ...
+ *   mru_append(&cache, item);

  *
  *   // Mark an item as used, moving it to the front of the list.
  *
  *   // Mark an item as used, moving it to the front of the list.

- *   mru_mark(&cache, p);
+ *   mru_mark(&cache, item);

  *
  *   // Reset the list to empty, cleaning up all resources.
  *   mru_clear(&cache);
  *
  *   // Reset the list to empty, cleaning up all resources.
  *   mru_clear(&cache);


@@ -29,17 +28,13 @@
  * you will begin traversing the whole list again.
  */
 
  * you will begin traversing the whole list again.
  */
 

-struct mru_entry {
-       void *item;
-       struct mru_entry *prev, *next;
-};
-

 struct mru {
 struct mru {

-       struct mru_entry *head, *tail;
+       struct list_head list;
+       void *item;

 };
 
 };
 

-void mru_append(struct mru *mru, void *item);
-void mru_mark(struct mru *mru, struct mru_entry *entry);
-void mru_clear(struct mru *mru);
+void mru_append(struct mru *head, void *item);
+void mru_mark(struct mru *head, struct mru *entry);
+void mru_clear(struct mru *head);

 
 #endif /* MRU_H */
 
 #endif /* MRU_H */

diff --git a/packfile.c b/packfile.c
index f69a5c8d607af191fa8ba04e84da8f02c40823ef..502d915991beeb452296dc0c7789806856ed5a7c 100644 (file)
--- a/packfile.c
+++ b/packfile.c
@@ -40,7 +40,7 @@ static unsigned int pack_max_fds;
 static size_t peak_pack_mapped;
 static size_t pack_mapped;
 struct packed_git *packed_git;
 static size_t peak_pack_mapped;
 static size_t pack_mapped;
 struct packed_git *packed_git;

-struct mru packed_git_mru;
+struct mru packed_git_mru = {{&packed_git_mru.list, &packed_git_mru.list}};

 
 #define SZ_FMT PRIuMAX
 static inline uintmax_t sz_fmt(size_t s) { return s; }
 
 #define SZ_FMT PRIuMAX
 static inline uintmax_t sz_fmt(size_t s) { return s; }


@@ -1824,13 +1824,14 @@ static int fill_pack_entry(const unsigned char *sha1,
  */
 int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
 {
  */
 int find_pack_entry(const unsigned char *sha1, struct pack_entry *e)
 {

-       struct mru_entry *p;
+       struct list_head *pos;

 
        prepare_packed_git();
        if (!packed_git)
                return 0;
 
 
        prepare_packed_git();
        if (!packed_git)
                return 0;
 

-       for (p = packed_git_mru.head; p; p = p->next) {
+       list_for_each(pos, &packed_git_mru.list) {
+               struct mru *p = list_entry(pos, struct mru, list);

                if (fill_pack_entry(sha1, e, p->item)) {
                        mru_mark(&packed_git_mru, p);
                        return 1;
                if (fill_pack_entry(sha1, e, p->item)) {
                        mru_mark(&packed_git_mru, p);
                        return 1;