Jump to content

TENET 210

Add links
From Wikipedia, the free encyclopedia

The TENET 210 was a mainframe computer designed for timesharing services. The machine was designed for high throughput and expandability, including 20 direct memory access (DMA) channels and eight slots for core memory, allowing up to 128k 32-bit words of RAM. The sales materials boasted that it guaranteed user responses within one second.

The 210 was the only product of TENET Inc, formed by several former members of Fairchild Semiconductor during its heyday in the late 1960s. The company sold only a single 210 before going out of business.

History

[edit]

The TENET 210 ultimately traces its history to a project within Fairchild Semiconductor's research and development center in Palo Alto, California run by Gordon Moore. A new group organized by Rex Rice was developing a machine specifically for the timesharing market. Known as the Symbol IIR, the design concept was a machine that ran a PL/1-like language as its native assembler language, and would be implemented entirely in hardware - no microcode or firmware was allowed.[1]

In 1966, Chuck Runge was working for the Atomic Energy Commission, writing programs on a machine at Iowa State University. Rice visited the campus on a recruiting drive and Runge interviewed with Moore that March. Runge joined the company in June, but quickly became disillusioned with the no-software decree, and was convinced the project would never ship. He found a like-minded engineer in Dave Masters, who knew Fairchild president Bob Noyce.[1]

The two approached Noyce with the idea of developing a new computer design. The system was initially pitched as a controller for Fairchild Instrumentation's new Sentry product, a software-controlled semiconductor testing system. This produced the 24-bit Fairchild FST-1, as well as the FACTOR programming language used to program the test suites. Although it was by most measures a general-purpose minicomputer, Fairchild was uninterested in marketing it as such.[2]

At the time, the timesharing market was developing rapidly, and had split into two solution classes; the minicomputer end was aimed at smaller users who would buy a complete system for in-house use, like the HP 2100, while at the other end were large mainframes that sold services on a per-minute basis to users on remote computer terminals, like the GE 635. In 1968, Runge and Masters left Fairchild to form TENET with the intent of building a mid-range system with the price of the mini offerings but the power of the mainframes.[1]

To fund development, Runge took a contract with Fairchild to develop the specification for FACTOR. When this was complete, they managed to arrange a 1969 meeting with Fred Adler, a NY trial attorney who had helped fund Data General. Adler put together a $2 million package to fund the development of two prototypes. Development of the first machine was completed within two years. To introduce the design, in January 1971 they held an open house in which a concert pianist used the prototype as a music synthesizer. However, the company had the bad fortune of launching sales directly into the leading edge of the 1973–1975 recession, and further funding was not available.[2]

Tymshare examined the machine as a replacement for the SDS 940s, and Hewlett-Packard as a replacement for their initial failed effort for what became the HP 3000, but neither effort was successful. The company's one and only sale was a bid in response to a State of California request for proposal for a machine to support their civil engineering teams designing roads and bridges. They won the bid although by this time the company was already in Chapter 11 protection, maintaining the machine through a separate contract that later included the purchase of the original prototype to use as a parts machine. This machine was only retired in the 1980s.[2]

Design

[edit]

The basic concept arranged the machine around a high-performance memory bus they referred to as the "data exchange". In the 200-series design, the only one to be built, there were two independent 32-bit busses. Each could perform a read and a write at the same time, as long as they were to different locations in memory. In total, the bus could provide 20 MB/sec bandwidth. Core memory was connected on one side of the bus, with up to eight modules of 8 to 16k words each. Fully expanded, a system could have 8 x 16 = 128 kWords, or 512 kB.[3]

The 210 was a single-processor design, but in theory up to four 3210 CPUs could be connected to the bus. In the 210, the CPU had two connections to the bus, allowing it to perform a total of four memory operations per cycle.[4] There were twenty ports in total to the bus, so in the 210 there were eighteen free ports on the data bus. Expansion systems included a disk controller which could run one to four 25 MB hard drives, a communications card for up to 16 terminals each, card readers, printer outputs and tape drives.[5]

A significant aspect of the design was its memory paging system, which used conventional hard drives rather than the custom memory drums or specialized hard disks with multiple read/write heads (a random-access disk, or RAD). Making this work with reasonable performance required significant efforts to tune the input/output routines to avoid unnecessary reads and writes, which was handled in the system's hardware memory management unit. Time-to-market and overall cost was also reduced through the use of off-the-shelf TTL small scale integration circuits.[2]

The CPU was designed to minimize the length of code as a further effort to reduce memory swapping. It included eight general-purpose registers and a separate set of eight control registers.[4] Its instruction set included a variety of "rich" instructions for packing and unpacking bytes into words, gathering and scattering data in memory, test-and-set, pre- and post-indexing and pattern matching against memory. The Programmed Instructions, or PINS, were designed to improve the density of subroutine calls; a single 32-bit word called a routine and passed a single parameter. There were sixteen global PINS, hard-wired to key operating system routines. A further 48 PINS were available for user programs.[6]

The system was primarily intended to be used by end-user programmers. It was supplied with two programming languages, FORTRAN IV and TENET BASIC, the later of which they claimed was the most powerful version of the BASIC programming language available.[7] Machines also included a text editor, macro assembler, two debuggers and a single- and double-precision floating point library.[8]

Prices listed in September 1970 put a basic unit, with a single CPU and 32 kWords of memory, at $220,000 (equivalent to $1,726,067 in 2023) while a fully-expanded version with 128 kWords was $475,000 (equivalent to $3,726,735 in 2023). Hard drive controllers were $21,000, the drives themselves $19,500, and the communications card and "quad adaptor" were $4,000 and $2,000 respectively Up to four quad adaptors could be used with each communications card, for a total of 16 terminals per card.[9]

TENET BASIC

[edit]

When the 210 was being designed, the BASIC programming language was widely perceived as the future of timesharing programming. In the mainframe world, almost all dialects of BASIC closely followed the original Dartmouth BASIC, first introduced in 1964.[10] Version 4 of 1968 added string variables denoted by $[a] along with rudimentary string manipulation, as well as a series of MAT commands that performed matrix math using single operations instead of using FOR...NEXT loops over a series of instructions.

TENET BASIC mostly followed the Dartmouth model, with the exception of string variables. Instead of the postfix $ indicating a string, variables were assumed to be single-precision floating-point unless explicitly declared otherwise. These declarations include STRING, INTEGER, REAL (single precision), DOUBLE, COMPLEX and DOUBLE COMPLEX.[b] Setting the values of the complex types required special functions, CMPLX(r,i) and DCMPLX(r,i), where r is the real part, and i the imaginary.[12] String constants could be delimited by double or single quotes.[13]

The language included a full set of math and string functions. It added RAD and DEG functions to convert between radians and degrees, FIX to return the integer part of a number (similar to INT, but always towards zero), FP to get the fractional part, and ROUND. It also included a full set of hyperbolic trig functions. String functions were similar to BASIC-PLUS, using LEFT, RIGHT and SUBSTR as opposed to MID. It also included INDEX to find one string in another.[14]

Another change was in the RND function. If the parameter was zero, it would return random numbers but always in the same sequence. Any positive number would return a random number between 0 or 1, but always the same one on subsequent calls.[c] A negative number used the system clock to seed the value so that it was a different sequence every time the program ran.[15] This contrasts with the more common solution of a separate RANDOMIZE statement that set the seed and ignored the value inside the RND.

Arrays could have two dimensions.[16] One could not use the same variable name for both a scalar variable and an array,[17] in contrast to Dartmouth (and most other dialects) where A and A() refer to different variables. The various MAT commands were used to apply functions to the arrays as a whole. For instance, one could MAT A = B + C where B and C are arrays, producing a new array A with the sums.[18]

IF statements had an optional ELSE clause.[19] FOR statements could be defined in the traditional way with FOR I=1 TO 100 or in the tested form, FOR I=1 WHILE I<=A which runs the test every time through the loop. Normally the end condition is set only once when the FOR is first encountered, so if A held 100 the loop will run 100 times even if the value of A is changed during the loop. Using WHILE will reevaluate the test and thus see any changes to A. This is similar to placing an IF in the body of the loop.[20] PAUSE was a synonym for STOP.[21]

One rather non-standard addition is the DO statement, which was similar in concept to the same command in the JOSS language but with a different syntax. DO statements function like reverse GOSUBs; instead of calling a subroutine and then continuing when the RETURN is encountered, DO allows the routine to be defined as a series of one or more line numbers that will return when they are complete. For instance, DO 20 will call line 20 and then return to the next statement after the DO when line 20 completes, whereas DO 10:50, 100, 200:220 will run lines 10 through 50, then line 100, and then lines 200 to 220.[22]

File handling was based on OPENing a file and giving it an integer file handle, and then performing INPUT FROM or PRINT TO instructions. Reading to the end of a file was handled by setting an ON ENDFILE handler, or ENDREC for record-based files. One could also ERASE FILE to delete data, APPEND FILE to add to the end of an existing file, or RESTORE FILE to rewind it.[23]

The system also included a set of editor commands; ENTER turned on automatic line numbering, DELETE removed a range of lines, ALTER made one of the lines active so it could be edited, and RENUMBER renumbered the lines in the program, or alternatively, a given range. Once could also set the TABs.[23]

Notes

[edit]
  1. ^ This format was widely used after this point, including in Microsoft BASIC.
  2. ^ "Extended" versions of MS BASIC had similar statements DEFSTR, DEFINT and DEFDBL.[11]
  3. ^ The utility of this is not clear in the manual.

References

[edit]

Citations

[edit]
  1. ^ a b c Runge 2008, p. 78.
  2. ^ a b c d Runge 2008.
  3. ^ Brochure 1970, p. 2.
  4. ^ a b Brochure 1970, p. 3.
  5. ^ Brochure 1970, pp. 1, 5.
  6. ^ Brochure 1970, p. 4.
  7. ^ Brochure 1970, p. 6.
  8. ^ Brochure 1970, pp. 7, 9.
  9. ^ Brochure 1970, p. 9.
  10. ^ Kemeny & Kurtz 1985, p. 5.
  11. ^ BASIC-80 Reference Manual (PDF). Microsoft. p. 1.7.
  12. ^ Manual 1970, pp. 3.1–3.2.
  13. ^ Manual 1970, p. 3.3.
  14. ^ Manual 1970, pp. D.1–D.5.
  15. ^ Manual 1970, p. D.6.
  16. ^ Manual 1970, p. 3.4.
  17. ^ Manual 1970, p. 3.5.
  18. ^ Manual 1970, p. 7.3.
  19. ^ Manual 1970, p. 4.14.
  20. ^ Manual 1970, pp. 4.15–4.16.
  21. ^ Manual 1970, p. 4.23.
  22. ^ Manual 1970, p. 4.10.
  23. ^ a b Manual 1970, p. 1.1.

Bibliography

[edit]
Retrieved from "https://en.wikipedia.org/w/index.php?title=TENET_210&oldid=1170231948"