2007-12-31 Neal H. Walfield <neal@gnu.org>

	* list.h: New file.
	* Makefile.am (viengoos_SOURCES): Add list.h.
	(t_link_SOURCES): Remove object.h.  Add list.h.
	* object.h: Include "list.h".
	(LINK_TEMPLATE): Move from here...
	* list.h: ... to this new file.  Generalize functionality.  Add
	count, head, prev, next and prev methods.  Rename LINK_TEMPLATE to
	LIST_CLASS.  Update users.
	* object.h (struct object_desc): Change activity_lru and
	global_lru to struct list_node's.
	(global_active): Change to a struct object_global_lru_list.
	(global_inactive_dirty): Likewise.
	(global_inactive_clean): Likewise.
	(disowned): Change to a struct object_activity_lru_list.
	* object.c (global_active): Change to a struct
	object_global_lru_list.
	(global_inactive_dirty): Likewise.
	(global_inactive_clean): Likewise.
	(disowned): Change to a struct object_activity_lru_list.
	* activity.h (struct activity): Change active, inactive_clean and
	inactive_dirty to struct object_activity_lru_list's.

1 files changed, 82 insertions, 61 deletions

diff --git a/viengoos/t-link.c b/viengoos/t-link.c
index 5143e1d..fe1578b 100644
--- a/viengoos/t-link.c
+++ b/viengoos/t-link.c
@@ -2,10 +2,17 @@
 #include "t-environment.h"
 
 #include <hurd/stddef.h>
-#include "object.h"
+#include "list.h"
 #include "output.h"
 
-ss_mutex_t lru_lock;
+struct object_desc
+{
+  int age;
+  struct list_node activity_lru;
+};
+
+LIST_CLASS(object_activity_lru, struct object_desc, activity_lru)
+
 int output_debug = 0;
 
 #define N 10
@@ -14,52 +21,43 @@ test (void)
 {
   struct object_desc descs[N];
 
-  struct object_desc *head = NULL;
+  struct object_activity_lru_list list;
+  object_activity_lru_list_init (&list);
+
   struct object_desc *p;
   int i;
 
-  ss_mutex_lock (&lru_lock);
-
   /* Add items with value 0 to N-1.  (Recall: items are added to the
      head of the list!)  */
   for (i = 0; i < N; i ++)
     {
+      assert (object_activity_lru_list_count (&list) == i);
+
       descs[i].age = i;
       descs[i].activity_lru.next = descs[i].activity_lru.prev = NULL;
-      object_activity_lru_push (&head, &descs[i]);
+      object_activity_lru_list_push (&list, &descs[i]);
 
       int j = i;
-      p = head;
-      if (p)
-	do
-	  {
-	    assert (p->age == j --);
-
-	    p = p->activity_lru.next;
-	  }
-	while (p != head);
+      for (p = object_activity_lru_list_head (&list);
+	   p; p = object_activity_lru_list_next (p))
+	assert (p->age == j --);
       assert (j == -1);
     }
+  assert (object_activity_lru_list_count (&list) == i);
 
   /* Unlink nodes 0, 2, 4, 6, 8.  (Leaving the list: 9 -> 7 -> 5 -> 3
      -> 1.)  */
   for (i = 0; i < N; i += 2)
     {
-      object_activity_lru_unlink (&head, &descs[i]);
+      object_activity_lru_list_unlink (&list, &descs[i]);
 
       int j = N - 1;
-      p = head;
-      if (p)
+      for (p = object_activity_lru_list_head (&list);
+	   p; p = object_activity_lru_list_next (p))
 	{
-	  do
-	    {
-	      assert (p->age == j --);
-	      if (j <= i)
-		j --;
-
-	      p = p->activity_lru.next;
-	    }
-	  while (p != head);
+	  assert (p->age == j --);
+	  if (j <= i)
+	    j --;
 	}
       assert (j == -1);
     }
@@ -67,61 +65,84 @@ test (void)
   /* Unlink nodes 1, 3, 5, 7, 9.  (Leaving an empty list.)  */
   for (i = 1; i < N; i += 2)
     {
-      object_activity_lru_unlink (&head, &descs[i]);
+      object_activity_lru_list_unlink (&list, &descs[i]);
 
       int j = N - 1;
-      p = head;
-      if (p)
+      for (p = object_activity_lru_list_head (&list);
+	   p; p = object_activity_lru_list_next (p))
 	{
-	  do
-	    {
-	      assert (p->age == j);
-	      j -= 2;
-
-	      p = p->activity_lru.next;
-	    }
-	  while (p != head);
+	  assert (p->age == j);
+	  j -= 2;
 	}
       assert (j == i);
     }
 
   /* A: 1 -> 2 -> 3.  */
-  struct object_desc *a = NULL;
-  object_activity_lru_push (&a, &descs[3]);
-  object_activity_lru_push (&a, &descs[2]);
-  object_activity_lru_push (&a, &descs[1]);
+  struct object_activity_lru_list a;
+  object_activity_lru_list_init (&a);
+
+  object_activity_lru_list_push (&a, &descs[3]);
+  object_activity_lru_list_push (&a, &descs[2]);
+  object_activity_lru_list_push (&a, &descs[1]);
+
+  assert (object_activity_lru_list_count (&a) == 3);
+
   /* B: 4 -> 5 -> 6.  */
-  struct object_desc *b = NULL;
-  object_activity_lru_push (&b, &descs[6]);
-  object_activity_lru_push (&b, &descs[5]);
-  object_activity_lru_push (&b, &descs[4]);
+  struct object_activity_lru_list b;
+  object_activity_lru_list_init (&b);
+
+  object_activity_lru_list_push (&b, &descs[6]);
+  object_activity_lru_list_push (&b, &descs[5]);
+  object_activity_lru_list_push (&b, &descs[4]);
+
+  assert (object_activity_lru_list_count (&b) == 3);
 
   /* Join 'em.  */
-  object_activity_lru_join (&a, &b);
-  assert (! b);
-  for (i = 1, p = a; i < 7; i ++, p = p->activity_lru.next)
+  object_activity_lru_list_join (&a, &b);
+  assert (! object_activity_lru_list_head (&b));
+
+  assert (object_activity_lru_list_count (&a) == 6);
+  assert (object_activity_lru_list_count (&b) == 0);
+
+  for (i = 1, p = object_activity_lru_list_head (&a);
+       i < 7; i ++, p = object_activity_lru_list_next (p))
+    assert (p && p->age == i);
+  assert (! p);
+
+  for (i = 6, p = object_activity_lru_list_tail (&a);
+       i > 0; i --, p = object_activity_lru_list_prev (p))
     assert (p && p->age == i);
-  assert (p == a);
+  assert (! p);
 
   /* Move a to b.  */
-  object_activity_lru_move (&b, &a);
-  assert (! a);
-  for (i = 1, p = b; i < 7; i ++, p = p->activity_lru.next)
+  object_activity_lru_list_move (&b, &a);
+  assert (! object_activity_lru_list_head (&a));
+  for (i = 1, p = object_activity_lru_list_head (&b);
+       i < 7; i ++, p = object_activity_lru_list_next (p))
     assert (p && p->age == i);
-  assert (p == b);
+  assert (! p);
 
   /* Remove some elements.  */
   for (i = 2; i < 7; i ++)
     {
-      object_activity_lru_unlink (&b, &descs[i]);
+      object_activity_lru_list_unlink (&b, &descs[i]);
 
-      assert (b->age == 1);
+      assert (object_activity_lru_list_head (&b)->age == 1);
+
+      p = object_activity_lru_list_head (&b);
+      assert (p && p->age == 1);
       int j;
-      for (j = i + 1, p = b->activity_lru.next; j < 7;
-	   j ++, p = p->activity_lru.next)
+
+      for (j = i + 1, p = object_activity_lru_list_next (p);
+	   j < 7;
+	   j ++, p = object_activity_lru_list_next (p))
 	assert (p && p->age == j);
-      assert (p == b);
-    }
+      assert (! p);
 
-  ss_mutex_unlock (&lru_lock);
+      p = object_activity_lru_list_tail (&b);
+      for (j = 6; j > i; j --, p = object_activity_lru_list_prev (p))
+	assert (p && p->age == j);
+      assert (p && p->age == 1);
+      assert (! object_activity_lru_list_prev (p));
+    }
 }