AT&T Hobbit

The AT&T Hobbit is a microprocessor design that AT&T Corporation developed in the early 1990s. It was based on the company's CRISP (C-language Reduced Instruction Set Processor) design, which in turn grew out of the C Machine design by Bell Labs of the late 1980s. All were optimized for running code compiled from the C programming language.

The design concentrates on fast instruction decoding, indexed array access, and procedure calls. Its processor is partially RISC-like.

The project ended in 1994 because the Hobbit failed to achieve commercially viable sales.

History

The C Machine Project at Bell Labs had been underway since 1975 to develop computer architectures to run C programming language programs efficiently, aiming for a design that would offer an order of magnitude performance improvement over commercially available computers while remaining competitive in terms of cost. The design methodology for the C Machine architecture involved an iterative development approach informed by measurements of C program characteristics, involving the formulation and implementation of new computer architecture revisions, the development of a compiler to target each new revision, the compilation of "a large body of UNIX software", and the analysis of the compiled software. The results from such measurements then informed subsequent architecture revisions.[1]

Following on from the stabilisation of the C Machine architecture in 1981 for an uncompleted ECL implementation, a design team was formed for CRISP in April 1983, and CRISP was first produced in a silicon implementation in 1986. The performance objectives were largely met by the fabricated processor, running at 16 MHz and delivering a Dhrystone benchmark score over 13 times greater than the VAX-11/750, achieving approximately 7.7 VAX MIPS. This was competitive with the MIPS R2000 as delivered in the MIPS M/500 Development System (an 8 MHz device delivering around 7.4 VAX MIPS[2]) although some benchmarks showed somewhat stronger performance by the CRISP processor. Compared to the R2000 which required numerous support chips when incorporated into a computer system, the CRISP was a "complete" processor incorporating on-chip caches and had "substantially" reduced board area requirements.[1]

Subsequently reoriented towards low-power applications and commercialised, the result was the Hobbit,[3] introduced in 1992 in the form of the 92010 and aimed at the personal communicator market. Operating at 3.3V, it could achieve a reported performance of 13.5 VAX MIPS. Initial pricing in multiples of 10,000 units was given as $35 per unit, with the full chipset costing below $100.[4] Several support chips were produced:[5]

  • AT&T 92011 System Management Unit
  • AT&T 92012 PCMCIA Controller
  • AT&T 92013 Peripheral Controller
  • AT&T 92014 Display Controller

AT&T followed up in 1993 with the 92020 family of processors, introducing new support chipsets targeting different applications. These devices could be run at 3.3V or at 5V with an elevated clock frequency. The 92020S was pin-compatible with the 92010, utilised a larger 6 KB instruction cache (as opposed to the 3 KB cache of the 92010[6]), and achieved a performance of 16 VAX MIPS with a typical power consumption of 210 mW.[7] The 92020S was intended to be used in conjunction with most of the original 92010 chipset, excluding the 92013 peripheral controller. Meanwhile, the 92020M and 92020MX processors were intended for use with the new support chips, also employing a multiplexed address and data bus for reduced pin count, and offering lower levels of performance, with the 92020M also utilising a 6 KB cache and achieving similar performance to the original 92010. The updated support chips were as follows:[6]

  • AT&T 92021M System Management Unit
  • AT&T 92021MX System Management Unit
  • AT&T 92024M Display Controller

The most highly integrated processor, the 92020MX, preserved the 3 KB cache of the 92010 but incorporated a single-channel PCMCIA interface and a display controller supporting resolutions of up to 640 x 480. Costing $32 per unit in 10,000 unit quantities, it presented opportunities for cost reduction with certain devices when compared to the original Hobbit chipset.[7]

Apple Computer approached AT&T and paid it to develop a newer version of the CRISP suitable for low-power use in the Newton handheld computer. The Hobbit-based Newton was never produced. According to Larry Tesler, "The Hobbit was rife with bugs, ill-suited for our purposes, and overpriced. We balked after AT&T demanded not one but several million more dollars in development fees."[8] Apple dropped its interest in the Hobbit and adopted the ARM610 for the Newton,[9] also partnering with Acorn Computers and VLSI Technology to form Advanced RISC Machines, ARM, in late 1990 with a $2.5 million investment. Apple sold its stake in ARM years later for a net $800 million.[8]

The Active Book Company (founded by Hermann Hauser, who also founded Acorn Computers), which had been using an ARM in its Active Book personal digital assistant (PDA),[10] was later purchased by AT&T and was subsumed by AT&T's Eo subsidiary,[11] which produced an early PDA, the EO Personal Communicator, running PenPoint OS from the GO Corporation.[12]

Hobbit was used in the earliest prototypes of the BeBox until in 1993, AT&T announced discontinuation of Hobbit.[13] With AT&T closing its Eo operations, these being responsible for the only commercially released product using the Hobbit,[14] despite early announcements of broad vendor adoption,[15] AT&T finally discontinued the Hobbit in 1994.[16]

Design

In a traditional RISC design implementing a load–store architecture, memory is accessed through instructions that explicitly load data into registers and store data back to memory, with instructions that manipulate data working solely on the registers. By seeking to limit the data processing operations to a single clock cycle, a simpler control mechanism can be employed to dispatch instructions, making it easier to tune the instruction pipelines,[17] and add superscalar support. However, programming languages do not actually operate in this fashion. Generally they use a stack containing local variables and other information for subroutines known as a stack frame or activation record. The compiler writes code to create activation records using the underlying processor's load-store design.

The C Machine in its CRISP implementation, and the Hobbit that followed directly, both aim to support the types of memory access that programming languages use, with the C programming language being a particular consideration.[6] Instructions can access memory directly, referencing values in structures and arrays held within memory and updating memory with computation results. Although this memory-to-memory model was typical of the earlier CISC designs, the C Machine as implemented by CRISP differs from both CISC and RISC designs, including the earlier Bellmac 32, by providing no directly accessible registers. Instead, a "stack cache" of 32-bit register entries is provided, 32 entries in CRISP but extended to 64 entries in Hobbit,[18]: 30  mapped to the address space corresponding to the top of the program stack, these being purely accessible using a stack-relative addressing mode. The CRISP architecture was described as a "2½ address memory-to-memory machine", where instructions could employ zero, one or two memory addresses as well as employing a stack entry called the accumulator for computation results. Reminiscent of the Bellmac 32 architecture, various instructions designed to support procedure calling are provided by the CRISP architecture: call saves the return address and branches to a routine; enter allocates a stack frame for a routine, flushing stack cache entries if necessary; return deallocates the stack frame and branches to the caller's return address; catch restores stack entries from memory.[1]

One side effect of the Hobbit design is that it inspired designers of the Dis virtual machine (an offshoot of Plan 9 from Bell Labs) to use a memory-to-memory-based system that more closely matches the internal register-based workings of real-world processors. They found, as RISC designers would have expected, that without a load-store design it was difficult to improve the instruction pipeline and thereby operate at higher speeds. They decided that all future processors would thus move to a load-store design, and built Inferno to reflect this. In contrast, Java and .NET virtual machines are stack-based, a side effect of being designed by language programmers as opposed to chip designers. Translating from a stack-based language to a register-based assembly language is a "heavyweight" operation; Java's virtual machine (VM) and compiler are many times larger and slower than the Dis VM and the Limbo (the most common language compiled for Dis) compiler.[19] The VMs for Android (Dalvik), Parrot, and Lua are also register-based.

See also

References
  1. Ditzel, David R.; McLellan, Hubert R.; Berenbaum, Alan D. (1987). "The hardware architecture of the CRISP microprocessor". Proceedings of the 14th annual international symposium on Computer architecture - ISCA '87. pp. 309–319. doi:10.1145/30350.30385. ISBN 0818607769. S2CID 14954824. Retrieved 28 March 2023.
  2. Performance Brief Part 1: CPU Benchmarks (PDF) (Technical report). MIPS Computer Systems Inc. May 1988. p. 12. Retrieved 28 September 2021.
  3. Ryan, Bob (February 1993). "Communications Gets Personal". Byte. pp. 169–170, 172, 174, 176. Retrieved 27 March 2023.
  4. Booker, Ellis (2 November 1992). "AT&T announces line of personal communicators". Computerworld. p. 41. Retrieved 26 March 2023.
  5. Cerda, Michael. "EO Block Diagram". Archived from the original on March 30, 2003. Retrieved May 15, 2009.
  6. Statt, Paul (January 1994). "The AT&T Hobbit Enters Its Second Generation". Byte. p. 105. Retrieved 26 March 2023.
  7. "AT&T Micro Unveils Fastest Hobbit MPU". Electronic News. 18 October 1993. p. 4. Retrieved 26 March 2023.
  8. Tesler, Larry (11 April 1999). "'The Fallen Apple' Corrections". Archived from the original on 2016-03-04. Retrieved 2020-08-21.
  9. Redfern, Andy (July 1992). "Apple ARMs Itself". Byte. p. 134. Retrieved 10 October 2022.
  10. "Xmas Launch for Active Books". Acorn User. August 1990. p. 7. Retrieved 6 May 2021.
  11. Kirkpatrick, David (1993-05-17). "COULD AT&T RULE THE WORLD?". CNN. Retrieved 2008-06-10.
  12. Glitman, Russell (December 1992). "Eo Communicator: Lord of the Roads". PC World. p. 58. Retrieved 30 March 2023.
  13. Gassée, Jean-Louis (2019-01-31). "50 Years In Tech Part 15. Be: From Concept To Near Death". Medium. Retrieved 2020-08-31.
  14. Smith, Ernie (3 January 2020). "Fax on the beach: The story of the audacious, totally calamitous iPad of the '90s". Input. Retrieved 2020-11-01.
  15. "Wide hardware and applications support for AT&T Hobbit chips" (Press release). AT&T. 16 November 1992. Archived from the original on 1996-12-26. Retrieved 30 March 2023.
  16. Hacker, Scot; Bortman, Henry; Herborth, Chris (1999). The BeOS Bible. Peachpit Press. p. 34. ISBN 0201353776. Retrieved 30 March 2023.
  17. Patterson, David A. (January 1985). "Reduced Instruction Set Computers". Communications of the ACM. Association for Computing Machinery. 28 (1): 8–21. doi:10.1145/2465.214917. S2CID 1493886. Retrieved 3 April 2023.
  18. ATT92010 Hobbit Microprocessor. AT&T Microelectronics. December 1992. Retrieved 7 April 2023.
  19. "The design of the Inferno virtual machine". April 22, 2013. Archived from the original on 2013-04-22.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.