IBM System/34

IBM System/34 (model 5340)

The IBM System/34 was an IBM midrange computer introduced in 1977.[1] It was withdrawn from marketing in February, 1984.[1] It was a multi-user, multi-tasking successor to the single-user System/32. Most notably, it included two very different processors, one based on System/32 and the second based on older System/3. Like the System/32 and the System/3, the System/34 was primarily programmed in the RPG II language. One of the machine's interesting features was an off-line storage mechanism that utilized "magazines" - boxes of 8-inch floppies that the machine could load and eject in a nonsequential fashion. Borrowing mainframe features such as programmable job queues and priority levels, the System/34 ran on 64K of memory.

Physical appearance and requirements

The System/34 5340 System Unit resembled a huge washer-dryer in appearance, and was noisy, due to its internal cooling fans. It had several access doors on both sides. Inside, were swing-out assemblies where the circuit boards and memory cards were mounted. It weighed 700 pounds and used standard household 220V power. The system cost US$100,000-plus.

IBM abbreviations

IPL - Initial Program Load

Starting or restarting the system. This acronym was pronounced eye-pee-ell and was used as a verb ("IPL the system") with past tense ("then we IPLed") and present tense ("while we were IPLing") and so forth - as well as a noun ("after the next IPL.")

APAR—Authorized Program Analysis Report

An APAR announced the entry of each new System/34 bug into the IBM process. If it was a genuine problem, the details would be sent for resolution to Rochester (for system problems) or Menlo Park / Rayners Lane (for application problems in MMAS, CMAS or DMAS). Eventually the APAR would be fixed by a corresponding PTF (see below).

PTF - Program Temporary Fix

IBM would distribute bug fixes on diskettes called PTF diskettes. By applying PTFs, the user could address software problems. When the next release was issued (S/34's last release was Release 9 in 1981) the old PTFs were incorporated into the release update diskettes the user received, and the old diskettes became useless. Since PTFs were only temporary in the sense that they were superseded by later releases of SSP, using the name "PTF" was considered odd.

F1, I1, S1-S3, and M1.01 - M2.10

These are proper names given to system equipment.

F1 is the Fixed Disk (the hard drive.) I1 is the Diskette Drive. S1, S2, and S3 are the three single Diskette Slots (if a magazine drive is connected.) M1.01-M1.10 are diskette slots 1 through 10 on Magazine 1. M2.01-M2.10 are diskette slots 1 through 10 on Magazine 2.

Software

SSP, The System/34 Operating System

SSP ("System Support Program") was the only operating system of the S/34. It contained support for multiprogramming, multiple processors, 36 devices, job queues, printer queues, security, indexed file support, and fully installed, it was about 5 MB.

Language compilers

The S/34 had five: RPG II, COBOL, BASIC, FORTRAN, and Assembler. RPG was cheaper, created compact code sizes, and became the best-seller. Cobol was popular in the business community. Fortran is not very practical for data processing purposes, and while Basic was nice, it was implemented as an interactive 40K session. Assembly language is efficient, but it is a little too easy to accidentally create a processor check on the System/34.

One feature of the S/34 was that Basic and Fortran were exclusive. One could not run a Fortran program on the system when running Basic, nor vice versa. Fortran was certainly not a popular language, so one would suppose this microcode level problem was only annoying to academia.

The implementation of Basic on the S/34 is very close to that of the System/36, the System/32, the System/38, and the AS/400 (iSeries.) The implementation of RPG II on the System/34 is similar to the RPG II used on the System/36, the System/370 and the System/390, but not like the RPG III and subsequent RPG compilers for the iSeries.

SDA - Screen Design Aid

This application allows the operator to build screen formats or menus online. Screen formats are very much like what Visual Basic and Access call "forms." Command keys can be enabled/disabled. Input fields, output fields, and constants can be created and conditioned. Conditions (in RPG these are called indicators) can cause fields to disappear, change colors, and so forth.

SORT - The system sort utility

SORT has one to eight input files, which may be of any valid record length. It has one output file, of any stated length, which may contain from zero to 8 million-plus records.

A sort can contain entire records or just 3-byte addresses which point to records in an associated file. This was called an address-out file or ADDROUT. When using an Addrout, the program read in these 3-byte addresses and then fetched associated records from the master file.

A programmer who wanted the benefits of a System/38-style logical file would use an Addrout with a RETAIN-S disposition: 

// LOAD MYPROG
// FILE NAME-ADDROUT,LABEL-WS.SORT,RETAIN-S
// RUN

After the program finishes, the Addrout file doesn't exist anymore. It has been "scratched," or set to RETAIN-S, meaning the system auto-deletes it.

SEU - Source Entry Utility

This looks like a DOS-era text editor. SEU allows data entry on a line-by-line basis. Special forms are used to assist the operator in keying RPG programs or other types of form-based languages (WSU, Sort, SDA, etc.)

WSU - Work Station Utility

This was an RPG-like language that ran on the S/34. It was focused on data entry type programs. WSU was free, but it wasn't particularly well-received because it was so limited.

Terminals, displays, screens, workstations and monitors

An operator sat in front of a device that vaguely resembles today's PC, except the monitor was small, expensive (US$2,000), low-resolution (24x80) and the available colors were green and bright green. Colour screens (7 colours) arrived later.

For preparing data input diskettes, as a successor to card punches, there was a special workstation called a "dual display" (3742) which employed a system of mirrors to split a horizontally mounted screen into two 12x80 displays. Two users sat on either side of it with two keyboards and two diskette drives.

IBM colors

Before 1984, the 5251 monitor predominated - it was US$2,000 and what IBM called "dual color" (green and bright green). However, by 1984, the IBM 3180 terminal helped usher in the age of IBM Color - seven colors (pink, red, blue, yellow, green, white, and turquoise.) By 1984, the price of the 3180 terminals was under US$2,000, though there was a graphics-capable terminal. By 1986, there was another type of "color" monitor - instead of green, the displayed characters were yellow ("amber," in IBM-speak).

Programming IBM colors

Programming colors did not require a new screen programming language, because the implementation was completely at the hardware level. A protocol called the IBM 5250 Data Stream interpreted field attributes such as blinking, non-display, high intensity, reverse image, underline, and column separators and was used in combination to create colors. Normal text was presented as green on a 3180 color terminal, but high intensity became white. Column separators became yellow. Blinking became red. Underlined text was presented as blue. High intensity blinking became pink. High intensity column separators became turquoise.

The five lights

On a 5251 type terminal, there were five lights to watch for:

(1) System Available light. If lit, this terminal is connected to the S/34 and is receiving information from it.

(2) Message Waiting light. Other users, and the system itself, can send messages to workstations. If lit, there is at least 1 message that has not been seen yet. When a program ends or when the user signs on, the message(s) will be shown.

(3) Insert. The Insert key has been pressed. Characters after the cursor while shift right when text is keyed. Press Insert again to cease Insert Mode.

(4) Caps Lock light. The Caps Lock key has been pressed. All keys pressed will be uppercase. Press Caps Lock again to unlock.

(5) Keyboard Shift light. The Shift key is being pressed. The key pressed simultaneously will be uppercase.

Keyboards

The 5251 and 5291 terminals used an 83-key keyboard with a similar key arrangement to the IBM PC 5150. Later 5250-compatible terminals used a 122-key or 102/103-key keyboard. There was a special terminal and keyboard for Katakana, a syllabary of the Japanese Language

Configuring devices

Dipswitches

Printers and workstations had a series of binary switches known as "dipswitches" for configuration. The binary OFF settings, zero ("0") and one ("1") were used to switch back and forth internally. In U.S. English and UK English, the British use the pound sterling ("£") and the Americans use the dollar ("$"). A switch could be set up on printers and monitors where in the zero position the British value would display or print. In the one position the American value would display or print. .

Setting the address

Up to 32 devices could be configured on a System/34, using four lines numbered from 0 to 3. A line was defined as a series of twinaxial cables attached to devices with IN and OUT ports. Eight devices could be configured per line; these were numbered 0 through 7.

Three binary switches on every device were used for the terminal's address (the physical designation of a particular terminal on a particular line.) Sometimes, the switches were numbered 1, 2, and 4. In order to set an address, simple addition was used:

Zero is all settings off. One is the 1 setting on. Two is the 2 setting on. Three is the 2 and 1 settings on. Four is the 4 setting on. Five is the 4 and 1 settings on. Six is the 4 and 2 settings on. Seven is all settings on.

Two devices can never have the same address on one line. Once the addresses were set, the system could be configured to use them.

Configuring using CNFIGSSP

The CNFIGSSP procedure was used to configure the system, including the devices. Each device is assigned a two-character ID. The first letter must be alphabetic; the second must be alphameric. The system also reserved certain IDs; the device can't be called I1 or F1, for example. I1 is the name of the diskette drive; F1 is what the system calls the hard drive (stands for "fixed disk," since it is not a removable disk pack.)

Use CNFIGSSP to place devices on the line/address map; identify the particular IBM printer or terminal model; assign characteristics such as console, alternate console, subconsole; and to name the printer's subconsole.

To apply CNFIGSSP, the system must be dedicated (no other users logged on or programs running.) The system must be IPLed (rebooted.) When IPL finished, the new devices would appear on the status display.

Processors

S/34s had two processors, the Control Storage Processor (CSP), and the Main Storage Processor (MSP). The MSP was the workhorse, based on System/3 architecture; it performed the instructions in the computer programs. The CSP was the governor, a different processor with different semi-RISC instruction set, based on System/32 architecture; it performed system functions in the background. Special utility programs were able to make direct calls to the CSP to perform certain functions; these are usually system programs like $CNFIG which was used to configure the computer system. These two processors worked in tandem.

Clock speed of the CPUs inside a System/34 was fixed at 1 MHz for the MSP and 4 MHz for the CSP. In today's PC-based world, the S/34 was the computational equivalent of a 16 to 20 MHz intel 80386 microprocessor.

Memory and disk

The smallest S/34 had 48K of RAM and an 8.6 MB hard drive. The largest configured S/34 could support 256K of RAM and 256MB of disk space. This cost over US$200,000 back in the early 1980s. S/34 hard drives contained a feature called "the extra cylinder," so that bad spots on the drive were detected and dynamically mapped out to good spots on the extra cylinder... so technically while the system did not recognize more than 256MB, slightly more space than this existed.

Printers

Typical System/34 offerings would include:

System security

There are three types of System/34 security: the badge reader that almost nobody ever bought, so it isn't discussed here; password security; and resource security.

Password security was used to begin a session at a computer terminal. Unless security was inactive, a correct password must be entered to begin.

The System/34 sign on looked like this:

* SIGN ON                                W1
* USER ID......... ________
* PASSWORD........ ____
* MENU (OPTIONAL). ______
* LIBRARY......... ________

The PROF ("Profile") procedure was used to work with User IDs and passwords. The user profile contains a 1-to-8 character alphanumeric User ID, a 4 character alphanumeric password, a code for the user's security rating—M (Master Security Officer), S (Security Officer), O (System Operator), C (Subconsole Operator), or D (Display Station Operator) -- and a number of other default settings.

The PRSRCID ("Profile Resource Security By User ID") procedure was used to establish security ratings for file and library objects. Access levels of O (Owner), G (Change), R (Read), E (Execute) or N (None) could be granted for a user to a particular resource.

The printed disk catalog (VTOC, Volume Table of Contents) displayed all secured objects with the notation 3 as being secured.

Files and libraries

SSP provides for two different data objects called files and libraries. Files contain records, almost always with a fixed record length. Libraries contain programs which can reference and access these files. SSP contained more than 60 different commands that allowed operators to create, delete, copy, edit/change, and secure files and libraries.

Disk space metrics

Disk space on the System/34 was organized by "blocks." One block = 2560 bytes. A high-end system would ship with about 90,000 blocks of disk space available. System objects could be allocated in blocks or records, but internally it was always blocks.

Program sizes

Since the S/34 ran "16-bit" programs, the largest program that could be compiled and run was 64K. Most were not nearly that large. Since memory addresses were stored in 16 bits, a 64K program was often a giant monster RPG screen program with 3,000 lines of code, five or six files, and forty-odd array/table entries.

Caching

<<Read this section with caution; much more than 48K RAM was available on S/34; the process to squeeze a program into a smaller executable size was called overlaying.>>

A 64K computer program can run on a S/34 when only 48K of RAM is available by using a process called caching. The system uses a cache or workspace on the hard drive to contain portions of the programs currently running. Loading the whole program into the cache area and then moving it piecemeal in and out of storage was a system function performed by the CSP. The MSP performed the instructions in the computer program. Insufficient memory makes the system run slower, since the disk speed was only about as good in the 1980s as PC drives are today, and modern "burst mode" rates were unheard of.

SPOOLING

SPOOL is an acronym for Simultaneous Peripheral Operations On Line.

The need for spooling

Computer printers are slow. On the S/34, computer programs could write data to the printer much faster than the printer can print and there can be more than one program writing to a printer at the same time.

How spooling works

To allow the system to manage the problem, system components called "writers" and "spool files" were developed. A writer is a small system program that reads the spool file, matches a particular printer with a ready-to-print spool object, and begins sending instructions to the printer. It is a two-way process; the printer sends a signal back to the system when it is ready for more work. In order to avoid mixing up data from two spool files, the first report to finish and close is traditionally printed first.

Unspooling

Sometimes the operator requires a dedicated, live printer - for example, when printing receipts for customers in real time, don't use spooling. Use the PRINTER OCL statement to declare the symbolic print job to be unspooled (SPOOL-NO.)

Forms numbers

When the operator prints paychecks, it is important that paycheck information printed on checks forms and not on plain paper; likewise, a regular printout should never print on expensive check forms. Therefore, forms numbers were created. A forms number is a one-to-four-character alphameric field that programs and operators use. Programmers use the PRINTER OCL statement as follows:

// PRINTER NAME-PAYCHECK, FORMS-BUXX, DEVICE-P1

When the spool writer is ready to process the checks spool entry, this message appears at the subconsole:

SYS-1404 OPTIONS (012 )
ON PRINTER P1, CHANGE TO FORMS NUMBER BUXX

By replying 1 to this message AFTER changing the forms, the operator could be sure that no other reports on standard stock would print on the checks.

Forms alignment

The expensive check forms must be perfectly aligned or all of the numbers won't fit in the little boxes. Therefore, an alignment can be performed using the PRINTER OCL statement:

// PRINTER NAME-PAYCHECK, FORMS-BUXX, DEVICE-P1,ALIGN-YES

The subconsole will now get this message when ready to print checks:

SYS-5825 OPTIONS (012 )
ALIGN THE FORMS IN PRINTER P1

By replying this message AFTER aligning the forms, the operator could be sure that the check information didn't print until the forms were properly aligned.

Jobs and job queues

In S/34 parlance, a job is any task the computer has been asked to do. A job has a job number, which for a program is the Workstation ID plus the time in HHMMSS format. For a printout, there's a spool job, which is "SP" and a four-digit suffix which is incremented by 1.

Sometimes a needed report should be run in the background so as not to delay the users. If the parameters of the report are defined, it shouldn't occupy the user's time or occupy that valuable area on the CRT. For this reason, the Job Queue was invented. Imagine the program standing in line waiting to use the computer processor. A job queue has a size (the number of jobs that can be in line) and a value for concurrency (how many lines there are, or, more accurately, job queue jobs that can run at the same time.)

JOBQ OCL

The JOBQ OCL statement causes the job queue job to be initialized, but it won't begin immediately if there's a lineup. This allows some greater control of system resources.

EVOKE OCL

The EVOKE OCL statement also causes the job to run in the background, but EVOKE causes the called module to start immediately as a new job, while the procedure that EVOKEd the called module continues to run. There is no delay as there can be when JOBQ is called.

Program attributes - MRTs, SRTs, NRTs and NEPs

MRT = Multiple Requestor Terminal program. SSP could attach up to 7 terminals to a program at once. Any operator could start the program at their terminal, then other operators' terminals would be attached when they selected the same program. The maximum number of terminals to be serviced was controllable by the programmer.

SRT = Single Requestor Terminal program. Not a MRT.

NRT = No Requestor Terminal program. Started at a terminal, the NRT releases the requesting terminal and continues. This is similar to an MS-DOS TSR (Terminate and Stay Resident) program. By definition, any program that was EVOKEd or submitted to the JOBQ was a NRT.

NEP = Never Ending Program. This was typically an interactive MRT program that would wait after all terminals disconnected until some terminal reconnected, avoiding initiation overhead. This was commonly used to allow large programs to be implemented as a chain of small programs that would pass the terminals from one to another while remaining ready to continue processing for other terminals and/or subsequent transactions. NRT programs could also be NEPs if written to loop and wait for some condition indicating there was work to be done. NEP programs normally did not end until system shutdown, unless written to recognize some special terminate condition.

Other object types

Cobol, Fortran, and RPG generated object code (type O). Basic was interpreted only; a compilation utility called BASICS created subroutine code (type R). Basic programs could be saved as sources for compatibility with other computers, but the project's text was preserved in the subroutine (unless the programmer used the LOCK parameter to keep it private.)

Procedures, which use OCL to start programs and assign resources to them, are type P.

Source members for all objects are type S, with the exception of Basic as above-specified.

DFU programs generated subroutine (R) code. So did WSU programs.

Screen formats generated object code.

Menus generated object code. A menu is simply a very specific screen format with a companion message member suffixed with two pound signs ("##") to contain the action to be taken when the associated number was chosen. System/34 menus allowed the operator to choose numbers between 1 and 24. On the System/34, a clever programmer could customize a menu using screen format language, but, caution, calling a customized menu that does not conform to exacting system requirements can cause a program error.

Message members generated object code that could be called by a program using the MEMBER OCL statement:

// MEMBER USER1-PROGMSG

Passing a four-digit code to an assembler routine returned the associated text. It was also a clever way for the computer programmer to push up to 10,000 74-byte constants out of program space.

Non-programmers use of the computer

The non-programmer could create a short sequence of file and input specifications and store them as a source member. A component called Data File Utility could then be used to generate on-screen displays for creating and edit files and print reports. It was not quite the equal of say, Access 2007, but in twenty minutes a file and a report could be designed Alternatively, define the data files and have the system generate a simple report program, using the Create Auto Report command.

Popular System/34 applications

MAPICS, the Manufacturing and Planning Integrated Control System, was a popular S/34 application, as were CMAS and DMAS II, all developed at IBM's offices in Menlo Park.

The System/34 Text Editor was a precursor to the IBM Office programs of the future System/36 (DisplayWrite, IDDU, Query, and so forth.)

There was a version of POP (Programmer and Operator Productivity Aid) that ran on a System/34. POP became extremely popular on the System/36 because of its browse and search functions for libraries and files and its easy point-and-shoot interface.

There was a games library called FUNLIB that contained games like Star Trek, Football, Hangman, Coffee, Grand Prix, and a status demo program called STDEMO that graphically displayed currently running programs.

The Britz Word Processing System was a general-purpose text editor that had mailmerge, label, and basic file editing capabilities.

System/34 magazines

Programmers read about the System/34 in monthly magazines like DataNetwork and News 34/38. Subscription prices were high (around US$8-US$12 per copy) but most Data Processing departments had a subscription. Issues were highly prized amongst programmers for their programming tips.

Migrating to the System/36

From 1984 until the mid-1990s, businesses began the process of shutting down their S/34s and moving to twice-as-powerful System/36s. The two machines were not object-code compatible; but source code from a System/34 would compile and go on a System/36.

Some System/34 hardware was incompatible with the System/36. An example is the 5252 Dual Display Station, which could not be configured on a S/36

See also

References

  1. 1 2 IBM Corporation. "System/34". IBM Archives. Retrieved December 4, 2012.

.

Further reading

This article is issued from Wikipedia - version of the Friday, March 18, 2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.