Computer Operating
Systems & Design is a five-week course that I have taken at Ashford
University that looked at Operating systems overall role in a computer system (Silberschata,
Galvin, & Gagne, 2014). The computer
operating system creates an environment for the user to interact with programs in
a computer system and to solve problem for that computer system. The user can interact with the programs which
interact with the operating system that interacts with the hardware of the
computer. The computer has a hardware
component called the CPU which is connected through a device controller that offers
contact to shared memory.
The operating system has several
operations that keep it functional. It
provides functions to start the computer.
It configures different devices, manages data and programs, provides a
user interface and manages memory. The concept
map photo below shows how the operating system interacts with the user, the
system and application programs and the computer hardware.
Computer programs have a
process that is accomplished by single or multiple threads ("Process
(computing)", 2020). “A thread is a
basic unit of CPU utilization; it comprises a thread ID, a program counter, a
register set, and a stack. It shares
with other threads belonging to the same process its code section, data
section, and other operating-system resources such as open files and signals” (Silberschatz et al., 2014, p. 163). A process begins with a state which is what
is currently happening in the process. The
operating system has five states: new, running, waiting, ready and
terminated. New is when the process is
being created. Running is when the
discussions are being executed. Waiting
is when the process is waiting for a event to happen. Ready is when the process is ready and
waiting to be assigned to a processor.
And terminated is the completion of the process’s execution (Silberschatz
et al., 2014, p. 107). The picture below
shows on the right how the process states happen. The concept map below also shows on the left
how the process control block is connected to thread execution. The process control blocks are where the code
data and files interact with the registers and stack. The process is a program that achieves thread
execution. The process must be executed
by a single-thread or multiple threads.
In a single thread only performs one task at a time. The multi-thread execution on the left lets
many tasks to be performed at once.
Modern computers have been programmed to use multi-threaded execution to
an advantage. Even though single-threaded
execution is still used for some programs.
Memory is essential and
the central of operations of all computers this day and age. The CPU fetches instructions from the memory
according to the value of the program counter.
The memory unit only sees a stream of addresses + read requests, or
addresses + data and write requests. There
is memory directly built into the hardware (the processor). Main memory and register are the only storage
in which the CPU may access directly.
Each process needs a separate memory space and will search for open
address space accordingly (Silberschatz et al., 2014). As
you can see in the main memory node of my concept map, the user space, this is
where the CPU hardware compares every address generated with the
registers. The operating system block
and the user mode block are separated because any attempt by a program in user
mode to access operating system memory or other users’ memory results in a
fatal error, which helps to keep the code or data structures separate. (Silberschatz
et al., 2014).
The CPU generates an
address (logical address) which loads into the physical address. The logical and physical addresses can
generate identical addresses. During
execution-time address binding scheme, the addresses can differ. Logical addresses can also be referred to as
virtual addresses. The picture below shows
how a process can be swapped out of memory when it is not being executed and
back when it is ready to execute it.
This shows how multiprogramming can be used to an advantage within the
memory management system. (Silberschatz et al., 2014).
Virtual Memory can separate logical memory from physical memory. This lets a large amount of memory to be
provided when there is only a smaller amount of physical memory available. The use of demand paging by virtual memory only
brings in a page when the page is referenced.
This allows for a process to run when the memory image is not in the
main memory (Silberschatz et al., 2014).
Having access to saved material is one of them most
important tools for users. The file
system is where all of this happens. The
file system contains two separate parts, the collection of files and a
directory structure. The file system stores material on storage
devices like hard disk, magnetic disk and optical disks. Physical storage devices store the files for
later use, which are mapped by the operating system to these physical
devices. Being nonvolatile allows these
physical devices to store the data and allows it to be accessed after the
computer is shut down, unlike RAM (random access memory) which cannot (Silberschatz
et al., 2014).
Inside the operating
system, there is file system management which keeps the files and data that is
saved by the user in order. The
operating systems order of these files is called a directory which groups these
files together. Operating systems use
multiple schemes of logical structure of the directory in keeping the files
together (Silberschatz et al., 2014). In
the concept map below I was able to display the differences in the logical
structures of a directory. These types
of directory structures are single-level directory, two-level directory,
acyclic directory and general graph structure.
I put emphasis on single-level directory, two-level directory and
acyclic graph directory.
Single-level directory
has all the files in the same directory.
There is not much wiggle room, when the file numbers increase or there
is more than one user on the system. The
single directory only allows files in the directory to have different
names. In the concept map below, the
directory has different names and a single file in each directory. Two-level directory allows for each user to
have their own directory. These files
are together in that directory and each directory has a single file. The user may be able to have the same name
for their file directory. In the concept
map below, I wanted to emphasize acyclic-graph structure because of its ability
for different directories to share files and sub-directories with other
directories. It is good to know that
shared file or directory is not the same as two copies of a file (Silberschatz
et al., 2014).
Most
of what people do on their operating systems is important to them. Having
a model and ways to protect and secure the operating system need to be in
place. To protect a computer system an access matrix is a general model
commonly used. “The access matrix provides an appropriate mechanism for
defining and implementing strict control for both static and dynamic
association between processes and domains” (Silberschatz et al., 2014, pg.
609). In my concept map I have a node that shows an access matrix.
Objects are the columns and domains are the rows. If the row and the
column have an access right intersected, then there is that specific access
right to the domain. This lets us see what access right is available for
different policies. I added a node for the capabilities which is like the
access matrix.
The concept map below has a node that represents a MULTICS system. The
MULTICs system organizes the protection domains hierarchically in a right type
structure (Silberschatz et al., 2014). “MULTICS has a segmented address
space; each segment is a file, and each segment is associated with one of the
rings. A segment description includes an entry that identifies the ring
number” (Silberschatz et al., 2014, pg. 606).
With my concept map I made a hierarchy of the four levels security measures and
ways to protect that level of security. The text made a good point when
it states, “Security at the first two levels must be maintained if
operating-system is to be ensured” (Silberschatz et al., 2014, pg. 636).
This gives a good look at how protecting the operating system before it can be
touch by a human is important. It also shows that only giving a user
access to parts of the operating system that they must have, lets way to less
mistakes. In my concept map, I also list of attacks that can be attempted
to break security.
Computer
Operating System Theory & Design has taught me many things that I can take
into my future career. I am studying for
a degree in Computer Software Technology in which I will like to become a
Software Engineer. Understanding how the
operating system works will let me develop software for operating systems
better. It will give me a understanding
of how the operating system works beneath the board of the software that is
created for it. The subjects of single-
and multi-threaded processes will help me begin to know what type of process
works best for each task. I will take
what I learned in this course to be the best software developer that I can be.
References
Silberschatz,
A., Galvin, P., & Gagne, G. (2014). Operating System Concepts
Essentials, 2nd Edition. John Wiley & Sons.
No comments:
Post a Comment