[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Using the GNU GMP Library for Bignums in Emacs

From: Stefan Monnier
Subject: Re: Using the GNU GMP Library for Bignums in Emacs
Date: Sun, 15 Jul 2018 11:02:49 -0400
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/27.0.50 (gnu/linux)

> I don't know HOW bad this will be.  (It would be nice to find out by
> experiment.)  That's why I said there _may_ be important advantages on
> the other side.  I don't know how important they are.

I recently posted a patch which makes EQ behave like `eql` attached.
I just tried to see its impact on the ELisp compilation time
(i.e. I did `rm **/*.elc; make`).

The original time on my benchmark machine was in the bracket
58.77s..59.13s, and with the patch, the time increased to a bracket of

So basically a 4% slow down.


diff --git a/src/fns.c b/src/fns.c
index 27c16c6072..4c23bb2488 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2173,10 +2173,7 @@ DEFUN ("eql", Feql, Seql, 2, 2, 0,
 Floating-point numbers of equal value are `eql', but they may not be `eq'.  */)
   (Lisp_Object obj1, Lisp_Object obj2)
-  if (FLOATP (obj1))
-    return equal_no_quit (obj1, obj2) ? Qt : Qnil;
-  else
-    return EQ (obj1, obj2) ? Qt : Qnil;
+  return EQL (obj1, obj2) ? Qt : Qnil;
 DEFUN ("equal", Fequal, Sequal, 2, 2, 0,
@@ -2272,7 +2269,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, enum 
equal_kind equal_kind,
-  if (EQ (o1, o2))
+  if (lisp_h_EQ (o1, o2))
     return true;
   if (XTYPE (o1) != XTYPE (o2))
     return false;
@@ -3766,7 +3763,7 @@ cmpfn_user_defined (struct hash_table_test *ht,
    in a Lisp integer.  */
 static EMACS_UINT
-hashfn_eq (struct hash_table_test *ht, Lisp_Object key)
+hashfn__eq (struct hash_table_test *ht, Lisp_Object key)
   return XHASH (key) ^ XTYPE (key);
@@ -3788,7 +3785,13 @@ hashfn_equal (struct hash_table_test *ht, Lisp_Object 
 static EMACS_UINT
 hashfn_eql (struct hash_table_test *ht, Lisp_Object key)
-  return FLOATP (key) ? hashfn_equal (ht, key) : hashfn_eq (ht, key);
+  return FLOATP (key) ? hashfn_equal (ht, key) : hashfn__eq (ht, key);
+static EMACS_UINT
+hashfn_eq (struct hash_table_test *ht, Lisp_Object key)
+  return hashfn_eql (ht, key);
 /* Value is a hash code for KEY for use in hash table H which uses as
diff --git a/src/lisp.h b/src/lisp.h
index 0bb7c488f2..26fa477ce4 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -361,7 +361,7 @@ typedef EMACS_INT Lisp_Word;
 #define lisp_h_INTEGERP(x) ((XTYPE (x) & (Lisp_Int0 | ~Lisp_Int1)) == 
 #define lisp_h_MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
 #define lisp_h_MISCP(x) (XTYPE (x) == Lisp_Misc)
-#define lisp_h_NILP(x) EQ (x, Qnil)
+#define lisp_h_NILP(x) lisp_h_EQ (x, Qnil)
 #define lisp_h_SET_SYMBOL_VAL(sym, v) \
    (eassert ((sym)->u.s.redirect == SYMBOL_PLAINVAL), \
     (sym)->u.s.val.value = (v))
@@ -421,7 +421,7 @@ typedef EMACS_INT Lisp_Word;
 # define CHECK_SYMBOL(x) lisp_h_CHECK_SYMBOL (x)
 # define CHECK_TYPE(ok, predicate, x) lisp_h_CHECK_TYPE (ok, predicate, x)
 # define CONSP(x) lisp_h_CONSP (x)
-# define EQ(x, y) lisp_h_EQ (x, y)
+# define EQ(x, y) EQL (x, y)
 # define FLOATP(x) lisp_h_FLOATP (x)
 # define INTEGERP(x) lisp_h_INTEGERP (x)
 # define MARKERP(x) lisp_h_MARKERP (x)
@@ -1141,10 +1141,21 @@ make_natnum (EMACS_INT n)
 /* Return true if X and Y are the same object.  */
+extern bool equal_no_quit (Lisp_Object o1, Lisp_Object o2);
+INLINE bool
+EQL (Lisp_Object x, Lisp_Object y)
+  if (lisp_h_FLOATP (x))
+    return equal_no_quit (x, y);
+  else
+    return lisp_h_EQ (x, y);
 INLINE bool
 (EQ) (Lisp_Object x, Lisp_Object y)
-  return lisp_h_EQ (x, y);
+  return EQL (x, y);
 /* True if the possibly-unsigned integer I doesn't fit in a Lisp fixnum.  */
@@ -3626,7 +3637,6 @@ extern Lisp_Object merge (Lisp_Object, Lisp_Object, 
 extern Lisp_Object do_yes_or_no_p (Lisp_Object);
 extern Lisp_Object concat2 (Lisp_Object, Lisp_Object);
 extern Lisp_Object concat3 (Lisp_Object, Lisp_Object, Lisp_Object);
-extern bool equal_no_quit (Lisp_Object, Lisp_Object);
 extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
 extern Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object);
 extern Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object);

reply via email to

[Prev in Thread] Current Thread [Next in Thread]