SSC - Concurrency and Multi-threading Basic concepts Shan He School for Computational Science University of Birmingham Module 06-19321: SSC
Outline Outline of Topics
Concurrency: history In the beginning, a computer was only capable of executing a single program at a time. Multitasking: Execute multiple programs at the same time. Modern operating systems are all multitasking Essentially shares the computing resources, such as CPU(s), main memory, and I/O channels. Single-CPU machine: only one task can be executed at one time through time-slicing of the CPU. Multi-CPU machine: tasks can be executed simultaneously, distributed among or time-slicing the CPUs.
Multitasking: Cooperative vs Preemptive Cooperative multitasking: processes control the CPU Used in early multitasking operating systems, e.g., Win 3.1 Transferring control explicitly from one process to another (co-routines) according to a cooperative model Runtime support is simpler to implement Programmers have to handle cooperation: bugs in processes may lock the systems Pre-emptive multi-tasking: Kernel schedules CPU to each task Used in modern multitasking operating systems Operating system s kernel manages (schedules) process access to CPU Pre-emption: an action performed by kernel: it forces a process to abandon its running state even if it could safely execute Used time slicing mechanism: a process is suspend when a specified amount of time has expired
Multitasking: Cooperative vs Preemptive Cooperative multitasking Pre-emptive multitasking 1 3 5 Switch() Switch() P1 2 4 6 Switch() P2 Switch() Interrupt Interrupt 1 3 5 P1 2 4 6 Interrupt P2 Interrupt
Preemptive Multitasking Process creation ready Selection Preemption running Process termination Synchronisation statement executed by other processes waiting Synchronisation statement executed by the process
Concurrent programming: Two basic units Process: a program has a self-contained execution environment has a complete, private set of basic run-time resources has its own memory space totally controlled by the operating system Thread: also called lightweight process, which is a dispatchable unit of work in a process. has a definite beginning and an end run inside a single process share the same address space, the resources allocated and the environment of that process
More about threads Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process. A process can be divided into multiple independent threads A process can be a single thread, which is called main thread. A standalone Java application starts with main thread ( main() ) This main thread can start new independent threads. Multithreading: executing multiple threads inside the same process (program).
Concurrency: Two basic units Single threaded process Multithreaded process Thread execution
Main thread and threads Main thread Thread 2 Thread 3 Time Begin End Suspended/Resumed
Difference between threads and processes Processes are typically independent and might consist of multiple threads Processes have separate address spaces for code, data and other resources, whereas threads share the address space of the process that created it Threads are easier to create than processes Multithreading requires careful programming A thread has its own stacks and registers Stack: a reserved region of memory data that is operated in a last-in-first-out manner Register: a small amount of storage available as part of CPU Processes use inter-process communication mechanisms provided by the OS to communicate with other processes, while threads can directly communicate with other threads in the same process
Difference between threads and processes Single thread process Code Memory segments Other Data resources Multithreaded process Code Data Other resources Register Stack Register Register Register Stack Stack Stack
Context switching Context switching: a procedure of multi-threading for the system to switch between threads running on the available CPUs A context is the minimal set of data used by this task that must be saved to allow a task interruption at any point int time Data to be saved include: Registers: one of a small set of data holding places in CPU, which may hold a computer instruction, a storage address, or any kind of data Program counter: known as an instruction address register, which is a small amount of fast memory that holds the address of the instruction to be executed immediately after the current one other necessary operating system specific data
Context switching: how it works A CPU timer: determines the end of the timeslice for each thread, and signals at the end of the timeslice Steps for context switching: Step 1: interrupt current thread by the CPU timer Step 2: The CPU saves all information required, e.g., register and programme counter for the current thread onto a stack Step 3: Move this information from the stack into a data structure called context structure. Step 4: A scheduler algorithm decides which thread to run next Step 5: Run the new thread until a interrupt-return is called to switch back to a previously executing thread Step 6: Transfers all the information from the context structure associated with the previously executing thread to the stack Step 7: resume previous executing thread
Advantages of multi-threading Advantages compared with multi-processing Improves the performance of the program by better usage of system resources: Share the same address space, less overhead for operating system Context-switching between threads is normally inexpensive Better usage of CPU time, e.g., while one thread is blocked (e.g., waiting for completion of an I/O operation), another thread can use the CPU time to perform computations Simpler program design: Control and communication between threads is easy and inexpensive. More responsive programs
Disadvantages of multi-threading Disadvantages/costs compared with single-threading Context switching overhead: even lighter than multi-processing, CPU still needs to save the register, program counter etc. of the current thread, and load the same of the next thread to execute. More complex design: data shared and accessed by multiple threads needs special attention Increased resource consumption: CPU time, memory to keep its local stack, and operating system resources to manage the thread
Concurrent programming - three important concepts Atomicity : An operation is said atomic when it cannot be interrupted. Visibility: If an action in one thread is visible to another thread, then the result of that action can be observed by the second thread. Ordering: Since in multi-threading program, the order of execution is not guaranteed, we need ordering constraints to define what order should the actions in threads executed. We shall see these concepts in Java examples in the next few lectures.