4 ms·
I guess next week they're going to get to the interesting bit which is how weird the architecture actually was on that thing... https://en.wikipedia.org/wiki/T
by PaulHoule 2y ago
I guess next week they're going to get to the interesting bit which is how weird the architecture actually was on that thing...
https://en.wikipedia.org/wiki/TI-99/4A https://en.wikipedia.org/wiki/TI-99/4A
Particularly it only had 256 bytes of RAM attached to the CPU but had (I think) 16 kb of RAM attached to the video controller which the CPU could read and write through I/O registers. You could use this for non-video storage but you couldn't access it directly.
Coding in BASIC could, at the very least, hide the insanity from you.
- bb88 2y agoAs I recall at the time, very few people knew how to write assembly for that machine, as there just wasn't a lot to go on. I enjoyed the sprites though, and that was something that was definitely different than Apple II, IBM, etc. at the time. Apple and IBM's graphics were definitely a step down. C64 could do sprites with POKE statements apparently. But that was definitely not as nice as the TI.
- qiqitori 2y agoSpeaking of interesting bits, this machine isn't actually an 8-bit computer, the CPU is 16-bit. (The video controller is 8-bit though, i.e. the VRAM data bus is 8-bits. It's also the same video controller used in various other machines, e.g. MSX.)
- phire 2y ago"Bits" is a stupid measure of "computer". The TI-99/4A clearly belongs in the 8-bit era of computers. Motorola's 68000 was the single most prolific microprocessor of the 16-bit era. Yet all the registers are 32-bit, and all the instructions easily operate on 32-bit values [1]. About the only claim to being "16-bit" is the 16-bit wide data bus. If we go by that metric, then the IBM PC (with its 8088 hobbled by an 8-bit data bus) is clearly just another 8-bit microcomputer. BTW, this is absolutely the way that Motorola sees it. The 68008 is just a 68000 hobbled with an 8-bit data bus, and they label it as a 8/32-bit microprocessor. [1] And if anyone dares to point out that the 68000's ALU is only 16-bits wide, then I have bad news about the Z-80: It only has a 4-bit ALU, so I guess it's actually a 4-bit microprocessor
- bonzini 2y agoThe Amiga was loudly marketed as having a 32-bit CPU though (the Atari ST a lot less so, for whatever reason). Having a 16-bit ALU in theory would make the 9900 a 16-bit processor as much as the 8086. The TI-99/4A is definitely weird (and slow!!) but it does fit the definition of a 16-bit system.
- moosedev 2y agoThe ST very subtly so, even :) > "ST" officially stands for "Sixteen/Thirty-two", referring to the Motorola 68000's 16-bit external bus and 32-bit internals. via https://en.wikipedia.org/wiki/Atari_ST https://en.wikipedia.org/wiki/Atari_ST
- RiverCrochet 2y agoWell, I was gonna say this: A CPU is X bits if the highest number of bits that the value of a "load immediate" instruction can have is X. But I think this makes MIPS 16-bit.
- phire 2y agoWorse, that would mean Arm64 is a 12-bit CPU. The original 32-bit ARM encoding could only load 8 bit immediates, though later versions gained a 16-bit load immediate instruction. RISC-V is a bit better off, as it has a special encoding for 20 bit immediates, while Alpha and PowerPC are the same as MIPS, stuck with 16-bit immediates.
- qiqitori 2y agoAhh, but that would be mean because it would make ARM64 CPUs 16-bit too. Though actually if you put -1 and it sign-extends to 0xFFFF'FFFF'FFFF'FFFF then that's technically 64-bit? :p
- spogbiper 2y agothe motorola 6809 can load 16 bit values into some of its registers but i've always seen it called an 8 bit CPU
- 2y ago
- jhallenworld 2y agoThe other early 16-bit CPUs include: National Instrument's PACE- I've never seen one used in anything: https://en.wikipedia.org/wiki/National_Semiconductor_PACE https://en.wikipedia.org/wiki/National_Semiconductor_PACE but its bit-slice precursor, the IMP-16 was used in Aston Martin's Lagonda https://sprague.com/peter-sprague/aston-martin/ https://sprague.com/peter-sprague/aston-martin/ https://opposite-lock.com/topic/90934/lagonda-dashboards https://opposite-lock.com/topic/90934/lagonda-dashboards General Instrument's CP1600, used in the Intellivision (a video game console yes, but there was a home computer keyboard attachment). http://spatula-city.org/~im14u2c/chips/GICP1600.pdf http://spatula-city.org/~im14u2c/chips/GICP1600.pdf Its co-processor, the CP1640 is famous for evolving into Microchip's PIC microcontroller.
- kragen 2y agoMuch more influential 16-bit CPUs from that era include the PDP-11's CPU, the Data General Nova's CPU, the Xerox Alto's CPU, and arguably even the 8086 and 8088. The chronology seems to go as follows: - 01965: IBM 1130 - 01966: HP 2116A, the first model of the HP 2100 series - 01969: Nova - 01970: PDP-11 - 01971: IBM System/7 - 01973: Alto (not shipped. NEVER shipped) - 01973: TI-990 (the 990/3, according to https://cozx.com/dpitts/ti990.html https://cozx.com/dpitts/ti990.html) - 01974: HP 3000 - 01974: PACE (which was from National Semiconductor, not National Instruments) - 01975: CP1600 - 01976: TMS9900 (what the TI-99/4A used) - 01976: Tandem (first Tandem/16 shipped to Citibank) - 01978: 8086 - 01979: 8088 - 01981: TI-99/4A Since there were plenty of 6-bit, 8-bit, 12-bit, 32-bit, 36-bit, 60-bit, and 64-bit CPUs in the 01950s, you'd think there would be some 16-bit CPUs then too, but I can't think of any. I'd even forgotten about the HP 2100 until I went looking just now.
- PaulHoule 2y agoDepends what you call '16-bit'. The addressable word size [1] for the PDP-11 was 8-bits and the problem space address space was 16-bits so a user program on the PDP-11 could ac cess 64kB of RAM, same as an Apple ][, except that multiple users could have their own address spaces. The IBM 360 had 24-bit addresses, 8-bit words, and 16 32-bit registers. 8-bit words were thoroughly established by 1980s for general purpose computers, I think because of the use of 7/8-bit ASCII characters. I mean, you could pack ASCII characters into larger words in different ways but the most comfortable (portable) way to handle them is to have a char* which requires either 8-bit words or some way to address subwords. The PDP-10 was probably the most loved heterodox architecture with a 20-bit address space and 36-bit words. It had pointers that could point to specific bits inside a word so it was possible to port C to it with char*'s. The user space was 256k words and 1152M bytes. (If an architecture like the PDP-10 let you access bits in the next word you could even point something like a char* at a variable sized UTF-8 char if you don't mind pointer arithmetic being limited to scans) Some of the 8-bit micros had 16-bit registers such as the 8086/8088 and the 6809. The word size doesn't have to be related to the size of the data bus: the 8088 had an 8-bit data bus and the 8086 had a 16-bit data bus, it just pumped twice if it needed 16-bits. The 68k series had 32-bit registers and a 32-bit address space (like the DEC VAX which was the first modern computer) but had various bus sizes as low as 8-bits in the 68008. With a cache the data bus could be larger than the word size. Programming really isn't fun if you don't have index registers at least as large as the address space. There were numerous attempts to extend 8-bit architectures to a 24-bit address space that didn't provide large enough index registers, the 65816 is probably the most famous. The eZ80 on the other hand, extends the registers to 24-bits so it's easy to write programs that use the whole address space. [1] which I'm just going to call word size
- phire 2y agoIt gets way weirder. The TMS9900 didn't have any internal data registers. It only had a program counter, a status register, and a workspace pointer. Instead, it put the "registers" in that same 256 bytes of RAM. There were sixteen 16-bit registers which the workspace pointer pointed to. The original idea was that this made for fast context switches, instead of dumping all registers to stack (it doesn't even have a stack pointer), just update the workspace pointer to point at a new set. But I have to assume this wasn't really used on the TI-99/4A, as there just wasn't enough RAM. Because your only other ram was locked behind the video controller, that 256 bytes had to contain all your registers, any your dynamically loaded code and any data you wanted rapid access to. The TMS9900 is weird, because it's the only CPU of the early home computer era that wasn't designed for microcomputers. It's actually an implementation of the TI-990 mini-computer on a single chip and is actually used in later versions of the minicomputer. Those minicomputers had more than enough fast 16-bit memory to take advantage of this fast context switching. Every other commonly used microprocessor of the 70s (8080, 6800, F8, 6502, RCA1802, Z80, 6809, 8086, 68000) was explicitly designed to target the low-cost microcomputer market.
- McGlockenshire 2y agoI've been working on a TMS99110 homebrew & emulator, and have studied the architecture of the 990 a whole lot over the past couple years. I want to make a very important distinction in a few things you said. For anyone that didn't get the context, it's the 99/4 design that has this weird RAM layout. The 990 architecture itself can use any (16-bit) word in memory as the starting point of the 16 registers. Developers have been known to use and abuse the workspace pointer to slide around the "window" on the registers. The window itself also uses the top three registers to link back to the previous workspace, status, and PC, if you use the proper instructions to branch and return. While there is no stack*, you can still crawl back through those references and get the state of each call. It's a really cool little architecture, hobbled by the 16-bit address space and how slow it was to keep the registers in RAM. Nowadays I can pick up a 1MB memory chip that's faster than the native bus speed for a few bucks, but that wasn't anywhere near the case in the late 70s and early 80s. *: The 990/12 minicomputer features the PSHS and POPS instructions, which take a pointer to a definition of where the stack lives and how big it should be. These instructions are not implemented in any production processor, but the platform makes it possible to emulate these instructions in software transparently... as an actual explicit instead of accidental feature in the later few iterations. The 990/12 itself was microcoded on a set of four daisy-chained programmable 4-bit bit slicers so they didn't need any of that nonsense.
- lightedman 2y ago"Coding in BASIC could, at the very least, hide the insanity from you." Except TI-BASIC is a hell-riddled double-interpreted language. I had a 99/4A at the age of 6, learned how to use all of the TI-BASIC language by 8, and said screw that, hardware it is for me, dad's buying me a 286 for Christmas, time to learn how to build that!