9 ms·

Lisp Machine Inc. K-machine (2001)

114 points by mepian 8y ago

jf 8y ago
The site appears to be down, here is the most recent copy available on the Wayback Machine: https://web.archive.org/web/20181123210702/http://fare.tunes.org/tmp/emergent/kmachine.htm https://web.archive.org/web/20181123210702/http://fare.tunes...
pmoriarty 8y ago
I wonder if a kickstarter to create a new Lisp Machine could work. I envision something like a Raspberry Pi, but with the hardware designed to run Lisp, and taking inspiration from the original Lisp Machines.
- eigenspace 8y ago
  I imagine that the hard part is probably not making a lisp machine but making what made the lisp machines so special: it's software and tooling. My understanding is that the tooling available on lisp machines was so good it made emacs look rigid and dumb. I'd imagine that reacreating such tooling would take more man hours that building the lisp machine and its kernel but I don't know.
  - rjsw 8y ago
    You could start with the old software, the MIT tree has been released. I have copies of the final LMI software including the K-machine stuff. The software wasn't dumb, there was just a lot less of it. They didn't have IPv6, SSL, a web browser ... One halfway house would be a Lisp unikernel.
  - mepian 8y ago
    Perhaps the open-sourced software for the original MIT CADR Lisp machine could be used as the starting point: https://github.com/mietek/mit-cadr-system-software https://github.com/mietek/mit-cadr-system-software
  - pinewurst 8y ago
    An LMI Lambda (shipped 1st gen machine that was an evolved MIT CADR) emulator is at: https://github.com/dseagrav/ld https://github.com/dseagrav/ld
- mepian 8y ago
  Andreas Olofsson and his team at Adapteva have demonstrated that it's possible for a small experienced team to design and launch a niche processor and a single-board computer board similar to the Raspberry Pi around it within a relatively small (less than 5 million USD) budget, and they even used Kickstarter to fund the later iterations: https://en.wikipedia.org/wiki/Adapteva https://en.wikipedia.org/wiki/Adapteva
- tyingq 8y ago
  There was this in 2014: https://news.ycombinator.com/item?id=8340283 https://news.ycombinator.com/item?id=8340283
  - pmoriarty 8y ago
    That's interesting, and I wonder if it ever went in to production, and if so how many units were sold. Unfortunately, it seems to have been based around PicoLisp, which isn't exactly a popular Lisp implementation. I expect that for any project like this to get wide traction in the Lisp community, it would have to be based around Common Lisp, as that's by far the most popular Lisp out there, with a huge existing ecosystem it could leverage -- an advantage akin to basing the Raspberry Pi around Java.
    - cellularmitosis 8y ago
      Speaking of which, a hardware JVM would also mean clojure on the metal :)
      - lispm 8y ago
        if the JVM would have been implemented in Clojure and all the other stuff, too. Already the Clojure compiler is not written Clojure, but Java. The JVM also for example has no TCP stack on its own, it interfaces the OS - which then is written in C/C++.
        rjsw 8y ago
        An example of a Java Machine is JOP [1], it has a TCP/IP stack and is a microcoded architecture too. [1] https://www.jopdesign.com/ https://www.jopdesign.com/
        lispm 8y ago
        Right, the JavaOS from SUN would also count: https://en.wikipedia.org/wiki/JavaOS https://en.wikipedia.org/wiki/JavaOS http://www.eecg.toronto.edu/~stumm/teaching/ece1759/javaos/javaos.html http://www.eecg.toronto.edu/~stumm/teaching/ece1759/javaos/j...
- sifoobar 8y ago
  Sorry, you can't sell Lisp. Maybe once upon a time that was possible, but those days are gone. And Lispers generally are a whiny, creaky bunch to deal with; me included. Pleasing that crowd is a serious undertaking. I sometimes try to imagine a world where these things took off, but the closest thing I've touched is Emacs and I'm pretty sure that's not what they had in mind.
  - dleslie 8y ago
    I would buy a Lisp machine, provided that I could afford it. That proviso was the undoing of them, IMHO.
  - jolmg 8y ago
    I would also buy a Lisp Machine, provided I could afford one. I'm really interested to see this software environment that I've heard spoken so highly of. What I've understood so far of it sounds amazing.
    - rjsw 8y ago
      Try one of the emulators.
    - jacquesm 8y ago
      Wait another hundred years and it will be close to magical. We have the collective habit of ascribing great properties to old technologies while bitching about the technologies we have today. I'm certainly no exception here, but the fact is that if it really was that good it likely would have won in the marketplace. Nostalgia is a powerful agent of deception.
      - armitron 8y ago
        You should definitely read 'Worse is Better' by Richard Gabriel if you truly believe that the marketplace is the final arbiter of what is really good. Hint: It's not. In order to see how important and iconoclastic (nevermind good) the Lisp Machine paradigm is, examine the trickle-down effect that it put in motion. There are popular IDEs today that are only _just beginning_ to integrate concepts from that paradigm. The Lisp Machines were so far ahead of their time, so visionary, that it will take decades if not centuries for the consensus to catch up to what they represented.
- lispm 8y ago
  If you have a Raspberry Pi, you have already all the hardware to run Lisp. There is very little reason to develop special hardware. Lisp runs nicely on an ARM processor. Actually some the first ARM processors were supposed to run a Lisp operating system. When Apple did the research&development for the Apple Newton, they originally attempted to run a Lisp-like system on mobile systems like PDAs and tablets. This Lisp dialect was derived mostly from Scheme and Common Lisp - the language was eventually called Dylan. Apple had ARM systems in their lab which ran a Dylan OS. When they at one point chose the ARM processor, Apple invested in ARM and they used a chip which was able to support a garbage collected language. Unfortunately these Lisp operating systems by Apple did not reach the market and Apple instead sold the Apple Newton with an OS kernel written in C++ and the software on top written and scripted in NewtonScript - a language with many aspects from Lisp - incl. garbage collection.
  - AnimalMuppet 8y ago
    Could you explain what you mean by a "Lisp operating system"? I understand the idea of Lisp as a language, but what does Lisp as an OS mean?
    - lispm 8y ago
      Historically it's an operating system written in Lisp, typically running as a Lisp runtime+image on the metal. Itself providing memory management, interrupt handling, process scheduling, network I/O, graphics, keyboard, mouse, windows, applications ... and everything else a typical OS provides. For a recent attempt see: https://github.com/froggey/Mezzano https://github.com/froggey/Mezzano
      - AnimalMuppet 8y ago
        Is there any advantage to that over a generic OS? I have not, in general, cared what language my OS was written in.
        white-flame 8y ago
- peter303 8y ago
  Custom hardware language machines fall behind firmware on general purpose CPUs because the latter have an order of magnitude faster hardware releases. There were all kinds of clever architectures coming out in the 1980s- LISP machines, prolog computers, Masspar, Thinking Machine, etc. The first release tended to be economically competitive. But the next release 3 to 5 years later fell behind Moores law.
  - bitwize 8y ago
    Not only that, but Lisp compiler technology improved to further narrow the gap between Lisp on Lisp Machine and Lisp on generic CPU.
- protomyth 8y ago
  It would probably be a better step to approach whoever owns one of the Lisp OSes, buy it with a fund raiser, and put it under an MIT license. Then go for custom hardware if needed.
- segmondy 8y ago
  Nah, that would a very wrong approach. If you want any chance, a Lisp machine needs to run on current OS. It needs to run on Linux, Windows, OSX. It's very easy to run on any OS, besides VM, we have seen linux subsystems for windows, ios, windows call on linux. And even user land kernel with gVisor, so build it on current OS.
- krylon 8y ago
  I don't think a Lisp machine would make much sense these days, as far as the hardware is concerned. Designing and building CPUs is very expensive, and the small market for such a machine would make them prohibitively expensive. But an operating system built around the idea could be quite interesting. From what I know, the systems running on the Lisp machines of the 1980s were nightmares from a modern security perspective. But the idea of having a closely integrated development-runtime-environment centered around Lisp is appealing, I think. Except that building an OS from scratch is a lot of work, at least if you want to support a reasonable range of hardware. But maybe you do not even need that. Now that I think of it, one might build a desktop environment for a modern Unix-ish system that aims to reproduce the Lisp machine development environment of the olden days. This would also allow one to harness the existing Lisp implementations. Does anyone know of such a project?
- kristianp 8y ago
  It would be fun if an fpga implementation was done, perhaps from the vlsi design described in [1] "Design of LISP-based Processors, or SCHEME: A Dielectric LISP, or Finite Memories Considered Harmful, or LAMBDA: The Ultimate Opcode". I can imagine an asic could fit an array of those and use little power, given advances in densities since 1979. [1] https://dspace.mit.edu/handle/1721.1/5731 https://dspace.mit.edu/handle/1721.1/5731
classichasclass 8y ago
> correct-endian, i.e. little. Hey now.
ngcc_hk 8y ago
Reading that gives me an impression many issues of getting lisp to run fast like CDR, type checking for add fixnum (sort of like the guess approach), floating point > 32 bit. Hard to implement a fast lisp? Is lisp relevant if the whole world move deep learning AI with self programming is the norm. May be. But a hardware?
- peter303 8y ago
  Until 2010 A.I. was pretty synomynous with LISP.
- eschaton 8y ago
  Even back in the Lisp Machine days, array processors were used for neural network stuff. You could get an LMI or Symbolics with a floating point accelerator (a Weitek chip), or with an array processor board and library (a whole bunch of Weitek chips and memory, for MIMD or SIMD operation).
- eschaton 8y ago
  Also, “machine learning” and “deep learning” are just other terms for neural network systems, which are good for a few specific tasks but are not a general architecture by any means. Symbolic AI of the sort for which Lisp Machines were originally created is still extremely important as something is needed to provide “executive function” in intelligent systems.
pinewurst 8y ago
Every time I see this (it's been posted a few times) I'm surprised that this architecture was designed so memory limited (26 bit addressing) and with a big penalty for IEEE floating point. The need to transcend both these limitations was pretty obvious at that time or so I remember. If LMI had continued in business along with the Lisp Machine gravy train, I can't imagine choosing a K-machine over a Symbolics 36xx and/or its 40-bit follow-on (which wasn't that much later). It's another subject, but I think there's a bit of a Stallman-esque glorification of LMI when they never seemed to go anywhere nor were Lambda machines that appealing IMHO.
- lispm 8y ago
  LMI had some interesting hardware: the were one of the first users of the NuBUS (which was later used in a smaller version in the Mac II by Apple) and they had Lisp Machines with several CPU boards: these used the infrastructure of a single machine, but each board could run its Lisp independently. TI bought/licensed the technology from LMI and then developed a bunch of interesting machines, like: Lisp Machines with embedded Unix system running on its own 68020 and communicating via a 68010, the first commercial Lisp Microprocessor (a 32bit chip), compact Lisp workstations using that chip, a NuBUS board for the Mac II based on their Lisp chip, ...
  - classichasclass 8y ago
    There was also the Symbolics MacIvory. I've got one of those in a IIci.
    - lispm 8y ago
      The Symbolics MacIvory is a bit more complex, since it is a 40bit machine and also uses 48bit ECC memory.
user2994cb 8y ago
Building a tagged architecture on top of a stock 64-bit system would be much easier than with 32 bits - current systems use 48 bits for addresses, which leaves plenty of bits left over for the tag (you could even represent all non-floating point values as 64-bit NaNs and avoid the problems with FP mentioned in the article).
- znpy 8y ago
  I am not sure, but if my memory serves me right somewhere in the amd64 specification there was something specifically forbidding the use of the uppermost 16 bit to implement tagged pointers, and this is one of the reasons why tagged-pointer-based runtimes haven't been spawning up like mushrooms after the amd64 ISA was implemented.
  - user2994cb 8y ago
    Useful discussion on Stack Overflow: https://stackoverflow.com/questions/16198700/using-the-extra-16-bits-in-64-bit-pointers https://stackoverflow.com/questions/16198700/using-the-extra... Upshot: you can probably get away with it if you are careful to canonicalize pointers before using them.
    - znpy 8y ago
      thank you.
znpy 8y ago
> The machine is correct-endian, i.e. little. Ah, back in those times it was already an argument.
FullyFunctional 8y ago
As I was recently playing with McCarthy's interpreter [1] (and much more that hasn't hit github), I had some thought about a modern Lisp machine, as an extension of a RISC-V core [2]. Software is always a big concern and rather than requiring everything be written in Lisp, I'd want to also be able to run regular binaries written in C. This requires a way to safely embed the "impure" world. The obvious way to do this is extend the value domain with a hidden tag bit [3] which is carried around everywhere, but can't be changed or inspected by regular RISC-V instructions and in fact, almost all instructions trap if any operand is tagged. Memory space would be partitioned into a tagged space and untagged. Tagged values can only live in the tagged space and registers (this is important for precise GC). For regular user space code, tagged values can only be created with a `cons` instruction, and accessed with `car`, `replaca`, etc instructions. Having dedicated instructions would allow a hardware read barrier for real-time (or incremental) GC. (Machine mode would be allowed unsafe access for part of the GC and various tasks). TL;DR: adding fast Lisp support to an existing RISC-V core is likely much easier than building a new dedicated architecture from scratch. (set! projects (cons 'RISCV-LISP projects)) [1] https://github.com/tommythorn/lisp https://github.com/tommythorn/lisp [2] https://github.com/tommythorn/yarvi https://github.com/tommythorn/yarvi [3] If you have data cache, it's not hard to implement a cache line as, say, 32 33-bit word line, backed by 33 32-bit memory words.
- mepian 8y ago
  Someone at UC Berkeley is already adding hardware-assisted GC to a RISC-V core: https://people.eecs.berkeley.edu/~maas/papers/maas-asbd16-hwgc.pdf https://people.eecs.berkeley.edu/~maas/papers/maas-asbd16-hw...
  - FullyFunctional 8y ago
    I'm on the RISC-V J committee (headed by Martin Mass), but what I'm proposing here is unlikely (?) to appeal to the mainstream RISC-V SoC developers, at least not without a strong PoC.

114 points by mepian 8y ago

jf 8y ago

The site appears to be down, here is the most recent copy available on the Wayback Machine: https://web.archive.org/web/20181123210702/http://fare.tunes.org/tmp/emergent/kmachine.htm https://web.archive.org/web/20181123210702/http://fare.tunes...

pmoriarty 8y ago

I wonder if a kickstarter to create a new Lisp Machine could work. I envision something like a Raspberry Pi, but with the hardware designed to run Lisp, and taking inspiration from the original Lisp Machines.

eigenspace 8y ago
I imagine that the hard part is probably not making a lisp machine but making what made the lisp machines so special: it's software and tooling. My understanding is that the tooling available on lisp machines was so good it made emacs look rigid and dumb. I'd imagine that reacreating such tooling would take more man hours that building the lisp machine and its kernel but I don't know.
- rjsw 8y ago
  You could start with the old software, the MIT tree has been released. I have copies of the final LMI software including the K-machine stuff. The software wasn't dumb, there was just a lot less of it. They didn't have IPv6, SSL, a web browser ... One halfway house would be a Lisp unikernel.
- mepian 8y ago
  Perhaps the open-sourced software for the original MIT CADR Lisp machine could be used as the starting point: https://github.com/mietek/mit-cadr-system-software https://github.com/mietek/mit-cadr-system-software
- pinewurst 8y ago
  An LMI Lambda (shipped 1st gen machine that was an evolved MIT CADR) emulator is at: https://github.com/dseagrav/ld https://github.com/dseagrav/ld
mepian 8y ago
Andreas Olofsson and his team at Adapteva have demonstrated that it's possible for a small experienced team to design and launch a niche processor and a single-board computer board similar to the Raspberry Pi around it within a relatively small (less than 5 million USD) budget, and they even used Kickstarter to fund the later iterations: https://en.wikipedia.org/wiki/Adapteva https://en.wikipedia.org/wiki/Adapteva
tyingq 8y ago
There was this in 2014: https://news.ycombinator.com/item?id=8340283 https://news.ycombinator.com/item?id=8340283
- pmoriarty 8y ago
  That's interesting, and I wonder if it ever went in to production, and if so how many units were sold. Unfortunately, it seems to have been based around PicoLisp, which isn't exactly a popular Lisp implementation. I expect that for any project like this to get wide traction in the Lisp community, it would have to be based around Common Lisp, as that's by far the most popular Lisp out there, with a huge existing ecosystem it could leverage -- an advantage akin to basing the Raspberry Pi around Java.
  - cellularmitosis 8y ago
    Speaking of which, a hardware JVM would also mean clojure on the metal :)
    - lispm 8y ago
      if the JVM would have been implemented in Clojure and all the other stuff, too. Already the Clojure compiler is not written Clojure, but Java. The JVM also for example has no TCP stack on its own, it interfaces the OS - which then is written in C/C++.
      - rjsw 8y ago
        An example of a Java Machine is JOP [1], it has a TCP/IP stack and is a microcoded architecture too. [1] https://www.jopdesign.com/ https://www.jopdesign.com/
        lispm 8y ago
        Right, the JavaOS from SUN would also count: https://en.wikipedia.org/wiki/JavaOS https://en.wikipedia.org/wiki/JavaOS http://www.eecg.toronto.edu/~stumm/teaching/ece1759/javaos/javaos.html http://www.eecg.toronto.edu/~stumm/teaching/ece1759/javaos/j...
sifoobar 8y ago
Sorry, you can't sell Lisp. Maybe once upon a time that was possible, but those days are gone. And Lispers generally are a whiny, creaky bunch to deal with; me included. Pleasing that crowd is a serious undertaking. I sometimes try to imagine a world where these things took off, but the closest thing I've touched is Emacs and I'm pretty sure that's not what they had in mind.
- dleslie 8y ago
  I would buy a Lisp machine, provided that I could afford it. That proviso was the undoing of them, IMHO.
- jolmg 8y ago
  I would also buy a Lisp Machine, provided I could afford one. I'm really interested to see this software environment that I've heard spoken so highly of. What I've understood so far of it sounds amazing.
  - rjsw 8y ago
    Try one of the emulators.
  - jacquesm 8y ago
    Wait another hundred years and it will be close to magical. We have the collective habit of ascribing great properties to old technologies while bitching about the technologies we have today. I'm certainly no exception here, but the fact is that if it really was that good it likely would have won in the marketplace. Nostalgia is a powerful agent of deception.
    - armitron 8y ago
      You should definitely read 'Worse is Better' by Richard Gabriel if you truly believe that the marketplace is the final arbiter of what is really good. Hint: It's not. In order to see how important and iconoclastic (nevermind good) the Lisp Machine paradigm is, examine the trickle-down effect that it put in motion. There are popular IDEs today that are only _just beginning_ to integrate concepts from that paradigm. The Lisp Machines were so far ahead of their time, so visionary, that it will take decades if not centuries for the consensus to catch up to what they represented.
lispm 8y ago
If you have a Raspberry Pi, you have already all the hardware to run Lisp. There is very little reason to develop special hardware. Lisp runs nicely on an ARM processor. Actually some the first ARM processors were supposed to run a Lisp operating system. When Apple did the research&development for the Apple Newton, they originally attempted to run a Lisp-like system on mobile systems like PDAs and tablets. This Lisp dialect was derived mostly from Scheme and Common Lisp - the language was eventually called Dylan. Apple had ARM systems in their lab which ran a Dylan OS. When they at one point chose the ARM processor, Apple invested in ARM and they used a chip which was able to support a garbage collected language. Unfortunately these Lisp operating systems by Apple did not reach the market and Apple instead sold the Apple Newton with an OS kernel written in C++ and the software on top written and scripted in NewtonScript - a language with many aspects from Lisp - incl. garbage collection.
- AnimalMuppet 8y ago
  Could you explain what you mean by a "Lisp operating system"? I understand the idea of Lisp as a language, but what does Lisp as an OS mean?
  - lispm 8y ago
    Historically it's an operating system written in Lisp, typically running as a Lisp runtime+image on the metal. Itself providing memory management, interrupt handling, process scheduling, network I/O, graphics, keyboard, mouse, windows, applications ... and everything else a typical OS provides. For a recent attempt see: https://github.com/froggey/Mezzano https://github.com/froggey/Mezzano
    - AnimalMuppet 8y ago
      Is there any advantage to that over a generic OS? I have not, in general, cared what language my OS was written in.
      - white-flame 8y ago
peter303 8y ago
Custom hardware language machines fall behind firmware on general purpose CPUs because the latter have an order of magnitude faster hardware releases. There were all kinds of clever architectures coming out in the 1980s- LISP machines, prolog computers, Masspar, Thinking Machine, etc. The first release tended to be economically competitive. But the next release 3 to 5 years later fell behind Moores law.
- bitwize 8y ago
  Not only that, but Lisp compiler technology improved to further narrow the gap between Lisp on Lisp Machine and Lisp on generic CPU.
protomyth 8y ago
It would probably be a better step to approach whoever owns one of the Lisp OSes, buy it with a fund raiser, and put it under an MIT license. Then go for custom hardware if needed.
segmondy 8y ago
Nah, that would a very wrong approach. If you want any chance, a Lisp machine needs to run on current OS. It needs to run on Linux, Windows, OSX. It's very easy to run on any OS, besides VM, we have seen linux subsystems for windows, ios, windows call on linux. And even user land kernel with gVisor, so build it on current OS.
krylon 8y ago
I don't think a Lisp machine would make much sense these days, as far as the hardware is concerned. Designing and building CPUs is very expensive, and the small market for such a machine would make them prohibitively expensive. But an operating system built around the idea could be quite interesting. From what I know, the systems running on the Lisp machines of the 1980s were nightmares from a modern security perspective. But the idea of having a closely integrated development-runtime-environment centered around Lisp is appealing, I think. Except that building an OS from scratch is a lot of work, at least if you want to support a reasonable range of hardware. But maybe you do not even need that. Now that I think of it, one might build a desktop environment for a modern Unix-ish system that aims to reproduce the Lisp machine development environment of the olden days. This would also allow one to harness the existing Lisp implementations. Does anyone know of such a project?
kristianp 8y ago
It would be fun if an fpga implementation was done, perhaps from the vlsi design described in [1] "Design of LISP-based Processors, or SCHEME: A Dielectric LISP, or Finite Memories Considered Harmful, or LAMBDA: The Ultimate Opcode". I can imagine an asic could fit an array of those and use little power, given advances in densities since 1979. [1] https://dspace.mit.edu/handle/1721.1/5731 https://dspace.mit.edu/handle/1721.1/5731

classichasclass 8y ago

> correct-endian, i.e. little. Hey now.

ngcc_hk 8y ago

Reading that gives me an impression many issues of getting lisp to run fast like CDR, type checking for add fixnum (sort of like the guess approach), floating point > 32 bit. Hard to implement a fast lisp? Is lisp relevant if the whole world move deep learning AI with self programming is the norm. May be. But a hardware?

peter303 8y ago
Until 2010 A.I. was pretty synomynous with LISP.
eschaton 8y ago
Even back in the Lisp Machine days, array processors were used for neural network stuff. You could get an LMI or Symbolics with a floating point accelerator (a Weitek chip), or with an array processor board and library (a whole bunch of Weitek chips and memory, for MIMD or SIMD operation).
eschaton 8y ago
Also, “machine learning” and “deep learning” are just other terms for neural network systems, which are good for a few specific tasks but are not a general architecture by any means. Symbolic AI of the sort for which Lisp Machines were originally created is still extremely important as something is needed to provide “executive function” in intelligent systems.

pinewurst 8y ago

Every time I see this (it's been posted a few times) I'm surprised that this architecture was designed so memory limited (26 bit addressing) and with a big penalty for IEEE floating point. The need to transcend both these limitations was pretty obvious at that time or so I remember. If LMI had continued in business along with the Lisp Machine gravy train, I can't imagine choosing a K-machine over a Symbolics 36xx and/or its 40-bit follow-on (which wasn't that much later). It's another subject, but I think there's a bit of a Stallman-esque glorification of LMI when they never seemed to go anywhere nor were Lambda machines that appealing IMHO.

lispm 8y ago
LMI had some interesting hardware: the were one of the first users of the NuBUS (which was later used in a smaller version in the Mac II by Apple) and they had Lisp Machines with several CPU boards: these used the infrastructure of a single machine, but each board could run its Lisp independently. TI bought/licensed the technology from LMI and then developed a bunch of interesting machines, like: Lisp Machines with embedded Unix system running on its own 68020 and communicating via a 68010, the first commercial Lisp Microprocessor (a 32bit chip), compact Lisp workstations using that chip, a NuBUS board for the Mac II based on their Lisp chip, ...
- classichasclass 8y ago
  There was also the Symbolics MacIvory. I've got one of those in a IIci.
  - lispm 8y ago
    The Symbolics MacIvory is a bit more complex, since it is a 40bit machine and also uses 48bit ECC memory.

user2994cb 8y ago

Building a tagged architecture on top of a stock 64-bit system would be much easier than with 32 bits - current systems use 48 bits for addresses, which leaves plenty of bits left over for the tag (you could even represent all non-floating point values as 64-bit NaNs and avoid the problems with FP mentioned in the article).

znpy 8y ago
I am not sure, but if my memory serves me right somewhere in the amd64 specification there was something specifically forbidding the use of the uppermost 16 bit to implement tagged pointers, and this is one of the reasons why tagged-pointer-based runtimes haven't been spawning up like mushrooms after the amd64 ISA was implemented.
- user2994cb 8y ago
  Useful discussion on Stack Overflow: https://stackoverflow.com/questions/16198700/using-the-extra-16-bits-in-64-bit-pointers https://stackoverflow.com/questions/16198700/using-the-extra... Upshot: you can probably get away with it if you are careful to canonicalize pointers before using them.
  - znpy 8y ago
    thank you.

znpy 8y ago

> The machine is correct-endian, i.e. little. Ah, back in those times it was already an argument.

FullyFunctional 8y ago

As I was recently playing with McCarthy's interpreter [1] (and much more that hasn't hit github), I had some thought about a modern Lisp machine, as an extension of a RISC-V core [2]. Software is always a big concern and rather than requiring everything be written in Lisp, I'd want to also be able to run regular binaries written in C. This requires a way to safely embed the "impure" world. The obvious way to do this is extend the value domain with a hidden tag bit [3] which is carried around everywhere, but can't be changed or inspected by regular RISC-V instructions and in fact, almost all instructions trap if any operand is tagged. Memory space would be partitioned into a tagged space and untagged. Tagged values can only live in the tagged space and registers (this is important for precise GC). For regular user space code, tagged values can only be created with a `cons` instruction, and accessed with `car`, `replaca`, etc instructions. Having dedicated instructions would allow a hardware read barrier for real-time (or incremental) GC. (Machine mode would be allowed unsafe access for part of the GC and various tasks). TL;DR: adding fast Lisp support to an existing RISC-V core is likely much easier than building a new dedicated architecture from scratch. (set! projects (cons 'RISCV-LISP projects)) [1] https://github.com/tommythorn/lisp https://github.com/tommythorn/lisp [2] https://github.com/tommythorn/yarvi https://github.com/tommythorn/yarvi [3] If you have data cache, it's not hard to implement a cache line as, say, 32 33-bit word line, backed by 33 32-bit memory words.

mepian 8y ago
Someone at UC Berkeley is already adding hardware-assisted GC to a RISC-V core: https://people.eecs.berkeley.edu/~maas/papers/maas-asbd16-hwgc.pdf https://people.eecs.berkeley.edu/~maas/papers/maas-asbd16-hw...
- FullyFunctional 8y ago
  I'm on the RISC-V J committee (headed by Martin Mass), but what I'm proposing here is unlikely (?) to appeal to the mainstream RISC-V SoC developers, at least not without a strong PoC.