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

Re: inline floating point for ds 3100

bachrach@gluttony.cs.umass.edu writes:

	I'm not able to get franz common lisp 3.1 beta to produce inline
	floating point for the decstation 3100 (specifically for the fft
	benchmark), but am able to get 3.1 beta to produce inline floating
	point for the sun3.  Is there a newer version of franz common lisp
	that will produce inline floating point for the ds 3100? Does the
	latest version of franz common lisp for sparcStations produce inline
	floating code?

Allegro CL on the DecStation 3100 does inline floating-point
code and does use the floating-point accelerator chip if their
is one.  In order for code to be inlined, it must contain
the proper declarations and the values of speed and safety
must be appropriate (as described in chapter 7 of the
Allegro CL User Guide).  As we said in an earlier private note
to bachrach (which perhaps he didn't receive??), we would need
more information about his code to determine why the functions
aren't inlining properly.
Information on newer releases should be directed to the
marketing department of Franz Inc. (info@franz.com).  We do
not publish release dates on public lists.  However, the
floating point behavior will not differ in the next release
(it will, as does the current release, inline properly
declared floing-point functions.)

Allegro CL on the Sun 4 and SparcStation also inlines
floating point code and uses the floating-point

	Is there any chance that your implementation will ever be able to
	return floats without producing garbage?

This is a more complex question.  A floating-point function
called at the top-level (e.g. (sin 1.0)) will return a
floating-point lisp object, called a boxed float.  Along
with the value, this object contains a type code and some
other information used within Lisp.  The creation of a boxed
float necessarily results in the creation of some garbage,
therefore.  However, boxed floats are (typically) only
created when needed, e.g. when a float is stored as the
value of a global variable or returned from a function
called at the top-level.  Certain coding techniques (for
example, not calling floating-point functions at the
top-level and not setting the values of global variables to
floats) suppresses boxing and reduces or eliminates the
garbage created by floating-point calls.  Macros are also
useful in reducing boxing.

It is difficult to say more without specific code examples.
Unless we have some idea of what a user has tried and how
Allegro CL acts differently from what is desired, we cannot
do more than speak in a very general way.  Users who are not
seeing the behavior they want on specific pieces of code can
ask us for advice by sending a description of their problem
(preferably with small code samples which illustrate it) to

David Margolies
Franz Inc.