UNR CS 446 Midterm
What are the two main roles/purposes of an OS?
1. Manage resources (isolation, scheduling, limit) 2. Provide a standardized interface for common functionalities so resources can be accessed easily. The OS abstracts hardware and provides a unified interface that are easy to predict.
What are the 6 major goals of every operating system?
1. Virtualize physical resources 2. Allow processes to run concurrently 3. Store files persistently 4. Use abstraction to make the system easy to use 5. Provide high performance by minimizing overhead 6. Protect applications and isolate processes
What is the difference between a user thread and a kernel thread?
A ________ ________ is created and managed by a user-level threading library, while a ________ ________ is created and managed by the operating system kernel. ________ ________ are typically faster to create and switch between, but they may suffer from poor performance due to the lack of direct support from the kernel. ________ ________ , on the other hand, are slower to create and switch between, but they benefit from the scheduling and synchronization mechanisms provided by the kernel.
What is a critical region? How is it related to process scheduling?
A critical region is a section of code where shared resources are accessed and modified by multiple threads. It is critical because if two or more threads access and modify the same shared resource at the same time, the results may be unpredictable or incorrect. Process scheduling is related to critical regions because a process scheduler must ensure that two threads do not access the same critical region at the same time, or else there could be data corruption or other issues.
What is a page table? How is it used to manage memory?
A page table is a data structure used by the operating system to map virtual addresses used by the CPU to physical addresses used by the memory subsystem. It contains entries that associate each virtual address with a physical address, as well as information about the state of the corresponding page (e.g., whether it is present in physical memory or needs to be fetched from disk). The page table is used by the MMU to translate virtual addresses into physical addresses.
Which states can be transitioned to from a specific state?
A process can transition from the ready state to the running state when it is selected by the scheduler. It can transition from the running state to either the blocked or ready state, depending on whether it needs to wait for some event or can continue executing. It can transition from the blocked state to the ready state when the event it was waiting for occurs.
What is the difference between a process and thread?
A process is an instance of a program that is being executed by the operating system, while a thread is a lightweight process that shares the same memory space as the parent process. A process can have multiple threads, and each thread can execute concurrently and independently of the other threads within the same process. Threads share the same process state and resources, while processes have their own independent memory and resource allocation.
What is a process? What are the three process states, and how do they communicate with each other?
A process is an instance of a program that is being executed by the operating system. It includes the program's code, data, and resources, as well as information about its state and execution context. The three process states are: Running: The process is currently using the CPU. Blocked: The process is waiting for some event, such as I/O completion or a signal. Ready: The process is waiting to be assigned to a processor. Processes communicate with each other through inter-process communication (IPC), which can be either through shared memory or message passing. In shared memory, multiple processes can access the same memory region, while message passing allows processes to exchange information by sending and receiving messages.
How are a thread and a process different? What do threads have shared access to, and what is not shared between threads?
A process is an instance of a program that is executing, whereas a thread is a lightweight unit of execution within a process. threads have shared access to the process's memory space, which includes global variables and shared data structures. However, each thread has its own stack and registers.
What are the process states?
A process state is defined as anything that executing instructions can affect or be affected by. The process states are: New: The process is being created. Ready: The process is waiting to be assigned to a processor. Running: The process is being executed by a processor. Blocked: The process is waiting for some event to occur (such as I/O completion or a signal). Terminated: The process has finished executing.
Compare and contrast a process and a program.
A program is a set of instructions and data that are stored on disk, whereas a process is an instance of a program that is currently executing in memory. A program can be seen as a passive entity, while a process is an active entity that is scheduled for execution by the operating system. A program can be loaded into memory multiple times, resulting in multiple processes executing the same program simultaneously. Each process has its own memory space, program counter, registers, and other relevant data, which makes it independent of other processes executing the same program.
What is the difference between a process and a program?
A program is a set of instructions that can be executed by a computer, while a process is an instance of a program that is being executed by the operating system.
What is a program, and how is it related to a process?
A program is a set of instructions that can be executed by the operating system. A process is an instance of a program that is being executed by the operating system. When a program is loaded into memory and begins execution, it becomes a process.
How many processes can be executed at once on a single CPU?
A single CPU core can handle one process or thread at a time
What is a trap instruction, and why is it useful when a user needs to escalate privileges?
A trap instruction is a software interrupt that is triggered by a program when it needs to perform a privileged operation, such as accessing hardware or performing a system call. When the trap instruction is executed, the CPU switches to kernel mode, and the kernel takes control of the system. The kernel then performs the requested operation on behalf of the program and returns control to the program. Trap instructions are useful when a user needs to escalate privileges because they allow a program running in user mode to request the kernel to perform operations that require elevated privileges. By using trap instructions, the program can remain in user mode and does not need to be executed with elevated privileges, which can help improve the security of the system.
What is concurrency?
Ability of an operating system to handle multiple tasks or processes at the same time.
What is persistence?
Ability of an operating system to store data and settings between system restarts.
What is persistence's role in ease of use?
Allows users to resume their work where they left off without having to start from scratch. Information is readily available for user without a process having to be actively running.
What is caching?
Caching is a technique used to speed up access to frequently used data. It involves storing a copy of the data in a small, fast memory (cache) that can be accessed more quickly than the original, larger memory (such as RAM or disk). When data is requested, the cache is checked first, and if the data is found, it is returned from the cache. This can significantly reduce access times and improve overall system performance.
When provided with a table of process names, arrival times, and execution times, you should be able to calculate the turnaround time and the wait time when an algorithm is specified, as well as the order of process execution.
Calculating turnaround time and wait time for a set of processes is a common task in operating systems. Turnaround time is the amount of time it takes for a process to complete execution, while wait time is the amount of time a process spends waiting in the ready queue before it is assigned to a CPU for execution. To calculate the turnaround time, you need to subtract the arrival time of the process from the time when the process completes execution. To calculate the wait time, you need to subtract the execution time of the process from its turnaround time. Different scheduling algorithms can produce different turnaround times and wait times for a set of processes. Common scheduling algorithms include First-Come-First-Serve (FCFS), Shortest-Job-First (SJF), Round-Robin (RR), and Priority scheduling.
What is the producer consumer problem, and where is it useful in the CS world?
Classic synchronization problem where there are two types of threads - producers and consumers - that share a common buffer. Producers add items to the buffer, while consumers remove items from the buffer. The challenge is to ensure that producers and consumers do not access the buffer at the same time and that the buffer does not overflow or underflow. This problem is useful in many areas of computer science, such as operating systems, databases, and network programming.
What is the tradeoff between creating processes in the user space, versus creating them in kernel space? Consider both time and space.
Creating processes in user space can be faster and requires less overhead than creating them in kernel space because user space processes do not require the intervention of the operating system. However, user space processes have limited access to system resources and may not be as secure as kernel space processes. Creating processes in kernel space allows for greater control and access to system resources but is more expensive in terms of time and overhead.
How can deadlock be managed? How can deadlock be recovered from?
Deadlock can be managed by using techniques such as resource ordering, timeouts, and detection algorithms. Deadlock can be recovered from by aborting one or more threads involved in the deadlock or by releasing the resources being held.
What is efficiency as it pertains to multiprogramming?
Efficiency in the context of multiprogramming refers to the ability of a computer system to effectively utilize its resources to execute multiple processes concurrently. The goal of multiprogramming is to maximize the system's throughput, which is defined as the number of processes completed per unit time. Efficiency can be measured in terms of the utilization of the CPU, memory, and I/O devices. If the CPU is constantly idle due to lack of processes or waiting for I/O operations to complete, the system is considered inefficient. Similarly, if the memory is not being utilized to its full potential, the system may experience unnecessary page faults or thrashing, resulting in a decrease in performance. Efficiency can be improved by employing techniques such as process scheduling, memory management, and I/O scheduling. Effective process scheduling can ensure that the CPU is always utilized and processes are executed in an optimal manner. Memory management techniques such as paging and segmentation can help to reduce unnecessary page faults and optimize memory usage. Proper I/O scheduling can ensure that I/O devices are not idle, waiting for processes to complete their operations. In summary, efficiency in multiprogramming refers to the ability of a system to effectively utilize its resources to execute multiple processes concurrently, thereby maximizing throughput and performance.
What does every process have to define before execution?
Every process has to define its address space, which is the memory range that the process can access and use.
True or False: init is always the last process to be run at boot.
False. It is the first process to be run when a Linux system boots up, and it is responsible for starting all other processes. It is not the last process to be run, but rather the first.
Compare and contrast internal and external fragmentation, and provide an example.
Fragmentation refers to the phenomenon where memory is allocated into small, non-contiguous pieces, which can lead to inefficient use of memory. Internal fragmentation occurs when a process is allocated more memory than it needs, leading to wasted space within the allocated block. External fragmentation occurs when there is enough free memory to satisfy a memory request, but the memory is divided into small, non-contiguous pieces, making it unusable. An example of external fragmentation is when a process requests a large block of memory, but the available memory is divided into many small free blocks, none of which are large enough to satisfy the request.
What is the difference between a parent and child process? If you are provided with a description of process relationships, you should be able to construct a process tree.
In a multi-process operating system, a parent process creates a child process by duplicating itself. The child process inherits the parent's resources, such as memory space and file descriptors, and runs independently of the parent. The parent process can communicate with the child process through interprocess communication mechanisms, such as pipes or sockets. A process tree is a hierarchical representation of the relationships between processes in a system, with the parent-child relationship forming the basis of the tree structure. The root of the tree is typically the init process, which creates all other processes in the system. Constructing a process tree requires understanding the parent-child relationships between processes. Each process in the tree has one parent and zero or more children. By tracing the creation and termination of processes, you can construct a process tree that shows the relationships between all processes in the system.
What is inter process communication?
Inter-process communication (IPC) refers to the mechanism used by different processes or threads to communicate with each other and share data. There are several IPC mechanisms, such as shared memory, message passing, pipes, and sockets.
What is virtualization? What portions of the OS is it associated with?
Involves creating multiple virtual environments on a single machine. These virtual environments operate as if they have their own set of resources (resource allocation). This gives process the impression they have unlimited resources. Associated with: CPU and Memory
What security does the operating system control?
Isolate processes Authenticate users Prevent malicious networking or input Harden program execution
Compare and Contrast kernel space and user space.
Kernel space and user space are two modes in which an operating system executes code. Kernel space is a privileged mode that has direct access to the hardware and can execute all instructions. User space is a non-privileged mode that can only execute a subset of instructions and cannot access the hardware directly.
What is a thread pool?
List of pre-allocated threads that can be used to execute tasks. Each thread in the thread pool is assigned a specific task to work on. That way, each thread knows exactly what task it's supposed to be working on, and multiple tasks can be worked on at the same time without getting confused.
What does an operating system manage? Provide an example of each.
Manages various resources of a computer system, including the central processing unit (CPU), memory, devices, and file systems. Manages the CPU by scheduling process execution order, allocating memory to processes and files, and managing input/output devices.
Define each of the following: mutex, semaphore, busy wait, condition variable. Compare and contrast them each other. Be sure to discuss the advantages and disadvantages of each.
Mutex: A mutex is a synchronization primitive that is used to protect a shared resource from being accessed simultaneously by multiple threads or processes. It allows only one thread to acquire the lock and access the resource at a time. The disadvantage of using a mutex is that it can lead to deadlocks, where a thread is waiting indefinitely to acquire the lock that is held by another thread. Semaphore: A semaphore is a synchronization primitive that is used to control access to a shared resource. It allows a specified number of threads to access the resource simultaneously. Semaphores can be used to implement synchronization mechanisms such as mutexes and barriers. The advantage of using a semaphore is that it can handle multiple threads accessing the shared resource at the same time. Busy wait: Busy wait is a synchronization technique in which a thread repeatedly checks a condition in a loop, while continuously using CPU time. The disadvantage of using a busy wait is that it wastes CPU cycles and can lead to performance degradation. Condition variable: A condition variable is a synchronization primitive that allows a thread to wait for a specific condition to occur, such as a shared resource becoming available. The advantage of using a condition variable is that it avoids busy waiting and allows the thread to sleep until the condition is met.
Define each of the following page replacement algorithms: optimal, not recently used, first-in, first-out, second-chance, clock, least recently used, working set, or WSClock. Compare and contrast them as you define
Not Recently Used (NRU): This algorithm divides pages into four categories based on their use and replaces a page in the lowest category. The categories are recently used and modified (RUM), recently used but not modified (RUNM), not recently used but modified (NRUM), and not recently used and not modified (NRUNM). First-In, First-Out (FIFO): This algorithm replaces the page that has been in physical memory the longest time. Second-Chance: This algorithm is similar to FIFO but gives a second chance to recently used pages that would otherwise be replaced. Clock: This algorithm maintains a circular list of pages and uses a reference bit to determine if a page has been recently used. When a page is replaced, the reference bit is set to 0 for all pages until a page is referenced again. Least Recently Used (LRU): This algorithm replaces the page that has not been used for the longest time. Working Set: This algorithm tries to keep track of the set of pages that a process is actively using and only replaces pages that are not in the working set. WSClock: This algorithm is a variation of the Clock algorithm that uses a combination of reference bit and age to determine which page to replace. The main differences between these algorithms are the criteria they use to determine which page to replace and how they keep track of page usage.
Why is it a bad idea to not use any memory abstraction when designing an OS?
Not using any memory abstraction when designing an OS can result in several problems, such as inefficient use of memory, lack of memory protection, and difficulty in managing memory. Without memory abstraction, it is difficult to manage different processes running concurrently in the system, and it can result in one process overwriting the memory of another process.
What is entailed in allowing an OS to be concurrent?
OS must provide mechanisms for process synchronization, inter-process communication, and resource sharing.
What conditions must be met for it to function correctly?
Only one program or thread can hold the lock at a time, and they have to release the lock when they're done using the resource so that someone else can use it.
Describe how paging handles page faults. You may draw a diagram if you think that would be helpful. Provide at least one example of a page replacement algorithm. What is the space-time trade off associated with paging?
Paging is a memory management technique that allows the memory to be divided into fixed-size pages and the program is divided into the same-sized pages. When the program is executed, only the necessary pages are loaded into memory, while the other pages are kept in secondary storage such as a hard disk. When a page that is not present in memory is referenced, a page fault occurs. The operating system then fetches the required page from secondary storage and loads it into a free page frame in physical memory. One example of a page replacement algorithm is the Least Recently Used (LRU) algorithm. This algorithm replaces the page that has not been used for the longest time. The space-time tradeoff associated with paging is that the more pages that are kept in physical memory, the less page faults occur, but the more memory is required.
Compare and contrast preemption and context switching; when is one used over the other?
Preemption and context switching are related concepts, but they serve different purposes. Preemption is a mechanism that allows the operating system to interrupt a running process to give CPU time to another process that has a higher priority. Preemption is used to ensure that high-priority processes can execute in a timely manner, even if lower-priority processes are still running. Context switching is a mechanism that allows the CPU to switch from one process to another. Context switching occurs whenever the operating system needs to interrupt a running process to allow another process to execute. Context switching is used to maximize CPU utilization and ensure that all processes get a fair share of CPU time. Preemption and context switching are often used together. When a high-priority process is scheduled to run, it may preempt a lower-priority process, causing a context switch to occur.
What is process synchronization, and why do we need it? Provide an example where synchronization is necessary.
Process synchronization refers to the coordination of concurrent processes or threads to ensure that they work correctly and do not interfere with each other. We need process synchronization to avoid race conditions and ensure the consistency of shared resources. For example, in a bank transaction system, multiple threads may access the same bank account balance concurrently. Without proper synchronization, it can lead to incorrect account balances or transaction losses.
Compare and contrast the Shortest Job First scheduling algorithm with the Shortest Remaining Time Next scheduling algorithm. What type of system uses these algorithms? What are the potential benefits and drawbacks to each?
Shortest Job First scheduling (SJF) and Shortest Remaining Time Next (SRTN) scheduling are both process scheduling algorithms used in operating systems. SJF schedules processes in order of their expected CPU burst time, with the shortest job being executed first. SRTN is a preemptive version of SJF that selects the process with the shortest remaining burst time for execution. SJF can minimize average wait time and turnaround time but requires knowledge of the expected CPU burst time, which may not be available. SRTN can minimize waiting time and response time, but has a potential for starvation.
Livelock
Situation where two or more threads are actively trying to acquire a resource but are continually blocked by each other.
Deadlock
Situation where two or more threads are blocked indefinitely, waiting for each other to release resources.
What is an operating system?
Software that manages computer hardware and software resources and provides common services for computer programs.
What is a lock?
Special key that programmers use to protect shared resources, like memory or data, from multiple programs or threads trying to access them at the same time.
What is starvation?
Starvation is a condition in which a process is unable to acquire the resources it needs to execute, even though the resources are available. This can happen when the operating system allocates resources to other processes in preference to the starved process, leading to the process being blocked indefinitely.
Compare and contrast swapping, paging, and segmentation. Provide at least one example of a situation where each is preferable.
Swapping, paging, and segmentation are memory management techniques used by operating systems to allocate and manage memory. Swapping involves moving entire processes between main memory and secondary storage. This technique is typically used when there is a shortage of physical memory and the system needs to free up memory for other processes. For example, a system might swap out an inactive process to disk and swap it back in when it becomes active again. Paging involves dividing physical memory into fixed-size chunks called pages and dividing processes into fixed-size chunks called page frames. Pages of a process are loaded into available page frames in physical memory when they are needed, and pages can be swapped out to disk when physical memory becomes full. Paging is commonly used in modern operating systems as it allows for flexible and efficient memory allocation. Segmentation is a memory management technique that divides a process into logical segments, each with its own address space. Each segment can grow or shrink dynamically as needed, and the operating system can manage segments independently. This technique is useful for managing large and complex data structures in a process, such as databases or multimedia applications. An example where swapping may be preferable is when a system is running many processes simultaneously, and there is not enough physical memory to hold all of them at once. Paging is preferable when the system needs to allocate and free memory dynamically as it is a more efficient use of memory resources. Segmentation is useful when the memory requirements of a process are complex, and the process needs to manage data structures of varying sizes.
What is the MMU, and how is it related to the TLB and paging?
The MMU (Memory Management Unit) is a hardware component that is responsible for translating virtual addresses used by the CPU into physical addresses used by the memory subsystem. The TLB (Translation Lookaside Buffer) is a cache of recent translations stored by the MMU, which speeds up the translation process by avoiding the need to look up translations in the page table. Paging is a memory management scheme that uses page tables to map virtual addresses to physical addresses.
Compare and contrast the Round Robin scheduling algorithm with the Completely Fair Scheduling (CFS) algorithm and the Multi-Level Feedback Queue algorithm. What type of system uses these algorithms? What are the potential benefits and drawbacks to each?
The Round Robin scheduling algorithm, Completely Fair Scheduling (CFS) algorithm, and Multi-Level Feedback Queue algorithm are all process scheduling algorithms used in operating systems. Round Robin scheduling assigns a fixed time slice to each process and switches between them in a circular fashion. CFS assigns priorities based on process usage and schedules the process with the smallest amount of usage. Multi-Level Feedback Queue assigns priorities based on the age of the process and dynamically adjusts priority levels based on the behavior of the process. Each algorithm has its own benefits and drawbacks. Round Robin ensures that every process gets an equal amount of CPU time, but can lead to low CPU utilization and high response time. CFS is fair and efficient, but can be complex to implement. Multi-Level Feedback Queue is adaptable and efficient, but can be complex and difficult to fine-tune.
What is the basic thread API- that is, what are the various pthread methods we've used in class, and what do they do? You should be able to write a very basic bit of multithreaded code and understand what each component in that code does.
The basic thread API includes functions for creating and joining threads, as well as functions for synchronizing threads using mutexes, condition variables, and semaphores. For example, the pthread_create function is used to create a new thread pthread_mutex_lock and pthread_mutex_unlock functions are used to lock and unlock a mutex.
What are the different methods of allocating memory to processes? Be sure to discuss the tradeoffs between each implementation.
The different methods of allocating memory to processes are: Contiguous memory allocation: Each process is allocated a contiguous block of memory. This can be further divided into three sub-methods: Fixed partitioning: The memory is divided into fixed partitions, each of which can hold a single process. This is a simple method, but it can lead to wastage of memory if a process is smaller than the partition it is allocated. Variable partitioning: The memory is divided into variable-sized partitions, which can be allocated to processes dynamically. This reduces wastage of memory but can lead to fragmentation. Buddy system: The memory is divided into blocks that are powers of two in size, and adjacent blocks are combined to form larger blocks when possible. This reduces fragmentation but can lead to wastage of memory. Non-contiguous memory allocation: The process is allocated memory that is not necessarily contiguous. This can be further divided into two sub-methods: Paging: Memory is divided into fixed-size pages, and each process is allocated the required number of pages. This allows efficient use of memory and reduces fragmentation, but can lead to overhead due to page tables and page faults. Segmentation: Each process is divided into segments, and each segment is allocated a block of memory of the required size. This allows for flexible memory allocation but can lead to fragmentation. The tradeoffs between these methods are generally related to efficiency, fragmentation, and overhead. Contiguous allocation can be efficient but can lead to fragmentation, while non-contiguous allocation reduces fragmentation but can lead to overhead.
What is the difference between an operating system and the kernel?
The kernel is the core of the operating system that manages system resources and provides essential services. The operating system is the software that manages the hardware and software resources and provides a platform for applications to run.
What is the purpose of a process scheduling algorithm? How is it related to the process table?
The purpose of a process scheduling algorithm is to allocate the CPU resources among multiple processes to optimize system performance. The process scheduling algorithm is related to the process table because the process table contains information about each process, including its state and priority, that is used by the scheduling algorithm to determine which process should be executed next.
What is the purpose of a process scheduling algorithm?
The purpose of a process scheduling algorithm is to decide which process to run next on the CPU. The scheduling algorithm should ensure that the CPU is always busy and that each process gets a fair share of CPU time. The scheduling algorithm should also optimize system performance metrics such as turnaround time, response time, and throughput.
What is the purpose of the CPU idle process?
The purpose of the CPU idle process is to keep the CPU busy when there are no other processes ready to run. It is a process that consumes as little CPU resources as possible, allowing the CPU to be available for other processes when they become ready.
What are the three multithreading models, and how do they work?
The three multithreading models are: Many-to-One Model: This model maps many user threads to a single kernel thread. All workers report to a single manager, which can make things efficient but not ideal if the project gets too complex. One-to-One Model: This model maps each user thread to a kernel thread. Each worker has their own manager, which can handle more complexity, but might lead to too many managers to handle at once. Many-to-Many Model: This model maps many user threads to many kernel threads, allowing the operating system to create a balanced ratio between the two. Multiple managers and workers, which can handle a lot of complexity and work, but might require more coordination and management.
What is the tradeoff between creating threads in the user space, versus creating them in kernel space? consider both time and space.
The tradeoff between creating threads in user space versus kernel space is mainly a tradeoff between time and space. User-level threads are faster to create and switch between, as they do not require any system calls, and can be managed entirely in user space. However, they cannot take advantage of multiple processors, and a blocking system call made by one thread can block the entire process. Kernel-level threads, on the other hand, can take advantage of multiple processors, and blocking calls made by one thread do not block the entire process. However, they require system calls to create and switch between threads, which are slower than user-level threads.
What are the two ways to share resources? Which portions of the OS are associated with each?
The two ways to share resources are time sharing (CPU) and space sharing (Memory, disk)
What is thrashing? Why is it bad? How do we prevent it?
Thrashing is a condition where a computer system is constantly swapping pages between physical memory and disk, which can significantly degrade system performance. Thrashing occurs when the system does not have enough physical memory to hold all the pages it needs, and instead, it spends more time swapping pages than executing code. Thrashing is bad because it significantly slows down system performance and can make the system unresponsive. It also leads to a phenomenon called the "working set problem," where the set of pages that a process needs to execute effectively changes over time. To prevent thrashing, the operating system can use techniques such as increasing the amount of physical memory, reducing the number of processes running, and improving the efficiency of the page replacement algorithm used by the system.
What is the role of threading in concurrency?
Threading enables concurrency by allowing multiple threads to execute concurrently within the same process. Threads are lighter weight than processes, so they can be created and destroyed more quickly, and they share the same memory space, which allows for efficient communication and coordination between threads.
Compare 3 different operating system types discussed in class, and give 1 real world example of each (batch, server, pc, sensor, etc).
Three different operating system types are: Batch OS: Batch OS processes a large number of similar jobs in a batch. An example is the IBM OS/360. Server OS: Server OS manages networked resources and provides services to clients. An example is Microsoft Windows Server. Embedded OS: Embedded OS is designed for specific hardware devices with limited resources. An example is Android OS for smartphones.
Determine if deadlock would occur.
To determine if deadlock would occur in a table, check if any cycle exists in the resource allocation graph. If a cycle exists, then deadlock is possible.
True or False: context switching allows a CPU to swap from process A to process B, and then return to the exact same place in instructions for process A after executing process B.
True. Context switching is a mechanism that allows a CPU to switch from one process to another. When a context switch occurs, the CPU saves the current context of the running process, which includes the value of program counter, registers, and other relevant data. Then, it loads the context of the next process to be executed and resumes execution from the point where that process was previously interrupted. Thus, when the CPU returns to process A after executing process B, it resumes execution from the exact same place where it left off.
True or False: on a machine with one CPU containing a single core, we can only run one process at a time.
True. On a machine with one CPU containing a single core, only one process can execute at a time. However, the operating system can switch between processes quickly, giving the illusion that multiple processes are running simultaneously.
Choose two operating system types (batch, multiprocessor, PC, embedded, real-time, or any other discussed in class) and compare and contrast them.
Two operating system types are: Multiprocessor OS: Multiprocessor OS can run on multiple processors and can execute multiple processes in parallel. It provides better performance than single-processor systems. Real-time OS: Real-time OS is designed to respond to events in real-time and provides predictable performance. It is commonly used in embedded systems and control systems.
What are the basic steps that happen when an operating system abstracts a process?
User executes program. OS creates a process for every program that's been executed OS time-shares the CPU across all of the processes OS scheduler will pick ONE of the executable processes to run Scheduler needs a list of processes and metadata for policy enforcement
What is the shell, and how is it related to system calls?
User interface that allows users to interact with the operating system. It is related to system calls because it provides a command-line interface for users to execute system calls.
Compare and contrast virtual and physical memory.
Virtual memory is a memory management technique that allows processes to use more memory than is physically available on the system. The system uses disk space to create a virtual address space that processes can use, and only the parts of the address space that are currently being used are loaded into physical memory. Virtual memory provides several benefits, including the ability to run more processes simultaneously and the ability to run processes larger than physical memory. Physical memory, on the other hand, refers to the actual memory chips installed on the computer's motherboard. It is the actual physical memory that the CPU uses to store and retrieve data. Physical memory is limited by the number of memory chips and their size.
Determine if resource allocation will be safe or not.
We can determine if resource allocation will be safe from a resource allocation graph The Banker's algorithm works by simulating the allocation of resources to processes and checking if the system is in a safe state to test for possible activities, before deciding whether allocation should be allowed to continue.
What do we do if we want to execute a program that is too large to hold in physical memory all at once?
When a program is too large to hold in physical memory all at once, we use a technique called demand paging. In demand paging, only the portions of the program that are currently needed are loaded into physical memory. When a portion of the program that is not in physical memory is needed, a page fault occurs and the required page is loaded from disk into physical memory. This allows the program to execute even if its size is greater than the physical memory available.
What is a race condition, and how do we avoid it?
When two or more parts of a program try to use the same resource, like a variable or a piece of memory, at the same time, they can interfere with each other and cause problems. To avoid it, we can use techniques such as locking, synchronization, and atomic operations to ensure that only one thread accesses the shared resource at a time.
What is parallelism and how is it different than multithreading?
________ involves the execution of multiple tasks simultaneously on multiple processing units. ___________, on the other hand, involves the execution of multiple threads within a single process.
