Section 1
Preview this deck
mutual exclusion
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (76)
Section 1
(50 cards)
mutual exclusion
only one process at a time can use a resource - part of a semaphore is ensured by the flag being set to either true or false and only allowing one job to run while true and one job to run while false. Important to check flags in order to see what happens
If you were going to allow the disabling of interrupts by the user, how would this mess up the synchronization primitives?
If the user could disable interrupts it would then be able to disable the timer interrupt and this can prevent switching from happening and this would mean that a process could run without letting other processes get a chance to execute.
progress
- step in the three things needed in a semaphore - you have to be able to accomplish things is ensured because both jobs cannot be in there busy wait at the same time. So, one is always making progress while the other is in its busy wait and vice versa.
Concurrency vs Parallelism
It is possible to have concurrency but not parallelism. Concurrency means that where there are two different tasks or threads are working together in an overlapped period of time, it does not mean they ran at the same time. Parallelism is when two tasks start the execution at the same time and they run simultaneously. They are forms of an operating system. But in order to complete a task the methods need to finish the task. The priority is to select which form is better and it depends on the requirement of the system and the operating system coding had created.
interrupts
An interrupt differs from a trap because a interrupt signals the CPU when there is a completion of a task, but a trap is triggered by the user to make a function happen.
medium term cpu scheduler
A Medium-term scheduler is used with time-sharing systems. It is used to remove partially running programs from memory and bring them back later to continue where they were stopped.
Non-preemptive scheduling
CPU scheduling that occurs when the currently executing process gives up the CPU voluntarily
Dining Philosophers Problem
simple representation of the need to allocate several resources among several processes in a deadlock-free and starvation-free manner.
firmware
it is the permanent software that is programed into the ROM. It also provides low level control of the device's specific hardware.
starvation
- is the program letting other things sitting in the que or stoping people from doing things
kernel
- it is a computer program that is the main part of the computers operating system. It is the one programing that is running all the time on the computer. It's one of the first programs loaded when the startup happens
cpu bound
means that a program is held up by the cpu. CPU bound would go faster if the cpu was faster
I/O bound
means that the program is held up by I/O like reading a disk. The I/O would go faster if the subsystem was faster
multiprocessing
These systems are growing in the use and importance. They could be known as parallel systems, and tightly-couples' systems. They have 3 advantages: increased throughput, economy of sale, increased reliability. There are two types, Asymmetric and Symmetric. Asymmetric is each processer is assigned a specific task, and symmetric is each processer performs all tasks. A dynamic assignment, it has multiple processers which is hardware.
some kind of restarting
The first action would be stopping the process and restoring the CPU's state. Then you would retrieve the details of the next process from memory. Then you return to the place that is indicated by the program in order to continue that specific process. Saves context of the current process and then loads the new process
embedded computer system
- These devices are found everywhere. It is a controller programed program that uses real time systems to actively respond to things happening. Like cars, planes or trains. Some systems have hundreds of computers in them, they are embedded in and they can have hardware and mechanical parts.
Shortest Job Next
scheduling policy that selects for execution the waiting process with the smallest execution time. ____ is a non-preemptive algorithm
find wait time
when the job arrived to when the job finished
devices that cant be shared
Three types of devices that cannot be shared is a speaker, keyboard and mouse.
short term cpu scheduler
is the CPU scheduler. It will select a process that is ready to be executed and then gives it to the CPU.
find average turn around time
all turn arounds divided by number of jobs
atomic operation
An operation that is uninterruptible
mutex
A mutex is meant to be taken and released, always in that order, by each task that uses the shared resource it protects.
batch system
the batch operating system does not require you to interact with the computer directly. Someone will make punch cards and give to a computer operator to run; similar tasks are batched together to be run at the same time. There is lack of interaction between a user and the job, CPU is often idle, and it's hard to provide priority. There is a strict time constraint on them, they will normally run them overnight when the computer is less active.
real time system
a real time system is something that is constantly giving you information and updating, like a heart monitor. This system reacts to real time things happening, it doesn't wait for something to happen, its constantly updating. Embedded systems almost always use real time systems
cloud computing
cloud computing is a type of computing that will deliver computing, storage and application as a service across the network. It can be considered an extension of virtualization because it uses it as a base of functionality. There's public (available to everyone), private (only available to certain people like employees), and hybrid (includes both public and private ideas) clouds. It is done remotely and you can tap into things remotely.
preemptive scheduling
CPU scheduling that occurs when the operating system decides to favor another process, preempting the currently executing process and kicking it out
shortest remaining time
A scheduling algorithm that deals with each user or task based on a calculating an estimated time remaining to complete, is preemptive will kick people out
to find turn around time
how long it takes to finish based on when it arrives
p nd v
p subtracts and v adds
first come first served (FCFS)
a priority sequencing rule that specifies that the job or customer arriving at the workstation first has the highest priority non premptive
processes vs threads
The primary difference is that threads within the same process run in a shared memory space, while processes run in separate memory spaces. Threads are not independent of one another like processes are, and as a result threads share with other threads their code section, data section, and OS resources (like open files and signals). But, like process, a thread has its own program counter (PC), register set, and stack space.
find weighted turn around time
turnaround time / cpu time
deadlock
when a resource wants on resources who wants a different resources and they cant use each other
thread
A thread is a path of execution within a process. A process can contain multiple threads.
bounded waiting
is preserved because even if one process gets sent back to the waiting que it will become available to be serviced again and will keep happening until it is finished what it needs to have done.
wait command
Controls how much time is allocated for each operation.
excelp
- overwrites the space it was using and then it doesn't print it, it overrides anything that is happening
multiprogramming
The technique of keeping multiple programs in main memory at the same time, competing for the CPU
Process Synchronization
(1) the need for algorithms to resolve conflicts between processors in a multiprocessing environment; or (2) the need to ensure that events occur in the proper order even if they are carried out by several processes.
orphan process
An Orphan process is a process whose parent process no longer exists. This parent process terminated before the child process terminated. This means that the child process becomes and orphan process.
how to find multiprogramming
Time remain * jobs = how many ticks needed + then add it to the last time of the last job
Round Robin Scheduling
A PREEMPTIVE scheduling designed for Time Sharing Systems The Ready Queue is treated as a circular queue A small execution time interval is defined as the Time Quantum, or TIME SLICE - When the executing interval of a process reaches the time quantum, a SYSTEM TIMER will cause the OS to interrupt the process The OS carries out a CONTEXT SWITCH to the next selected process from the ready queue. Length of the Time Quantum Time quantum that is too short will generate many context switching and results in lower CPU efficiency. Time quantum too long may result in poor performance time. preemptive
fork
splits into child and parent each has its own copy but what you do to the parent doesn't affect the child and vice versa
zombie process
A zombie process is left over bits of a dead process that was not deleted or cleaned correctly. You cannot kill this process again because it is already dead. When a parent process is not programmed correctly to delete the zombie process when it dies immediately, that's when it is able to hang around.
Multiprogramming
multiprogramming will increase the utilization of the CPU. It will organize jobs so that the CPU will always be doing something. Its more efficient because its doing things all the time.
multithreading
allows multiple commands, or threads to run simultaneously
zombie process again
When a process is stopped, it shifts to a zombie state and remains that way until the parent process calls wait(). If a parent does not use wait(), the child process remains a zombie until the parent process is terminated. Once the parent process is terminated then the Init process becomes the new parent of the zombie process. The init process will call wait() often which releases the zombie process. If the parent did not initiate the wait call then the init has to do it for the zombie program, and then once it terminates the parent process did not have a wait then the process that just terminated becomes the zombie until the init ocmes along If the parent is allvie and the child dies then the init grab it and clean it up
signal command
signals when to let something in or move on
long term cpu scheduler
A Long-term scheduler is a job scheduler. It will determine the jobs brought to the memory to be processed. One of the biggest differences is the frequency of the execution. Long term would be used less often then short term and medium term for example
Section 2
(26 cards)