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

[no subject]

To:       (commonloops.pa@xerox.com)
From:     Nadine Sobolevitch (sobo@s66)
Date:     05 Oct 88  10:41 AM
Subject:  Compiling 8/28/88 PCL on Prime Lucid Common Lisp

There is an endless (garbage-production and) garbage-collection loop that
occurs during the compilation of the file pcl/dcode-pre1.lisp when you try to
compile the new PCL on Lucid Common Lisp on the Prime.

I sent a note on this problem to the commonloops mailing list about a week
ago.  Owing to mailer problems at this end of the line, I don't know if the
note reached its destination or not.  My apologies if this is a duplicate.
And if anybody has seen any *response* to the previous note, could someone
please send me a copy?

Note: the distribution file pcl/lucid-low.lisp has some bugs which we
have fixed in order to get this far in the compilation.  In particular,
the redefination of sys::defadvice should be the redefinition of lucid::
defadvice (and similarly for some functions called by defadvice).

Lisp was called with 48 reserved segments and 128 dynamic segments.
(64 kbytes/segment)



;;; Lucid Common Lisp, Version 1.2, June 22, 1988
;;; Copyright (C) 1988 by Lucid, Inc.   All Rights Reserved

;;; EDIT-CMD-LINE installed.

> (load "clos*>pcl-aaai>defsys.lisp")
;;; Loading source file "CLOS*>PCL-AAAI>DEFSYS.LISP"
#P"CLOS*>PCL-AAAI>DEFSYS.LISP"
> (in-package 'pcl)
#<Package "PCL" 910AF12>
> (compile-pcl)
Loading binary of PKG...
Loading binary of WALK...
Loading binary of ITERATE...
Loading binary of MACROS...
Loading binary of LOW...
Loading binary of LUCID-LOW...
;;; Warning: Redefining %LOGAND
;;; Warning: Redefining MAKE-MEMORY-BLOCK
;;; Warning: Redefining OBJECT-CACHE-NO
;;; Warning: Redefining SET-FUNCTION-NAME-1
;;; Warning: Redefining PRINTING-RANDOM-THING-INTERNAL
Loading binary of FIN...
Loading binary of DEFS...
Loading binary of BOOT...
Loading binary of VECTOR...
Loading binary of SLOTS...
Loading binary of MKI...
Loading binary of INIT...
Loading binary of DEFCLASS...
Loading binary of STD-CLASS...
Loading binary of BRAID1...
Loading binary of FSC...
Loading binary of METHODS...
Loading binary of COMBIN...
Loading binary of DCODE...
Compiling DCODE-PRE1...
;;; Reading input file #P"CLOS*>PCL-AAAI>DCODE-PRE1.LISP"
;;; GC: 104478 words [417912 bytes] of dynamic storage in use.
;;; 1992172 words [7968688 bytes] of free storage available before a GC.
;;; 4088822 words [16355288 bytes] of free storage available if GC is disabled.
;;; GC: 104476 words [417904 bytes] of dynamic storage in use.
;;; 1992174 words [7968696 bytes] of free storage available before a GC.
;;; 4088824 words [16355296 bytes] of free storage available if GC is disabled.
*** Deferring This Asynchronous Interrupt ***
>>Deferred Interrupt (noticed during function return): QUIT$

LUCID:%ZERO-REGION:
   Required arg 0 (ADDRESS): 220397568
   Required arg 1 (SEGMENT-COUNT): 1

:A    Abort to Lisp Top Level
:C    Will resume normal return

-> :b
LUCID:%ZERO-REGION <- PRE-MAKE-CACHING-DISCRIMINATING-FUNCTIONS <-
LUCID:COMPILE-FORM <- LUCID:COMPILE-FORM <- LET <- IF <- PROGN <- BLOCK <-
COMPILE-MODULE <- IF <- ECASE <- LET <- PROGN <- PROGN <- TAGBODY <- BLOCK <-
PROGN <- LABELS <- LET <- PROGN <- LET <- BLOCK <- OPERATE-ON-SYSTEM <-
RETURN-FROM <- IF <- PROGN <- BLOCK <- BLOCK <- COMPILE-PCL <- EVAL <-
unnamed function
-> :n
PRE-MAKE-CACHING-DISCRIMINATING-FUNCTIONS:
   Required arg 0 (FORM): (PRE-MAKE-CACHING-DISCRIMINATING-FUNCTIONS
((1 NIL # ...) (2 NIL # ...) (2 NIL # ...) ...))
   Required arg 1 (ENVIRONMENT): NIL
-> :n
LUCID:COMPILE-FORM:
   Required arg 0 (FORM): (PRE-MAKE-CACHING-DISCRIMINATING-FUNCTIONS
((1 NIL # ...) (2 NIL # ...) (2 NIL # ...) ...))
   Required arg 1 (MODE): LUCID::NOT-COMPILE-TIME
   Required arg 2 (OUTPUT): #<Compiled-Function LUCID::ASSEMBLE-FORM 8EA5E86>
   Rest arg (OUTARGS): (#<Compiled-Function LUCID::BACKEND-OUTPUT 8EA6392>
#<Stream SYSTEM:BUFFERED-STREAM 90F649A> #<Structure LUCID::FASLSTATE 9122432>)
-> :n
LUCID:COMPILE-FORM:
   Required arg 0 (FORM): (EVAL-WHEN (LOAD)
(PRE-MAKE-CACHING-DISCRIMINATING-FUNCTIONS (# # # ...)))
   Required arg 1 (MODE): LUCID::NOT-COMPILE-TIME
   Required arg 2 (OUTPUT): #<Compiled-Function LUCID::ASSEMBLE-FORM 8EA5E86>
   Rest arg (OUTARGS): (#<Compiled-Function LUCID::BACKEND-OUTPUT 8EA6392>
#<Stream SYSTEM:BUFFERED-STREAM 90F649A> #<Structure LUCID::FASLSTATE 9122432>)
-> :n
LET:
Original code: (LET ((NAME #)) (COMPILE-FILE (MAKE-SOURCE-PATHNAME NAME)
:OUTPUT-FILE ...))
   Local 0 (NAME): DCODE-PRE1
-> (room t)
;;; 296416 words [1185664 bytes] of dynamic storage in use.
;;; 1800234 words [7200936 bytes] of free storage available before a GC.
;;; 3896884 words [15587536 bytes] of free storage available if GC is disabled.
;;; Semi-space Size: 4096K bytes [64 segments]
;;; Current Dynamic Area: Dynamic-0-Area
;;; GC Status: Enabled
;;; Reserved Free Space: 1920K bytes [30 segments]
;;; Memory Growth Limit: 32768K bytes [512 segments], total
;;; Memory Growth Rate: 256K bytes [4 segments]
;;; Reclamation Ratio: 33% desired free after garbage collection
;;; Area Information:
;;; Name                        Size [used/allocated]
;;; ----                        ----
;;; Dynamic-0-Area              580K/4096K bytes,  10/64 segments
;;; Dynamic-1-Area              0K/4096K bytes,    0/64 segments
;;; Static-Area                 867K/892K bytes,   14/14 segments
;;; Readonly-Pointer-Area       295K/320K bytes,   5/5 segments
;;; Readonly-Non-Pointer-Area   1782K/1791K bytes, 28/28 segments
NIL
-> :a
;;; Compilation aborted, object file not written
Back to Lisp Top Level

> (user::quit)