1. The Structure of “THE” – Multiprogramming Systemby
Edsger W. Dijksta
Technological University, Eindhoven, Netherlands.
Slideset (mostly) by Navya Jammula

2. What is the paper about?
The Conception, Construction and Verification of a multiprogramming system – “THE” (Technische Hogeschool Eindhoven)

3. Outline Goal Hardware configuration used Key Contribution Areas
Synchronization Primitives
Experience
Mistakes
Concerns

4. Goal
Process smoothly a continuous flow of user programs.

5. Objectives
Reduction of turn-around time for programs of short duration
Economic use of peripheral devices
Efficient use of Memory and Processor.
Support programs that need the flexibility of general purpose computer without the capacity and the processing power

6. Tool Dutch Electrologica EL X8 computer
32K core memory (cycle time 2.5usec)
512K words drum (1024 words per track, 40msec rev )
An indirect addressing (suited for stack implementation)
Low capacity channels supporting peripherals
(3 paper tape readers and punches, printer, plotter, and 2 teleprinter)
A sound control of interrupts and peripherals

7. Key Contribution Areas
Storage Allocation
Processor Allocation
System Hierarchy

8. Storage Allocation
strict distinction between memory units and corresponding information units
Pages
Core Pages (page frames)
Drum Pages (disk blocks)
Segments
A segment fits in a page (virtual pages)

9. Storage Allocation Contd.
Number of possible segment identifiers is much larger than the total number of pages in primary and secondary store.
Virtual space >> physical space
The segment identifier (page #) gives fast access to a so-called “segment variable” in core whose value denotes
If not empty, in which page (or pages) it can be found.

10. Consequences
No need to return the segment to the same drum page from which it originally came
Can select one from among the free drum pages with minimum latency time.
Total absence of a drum allocation problem
A program need not occupy consecutive drum pages
In other words … virtual memory!

11. Processor Allocation
In a single sequential process only the time succession of various states has a logical meaning, but not the actual speed with which the sequential process is performed.
Hence the whole system can be arranged as a society of sequential processes, progressing with undefined speed ratios
In other words – virtualization of the CPU!

12. Society of Sequential Processes
The following are processes:
Each user program accepted by the system
Each input peripheral (buffering input streams in synchronism with the execution of the input commands),
Each output peripheral (unbuffering output streams in synchronism with the execution of the output commands);
Segment Controller associated with the drum
Message Interpreter associated with the console keyboard.

13. Cooperation Among Processes
Processes co-operate with each other using explicit mutual synchronization statements
Semaphores!
Two Uses for Semaphores
Mutual Exclusion Semaphores
Private Semaphores (Condition Synchronization)

14. System Hierarchy “THE” has a strict hierarchical structure.
THE has six Layers, levels 0 – 5
Each layer builds an abstraction hiding the details below it
Each layer uses only the functionality of the layers below it

15. Level 0 – CPU Virtualization
Responsible for processor allocation to one of the processes whose dynamic progress is logically permissible
It deals with interrupts and performs the context switches when a process change is required
A priority rule is incorporated to achieve quick response of the system
Above level 0 the number of processors actually shared is no longer relevant
Processor virtualization is the first level of abstraction

16. Level 1 – Memory Virtualization
The segment controller is present at this level
It is responsible for the bookkeeping for an automatic backing store
At all higher levels identification of information takes place in terms of segments, the actual storage pages have lost their identity
Memory virtualization is the second level of abstraction

17. Level 2 – Console Virtualization
At level 2 we find the Message Interpreter taking care of the allocation of the console keyboard.
Above level 2 it is as if each process had its private conversational console
In fact all processes share one physical resource and the sharing is enabled via mutual synchronization
At higher levels the actual console teleprinter loses its identity
Console virtualization is the third level of abstraction

18. Levels 3 – 5 Level 3 – I/O Virtualization Level 4 – Application Level
Contains the Sequential Processes associated with buffering of input streams and unbuffering of output streams.
Manages all I/O between the devices attached to the computer
Level 4 – Application Level
Consists of the independent – user programs
Level 5 – The actual user!
Consists of the System Operator

19. Synchronizing Primitives
Mutual synchronization of parallel sequential processes is implemented via "semaphores.“
Semaphores are special purpose integer variables initialized with the value 0 or 1
Parallel processes will access the semaphores via two specific operations
P-operation
"P(sem)" decreases the value of the semaphore called "sem“ by 1.
V-operation.
"V(sem)" increases the value of the semaphore called "sem“ by 1

20. Semaphores Contd.
If a semaphore value is nonpositive its absolute value equals the number of processes booked on its waiting list.
The P-operation represents the potential delay, the complementary V-operation represents the removal of a barrier.
P- and V-operations are "indivisible actions“
Presumably implemented via interrupt disabling?
If the semaphore value resulting from a V – operation is negative, its waiting list originally contained more than one process.
It is logically immaterial-which of the waiting processes is then removed from the waiting list.

21. Semaphores For Mutual Exclusion
begin semaphore mutex; mutex := 1;
parbegin
begin L1 :
P (mutex ) ;
critical section 1;
V(mutex);
remainder of cycle 1;
go to L1
end;
begin L2:
P (mutex);
critical section 2;
V (mutex);
remainder of cycle 2;
go to L2
end
parend

22. Semaphores for Condition Synchronization
Each sequential process has associated with it a number of private semaphores, initialized to 0.
Max value equals 1,
Min value equals -1.
No other process can ever perform a P-operation on them

23. Semaphores for Condition Synchronization
A process reaches a stage where the permission for dynamic progress depends on current values of state variables
P(mutex) ;
"inspection and modification of state variables including a conditional V(private semaphore)";
V (mutex) ;
P(private semaphore).
If the resource is available,
It performs the operation "V (private semaphore) “
The semaphore value then changes from 0 to 1
Else
this V-operation is skipped, leaving to other processes, to perform this V – operation at a suitable moment

24. Semaphores for Condition Synchronization
A process reaches a stage where as a result of its progress possibly one (or more) blocked processes should now get permission to continue
P (mutex) ;
"modification and inspection of state variables including
zero or more V-operations on private semaphores
of other processes";
V(mutex).

25. Proving Harmonious Co-operation
Homing Position: The neutral point in which all cyclic processes are when the system is at rest.
A single task cannot give rise to an infinite number of task generations
processes can only generate tasks for processes at lower levels of the hierarchy so that circularity is excluded
System cannot be at rest if there are still pending tasks
All processes will eventually be in homing position (no deadlock)

26. Experience
Conception
Construction
Verification

27. Conception, Construction
All the concepts are born
It took a long time!
Learnt that the society of mutually synchronized processes in time behavior can satisfy all the requirements
Construction
Done in rather traditional manner
Change of specifications has been rare

28. Verification
Starting at level 0 the system was tested, each time adding (a portion of) the next level only after the previous level had been thoroughly tested.
Force the system into all different relevant states
Verify that the system continued to react according to specification
Hierarchical structure made testing easy
Else the number of "relevant states" would have exploded to such a height that exhaustive testing would have been an illusion
The hardware failures couldn’t affect testing due to the hierarchical structure

29. Software Engineering Observations
Production speed severely slows down when working with part–time people
People lose time and energy in switching over and the group loses decision speed.
Similar to context switching in OS
This type of work is very difficult, and that every effort to do it with other than the best people is doomed to either failure or moderate success at enormous expense.
This strongly supports the argument that we need wizards for multi programming

30. Mistakes Made
Paying too much attention to eliminating what was not the real bottle neck
Trying for “Perfect Installation”
Late Debugging

31. Conclusion
The “THE” system apparently introduced the first forms of software-based memory segmentation freeing programmers from being forced to use actual physical locations on the drum memory
The design of the “THE” multiprogramming system is significant for its use of a layered structure, in which "higher" layers only depend on "lower' layers
Hierarchical structure of the system in which layers of abstraction are used to virtualize resources.
A refined multiprogramming system whose logical soundness can be proved a priori and whose implementation admits exhaustive testing