|
|
|
last edited 10 years ago by test1 |
Edit detail for #17 algebra BOOTSTRAP fixed point revision 3 of 3
| 1 2 3 | ||
|
Editor: test1
Time: 2014/04/15 17:06:35 GMT+0 |
||
| Note: | ||
added:
From test1 Tue Apr 15 17:06:35 +0000 2014
From: test1
Date: Tue, 15 Apr 2014 17:06:35 +0000
Subject:
Message-ID: <20140415170635+0000@axiom-wiki.newsynthesis.org>
Status: open => closed
William, Ralf, Tim; Keep in mind here that what Steve and I are talking about are changes in the lisp coding generated by the )compile command for the *same* spad code between the initial build of Axiom and a repeat build of the same algebra spad code. When you run something like: > (21) -> for i in 10^32 .. 10^32+5 repeat print i if this loop called PRIMELT (or some other code affected by the boostrap) then the first version of the lisp code is being run because you are using only the initial build of Axiom. But if you recompile PRIMELT and then run your test again, then the second version of the lisp code is being run. The fact that the compiled lisp code (which is compiled by GCL to an object file) is not consistent from the first compile to the next is the reason why we are concerned about this. We want to know the reason why this happens. One reasonable theory is that some algebra code, say A contains some implicit dependencies on other algebra code B and that when the code for B changes it causes changes in the code generated for A. In other words A has to be recompiled because B changed. This is not too much of a problem in general provided that we either rebuild all of the algebra each time for any change or if we have a complete set of dependencies which shows what depends on what. But the fact that these dependencies form loops means that some spad code files have to be singled out as "bootstrap" files. For these one must supply initial lisp code in order to get the initial `.o' files so that the rest of the algebra files can be compiled. In the current Axiom build the bootstrap lisp files are subtly different than the lisp actually generated by the compiler for the corresponding spad file. It would appear that the initial differences in the bootstrap lisp files can be passed on to other files that depend on them. In the current build, the algebra files must be compiled twice before no further changes in the generated lisp code occurs. >PRIMELT > > The differences in the generated lisp are w.r.t QSADD1, in compiler > generated code implementing a for loop. The differences look like: > > - (LETT |i| (+ |i| 1) > + (LETT |i| (QSADD1 |i|) > > In primitiveElement, we use a for loop on `i in 10..'. i is passed to > symmetricRemainder, defined in IntegerNumberSystem with signature: > > -----Original Message----- > From: William Sit [address@bogus.example.com">mailto:address@bogus.example.com > Sent: Monday, January 17, 2005 12:29 PM > To: Ralf Hemmecke; address@bogus.example.com; address@bogus.example.com > Subject: Re: [Axiom-developer] RE: algebra Makefiles > withexplicitdependencies, bootstrap, fixed-points etc. > > > (21) -> for i in 10^32 .. 10^32+5 repeat print i > 100000000000000000000000000000000 > 100000000000000000000000000000001 > 100000000000000000000000000000002 > 100000000000000000000000000000003 > 100000000000000000000000000000004 > 100000000000000000000000000000005 > Type: Void > > William Sit wrote: > > > > Let's not forget that 2^32 is over 4 billion. > > > > William > > -- > > > > Ralf Hemmecke wrote: > > > > > > This sounds like forbidding > > > > > > for i in 10^32 .. repeat .... > > > > > > or do I misunderstand something? > > > > > > Ralf > > > > > > root wrote: > > > > Steve, > > > > > > > > I don't know if there is an actual statement to the effect that > > > > the upper bound on a loop would be a register-sized number (32 > > > > or 64 bits) but at 6Mhz it seemed impossible that one could > > > > run a loop of any consequence for greater than 2^32 or 2^64 > > > > iterations. If you wanted to do that you'd have to do the > > > > looping using some other construct. In general it is safe to > > > > assume that the upper bound of the register size cannot be > > > > exceeded. There is a practical performance difference to > > > > be gained by using (declare (fixnum as the compiler can, > > > > in the best case, assign a register to the loop variable. > > > > > > -- > William Sit ------------------------------------------------------------ fixnum optimization in new compiler --Mon, 17 Jan 2005 21:19:24 -0600 I compleatly fine with the fixnum declaration. We just need to make sure it is a rule programmers can rely on. Consider: )abbrev package ITER Iter Iter(): E == I where E == with iter: () -> Void I == add iter(): Void == for i in 2.. repeat print(i::OutputForm) The relavent lisp decalres we are using fixnums: (LETT |i| (QSADD1 |i|) |ITER;iter;V;1|) Now compile the above with a lower bound of 3: for i in 3.. repeat print(i::OutputForm) We get generic arithmetic: (LETT |i| (+ |i| 1) |ITER;iter;V;1|) Baffled, Steve Integer substitutions --Mon, 17 Jan 2005 21:24:41 -0600 > ... >PRIMELT > > The differences in the generated lisp are w.r.t QSADD1, in compiler > generated code implementing a for loop. The differences look like: > > - (LETT |i| (+ |i| 1) > + (LETT |i| (QSADD1 |i|) > > In primitiveElement, we use a for loop on `i in 10..'. i is passed to > symmetricRemainder, defined in IntegerNumberSystem with signature: > > primitiveElement(%,%). > > The call site takes the form primitiveElement(Integer, i), so we would > expect that i should have type integer. Looking at the generated lisp > for integer we see that QSADD1 is not on the property list for any > function, but it is on the property list for SINT's `inc' function. > > Note the definition of QSADD1 in vmlisp.lisp: > > (defmacro qsadd1 (x) `(the fixnum (1+ (the fixnum ,x)))) > > How does the compiler know on the second-iteration build that `i' will > always be a fixnum? Though probably correct 99% of the time, the > second-iteration code in this case is incorrect. I don't understand the mechanism that makes this substitution but in what sense is it incorrect. Can you give an example that might apply the other 1% of the time? Do you mean because the magnitude could exceed fixnum? more questions --Tue, 18 Jan 2005 23:05:23 -0600 On Tuesday, January 18, 2005 7:28 AM Tim Daly wrote: > ... > Suppose VECTOR.spad used something from SINT.spad. When the > VECTOR.lsp BOOTSTRAP file is compiled by depsys it contains > (+ ... ...) and generates untyped and unoptimized code. > > Later when VECTOR.spad is compiled and SINT.o is available > then the spad compiler will use the optimization information > to generate (QSADD1 ... ...) > So you are saying that the type information derived from the object files `A_i' files on which some code X depends can affect the actual code generated library file X because the compiler attempts optimizations based on this information. The bootstrap lisp files do not currently have any type information, therefore any library file that depends on a bootstrap file (quite a large number) might not be optimized during the initial build. The bootstrap files themselves are re-compiled from the spad sources but of course by then it is too late for any other library file that has already been compiled. After the first iteration of fixedPoint all of the library files have been re-compiled using object files that do have type information, so now everything is optimized as expected. Your argument is that the missing optimizations are not that critical because the "mathematics" is still correct. It is just that the generated code is less than optimal. Right? But on Monday, January 17, 2005 9:38 PM Stephen Wilson wrote > > On Mon, Jan 17, 2005 at 09:09:12PM -0500, Page, Bill wrote: > > I wonder if both are necessary or is it only the change in > > interpsys? > > The bootstrap code does influence the generated code for RECLOS > and ROIRC (SINT's missing `one?' is showing up here). > > We know the bootstrap code is out of sync, so it would probably > be a good idea to refresh it. Note that when I built a system > with fresh bootstrap code, even though the generated lisp code > was the same save for RECLOS and ROIRC, I did notice differences > in how domains vectors were being instantiated at runtime (the > vectors had the same layout, just that the runtime lookup of > certain functions was proceeding differently). Steve says that the code for `one?' was missing for SINT.lsp Is this because it was coded as "onep$lisp" in the original spad sources? I guess the actual symbols occurring in the bootstrap lisp code would contain "hard coded" domain vector `;offsets' as part of their names, corresponding to the old coding of onep$lisp. But after SINT is recompiled from the new spad code, the previous hardcoded offsets of any function appearing after `one?' would become incorrect in any bootstrap function that depends on SINT but was re-compiled before SINT. Presumably this could lead to subtle (or not so subtle) run- time errors. In other words, we have to be very careful of the order in which we re-compile the bootstrap from the spad code. If there are cyclic dependencies among the bootstrap files (I think there are) then we are in trouble. Of have I still got this wrong? My understanding of how the compiler assigns and uses domain table offsets remains very unclear to me. yet another wrinkle --Tue, 18 Jan 2005 23:06:43 -0600 Tim, I believe I understand the process by which optimized versions of the bootstrap files are produced. However, I think that many of the differences in the code we are seeing are not due to this process. The fixed point build is causing the interpsys image to be rebuilt. These images are different: -rwxr-xr-x 1 steve steve 15858720 2005-01-06 05:29 interpsys1 -rwxr-xr-x 1 steve steve 16645152 2005-01-07 21:42 interpsys2 and they generate different code. Consider the following simple package: )abbrev package Foo Foo Foo(): E == I where E == with bar: () -> Void I == add SI ==> SingleInteger sint : SI := 2::SI bar(): Integer == for j in 3.. repeat print(i::OutputForm) When compiled using both images, with the same $AXIOM environment (so we know the images are seeing the same algebra) we get these basic differences: 1) In iteration over the for loop, generic stepping code is replaced with fixnum arith 2) Trivial coercions to SINT's coerce(Integer):% are being inlined. In wi1.boot we see an improved version of compCoerce. Likewise in wi2.boot we see an improved version of compIterator. The improved version of compIterator makes explicit attempts to decide when fixnum arith should be generated for stepping code (a higher-level attempt then the quick hack found in the definition of -REPEAT in macros.lisp, see a previous email). My feeling is that somehow the new versions of these functions have been loaded into the image in the second pass. ONEP removed globally --Sat, 22 Jan 2005 02:53:21 -0600 The ONEP change is mine. ONEP is a CCL function, not a common lisp function. The question that needs to be answered in order to implement ONEP in common lisp is what is the representation of '1' in various domains? Notice that in a domain 'foo = 1' is a spad way of asking the question. This used to be the way it was done but NAG changed it in the CCL implementation (probably for efficiency). Since I couldn't decide what the exact semantics of ONEP are I took the safest route. additional information --Mon, 24 Jan 2005 21:14:01 -0600 =============================================================================================== I have built first-iteration and second-iteration axioms. An identical fixedPoint.log was produced. I have been examining the domain vectors, trying to find some clues. I failed to spot a difference in two domains; BINFILE in files.spad, and PRIMELT in primelt.spad. Indeed, for PRIMELT note that: ============================================================================== (1) -> )lisp (setq |$DALYMODE| t) Value = T (1) -> (trace |eval|) Value = (|eval|) (1) -> PF ==> PrimeField 5 Type: Void (2) -> VPF ==> Vector PF Type: Void (3) -> vec : VPF := [0, 1, 2, 3, 4] (3) [0,1,2,3,4] Type: Vector PrimeField 5 (4) -> inv(vec)$INBFF(PF) 1> (|eval| (|InnerNormalBasisFieldFunctions| (|PrimeField| 5))) <1 (|eval| #<vector 08df6888>) 1> (|eval| #<vector 08df6888>) <1 (|eval| #<vector 08df6888>) 1> (|eval| (SPADCALL (QUOTE #<vector 08db9428>) (QUOTE (#<compiled-function |INBFF;inv;2V;1|> . #<vector 08df6888>)))) >> Error detected within library code: index out of range protected-symbol-warn called with (NIL) ============================================================================== This happens in both builds. Im assuming at the moment the domain vector is being indexed improperly (as opposed to the `vec' argument). I'll look into this further. I have not tested BINFILE to see if a similar problem is occurring there is well. I have attached the notes I have made while examining the domain vectors. They show what commands I used to get the domain vectors, followed by a snip of the vectors where I noticed a difference. I have yet to trace FORTRAN, fortran.spad. Generally, the domain vectors below are changing w.r.t dependencies on SingleInteger, or Integer. I feel that looking at the build w.r.t these two domains would be a good direction for future investigations. Sorry this message is so terse, but I am in a bit of rush at the moment. I'll be able to reenter this issue later today. Sincerely, Steve [ notes ] files.spad, BINFILE identical primelt.spad, PRIMELT identical ------------------------------------------------------------------- --- First iteration, pattern.spad, PATTERN (1) -> (pspadvec (|evalDomain| '(|Pattern| (|PrimeField| 5)))) ... 30: (Union 56 (QUOTE failed)) 31: (#<compiled-function PATTERN;isPlus;$U;10> . #<vector 09089f50>) 32: (SingleInteger) 33: (newGoGet #<vector 09089f50> 14 . coerce) 34: (#<compiled-function PATTERN;isTimes;$U;11> . #<vector 09089f50>) 35: (#<compiled-function PATTERN;isList;$U;12> . #<vector 09089f50>) ... ------------------------------------------------------------------- --- Second iteration, pattern.spad, PATTERN (1) -> (pspadvec (|evalDomain| '(|Pattern| (|PrimeField| 5)))) ... 30: (Union 54 (QUOTE failed)) 31: (#<compiled-function PATTERN;isPlus;$U;10> . #<vector 08fa201c>) 32: (#<compiled-function PATTERN;isTimes;$U;11> . #<vector 08fa201c>) 33: (#<compiled-function PATTERN;isList;$U;12> . #<vector 08fa201c>) 34: (Record (: val $) (: exponent 26)) 35: (Union 34 (QUOTE failed)) ... ------------------------------------------------------------------- --- First iteration, d01agents.spad, D01AGNT (1) -> (pspadvec (|evalDomain| '(|d01AgentsPackage|))) ... 59: (#<compiled-function LIMITPS;limit;FEEU;24> . #<vector 090337a8>) 60: (#<compiled-function ORDCOMP;finite?;$B;3> . #<vector 08f2d6e4>) 61: (SingleInteger) 62: (newGoGet #<vector 08ec2f88> 117 . coerce) 63: (#<compiled-function SEG;hi;$S;4> . #<vector 08e96c78>) 64: (newGoGet #<vector 08ec2f88> 127 . whatInfinity) ... ------------------------------------------------------------------- --- Second iteration, d01agents.spad, D01AGNT (1) -> (pspadvec (|evalDomain| '(|d01AgentsPackage|))) ... 59: (#<compiled-function LIMITPS;limit;FEEU;24> . #<vector 09008e00>) 60: (#<compiled-function ORDCOMP;finite?;$B;3> . #<vector 08efb94c>) 61: (#<compiled-function SEG;hi;$S;4> . #<vector 08ca0c40>) 62: (SingleInteger) 63: (newGoGet #<vector 08b85834> 122 . whatInfinity) 64: (#<compiled-function SEG;lo;$S;2> . #<vector 08ca0c40>) ------------------------------------------------------------------- --- First Iteration, fortran.spad, FC (1) -> (pspadvec (|evalDomain| '(|FortranCode|)) 1) ... 7: (Integer) 8: <vector> : 0: (SingleInteger) 1: (#<compiled-function lookupComplete> #<vector 08d60a80> #<vector 08d60b0c>) ... ... 9: (#<compiled-function SINT;coerce;I$;51> . #<vector 08d60a80>) 10: 25000 11: (#<compiled-function FC;setLabelValue;2Si;1> . #<vector 08d5ce38>) 12: (Polynomial 7) 13: (newGoGet #<vector 08d5ce38> 5 . One) ... ------------------------------------------------------------------- --- Second Iteration, fortran.spad, FC (1) -> (pspadvec (|evalDomain| '(|FortranCode|))) ... 7: 25000 8: (SingleInteger) 9: (#<compiled-function FC;setLabelValue;2Si;1> . #<vector 08ce9ab8>) 10: (Polynomial 13) 11: (newGoGet #<vector 08ce9ab8> 0 . One) 12: (String) 13: (Integer) ... ------------------------------------------------------------------- --- First iteration, ffnb.spad, INBFF (1) -> (pspadvec (|evalDomain| '(|InnerNormalBasisFieldFunctions| (|PrimeField| 5))) 1) ... 16: 1 17: (Integer) 18: <vector> : 0: (SingleInteger) 1: (#<compiled-function lookupComplete> #<vector 08d60a80> #<vector 08d60b0c>) 19: (#<compiled-function SINT;coerce;I$;51> . #<vector 08d60a80>) 20: (0 10 16 20 23 0 28 30 32 0 35) 21: (NIL (4 12 48 160 480 0) (8 72 432 0) (18 216 0) (32 480 0) NIL (72 0) (98 0) (128 0) NIL (200 0)) 22: (Vector 6) ... ------------------------------------------------------------------- --- Second iteration, ffnb.spad, INBFF (1) -> (pspadvec (|evalDomain| '(|InnerNormalBasisFieldFunctions| (|PrimeField| 5))) 1) ... 16: 1 17: (0 10 16 20 23 0 28 30 32 0 35) 18: (NIL (4 12 48 160 480 0) (8 72 432 0) (18 216 0) (32 480 0) NIL (72 0) (98 0) (128 0) NIL (200 0)) 19: (Integer) 20: <vector> : 0: (SingleInteger) 1: (#<compiled-function lookupComplete> #<vector 08ce96ac> #<vector 08ce9c94>) 21: (newGoGet #<vector 08e96b0c> 14 . coerce) 22: (Vector 6) ... ------------------------------------------------------------------- --- First iteration, omdev.spad, OMENC (1) -> (pspadvec (|evalDomain| '(|OpenMathEncoding|))) ... 7: (Boolean) 8: (#<compiled-function OMENC;=;2$B;1> . #<vector 08e1a594>) 9: (Integer) 10: (newGoGet #<vector 08e1a594> 0 . coerce) 11: (OutputForm) 12: (#<compiled-function OMENC;coerce;$Of;2> . #<vector 08e1a594>) ... ------------------------------------------------------------------- --- Second iteration, omdev.spad, OMENC (1) -> (pspadvec (|evalDomain| '(|OpenMathEncoding|))) ... 7: (Boolean) 8: (#<compiled-function OMENC;=;2$B;1> . #<vector 08e9ca48>) 9: (OutputForm) 10: (#<compiled-function OMENC;coerce;$Of;2> . #<vector 08e9ca48>) 11: (#<compiled-function OMENC;OMencodingUnknown;$;3> . #<vector 08e9ca48>) 12: (#<compiled-function OMENC;OMencodingBinary;$;4> . #<vector 08e9ca48>) ... ------------------------------------------------------------------- --- First iteration, ffcg.spad, FFCGP --- --- NOTE: vector element 147 (1) -> (pspadvec (|evalDomain| '(|FiniteFieldCyclicGroupExtensionByPolynomial| (|PrimeField| 5) ((1 . 0))))) ... 12: 1 13: (#<compiled-function ZMOD;size;Nni;1> . #<vector 08e1a8f8>) 14: 5 15: (PositiveInteger) 16: (#<compiled-function SGROUP-;**;SPiS;1> . #<vector 08e72f34>) 17: NIL ... ... 144: (#<compiled-function FFCGP;/;$GF$;39> . #<vector 08e72fa4>) 145: (#<compiled-function FFCGP;inv;2$;40> . #<vector 08e72fa4>) 146: (#<compiled-function FFCGP;**;$I$;43> . #<vector 08e72fa4>) 147: (#<compiled-function FFCGP;**;$Pi$;41> . #<vector 08e72fa4>) 148: (#<compiled-function FFCGP;**;$Nni$;42> . #<vector 08e72fa4>) 149: (Union 71 (QUOTE failed)) 150: (Matrix $) ... ------------------------------------------------------------------- --- Second iteration, ffcg.spad, FFCGP --- --- NOTE: vector element 147 above is element 16 here. (1) -> (pspadvec (|evalDomain| '(|FiniteFieldCyclicGroupExtensionByPolynomial| (|PrimeField| 5) ((1 . 0))))) ... 12: 1 13: (#<compiled-function ZMOD;size;Nni;1> . #<vector 08e9cdac>) 14: 5 15: (PositiveInteger) 16: (#<compiled-function FFCGP;**;$Pi$;41> . #<vector 08e9c7fc>) 17: (#<compiled-function SGROUP-;**;SPiS;1> . #<vector 08e9c674>) ... ... 144: (newGoGet #<vector 08e9c7fc> 284 . /) 145: (#<compiled-function FFCGP;/;$GF$;39> . #<vector 08e9c7fc>) 146: (#<compiled-function FFCGP;inv;2$;40> . #<vector 08e9c7fc>) 147: (#<compiled-function FFCGP;**;$I$;43> . #<vector 08e9c7fc>) 148: (#<compiled-function FFCGP;**;$Nni$;42> . #<vector 08e9c7fc>) 149: (Union 72 (QUOTE failed)) 150: (Matrix $) ... ------------------------------------------------------------------- --- First iteration, reclos.spad, RECLOS (1) -> (pspadvec (|evalDomain| '(|RealClosure| (|Fraction| (|Integer|))))) ... 88: (newGoGet #<vector 08e72b44> 184 . *) 89: (newGoGet #<vector 08e72b44> 190 . one?) 90: (Mapping $$ $$) 91: (newGoGet #<vector 08e72b44> 195 . map) 92: (#<compiled-function RECLOS;*;I2$;23> . #<vector 08e72b44>) 93: (newGoGet #<vector 08e72b44> 201 . *) 94: (newGoGet #<vector 08e72b44> 207 . zero?) 95: (newGoGet #<vector 08e72b44> 212 . one?) ... ------------------------------------------------------------------- --- Second iteration, reclos.spad, RECLOS (1) -> (pspadvec (|evalDomain| '(|RealClosure| (|Fraction| (|Integer|))))) ... 88: (newGoGet #<vector 08e9c2a0> 184 . *) 89: (Mapping $$ $$) 90: (newGoGet #<vector 08e9c2a0> 190 . map) 91: (#<compiled-function RECLOS;*;I2$;23> . #<vector 08e9c2a0>) 92: (newGoGet #<vector 08e9c2a0> 196 . *) 93: (newGoGet #<vector 08e9c2a0> 202 . zero?) 94: (newGoGet #<vector 08e9c2a0> 207 . one?) 95: (#<compiled-function RECLOS;*;TheField2$;24> . #<vector 08e9c2a0>) ... ------------------------------------------------------------------- --- First iteration, reclos.spad, ROIRC (1) -> (pspadvec (|evalDomain| '(|RightOpenIntervalRootCharacterization| (|PrimeField| 5) (|SparseUnivariatePolynomial| (|PrimeField| 5))))) ... 50: (newGoGet #<vector 08e72770> 140 . boundOfCauchy) 51: (newGoGet #<vector 08e72770> 145 . sturmVariationsOf) 52: (newGoGet #<vector 08e72770> 150 . one?) 53: (List 7) 54: (newGoGet #<vector 08e72770> 155 . sturmSequence) 55: (newGoGet #<vector 08e72770> 160 . unitCanonical) ... ------------------------------------------------------------------- --- Second iteration, reclos.spad, ROIRC (1) -> (pspadvec (|evalDomain| '(|RightOpenIntervalRootCharacterization| (|PrimeField| 5) (|SparseUnivariatePolynomial| (|PrimeField| 5))))) ... 50: (newGoGet #<vector 08e9cfc0> 140 . boundOfCauchy) 51: (newGoGet #<vector 08e9cfc0> 145 . sturmVariationsOf) 52: (List 7) 53: (newGoGet #<vector 08e9cfc0> 150 . sturmSequence) 54: (newGoGet #<vector 08e9cfc0> 155 . unitCanonical) 55: (newGoGet #<vector 08e9cfc0> 160 . numberOfMonomials) ... additional information --Mon, 24 Jan 2005 21:15:23 -0600 =================================================================================================== No, NONE of the files with changes in the lisp code on the 1st iteration are on the bootstrap list. Here's the list: > --- int/algebra/BINFILE.lsp Thu Jan 6 22:22:55 2005 > +++ int/algebra/BINFILE.NRLIB/code.lsp Thu Jan 6 23:09:32 2005 > --- int/algebra/D01AGNT.lsp Thu Jan 6 22:22:57 2005 > +++ int/algebra/D01AGNT.NRLIB/code.lsp Fri Jan 7 00:23:04 2005 > --- int/algebra/FC.lsp Thu Jan 6 22:23:00 2005 > +++ int/algebra/FC.NRLIB/code.lsp Thu Jan 6 23:59:50 2005 > --- int/algebra/FFCGP.lsp Thu Jan 6 22:23:01 2005 > +++ int/algebra/FFCGP.NRLIB/code.lsp Thu Jan 6 23:39:00 2005 > --- int/algebra/FORTRAN.lsp Thu Jan 6 22:23:02 2005 > +++ int/algebra/FORTRAN.NRLIB/code.lsp Fri Jan 7 00:00:23 2005 > --- int/algebra/INBFF.lsp Thu Jan 6 22:23:04 2005 > +++ int/algebra/INBFF.NRLIB/code.lsp Fri Jan 7 00:23:21 2005 > --- int/algebra/OMENC.lsp Thu Jan 6 22:23:10 2005 > +++ int/algebra/OMENC.NRLIB/code.lsp Thu Jan 6 22:49:46 2005 > --- int/algebra/PATTERN.lsp Thu Jan 6 22:23:11 2005 > +++ int/algebra/PATTERN.NRLIB/code.lsp Thu Jan 6 23:45:01 2005 > --- int/algebra/PRIMELT.lsp Thu Jan 6 22:23:13 2005 > +++ int/algebra/PRIMELT.NRLIB/code.lsp Thu Jan 6 23:45:25 2005 > --- int/algebra/RECLOS.lsp Thu Jan 6 22:23:14 2005 > +++ int/algebra/RECLOS.NRLIB/code.lsp Thu Jan 6 23:45:39 2005 > --- int/algebra/ROIRC.lsp Thu Jan 6 22:23:14 2005 > +++ int/algebra/ROIRC.NRLIB/code.lsp Thu Jan 6 23:28:06 2005 > There are subtle semantic differences (not formatting differences) in all of the above files. But yes ALL of the original bootstrap .lsp files from the pamphlet files *are* outdated in the sense that they appear to have been produced by a very different version of Axiom (or maybe even hand-compiled in some cases?). The lisp code produced by AXIOM from the spad files corresponding to the bootstrap files (which is done as the last step in the Algebra build) is formatted very differently than the original bootstrap lisp code. A diff of the original bootstrap files shows them as entirely different although a quick inspection shows that the semantic content is at least VERY SIMILAR to what Axiom produces for these files. In my fixedPoint script, I do not bother to show the initial differences of the bootstrap files after only the first build - they are all different (different variable names, pretty printing etc.) Only a hand-analysis could determine how different they really are. And of course at this first step it is not possible to compare any of the non-bootstrap files because we do not have any lisp files other than those for the bootstrap. What I do show in the fixedPoint.log file is the result AFTER first replacing the bootstrap lisp files with the newly generated lisp for ALL of the SPAD files and then running the make a 2nd time (I called this the 1st iteration). This is where I find differences in the generated lisp code in the 2nd pass compared the lisp code from the first pass. None of these differences are in the original bootstrap files. In this comparison the none of the original bootstrap code is still present. It had all been replaced with newly generated code in the previous step and did not change in the 2nd step. However other files (non-bootstrap files) did change. This is why I say that the differences in the original bootstrap files seem to have "propagated along the dependencies" to some of the files that directly depend on the bootstrap files. This is what really had me worried. In spite of the fact that the original bootstrap files are out of date, I did (more or less) expect from your description of the process that on the 2nd pass with all newly generated lisp files, that the next generation of lisp files would not change, but they do. On the 3rd pass, finally all of the lisp files match with the lisp files from the 2nd pass. (I called this the "fixed point" since no further change can take place after that.) If I were to replace all of the bootstrap lisp code in the current pamphlet files with the newly generated lisp code then it seems likely (unless I am missing something rather basic) that the build should immediately converge to the fixed point on the first pass. This is, of course what we should do in the SHORT TERM. But the longer term question for me is: Do changes in the spad files really propagate like this from one file to the next in the dependency chain? If the answer is yes, then this means that every time we make a change in ANY of the algebra spad files (not just the spad files that have bootstrap lisp code), then we will have to run the fixedPoint script in order to make sure that we have new bootstrap lisp code that is consistent with the spad code (the system of spad and lisp files must "converge"). We need to do this because the dependencies are really cyclic - they really do loop back on themselves. So changes deeper down in the "lattice" (not really a lattice) can potentially propagate back around to the bootstrap lisp code. additional information --Mon, 24 Jan 2005 21:16:48 -0600 ============================================================================================== Although technically it probably doesn't matter, but as far as I can tell from the email archives, the version of the databases that we have been using on Savannah was actually supplied by Jergen Weiss after he was the first to successfully build the full set of Axiom spad files under GCL in about August 2003.. The problem with compiling some of the spad files up until that point was apparently that the database files from the NAG version that you had been using were somehow incompatible with GCL. I think Jergen actually obtained the original database files that he used to bootstrap GCL from some other version of Axiom (based on a different lisp, CMCL?). He was then able to build a new set of databases directly using the GCL version of AXIOM. In about September 2003 on your request I uploaded these database files to the Savannah CVS. As far as I know, these are still the same ones we are using today unless you replaced them again at some point. The minor differences that I saw between the most recently built database files and the ones that Jergen built was probably due to one or two addition spad files that were missing from Jergen's build. In any case, this does not seem to be the reason for the "propagation" of changes in the *.lsp files. Regards, Bill Page. > -----Original Message----- > From: root [address@bogus.example.com">mailto:address@bogus.example.com > Sent: Friday, January 07, 2005 10:53 AM > To: address@bogus.example.com; address@bogus.example.com > Cc: address@bogus.example.com > Subject: Re: [Axiom-developer] RE: algebra Makefiles with > explicit dependencies, bootstrap, fixed-points etc. > > > Bill, Steve, > > Note that the original databases are the NAG versions and the actual > algebra code has been improved since that time. Modifying the algebra > will change the domain vectors. These vectors contain hard-coded > indexes. So, for instance, PLEQN is new since NAG's version so the > domains which use it will have different index values. The database > build is done after the algebra is compiled and should reflect the > actual algebra whereas the original databases may not. > > t > axiom of a field --unknown, Thu, 16 Jun 2005 00:45:59 -0500 ... --kratt6, Fri, 28 Dec 2007 14:45:39 -0800 Category: Axiom Mathematics => building Axiom from source ... --test1, Tue, 15 Apr 2014 17:06:35 +0000 Status: open => closed