Changeset 3668

Timestamp:

04/06/05 20:54:17 (4 years ago)

Author:

miyoshi

Message:

* alloc.c (FLOAT_BLOCK_SIZE): Sync up with Emacs CVS HEAD.
(FLOAT_BLOCK_SIZE): New macro.
(GETMARKBIT): Ditto.
(SETMARKBIT): Ditto.
(UNSETMARKBIT): Ditto.
(FLOAT_BLOCK): Ditto.
(FLOAT_INDEX): Ditto.
(struct float_block): Sync up with Emacs CVS HEAD.
(FLOAT_MARKED_P): Ditto.
(FLOAT_MARK): Ditto.
(FLOAT_UNMARK): Ditto.
(make_float): Ditto.
(mark_object): Ditto.
(pdump_block_table): New structure.
(PDUMP_BLOCK_HASH_SIZE): New macro.
(pdump_block): New structure.
(pdump_block_hash_value): New function.
(pdump_put_block_hash): Ditto.
(pdump_get_block_hash): Ditto.
(initialize_block_hash): Ditto.
(pdump_register_object): calculate a special offset for
PDUMP_FLOAT.
(pdump_write_objects): The codes related with PDUMP_FLOAT are
removed.
(pdump): Initialize `pdump_block_hash'.
(pdump): Wirte float blocks.
(pdump): Destruct memories for `pdump_block_hash'.
(PDUMP_RELOCATE): Consider space for `float_block'.
(pdump_load): Load float blocks.
(pdump_relocate_objects): The codes related with Lisp_Float are
removed.
(unmark_pdumped_objects): Sync up with Emacs CVS HEAD.

* lisp.h: Sync up with Emacs CVS HEAD. a member variable `type' is
removed.

Files:

• branches/2.2/src/ChangeLog.Meadow (modified) (1 diff)
• branches/2.2/src/alloc.c (modified) (19 diffs)
• branches/2.2/src/lisp.h (modified) (1 diff)

branches/2.2/src/ChangeLog.Meadow

@@ +1 @@
+2005-04-06  MIYOSHI Masanori  <miyoshi@meadowy.org>
+
+        * alloc.c (FLOAT_BLOCK_SIZE): Sync up with Emacs CVS HEAD.
+        (FLOAT_BLOCK_SIZE): New macro.
+        (GETMARKBIT): Ditto.
+        (SETMARKBIT): Ditto.
+        (UNSETMARKBIT): Ditto.
+        (FLOAT_BLOCK): Ditto.
+        (FLOAT_INDEX): Ditto.
+        (struct float_block): Sync up with Emacs CVS HEAD.
+        (FLOAT_MARKED_P): Ditto.
+        (FLOAT_MARK): Ditto.
+        (FLOAT_UNMARK): Ditto.
+        (make_float): Ditto.
+        (mark_object): Ditto.
+        (pdump_block_table): New structure.
+        (PDUMP_BLOCK_HASH_SIZE): New macro.
+        (pdump_block): New structure.
+        (pdump_block_hash_value): New function.
+        (pdump_put_block_hash): Ditto.
+        (pdump_get_block_hash): Ditto.
+        (initialize_block_hash): Ditto.
+        (pdump_register_object): calculate a special offset for
+        PDUMP_FLOAT.
+        (pdump_write_objects): The codes related with PDUMP_FLOAT are
+        removed.
+        (pdump): Initialize `pdump_block_hash'.
+        (pdump): Wirte float blocks.
+        (pdump): Destruct memories for `pdump_block_hash'.
+        (PDUMP_RELOCATE): Consider space for `float_block'.
+        (pdump_load): Load float blocks.
+        (pdump_relocate_objects): The codes related with Lisp_Float are
+        removed.
+        (unmark_pdumped_objects): Sync up with Emacs CVS HEAD.
+
+        * lisp.h: Sync up with Emacs CVS HEAD. a member variable `type' is
+        removed.
+
-2005-04-03  MIYOSHI Masanori  <miyoshi@meadowy.org>
-

branches/2.2/src/alloc.c

@@ -2473 +2473 @@
-   any new float cells from the latest float_block.  */
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-struct float_block
@@ -2480 +2502 @@
-  /* Place `floats' at the beginning, to ease up FLOAT_INDEX's job.  */
-  struct Lisp_Float floats[FLOAT_BLOCK_SIZE];
+  int gcmarkbits[1 + FLOAT_BLOCK_SIZE / (sizeof(int) * CHAR_BIT)];
-  struct float_block *next;
-};
-
-#define FLOAT_MARKED_P(fptr) \
-(XMARKBIT ((fptr)->type
+GETMARKBIT (FLOAT_BLOCK (fptr), FLOAT_INDEX ((fptr)
-
-#define FLOAT_MARK(fptr) \
-(XMARK ((fptr)->type
+SETMARKBIT (FLOAT_BLOCK (fptr), FLOAT_INDEX ((fptr)
-
-#define FLOAT_UNMARK(fptr) \
-(XUNMARK ((fptr)->type
+UNSETMARKBIT (FLOAT_BLOCK (fptr), FLOAT_INDEX ((fptr)
-
-/* Current float_block.  */
@@ -2556 +2579 @@
-                                                          MEM_TYPE_FLOAT);
-          new->next = float_block;
+          bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits);
-          float_block = new;
-          float_block_index = 0;
@@ -5096 +5120 @@
-
- loop:
-  XUNMARK (obj);
-
-#ifndef PDUMP
@@ -5150 +5173 @@
-
-#endif /* not GC_CHECK_MARKED_OBJECTS */
+
+  switch (SWITCH_ENUM_CAST (XGCTYPE (obj)))
+    {
+    case Lisp_Int:
+    case Lisp_Misc:
+    case Lisp_Float:
+      break;
+      
+    case Lisp_Symbol:
+    case Lisp_String:
+    case Lisp_Vectorlike:
+    case Lisp_Cons:
+      XUNMARK (obj);
+      break;
+    default:
+      XUNMARK (obj);
+      break;
+    }
-
-  switch (SWITCH_ENUM_CAST (XGCTYPE (obj)))
@@ -6117 +6158 @@
-} pdump_forward_hash_table;
-
+
+typedef struct pdump_block_table
+{
+  void *block;
+  int block_index;
+  int n_blocks;
+} pdump_block_table;
+
-/* Struct to hold root object data. */
-typedef struct pdump_root
@@ -6136 +6185 @@
-#define PDUMP_HASH_TABLE_SIZE 7 /* for Lisp_Hash_Table */
-#define PDUMP_OFFSET 12289
+#define PDUMP_BLOCK_HASH_SIZE 71
-
-static pdump_forward **pdump_hash;
@@ -6341 +6391 @@
-}
-
+/* Struct to hold a element of blocks in a hash table. */
+typedef struct pdump_block
+{
+  void *obj;
+  int block_index;
+  int element_index;
+  struct pdump_block *next;
+} pdump_block;
+
+static pdump_block **pdump_block_hash;
+
+/* calculate hash value for Lisp_Object */
+static int
+pdump_block_hash_value (void *obj)
+{
+  return ((unsigned long) obj >> 3) % PDUMP_BLOCK_HASH_SIZE;
+}
+
+/* put given Lisp_Object to pdump_block_hash */
+static void
+pdump_put_block_hash (void *obj, int block_index, int element_index)
+{
+  int idx = pdump_block_hash_value (obj);
+  pdump_block **prev = &pdump_block_hash[idx];
+  pdump_block *f = pdump_block_hash[idx];
+
+  while (f != 0)
+    {
+      if (f->obj == obj)
+        return;
+      prev = &(*prev)->next;
+      f = f->next;
+    }
+  f = (pdump_block *) xmalloc (sizeof (*f));
+  f->obj = obj;
+  f->block_index = block_index;
+  f->element_index = element_index;
+  f->next = NULL;
+  *prev = f;
+}
+
+/* retrieve pdump_forward entry of given Lisp_Object */
+static pdump_block *
+pdump_get_block_hash (void *obj)
+{
+  pdump_block *f = pdump_block_hash[pdump_block_hash_value (obj)];
+
+  while (f != 0)
+    {
+      if (f->obj == obj)
+        return f;
+      f = f->next;
+    }
+  return 0;
+}
+
+static void
+initialize_block_hash (void)
+{
+  struct float_block *p = float_block;
+  int n = float_block_index;
+  int i, j = 0;
+
+  while (p)
+    {
+      for (i = 0; i < n; i++)
+        {
+          pdump_put_block_hash ((void *) &p->floats[i], j, i);
+        }
+      p = p->next;
+      n = FLOAT_BLOCK_SIZE;
+      j++;
+    }
+}
+
+static unsigned long
+pdump_float_blocks_size (void)
+{
+  return sizeof (struct float_block) * n_float_blocks + sizeof (pdump_block);
+}
+
-/* Register given object for pdump_hash and pdump_lisp_object[type] */
-static void
@@ -6347 +6478 @@
-{
-  assert (pdump_get_hash (obj) == 0);
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}
@@ -6745 +6893 @@
-
-  addr = f->offset + PDUMP_OFFSET + sizeof (pdump_header_type);
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-  XSET (new_obj, XTYPE (obj), addr);
-  return new_obj;
@@ -6881 +7039 @@
-      fwrite (&new, size, 1, pdump_stream);
-    }
-  for (i = 0; i < pdump_lisp_object[PDUMP_FLOAT].index; i++)
-    {
-      Lisp_Object obj = pdump_lisp_object[PDUMP_FLOAT].objects[i];
-      int size = sizeof (struct Lisp_Float);
-      fwrite (XFLOAT (obj), size, 1, pdump_stream);
-    }
-  for (i = 0; i < pdump_lisp_object[PDUMP_HASH_TABLE].index; i ++)
-    {
@@ -7048 +7200 @@
-  bzero (pdump_hash_table, sizeof (*pdump_hash_table) * PDUMP_HASH_TABLE_SIZE);
-
+  pdump_block_hash = (pdump_block **)
+    xmalloc (sizeof (*pdump_block_hash) * PDUMP_BLOCK_HASH_SIZE);
+  bzero (pdump_block_hash, sizeof (*pdump_block_hash) * PDUMP_BLOCK_HASH_SIZE);
+  initialize_block_hash ();
+  
-  pdump_stream = fopen ("emacs.dmp", "w");
-
@@ -7098 +7255 @@
-                  header.hash_table_length, header.hash_table_size,
-                  header.vector_length, header.vector_size));
+
+  /* write float blocks */
+  {
+    struct float_block *p = float_block;
+    unsigned long offset = PDUMP_OFFSET + sizeof (pdump_header_type);
+    struct pdump_block_table bt;
+    
+    for (i = 0; i < PDUMP_OBJECT_LIMIT; i++)
+      offset += pdump_lisp_object[i].size;
+
+    bt.block = (struct float_block *) offset;
+    bt.block_index = float_block_index;
+    bt.n_blocks = n_float_blocks;
+    
+    while (p)
+      {
+        struct float_block fb = *p;
+
+        if (fb.next)
+          fb.next = (struct float_block *) (offset
+                                            + sizeof (struct float_block));
+        fwrite (&fb, sizeof (fb), 1, pdump_stream);
+        p = p->next;
+        offset += sizeof (struct float_block);
+      }
+    fwrite (&bt, sizeof (bt), 1, pdump_stream);
+  }
-
-  /* write misc */
@@ -7204 +7388 @@
-  xfree (pdump_hash);
-
+  for (i = 0; i < PDUMP_BLOCK_HASH_SIZE; i++)
+    {
+      pdump_block *f = pdump_block_hash[i], *next;
+
+      while (f != 0)
+        {
+          next = f->next;
+          xfree (f);
+          f = next;
+        }
+    }
+  xfree (pdump_block_hash);
+
-#ifdef PDUMP_DEBUG
-  assert (pure_bytes_used == 0);
@@ -7215 +7412 @@
-  if (! INTEGERP (obj)                                                  \
-      && pdump_objects_start <= p_r_ptr                                 \
-
+
+
-    XSET ((obj), XTYPE (obj), p_r_ptr);                                 \
-}                                                                       \
@@ -7481 +7679 @@
-  PDUMP_MESSAGE (("Loading root objects... \n"));
-  lseek (fd, pdump_header.objects_size + sizeof (pdump_header_type), SEEK_SET);
+
+  /* load float blocks */
+  {
+    struct float_block fb, *p;
+    struct pdump_block_table bt;
+    int count = 0;
+
+    do
+      {
+        read (fd, &fb, sizeof (fb));
+      }
+    while (fb.next);
+
+    read (fd, &bt, sizeof (bt));
+    float_block = (struct float_block * )((unsigned long) bt.block
+                                          + offset);
+    float_block_index = bt.block_index;
+    n_float_blocks = bt.n_blocks;
+
+    /* relocation */
+    p = float_block;
+    while (p)
+      {
+        if (p->next)
+          p->next = (struct float_block * ) ((unsigned long) p->next + offset);
+        p = p->next;
+      }
+  }
+
-  for (staticidx = 0; staticidx < pdump_header.root_objects_length; staticidx++)
-    {
@@ -7730 +7957 @@
-      obj_ptr += sizeof (struct Lisp_Symbol);
-    }
-  for (i = 0; i < pdump_header.float_length; i++)
-    obj_ptr += sizeof (struct Lisp_Float);
-  for (i = 0; i < pdump_header.hash_table_length; i ++)
-    obj_ptr += PDUMP_LISP_HASH_TABLE_SIZE;
@@ -7764 +7989 @@
-    {
-      struct Lisp_Cons *ptr = (struct Lisp_Cons *) obj_ptr;
-XMARKBIT (ptr->ca
-XUNMARK (ptr->ca
+CONS_MARKED_P (pt
+CONS_UNMARK (pt
-      obj_ptr += sizeof (struct Lisp_Cons);
-    }
@@ -7840 +8065 @@
-  assert (pdump_object_start_address (PDUMP_FLOAT) == obj_ptr);
-#endif
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-#ifdef PDUMP_DEBUG
-  assert (pdump_object_start_address (PDUMP_HASH_TABLE) == obj_ptr);

branches/2.2/src/lisp.h

@@ -1287 +1287 @@
-struct Lisp_Float
-  {
-    Lisp_Object type;           /* essentially used for mark-bit
-                                   and chaining when on free-list */
-#ifdef HIDE_LISP_IMPLEMENTATION
-    double data_;