Upgrade to remove ads
Only $35.99/year

CS 4323 Exam 1

Terms in this set (62)

Mention any three main purposes of an operating system (Chapter 1, Lecture 2)
Device manager
Process manager
Memory manager
File manager
Network manager
Describe two design objectives of an operating system
Performance (throughput v. response time)
Throughput is about general purpose OS while response time is about real-time OS

Protection and Isolation to make sure one process doesn't crash another or the entire operating system
Convenience: Think Command line interface v. GUI
What are the main characteristics of Von Neumann architecture?
In Von Neumann architecture, you have a control unit, ALU, main memory, I/O, and buses
What are interrupts and why are they useful? How are interrupts handled?
An interrupt is an event. In a software interrupt, a process is needing to run. Hardware interrupt sends a signal when it needs CPU attention. They are all handled by the operating system
Compare programmed I/O, interrupt-driven I/O, and DMA.
Programmed I/O: Constantly check device
Interrupt-driven: Device's responsibility to alert
DMA: Checks device and alerts CPU when ready
How is polling different in programmed I/O from interrupt-driven I/O?
Polling is the checking of external devices and checking their status. programming I/O is constantly polling. Interrupt driven, the polling is done once.
Compare blocking and non-blocking I/O
Blocking does not return control until the I/O is complete
Blocking is synchronous

Non-blocking checks the status if no output
Non-blocking is asynchronous
Compare multicore and multiprocessor systems. Which one would you prefer and why?
A single processor with more than once processor is multicore
Advantages
The cores are usually integrated into a single circuit (higher cache)
Energy efficient (high performance out of lower energy consumption)
More overhead
Disadvantages
Dual-core only have 60-80% more speed than single-core
Some OS are still using single-core processors

Multiprocessor: Two or more processors in the same system
Advantages
Increased Throughput
More reliable
If one processor fails, you aren't screwed
Needs little complex configurations
Parallel processing is possible (can do more than one process at a time)
Disadvantages
More traffic (Distance between two processes will be greater)
Throughput may be reduced in I/O operations
Since there are more working processors, the coordination between the two is a lot more complex
Give any one advantage and disadvantage of symmetric multiprocessing architecture and asymmetric multiprocessing architecture
Symmetric
Each processor shares memory space among themselves and can alter any element in the memory or can perform any I/O operations
SMPs are costlier and more complex to design

Asymmetric
Each processor can have specialized software and roles, which can be different from one another
Processors will not be able to access all the memory that others have access to, since each processor has private memory
IPC will be more difficult because processing cores are unaware of each other
What is the main goal of a clustered system? (Link to article)
The main goals of a clustered system are to provide better system performance and improve scalability of the system
What do we mean by degree of multiprogramming and why is it often desired to have a high degree of multiprogramming?
It describes the number of processes that a single process can accommodate efficiently
It is often desired to have a high degree of multiprogramming because it results in a lower wait time, so the CPU is more busy and not waiting as much
What do you understand by timesharing and what is its main goal?
The main goal of timesharing is to give multiple users or processes as equal CPU time as possible
After t time, the processor switches to the next process and does this over and over
This gives the impression that only one user is using the timesharing system even though it is being shared among several users
Main goal is to lower response time for processes/users
snip snap snip snap snip snap
Often, it is desired that the operating system would make an efficient use of computing hardware. When is it appropriate for the operating system to forsake this principle and to "waste" resources? Why is such a system really not wasteful?
...
How can you say that having two modes (i.e. kernel mode and user mode) provides rudimentary form of protection in the system?
...
Why is the timer so important for modern general-purpose computing systems?
The timer is used to make sure that one process doesn't use the CPU for too much time or use too much of the system's resources
List any 5 functions of operating systems
YOU BETTER NOT PUNCH MY NIECE
Compare client-server model vs peer-to-peer model. Specify the advantage and disadvantage of each of these models
In client-server model, every client is connected to one central server
This model is designed to support multiple users
List any 4 resources managed by an operating system
Memory space
I/O devices
Files
DONT PUNCH MY NIECE
What is a system call and what is its purpose?
A system call is a mechanism used by processes to request various services from the OS such as CPU time, memory allocation, or other resources
How is a system call different from interrupts?
System calls provide processes with the ability to talk to the OS, while interrupts are what causes the CPU to halt.
What are the different ways to pass parameters during a system call?
Passing to registers in memory, storing parameters in memory and passing the addresses to the registers, pushing parameters onto a stack
Explain with an example how policy is different from mechanism in an operating system.
Policies are rules that need to be followed by processes. Mechanisms are how those rules are met in the processes
Why is it necessary to differentiate policy from mechanism?
They are completely different from each other and having definitions for each of them helps to provide better understanding of their functions.
Policies define the rules, and mechanisms enforce them. It is important to maintain the separation between the part of the code that makes the decisions, and the part of the code that enforces those decisions. This separation allows different applications to use the same mechanisms for different policies.
What is a kernel? Why is it often desired to make the kernel as small as possible?
A kernel is a single program in the operating system which resides in memory that has complete control over everything within the system. It is important to make the kernel as small as possible because if the kernel is too big, there may not be enough memory left for other processes to execute.
What are the advantages and disadvantages of layered OS?
One advantage of a layered OS is the simplicity of its construction. Because of its simple construction, it is easier to debug since there is easy communication between the layers
What is the philosophy behind microkernel OS?
By having basic kernel services such as device drivers, file systems, networking, etc. run in user space, this decreases kernel code size, and improves security, stability, and robustness.
Compare monolithic structure to microkernel structure in the context of an operating system
Monolithic executes faster at the cost of more memory taken. Microkernel has better security and robustness at the cost of poorer performance.
What is the advantage of virtualization? How is bare-metal architecture different from hosted architecture? Compare the two
A server virtualization technology that tailors a standard OS so that it can run multiple user processes at a time on a single machine. This reduces downtime and enhances the resilience of the system. Bare metal architecture is a Type 1
Aaron's notes: bare-metal architecture: the hypervisor (VM monitor) is installed directly on the hardware rather than on top of an underlying OS; applications provide real-time
access or data processing benefit from bare-metal virtualization architecture (type 1: enterprises)
hosted architecture: an OS is installed on the hardware first; then a hypervisor; then applications are installed and run on VMs the same as a physical machine (type 2: like virtual machine)
Discuss the various stages in system boot, starting from power on until you see home screen
Stages:
Power supply: Switching mode power supply
Bootstrapping: (Definition)
BIOS: basic input output system (battery)
CMOS: complementary metal oxide semiconductor
Master Boot Record
Discuss various phases of the process life cycle (Chapter 3, Lecture 2)
There are five phases or states of the process life cycle
When the job is accepted by the system, it is in the start state and placed in the main queue
The process is not yet loaded into main memory, so it isn't an executable process at this point
The process control block (PCB) is created in this state/phase
When the process is ready to run, the Job Scheduler uses some predefined policy to move it from the start state to the ready state
Processes in this state wait for the CPU
This is the state where availability of memory is checked
The jobs that are being processed are now moved from the ready state into the running state by the Process Scheduler using a predefined algorithm
In a single processor system, only one process can be run at a time, which implies that only one process will be in the running state at a time
The process may be moved from the running state back to the ready state due to timeout or some other interrupt occurring
When the process cannot continue further, the Process Scheduler moves the process from the running state to the wait state
This may be because the process needs to wait for some specific resource allocation or completion of some I/O operation
When the requested resources are allocated or the I/O operation is completed, the Process scheduler moves the process from the wait state into the ready state
Finally, the Process Scheduler moves the process from the running state to the terminate state if the process has successfully completed its operation, if the process exceeds its time limit (timer), or some error occurs in the process, causing the OS to terminate the process prematurely
How will a process become a zombie or orphan? (Chapter 3, Lecture 6)
A process becomes a zombie process when it is terminated for any reason and its resources are collected back and freed for another process while it still maintains an entry on the process table
Too many zombie processes cause memory to be filled, resulting in other processes not being able to run
A process becomes an orphan process when its parent process is terminated before itself, resulting in the child process (in this case, now an orphan process) being adopted by the INIT process, as arranged by the kernel
The INIT process will eventually invoke a wait system call so that these orphan processes can die
What can be the issue with zombie processes and how can you avoid that? (Chapter 3, Lecture 6)
Zombie processes maintain an entry in the process table, and having too many will fill up memory, preventing other processes from running
This can be avoided by having parent processes invoke the wait system call
When would you create an orphan process? (Chapter 3, Lecture 6)
Unsure of what exactly this question is asking
An orphan process is created when a parent process does not wait for its child process to terminate and terminates before the child process
You would want to create an orphan process if you want to create a daemon process, some long-term process that is intended to run in the background
Mention any five information maintained in process control block (Chapter 3, Lecture 2)
Process ID, or PID, which is a unique identifier associated with each process
Process state, to specify the current state of the process
Process privileges, which specify whether or not a process has permission to access system resources
Process priority level, to specify the priority level of some process relative to other processes
Pointer to point to the parent process of the given process
Program counter to point to the address of the next instruction in the program to execute
Context data, which is present in the register in the processor while the process is executing
Memory management information to keep track of the information about the page table, memory limits, and segment table (depending on the memory being used by OS)
I/O status information to indicate a list of I/O devices allocated to the process, outstanding I/O requests, list of files in use by the process, etc.
Accounting information, such as the amount of processor time and other resources used by the process, which is particularly useful for enterprise environments
Describe different types of queues that a process can be in (Chapter 3, Lecture 3)
There are three different queues that a process can be in:
The ready queue is where interactive processes reside when they are accepted.
When a process uses the CPU for an amount of time greater than a certain limit, the process is forced to give up
The job queue is where batch processes must be placed before they can be accepted by the system. After they are accepted, they are moved into the ready queue
When a running process needs to perform I/O operations, it gets moved into the I/O queue
After the process completes its I/O operations, it gets moved back into the ready queue to wait its turn to access the CPU
Why is it necessary that short-term schedulers be very fast while you can have a bit slow long-term scheduler? (not covered in lectures/can't find info)
Short term scheduler CPU scheduler, takes process from ready queue and determines which process is suitable for processing
Deals with priority
A short term scheduler needs to be fast because it is moving processes in and out of the running state
Long term scheduler regulates programs which are selected for the system for processing
How and why do medium-term schedulers decrease the degree of multiprogramming? (not covered in lectures/can't find info)
Part of swapping, so it reduces the process from the memory
Decreases degree of multiprogramming because it makes the decision to let the job on or sideline it
Instead of having more important processes running at the same time, it's prioritizing processes of higher quality
Degree of multiprogramming describes the max number of processes that a single processor can accommodate efficiently
Mention three possible scenarios for context switching (Chapter 3, Lecture 2 [Briefly], but scenarios found online)
Multitasking
Handling interrupts
Switching between user mode and kernel mode
Under what scenario does a parent process abort its child process? Explain with a suitable example (Chapter 3, Lecture 7)
A parent process will abort its child process if the child process has used too much of the resources allocated by the parent process, the task assigned to the child process is no longer required, or the parent process is being terminated as well
example here
Give one scenario when you would prefer to use message passing as a means of IPC. Explain why (Chapter 3, Lecture 8)
If a process acts as a producer in the producer-consumer scenario and another acts as the consumer, message passing is a useful method for IPC. To expand on this, message passing is extremely useful in a scenario where one process writes to another, but not the other way around.
This ensures that data transfer is unidirectional
Workers cannot modify others' data
Give one scenario when you would prefer to use memory sharing as a means of IPC. Explain why? (Chapter 3, Lecture 8)
At times, a process may need to send and receive information from other processes efficiently. When using shared memory, any process that knows the memory address of the shared memory can access and modify it.
When multiple process need similar access to the same data and need to add or write over data, memory sharing is a useful method for IPC
How can you resolve the issue that could occur if the mailbox is used to communicate between three processes P1, P2, and P3, given one message is kept in the mailbox by the sender? (???)
Have either P1, P2, or P3 receive the message since a message can only be received by one process. The message could then be sent to the other processes if needed
Only one process can execute a receive at a time
Differentiate between blocking send and non-blocking send in message passing IPC. (Link to thread. I think send/receive is similar)
Blocking means that execution of your code (in that thread) will stop for the duration of the call. Essentially, the function call will not return until the blocking operation is complete.
A blocking read will wait until there is data available (or a timeout, if any, expires), and then returns from the function call. A non-blocking read will (or at least should) always return immediately, but it might not return any data, if none is available at the moment.
A blocking send can not send anymore messages until that message is received
Non-blocking send can send additional messages without waiting for the message to be received
Differentiate between blocking receive and non-blocking receive in message passing IPC (Link to thread)
Blocking means that execution of your code (in that thread) will stop for the duration of the call. Essentially, the function call will not return until the blocking operation is complete.
A blocking read will wait until there is data available (or a timeout, if any, expires), and then returns from the function call. A non-blocking read will (or at least should) always return immediately, but it might not return any data, if none is available at the moment.
The receiver can't receive until there is a message is available for blocking
For the producer-consumer problem, explain the scenario with zero buffer capacity, bounded buffer capacity, and unbounded buffer capacity (Chapter 3, Lecture 1 for producer-consumer problem, link talking about IPCs and different buffer capacities briefly)
The producer-consumer problem is a scenario in which a producer produces items and puts them in storage while the consumer takes items from the same storage. It is used to explain cooperative processes and data sharing between the two
In the scenario with zero buffer capacity, the producer must wait for the consumer to take each item from the storage before putting a new item in storage.
Zero buffer capacity is most dependent on the consumer since the producer must halt production of items to put in storage. The producer must communicate explicitly with the consumer in this scenario.
In the scenario with bounded buffer capacity, there is a finite number of items that the producer can put in storage before the storage is filled up
Once this happens, the producer must wait for the consumer to take an item from the storage, like in zero buffer capacity. However, unlike zero buffer capacity, the producer in bounded buffer capacity does not need to wait for the consumer to take each item and can instead put multiple items in storage, until the storage is completely filled.
In the scenario with unbounded buffer capacity, there is (seemingly) no limit on the number of items that the producer can put in storage before the storage is filled up
In this scenario, the producer can constantly put items into storage with no restrictions on the number of items that can be stored at a time.
In all three of these scenarios, the consumer will need to wait for the producer if there are no items in storage, just like how the producer may need to wait for the consumer to take items out of storage in bounded and zero buffer capacity scenarios. In IPC, "storage" can refer to either shared memory or message passing, depending on the context.
A quick example is the message queues in Assignment01 had a bounded buffer capacity, set by the kernel, which was 10.
What is the difference between connection-oriented socket and connectionless socket communication? (Chapter 3, Lecture 12)
Connection-Oriented (TCP):
The server needs to assign an address and port to the socket that the client will be requesting for the connection
After this, the server needs to listen to this port for any incoming requests from the client
At this point, the client sends the request
Once the server receives the request, etc., the client closes and terminates its socket
Connectionless (UDP):
The client does not need to establish a connection with the server and instead sends a datagram to the server
Similarly, the server does not accept the connection from the client and instead just waits until the data arrives from some client by calling recfrom()
Once the client is done, it simply closes the socket while the server waits for another request from any client
Analogy:
Two houses are on opposite sides of a river and one needs to send a message/letter to the other, but there isn't a way to cross the river yet
Two different approaches:
Build a bridge over the river (connection-oriented)
Send a pigeon (connectionless)
Sending a pigeon will be much quicker, but who knows what could happen after you send it. The letter could fall into the water, the pigeon could fly the wrong way, etc. Only one house needs to send the pigeon while the other house will receive it without having to do anything.
Building a bridge will take longer, but once it's built, there will be a guarantee that message/letter makes it to the other house. Both houses (server and client) need to contribute to the building as well.
What is the advantage of using RPC (remote procedure call) in the distributed network? (Chapter 3, Lecture 12)
The main advantage of RPC is that it hides the details of communication from the programmers so that when the client needs to invoke a remote procedure, it invokes a stub by passing all of the required parameters to the stubs
Differentiate between ordinary pipes and named pipes (Chapter 3, Lecture 10)
Ordinary pipe is regular unnamed anonymous pipe, a special kind of file that you can read and write to. Named Pipe, FIFO, exact same as pipe except, you give it a name
Give any one programming example in which multithreading does not provide better performance than a single-threaded solution
A web server that services each request in a separate thread
Calculate the speedup in the performance of the system by adding 4 additional cores. Assume that the programs it is running has 45% parallel portion (Chapter 4, Lecture 3)
Use Amdahl's Law (1/S+((1-S)/N))
Consider a system A has 4 processing cores and a system B has 8 processing cores. Assume that the program X has 80% of the code can run in parallel. How much is the improvement in the speedup by migrating the program from system A to system B? (Chapter 4, Lecture 3)
Apply Amdahl's Law, find the ratio of the difference between system A and system B
Specify any 4 programming challenges when using threads in a multicore environment. (Chapter 4, Lecture 3)
Identify the task that can be divided into separate concurrent tasks so that each of these tasks can be carried in a different processor at the same time
Find balance of work in each task
We want all processors to be equally busy and we do not want an unequal distribution of work among the processor
Since each task is going to be running on a separate processor, when redesigning code, you have to consider the distribution of overall work on each task
Splitting of data
Each running task will be accessing data or even modifying it
To make these independent tasks run efficiently, you have to divide data among those tasks as well so that they don't interfere with each other
Examine the tasks that are dependent on one another
Dependent tasks mean that task A may modify the value of one variable and another task, task B, needs to access this modified variable
If this the case, then task B cannot be executed before task A
Therefore, there should be some order of execution of tasks and that should be maintained while redesigning code
Ensure the program running in parallel on multiple cores is correct
Debugging errors in parallel programming is not as straightforward as in sequential programming
What would happen if there is data dependency between two tasks running by two different threads in a process? (Chapter 4, Lecture 3)
Dependent tasks mean that task A may modify the value of one variable and another task, task B, needs to access this modified variable
If this the case, then task B cannot be executed before task A
Therefore, there should be some order of execution of tasks and that should be maintained while redesigning code
How is data parallelism different from task parallelism? (Chapter 4, Lecture 2)
In data parallelism, the same task runs on different data in parallel
Each task produces different results that can be combined to get a final result
Example: Performing addition on a subset of data can be performed in parallel and later summed up for the final sum
In task parallelism, you have different tasks running in parallel, either on the same or different data
Like data parallelism, tasks produce results which can be combined to get a final result
If the different tasks are running in parallel on different data, then it is called hybrid parallelism
Example: Performing addition on a subset of data and average all of the numbers after
What are two differences between user-level threads and kernel-level threads? Under what circumstances is one type better than the other? (Chapter 4, Lecture 4)
For user-level threads, it is implemented by the user
Easy
No hardware support
Implementation by OS
More complicated
Hardware support
POSIX is much better for user-level, Solaris is better for kernel-level
What are the advantages and disadvantages of one-to-one model in threads? (Chapter 4, Lecture 5)
Advantages
Threads can operate in parallel on different processors in a multiprocessor system
The block of one user-level thread does not block the entire thread of the process because each user-level thread is mapped to different kernel-level threads
This is the most important requirement for real-time applications
Disadvantages
There is a lot of overhead due to switching between threads since the kernel is heavily involved in one-to-one association
Since there is one-to-one mapping between the user-level threads and kernel-level threads, there is a limit to the number of user-level threads that can be created
What are the advantages and disadvantages of many-to-many model in threads? (Chapter 4, Lecture 5)
Advantages
Parallelism between user-level threads since they can be mapped to different kernel-level threads
Low overhead of switching between user-level threads that are scheduled on the same kernel-level threads
Since there is no one-to-one mapping between user-level threads and kernel-level threads, there is no restriction on the number of user-level threads that can be created
Disadvantages
Implementation is complex
In the case of a two-level model of thread relationship between user threads and kernel thread. What is the significance of bounding user thread to a kernel thread in 1:1 relation? (Chapter 4, Lecture 5)
By bounding user threads to kernel threads in a one-to-one relation, the threads are particularly useful for real-time applications which require immediate execution
Few user level threads have one-to-one mapping with kernel-threads in this scenario
What do you mean by implicit threading? Why is its significance in modern programming?
It's mainly the use of libraries or other language support to hide the management of threads
How is the concept of thread pools make the program run faster? What are the other advantages it can offer to the system? (Chapter 4, Lecture 7)
The main idea of thread pools is that there are a number of threads already created in the system at the process startup, which are placed in a pool
When the server receives a request from the client, it uses a thread from the pool to serve the client. This makes the program run faster because there is no need to create and delete threads for each client
Another advantage of thread pools is to provide concurrency in the system.
If for each request, a new thread is created without any limit, it will exhaust system resources
Highlight any three issues when dealing with multithreading applications?
Increased complexity
Complications due to concurrency
Difficult to identify errors
Testing complications
Unpredictable results
Complications for porting existing code
What is the goal of scheduler activation and how does it achieve that?
The kernel provides an application with a set of virtual process
The application can schedule user threads on an available virtual processor
The kernel must inform an application of certain events
This is an upcall
Threads are scheduled by these upcall handlers
A virtual processor is required for the upcall handler
Sets found in the same folder