X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcode%2Fsave.lisp;h=76b7b95ef7f2205b9bcff340958d37902a4885f0;hb=b3f188843330c56bd4d17a3c930e73f573b1c71f;hp=7f0abb02fe7741e7788d65e19752304730ab70e6;hpb=b08344ddbb8d0193054b72c01be7e367422ccf03;p=sbcl.git diff --git a/src/code/save.lisp b/src/code/save.lisp index 7f0abb0..76b7b95 100644 --- a/src/code/save.lisp +++ b/src/code/save.lisp @@ -15,23 +15,11 @@ (in-package "SB!IMPL") -(defvar *before-save-initializations* nil - #!+sb-doc - "This is a list of functions which are called before creating a saved core - image. These functions are executed in the child process which has no ports, - so they cannot do anything that tries to talk to the outside world.") - -(defvar *after-save-initializations* nil - #!+sb-doc - "This is a list of functions which are called when a saved core image starts - up. The system itself should be initialized at this point, but applications - might not be.") - ;;;; SAVE-LISP-AND-DIE itself -(sb!alien:def-alien-routine "save" (sb!alien:boolean) - (file sb!c-call:c-string) - (initial-function (sb!alien:unsigned #.sb!vm:word-bits))) +(sb!alien:define-alien-routine "save" (sb!alien:boolean) + (file sb!alien:c-string) + (initial-fun (sb!alien:unsigned #.sb!vm:n-word-bits))) ;;; FIXME: When this is run without the PURIFY option, ;;; it seems to save memory all the way up to the high-water mark, @@ -40,41 +28,53 @@ ;;; (But with the PURIFY option it seems to work OK.) (defun save-lisp-and-die (core-file-name &key (toplevel #'toplevel-init) - (purify nil) + (purify t) (root-structures ()) (environment-name "auxiliary")) #!+sb-doc - "Saves a CMU Common Lisp core image in the file of the specified name, - killing the current Lisp invocation in the process (unless it bails - out early because of some argument error or something). - - The following keyword args are defined: + "Save a \"core image\", i.e. enough information to restart a Lisp + process later in the same state, in the file of the specified name. - :TOPLEVEL - The function to run when the created core file is resumed. - The default function handles command line toplevel option - processing and runs the top level read-eval-print loop. This - function should not return. + This implementation is not as polished and painless as you might like: + * It corrupts the current Lisp image enough that the current process + needs to be killed afterwards. + * It will not work if multiple threads are in use. + * There is absolutely no binary compatibility of core images between + different runtime support programs. Even runtimes built from the same + sources at different times are treated as incompatible for this purpose. + This isn't because we like it this way, but just because there don't + seem to be good quick fixes for either limitation and no one has been + sufficiently motivated to do lengthy fixes. - :PURIFY - If true (the default), do a purifying GC which moves all dynamically - allocated objects into static space so that they stay pure. This takes - somewhat longer than the normal GC which is otherwise done, but it's only - done once, and subsequent GC's will be done less often and will take less - time in the resulting core file. See PURIFY. + The following &KEY arguments are defined: + :TOPLEVEL + The function to run when the created core file is resumed. + The default function handles command line toplevel option + processing and runs the top level read-eval-print loop. This + function should not return. + :PURIFY + If true (the default), do a purifying GC which moves all dynamically + allocated objects into static space so that they stay pure. This takes + somewhat longer than the normal GC which is otherwise done, but it's + only done once, and subsequent GC's will be done less often and will + take less time in the resulting core file. See the PURIFY function. + :ROOT-STRUCTURES + This should be a list of the main entry points in any newly loaded + systems. This need not be supplied, but locality and/or GC performance + may be better if they are. Meaningless if :PURIFY is NIL. See the + PURIFY function. + :ENVIRONMENT-NAME + This is also passed to the PURIFY function when :PURIFY is T. + (rarely used) - :ROOT-STRUCTURES - This should be a list of the main entry points in any newly loaded - systems. This need not be supplied, but locality and/or GC performance - may be better if they are. Meaningless if :PURIFY is NIL. See PURIFY. + The save/load process changes the values of some global variables: + *STANDARD-OUTPUT*, *DEBUG-IO*, etc. + Everything related to open streams is necessarily changed, since + the OS won't let us preserve a stream across save and load. + *DEFAULT-PATHNAME-DEFAULTS* + This is reinitialized to reflect the working directory where the + saved core is loaded." - :ENVIRONMENT-NAME - This is also passed to PURIFY when :PURIFY is T. (rarely used)" - - #!+mp (sb!mp::shutdown-multi-processing) - (when (fboundp 'sb!eval:flush-interpreted-function-cache) - (sb!eval:flush-interpreted-function-cache)) - ;; FIXME: What is this for? Explain. (when (fboundp 'cancel-finalization) (cancel-finalization sb!sys:*tty*)) ;; FIXME: Would it be possible to unmix the PURIFY logic from this @@ -101,27 +101,3 @@ (without-gcing (save (unix-namestring core-file-name nil) (get-lisp-obj-address #'restart-lisp))))) - -;;;; functions used by worldload.lisp in CMU CL bootstrapping - -;;; If Name has been byte-compiled, and :RUNTIME is a feature, then load the -;;; byte-compiled version, otherwise just do normal load. -#+nil ; no longer needed in SBCL.. I think.. -- WHN 19990814 -(defun maybe-byte-load (name &optional (load-native t)) - (let ((bname (make-pathname - :defaults name - :type #.(sb!c:backend-byte-fasl-file-type)))) - (cond ((and (featurep :runtime) - (probe-file bname)) - (load bname)) - (load-native - (load name))))) - -;;; Replace a cold-loaded native object file with a byte-compiled one, if it -;;; exists. -#+nil ; no longer needed in SBCL.. I think.. -- WHN 19990814 -(defun byte-load-over (name) - (load (make-pathname - :defaults name - :type #.(sb!c:backend-byte-fasl-file-type)) - :if-does-not-exist nil))