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

optimization in the spec

In the latest draft of the spec, there are several places which
explicitly address legal optimizations an implementation might perform.
I find these somewhat confusing, and I think that instead we might want
to do the following:

  1- Have an general, well worked out statement about what kinds of
     optimization are legal in CLOS implementations.  This statement
     would be 'the optimization law'.
  2- Have an appendix or implementation notes in the document reflecting
     places in the design where the intent was to allow optimizations
     that are in accordance with the 'the optimization law'.

As a start on this, here is a first crack on the law.

In order to insure program portability, there are strict rules which
must be followed when doing optimization of CLOS implementations.  The
rules governing when error checking and signalling can be optimized away
have already been covered.  Except where it is explicitly stated that
under certain compilation conditions it is permissible not to signal an
error, the rule governing optimizations is that no optimization can
change the behavior of a program.  All optimizations must preserve the
semantics of the CLOS.

  Examples of legal optimizations include:

    Where the system can determine what methods will be called for a
particular invocation of a generic function, it might compile out the
method lookup.

    Where methods have been declared inline (whatever that means) or are
system supplied methods, the system might compile calls (like the one
above) out entirely.

This is just rough, but I hope you can see what I am trying to capture.
That is that I am trying to make it clear that except where we say so
explicitly, a program can be sure that optimizations won't have weird
semantics.  For example, the current text that talks about optimizing
initarg defaulting makes it sound like I could write a program which
could tell that some initarg defaulting had been optimized out.  We need
to make it clear that no user program will be able to detect
optimization (except for the stuff about an error should be signalled).