Lisp machine

From Wikipedia, the free encyclopedia
  (Redirected from LISP machine)
Jump to: navigation, search
This article is about the type of computer. For the company, see Lisp Machines.
A Knight machine preserved in MIT's museum.

Lisp machines are general-purpose computers designed (usually through hardware support) to efficiently run Lisp as their main software language. In a sense, they were the first commercial single-user workstations. Despite being modest in number (perhaps 7,000 units total as of 1988[1]), Lisp machines commercially pioneered many now-commonplace technologies – including effective garbage collection, laser printing, windowing systems, computer mice, high-resolution bit-mapped graphics, computer graphic rendering, and networking innovations like CHAOSNet.[citation needed] Several companies were building and selling Lisp Machines in the 1980s: Symbolics (3600, 3640, XL1200, MacIvory and other models), Lisp Machines Incorporated (LMI Lambda), Texas Instruments (Explorer and MicroExplorer) and Xerox (InterLisp-D workstations). The operating systems were written in Lisp Machine Lisp, InterLisp (Xerox) and later partly in Common Lisp.

Symbolics 3640 Lisp machine

History[edit]

Historical context[edit]

Artificial intelligence (AI) computer programs of the 1960s and 1970s intrinsically required what was then considered a huge amount of computer power, as measured in processor time and memory space. The power requirements of AI research were exacerbated by the Lisp symbolic programming language, when commercial hardware was designed and optimized for assembly- and Fortran-like programming languages. At first, the cost of such computer hardware meant that it had to be shared among many users. But as integrated circuit technology shrank the size and cost of computers in the 1960s and early 1970s, and the memory requirements of AI programs started to exceed the address space of the most common research computer, the DEC PDP-10, researchers considered a new approach: a computer designed specifically to develop and run large artificial intelligence programs, and tailored to the semantics of the Lisp programming language. To keep the operating system (relatively) simple, these machines would not be shared, but would be dedicated to a single user[citation needed].

Initial development[edit]

In 1973, Richard Greenblatt and Thomas Knight, programmers at MIT's AI Lab, started what would become the MIT Lisp Machine Project when they first began building a computer hardwired to run certain basic Lisp operations, rather than run them in software, in a 24-bit tagged architecture. The machine also did incremental (or "Arena") garbage collection.[citation needed] More specifically, since Lisp variables are typed at runtime rather than compile time, a simple addition of two variables could take five times as long on conventional hardware, due to test and branch instructions. Lisp Machines ran the tests in parallel with the more conventional single instruction additions. If the simultaneous tests failed, then the result was discarded and recomputed; this meant in many cases a speed increase by several factors. This simultaneous checking approach was used as well in testing the bounds of arrays when referenced, and other memory management necessities (not merely garbage collection or arrays).

Type checking was further improved and automated when the conventional byte word of 32-bits was lengthened to 36-bits for Symbolics 3600-model Lisp machines[2] and eventually to 40-bits or more (usually, the excess bits not accounted for by the following were used for error-correcting codes). The first group of extra bits were used to hold type data, making the machine a tagged architecture, and the remaining bits were used to implement CDR coding (wherein the usual linked list elements are compressed to occupy roughly half the space), aiding garbage collection by reportedly an order of magnitude. A further improvement was two microcode instructions which specifically supported Lisp functions, reducing the cost of calling a function to (in some Symbolics implementations) as little as 20 clock cycles.

The first machine was called the CONS machine (named after the list construction operator cons in Lisp). Often it was affectionately referred to as the "Knight machine", perhaps since Knight wrote his master's thesis on the subject; it was extremely well received.[citation needed] It was subsequently improved into a version called CADR (a pun; in Lisp, the cadr function, which returns the second element of a list, is pronounced /ˈkeɪ.dəɹ/ or /ˈkɑ.dəɹ/, as some pronounce the word "cadre") which was based on essentially the same architecture. About 25 of what were essentially prototype CADRs were sold within and without MIT for ~$50,000; it quickly became the favorite machine for hacking- many of the most favored software tools were quickly ported to it (e.g. Emacs was ported from ITS in 1975). It was so well received at an AI conference held at MIT in 1978 that DARPA began funding its development.

Commercialization of the MIT Lisp Machine technology[edit]

In 1979, Russell Noftsker, being convinced that Lisp machines had a bright commercial future due to the strength of the Lisp language and the enabling factor of hardware acceleration, made Greenblatt a proposal: they would take the technology commercial.[citation needed] In a counter-intuitive move for an AI Lab hacker, Greenblatt acquiesced, hoping perhaps that he could recreate the informal and productive atmosphere of the Lab in a real business. These ideas and goals were considerably different from the ones Noftsker held. The two negotiated at length, but neither would compromise. As the proposed company could only be a success with the full and undivided assistance of the AI Lab hackers as a group, Noftsker and Greenblatt decided that the fate of the enterprise was up to them, and so the choice should be left to the hackers.

The ensuing discussions of the choice divided the lab into two factions. In February, 1979, matters came to a head. The hackers sided with Noftsker, believing that a commercial venture fund-backed company had a better chance of surviving and commercializing Lisp Machines than Greenblatt's proposed self-sustaining start-up. Greenblatt had lost the battle.

It was at this juncture that Symbolics, Noftsker's enterprise, slowly came together. While Noftsker was paying his staff a salary, he did not actually have a building or any equipment for the hackers to work on. He bargained with Patrick Winston that, in exchange for allowing Symbolics’ staff to keep working out of MIT, Symbolics would let MIT use internally and freely all the software Symbolics developed. A consultant from CDC, who was trying to put together a natural language computer application with a group of West-coast programmers, came to Greenblatt, seeking a Lisp machine for his group to work with, about eight months after the disastrous conference with Noftsker. Greenblatt had decided to start his own rival Lisp machine company, but he had done nothing. The consultant, Alexander Jacobson, decided that the only way Greenblatt was going to actually start his company and build the Lisp machines that Jacobson desperately needed was if Jacobson pushed and otherwise helped Greenblatt launch his company. Jacobson pulled together business plans, a board, a partner for Greenblatt (one F. Stephen Wyle). The newfound company was named LISP Machine, Inc. (LMI), and was funded by CDC orders, via Jacobson.

Around this time Symbolics (Noftsker's company) began operations – it had been hindered by Noftsker's promise to give Greenblatt a year’s head start, and by severe delays in procuring venture capital. Symbolics still had the major advantage that while 3 or 4 of the AI Lab hackers had gone to work for Greenblatt, a solid 14 other hackers had signed onto Symbolics. There were two AI Lab people who did not get hired by either: Richard Stallman and Marvin Minsky. Stallman, however, blamed Symbolics for the decline of the hacker community that had centered around the AI lab. For two years, from 1982 to the end of 1983, Stallman worked by himself to clone the output of the Symbolics programmers, with the aim of preventing them from gaining a monopoly on the lab's computers.[3]

Regardless, after a series of internal battles, Symbolics did get off the ground in 1980/1981, selling the CADR as the LM-2, while Lisp Machines, Inc. sold it as the LMI-CADR. Symbolics did not intend to produce many LM-2s, since the 3600 family of Lisp machines was supposed to ship quickly, but the 3600s were repeatedly delayed, and Symbolics ended up producing ~100 LM-2s, each of which sold for $70,000. Both companies developed second-generation products based on the CADR: the Symbolics 3600 and the LMI-LAMBDA (of which LMI managed to sell ~200). The 3600, which shipped a year late, expanded on the CADR by widening the machine word to 36-bits, expanding the address space to 28-bits,[4] and adding hardware to accelerate certain common functions that were implemented in microcode on the CADR. The LMI-LAMBDA, which came out a year after the 3600, in 1983, was compatible with the CADR (it could run CADR microcode), but there were hardware differences. Texas Instruments (TI) joined the fray when it licensed the LMI-LAMBDA design and produced its own variant, the TI Explorer. Some of the LMI-LAMBDAs and the TI Explorer were dual systems with both a Lisp and a UNIX processor. TI also developed a 32bit microprocessor version of its Lisp CPU for the TI Explorer. This Lisp chip also was used for the MicroExplorer – a NuBus board for the Apple Macintosh II (NuBus was initially developed at MIT for use in Lisp machines).

Symbolics continued to develop the 3600 family and its operating system, Genera, and produced the Ivory, a VLSI implementation of the Symbolics architecture. Starting in 1987, several machines based on the Ivory processor were developed: boards for Suns and Macs, stand-alone workstations and even embedded systems (I-Machine Custom LSI, 32 bit address, Symbolics XL-400, UX-400, MacIvory II; in 1989 available platforms were Symbolics XL-1200, MacIvory III, UX-1200, Zora, NXP1000 "pizza box"). Texas Instruments shrunk the Explorer into silicon as the MicroExplorer which was offered as a card for the Apple Mac II. LMI abandoned the CADR architecture and developed its own K-Machine,[5] but LMI went bankrupt before the machine could be brought to market. Prior to its demise, LMI was working on a distributed system for the LAMBDA using Moby space.[6]

These machines had hardware support for various primitive Lisp operations (data type testing, CDR coding) and also hardware support for incremental garbage collection. They ran large Lisp programs very efficiently. The Symbolics machine was actually competitive against many commercial super mini computers, but it was never adapted for conventional purposes. The Symbolics Lisp Machines were also sold to some non-AI markets like computer graphics, modeling and animation.

The MIT-derived Lisp machines ran a Lisp dialect called Lisp Machine Lisp, descended from MIT's Maclisp. The operating systems were written from the ground up in Lisp, often using object-oriented extensions. Later these Lisp machines also supported various versions of Common Lisp (with Flavors, New Flavors and CLOS).

InterLisp, BBN, and Xerox[edit]

BBN developed its own Lisp Machine, called Jericho,[7] which ran a version of Interlisp. It was never marketed; frustrated, the entire AI group resigned, and were hired primarily by Xerox. So, Xerox Palo Alto Research Center had, simultaneously with Greenblatt's own development at MIT, developed their own Lisp machines which were designed to run InterLisp (and later Common Lisp). The same hardware was used with different software also as Smalltalk machines and as the Xerox Star office system. These included the Xerox 1100, "Dolphin" (1979); the Xerox 1132, "Dorado"; the Xerox 1108, "Dandelion" (1981); and the Xerox 1109, "Dandetiger"; and the Xerox 1186/6085, "Daybreak". The Xerox machines were a commercial failure, but they did influence the creation of Apple Computer's Macintosh. The operating system of the Xerox Lisp Machines has also been ported to a virtual machine and is available for several platforms as a product called "Medley". The Xerox Lisp Machine was well known for its advanced development environment (InterLisp-D), the ROOMS window manager, for its early graphical user interface and for novel applications like NoteCards (one of the first Hypertext applications).

Xerox also worked on a RISC-based Lisp Machine using the 'Xerox Common Lisp Processor' and planned to bring it to market by 1987,[8] which did not happen.

Integrated Inference Machines[edit]

In the mid-80s prototypes of Lisp Machines called Inferstar have been built by Integrated Inference Machines (IIM).[9]

Developments of Lisp Machines outside the US[edit]

In 1984–1985 a UK company, Racal-Norsk, a joint subsidiary of Racal and Norsk Data, attempted to repurpose Norsk Data's ND-500 supermini as a microcoded Lisp Machine, running CADR software: the Knowledge Processing System (KPS).[10]

There were several attempts by Japanese manufacturers to enter the Lisp Machine market: the Fujitsu Facom-alpha[11] mainframe co-processor, NTT's Elis,[12][13] Toshiba's AI processor (AIP)[14] and NEC's LIME.[15] Several university research efforts produced working prototypes, among them are Kobe University's TAKITAC-7,[16] RIKEN's FLATS[17] and Osaka University's EVLIS.[18]

In France there were two Lisp Machine projects: M3L[19] at Toulouse Paul Sabatier University and later MAIA.[20]

In Germany the company Siemens designed the RISC-based Lisp co-processor COLIBRI.[21][22]

End of the Lisp Machines[edit]

With the onset of the "AI winter" and the early beginnings of the microcomputer revolution (which would gather steam and sweep away the minicomputer and workstation manufacturers), cheaper desktop PCs soon were able to run Lisp programs even faster than Lisp machines, without the use of special purpose hardware. Their high profit margin hardware business eliminated, most Lisp Machine manufacturers went out of business by the early 90s, leaving only software based companies like Lucid Inc. or hardware manufacturers who switched to software and services to avoid the crash. Besides Xerox, Symbolics is the only Lisp Machine company still operating today, selling the Open Genera Lisp Machine software environment as well as the Macsyma computer algebra system.

Legacy[edit]

Several attempts to write open-source emulators for various Lisp Machines have been made: CADR Emulation,[23] Symbolics L Lisp Machine Emulation,[24] the E3 Project (TI Explorer II Emulation),[25] Meroko (TI Explorer I)[26] and Nevermore (TI Explorer I).[27] On 3 October 2005, the MIT released the CADR Lisp Machine source code as open source.[28]

The Bitsavers' PDF Document Archive[29] has PDF versions of the extensive documentation for the Symbolics Lisp Machines,[30] the TI Explorer[31] and MicroExplorer[32] Lisp Machines and the Xerox Interlisp-D Lisp Machines.[33]

Other attempts on language-optimized computers[edit]

A number of processors and coprocessors intended to implement Prolog more directly were designed in the late 1980s and early 1990s, including the Berkeley VLSI-PLM, its successor (the PLUM), and a related microcode implementation. There were also a number of simulated designs that were not produced as hardware [1], [2]. Like Lisp, Prolog's basic model of computation is radically different from standard imperative designs, and computer scientists and electrical engineers were eager to escape the bottlenecks caused by emulating their underlying models.

Niklaus Wirth's Lilith project included a custom CPU geared toward the Modula-2 language.[34]

The INMOS Transputer was designed to support concurrent programming, using occam.

The AT&T Hobbit processor, stemming from a design called CRISP (C-language Reduced Instruction Set Processor), was optimized to run C code.

In the late 1990s, there were plans by Sun Microsystems and other companies to build CPUs that directly (or closely) implemented the stack-based Java virtual machine. As a result several Java processors have been built and used.

Ericsson developed ECOMP, a processor designed to run Erlang.[35] It was never commercially produced.

Applications[edit]

Domains using the Lisp Machines were mostly in the wide area of Artificial Intelligence applications, but also in Computer Graphics, Medical Image Processing and many others.

The main commercial expert systems of the 80s were available: Intellicorp's Knowledge Engineering Environment (KEE), Knowledge Craft from The Carnegie Group Inc. and ART (Automated Reasoning Tool) from Inference Corporation.[36]

Technical overview[edit]

Initially the Lisp Machines were designed as personal workstations for software development in Lisp. They were used by a single person and offered no multi-user mode. The Lisp Machines provided a large, black and white, bitmap display, keyboard and mouse, network adapter, local hard disks, more than 1 MB RAM, serial interfaces, and a local bus for extension cards. Color graphics cards, tape drives, and laser printers were optional.

The processor did not run Lisp directly, but was a stack machine with instructions optimized for compiled Lisp. The early Lisp Machines used microcode to provide the instruction set. For several operations type checking and dispatching was done in hardware at runtime. There was for example only a single addition operation that could be used with various numeric types (integer, float, rational and complex numbers). The result was a very compact compiled representation of Lisp code.

The following example uses a function that counts the number of elements of a list for which a predicate returns 'true'.

(defun example-count (predicate list)
  (let ((count 0))
    (dolist (i list count)
      (when (funcall predicate i)
        (incf count)))))

The disassembled machine code for above function (for the Ivory microprocessor from Symbolics):

Command: (disassemble (compile #'example-count))
 
  0  ENTRY: 2 REQUIRED, 0 OPTIONAL      ;Creating PREDICATE and LIST
  2  PUSH 0                             ;Creating COUNT
  3  PUSH FP|3                          ;LIST 
  4  PUSH NIL                           ;Creating I
  5  BRANCH 15
  6  SET-TO-CDR-PUSH-CAR FP|5
  7  SET-SP-TO-ADDRESS-SAVE-TOS SP|-1
 10  START-CALL FP|2                    ;PREDICATE 
 11  PUSH FP|6                          ;I 
 12  FINISH-CALL-1-VALUE
 13  BRANCH-FALSE 15
 14  INCREMENT FP|4                     ;COUNT 
 15  ENDP FP|5
 16  BRANCH-FALSE 6
 17  SET-SP-TO-ADDRESS SP|-2
 20  RETURN-SINGLE-STACK

The operating system used virtual memory to provide a large address space. Memory management was done with garbage collection. All code shared a single address space. All data objects were stored with a tag in memory, so that the type could be determined at runtime. Multiple execution threads were supported and called 'processes' – all processes were running in the single address space.

All operating system software was written in Lisp. Xerox used InterLisp. Symbolics, LMI and TI used Lisp Machine Lisp (descendant of MacLisp). With the appearance of Common Lisp, Common Lisp was supported on the Lisp Machines and some system software was ported to Common Lisp or later written in Common Lisp.

Some later Lisp Machines (like the TI MicroExplorer, the Symbolics MacIvory or the Symbolics UX400/1200) were no longer complete workstations, but boards designed to be embedded in host computers: Apple Macintosh II and SUN 3 or 4.

Some Lisp Machines, like the Symbolics XL1200, had extensive graphics capabilities using special graphics boards. These Lisp Machines were used in domains like medical image processing, 3D animation and CAD.

See also[edit]

References[edit]

  1. ^ Newquist, HP. The Brain Makers, Sams Publishing, 1994. ISBN 0-672-30412-0
  2. ^ ""Architecture of the Symbolics 3600", David A. Moon". Portal.acm.org. doi:10.1145/327070.327133. Retrieved 12 November 2011. 
  3. ^ Levy,S: Hackers. Penguin USA, 1984
  4. ^ Moon 1985
  5. ^ K-Machine 
  6. ^ Moby space Patent application 4779191
  7. ^ http://www.aaai.org/ojs/index.php/aimagazine/article/download/94/93 (1981). "Computing Facilities for AI: A Survey of Present and Near-Future Options". AI Magazine 2 (1). 
  8. ^ "The AAAI-86 Conference Exhibits: New Directions for Commercial AI, VLSI Lisp Machine Implementations Are Coming". AI Magazine 8 (1). 1987. 
  9. ^ "The AAAI-86 Conference Exhibits: New Directions for Commercial AI, A New Lisp Machine Vendor, AI Magazine Volume 8 Number 1, 1987". Retrieved 12 November 2011. 
  10. ^ "Computer Algebra in Norway, Racal-Norsk KPS-5 and KPS-10 Multi-User Lisp Machines". Springerlink.com. Retrieved 12 November 2011. 
  11. ^ "IPSJ Computer Museum, Facom Alpha". Museum.ipsj.or.jp. Retrieved 12 November 2011. 
  12. ^ "IPSJ Computer Museum, NTT ELIS". Museum.ipsj.or.jp. 9 September 1983. Retrieved 12 November 2011. 
  13. ^ "A 32-bit LISP Processor for the Al Workstation ELIS with a Multiple Programming Paradigm Language, TAO". Ci.nii.ac.jp. 25 August 1990. Retrieved 12 November 2011. 
  14. ^ "Architecture of an AI Processor Chip (IP1704)". Ci.nii.ac.jp. 25 August 1990. Retrieved 12 November 2011. 
  15. ^ "IPSJ Computer Museum, NEC LIME Lisp Machine". Museum.ipsj.or.jp. Retrieved 12 November 2011. 
  16. ^ "IPSJ Computer Museum, Kobe University Lisp Machine". Museum.ipsj.or.jp. 10 February 1979. Retrieved 12 November 2011. 
  17. ^ "IPSJ Computer Museum, RIKEN FLATS Numerical Processing Computer". Museum.ipsj.or.jp. Retrieved 12 November 2011. 
  18. ^ "IPSJ Computer Museum, EVLIS Machine". Museum.ipsj.or.jp. Retrieved 12 November 2011. 
  19. ^ "M3L, A Lisp-machine". Limsi.fr. Retrieved 12 November 2011. 
  20. ^ "MAIA, Machine for Artificial Intelligence". Limsi.fr. Retrieved 12 November 2011. 
  21. ^ Müller-Schloer ”Bewertung der RISC-Methodik am Beispiel COLIBRI”, ”RISC-Architekturen”, Editor A. Bode, BI-Verlag, 1988
  22. ^ Christian Hafer, Josef Plankl, F. J. Schmitt., COLIBRI: Ein RISC-LISP-System, Architektur von Rechensystemen, Tagungsband, 11. ITG/GI-Fachtagung, 7.-9. März 1990, München, Germany 1990
  23. ^ "CADR Emulation". Unlambda.com. Retrieved 12 November 2011. 
  24. ^ "Symbolics L Lisp Machine Emulation". Unlambda.com. 28 May 2004. Retrieved 12 November 2011. 
  25. ^ "The E3 Project, TI Explorer II emulation". Unlambda.com. Retrieved 12 November 2011. 
  26. ^ "Meroko Emulator (TI Explorer I)". Unlambda.com. Retrieved 12 November 2011. 
  27. ^ "Nevermore Emulator (TI Explorer I)". Unlambda.com. Retrieved 12 November 2011. 
  28. ^ "MIT CADR Lisp Machine Source code". Heeltoe.com. Retrieved 12 November 2011. 
  29. ^ "Bitsavers' PDF Document Archive". Bitsavers.org. Retrieved 12 November 2011. 
  30. ^ "Symbolics documentation". Bitsavers.org. Retrieved 12 November 2011. 
  31. ^ "TI Explorer documentation". Bitsavers.org. 15 May 2003. Retrieved 12 November 2011. 
  32. ^ "TI MicroExplorer documentation". Bitsavers.org. 9 September 2003. Retrieved 12 November 2011. 
  33. ^ "Xerox Interlisp documentation". Bitsavers.org. 24 March 2004. Retrieved 12 November 2011. 
  34. ^ "Pascal for Small Machines – History of Lilith". Pascal.hansotten.com. 28 September 2010. Retrieved 12 November 2011. 
  35. ^ http://www.erlang.se/euc/00/processor.ppt
  36. ^ Richter,Mark: AI Tools and Techniques. Ablex Publishing Corporation USA, 1988, Chapter 3, An Evaluation of Expert System Development Tools
General

External links[edit]