$A MARK=2
$A TAB=5, 10, 15
$A JUST=1; LINE=69; PAGE=54; TOP=5; BOTTOM=7
$A NLS=2
DESCRIPTION OF DEIMOS
$B1 $L1C
GOALS
$P0 @THE SECOND SYSTEM WAS DESIGNED FOR OPERATION IN A MEDIUM
SIZED .PDP 11. @AT LEAST 16K WORDS OF CORE, A MEMORY MANAGEMENT UNIT,
A DISC OR SIMILAR FAST MASS STORAGE DEVICE, A TERMINAL AND A CLOCK ARE
REQUIRED.  @A FULLY SELF SUPPORTING SYSTEM REQUIRES 28K WORDS OF CORE
IN ORDER TO SUPPORT THE COMPILER.
$P1 @THE SYSTEM WAS DESIGNED WITH FIVE MAIN AIMS:
$A INDENT=1
$B1
%@RUNNING %USER %PROGRAMS
$P0 @THE SYSTEM IS DESIGNED TO RUN GENERAL USER
PROGRAMS. @NORMALLY,
 ABOUT TWENTY SIMULTANEOUS PROGRAMS SHOULD BE SUPPORTED,
BUT THIS FIGURE SHOULD BE A PARAMETER AT SYSTEM
GENERATION. @EACH PROGRAM
WILL RUN IN ITS OWN VIRTUAL MEMORY ENVIRONMENT .(VM), NOT
NECESSARILY LIMITED TO THE HARDWARE'S MAPPING LIMIT OF 32K WORDS. @THE
SYSTEM, AND OTHER USER PROGRAMS, SHOULD BE FULLY PROTECTED FROM
THE FAILURE OF A USER PROGRAM.
$B1
%@MULTIPLE %TERMINAL %SUPPORT
$P0 @THE SYSTEM SHOULD SUPPORT
MULTIPLE TERMINALS, EACH TERMINAL SHOULD, OPTIONALLY, BE LINKED TO A
COMMAND LANGUAGE INTERPRETER WHICH WILL ENABLE THE USER TO INITIATE AND
CONTROL PROGRAMS FROM THE TERMINAL.
$B1
%@PERIPHERAL %SUPPORT
$P0 @THE SYSTEM SHOULD SUPPORT A WIDE RANGE
OF PERIPHERALS, EG, LINE PRINTER, CARD READER, PAPER TAPE READER AND 
PUNCH, VARIOUS DISCS, MAGNETIC TAPE AND A SYNCHRONOUS COMMUNICATION LINE
RUNNING UNDER 
A NUMBER OF PROTOCOLS.
@IT SHOULD BE POSSIBLE TO ADD NEW PERIPHERALS WITH MINIMUM
DISTURBANCE TO THE SYSTEM.
$B1
%@SWAPPING
$P0 @THE NUMBER AND SIZE OF USER PROGRAMS SHOULD NOT BE LIMITED TO
THE PHYSICAL STORE SIZE OF THE MACHINE, A LIMITED SWAPPING
STRATEGY
SHOULD BE IMPLEMENTED TO SUPPORT A VIRTUAL STORE
SIZE OF TWO TO THREE TIMES THE PHYSICAL STORE SIZE.
$B1 %@MINIMAL %RESIDENT %SECTION
$P0 @THE SIZE OF THE RESIDENT SYSTEM SHOULD BE KEPT SMALL
TO ALLOW AS MUCH STORE AS POSSIBLE FOR USER PROGRAMS.
$A INDENT=0
$B3 $L1C
CONSTRAINTS
$P0 @THE CORE CONSTRAINTS,
WHICH DOMINATED THE FIRST SYSTEM DO NOT DOMINATE
THIS SYSTEM. @THERE ARE TWO MAIN REASONS FOR THIS:
$A INDENT=1
$B0 1) THE TARGET MACHINE IS LARGER THAN THAT FOR THE FIRST SYSTEM
$B0 2) THE SYSTEM IS NOT ENTIRELY CORE RESIDENT.
$A INDENT=0
 @THIS MEANS THAT
DEVICE HANDLERS THAT ARE INACTIVE WILL NOT BE USING VALUABLE CORE,
FOR EXAMPLE,
IT IS FEASABLE TO HAVE A MORE COMPLEX
TERMINAL HANDLER, BECAUSE THOSE THAT ARE INACTIVE WILL BE SWAPPED OUT. @THE
TIME REQUIRED TO SWAP A PROGRAM WILL BE IN THE ORDER OF 
1/5 OF A SECOND, AND 
TO MINIMISE THE AFFECTS ON RESPONSE THE SYSTEM
TASKS WILL
BE ABLE TO LOCK THEMSELVES DOWN
WHILE THEY ARE ACTIVE.
$P1 @IT IS STILL DESIRABLE TO KEEP THE RESIDENT PART OF THE SYSTEM
AS SMALL AS POSSIBLE TO ENABLE THE SYSTEM TO RUN IN SMALLER
CORE CONFIGURATIONS. @THIS CONSTRAINT EFFECTS THE OVERALL DESIGN,
DISTINGUISHING IT FROM  SYSTEMS WITH A LARGE SET OF
FACILITIES LIKE .UNIX AND .RSX11D
WHICH REQUIRE 48K WORDS OF CORE TO DO USEFUL WORK.
$B1 $V10 $L1C
STRUCTURAL OVERVIEW
$P0 @THE DESIGN OF THIS SYSTEM STEMS LARGELY
FROM THE PREVIOUS SYSTEM HOWEVER THE BASIC TASK SYNCHRONISATION
MECHANISM IS NOW A 'MESSAGE', RATHER THAN THE SEMAPHORE OF
THE FIRST STYSTEM.
@THE CONCEPT OF MESSAGES COMES FROM .EMAS, THE .GEC 4080
AND OTHERS.
$P1 @THE USER INTERFACE IS HEAVILY INFLUENCED BY A NUMBER OF MACHINES
RUNNING IN THE @COMPUTER @SCIENCE DEPARTMENT.
$P1 @THE SYSTEM HAS TWO MAIN SECTIONS, A RESIDENT
SECTION AND A POTENTIALLY SWAPPABLE SECTION.
$B1 @THE RESIDENT SECTION CONSISTS OF A KERNEL AND THE
MASS STORAGE DEVICE HANDLER WHICH RUNS AS AN OTHERWISE STANDARD
SYSTEM TASK.
$B1 $V7 @THE KERNEL PROVIDES THE FOLLOWING SERVICES:
$A INDENT=1
$B0 1) @CONTROLS THE .CPU ALLOCATION.
$B0 2) @PASSES INTERRUPTS TO THEIR DEVICE HANDLERS.
$B0 3) @PASSES MESSAGES BETWEEN TASKS, STORING THEM IF NECESSARY.
$B0 4) @SUPPORTS THE VIRTUAL MEMORIES, INCLUDING MAPPING BETWEEN THEM.
$B0 5) @PROVIDES CLOCK AND TIMER FUNCTIONS.
$B0 6) @CONTROLS CORE ALLOCATION CONTROL.
$A INDENT=0
$P1 @ALL PERIPHERALS AND OTHER SYSTEM FUNCTIONS, E. G.,
 THE FILE STORAGE HANDLER,
COMMAND LANGUAGE INTERPRETER AND LOADER - ARE HANDLED BY SYSTEM
TASKS. @THE SYSTEM TASKS ARE 'PRIVILEGED', THIS ENTITLES THEM TO
ACCESS PARTS OF THE REAL MACHINE AND OTHER TASKS.
@A SYSTEM TASK MAY ALSO REQUEST TO BE HELD
IN CORE, AS THE MAIN DISC TASK DOES PERMANENTLY.
$P1 @A NEW TASK IS CREATED WHEN A USER PROGRAM IS RUN AND
IS DELETED ON ITS TERMINATION.
@A TASK CONSISTS OF A VIRTUAL MEMORY ENVIRONMENT AND A 'TASK DESCRIPTOR
BLOCK', HELD WITHIN THE KERNEL. @A TASK 
ON THIS SYSTEM DOES NOT HAVE A 'TASK
MONITOR';
ALL INTERRUPTS AND MESSAGES ARE PROCESSED BY THE TASK IN ITS 'USER'
STATE.
$A INDENT=1
$P1 @THE VIRTUAL MEMORY ENVIRONMENT OF A TASK CONSISTS
OF A NUMBER OF SEGMENTS, THESE SEGMENTS ARE USED TO HOLD
THE PROGRAM CODE, DATA AREAS AND SHARED SYSTEM CODE.
@THE HARDWARE OF THE .PDP11 ALLOWS EIGHT SEGMENTS TO BE MAPPED 
ONTO REAL STORE AT ANY GIVEN TIME, GIVING A VIRTUAL MEMORY ADDRESS
SPACE OF 32K WORDS. @THE NUMBER OF SEGMENTS OWNED BY A TASK IS
NOT LIMITED TO EIGHT, AND A 'SEGMENT STACK' IS USED TO
HOLD THE NON-MAPPED SEGMENTS. @A SEGMENT MAY BE MAPPED IN A READ
ONLY OR A READ/WRITE MODE WHICH ALLOWS PROTECTION OF CODE AREAS.
$P1 @THE 'TASK DESCRIPTOR BLOCK' CONTAINS THE REGISTERS
(WHEN THE TASK IS NOT ACTUALLY EXECUTING) AND OTHER INFORMATION
SUCH AS THE STATE, PRIORITY LEVEL AND MESSAGE QUEUE THAT
CONSTITUTES THE CONTEXT OF THE TASK.
$A INDENT=0

$P1 
@THE LIST OF SEGMENTS USED BY A TASK IS
HELD IN A .GLOBAL .SEGMENT .TABLE WITHIN THE
KERNEL, WITH 
THE CORE OR DISC ADDRESS, ACCESS PERMISSION AND
THE NUMBER OF TASKS USING THE SEGMENT. @THIS TABLE
ENABLES THE KERNEL TO MAINTAIN CONTROL OVER THE
USAGE OF SEGMENTS AND CAN EASILY DETERMINE
WHAT PARTS OF TASKS MAY BE SWAPPED OUT. @THE CORE ADDRESS,
ACCESS PERMISSION AND A POINTER INTO THE GLOBAL
SEGMENT TABLE ARE ALSO MAINTAINED WITHI THE TASK DESCRIPTOR
TO SPEED UP THE CONTEXT SWITCH.
$P1 @IF A TASK FAILS WITH EITHER A HARDWARE FAULT, EG, AN
ADDRESS ERROR OR MEMORY PROTECTION VIOLATION, OR WITH
A FAULT DETECTED BY SOFTWARE, E. G., AN ILLEGAL SUPERVISOR CALL
OR MESSAGE, THE KERNEL GENERATES A MESSAGE TO A 'SYSTEM ERROR
TASK'; TO ALLOW LATER INVESTIGATION
THE FAILED TASK IS PREVENTED FROM CONTINUING.
@THE 'ERROR TASK' INFORMS THE USER
OF THE TASK FAILURE AND THE REASON FOR IT.
@THE 'ERROR TASK' IS ALSO USED BY SOME SYSTEM TASKS TO INFORM THE
OPERATOR ABOUT THE STATE OF DEVICES.
$P1 @ALL COMMUNICATION IN THE SYSTEM IS DONE BY SENDING MESSAGES.
@THESE MESSAGES ARE QUEUED BY THE KERNEL, IF NECESSARY, UNTIL THEY
ARE REQUESTED. @INTERRUPTS ARE HANDLED SIMILARLY, THE KERNEL
GENERATES AND QUEUES A MESSAGE FOR THE APPROPRIATE TASK. @A TABLE

IS USED TO DETERMINE WHICH TASK A MESSAGE (OR INTERRUPT)
IS FOR. @A SUPERVISOR CALL IS PROVIDED TO ENABLE TASKS
TO 'LINK' THENSELVES TO A PARTICULAR MESSAGE NUMBER. @THIS
IS SLIGHTLY LESS EFFICIENT THAN DIRECT OWNERSHIP BUT 
ENABLES DEVICE HANDLERS TO BE CONFIGURED INTO THE SYSTEM DYNAMICALLY.
$P1 @THE ADDRESS OF A DATA AREA MAY BE PASSED BY A MESSAGE.
@THE SEGMENT
CONTAINING THIS AREA MAY THEN BE MAPPED FROM THE CALLERS .VM
TO THE RECEIVERS .VM. @CURRENTLY THIS MECHANISM IS ONLY USED TO
SHARE SEGMENTS, WHICH ARE EVENTUALLY RETURNED TO THE CALLER. @THERE
IS NO RESTRICTION TO STOP SEGMENTS ACTUALLY BEING TRANSFERRED
BY THIS METHOD.
$P1 @INPUT/OUTPUT ON THIS SYSTEM USES A SEPARATE
SEGMENT IN EACH USER'S TASK TO HOLD ITS .I/O BUFFERS. @THIS 
ALLOWS THE KERNEL TO SWAP THE MAJOR PART OF A TASK
WHILEST SLOW .I/O IS IN PROGRESS. @THE SHARING OF SEGMENTS, AS 
DESCRIBED ABOVE, IS USED BY THE DEVICE HANDLERS TO PROCESS THE
BUFFERS, THE SEGMENT BEING RELEASED AND A REPLY SENT ON COMPLETION.
$B1
$V10 $L1C
IMPLEMENTATION
$P0 @THIS SYSTEM WAS WRITTEN IN .IMP. .IMP WAS CHOSEN FOR A
VARIETY OF REASONS:
$A INDENT=1
$I0 1) $T+1 @THE IMPLEMENTER HAS HAD A LONG EXPERIENCE WITH
.IMP, USING IT AS A SYSTEMS PROGRAMMING LANGUAGE ON .EMAS AND
OTHER SYSTEMS.
$I0 2) $T+1 @THERE WAS NO EASY ACCESS TO ANY OF THE OTHER POSSIBLE
LANGUAGES, WITH THE EXCEPTION OF .FORTRAN, WHICH WAS NOT CONSIDERED
TO BE AS GOOD AS .IMP AS A SYSTEMS PROGRAMMING LANGUAGE, EITHER
IN ITS STRUCTURE OR ITS IMPLEMENTATION.
$I0 3) $T+1 @A NEW IMPLEMENTATION OF .IMP WAS AVAILABLE, TO A STANDARD
THAT MADE THE PROJECT POSSIBLE.
$A INDENT=0
$P1 @TWO MODULES OF THE SYSTEM HAVE BEEN WRITTEN IN ASSEMBLER. @THE FIRST
MODULE IS AT THE LOWEST LEVEL OF THE SYSTEM, LOADING UP THE REGISTERS
ON CONTEXT SWITCHING. @SINCE THERE ARE NO EXPLICIT REGISTER
MANIPULATIONS IN .IMP, IT FORCED THIS MODULE TO BE IN ASSEMBLER.
@THE SECOND ASSEMBLER MODULE PROVIDES THE RUN TIME SUPPORT FOR .IMP
PROGRAMS. @THIS MODULE COULD PROBABLY BE CONVERTED TO .IMP LATER,
BUT WAS WRITTEN IN ASSEMBLER FOR BOOTSTRAPPING REASONS. @FORTUNATELY,
THESE TWO SECTIONS ARE CHANGED INFREQUENTLY AS THEY HAVE PROVED TO BE A
DISPROPORTIONATE SOURCE OF PROBLEMS IN RELATION TO THEIR SIZE.
$P1 @THE REST OF THE SYSTEM CONSISTS OF SIX .IMP MODULES, COMPRISING
THE KERNEL AND THE SYSTEM TASKS. @THESE MODULES ARE COMPILED SEPARATELY
AND THEN 'LINKED' BY A PURPOSE BUILT LINKER WHICH ALSO SETS UP
THE BOOTSTRAPPING AREA.
$P1 @APPLICATION PROGRAMS, WITH THE EXCEPTION OF THE EDITOR - WHICH
WAS BROUGHT FROM THE PREVIOUS SYSTEM - HAVE BEEN WRITTEN IN .IMP. @THE
SOURCES ARE HELD AND COMPILED ON THE SYSTEM.
$B2
$V10 $L1C
OPERATION
$P0 @THIS SYSTEM HAS BEEN IN OPERATIONAL USE ON TWO MACHINES
SINCE @MAY 1976, AND IS OCCASIONALLY USED ON A THIRD MACHINE
FOR A SPECIAL PROJECT,
THE INTERACTIVE BENCHMARKING OF AN .ICL 2970.
 @AT THIS STAGE SWOPPING
AND THE USE OF MORE THAN EIGHT SEGMENTS,
HAS STILL
TO BE IMPLEMENTED, THOUGH MOST OF THE NECESSARY KERNEL
FEATURES ARE ALREADY PRESENT. @THE MULTIPLE TERMINAL SUPPORT
HAS NOT BEEN TRIED, OWING TO A LACK OF HARDWARE.
$P1 @IT IS STILL TOO EARLY AT THIS STAGE TO
EVALUATE THIS SYSTEM PROPERLY,
 BUT IT IS CURRENTLY BEING USED BY
SEVEN OTHER PEOPLE, IN WIDELY DIFFERING WAYS AND IS PROVING
SATISFACTORY.
$N 
$E