Jump to content

AT&T Hobbit

From Wikipedia, the free encyclopedia

The AT&T Hobbit is a microprocessor design developed by AT&T Corporation in the early 1990s. It was based on the company's CRISP (C-language Reduced Instruction Set Processor) design resembling the classic RISC pipeline, and 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.

The project was ended in March 1994[1] because the Hobbit failed to achieve commercially viable sales.

History

[edit]

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.[2]

Following on from the stabilization 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[3]) 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.[2]

It was subsequently reoriented toward low-power applications and commercialized, resulting in the Hobbit.[4] It was introduced in 1992 in the form of the 92010 and aimed at the personal communicator market. Operating at 3.3V, its reported performance is up to 13.5 VAX MIPS. Initial pricing in multiples of 10,000 units was given as $35 per unit, with the full chipset below $100.[5] Several support chips were produced:[6]

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

AT&T followed in 1993 with the 92020 family of processors, introducing new support chipsets targeting different applications. These devices can run at 3.3V or at 5V with an elevated clock frequency. The 92020S is pin-compatible with the 92010, has a larger 6 KB instruction cache (as opposed to the 3 KB cache of the 92010[7]), and performs the equivalent of 16 VAX MIPS with a typical power consumption of 210 mW.[8] 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 utilizing a 6 KB cache and achieving similar performance to the original 92010. The updated support chips are as follows:[7]

  • 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 has 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.[8]

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."[9] Apple rejected the Hobbit and adopted the ARM610 for the Newton,[10] 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.[9]

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),[11] was later purchased by AT&T and was subsumed by AT&T's Eo subsidiary,[12] which produced an early PDA, the EO Personal Communicator, running PenPoint OS from the GO Corporation.[13]

AT&T made early announcements in 1992 of broad vendor adoption.[14] Hobbit was used in the earliest prototypes of the BeBox until in 1993, AT&T announced discontinuation of Hobbit.[15] AT&T closed its Eo operations which were responsible for the only commercially released product using the Hobbit,[16] and finally discontinued the Hobbit in 1994.[17]

Design

[edit]

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,[18] 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.[7] 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 is 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,[19]: 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 can employ zero, one, or two memory addresses and can employ 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.[2]

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.[20] The VMs for Android (Dalvik), Parrot, and Lua are also register-based.[citation needed]

See also

[edit]

References

[edit]
  1. ^ Dominic Giampaolo (2008). Practical File System Design.
  2. ^ a b c 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 March 28, 2023.
  3. ^ Performance Brief Part 1: CPU Benchmarks (PDF) (Technical report). MIPS Computer Systems Inc. May 1988. p. 12. Retrieved September 28, 2021.
  4. ^ Ryan, Bob (February 1993). "Communications Gets Personal". Byte. pp. 169–170, 172, 174, 176. Retrieved March 27, 2023.
  5. ^ Booker, Ellis (November 2, 1992). "AT&T announces line of personal communicators". Computerworld. p. 41. Retrieved March 26, 2023.
  6. ^ Cerda, Michael. "EO Block Diagram". Archived from the original on March 30, 2003. Retrieved May 15, 2009.
  7. ^ a b c Statt, Paul (January 1994). "The AT&T Hobbit Enters Its Second Generation". Byte. p. 105. Retrieved March 26, 2023.
  8. ^ a b "AT&T Micro Unveils Fastest Hobbit MPU". Electronic News. October 18, 1993. p. 4. Retrieved March 26, 2023.
  9. ^ a b Tesler, Larry (April 11, 1999). "'The Fallen Apple' Corrections". Archived from the original on March 4, 2016. Retrieved August 21, 2020.
  10. ^ Redfern, Andy (July 1992). "Apple ARMs Itself". Byte. p. 134. Retrieved October 10, 2022.
  11. ^ "Xmas Launch for Active Books". Acorn User. August 1990. p. 7. Retrieved May 6, 2021.
  12. ^ Kirkpatrick, David (May 17, 1993). "COULD AT&T RULE THE WORLD?". CNN. Retrieved June 10, 2008.
  13. ^ Glitman, Russell (December 1992). "Eo Communicator: Lord of the Roads". PC World. p. 58. Retrieved March 30, 2023.
  14. ^ "Wide hardware and applications support for AT&T Hobbit chips" (Press release). AT&T. November 16, 1992. Archived from the original on December 26, 1996. Retrieved March 30, 2023.
  15. ^ Gassée, Jean-Louis (January 31, 2019). "50 Years In Tech Part 15. Be: From Concept To Near Death". Medium. Retrieved August 31, 2020.
  16. ^ Smith, Ernie (January 3, 2020). "Fax on the beach: The story of the audacious, totally calamitous iPad of the '90s". Input. Retrieved November 1, 2020.
  17. ^ Hacker, Scot; Bortman, Henry; Herborth, Chris (1999). The BeOS Bible. Peachpit Press. p. 34. ISBN 0201353776. Retrieved March 30, 2023.
  18. ^ Patterson, David A. (January 1985). "Reduced Instruction Set Computers". Communications of the ACM. 28 (1). Association for Computing Machinery: 8–21. doi:10.1145/2465.214917. S2CID 1493886. Retrieved April 3, 2023.
  19. ^ ATT92010 Hobbit Microprocessor. AT&T Microelectronics. December 1992. Retrieved April 7, 2023.
  20. ^ "The design of the Inferno virtual machine". April 22, 2013. Archived from the original on April 22, 2013.
[edit]
Retrieved from "https://en.wikipedia.org/w/index.php?title=AT%26T_Hobbit&oldid=1219835073"