CS 736 Reviews - Spring 2015

1. Summary
This paper introduces the nucleus of multiprogramming system while provides great flexibility in various aspects such as multiple process execution, dynamic process creation and termination, process communications, process hierarchies, resource allocation, etc.

2. Problem
The paper states all systems back to that time lacked a flexibility to do various operations in one machine, as there is only one program executing (one process). This extremely limits the power of computers and it suggests that more operations could be supported in a cooperating way to carry out more complex jobs.

3. Contributions
The nucleus system is designed to resolve the problem. Specifically, it abstracts each kind of operation as a process, and provides primitives of process communication, scheduling, dynamic control (creation/termination), hierarchy, etc.

The paper defined the concept of process. Internal process is an execution of program while external process handles the i/o of a peripheral device. Process can communicate with each other using a shared buffer location to store message and a message queue associated with each process.

External process is specially design to handle i/o. Back to that time we didn’t have file system which implies we didn’t treat peripheral devices as files as we do today. To do read and write, the way is to create an external process for that device and read/write can be carried out by process communication.

The dynamic control and resource allocation is realized by process hierarchies. On system start-up, only one process is executing. This process can create/stop/restart/terminate child processes and allocate/revoke resources to child processes. Child processes can in turn have their own child processes, which makes a rooted-tree of all processes. All control (including scheduling) and resource allocation of a child process is in the charge of its parent process, which keep the system manageable while flexible.

4. Evaluation
This paper did not compare the performance of the nucleus design and existing systems. However, from the description it’s easy to see the advantage of nucleus design, which solves the problem in a systematic and elegant way. The paper did provide timing overhead of nucleus system and stated such an overhead is tolerable and to reduce this overhead we have to make hardware faster.

5. Confusion
I did not understand the differences between send/wait message and send/wait answer in process communication. Under what circumstances are we only able to use one instead of the other? I suppose either is redundant even though the system still works with both mechanisms, as long as the parent process of communicating processes specifies which mechanism to use. Another confusion is that I believe the scheduling is done by parent process via stopping(pause)/restarting(resume) child processes, while members in my reading group insist it is done by the nucleus system. My understanding is the nucleus system only provides primitives to create/stop/restart/terminate a process. It is the parent process, however, that actually calls these primitives and schedule the child processes.

1. summary
This paper, "The Nucleus of a Multiprogramming System" describes the structure of a multiprogramming system. In this paper they concentrate on three important aspects of the "Nucleus"(kernel),
- Defines the concept of Processes
- How multiple process synchronize and communicate with one another
- Rules for dynamic process creation, control and removal
To effectively Adapt into different operating modes, this paper proposed the idea of abstracting the basic functionalities into "Nucleus" of the Operating system with the above mentioned multiprogramming features.

2. Problem
At the time of this paper, Operating systems were limited to a single mode of operation like batch processing. When the user wants another functionality he is forced to use a new operating system. To Address this issue, this paper presents a abstraction called, system "Nucleus" which can extended into a new OS.
3. Contributions
- The key contribution is the idea of nucleus, which is to be considered as a part of computer hardware and over which new operating systems can be built (or switched dynamically).
- Nucleus should only contain the essential primitives and functionalities like creating, controlling, removing process, interprocess communication and synchronization. Resource allocation and scheduling of process are left to the operating system.
- Distinction between Internal(execution of program) and external process(I/O tasks of a process).
- Interprocess communication are done using message buffers using primitives like sendmessage().
- Rules for process hierarchy are explained. Process hierarchy is used to manage the processes. Child process is controlled by the parent process.
4. Evaluation
This paper doesn't provide any implementation details of the proposed system. But they do provide some measurements of this system running on RC4000. They also didn't provide any comparison over others and "Nucleus" running on other machines.
5. Confusion
How is the scheduling done? Is it left to the operating system or done in round robin fashion ?
Can you explain the old terminologies like "catalog on the backing store" ?

1. Summary

Their paper is about a multiprogramming system built for the RC 4000 computer, based around the concept of a system nucleus, which itself is responsible largely for process handling. The entire system designed to be flexible and extensible by minimizing the constraints placed on the processes, and leaving most resource allocation problems to the processes

2. Problem

Most other OSs are based on one processing model (i.e. batch processing). And it is in general not feasible to modify the operating system to use another processing model or another API. In particular, such a change usually required a rewrite of the system from scratch.

3. Contributions

Their core concept in this direction is to have most of the operating system as we would know it be implemented as parallel cooperating processes. As compared with more common operating systems, this allowed the operating system to be both easily modifiable and easily replaceable. To this end, the system nucleus focus on two pieces, processes and interprocess communications.

To start we have processes, of which there are two types, internal and external. Internal processes, arguably the more familiar type of process, represents a unit of execution. (some more details). External processes on the other hand, are an abstraction used to deal with hardware, usually various sorts of input/output. The point of the external processes is to allow access to devices and IO without creating new system calls. instead, since they are treated as processes, and to communicate with the hardware, the other programs only needed to communicate with the external processes.

In particular, for the most part, whether a process is internal or external is not of any particular importance, from the standpoint of unrelated processes, external and internal processes are identical, since they both respond do and communicate via the same messaging protocol. This allows for further flexibility, since one could choose to implement an external process in an internal process at some later time, with no changes required to the other programs.

Another detail relates to resource management, in particular, the process hierarchy the system nucleus creates. To increase flexibility, the system nucleus itself does not deal heavily in resource management, instead the large majority of this is left to the processes. In particular, each process has some set of child processes, the execution of which is largely under the control of the parent process

4. Evaluation

One of the more important features touted by the paper is flexibility. This as compared to speed or response time is considerably harder to measure, but they could have, as an example, created several simple systems which show the range of possibilities on the system.

They do also look at the speed of the calls. Context is again not really present, although they do mention the average machine instruction speed. Nor is it shown how this might scale with message size, the value for the response times of the various primitives is not clarified with any information about what data was actually sent. In addition, these are very low level primitives, which in all likelihood would be called many times for any higher level operation, and nowhere do they attempt to show that higher level operations, written in these terms would actually execute in a reasonable time frame.

5. Confusion

How do the processes implement program scheduling, it seems that the scheduling is a round robin between the processes, yet earlier they mention that the scheduling is up to the user programs? Is it just in their particular system that they use, the processes implement round robin scheduling, or is this baked into the system nucleus.

Summary:
This paper discusses the multiprogramming system that was developed for RC 4000 computer. In particular, it discusses the system nucleus, which was designed to provide a multiprogramming environment, where program execution and IO support are handled as parallel, cooperating processes. The paper also clearly describes the primitives provided by the system nucleus to support multiprogramming such as inter process communication, synchronization and a hierarchy of processes.

Problem:
In this paper, the author attempts on breaking the rigidity of the conventional operating systems by allowing a degree of freedom in the user processes to select the strategies for scheduling, execution, resource allocation etc. Thus the focus of the author is not to define functions to meet the operating needs but rather to design a system nucleus, which can be used as a base on which the operating system can be easily extended.

Contributions:
One of the defining features of this multiprogramming system is to regard the system nucleus as a software extension of the hardware structure. The main function of the nucleus, which is very akin to a microkernel is to implement primitives that processes can invoke to create and control other processes and communicate with them. System nucleus implements only the privileged operation but has no built-in strategies. Each process implements its own strategies to control scheduling and resource allocation. The inter process communication is supported through a message passing mechanism with necessary primitives in the form of send and wait APIs and message buffers and queues for each process. There is a clear notion of internal and external processes, but they are handled uniformly as independent, self contained processes. The system also structures a clear process hierarchy, where each process (parent) can create its own child processes and define its own strategies to control the scheduling and resource allocation of its children.

Evaluation:
The paper provides some figures pertaining to the size of the nucleus and execution times for communication and creating and destroying a process. But, these are stand alone numbers that specify the system and can’t be used to evaluate the system.

Confusions:.
It has been mentioned in the paper that the processes are responsible for scheduling its children. But it has also been mentioned that the system uses round robin mechanism for scheduling. So I am basically confused with the scheduling mechanism in the system.

1. Summary
The paper outlines the architecture of a multi-programming system, Nucleus, which is extendable to implement operating systems that suit the user requirements of resource allocation and scheduling. The system achieves this goal by providing fundamental primitives for process control (creation, termination of processes) and communication between processes via message passing. These primitives assist in creating a hierarchy of processes (or operating systems), where parent processes controls the resource allocation and scheduling of its children.

2. Problem
Existing operating systems at that time made inflexible assumptions in design that were tailored towards specific mode of operation. Changing the mode of operations or co-existence of multiple modes of operation in the same system was nearly impossible. Nucleus aims to provide a framework for easy implementation of new operating systems and concurrent operation of multiple operating systems.

3. Contributions
Nucleus adopts message passing primitive for inter-process communication and synchronization needs. More importantly, it reuses this message passing primitive for communication with devices by implementing them as processes (external), which control access to user processes (internal). Nearly all modern operating systems use some sort of message passing API to control access to external devices. It structures the system as a process hierarchy with parents controlling the scheduling and resource allocation of children, where typically the first layer of processes serve as an operating system implementing the requirement of the user.

4. Evaluation
The author provides code size of Nucleus system including the sizes of implementation of primitives and external processes to show the feasibility of this approach. In addition, the author provides the latency of system response to invocations of process control and message passing primitives to show the real-time nature. However, in both aspects (code sizes and latencies), the author fails to compare them with conventional multiprogramming system designs.

5. Confusion
The paper contradicts the claim that Nucleus lets the parent process control the scheduling of the children. The author states towards the end that Nucleus uses round-robin scheduling across all the processes in the system. On the same note, the description of swapping processes seems unclear. If it refers to scheduling change of processes, it adds to claim of parent processes controlling the scheduling.

1. Summary
This paper introduced the idea and structure of an innovative multiprogramming operating system, which allows multiple programs to be executed at the same time and communicate with each other. Specifically, the paper formally defined a series of concepts about a process, discussed how information could be shared and synchronized across different processes, explained the hirarchy of processes and how child processes are created and controlled.

2. Problem
At the time the paper was written, it is not allowed in operating systems to control different programs with different modes of operations. However, there arises need for such flexibility in operating systems. More problems came up if a multiprogramming system is adopted, including information exchange between processes, and the design of process control primitives.

3. Contributions
1. This paper offered a set of unambiguous definitions regarding processes - internal/external process, document, and peripheral device.
2. A method buffering method was introduced to tackle the problem of process communication. It discussed how buffers should be managed, and four primitives used for communication in a dynamic environment.
3. The concept and usage of external processes is introduced, which is like the origin of a modern file management system.
4. The paper also talked about process hirarchy, mentioning that child process and its parent share the same storage space. A parent process can dynamically create, stop or remove a child process, to reach the goals of scheduling.
5. The paper also presented the implementation of system nucleus, with test results in execution time.

4. Evaluation
In this paper it shows that the common actions of system nucleus are carried out in real time, which looks good.

5. Confusion
1. What is the major difference between methods send message (receiver, message, buffer) and send answer (result, answer, buffer)? It seems one of them is redundant.
2. In the 7th section, it says “computing time is shared by round-robin scheduling among active processes regardless of their position in the hierarchy”. What does it imply? How could parent processes achieve flexible scheduling with only start/stop operations over child processes?

Summary:
The paper focuses on addressing the main problem in design of multiprogramming system by focusing on the development of a minimal system for initiation and control of processes.

Problem:
The Operating Systems existing before the time of this paper were based on single mode of operation like batch processing, priority scheduling, etc. This restricted the freedom in switching the operation mode.

Solution:
The paper proposes a system nucleus that can be extended with new operating systems operating in different modes. The nucleus design supports simulation of process, communication among parallel processes, and creation, control and removal of processes. This nucleus concentrates on an environment of parallel and cooperating processes. The key idea introduced to achieve this goal are as follows:
-Internal and External process:
External processes are created on request from an internal process, and are simply as assignment to the peripheral device added to a system. External processes are used to obtain synchronization between internal processes and peripheral devices. In case of internal processes synchronization, clocks are used. Internal process are created on request from other internal process.
-Interprocess Communication through message buffering:
The binary semaphore are insufficient in a dynamic environment, where a process might be non-cooperating. The paper introduces message buffering for process communication, with each process having its own message buffers and message queue. Communication is established between two processes by selection of buffer. A process can send only limited number of messages.
-Process Hierarchy:
The internal store in a system can have just the nucleus and a primitive operating system that can spawn new processes. These processes can have resources allocated from only the parent's resource pool, and a parent can just control its own child processes. This hierarchy system is crucial for process control and resource allocation management.

Evaluation:
The paper includes the evaluation for system with proposed design, but there are no benchmark comparison with other systems.

Learning/Confusions:
There are a couple of loose ends in the paper, which can be summarised to following questions:
-How will the system handle the case of non-cooperating processes? Will solutions like message buffering be sufficient?
-For synchronization between external world and internal process, external process is used as signal. What if the external device misbehaves? Will it lead to internal process waiting forever? A hang situation? No time-out in this case is mentioned in paper.
-Paper doesn't mention about the process behaviour in case of dummy answers are returned to sender from a removed receiver process during process communication?

Summary:
This paper talks about a pioneering attempt at building what is now known as a 'Microkernel' - the 'nucleus' system, for the RC 4000 microcomputer.

Motivation:
The developer, Per Brinch Hansen, built the 'nucleus', envisioning it as a basic set of primitives (/mechanisms) for a multiprogramming system on top of which other operating systems could be built. He felt that this would afford increased flexibility to the users of the system.This is essentially achieved through a kernel that does as little amount of work as possible, pushing a lot of functionality into other programs ( and hence the name 'micro'-kernel).

Contributions/Solution:
Some important points to note about the design of nucleus are:
- The separation of 'policy' (strategies, for ex: scheduling strategies) and 'mechanism' (nucleus primitives) and the increased flexibility that such a separation offers.
- A synchronization/ inter process communication mechanism through buffers and message queues that offers increased protection compared to a simple semaphore based system (since each buffer can only be accessed by defined sender and receiver processes)
- A classification of internal vs external processes: Internal processes are programs in execution where as the term 'external process' refers to the execution of pieces of code from the nucleus which are created by, and interact with, the internal processes to handle their I/O tasks (such as writing a file to disk).
- A hierarchy of processes ( parent to child ) where each parent is in charge of creation, scheduling, resource allocation, and finally termination/removal, of its child processes. Such a hierarchy of processes gives the user the ability to run almost completely different operating systems in parallel on the same hardware, which is a remarkable degree of flexibility.
The actual basic multiprogramming system consists of the nucleus (which is a set of interrupt service routines, inter process communication and process management primitives) and the basic process (named 'S') ( somewhat like the the init process in unix) which forms the root of the process hierarchy.

Evaluation:
A short list of the time taken for important primitives such as send/receive message is provided at the end of the paper. The author argues that since the communication primitives take a short amount of time, it is agreeable to suspend interrupts(/ run in uninterruptable mode) during their execution ( possibly to avoid a lot of book-keeping that might need to be done about the status of buffers and queues if these primitives were interruptable). An interesting idea explained in this section is that since the primitives to 'create', 'start', 'stop' and 'remove' a process take a lot more time, they are not executed in uninterruptable mode, but rather as a separate anonymous process.

Confusions:
-In the evaluation section, it is stated that since the time taken for communication primitives is distributed uniformly across validity checking, process activation and message buffering, the addition of ad hoc machine instructions will not help to improve the efficiency. But this is not explained further. How will such an addition improve efficiency if the time was not evenly distributed?
-Why can the process management primitives not execute in interruptable mode directly? Why is the new anonymous process neccessary for them to avoid being uninterruptable?
-Does communication with the anonymous process for process management ( create, start, stop etc.) happen through the buffers and message queues?

1. Summary
The paper describes a multiprogramming operating system model, based on a single minimalistic kernel or nucleus system. The design principle is to maintain the flexibility for the users to tailor the system according to their computing applications/requirements.
2. Problem
The freedom of system design is often limited by the fact that most of the kernel design either cannot be modified or is too difficult to change. So, the focus of the problem in this paper is not about providing a functional interface to the users, but rather providing the functionality to implement user-defined strategies.
3. Contributions
To address these issues, the authors provide a minimalistic kernel/nucleus interface, where the kernel provides the fundamental abstraction of process creation, control, removal and a set of communication primitives. This is the basis for constructing a system of parallel, cooperating processes. These processes can be either user defined programs or I/O devices. This gives freedom to the user to define strategies for resource allocation and process scheduling. All the user processes are independent, self-contained and unaware of the state of other processes and communicate with each other through message buffers and queues. The nucleus implements all the privileged operations and places some restrictions on process creation, release, message handling in order to restrict malicious processes.
4. Evaluation
The evaluation is performed on a RC 4000 machine and a timing profile of the system components under uninterrupted conditions is given. This includes the profile for message send/receive and process creation/removal. Since this is the timing behavior for the primitive operations, it is difficult to estimate the performance for an application since that would involve other factors as well. Considering that the design is a minimalist kernel, providing such numbers could be misleading though. But still, a comparison with existing systems performance could have been helpful.
5. Confusion
I think microkernels are competitive in comparison to monolithic designs, but why did they choose message buffering interface for communication? They say it is to maintain security, but isn't this method an overhead in itself? And I did not understand how process memory address spaces work here. Can the address space be shared?

Summary:
The paper introduces the concept of a Nucleus, which was intended as a basic block to develop operating systems around. It provided the developer of Operating systems with a general set of primitives for dynamically creating and controlling processes, inter-process communication, synchronization and a top level round-robin scheduler.

Problem:
The existing operating systems did not provide any flexibility to the developer of advanced information systems to customize the modes of operation to suit the workloads. The fundamental ideas were placed at the core of the operating systems and modifying them was a daunting task. The aim was to provide a minimalistic system over which system designers could build on to customize the OS to specific applications.

Contributions:
The idea of treating the nucleus as a platform for processes to create and control other processes was the essence of the paper. It inspired the concept of minimalistic design, ex. micro-kernel, which played a key role development of OS for some time. The paper also introduces the concept of queued message buffers for inter-process communication, which I believe was an alternative for signaling using conditional variables, where the author tried to address the problem of deadlocks by using dummy answers from the Nucleus. By doing this, the system was immunized against buggy multi-threaded cores. The issue of security was addressed by using process identifiers. The author mentions limitations of the approach, limited number of simultaneous messages that a process can send, but doesn’t provide any solution to it. One of the solutions to this problem would have been to set an upper limit to the number of messages a process can send and keep the process on hold if it exceeds the limit. By abstracting the peripherals as external processes and treating external and internal processes similarly, the author made Nucleus a programmer friendly environment and also reduced the code size. Another key area where the paper’s contribution was significant was the concept of using external interrupts for inter-process communication; it defined a way for processes to establish connection with external devices. The concept of hierarchical processes provided a guideline for developers to build their systems around Nucleus.

Evaluation:
I believe the data provided, time taken by communication and process control primitives, helped system developers estimate the performance of their system. However the data is limited to RC4000 which had storage restrictions, it would have been interesting to see how the concept of Nucleus performed on other systems

Confusions:
If the control was not returned to the nucleus at and after external interrupts, or timer interrupts, how did the nucleus control the scheduling of processes? Was it implemented using control blocks in the address space of processes?

1. Summary
The paper describes a basic operating system that is flexible in the sense that it allows other processes to suit diverse requirements of its children processes. Thus the nucleus is just a minor software extension of the hardware it sits on top of.

2. Problem
Existing operating systems then were rigid in their program scheduling and resource allocation strategies. The author wanted to develop an operating system(nucleus) that takes care of process creation, simulation and communication while staying out of scheduling and resource allocation of newly created processes.

3. Contributions
Processes: Internal process were running programs in the given storage area. They can create their own children processes in their given memory space. Thus they form a hierarchy(tree) of processes starting from a base operating system.
External processes were called in times of I/O communications with the disk and other devices, creating a process every time.
Process communication: To improve security, message buffers and queues were used in place of semaphores. Four routines are used to synchronise sending and receiving of messages through buffers. Proper deletion of buffers were implemented in case of killed processes.

4. Evaluation
The message communication routines take 0.5ms on average. However, creation and deletion of processes are around 28ms on average and hence are implemented as separate processes rather than non-interruptible routines. Buffering of these messages take 30% of the system time while validity check takes up 25% and the rest of the time is used for process activation.

5. Confusions
It is said that there is one anonymous internal process that creates new process and is non-interruptible. If there are many calls for creation from different processes, are they serialised to this anonymous process or is a new process forked every time?

Summary: This paper introduces the philosophy and structure of RC 4000,
a multiprograming operating system which can be extended to a hierarchy
of operating 
systems with diverse requirements of operating mode. Size and
performance are reported. 

Problem: At the era of the paper, the operating systems are designed
with rigid assumption on the specific mode of operation (e.g. batch
processing, priority scheduling). This makes the designer's freedom
restricted. Designers need another kind of operating system that only
provide the nucleus for extending to more focused operating systems.

Contribution: This paper considers several fundamental concepts in OS
(beyond specific things previously).
1. Definition of internal process (execution of interruptable
instructions on a given storage) and external process (input/output of
documents). These two kinds of processes are switched by interruption.

2. They utilize message buffers for process communication, which has
advantages in dynamic environment where each process can be down/error.
The buffer is particularly useful for unreliable communication between
pair of processes.

3. It only provides the primitive functionality to allow a hierarchical
of operating systems (as internal processes) to run on it
simultaneously.  Each operating system (internal process) has the
control of the operating mode.

Evaluation: The size of nucleus and basic operating system is 6200
words. The distribution and time for each basic operation on processes
are also shown.

Confusion:
The paper mentioned to let the operating system choose the schedule, but it also mention the creation of process is based on round-robin based schedule. Doesn't these two statement in conflict?

Summary

Hansen proposes a multiprogramming system which allows a system to adapt flexibly between different operating modes. It achieves this by abstracting low level system functionality into a "nucleus", then allowing multiple operating systems with different characteristics to run on top of this nucleus. This was an early attempt at developing some of common abstractions that later became the architecture for modern operating systems.

Problem

Operating systems in the late 1960s were unable to meet diverse requirements for scheduling, resource allocation and batch processing. This fundamentally limited individual operating systems to a single mode of operation; if a programmer had to change their operational needs, they required a new OS, which was logistically difficult if not impossible. Hence, the nucleus of systems needed to be redesigned to allow diverse operational modes.

Contributions

Hansen's paper presents a new model whereby many different operating systems run on the same machine at once. The system is designed with a "nucleus": a primitive operating system that performs only very basic, low level system functions, akin to the modern kernel. The nucleus then creates parallel processes which are in effect separate operating systems; these in turn have child processes.

The paper also describes a difference between internal and external processes. Internal processes were similar to what modern operating systems consider a process; external processes were an early abstraction for files and data, which would later evolve into the file system. It also talks about a communication system between processes, similar to modern sockets.

Evaluation

Hansen provides some measurements of the performance of the RC 4000 system running with the proposed multiprogramming system. These results are interesting, but unfortunately not very useful as they don't offer any basis for comparison. It would be more helpful if the paper showed the time requirements for a different operating system running on the RC 4000, especially across a variety of different processes and operating modes.

Confusions

Were internal and external processes actually set up as different constructs in system memory? Or were these just different ways of using a common process structure?

I'm also confused about the primitives used to send messages between processes. Specifically, I don't understand why a "wait message" primitive is needed. Also, do the messages use any sort of locks?

Why is computing time shared among all processes by round-robin scheduling? Wasn't the whole point of having subprocesses running unique operating systems that they could have their own individual operation modes (and hence, scheduling rules)? This seems to contradict their earlier statement that "processes should have complete freedom to choose their own strategy of program scheduling".

Summary
This paper discussed how to build a multiprogramming system using a dynamic hierarchical process design system, implementing concurrency primitives by allowing processes to communicate to each other with message buffers, and providing a distinction between internal and external processes which allow the system to communicate with a peripheral device. The process hierarchy was created so that each parent process has complete control of every child process that it contains, meaning it has control over the scheduling and resource allocation. The paper also describes a message buffering system, which is used for concurrency, which allows two processes to communicate with each other.

Problem
The problem that this paper set out to solve was to create the minimal set of features (the core of the system) needed to create a multiprogramming system. They made no assumptions of the underlying hardware of the system, or of the types of processes that would be run on this system. Their overall goal was to create a system in which multiple processes could run in a parallel and safe manner. In order to do this, they also had to solve the problem on how best to synchronize access to a shared resource and how to allow processes to be created and to be destroyed and what controls the process during its lifetime.

Contributions
This paper contributed several ideas that allowed for processes to be run in a multiprogramming environment. The paper introduced the idea of message buffers as a way for process to communicate to another process and synchronize the access to the data. When two processes want to communicate to each other, one process can call send message and copy a message into the buffer. Another process could also be running, call wait message, and be suspended until a message appears in the queue. Once the message appears in the queue the process proceeds and the buffer is removed from the queue. Processes can also send answers and wait for answers to the messages that they send and receive in a similar manner. One of the main contributions this paper made was the idea of a system nucleus in general, which is the idea the nucleus is the core of the system, and processes can be created on top of that which creates a process hierarchy within the system. This also led to the distinction between internal processes and external processes. The paper declared that internal processes are simply the execution of a program whereas an external process is used to communicate to documents that are stored on a particular physical device. This is a key concept, because it allows internal processes to use devices and use documents by simply accessing their device number, rather than know which physical device contains the document.

Evaluation
This paper presents a number of good ideas for the design of an operating system, but it doesn’t necessarily show any evidence on why or how these design philosophies are better than other systems. It does present some good points at the end of the paper on the advantages of designing a system nucleus like this, such as that new operating system can be implemented on top of it without modifying the system nucleus and that the operating system can “be replaced dynamically”. The paper also outlines some of the implementation statistics of the system, such as the size of the nucleus and the size of the primitives and code for external processes. The implementation details are interesting and useful, but it could have been more precise in the evaluation and compared it to an existing system to show that the system design was superior.

Confusions
I was able to understand the idea behind the process hierarchy, but throughout the paper I was under the impression that each process could control the scheduling of their child processes. Then, the paper mentioned that “Computing time is shared by round-robin scheduling among active processes regardless of their position in the hierarchy”. This confused me because it seemed to be a direct contradiction of the general idea of a process hierarchy. The explanation of “dummy” answers also could have been explained more clearly, such as when a situation that would require a dummy answer would arise.

Summary
In this paper, Hansen describes structure of minimalistic multiprogramming system which can be used to build different operating systems supporting different modes of operations. Author explains in detail concept of process, difference between internal and external process, different primitives used for communication between process and primitives used to create dynamic processes, control them and remove them.

Problem
Users were not allow to change mode of operation at that time because operating system were made for certain mode of operation and had made some rigid assumptions in its design. Author tries to solve this
problem by building minimal flexible system which can be used to build operating system serving different mode of operations.

Contributions
1. Author introduces concept of Nucleus which is bare minimal system used to build different operating systems. Nucleus implements only basic features like process communication, process control and lifetime of process.
2. Nucleus helps in running different modes of operations with same installation. Operating system supporting different modes can be switched dynamically.
3. He introduces internal process which is execution of a program and external process which performs I/O task. Different primitives for communication between process are described and its flow is explained in detail. Process communication is designed considering different aspects like security, efficiency, support to exchange more messages at a time.
4. Introduces concept of process hierarchy which allows parent for complete control of child process in terms of its creation, deletion and its resources.

Evaluation :
1. Given hardware present at that time, author claims performance of system was at peak and performance can be further improved only with faster hardware.
2. Size of basic operating system and nucleus is given.
3. Time taken by different primitives in communication are presented.
4. For 2ms conversation, time spend in validity checking, process activation and message buffering is shown.
5. Time taken by different primitives like create process, start process, stop process and remove process is given.

Confusions
Didn't understood terms like catalog and description of file in the following sentence:
“A file on the backing store can be used as an external process by copying a description of the file from a catalog on the backing store into the system nucleus”.

Summary
The paper is about the core(nucleus) of a multiprogramming system that gives sufficient flexibility to perform batch and interactive operations alike. The author presents a system with abstractions of internal and external processes and heirarchical relations between processes to support a generic multiprogramming system.

Problem
The problem discussed in this paper is of the rigidity of operating mode in earlier operating systems. The ways to get around this problem were either modify the operating system or replace it.

Contribution
The author clearly defines the abstraction of processes with their types, arrangement in memory and communication primitives for a flexible multiprogramming system. Firstly, the authors establishes clear difference between a program and a process. The execution of programs in memory is termed as an internal process whereas an external process deals with input/output tasks of a specific process. For communication between processes, this system uses message passing via message buffer pool and message queues. Sending and waiting primitives are provided by the nucleus for both messages and message responses. External processes are created by internal processes when they need to perform input/output operations. Internal processes follow a similar pattern where each process is created by another process which is referred to as the parent process. This defines a heirarchy for the processes in the system. The first process is created by the operating system. The heirarchical structure enables operating systems to be treated as a process and further allows the nucleus to support running multiple operating systems at the same time.

Evaluation
The nucleus is evaluated by implementing it on a RC 4000 computer. The author presents statistics on the size of the nucleus and the operating system in terms of words. The author presents latency data of the message passing primitives and the percentage breakdown of the time taken for the message. The times for process operations like creation and removal are also measured. However, the paper does not provide any comparison of performance with other systems or does not give any data of how various operating modes performed on the system.

Confusion
It is not clearly defined how the memory(storage area) is managed in the system. It is only mentioned that the parent process has the power to control the resources of its children but there are not details on how it is done. The way it is organized as per the paper, it will pose problems like memory crunch if a process spawns too many children.

Summary:
The paper attempts to explain the design ideologies and structure of the RC4000 multiprogramming system. It gives a precise definition to terms like programs, internal processes, external processes, documents, peripheral devices and the system nucleus and also explains the functionality of each component. The paper also introduces the method of communication between processes via messages. It attempts to develop a multiprogramming system which is composed of a set of independent, parallel processes which can be extended with new operating systems.

Problem:
Initially the operating systems didn’t allow system designers to change the mode of operation, most of them were fixed to a single mode viz. batch processing, priority scheduling, real-time scheduling or conversational access. Changing the mode would require major effort in its modification or reinstallation of a new operating system. This paper also claims that semaphores are not apt for synchronization between parallel cooperating process in terms of efficiency and safety.

Contribution:
The paper puts forward a new idea that design of a multiprogramming system where the main focus should not be to define functions which solve particular needs but rather to just design a basic system nucleus around which more functionality can be built by extending it.
The primary aim of the system nucleus was to provide a controlled environment for parallel, cooperating processes. Internal processes were defined as execution of interruptible programs and external processes was defined as IO of data. System nucleus was tasked with multiprogramming and communication between these processes as it has complete control of the IO, storage protection, and the interrupt system.
The paper claims that the semaphores technique is not optimal in situations where rogue process may not follow the rules of synchronization. Hence, message buffering within the nucleus was introduced as a method of communication. Primitives were defined for transmitting and receiving messages through the message buffers and queues of each process, which were administered by the system nucleus. This method provided the advantage of efficiency, where processes are unaware of each other's existence, processes can be terminated anytime, queuing of buffers and sending multiple messages at one time.
The system nucleus also contains the code to interpret messages from internal processes and initiates an IO. It also generates an answer with the status of the IO operation.
This design model also introduces the concept the process hierarchy which is essential when parts of the operating system are developed as other programs. At initial loading of the system, it contains just the nucleus and a basic OS which can create and run more child processes. The system nucleus also governs the rules for creation and termination of processes.

Evaluation:
This new design model now enabled new operating systems to be developed as programs without modification of the system nucleus. Also these operating systems can be replaced dynamically to change the mode of operation and programs can be executed under these different operating systems. The paper provides us with numerical data on the performance of the RC4000 System like size of the modules, speed of communication and process creation and removal. It claims that the speed of the system cannot be improved further by addition of more machine instructions but instead by speeding up the hardware. The paper also states that the storage protection system of the RC4000 increased the start and removal times of the processes hence it indicates that this system can perform better on improved machines.
The paper also mentions about the drawback of message buffering where the pool of buffers is limited hence a limit is set to the number of messages that the process can send simultaneously.

Confusions:
What advantage is provided by sending dummy messages when a process is terminated over using a timeout mechanism. The system has a real time clock, can that be used to calculate a timeout if an answer doesn’t arrive? If the system has numerous number of processes which are being terminated, will the nucleus will be burdened with tracking and sending dummy messages?

Summary :
The authors introduce an improved multi programming system paradigm over Dijkstra’s design. The paper also introduces design aspects of how messages are passed for communication between different processes of the system.

Problem :
Semaphores are good to communicate between processes and ensure mutual synchronization. But these are not enough to ensure security in a dynamic environment where processes may be malicious and disrupt the system. So, individual messages which specifically talk about sender and receiver processes are needed for one-on-one communication between two processes.

Contribution :
1. Distinction between internal and external processes where internal means executing one or more interruptible programs in memory and external processes are used to communicate between these internal processes.
2. The authors introduce “system nucleus” - used for multiprogramming and communication between internal and external processes.
3. Primitives for communication between internal processes in addition to external processes. These include send and wait for both request and response.
4. Implementing process hierarchy where the parent has absolute control over the child processes, regarding creation, killing and scheduling them. The overall processes in the system are scheduled in a round robin fashion.

Evaluation :
The paper presents evaluations in terms of execution times of send and wait calls for requests and response. The authors also show that the cumulative time used by the calls are evenly distributed between validity checking, process activation and message buffering. They conclude that if we want to increase the speed of the system we have to make hardware faster. The execution times for creating, starting, stopping and removing process are also measured and because these take long periods to execute they are separated as an anonymous internal process which is interruptible.

What I found confusing :
I found the anonymous process creation confusing. Does multiple creates from multiple processes fork different anonymous processes? Or is it just one process and the other creates have to wait?

1. Summary - The structure of the nucleus of a multiprogramming system is presented in this paper. The responsibilities of the nucleus such as handling process execution, synchronization, I/O support etc are clearly described. This minimalist design philosophy helps provide flexibility to the runtime environment by allowing operating systems to determine the strategies for process scheduling and resource allocation.

2. Problem - The author attempts to improve upon the conventional structure of operating systems, whose design is tightly and inflexibly coupled to certain operating requirements. The intent is to create a bare-bones system, close to the hardware, which provides useful basic primitives that can be easily extended to suit various requirements.

3. Contributions - The main contribution of this paper seems to be the idea that the nucleus or kernel needs to be viewed as an extension of the hardware itself, and an effective base over which an operating system can be built. According to the author, the nucleus should provide primitives for handling the execution of processes and inter-process communication. However, strategies regarding the scheduling of programs and resource allocation should be left for the operating systems to implement as needed. The author also provides clear, concise definitions for various types of processes. They simplify system design by treating both I/O operations and program execution uniformly, as well-defined internal and external processes. The synchronization of parallel processes is supported through message buffering implemented using certain basic primitives. Primitives and rules for handling the creation, control and removal of internal and external processes are also specified clearly. The notion of process hierarchy is an important contribution as it supports the creation of modular operating systems, and allows flexibility in terms of policies pertaining to program scheduling and resource allocation.

4. Evaluation - The paper doesn’t focus on implementation details or performance results. In my opinion, the ideas behind the high-level design philosophy being introduced are more important than the specific implementation itself. However, the paper does provide figures for the execution times of the message-passing primitives as well as the process control primitives. They also analyze the relative percentage of time spent in the various stages of their message passing protocol to demonstrate that their primitives are as highly optimized as physically possible.

5. Confusions - Could you please discuss the program loading and swapping that are not part of the nucleus? Also, the paper states that the operating systems handle the scheduling of processes, but also says that the scheduling happens on a round-robin basis.I am not clear as to how both of these work together.