CDC PPU COMPASS

CDC PPU COMPASS is the peripheral-processor side of COMPASS, Control Data Corporation’s assembler for its 60-bit 6000, 7600 and Cyber computers. Each of these machines has one fast central processor surrounded by a set of small, independent 12-bit computers called peripheral processors (PPs, or PPUs in some manuals), and COMPASS assembled code for both. The central processor ran user programs. The PPs handled all input and output, drove the operator’s console, and ran most of the operating system, including its monitor. PP COMPASS was therefore the language of CDC’s system programmers. Application programmers could assemble PP code, but only privileged jobs could run it.

History & Origins

From ASPER to COMPASS

The CDC 6600’s first software was built around the SIPROS operating system. Its PP assembler was ASPER, short for “Assembly System PERipheral Processor”. ASPER was tied closely to ASCENT, the central-processor assembler of the time. The ASPER manual says an ASPER routine had access to all the symbols of the central-processor program it belonged to, whether that program was written in ASCENT, FORTRAN or both. The manual also mentions the “SIPROS resident”, which occupied PP locations 7000 to 7776 (octal) at run time.

When CDC replaced SIPROS with SCOPE, COMPASS became the assembler for both processors. The first sign of the change is a CDC training guide copyrighted 1966, titled ASPER/COMPASS Programming Training Guide for Peripheral Processors. It works through the PP instruction set one instruction at a time, with coding exercises. The instruction names in it (LDN, LDC, LDD, LDI, LDM, STD, RJM, CRD, IAM and so on) are the ones PP COMPASS used for the rest of its life.

By April 1967 CDC had published the 6400/6500/6600 COMPASS Reference Manual (publication 60190900). It says a COMPASS subprogram “consists of either central processor (CP) code or peripheral processor (PP) code”, and that the pseudo instruction PERIPH “declares the program to be a PP program and absolute”.

The encyclopedia index dates PPU COMPASS to 1964, which is the year of the 6600 hardware. This page uses 1966, the date of the earliest document that names COMPASS for the peripheral processors, and the same year used for the companion CDC CPU COMPASS page.

Why the PPs existed

Ralph Grishman’s textbook on 6000-series assembly language explains why the PPs had their own memories rather than sharing central memory. I/O works in small units, “typically one number or character (e.g., one card column)”. I/O devices are slow, so a PP can keep up with them while working a few digits at a time. PPs also do not need large words for precise arithmetic. And giving every PP direct access to central memory “would require considerably more central memory electronics”. Grishman adds that because the PPs are independent processors they can also act as system monitors: “In a 6600 system, there are normally 10 PP’s; one or two can be assigned to supervisory functions, and the rest used for I-O operations.”

The Machine Behind the Language

The August 1970 6000 Series Computer Systems Hardware Reference Manual describes the processor that PP COMPASS targeted:

The ten PPs did not have ten sets of logic. They shared one set of arithmetic and control hardware through a 10-position barrel: each PP’s current instruction state went round the barrel, and each passed through the shared “slot” once every 1000 ns. So although there were ten independent programs, the hardware worked on each one in turn.

A PP can also start or interrupt the central processor with an exchange jump (EXN), which swaps the central processor’s registers with a package held in central memory. This is how the operating system, running in the PPs, switched the central processor between jobs.

Key Features

Instruction formats and address modes

A PP instruction is 12 bits (a 6-bit operation code f and a 6-bit field d) or 24 bits (the same, plus a 12-bit m in the next word). The third letter of most mnemonics shows the address mode:

Because the d field is only 6 bits wide, direct addressing reaches only the first 64 words of PP memory. These direct cells acted as the PP’s working registers. System programs gave them names (T1, T2 and so on for scratch cells), and a program’s first job was often to define its own with EQU.

I/O and central-memory instructions

About a quarter of the operation codes deal with the outside world:

• Channel tests: AJM, IJM, FJM and EJM jump if a channel is active, inactive, full or empty.
• Channel control: ACN activates a channel, DCN disconnects it, and FAN and FNC send a function code to a device.
• Data transfer: IAN and OAN move one word between a channel and A. IAM and OAM move a block between a channel and PP memory.
• Central memory: CRD and CWD read or write one 60-bit word as five PP words. CRM and CWM move blocks, with the central-memory address in A.

The 1966 ASPER manual gives execution times in major cycles (1 µs each on the 6000 series): 2 for LDC or LDD, 3 for an indirect load, and 5 plus 5 per word for a CRM block read from central memory.

Assembler behaviour in PP mode

The same COMPASS program handles both dialects, but the 1986 manual lists several differences for PP assemblies:

• PP programs are always absolute; there is no relocating loader for PP code. The load address is the origin minus 5, because five 12-bit PP words are overlaid by the 60-bit loader table.
• CPU register names such as X1 or A6 are ordinary symbols in a PP assembly.
• Floating-point constants, ENTRY, EXT and the other linkage pseudo instructions are illegal.
• No “forcing upper” occurs, because PP instructions are not packed into 60-bit words.
• CON produces 12-bit (or 16-bit) words, where a CPU assembly produces 60-bit words.
• A PP program name is limited to three characters for 12-bit PP programs, four for Cyber 180 16-bit programs, and seven on the 7600.

The three-character limit is why SCOPE and NOS PP programs have names like 1AJ, DSD, MTR and 1DL.

A Worked Example

The main loop and one subroutine of KAL, the kaleidoscope display written by John P. Strait in 1976, from the NOS 2.8.7 “cgames” package in the DtCyber repository. The program runs in a PP and draws directly on the console’s two screens. The comments are Strait’s own, including his note on CNC:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

          IDENT  KAL,KAL
          PERIPH
          BASE   MIXED
          SST    RDS
*         (DIRECT CELL AND SYMBOL DEFINITIONS)
 CH       EQU    CHDS        DISPLAY CHANNEL
 XC       EQU    16          X COORDINATE
 YC       EQU    17          Y COORDINATE
 MZ       EQU    23          12 BIT MINUS ZERO (7777)
*         (...)
          ORG    PPFW

 KAL      RJM    PRS         PRESET KALEIDOSCOPE
 KAL1     RJM    PSS         PAUSE FOR SYSTEM
          RJM    CNC         COMPUTE NEW COORDINATES
          RJM    SXY         SEND X,Y COORDS TO SCREENS
          RJM    CTD         CHECK TIME DELAY
          RJM    CKS         CHECK FOR KEY STRUCK
          UJN    KAL1        GO BACK FOR MORE
*
*         I DON'T UNDERSTAND THIS ROUTINE, BUT IT WORKS.

 CNC      SUBR               ENTRY/EXIT
          LDD    YC
          RJM    SCL         SCALE Y COORDINATE
          LMD    MZ
          ADD    XC          ADD X COORDINATE
          STD    XC          NEW X COORDINATE
          RJM    SCL         SCALE X COORDINATE
          ADD    YC          ADD Y COORDINATE
          STD    YC          NEW Y COORDINATE
          UJN    CNCX

Some things to notice:

• PERIPH on the second line switches COMPASS into PP mode.
• XC, YC and MZ are direct cells, locations 16, 17 and 23 octal. LDD XC and STD XC reach them in a single 12-bit instruction.
• LMD MZ negates. LMD is the “logical difference” (exclusive OR) with a direct cell. MZ holds 7777 octal, which is minus zero in 12-bit one’s complement, so XOR with it flips every bit and negates the value.
• RJM and SUBR. A return jump stores the return address at the jump target and continues at the next word. SUBR is a system macro that sets up this linkage, so the routine returns by jumping to its exit label CNCX.
• ORG PPFW sets the origin to PPFW, a symbol from the system common decks for the first PP word available to a loaded program after the PP resident.

Evolution

The PP instruction set grew with the hardware. According to the 1986 manual:

• Cyber 170 800-series and Cyber 180 models added a 22-bit R register that relocates central-memory addresses for the central read and write instructions. It is loaded and stored with LRD and SRD.
• The manual lists monitor exchange jumps, MXN and MAN, alongside the original EXN.
• The Cyber 180 introduced a “long” 16-bit PP mode. COMPASS assembled it under the CIPPU pseudo instruction, and MEMSEL 8 allowed an 8192-word PP memory on the Model 990 and some 840, 850 and 860 systems.
• COMPASS also assembled special instructions for the 6416, a configuration with PPs and no central processor, which the 1970 hardware manual describes as otherwise identical to the other 6000 systems.

Current Relevance

The hardware has long since gone, but PP COMPASS still runs under simulation. DtCyber, maintained on GitHub by the Nostalgic Computing Center and descended from Tom Hunter’s Desktop CYBER, emulates the peripheral processors along with the central processor. Its NOS 2.8.7 kit puts COMPASS on the initial deadstart tape, and its optional “cgames” product is a job file containing the COMPASS source of the 1970s console programs. The CYBIS system in the same kit still includes the PP COMPASS lessons, stored under the CYBIS user “ppu”.

Bitsavers keeps scans of the key documents: the ASPER manual, the 1966 training guide, the COMPASS reference manuals from 1967 to 1986, and CDC’s PP COMPASS course workbooks and instructor’s guide. Many of the scans have no text layer, but the Internet Archive’s OCR copies make them searchable.

No official Docker image exists. Running PP COMPASS means building DtCyber and installing one of its operating-system kits.

Why It Matters

The 6600 split its work unusually. Seymour Cray’s central processor did no I/O at all; the PPs did it, along with much of the supervisory work. Later SCOPE versions ran part of the monitor, CPMTR, on the central processor, but MTR stayed in PP0. Grishman’s textbook calls the PPs “super data channels”. PP COMPASS was how that design was actually programmed. It is a small, very regular language (one accumulator, 64 working cells in the first 64 words of memory, channel instructions that test and move 12-bit words), and CDC wrote its monitors, console displays, disk and tape drivers, and deadstart code in it for about two decades.

It is also a record of how hardware limits shape software conventions: three-character program names to fit a 12-bit header, direct cells used as registers, one’s complement arithmetic, and overlays loaded into 4096 words of memory. The surviving console games show how far people could push those limits for fun.