It's Called the PMC20

Well, it's coming together. After 9 months of building, rebuilding, and writing a lot of code, I have a working minicomputer.

Overview

PMC-20 (Personal Mini Computer) is the minicomputer I designed. It is a 5 processor design with 20 CPU cores. It can easily handle 64 simultaneous users running MPE, the operating system I wrote.

The operating system is built on the best of the commands I've used from Prime Computer's Primos, DEC's RSTS, unix, GNU Linux, and some that I always thought should be there. The operating system is a set of commands, a custom shell, a specialized directory structure and background processes that ride on top of a Linux kernel. The kernal handles the hardware, MPE does the rest.

MPE, or Multi user Programming Environment, is written as a typical 1980's minicomputer/mainframe operating system. It has job control, a multi user accounting package, about 50 built-in commands in the shell which allow the user to create, edit, delete, and manipulate files and run them. There are multiple programming languages including BASIC, Fortran (77 thru 2008), COBOL, c, c++ and Python and Ruby. More can be added as neeed.

Also, an unlimited amount of external commands (external to the shell) can be added as needed. They can be any language (BASIC, c++, etc) and created under the MPE operating system. It will be up to the user to write any custom programs for their applications. Additional internal and external commands are being added as needed.

MPE is written with multi user security in mind. System users (group# 1) can access any part of the disk structure and manipulate hardware as needed. Regular users (group# > 1) can work in their own assigned directories and those shared among multiple users (using the ATTACH command) but cannot see other users files or run most system commands. Users are assigned a Group # and a User # as well as a login name. Their login name and a password is used to access the computer from an SSH connection.

The PMC20 running MPE would be an ideal minicomputer for a school computer lab, a small (less than 80 users) business, the backend for a Point of Sale system, or research facility where multiple users need to share data with specialized hardware data collection using specialized applications written in-house.

MPE is a command-line based operating system. Access to the PMC20 for most users is via an Ethernet connected device. Full access is available via the system console.

Hardware

Here is a block diagram of the PMC20 minicomputer.

 (Click on the above image to see a full-sized version)

CPU1 is the main control processor for the computer. It handles all I/O, disk access, printer access and Ethernet traffic to and from the computer. It is the gateway to this and any attached system as well as the controller for all attached hardware.

CPU2-5 are sub-processors that handle the load when CPU1 reaches a pre-defined load value. Also when users log in, they are assigned one of the internal CPU's. When they log off, that slot is freed up for another user. Each processor can handle about 16 users and all of the overhead associated with the overall computer operation. For the benefit of overall speed and stability, the system is limited to 64 users. This number can be changed by anyone with a system user account. Users can have multiple sessions by connecting multiple times.

A batch job entry system allows users to submit time-intensive sets of programs for later (or immediate) execution. 

There are 3 internal drives. More can be added as needed. DISK1 and DISK2 are 1 TB drives that hold the operating system, all internal files and all of the users directories and files, and any application programs the end-user wishes to install.

DISK3 is a multi-drive Raid 1 array used to hold backups. Backups can be made on a scheduled basis, or whenever a user wants to backup his/her files. When a user types "backup" all files and directories in their login directory are backed up to this array. An external USB drive or even a thumb drive can be plugged into the front panel and the backup files will be copied to it for off-site storage. Multiple copies can be made at any time.

If the need ever arises to restore a users (or system) files, the "restore" command will restore the missing/corrupted files.

As noted above, each CPU board has a USB bus port that allows additional hardware to be attached to the system as needed.These buses are brought out to the back panel of the PMC20.

The PMC20 runs on 120 VAC house current and draws (without the optional hardware controller) about 60 watts.

The system console consists of an HDMI monitor, usb keyboard and usb mouse.  A second console is attached as a backup to the primary console. It sits on top of the PMC20 computer. The primary system console can be located up to 15 feet from the PMC20 minicomputer.  The secondary console  can be used as a primary console if needed as well as monitoring system operation.

There is also an (optional) hardware I/O sub-processor that can provide up to 256 input or output devices, or any combination of input and output. These can be used for hardware control of external devices. There are also 16 analog inputs for measurements. It will be up to the user to provide any custom interfacing to the sub-processor with his/her equipment.

 Software

MPE, the PMC20's operating system, allows more than 65000 user accounts and 250 system accounts. The internal commands (commands that are built into the shell, or user interface program) allow the user to create and manipulate files and write and execute programs in multiple computer languages. A list of many of these commands are shown below:

login - login into (or change username) the system
lo - log out of the system
job - show information on the users job (login/accounting information)
help - show help on a command, show a list of available commands
dir - show a directory listing
dirsize - show the size of the users login directory
edit - invoke the editor to create and modify a text file
type - display contents of a text file
del - delete a file or directory
filestat - show attributes of a file
rename - rename a file
copy - copy a file
password - change users password
show - show system status on a physical device or user
cls - clear the users screen
create - create an empty file or a new directory
date - show date and time
time - show date and time
basic - start the BASIC interpreter
python(2/3) - start the python interpreter
set - set a file or user attribute
home - jump from a subdirectory back to the users home directory
cc - start the c compiler (or c++ compiler)
run - run a program (external to the shell)
cd - change to another sub-directory in the users login directory
move - move a file to another directory
attach - jump to another users directory (as defined by the system user)
unattach - jump back to users login directory
search - find a file or files. Uses wildcards
backup - backup files from a users login or system directory
f77 - start the Fortran 77 compiler
fortran - start the Fortran (90-2008) compiler
cobol - start the COBOL compiler
h2d - convert a hex value to decimal
d2h - convert a decimal value to hex
assign - assign a logical name to a physical device
unassign - delete the logical name from a physical device
cat - show a catalog of files of different users (system user only)
ver - show MPE version information
spool - send a text file to the printer

In addition to the internal shell commands, there are multiple external commands in the system directory. A partial list of these are:

adduser - add a new user to the system
deluser - delete a user from the system
backups - a larger, full featured backup and restore program
mpe - start, stop, suspend and refresh the system.
money - user process accounting package (login times, activity, quotas)
scopy, smove - system copy & move (files, directories)
showuser - show basic user account information 

along with various development programs (make, as, diff, etc).

The overall control of the operating system is by a program called mpeinit. This is the equivalent of the unix init program. It is called at startup and controls things like idle timeouts (forcing the user to log out if his/her idle time exceeds a preset value), the print spooler, cron and batch jobs, and background processes and job control.


More internal and external MPE commands are being written as needed. The above list is as of late Sept 2016.

Summary

What started out as an exercise in "what can I do with a handful of parts?" turned into a production machine that exceeds what a $250,000 minicomputer of the late 1980's could do.

Some of the features originally designed and built into the computer have been pulled out since they were not needed. Some changes in the design were needed as I realized how the machine was evolving. The front panel and back panels were rebuilt to utilize the changed hardware. Some of the internal processors were changed to units that gave me better performance or features I wanted.

Most importantly I wrote software that turned this collection of parts into a truly useful multi user, multi processor minicomputer that could easily fulfill a commercial need today in a number of markets.

---------------------------------------------------------------------------------------------------------------------------------

I'm still finishing up the software, the external I/O controller, and adding additional features. I'll post pictures on this page as I finish up.

Initially I used Linux as the development system. I found myself writing the software using MPE over the last few weeks, and when I added some commands (attach, assign) I realized this is now a production box. I'm going over user manuals from Primos, RSTS, RSX-11 and other minicomputer operating systems looking for functionality that could be applied to the hardware I have running. One feature I want is to network a number of the PMC20's together that will eventually give me mainframe capability.

-- Kurt --