Changeset 12306

Timestamp:

12/25/09 21:52:23 (14 years ago)

Author:

ehuelsmann

Message:

Land fast-boot-preloading branch on trunk.

Note: things to do include

1. Applying the same strategy to macro functions
2. Applying the same strategy to functions which get loaded during

EVAL-WHEN when compiling

Location:

trunk/abcl/src/org/armedbear/lisp

Files:

• Autoload.java (modified) (1 diff)
• AutoloadedFunctionProxy.java (copied) (copied from branches/fast-boot-preloading/abcl/src/org/armedbear/lisp/AutoloadedFunctionProxy.java)
• CompiledClosure.java (modified) (1 diff)
• Lisp.java (modified) (9 diffs)
• Load.java (modified) (2 diffs)
• Symbol.java (modified) (2 diffs)
• compile-file.lisp (modified) (4 diffs)
• compiler-pass2.lisp (modified) (1 diff)

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

@@ -665 +665 @@
         autoload(PACKAGE_SYS, "zip", "zip", true);
 
+        autoload(PACKAGE_SYS, "proxy-preloaded-function",
+                 "AutoloadedFunctionProxy", false);
+        autoload(PACKAGE_SYS, "make-function-preloading-context",
+                 "AutoloadedFunctionProxy", false);
+        autoload(PACKAGE_SYS, "function-preload",
+                 "AutoloadedFunctionProxy", false);
+
         autoload(Symbol.COPY_LIST, "copy_list");
 

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

@@ -220 +220 @@
       else if (arg instanceof AbstractString)
         namestring = arg.getStringValue();
-      if (namestring != null)
-        return loadCompiledFunction(namestring);
+      if (namestring != null) {
+          //    Debug.trace("autoloading preloaded ... " + namestring);
+        return AutoloadedFunctionProxy.loadPreloadedFunction(namestring);
+      }
       if(arg instanceof JavaObject) {
     try {
-        return loadCompiledFunction((byte[]) arg.javaInstance(byte[].class));
+        return loadClassBytes((byte[]) arg.javaInstance(byte[].class));
     } catch(Throwable t) {
         Debug.trace(t);

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

@@ -289 +289 @@
             throw c;
           }
-        catch (Throwable t)
+        catch (Throwable t) // ControlTransfer handled above
           {
             Debug.trace(t);
@@ -1205 +1205 @@
 
   {
+      byte[] bytes = readFunctionBytes(namestring);
+      if (bytes != null)
+        return loadClassBytes(bytes);
+
+      return null;
+  }
+
+  public static final byte[] readFunctionBytes(final String namestring)
+  {
     final LispThread thread = LispThread.currentThread();
     final boolean absolute = Utilities.isFilenameAbsolute(namestring);
@@ -1277 +1286 @@
                                 long size = entry.getSize();
                                 InputStream in = zipFile.getInputStream(entry);
-                                LispObject obj = loadCompiledFunction(in, (int) size);
-                                return obj != null ? obj : NIL;
+                                return readFunctionBytes(in, (int) size);
                               }
                             else 
@@ -1286 +1294 @@
                                   = defaultPathname.name.getStringValue() 
                                   + "." +  "abcl";//defaultPathname.type.getStringValue();
-                                byte in[] 
-                                  = Utilities
-                                  .getZippedZipEntryAsByteArray(zipFile, 
+                                return Utilities
+                                  .getZippedZipEntryAsByteArray(zipFile,
                                                                 entryName,
                                                                 namestring);
-                                LispObject o = loadCompiledFunction(in);
-                                return o != null ? o : NIL;
                               }
                           }
@@ -1302 +1307 @@
                   }
               }
+            catch (VerifyError e)
+              {
+                error(new LispError("Class verification failed: " +
+                                    e.getMessage()));
+                return null; // not reached
+              }
             catch (IOException e)
               {
@@ -1307 +1318 @@
               }
           }
-        return error(new LispError("Unable to load " + namestring));
+        error(new LispError("Unable to load " + namestring));
+        return null; // not reached
       }
     Pathname pathname = new Pathname(namestring);
@@ -1314 +1326 @@
       {
         // The .cls file exists.
-        LispObject obj = null;
-        try {
-            obj = loadCompiledFunction(new FileInputStream(file),
-                                       (int) file.length());
+        try
+          {
+            byte[] bytes = readFunctionBytes(new FileInputStream(file),
+                                             (int) file.length());
+            // FIXME close stream!
+            if (bytes != null)
+              return bytes;
+          }
+        catch (FileNotFoundException fnf) {
+            error(new LispError("Unable to load " + pathname.writeToString()
+                                + ": " + fnf.getMessage()));
+            return null; // not reached
         }
-        catch (FileNotFoundException e) {
-            return error(new LispError("Unable to load " +
-                         pathname.writeToString() + ": Not found."));
+        return null; // not reached
+      }
+    try
+      {
+        LispObject loadTruename = Symbol.LOAD_TRUENAME.symbolValue(thread);
+        String zipFileName = ((Pathname)loadTruename).getNamestring();
+        ZipFile zipFile = ZipCache.getZip(zipFileName);
+        try
+          {
+            ZipEntry entry = zipFile.getEntry(namestring);
+            if (entry != null)
+              {
+                byte[] bytes = readFunctionBytes(zipFile.getInputStream(entry),
+                                                 (int) entry.getSize());
+                if (bytes != null)
+                  return bytes;
+                Debug.trace("Unable to load " + namestring);
+                error(new LispError("Unable to load " + namestring));
+                return null; // not reached
+              }
+          }
+        finally
+          {
+            ZipCache.removeZip(zipFile.getName());
+          }
+      }
+    catch (IOException t)
+      {
+        Debug.trace(t);
+      }
+    error(new FileError("File not found: " + namestring,
+                        new Pathname(namestring)));
+    return null; // not reached
+  }
+
+    public static final Function makeCompiledFunctionFromClass(Class<?> c) {
+      try {
+  if (c != null) {
+      Function obj = (Function)c.newInstance();
+      return obj;
+        } else {
+            return null;
         }
-        // FIXME close stream!
-        if (obj != null)
-          return obj;
-        return error(new LispError("Unable to load " +
-                                    pathname.writeToString()));
-      }
-    LispObject loadTruename = Symbol.LOAD_TRUENAME.symbolValue(thread);
-    String zipFileName = ((Pathname)loadTruename).getNamestring();
-    ZipFile zipFile = null;
+      }
+      catch (InstantiationException e) {} // ### FIXME
+      catch (IllegalAccessException e) {} // ### FIXME
+
+      return null;
+    }
+
+
+  public static final LispObject loadCompiledFunction(InputStream in, int size)
+  {
+      byte[] bytes = readFunctionBytes(in, size);
+      if (bytes != null)
+        return loadClassBytes(bytes);
+      else
+        return error(new FileError("Can't read file off stream."));
+  }
+
+
+
+  private static final byte[] readFunctionBytes(InputStream in, int size)
+  {
     try
       {
-        zipFile = ZipCache.getZip(zipFileName);
-        ZipEntry entry = zipFile.getEntry(namestring);
-        if (entry != null)
-          {
-            LispObject obj = null;
-            try {
-                obj = loadCompiledFunction(zipFile.getInputStream(entry),
-                                                  (int) entry.getSize());
-            }
-            catch (IOException ignore) { };
-            if (obj != null)
-              return obj;
-            Debug.trace("Unable to load " + namestring);
-            return error(new LispError("Unable to load " + namestring));
-          }
-      }
-    catch (IOException ignore) {
-        //ignore IOException from ZipCache.getZip()
-    }
-    finally
-      {
-        try {
-            ZipCache.removeZip(zipFile.getName());
-        }
-        catch (IOException ignore) { } // ignore
-      }
-    return error(new FileError("File not found: " + namestring,
-                                new Pathname(namestring)));
-  }
-
-    public static final LispObject makeCompiledFunctionFromClass(Class<?> c) {
-  if (c != null)
-        try {
-            return (LispObject)c.newInstance();
-        }
-        catch (InstantiationException ignore) {
-            // ignore
-        }
-        catch (IllegalAccessException ignore) {
-            // ignore
-        }
-    return null;
-    }
-
-  private static final LispObject loadCompiledFunction(InputStream in, int size)
-  {
-    byte[] bytes = new byte[size];
-    int bytesRemaining = size;
-    int bytesRead = 0;
-    try {
+        byte[] bytes = new byte[size];
+        int bytesRemaining = size;
+        int bytesRead = 0;
         while (bytesRemaining > 0)
           {
@@ -1393 +1417 @@
           }
         in.close();
+        if (bytesRemaining > 0)
+          Debug.trace("bytesRemaining = " + bytesRemaining);
+
+        return bytes;
+      }
+    catch (IOException t)
+      {
+        Debug.trace(t); // FIXME: call error()?
+      }
+    return null;
+  }
+
+    public static final Function loadClassBytes(byte[] bytes)
+    {
+      return loadClassBytes(bytes, new JavaClassLoader());
     }
-    catch (IOException e) {
-        return null; // fixme: return an error?
-    }
-    if (bytesRemaining > 0)
-      Debug.trace("bytesRemaining = " + bytesRemaining);
-
-    return loadCompiledFunction(bytes);
-  }
-
-    public static final LispObject loadCompiledFunction(byte[] bytes) {
-        return loadCompiledFunction(bytes, new JavaClassLoader());
-    }
-
-    public static final LispObject loadCompiledFunction(byte[] bytes, JavaClassLoader cl) {
+
+    public static final Function loadClassBytes(byte[] bytes,
+                                                JavaClassLoader cl)
+    {
         Class<?> c = cl.loadClassFromByteArray(null, bytes, 0, bytes.length);
-        LispObject obj = makeCompiledFunctionFromClass(c);
-        if (obj instanceof Function) {
-            ((Function)obj).setClassBytes(bytes);
-        }
-        return obj;
+  Function obj = makeCompiledFunctionFromClass(c);
+  if (obj != null) {
+      obj.setClassBytes(bytes);
+  }
+  return obj;
     }
 
@@ -2443 +2472 @@
     exportSpecial("*AUTOLOAD-VERBOSE*", PACKAGE_EXT, NIL);
 
+  // ### *preloading-cache*
+ public static final Symbol AUTOLOADING_CACHE =
+   internSpecial("*AUTOLOADING-CACHE*", PACKAGE_SYS, NIL);
+
   // ### *compile-file-type*
   public static final String COMPILE_FILE_TYPE = "abcl";

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

@@ -45 +45 @@
 import java.net.URL;
 import java.net.URLDecoder;
+import java.util.Hashtable;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
@@ -607 +608 @@
         try {
             thread.bindSpecial(_FASL_ANONYMOUS_PACKAGE_, new Package());
+            thread.bindSpecial(AUTOLOADING_CACHE,
+                               AutoloadedFunctionProxy.makePreloadingContext());
             while (true) {
                 LispObject obj = in.faslRead(false, EOF, true, thread);

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

@@ -3015 +3015 @@
   public static final Symbol FSET =
     PACKAGE_SYS.addInternalSymbol("FSET");
+  public static final Symbol FUNCTION_PRELOAD =
+    PACKAGE_SYS.addInternalSymbol("FUNCTION-PRELOAD");
   public static final Symbol INSTANCE =
     PACKAGE_SYS.addInternalSymbol("INSTANCE");
   public static final Symbol MACROEXPAND_MACRO =
     PACKAGE_SYS.addInternalSymbol("MACROEXPAND-MACRO");
+  public static final Symbol MAKE_FUNCTION_PRELOADING_CONTEXT =
+    PACKAGE_SYS.addInternalSymbol("MAKE-FUNCTION-PRELOADING-CONTEXT");
   public static final Symbol NAME =
     PACKAGE_SYS.addInternalSymbol("NAME");
@@ -3027 +3031 @@
   public static final Symbol OPERATION =
     PACKAGE_SYS.addInternalSymbol("OPERATION");
+  public static final Symbol PROXY_PRELOADED_FUNCTION =
+    PACKAGE_SYS.addInternalSymbol("PROXY-PRELOADED-FUNCTION");
   public static final Symbol _SOURCE =
     PACKAGE_SYS.addInternalSymbol("%SOURCE");

trunk/abcl/src/org/armedbear/lisp/compile-file.lisp

@@ -161 +161 @@
                       (setf form
                             `(fset ',name
-                                   (load-compiled-function ,(file-namestring classfile))
+                                   (proxy-preloaded-function ',name ,(file-namestring classfile))
                                    ,*source-position*
                                    ',lambda-list
@@ -485 +485 @@
          (temp-file (merge-pathnames (make-pathname :type (concatenate 'string type "-tmp"))
                                      output-file))
+         (temp-file2 (merge-pathnames (make-pathname :type (concatenate 'string type "-tmp2"))
+                                     output-file))
          (warnings-p nil)
          (failure-p nil))
@@ -511 +513 @@
               (jvm::with-saved-compiler-policy
                   (jvm::with-file-compilation
-                      (write "; -*- Mode: Lisp -*-" :escape nil :stream out)
-                    (%stream-terpri out)
-                    (let ((*package* (find-package '#:cl)))
-                      (write (list 'init-fasl :version *fasl-version*)
-                             :stream out)
-                      (%stream-terpri out)
-                      (write (list 'setq '*source* *compile-file-truename*)
-                             :stream out)
-                      (%stream-terpri out))
                     (handler-bind ((style-warning #'(lambda (c)
                                                       (setf warnings-p t)
@@ -545 +538 @@
                     (dolist (name *fbound-names*)
                       (fmakunbound name)))))))
-        (rename-file temp-file output-file)
+        (with-open-file (in temp-file :direction :input)
+          (with-open-file (out temp-file2 :direction :output
+                               :if-does-not-exist :create
+                               :if-exists :supersede)
+            ;; write header
+            (write "; -*- Mode: Lisp -*-" :escape nil :stream out)
+            (%stream-terpri out)
+            (let ((*package* (find-package '#:cl))
+                  (count-sym (gensym)))
+              (write (list 'init-fasl :version *fasl-version*)
+                     :stream out)
+              (%stream-terpri out)
+              (write (list 'setq '*source* *compile-file-truename*)
+                     :stream out)
+              (%stream-terpri out)
+              (dump-form `(dotimes (,count-sym ,*class-number*)
+                            (function-preload
+                             (%format nil "~A-~D.cls" ,(pathname-name output-file)
+                                      (1+ ,count-sym)))) out)
+              (%stream-terpri out))
+
+
+            ;; copy remaining content
+            (loop for line = (read-line in nil :eof)
+               while (not (eq line :eof))
+               do (write-line line out))))
+        (delete-file temp-file)
+        (rename-file temp-file2 output-file)
 
         (when *compile-file-zip*

trunk/abcl/src/org/armedbear/lisp/compiler-pass2.lisp

@@ -2071 +2071 @@
      (declare-field g +lisp-object+ +field-access-default+)
      (emit 'ldc (pool-string (file-namestring pathname)))
-     (emit-invokestatic +lisp-class+ "loadCompiledFunction"
+     (emit-invokestatic "org/armedbear/lisp/AutoloadedFunctionProxy" "loadPreloadedFunction"
       (list +java-string+) +lisp-object+)
      (emit 'putstatic *this-class* g +lisp-object+)