Barry Margolin wrote:
> Probably the most significant distinguishing feature of Lisp Machines
is
> their support for type dispatching. When you invoke an arithmetic
> operator, the data is fed in parallel to the fixnum unit and the
> floating-point co-processor, and in parallel with this the microcode
> checks the type tags. It then either latches the result register
from
> the appropriate hardware unit, or traps out to a software function
that
> handles all the other types.
This kind of technique should be eminently implementable on modern
CPUs, which generally have more execution units than they know what to
do with and speculative execution. I think the problem with the naive
approach - generate conditional code for all the possibilities, which
the processor would then speculatively execute until it knew the result
of the type test - would be code bloat, but I'm not sure that is a real
problem. I guess that compiler implementors for modern machines
(Duane? The CMUCL-related-implementation people?) could comment more
knowledgably.
My impression is that modern CPUs *are* lisp machines in the sense that
they have parallel type checking units and so forth. These units
happen to be general-purpose ALUs rather than special-purpose units,
but this is a good thing, as it means that the unit is still useful if
you have a compiler which can optimise type checks away in many cases.
Of course there were other things that Lisp CPUs did: fixnums being
less than 32 bits always bugs me on stock HW.
--tim
···········@tfeb.org" <··········@tfeb.org> writes:
> Of course there were other things that Lisp CPUs did: fixnums being
> less than 32 bits always bugs me on stock HW.
Don't you mean 36 bits? ;)
--
Rahul Jain
·····@nyct.net
Professional Software Developer, Amateur Quantum Mechanicist
Rahul Jain <·····@nyct.net> writes:
> ···········@tfeb.org" <··········@tfeb.org> writes:
>
> > Of course there were other things that Lisp CPUs did: fixnums being
> > less than 32 bits always bugs me on stock HW.
>
> Don't you mean 36 bits? ;)
Save the uninteresting exception of the LM-2, fixnums were 32-bits on
every Symbolics Lisp Machine. Machines from other vendors had much
smaller fixnums (24 or 25 bits).