DEC PDP-11 History

pdp11 peripherals and interfacing handbook, part number 112-01071-1854 D-09-25 from 1971. This handbook desribes the UNIBUS bus. The copyright page explains how the book was produced through a new typesetting method where the text was entered and formatted on a DECsystem-10 and the copied to a DEC typesetting system on DECtape magnetic tapes.

The pdp-11/45 processor handbook from 1973, part number 67-00473-2743 JN-09-30. This handbook described the pdp-11/45 instruction set and timings.

Here is the forward from page iii. Note how yellow the page is.

The PDP-11 is a family of upward compatible computer systems. We believe that these systems represent a significant departure from traditional methods of computer design.
The initial design step was the introduction of a totally new language, notation, and theory of evolution of computers called the Instruction Set Processor (ISP). This language provides a concise and powerful generalized method for defining an abritrary computer system and its operation. Along with the development of ISP, a PDP-10 program was written for simulating the operation of any computer system on the basis of its ISP description. With the aid of ISP and the machine simulation program, benchmark comparison tests were run on a large number of potential computer designs. In this manner, it was possible to evaluate a variety of design choices and compare their features and advantages, without the time and expense of actually constructing physical prototypes.
Since the main design objective of the PDP-11 was to optimize total system performance, the interaction of software and hardware was carefully considered at every step in the design process. System programmers continually evaluated the efficiency of the code which would be produced by the system software, the ease of coding a program, the speed real-time response, the power and speed that could be built into a system executive, the ease of system resource management, and numerous other potential software considerations.
The current PDP-11 Family is the result of this design effort. We believe that its general purpose register and UNIBUS organization provides unparalleled power and flexibility. This design is the basis for our continuing commitment to further PDP-11 product development.
Thus the PDP-11 Family is at once a new concept in computer systems, and a tested and tried system. The ultimate proof of this new design approach has come from the large and rapidly increasing number of PDP-11 users all around the world.
Kenneth H. Olsen
President,
Digital Equipment Corporation

The RSX-11M Mini-Reference for RSX-11M Version 4.1, part number AV-5570E-TC, first printed 1977, last revised 1983.

In RSX, programs had to have three letter names. (To save space, DEC used an octal coding called RAD-50 that packed three characters per 16-bit word using a 40-position character set (A-Z and 0-9 plus punctuation)). This manual had basic commands like
BAD for finding bad blocks,
BRU for making and restoring backups,
CMP for comparing files,
EDI for the line-oriented text editor,
EDT for the standard editor (gnu-emacs still has edt-emulation-on to emulate this editor),
FLX for converting between DOS-11 and FILES-11 volume formats,
FMT for formatting a device,
LBR for creating libraries,
PIP for copying files,
MCR and DCL for command line shells, and
TKB for building tasks (the RSX name for executables).

DEC operating systems specified files with the syntax
volume:[#,#]name.ext;ver
where volume was a two letter name plus a digit, name was at most 6 characters, ext was at most 3 characters, and ver was a version number. For example, a typical name might be
DR0:[30,12]FILE.TXT;10

EDT ran on both PDP-11's and VAXen. When we switch to Unix, I hacked MicroEmacs to work like EDT on a keypad. My MicroEmacs source is at ftp://ftp.newspapersystems.com/pub/binaries/src/

PDP-11's used 16-bit addressing, so programs could access at most 64 KB. Most DEC operating systems allowed separate instruction and data space, which allowed 64 KB of code and 64 KB of data. Later versions of RSX allowed supervisor mode libraries, which you could call like DLL's. Each library could have 64 KB. We supported RSTS, so we could not use libraries. I don't think that we ever supported IAS, and we never supported RT (a single user real time operating system).

Our largest program was called ILP, the Interactive Layout Program. In order to make it fit in 64 KB, we had to overlay the code. An overlay would let the system store two modules of code at the same location in memory. When you called a routine in an overlay, the run-time overlay loader would pull the module from the task file on disk if needed. (This probably explains why task files had to be contiguous on the disk to be executable). Unfortunately, when a subroutine returned, the loader could not check to see if the module being returned to was still in memory. This allowed you to create the dreaded V-call:

   /--A
 X-
   \--B

If a routine in module X called a routine in module A, and then if the routine in module A called a routine in module X that called a routine in module B, after B returned to X, the system would not know to reload A into memory before returning from X back to A. The return from X would end up jumping into the middle of B, which would usually cause the program to trap.
ILP was about 1/4 million lines of Fortran, and the overlay for ILP was 6 pages long with several co-trees. The overlay included a custom overlay of the fortran runtimes based on one of DEC's sample overlays. In order to reduce code space (and also to improve performance in PDP-11 systems without hardware floating point), my first work on ILP in 1984 was to convert all of the real numbers to scaled integers. The compiler did not have an integer-only switch, and some operators could generate real number math instructions as optimizations, so whenever I compiled a subroutine, I made an assembly listing, and I wrote a program to scan the assembly code for real number op codes. By the time of the final PDP-11 version of ILP, whenever I added a new subroutine (and sometimes even when I made an existing subroutine larger), shuffling the overlay to make the subroutine fit would often take as long as writing the subroutine itself did. Towards the end, I even got creative and made module loading stubs so I could create intentional V-calls without causing traps. I was a happy camper the day we stopped supporting RSX, and I no longer needed to maintain the overlay, although, for about a year, I was still paranoid about writing code that would have cause V-calls under the overlay.
I did most of the development with on a PDP-11/73 running RSX-11M V4.3 in 22-bit mode. The boot process loaded RT-11 to load an 18-bit version of RSX to load the 22-bit version. Unfortunately, the first two times that I would try to make a tape after booting, the system would crash. This meant that the system had to be booted effectively nine times in order to write a tape. The PDP-11/73 system cabinet was several times larger than a PC, maybe about 3 feet X 3 feet X 2 feet (1m X 1m X 0.6m), but DEC slapped a handle on each side so they could advertise it as portable, even though it took two strong people to move it.
The overlay for ILP pushed TKB, the linker, to its limits. DEC provided three versions of the linker. FTB, the fast task builder, was limited and we could never use it for real programs. TKB, the task builder, took about 45 minutes to link ILP but sometimes ran out of memory. STB, the slow task builder (and you must keep in mind that if the normal task builder took 45 minutes, calling the slow version slow was an understatement) stored everything on disk and took about 10 hours to link ILP. We allocated some of the PDP-11/73's memory to a RAM disk to make the slow task builder run faster.
RSX had a program called RMD that showed a character-graphic display of the system RAM across the screen with the name of the program in each block of memory. RMD filled the same function that a program like top does under unix. I used RMD a lot to see what the system was doing.
In RSX, if you pressed <return> after a command, the system would give you another prompt. It was as if you had ended every command line with & on a unix system. Programs had to make a special call to attach the terminal if they wanted to prevent the system from displaying a new prompt. I used to bring our systems to their knees doing compiles, but I had to be careful, because Norm, our RSX expert, would just relax and tell me that no matter how much of the system I consumed, he could always find a way to consume more than me, so I shouldn't try to challenge him. If you tried to run more programs at a time than all fit in RAM at once, the system would start swapping (which we called thrashing). RSX did not support virtual memory, so an entire program had to sit in memory for it to run. More modern operating systems like VMS and Unix use virtual memory to load programs by pages and make much more efficient use of memory because entire programs do not need to be in memory.

That Old-Time PDP by Gordon Booman (unofficial theme song of the RSX/IAS SIG,
from page RSX/IAS-6 of the 4/25/89 IAS newsletter)
http://www.poppyfields.net/filks/00224.html http://www.travelnotes.de/california/silicon/oldpdp.htm
To the tune of "That Old-Time Rock'n'Roll" by Bob Seger
Just take that PRO down off the shelf.
I'll sit here and program it by myself.
I love that old-time PDP.
Refrain:
I love that old-time PDP.
The kinda CPU that sets you free.
Instruction set sure looks good to me.
I love that old-time PDP.

Don't try to take me to ZK.
I won't make it, I won't last a day.
32 bits is twice what I need.
I love that old-time PDP.
Refrain
Say I'm old fashioned, say I'm over the hill,
say I'm out of touch, say what you will.
Those new CPUs ain't got the same thrill,
I love that old-time PDP.
Refrain
You gotta balance complexity
against function and quality.
32 bits is twice what I need.
I love that old-time PDP.
Refrain

The mini-reference page for PIP, the Peripheral Interchange Program.

PIP made directory listings and copied files. For example:
PIP new.txt=old.txt copied old.txt to new.txt.
PIP new.tsk/CO=old.tsk copied a file and made it contiguous on the disk, which was required for executables. When the disk became full, the linker would not be able to create contiguous executables and you would need to find space by deleting files and then recopy the executable.
PIP /FR showed the number of free blocks.
PIP /LI displayed a directory listing.
PIP *.*/PU purged old versions of files.
PIP file.txt;*/DE deleted all versions of a file.

Digital microcomputers and memories guide from 1982, part number EB-20912-20. The cover shows two PDP-11/23-PLUS systems and three Q-Bus cards. The system on the right has two RL02 disk drives.

This book describes PDP-11 systems and sections on hardware including the LSI-11/2, LSI-11/23, FALCON SBC-11/21, PDP-11/23-PLUS and the operating systems RT-11, RSX-11M, RSX-11M-PLUS, RSTS/E, RSX-11S, and SIMRT. The PDP-11/03 used the LSI-11/2 processor, and the PDP-11/23 used the LSI-11/23 processor. LSI stands for Large Scale Integration.
LSI-11 cards were introduced in 1975 and were quad-height or 10" X 8.5" (26 cm X 22 cm).
LSI-11/02 cards were introduced in 1977 and had the same processor as LSI-11 card except on a double-height or 5.2" X 8.5" (12 cm X 22 cm) card.
LSI-11/23 cards were introduced in 1979 and had the same form factor as the LSI-11/02 but used NMOS technology to run 2.5 times as fast (a 300 ns cycle time for a zippy 3.3 MHz clock rate). In 1981, DEC extended the LSI-11/23 to support an extended 22-bit addressing range capable of addressing 4 MB of RAM.
The FALCON SBC-11/21 was introduced in November, 1981, as DECs first single-board microcomputer.
The PDP-11/23-PLUS was introduced in November, 1981, and offered in configurations with as much as a whole MB of RAM.
The PDP-11 instruction set included
87 standard PDP-11 instructions
6 general purpose registers (R0 to R7) and 2 special purpose registers (PC and SP)
12 addressing modes
the EIS (extended instruction set), optional on the 11/2 but standard on the 11/23, with 4 instructions for signed multiplication and division and multiple shifting.
optional microcoded floating point, KEV11 for the LSI-11 and LSI-11/2 and KEF11 for the 11/23.
optional FPF11 floating point processer for the 11/23.
RT-11 was a real time operating system that could run from floppy disks or a hard disk. DEC sold MicroPower/Pascal for it.
RSX-11M was a hard-disk-based, multi-user, multi-tasking operating systems.
RSX-11S was a limited memory-resident version of RSX.
RSTS/E, Resource Sharing Timesharing System/Extended, was a multi-user, multi-tasking operating system that used BASIC as its command language and had Ready as its prompt.

peripherals handbook (for PDP-11's) from 1981, part number EB-20443-20.

This book describes
the RX211, RL01/RL02, RK07, RM02/03, RM80, RP06, RM05 and RP07 disk drives,
the TU58, TS11, TE16, TU77, and TU78 tape drives,
the LXY11/21 line printers, and the
the CMS11-K/CME11-K card readers.

microcomputer interfaces handbook, part number EB-20175-20/81 from 1981. This book covers the hardware interface specifications of various cpu cards and peripherals. The cover shows a typical Q-Bus card.

pdp11 bus handbook, part number EB-17525-20/79 070-14-55 from 1979. This book describes the UNIBUS and the LSI-11 bus.

pdp11 software handbook, part number EB-18687-20/80 90-04-90 from 1980. This book lists the various operating systems, languages and packages that DEC provided for PDP-11 systems. The cover shows two VT-100 terminals in the center, a printer on the left, and a PDP-11 system on the right with two disk drives.

VT100 Series Video Display Terminal Complementary and Supporting Products Guide, part number VT100 EC-21754-75 from 1981. This eight-page booklet had all of the options that you might want to buy for your beloved vt100.

Part of page 3 of the VT100 Supporting Products Guide.

1) screen filters (in gray, green, and amber),
2) a filter kit (in gray, green, or bronze),
3) a tilt-swivel base,
4) a terminal stand,
5) a dust cover (heavy gauge vinyl, in charcoal brown only),
6) a catalog stand,
7) blank key caps,
8) a keypad overlay (we had a bunch of overlays for the EDT editor that some people referred to as keypad condoms,
9) a 300 baud acoustic coupler (what we now would call a dinosaur modem) ../modem300/modem300.html ,
10) a 300/1200 baud modem,
11) an accessory cable,
12) the interface option (to add a printer port),
13) the VT100 advanced video option (I think to add lower case),
14) an interface cable (due to the connector conspiracy, the main port and printer port had different wiring,
15) an anti-static DECmat floor mat (in driftwood, silver birch, or autumn bronze),
16) a terminal table,
17) a work station,
18) a media mate (i.e. a cart with drawers for 8" floppy disks),
19) various technical manuals,
20) maintenance prints,
21) a spare parts kit (back in the days when you could fix hardware with a screw driver),
22) loose piece spares (i.e. extra screws to replace the ones that you lost while using the spare parts kit),
23) and various tools and testers.

Continue with PDP-11 Unix manuals at ../manuals/manuals.html.

PDP Lineage lineage.html


 


SCS used SFORTRAN, structured fortran with a syntax similar to fortran-77. The SFORTRAN preprocessor was written in SFORTRAN and produced portable output compatible with fortran-iv / fortran 66.

Here is an example.
Everything was upper case.
Identifiers could be at most 6 characters.
Program code had to start on column 7 or later.
Continuation lines had a character in column 6.
Statment numbers, when present, had to be in columns 1 through 5.
Lines could not be completely empty. A blank line needed at least one space.
A C in column 1 was a comment.
*COPY included a file.
RSX-11 paths had <two letter drive><one digit drive number>:[<major number>,<minor number>]<six character name>.<three character extension>
This application was called Layout, so the source drive letters used the alias LA.
This application had an ad file database.
Fortran did not have records, so we declared arrays in named COMMON blocks and used EQUIVALENCE statements to map identifiers to positions in the array.
Named COMMON blocks in ADFHDR.COM declared the header and in ADFADS.COM declared the records.
The fields in COMMON blocks usually had two-letter prefixes. ADF blocks had the prefix XH.

      SUBROUTINE EXTINI(PURPOS)
 
C --- INITIALIZE PROCESSING OF THE EXTRACT ADS FILE.  *PURPOS* GIVES
C -   THE PURPOSE (CREATE, UPDATE OR READ ONLY).
 
*COPY LA1:[64,4]ADFHDR.COM
*COPY LA1:[64,4]ADFADS.COM
*COPY LA1:[64,4]ADFBTR.COM
*COPY LA1:[64,4]LAYOPS.COM
 
      INTEGER PURPOS
      INTEGER I
 
 
      SELECT CASE PURPOS : 3
 
C - CREATE
      CASE(1)
        DOLOOP I = 1, 128
          XHREC(I) = 0
        ENDLOOP
 
        XHORDR = 7
        XHROOT = 2
        XHCONF = .FALSE.
        XHEROR = .FALSE.
        CALL LAYOPS(CRFEXT, DUMMYA, DUMMY)
 
        NODES(1, 1) = -1
        NODES(2, 1) = 0
        NODES(14 * XHORDR + 3, 1) = 0
        CALL ADFOPS(CRREXT, NODES(1, 1), DUMMY)
 
C - UPDATE
      CASE(2)
        CALL LAYOPS(UPFEXT, DUMMYA, DUMMY)
        CALL ADFOPS(RDREXT, NODES(1, 1), XHROOT)
 
C - READ ONLY
      CASE(3)
        CALL LAYOPS(RDFEXT, DUMMYA, DUMMY)
        CALL ADFOPS(RDREXT, NODES(1, 1), XHROOT)
 
      ENDCASE
 
 
C --- SET UP B-TREE CONTROL INFORMATION.
 
      MAXLEV = 4
      NODINX(1) = XHROOT
      DOLOOP I = 2, MAXLEV
        NODINX(I) = 0
      ENDLOOP
      CURLEV = 1
      CURINX(1) = 0
 
      XAINDX = 0
 
      RETURN
      END

This is section of the ADFHDR.COM include file.
The COMMON block includes a 256 word record (for efficient IO), fields aliased to indices in the record, and a few extra variables.
Increasing the size of an array in a record required a lot of index recalculations.

      COMMON /ADFHDR/ XHREC, XHUNKN, XHINCH, XHCM, XHLINE, XHMM,
     +  XHPICA, XHPNT, XHGRID, XHPIPN, XHMAXU
      INTEGER*2 XHREC(256)
      INTEGER*2 XHRTC, XHLAST, XHZONE
      INTEGER*2 XHIDAT(2), XHPANO, XHPANM(15), XHEDNO
...
      EQUIVALENCE (XHREC(1), XHRTC)
      EQUIVALENCE (XHREC(2), XHLAST)
      EQUIVALENCE (XHREC(3), XHIDAT(1))
      EQUIVALENCE (XHREC(5), XHPANO)
      EQUIVALENCE (XHREC(6), XHPANM(1))
      EQUIVALENCE (XHREC(21), XHEDNO)

This is a function from the SFORTRAN preprocessor.
SFORTRAN was written by Volvo in Sweden.
The variable names are in Swedish.
This function checks that the first open parenthesis has a matching close parenthesis.
You need to know enough Swedish that ANTAL = COUNT, V = VÄNSTER = LEFT, and H = HÖGER = RIGHT.
In VILLKB, VILL could mean WANT or be short for VILLKOR = CHECK TO, K = KONTROLLERA = VERIFY, B = (PARENTES)BALANS = (PARENTHESIS) BALANCE.
The type of undefined variables depends on the first letter of their name. A-H and O-Z are real numbers. I-N are integers.
Integer identifiers often have an "I" prefix.
Supposedly the author of SFORTRAN confused himself so much with the clash between English keywords and Swedish identifiers that he used English identifiers in later projects.
I added simple macros and IFDEFs to SFORTRAN.
SCS resold SFORTRAN and SCOBOL (a preprocessor for structured COBOL).

      SUBROUTINE VILLKB(IVP, IHP)
 
*COPY LA1:[64,4]GENIUS.COM
*COPY LA1:[64,4]ALGOL.COM
*COPY LA1:[64,4]ALPHA.COM
 
      INTEGER IVP, IHP
      INTEGER I, ANTAL
      SHORT ASI
      LOGICAL F
 
 
      IHP = NAS + 1
      ANTAL = 0
      F = .TRUE.
      DOLOOP I= IFEID, NAS
         ASI = AS(I)
         IF ((ANTAL .EQ. 0) .AND. F .AND. (ASI .EQ. VP)) THEN
            IVP = I
            F = .FALSE.
         ENDIF
         IF (ASI .EQ. VP) ANTAL = ANTAL + 1
         IF (ASI .EQ. HP) ANTAL = ANTAL - 1
         IF (ANTAL .EQ. 0) THEN
            IHP = I
            IF(.NOT. F) RETURN
         ENDIF
      ENDLOOP
 
      CALL SAVERR(35)
 
      RETURN
      END

We used Oregon Pascal-2 on RSX-11, VAX Pascal on VAX/VMS, and Prospero Pascal on MSDOS.
We made a comment system for portability and had a 'switch' tool to modify the close comments to select a given operating system.
This is the end of an include file lockprc3.pas.

{/if/oldvax,rsx,rsxws,ms,or_x
        if ok then
          with AnsBuf do
            begin
              UnpSet(AnsRd, RdSet);
              UnpSet(AnsWrt, WrtSet);
              UnpSet(AnsOpt, OptSet);
              AccessOK := (AnsCod = 1);
              Waited := OptWat in OptSet;
              Same := OptSam in OptSet
            end
      end { with }
{/elseif/vax,vaxws}
    { nothing }
{/else/
    with LockData do
      begin
        OK := true;
        AccessOK := true;
        Waited := false;
        Same := true
      end
{/end/}

Joe Smith's PDP-10 page http://www.inwap.com/pdp10 I used a DEC-20 running TOPS-20 while I was at Lehigh University http://www.lehigh.edu .

nocrew's PDP-10 stuff http://pdp10.nocrew.org/

Uppsala University Computer Club PDP-8 and PDP-11 files ftp://ftp.update.uu.se/pub/

PiDP-8/I, Remaking the PDP-8/I using the Pi http://hackaday.io/project/4434-pidp-8i

The Trailing-Edge PDP-10 and PDP-11 software archives http://www.trailing-edge.com .

The Computer History Simulation Project http://simh.trailing-edge.com/ has a free simulator that supports various PDP and VAX machines.

FPGA to emulate a PDP-11 https://pdp2011.sytse.net/wordpress/

Javascript PDP-11 emulator running V6 unix http://pdp11.aiju.de/

The OpenVMS Hobbyist http://www.openvmshobbyist.com/ can provide free OpenVMS licenses.

A PDP-11 page http://www.telnet.hu/hamster/pdp-11

A PDP-11 FAQ page with lists of PDP-11 models and operating systems http://www.village.org/pdp11/faq.html

The PDP-11 Pages at PARSE.COM http://www.parse.com/~museum/pdp11/index.html

PDP-11 DECUS Software Index https://www.ibiblio.org/pub/academic/computer-science/history/pdp-11/decus/index.html

Columbia University Computing Timeline http://www.columbia.edu/acis/history

Reinhard Heuberger's PDP-11 site http://www.youtube.com/user/PDP11GY

RSX-11 and PDP-11 Consulting, Software and Services http://www.miim.com/

The RSX Multi-Tasker http://www.miim.com/documents/mtasker/iindex.html

RSX-11 http://en.wikipedia.org/wiki/RSX-11

Old Computers http://oldcomputers.net/

ELVIRA RSTS VM http://elvira.stacken.kth.se/pdp11/

A brief tour of the PDP-11, the most influential minicomputer of all time https://arstechnica.com/gadgets/2022/03/a-brief-tour-of-the-pdp-11-the-most-influential-minicomputer-of-all-time/

Rhode Island Computer Museum https://www.ricomputermuseum.org/ Large Systems Collection https://www.ricomputermuseum.org/collections-gallery/equipment

Large Scale Systems Museum https://www.mact.io/

ACMS Retro Computer Group photo albums https://www.facebook.com/groups/522149334818014/

IN PICTURES: Where old computers find their final resting place https://www.goodgearguide.com.au/slideshow/268510/pictures-tech-yesteryear-where-old-computers-find-their-final-resting-place/

Xerox PARC's Engineers On How They Invented The Future https://spectrum.ieee.org/xerox-parc

Return to SCS VAX History vax.html

Continue with DEC VAX History vaxhistory.html

Return to the museum ../museum.html



http://williambader.com - Revised May 22, 2025 06:10:57 PM.
Copyright © 2025 William Bader.