Operating System Processes and Threads

kernel threads

Another one is scheduled.

multi-thread mapping

<p>many-to-one</p> Signup and view all the answers

<p>kernel threads</p> Signup and view all the answers

<p>Double-clicking using a GUI or typing a command in a console.</p> Signup and view all the answers

<p>The parent process creates the child process. The child can also spawn new processes.</p> Signup and view all the answers

<p>A PID is a unique process identification number, stored in a process table by the Operating System.</p> Signup and view all the answers

<p>A PCB holds all the information about a process. It saves all the state information.</p> Signup and view all the answers

<p>A process can be in one and only one state at any given time.</p> Signup and view all the answers

<p>At most one process can be in the RUNNING state.</p> Signup and view all the answers

<p>READY means the process is ready to run but waiting for the CPU.</p> Signup and view all the answers

<p>A process enters the BLOCKED state when it is waiting for a resource to become available.</p> Signup and view all the answers

<p>Threads share an address space, while processes share resources like memory and disk.</p> Signup and view all the answers

<p>Process properties are shared between threads.</p> Signup and view all the answers

<p>Thread properties.</p> Signup and view all the answers

<p>In order, or in sequence.</p> Signup and view all the answers

<p>Single-CPU system.</p> Signup and view all the answers

<p>Single thread of control.</p> Signup and view all the answers

<p>Next term distributed systems programming will be revisited.</p> Signup and view all the answers

<p>The definition of concurrent programming is not detailed.</p> Signup and view all the answers

<p>To provide mutual exclusion and ensure that only one process accesses the shared buffer at a time.</p> Signup and view all the answers

<p>It has ownership, meaning only the process that decremented it can increment it.</p> Signup and view all the answers

<p>It makes the producer wait for an available slot in the buffer, to prevent overruns.</p> Signup and view all the answers

<p>It waits for mutual exclusion access to the buffer, it is signalled by the <em>same</em> thread after writing to the buffer.</p> Signup and view all the answers

<p>It makes the consumer wait until there are items to get from the buffer</p> Signup and view all the answers

<p>Deadlock. Other producers and consumers would get blocked forever waiting for the mutex.</p> Signup and view all the answers

<p>The consumer loop is missing the <code>Wait(ItemsReady)</code>, <code>Get item i</code>, and <code>Signal(SpacesLeft)</code> operations.</p> Signup and view all the answers

<p>It acts as a mutex, ensuring that only one process can access the shared buffer at a time.</p> Signup and view all the answers

<p>It signals the consumer that a new item has been placed in the buffer, allowing the consumer to proceed with consumption.</p> Signup and view all the answers

<p>Each philosopher needs two forks because to eat spaghetti, they must grasp the fork on either side of their plate.</p> Signup and view all the answers

<p>The left chopstick is at the philosopher's index <code>i</code>, and right is at <code>((i-1)+N)%N</code>, where N is the total num of philosophers.</p> Signup and view all the answers

<p>It is used to acquire the use of the left chopstick, ensuring that no other philosopher can use it simultaneously.</p> Signup and view all the answers

<p>They release the left chopstick and then the right chopstick using <code>signal</code> operations.</p> Signup and view all the answers

<p>The potential problem is a deadlock, where all philosophers hold their left fork and are waiting for the right.</p> Signup and view all the answers

<p>The order determines resource acquisition, which has implications for preventing deadlock and ensuring correct synchronization, as shown in the dining philosophers problem.</p> Signup and view all the answers

<p>A consumer reading <code>itemCount</code> as 0 and then calling <code>sleep(consumer)</code> leading to a deadlock.</p> Signup and view all the answers

<p>Mutual exclusion, hold and wait, no preemption, and circular wait.</p> Signup and view all the answers

<p><code>sleep(consumer)</code></p> Signup and view all the answers

<p>It's where processes holding resources are allowed to request and wait for additional resources.</p> Signup and view all the answers

<p>Resources previously locked cannot be forcefully unlocked by another process, they must be released by the holding process</p> Signup and view all the answers

<p>It means that there’s a chain of processes where each is waiting for a resource held by the next process in the chain.</p> Signup and view all the answers

<p>It signals the consumer thread that a new item has been placed in the buffer and that it should wake up and try to consume.</p> Signup and view all the answers

<p>It keeps track of the number of items currently in the shared buffer.</p> Signup and view all the answers

Threads directly managed by the operating system's kernel.

Threads created and handled by a user-level thread library, not visible to the kernel.

Many user threads are mapped to a single kernel thread.

Each user thread directly maps to a separate kernel thread.

Multiple user threads are mapped to multiple kernel threads, allowing flexible execution.

A synchronization issue where producers generate items and consumers consume them, requiring coordination.

A signaling mechanism used to control access to a common resource in concurrent programming.

A mutual exclusion semaphore that allows only one process to access a critical section at a time.

Refers to the property of a semaphore that can only be released by the process that acquired it.

A semaphore that indicates if the buffer is currently in use by either producers or consumers.

A semaphore indicating the number of vacant spaces available in the buffer for new items.

A semaphore signaling that there are items available for consumers to process.

Part of the code that accesses shared resources, requiring synchronization to prevent conflicts.

A thread is the smallest unit of processing that can be scheduled by an operating system.

A process is a program in execution that has its own memory space.

Threads share the same address space; processes do not.

A programming model where statements are executed in a specific order.

A programming model that allows multiple threads to run simultaneously.

In threads, properties are shared while in processes, they are separate.

Execution model where only one thread executes at a time.

A process that can contain multiple threads running concurrently.

The process that creates a new process.

The new process created by a parent process.

A unique number assigned to each process by the OS.

A data structure holding information about the process.

The current condition of a process (READY, RUNNING, BLOCKED).

The state when a process is ready to run but waiting for CPU.

The state when a process is actively running on the CPU.

The state when a process is waiting for a resource to become available.

A problem that illustrates synchronization issues in concurrent computing with philosophers needing forks to eat.

Tools required by philosophers to eat, where each philosopher needs two to consume spaghetti.

Commands used in semaphore operations to control resource access; waiting for signals and signaling availability.

A class representing each philosopher in the Dining Philosophers Problem, managing their actions with semaphores.

The process of assigning available resources (like forks) to competing threads (like philosophers) efficiently.

A situation where two or more threads wait indefinitely for each other to release resources.

A resource can only be assigned to one process at a time.

Processes holding resources can request more resources while waiting.

Resources cannot be forcibly taken from a process; they must be voluntarily released.

A condition where a set of processes wait for each other in a circle.

Threads that are in a waiting state, unable to proceed until they are 'woken up'.

The number of items currently in the buffer in the producer-consumer problem.