CST 334 - Concurrency

Process Memory

*Heap*Text section* made up of *compiled program code*, read from non-volatile storage when the program is launched. *Data section* made up of *global and static variables*, allocated and initialized prior to executing the main. *Heap* used in *Dynamic memory allocation*, and is managed via calls to *new, delete, malloc, free*, etc. *Stack* used for *local variables*. Space on the stack is reserved for local variables when they are declared.

How many condition variables are used in the Anderson/Dahlin method?

0 or more

Semaphore

are integer variables that are used to solve the critical section problems by using two atomic operations, wait and signal that are used for process synchronization.

Serialization

process of translating data structures or object state into a format that can be stored( ex, in a file or a memory buffer) or transmitted (ex. across a network connection) and reconstructed later.

What is the blocking operation in the pthreads API?

pthread_cond_wait

Blocking operation

puts the calling process on wait until the event (on which the call is blocked) occurs after which the process is woken up and is ready for execution.

Process Synchronization

sharing system resources by processes in such a way that, concurrent access to shared data is handled thereby minimizing the chance of inconsistent data. Maintaining data consistency demands mechanisms to ensure synchronized execution of cooperating processes.

Synchronization Instructions

tell one thread to wait until some action is performed by another thread before the former continues its execution.

Asynchronous

the API always returns immediately, having started a "background" effort to fulfill your request, so there must be some related way to obtain the result.

sem.signal

the signal operation increments the value of its argument S

sem.wait

the wait operation decrements the value of its argument S, if it is positive. If S is negative or zero, then no operation is performed.

Properties of lock

1. A lock can be in one of two states: busy or free. 2. A lock is initially in the free state. 3. The lock operation waits until the lock is free, and automatically makes the lock busy. 4. The unlock operation makes the lock free. 5. 'Lock' is sometimes called 'acquire' 6. 'Unlock' is sometimes called 'free'

Using locks for mutual exclusion

1. A lock is an object that can be "held" by only one thread at a time. 2. A lock can be acquired by a thread. 3. A lock can be released by a thread.

Thread

1. Are a sequence of execution code which can be executed independently of one another. a. it is the smallest unit of tasks that can be executed by an OS 2. A program can be single threaded or multi-threaded.

Threads

1. Threads are faster to create, destroy, and context switch. 2. Threads within a process share a virtual address space. 3. *Each thread has it own stack and its own registers.*

Shared Memory

1. concurrent modules interact by reading and writing shared objects in memory. 2. two threads can communicate by having a shared memory location that one writes to and the other reads from. 3. But then the value read by the latter depends on whether the read occurred before or after the former wrote to that memory location. 4. Worse still, if the read and write happen at the same time, it's possible for the reader to see a partially updated value because the writer started updating it but did not finish before the reader read the value. 5. In order to avoid this use synchronization.

Condition variable

1. synchronization primitives that enable threads to wait until a particular condition occurs. 2. condition variables are user-mode objects that cannot be shared across processes. 3.used to wait for a particular condition to become true (eg. characters in buffer).

without proper synchronization of bounded buffer:

1. the producers doesn't block when the buffer is full 2. a consumer consumes an empty slot in the buffer 3. a consumer attempts to consume a slot that is only half-filled by a producer. 4. two producers writes into the same slot. 5. two consumers reads the same slot.

Thread-safe data structure

A method or class instance can be used by multiple threads at the same time without any problems occurring.

When a thread calls wait(), the lock it passes must be in which state?

ACQUIRED note: the thread must be holding the lock when it calls wait()

A ______ is a piece of code that accesses a shared resource, such as a shared variable.

CRITICAL SECTION

What do threads use to signal other threads in the pthreads API?

Condition variables

Two processes may share memory if they each have multiple threads?

FALSE

Processes can have zero threads

FALSE note: every process has at least one thread.

All threads of a process run the same code?

FALSE note: Take for example the readers/writers problem. The readers and writers are threads in the same process.

Condition variables can be implemented with locks

FALSE note: the only state of a lock is whether it is busy or free.

The function 'pthread_create' creates a clone of the currently running thread ( like 'fork' of the process API)

False note: one of the parameters of pthread_create specifies the function that should be run by the newly-created thread.

Minimum number of threads in a process?

ONE

When multiple threads are running, and the output depends on the timing of their execution, then the code has a _____.

RACE CONDITION

The wait() call on condition variable requires a parameter for a condition variable and a parameter for a lock.

TRUE

Threads of the same process can share variables?

TRUE

When a lock is initialized, it is in the 'free' state.

TRUE

If your code is designed following the Anderson/Dahlin guideline, then your code will never break is a 'spurious wakeup' occurs.

TRUE note: A spurious wakeup is when a call to wait() returns if a signal has not occurred

In the Anderson/Dahlin style of designing shared objects, each object has one lock

TRUE note: The lock is used to ensure mutually exclusive access to shared variables

Race condition

When multiple threads are running, and the output depends on the timing of their execution.

Critical section

a code segment that accesses shared variables and has to be executed as an atomic action. This means that in a group of cooperating processes, at a given point of time, only one process must be executing its critical section. If any other process also wants to execute its critical section, it must wait until the first one finishes.

Process

a program in execution. || an instance of a running program. a program can have multiple processes. a process usually starts with a single thread (a primary thread), but later down the line of execution it can create multiple threads.

Mutual exclusion

a program object that prevents simultaneous access to a shared resource *out of a group of cooperating process, only one process can be in its critical section at a given point of time.*

Execution path

a sequence of instructions, that is managed separately by the operating system scheduler as a unit.

Deadlock

a set of blocked processes each holding a resource and waiting to acquire a resource held by another process. occurs when a process or thread enters a waiting state because a requested system resource is held by another waiting process, which in turn is waiting for another resource held by another waiting process.

Create an alias called clr for the clear command.

alias clr="clear"

Threads and processes

both have state.

Shared data

by using a designated area of shared memory, the data can be made directly accessible to both processes without having to use the system services. check semaphore value, write the data, and then reset the semaphore to signal to the server that data is waiting. In turn, the server process writes data back to the shared memory area using the semaphore to indicate that data is ready to be read.

process

contains one or more threads

Concurrency

executing multiple tasks at the same time but not necessarily simultaneously. In a concurrent application, two tasks can start, run, and complete in overlapping time periods i.e Task-2 can start even before Task-1 gets completed.

Create a global bash variable foo and set it equal to the string bar

export foo=bar

Lock

is a blocking operation.

Bounded buffer

lets multiple producers and multiple consumers share a single buffer. Producers write data to the buffer and consumers read data from the buffer. Producers must block if the buffer is full. Consumers must block if the buffer is empty.

Non-blocking

means that if an answer can't be returned rapidly, the API returns immediately with an error and does nothing else. There must be some related way to query whether the API is ready to be called.(that is to simulate a wait in an efficient way).

lock

method of synchronization used to prevent multiple threads from accessing a resource at the same time.

Synchronization primitive

mutex, event, conditional variables, and semaphores are all synchronization primitives. So are shared locks and exclusive locks. you need some synchronization primitives to protect critical section.

At most one thread at a time can be in the critical section - this is ____.

mutual exclusion

Non-determinism

non-predictive. Inability to objectively predict an outcome or result. or for the same input, the compiler may produce different output in different runs.

Atomic operations

operations that finish their tasks as a whole, ie. no other interruption is allowed before its completion.

Which condition variable operations are blocking?

wait

Spurious wakeup

when we wake threads up knowing that they may not be able to proceed. Even after a condition variable appears to have been signaled from a waiting thread's point of view, the condition that was awaited may still be false.

Assign the output of the command date to a variable x.

x=$(date)