ICT 1900
From Wikipedia, the free encyclopedia
ICT 1900 is the name given to a series of mainframe computers released by International Computers and Tabulators (ICT) in the 1960s.
Contents |
[edit] 1900 Series computers
These varied in computing power and the models included:
- ICT 1901
- ICT 1902
- ICT 1903
- ICT 1904
- ICT 1905
- ICT 1906
- ICT 1907
- ICT 1909 (this machine had a hardware floating point arithmetic engine so it was suitable for scientific use.)
The first machine was in fact the 1904 which was a Canadian design from the Ferranti-Packard company, originally called the FP6000. It is said that this machine with 'core store memory' fired up with its program still in store after its sea freight journey from Canada.[citation needed]
One feature of these mainframes was the common instruction set throughout the range meaning that programs written and compiled on one machine would run unchanged on any other. In fact the hardware was different between machines. To achieve this a program termed "the executive" or exec encapsulated the hardware and supplied software routines to supplement the hardware supplied instructions.
By 1968 ICT had merged with English Electric computers and become ICL.
Enhanced versions of the 1900 series subsequently appeared with an A suffix, an E suffix, an F suffix (for floating point), a T suffix, and an S suffix, e.g.
Stevenage designed and built machines, typically smaller system using the E3RM executive software
- ICL 1901A
- ICL 1901S/T
- ICL 1902A
- ICL 1902S
- ICL 1902T
- ICL 1903A
- ICL 1903S
West Gorton (Manchester) built machines, typically larger system using the E6RM executive software
- ICL 1903T
- ICL 1904A
- ICL 1904T
- ICL 1904S
- ICL 1906S
The 1900 Series were 24-bit word machines (supporting 4 6-bit characters per word) and using octal for binary short-hand, as opposed to the IBM Systems using 8-bit bytes and hex. Basic memory on the smaller machines was 16K words (or 64 kilobytes equivalent), and there were even 8K word versions sold (although most actually had 16K memory factory installed in readiness for the certain upgrade order that followed!) - early machines using 'core-store' memory (ferrite rings on a copper wire matrix) and operated on binary hand-switches on the mainframe cabinet. Despite the apparent small memory size, quite sophisticated applications were run on the equipment and computer programmers paid great attention to the efficient use (and reuse) of memory.
Input and output (I/O) consisted of 80 column cards (40 column cards - with round holes - were unable to cope with the full 64 character set), a card punch and 8-track paper tape; printed output was produced on a solid barrel line printer (120 columns wide).
The first commercial sale was made in 1964 to the Morgan Crucible Company and consisted of a 16k word 1902 with an 80-column 980 card/minute reader, a card punch, a 600 line/min printer and 4 x 20Kbs tape drives. It was soon upgraded to a 32K word memory and a floating point unit to allow for some scientific work. Incidently this company was also the first business to order ICT's previous computer, the HEC4 (later ICT 1201) in 1955.
Disk capacity was also very limited, with early units supporting 4 or 8Mb removable multi-disc packs (first introduced on 1903 systems) (and Steve Hillel crashed the first unit when demonstrating it to his manager) and careful attention to ensuring the efficient use of disk space was common. Early machines used storage on reels of magnetic tape and were then augmented by direct access devices (disks) typically with disk capacities of 1.6Mb, 4Mb and 8Mb were the order of the day. By the time 30Mb packs were available they occupied a cabinet 4 feet high (MEDS - Multiple Exchangeable Disk Store).
After ICL had introduced the "New Range" (NR) series of computers during the 70s, marketed as the 2900 series, the 1900 series actually lived on as there was such a wealth of software written for it:
- The ICL 2903/2904, designed and built in Stevenage, which were really successors to the 1902A/3A machines as they had the same target instruction set (albeit with a native 32 bit rather than 24 bit architecture)
- Second generation "S3E" (microcoded) versions of the larger NR systems (such as the 2960/2966 from West Gorton, and the later 2940/50 from Stevenage), could run 1900 series code under DME (Direct Machine Environment) as an emulation as well as the New Range instruction set under the newer VME (Virtual Machine Environment)
- The later availability of CME (Concurrent Machine Environment) microcode, which allowed DME and VME to co-exist (and run) concurrently on the same platform, similar to the functionality offered by virtualisation software such as VMware today
- The replacement for the 2903/4 was the ME29 (Machine Environment 29) with its own operating system, TME (Transaction Machine Environment), which could still execute 1900 applications
- An update of CME to CME* in the 1980s to support a small VME range called DM1 that replaced the ME29, which could run TME within a VME VM (virtual machine)
Programming languages included the assembly type language PLAN (Programming LAnguage Nineteen-hundred) and latterly COBOL for the development of commercial-orientated systems while ALGOL and FORTRAN were used for scientific work.
The basic operating System was called "Executive" and supported "multiprogramming", i.e. it was capable of running as many as 4 programs concurrently, on the 1904 and larger machines. Later on (starting about 1968) advanced features (e.g. batch processing, spooling) were provided by a privileged ("trusted") program called GEORGE.
[edit] Instruction Set (1900)
The 1900 series machines were designed around a 'load-and-store' architecture.
Two address-modes were supported, one which used 15-bits and one which used 22-bits. This meant that a normal program written in '15AM' could use a maximum of 32768 words of data (32k) while a program written in '22AM' could address up to 4194304 (4m) words of data.
There were eight 24-bit registers (denoted r0 to r7), to address which three bits were required; the instruction code took up seven bits (000 to 177 in octal) of the word; registers 1, 2 and 3 could be used as 'modifiers' to the operand (requiring a further two bits, zero meaning no modifier) which left twelve bits for the operand itself. The registers occupied and were addressable as the first 8 words of memory.
If it was required to use more than a 12-bit operand, the required value could be loaded into r1,r2 or r3 and the respective register used as a modifier (index), which was added to whatever was put in the operand.
The instruction set was heavily word oriented - machine addresses represented words rather than bytes. Two instructions were provided for character manipulation: LDCH (LoaD CHaracter) and DCH (Deposit CHaracter). These used the two most significant bits of the address to specify which of the 4 six-bit characters of a word was to be loaded into, or deposited from, a register. As an instruction operand was only 12 bits long, these instructions were only useful if a modifier was also used.[1]
[edit] Character Set
The basic character set was based around a 6-bit byte, which meant that only 64 different characters could be represented: upper case letters, the numbers 0 to 9 and a handful of other symbols. In the early days most output devices printed only in uppercase, and it was only with the advent of VDUs (Visual Display Units) that lower-case output started to become possible and printers began to support a 96-character set. To change case or output control codes a "3 shift" coding was used, character #74 (octal 74, "$" in the 64 character set) was used as "α shift" to indicate subsequent characters were uppercase, #75 ("]" in the 64 character set) was "β shift", indicating subsequent characters were lowercase and #76 ("↑") was "δ shift" and indicated the subsequent character was a control character (or one of "$", "]" or "↑"). For example the text "$200! You MUST be joking" would be encoded as ↑T200! Y]OU $MUST ]BE JOKING (Text was assumed to start in α shift (uppercase), δ shift "T" was displayed as "$"). [2]
The ICL ASCII codes for the symbols $ (dollar) £ (pound) and # (hash) were different from the other major suppliers of computer equipment.
[edit] Operating systems and software
[edit] The Georges
- George I (GEneral ORGanisational Environment)
- George IS
- George II
- George 2S
- George 2+ (from Dataskil)
- George 3
- George 4
[edit] Utilities and compilers
- XEKB COBOL compiler
- XEMC Extended mode COBOL compiler
- XPCK Consolidator
- XPJC Disc file allocator
- XPJQ Magnetic Tape Header utility
- XPJW Backup and restore utility
- XSDC Disc Sort (sort contents of files)
- XPLG PLAN compiler (Programming Language Nineteen Hundred) Assembly language
- XPLT PLAN 4 compiler
- YMTC tape copier
- YMTV tape formatter
- FIND File Interrogation of Nineteenhundred Data (data analysis package)
[edit] Application software
- SCAN Stock control system (Acronym: Stock Control and Analysis on Nineteen-hundred)
- PERT Project management system (Acronym: Project Evaluation and Review Technique)
- PROSPER Financial planning system (forerunner of today's spreadsheet programs)
- NIMMS Production control system (Acronym: Nineteen-hundred Integrated Modular Management System)
- JEAN Interactive, time sharing programming language (Acronym: JOSS Extended and Adapted for Nineteen-Hundred]]
- More detailed history is available at [1] (requires Internet Explorer)
