Jump to content

Lisp machine

From Wikipedia, the free encyclopedia
This article is about the type of computer. For the company, seeLisp Machines.

A Knight machine preserved in theMIT Museum

Lisp machinesare general-purpose computers designed to efficiently runLispas their main software andprogramming language,usually via hardware support. They are an example of ahigh-level language computer architecture.In a sense, they were the first commercial single-userworkstations.Despite being modest in number (perhaps 7,000 units total as of 1988[1]) Lisp machines commercially pioneered many now-commonplace technologies, including effectivegarbage collection,laser printing,windowing systems,computer mice,high-resolution bit-mappedraster graphics,computer graphic rendering, and networking innovations such asChaosnet.[2]Several firms built and sold Lisp machines in the 1980s:Symbolics(3600, 3640, XL1200, MacIvory, and other models),Lisp MachinesIncorporated (LMI Lambda),Texas Instruments(Explorer, MicroExplorer), andXerox(Interlisp-D workstations). The operating systems were written inLisp Machine Lisp,Interlisp (Xerox), and later partly inCommon 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 forassembly- andFortran-like programming languages. At first, the cost of such computer hardware meant that it had to be shared among many users. Asintegrated circuittechnology shrank the size and cost of computers in the 1960s and early 1970s, and the memory needs of AI programs began to exceed theaddress spaceof the most common research computer, theDigital Equipment Corporation(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 theLisplanguage. To keep theoperating system(relatively) simple, these machines would not be shared, but would be dedicated to single users.[citation needed]

Initial development[edit]

In 1973,Richard GreenblattandThomas Knight,programmers atMassachusetts Institute of Technology(MIT)Artificial Intelligence Laboratory(AI Lab), began 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-bittagged architecture.The machine also did incremental (orArena)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 forSymbolics3600-model Lisp machines[3]and eventually to 40-bits or more (usually, the excess bits not accounted for by the following were used forerror-correcting codes). The first group of extra bits were used to hold type data, making the machine atagged architecture,and the remaining bits were used to implementCDR 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 Lispfunctions,reducing the cost of calling a function to as little as 20 clock cycles, in some Symbolics implementations.

The first machine was called the CONS machine (named after the list construction operatorconsin Lisp). Often it was affectionately referred to as theKnight machine,perhaps sinceKnightwrote 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, thecadrfunction, which returns the second item 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.Emacswas ported fromITSin 1975[disputed–discuss]). It was so well received at an AI conference held at MIT in 1978 thatDefense Advanced Research Projects Agency(DARPA) began funding its development.

Commercializing MIT Lisp machine technology[edit]

Symbolics 3620 (left) and LMI Lambda Lisp machines

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, proposed to Greenblatt that they commercialize the technology.[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 those of Noftsker. The two negotiated at length, but neither would compromise. As the proposed firm could succeed only 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 firm had a better chance of surviving and commercializing Lisp machines than Greenblatt's proposed self-sustaining start-up. Greenblatt lost the battle.

It was at this juncture thatSymbolics,Noftsker's enterprise, slowly came together. While Noftsker was paying his staff a salary, he had no building or any equipment for the hackers to work on. He bargained withPatrick Winstonthat, 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 fromCDC,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 firm, but he had done nothing. The consultant, Alexander Jacobson, decided that the only way Greenblatt was going to start the firm and build the Lisp machines that Jacobson desperately needed was if Jacobson pushed and otherwise helped Greenblatt launch the firm. Jacobson pulled together business plans, a board, a partner for Greenblatt (one F. Stephen Wyle). The newfound firm was namedLISP Machine, Inc.(LMI), and was funded by CDC orders, via Jacobson.

Around this time Symbolics (Noftsker's firm) began operating. It had been hindered by Noftsker's promise to give Greenblatt a year'shead 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. Two AI Lab people were not hired by either:Richard StallmanandMarvin 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.[4]

Regardless, after a series of internal battles, Symbolics did get off the ground in 1980/1981, selling the CADR as the LM-2, whileLisp 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 firms developed second-generation products based on the CADR: theSymbolics3600 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,[5]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 hardware differences existed.Texas Instruments(TI) joined the fray when it licensed the LMI-LAMBDA design and produced its own variant, theTI Explorer.Some of the LMI-LAMBDAs and the TI Explorer were dual systems with both a Lisp and aUnixprocessor. TI also developed a 32-bitmicroprocessorversion of its Lisp CPU for the TI Explorer. This Lisp chip also was used for the MicroExplorer – aNuBusboard for the AppleMacintosh 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, aVLSIimplementation 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 shrank the Explorer into silicon as the MicroExplorer which was offered as a card for the AppleMac II.LMI abandoned the CADR architecture and developed its own K-Machine,[6]but LMI went bankrupt before the machine could be brought to market. Before its demise, LMI was working on a distributed system for the LAMBDA using Moby space.[7]

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

The MIT-derived Lisp machines ran a Lisp dialect namedLisp Machine Lisp,descended from MIT'sMaclisp.The operating systems were written from the ground up in Lisp, often using object-oriented extensions. Later, these Lisp machines also supported various versions ofCommon Lisp(withFlavors,New Flavors,andCommon Lisp Object System(CLOS)).

Interlisp, BBN, and Xerox[edit]

Bolt, Beranek and Newman(BBN) developed its own Lisp machine, named Jericho,[8]which ran a version ofInterlisp.It was never marketed. Frustrated, the whole AI group resigned, and were hired mostly by Xerox. So,XeroxPalo Alto Research Centerhad, simultaneously with Greenblatt's own development at MIT, developed their own Lisp machines which were designed to run InterLisp (and laterCommon Lisp). The same hardware was used with different software also asSmalltalkmachines and as theXerox Staroffice system. These included the Xerox 1100,Dolphin(1979); the Xerox 1132,Dorado;the Xerox 1108,Dandelion(1981); the Xerox 1109,Dandetiger;and theXerox 1186/6085,Daybreak.[9]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 namedMedley.The Xerox 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 likeNoteCards(one of the firsthypertextapplications).

Xerox also worked on a Lisp machine based onreduced instruction set computing(RISC), using the 'Xerox Common Lisp Processor' and planned to bring it to market by 1987,[10]which did not occur.

Integrated Inference Machines[edit]

In the mid-1980s, Integrated Inference Machines (IIM) built prototypes of Lisp machines named Inferstar.[11]

Developments of Lisp machines outside the United States[edit]

In 1984–85 a UK firm, Racal-Norsk, a joint subsidiary ofRacalandNorsk Data,attempted to repurpose Norsk Data'sND-500supermini as a microcoded Lisp machine, running CADR software: the Knowledge Processing System (KPS).[12]

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

In France, two Lisp Machine projects arose: M3L[21]at Toulouse Paul Sabatier University and later MAIA.[22]

In Germany Siemens designed the RISC-based Lisp co-processor COLIBRI.[23][24][25][26]

End of the Lisp machines[edit]

With the onset of theAI winterand the early beginnings of themicrocomputer revolution,which would sweep away the minicomputer and workstation makers, cheaper desktop PCs soon could run Lisp programs even faster than Lisp machines, with no use of special purpose hardware. Their high profit margin hardware business eliminated, most Lisp machine makers had gone out of business by the early 90s, leaving only software based firms likeLucid Inc.or hardware makers who had switched to software and services to avoid the crash. As of January 2015,besides Xerox and TI, Symbolics is the only Lisp machine firm still operating, selling theOpen GeneraLisp machine software environment and theMacsymacomputer algebra system.[27][28]

Legacy[edit]

Several attempts to write open-source emulators for various Lisp Machines have been made: CADR Emulation,[29]Symbolics L Lisp Machine Emulation,[30]the E3 Project (TI Explorer II Emulation),[31]Meroko (TI Explorer I),[32]and Nevermore (TI Explorer I).[33]On 3 October 2005, the MIT released the CADR Lisp Machine source code as open source.[34]

In September 2014, Alexander Burger, developer ofPicoLisp,announced PilMCU, an implementation of PicoLisp in hardware.[35]

The Bitsavers' PDF Document Archive[36]has PDF versions of the extensive documentation for the Symbolics Lisp Machines,[37]the TI Explorer[38]and MicroExplorer[39]Lisp Machines and the Xerox Interlisp-D Lisp Machines.[40]

Applications[edit]

Domains using the Lisp machines were mostly in the wide field 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'sKnowledge Engineering Environment(KEE), Knowledge Craft, from The Carnegie Group Inc., and ART (Automated Reasoning Tool) from Inference Corporation.[41]

Technical overview[edit]

Initially the Lisp machines were designed as personal workstations for software development in Lisp. They were used by one person and offered no multi-user mode. The 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 astack machinewith 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. For example, only one addition operation 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 returnstrue. 

(defunexample-count(predicatelist)
(let((count0))
(dolist(ilistcount)
(when(funcallpredicatei)
(incfcount)))))

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

Command:(disassemble(compile#'example-count))

0ENTRY:2REQUIRED,0OPTIONAL;Creating PREDICATE and LIST
2PUSH0;Creating COUNT
3PUSHFP|3;LIST
4PUSHNIL;Creating I
5BRANCH15
6SET-TO-CDR-PUSH-CARFP|5
7SET-SP-TO-ADDRESS-SAVE-TOSSP|-1
10START-CALLFP|2;PREDICATE
11PUSHFP|6;I
12FINISH-CALL-1-VALUE
13BRANCH-FALSE15
14INCREMENTFP|4;COUNT
15ENDPFP|5
16BRANCH-FALSE6
17SET-SP-TO-ADDRESSSP|-2
20RETURN-SINGLE-STACK

The operating system usedvirtual memoryto provide a large address space. Memory management was done with garbage collection. All codeshared 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 termedprocesses.All processes ran in the one 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: AppleMacintosh IIandSun-3orSun-4.

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

See also[edit]

  • ICAD– example ofknowledge-based engineeringsoftware originally developed on a Lisp machine that was useful enough to be then ported via Common Lisp to Unix
  • Orphaned technology

References[edit]

  1. ^Newquist, H.P. (1 March 1994).The Brain Makers.Sams Publishing.ISBN978-0672304125.
  2. ^Target, Sinclair (30 September 2018)."A Short History of Chaosnet".Two-Bit History.Retrieved6 December2021.
  3. ^Moon, David A.(1985). "Architecture of the Symbolics 3600".ACM SIGARCH Computer Architecture News.13(3). Portal.acm.org: 76–83.doi:10.1145/327070.327133.S2CID17431528.
  4. ^Levy, S:Hackers.Penguin USA, 1984
  5. ^Moon 1985
  6. ^K-Machine
  7. ^Moby spaceArchived25 February 2012 at theWayback MachinePatent application 4779191
  8. ^"Computing Facilities for AI: A Survey of Present and Near-Future Options".AI Magazine.2(1). 1981.
  9. ^Tello, Ernest R (July 1987)."The Xerox 1186 LISP Machine".Dr. Dobb's Journal.No. 129. pp. 118–125.The Xerox 1186, nicknamed Daybreak, provides several unique, powerful features at a relatively low cost. [...] The 1186 closely resembles an earlier machine from Xerox—the 1108, or Dandelion.
  10. ^"The AAAI-86 Conference Exhibits: New Directions for Commercial AI, VLSI Lisp Machine Implementations Are Coming".AI Magazine.8(1). 1987.
  11. ^"The AAAI-86 Conference Exhibits: New Directions for Commercial AI, A New Lisp Machine Vendor",AI Magazine,8(1), 1987,retrieved12 November2011
  12. ^"Computer Algebra in Norway, Racal-Norsk KPS-5 and KPS-10 Multi-User Lisp Machines". Springer link.doi:10.1007/3-540-15984-3_297.{{cite journal}}:Cite journal requires|journal=(help)
  13. ^"Facom Alpha".Computer Museum.IPSJ.Retrieved12 November2011.
  14. ^"NTT ELIS".Computer Museum.IPSJ. 9 September 1983.Retrieved12 November2011.
  15. ^Yasushi, Hibino (25 August 1990)."A 32-bit LISP Processor for the Al Workstation ELIS with a Multiple Programming Paradigm Language, TAO".Journal of Information Processing.13(2). NII: 156–164.Retrieved12 November2011.
  16. ^Mitsuo, Saito (25 August 1990)."Architecture of an AI Processor Chip (IP1704)".Journal of Information Processing.13(2). NII: 144–149.Retrieved12 November2011.
  17. ^"NEC LIME Lisp Machine".Computer Museum.IPSJ.Retrieved12 November2011.
  18. ^"Kobe University Lisp Machine".Computer Museum.IPSJ. 10 February 1979.Retrieved12 November2011.
  19. ^"RIKEN FLATS Numerical Processing Computer".Computer Museum.IPSJ.Retrieved12 November2011.
  20. ^"EVLIS Machine".Computer Museum.IPSJ.Retrieved12 November2011.
  21. ^"M3L, A Lisp-machine".Limsi.Retrieved12 November2011.
  22. ^"MAIA, Machine for Artificial Intelligence".Limsi.Retrieved12 November2011.
  23. ^Hafer, Christian; Plankl, Josef; Schmidt, Franz Josef (1991), "COLIBRI: A Coprocessor for LISP based on RISC",VLSI for Artificial Intelligence and Neural Networks,Boston, MA: Springer: 47–56,doi:10.1007/978-1-4615-3752-6_5,ISBN978-1-4613-6671-3
  24. ^Müller-Schloer (1988), "Bewertung der RISC-Methodik am Beispiel COLIBRI", in Bode, A (ed.),RISC-Architekturen[Risc architectures] (in German), BI
  25. ^Hafer, Christian; Plankl, Josef; Schmitt, FJ (7–9 March 1990), "COLIBRI: Ein RISC-LISP-System" [Colibri: a RISC, Lisp system],Architektur von Rechensystemen, Tagungsband(in German), München,DE:11. ITG/GI-Fachtagung
  26. ^Legutko, Christian; Schäfer, Eberhard; Tappe, Jürgen (9–11 March 1988), "Die Befehlspipeline des Colibri-Systems" [The instruction pipeline of the Colibri system],Architektur und Betrieb von Rechensystemen, Tagungsband,Informatik-Fachberichte (in German),168,Paderborn,DE:10. ITG/GI-Fachtagung: 142–151,doi:10.1007/978-3-642-73451-9_12,ISBN978-3-540-18994-7
  27. ^"symbolics.txt".
  28. ^"A few things I know about LISP Machines".
  29. ^"CADR Emulation".Unlambda.Retrieved12 November2011.
  30. ^"Symbolics L Lisp Machine Emulation".Unlambda. 28 May 2004.Retrieved12 November2011.
  31. ^"The E3 Project, TI Explorer II emulation".Unlambda.Retrieved12 November2011.
  32. ^"Meroko Emulator (TI Explorer I)".Unlambda.Retrieved12 November2011.
  33. ^"Nevermore Emulator (TI Explorer I)".Unlambda.Retrieved12 November2011.
  34. ^"MIT CADR Lisp Machine Source code".Heeltoe.Retrieved12 November2011.
  35. ^"Announce: PicoLisp in Hardware (PilMCU)".
  36. ^"Bitsavers' PDF Document Archive".Bitsavers.Retrieved12 November2011.
  37. ^"Symbolics documentation".Bitsavers.Retrieved12 November2011.
  38. ^"TI Explorer documentation".Bitsavers. 15 May 2003.Retrieved12 November2011.
  39. ^"TI MicroExplorer documentation".Bitsavers. 9 September 2003.Retrieved12 November2011.
  40. ^"Xerox Interlisp documentation".Bitsavers. 24 March 2004.Retrieved12 November2011.
  41. ^Richter, Mark:AI Tools and Techniques.Ablex Publishing Corporation USA, 1988, Chapter 3, An Evaluation of Expert System Development Tools
General

External links[edit]

Retrieved from "https://en.wikipedia.org/w/index.php?title=Lisp_machine&oldid=1234422559"