Changeset 15363

Timestamp:

08/06/20 16:03:15 (3 years ago)

Author:

Mark Evenson

Message:

Refined serialization of local functions and closures (including compiled closures).
Proper tests however should involve multiple instances of ABCL to avoid any in-process effects.

Location:

trunk/abcl

Files:

• abcl.asd (modified) (1 diff)
• src/org/armedbear/lisp/Function.java (modified) (5 diffs)
• src/org/armedbear/lisp/JavaObject.java (modified) (2 diffs)
• test/lisp/abcl/closure-serialization.lisp (added)

trunk/abcl/abcl.asd

@@ -58 +58 @@
                          (:file "runtime-class")
                          #+abcl
-                         (:file "package-local-nicknames-tests")))))
+                         (:file "package-local-nicknames-tests")
+                         #+abcl
+                         (:file "closure-serialization")))))
 
 ;;; FIXME Currently requires ACBL-CONTRIB and QUICKLISP-ABCL to be

trunk/abcl/src/org/armedbear/lisp/Function.java

@@ -195 +195 @@
 
     public final LispObject getClassBytes() {
-  LispObject o = getf(propertyList, Symbol.CLASS_BYTES, NIL);
-  if(o != NIL) {
-      return o;
-  } else {
-      ClassLoader c = getClass().getClassLoader();
-      if(c instanceof FaslClassLoader) {
-    final LispThread thread = LispThread.currentThread(); 
-    SpecialBindingsMark mark = thread.markSpecialBindings(); 
-    try { 
-        thread.bindSpecial(Symbol.LOAD_TRUENAME, loadedFrom); 
-        return new JavaObject(((FaslClassLoader) c).getFunctionClassBytes(this));
-    } catch(Throwable t) {
-        //This is because unfortunately getFunctionClassBytes uses
-        //Debug.assertTrue(false) to signal errors
-        if(t instanceof ControlTransfer) {
-      throw (ControlTransfer) t;
-        } else {
-      return NIL;
-        }
-    } finally { 
-        thread.resetSpecialBindings(mark); 
-    }   
-      } else {
-    return NIL;
-      }
-  }
+        LispObject o = getf(propertyList, Symbol.CLASS_BYTES, NIL);
+        if(o != NIL) {
+            return o;
+        } else {
+            ClassLoader c = getClass().getClassLoader();
+            if(c instanceof JavaClassLoader) {
+                final LispThread thread = LispThread.currentThread();
+                SpecialBindingsMark mark = thread.markSpecialBindings();
+                try {
+                    thread.bindSpecial(Symbol.LOAD_TRUENAME, loadedFrom);
+                    return new JavaObject(((JavaClassLoader) c).getFunctionClassBytes(this));
+                } catch(Throwable t) {
+                    //This is because unfortunately getFunctionClassBytes uses
+                    //Debug.assertTrue(false) to signal errors
+                    if(t instanceof ControlTransfer) {
+                        throw (ControlTransfer) t;
+                    } else {
+                        return NIL;
+                    }
+                } finally {
+                    thread.resetSpecialBindings(mark);
+                }
+            } else {
+                return NIL;
+            }
+        }
     }
 
@@ -402 +402 @@
     }
 
+    public static class ObjectInputStreamWithClassLoader extends ObjectInputStream {
+        private final ClassLoader classLoader;
+        public ObjectInputStreamWithClassLoader(InputStream in, ClassLoader classLoader) throws IOException {
+            super(in);
+            this.classLoader = classLoader;
+        }
+
+        @Override
+        protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
+            return Class.forName(desc.getName(), false, classLoader);
+        }
+    }
+
     public static class SerializedLocalFunction implements Serializable {
         final LispObject className;
@@ -408 +421 @@
 
         public SerializedLocalFunction(Function function) {
-            this.className = JavaObject.getInstance(function.getClass().getName());
+            this.className = new SimpleString(function.getClass().getName());
             this.classBytes = function.getClassBytes();
             serializingClosure.set(true);
@@ -425 +438 @@
             MemoryClassLoader loader = new MemoryClassLoader();
             MemoryClassLoader.PUT_MEMORY_FUNCTION.execute(JavaObject.getInstance(loader), className, classBytes);
-            Thread thread = Thread.currentThread();
-            ClassLoader oldLoader = thread.getContextClassLoader();
             try {
-                thread.setContextClassLoader(loader);
-                return new ObjectInputStream(new ByteArrayInputStream(serializedFunction)).readObject();
+                ByteArrayInputStream in = new ByteArrayInputStream(serializedFunction);
+                return new ObjectInputStreamWithClassLoader(in, loader).readObject();
             } catch (Exception e) {
                 InvalidObjectException ex = new InvalidObjectException("Could not read the serialized function back");
                 ex.initCause(e);
                 throw ex;
-            } finally {
-                thread.setContextClassLoader(oldLoader);
             }
         }
@@ -445 +454 @@
         if(shouldSerializeByName()) {
             return new SerializedNamedFunction((Symbol) getLambdaName());
-        } else if(serializingClosure.get() != null) {
+        } else if(getClassBytes() == NIL || serializingClosure.get() != null) {
+            return this;
+        } else {
             return new SerializedLocalFunction(this);
-        } else {
-            return this;
         }
     }

trunk/abcl/src/org/armedbear/lisp/JavaObject.java

@@ -36 +36 @@
 import static org.armedbear.lisp.Lisp.*;
 
+import java.io.Serializable;
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
@@ -41 +42 @@
 import java.util.*;
 
-public final class JavaObject extends LispObject {
+public final class JavaObject extends LispObject implements Serializable {
     final Object obj;
     private final Class<?> intendedClass;