Changeset 15361

Timestamp:

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

Author:

Mark Evenson

Message:

Serialization of local functions and closures w/ tests (except for compiled closures)

Location:

trunk/abcl

Files:

• src/org/armedbear/lisp/ArgumentListProcessor.java (modified) (3 diffs)
• src/org/armedbear/lisp/Binding.java (modified) (2 diffs)
• src/org/armedbear/lisp/Closure.java (modified) (1 diff)
• src/org/armedbear/lisp/ClosureBinding.java (modified) (2 diffs)
• src/org/armedbear/lisp/Environment.java (modified) (1 diff)
• src/org/armedbear/lisp/Function.java (modified) (2 diffs)
• src/org/armedbear/lisp/FunctionBinding.java (modified) (1 diff)
• src/org/armedbear/lisp/MemoryClassLoader.java (modified) (1 diff)
• test/src/org/armedbear/lisp/serialization/SerializationTest.java (modified) (1 diff)

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

@@ -35 +35 @@
 package org.armedbear.lisp;
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.ArrayList;
@@ -44 +45 @@
  * All other lambda lists are parsed elsewhere in our code base.
  */
-public class ArgumentListProcessor {
+public class ArgumentListProcessor implements Serializable {
     
   public enum LambdaListType {
@@ -562 +563 @@
    * Because we have two implementations - a fast one and a slower one - we
    * need this abstract super class */
-  private static abstract class ArgumentMatcher {
+  private static abstract class ArgumentMatcher implements Serializable {
       abstract LispObject[] match(LispObject[] args, Environment _environment,
               Environment env, LispThread thread);

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

@@ -34 +34 @@
 package org.armedbear.lisp;
 
+import java.io.Serializable;
+
 /** Used by the environment to capture different kinds of bindings:
  * tags, blocks, functions and variables.
@@ -39 +41 @@
  */
 // Package accessibility.
-final class Binding
+final class Binding implements Serializable
 {
     /** The symbol in case of a variable, block, symbol-macro or

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

@@ -230 +230 @@
     return arglist.match(args, environment, environment, thread);
   }
+
+  //Serialization
+
+  @Override
+  protected boolean shouldSerializeByName() {
+    return false; //Closures have an environment that we must serialize, even if they're top-level function
+  }
 }

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

@@ -34 +34 @@
 package org.armedbear.lisp;
 
+import java.io.Serializable;
+
 /** This class serves merely to store a reference to an
  * object, used in the closure array.
@@ -41 +43 @@
  *
  */
-public class ClosureBinding
+public class ClosureBinding implements Serializable
 {
     public LispObject value;

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

@@ -34 +34 @@
 package org.armedbear.lisp;
 
+import java.io.Serializable;
+
 import static org.armedbear.lisp.Lisp.*;
 
-public final class Environment extends LispObject
+public final class Environment extends LispObject implements Serializable
 {
   Binding vars;

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

@@ -34 +34 @@
 package org.armedbear.lisp;
 
-import java.io.NotSerializableException;
-import java.io.Serializable;
+import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 
 import static org.armedbear.lisp.Lisp.*;
@@ -401 +402 @@
     }
 
-    public Object writeReplace() throws NotSerializableException {
+    public static class SerializedLocalFunction implements Serializable {
+        final LispObject className;
+        final LispObject classBytes;
+        final byte[] serializedFunction;
+
+        public SerializedLocalFunction(Function function) {
+            this.className = JavaObject.getInstance(function.getClass().getName());
+            this.classBytes = function.getClassBytes();
+            serializingClosure.set(true);
+            try {
+                ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                new ObjectOutputStream(baos).writeObject(function);
+                serializedFunction = baos.toByteArray();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            } finally {
+                serializingClosure.remove();
+            }
+        }
+
+        public Object readResolve() throws InvalidObjectException {
+            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();
+            } catch (Exception e) {
+                InvalidObjectException ex = new InvalidObjectException("Could not read the serialized function back");
+                ex.initCause(e);
+                throw ex;
+            } finally {
+                thread.setContextClassLoader(oldLoader);
+            }
+        }
+    }
+
+    private static final ThreadLocal<Boolean> serializingClosure = new ThreadLocal<Boolean>();
+
+    public Object writeReplace() throws ObjectStreamException {
+        if(shouldSerializeByName()) {
+            return new SerializedNamedFunction((Symbol) getLambdaName());
+        } else if(serializingClosure.get() != null) {
+            return new SerializedLocalFunction(this);
+        } else {
+            return this;
+        }
+    }
+
+    protected boolean shouldSerializeByName() {
         LispObject lambdaName = getLambdaName();
-        if(lambdaName instanceof Symbol && lambdaName.getSymbolFunction() == this) {
-            return new SerializedNamedFunction((Symbol) lambdaName);
-        } else {
-            throw new NotSerializableException(getClass().getName());
-        }
+        return lambdaName instanceof Symbol && lambdaName.getSymbolFunction() == this;
     }
 }

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

@@ -34 +34 @@
 package org.armedbear.lisp;
 
+import java.io.Serializable;
+
 // Package accessibility.
-final class FunctionBinding
+final class FunctionBinding implements Serializable
 {
     LispObject name;

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

@@ -145 +145 @@
     };
 
-    private static final Primitive PUT_MEMORY_FUNCTION = new pf_put_memory_function();
+    public static final Primitive PUT_MEMORY_FUNCTION = new pf_put_memory_function();
     private static final class pf_put_memory_function extends Primitive {
         pf_put_memory_function() {

trunk/abcl/test/src/org/armedbear/lisp/serialization/SerializationTest.java

@@ -46 +46 @@
         ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
         Object readObject = ois.readObject();
-        assertEquals(readObject, closure);
+        assertTrue(readObject instanceof Closure);
+        assertEquals(NIL, ((Closure) readObject).execute());
+    }
+
+    @Test
+    public void testSerializationOfLocalClosure() throws Exception {
+        Symbol symbol = new Symbol("test");
+        LispObject lambda_expression =
+                new Cons(Symbol.LAMBDA, new Cons(NIL, new Cons(symbol)));
+        LispObject lambda_name =
+                list(Symbol.FLET, new Symbol("test"));
+        Environment env = new Environment();
+        env.bind(symbol, new SimpleString("OK"));
+        Closure closure =
+                new Closure(lambda_name, lambda_expression, env);
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(baos);
+        oos.writeObject(closure);
+
+        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
+        Object readObject = ois.readObject();
+        assertTrue(readObject instanceof Closure);
+        assertEquals("OK", ((Closure) readObject).execute().toString());
     }