Vorige                       Titel                            Volgende
______________________________________________________________________


We now come to our solution. We will bring it in three parts. An
outline, then we will discuss the interaction of the different parts
and finally we will look into the way the system stores it in memory.



                       Outline.

There are three basicly different things in the system.

- The programs wich are run
- The files and FIFO's wich hold the data for the programs.
- The directory wich is used to find the programs and files in memory.

Task
When the user instructs the system to run a program the system starts
up a task. A task is any machine-code program wich is being run.
Several tasks can be run at the same time. Also several tasks can use
the same programcode. Thus an editor wich is used by two users is
only stored once in memory. For the user it looks as if all active
tasks are run at the same time. In fact only one task is run at a
time and after a certain time that task is stopped and the next
task started. A task can be active or waiting. It is active if it
isn't waiting and it is waiting when the task can't continue for
one or another reason. (Lack of input for example)
Tasks can have different prioritylevels. Only tasks of the highest
priority level in wich there is an active task are run.
If a task starts up another task this will be it's child. If a task
is aborted or killed all it's children are killed too as the have
lost their meaning.
To communicate with JANOS a task can make systemcalls. This is the
only way for a task to affect anything outside it's own memory.
The only I/O a task has is through an UFI. (UFI's will be discussed
later) A task also has a standard input and a standard output UFI.
These are used for the main I/O and for pipelineing.
For the task the UFI's it has access to are numbered  0,1,2 etc.
For every number there is a read and a write UFI. UFI number 0 make
up the standard in and out UFI.
If a task needs more RAM it can ask for more. In this respect there
are two classes of tasks. Approved tasks wich have been generated
by a compiler or wich have been approved by the systemprogrammer.
These tasks are garanteed not to write outside their allocated memory.
These tasks get memory in small chunks.
Unapproved tasks are all tasks wich have been written by an unapproved
compiler or directly in machinecode. If these tasks need RAM they
get a segment at a time and no other data is stored in that segment.
Thus it won't harm the system if this task crashes.

UFI
UFI is the abbreviation of Universal File. Although an UFI isn't
as universal any more as it was when we invented it we still kept
the name. An UFI wich can be found in the directory is called a file.
UFI's are used for datastorage and for buffering. They also make
the FIFO's necessary for pipelining.
An UFI has a read and a write task. The writetask is the only one
allowed to write into the UFI. The read task is the only one allowed
to read destructively from the UFI. (destructively means that after
the data has been read by the task it is removed from the UFI.)

______________________________________________________________________

Vorige                       Titel                            Volgende