Threads and Data Sharing NETW 3005 Threads and Data Sharing

Last Lecture Hierarchical structure in Operating Systems System calls and interrupts Representing processes in Operating Systems Overview of process scheduling NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

This lecture Cooperating processes. Communication between parent and child processes. Shared memory and pipes. Threads. Inter-process communication. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Interprocess Communication Processes within a system may be independent or cooperating Cooperating process can affect or be affected by other processes, including sharing data Reasons for cooperating processes: Information sharing Computation speedup Modularity Convenience Cooperating processes need interprocess communication (IPC) Two models of IPC Shared memory Message passing

Shared memory: a simple kind of data sharing The map memory family of system calls allow two processes to share some region of main memory. This is achieved by overriding the operating system’s normal constraints on memory access for processes. Operating System P2 P1 NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

IPC by shared memory ; Producer and Consumer Problem A producer process writes data to a buffer of fixed size. A consumer process reads data from the buffer. The two processes are being scheduled independently by the CPU. Producer and Consumer Problem, explained in detail in Lecture 5 NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

IPC : Pipes (in UNIX) Pipes provide a simple method for sharing data. Example : grep ‘party’ events.txt | lpr NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

What’s happening here? We’re typing the command to the shell. When you hit ‘return’, the shell process normally forks a child process, which is told to execute the specified program. When you link two programs with a pipe, the shell process first sets up a buffer in memory, then forks two child processes, which write to / read from this buffer. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Threads (1) Operating systems frequently support a special kind of process called a thread to allow more complex data-sharing. A standard process has a data section, code section, and a full PCB. A thread just has a program counter, a register set and a stack space. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Threads (2) You can have several threads within a single process, using the same code section, data section, memory and I/O resources. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Threads (3) S PC R S PC R S PC R code segment data segment OS management information NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Terminology The code segment, data segment, and O/S housekeeping information of a process is collectively known as a task. A task with just one thread is called a heavyweight process. A thread is also known as a lightweight process. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Operations on threads Threads and processes can do a similar range of things. A thread can wait while an I/O process completes (called blocking). A thread can be in different states – ready, blocked, running, or terminated. A thread can create child threads. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Advantages of threads (1) Responsiveness. Multithreading an interactive application may allow a program to continue running, even if part of it is waiting. Switching speed. Switching between threads is faster than between (heavyweight) processes, because there’s less to change. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Advantages of threads (2) Communication between processes. We don’t need special setups for shared memory when implementing communicating processes as threads in the same task. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Problems with Threads Can suffer from Race Condition Difficult to predict the behavior of threads Difficult to diagnose and test NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

User-level threads Implemented in user-level libraries, without the need for system calls. Fastest kind of thread to switch between. But, the kernel doesn’t know about individual threads within a process. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Kernel-level threads Implemented via system calls. In this case, the kernel knows about individual threads. But switching between threads is slower. NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Multi-threading models Many systems support both user-level and kernel-level threads. We then need some way to map user-level threads to kernel-level threads. many to one one to one many to Many NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Many to one :Multi-threading model In a many-to-one model, many user threads are mapped onto a single kernel thread. This suffers from the problem of blocking: the kernel doesn’t know about it when one thread blocks. Examples: Solaris Green Threads GNU Portable Threads NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

One to one :Multi-threading models In a one-to-one model, each user thread is mapped onto a single kernel thread. This doesn’t suffer from the above prob-lem, but there’s an overhead in creating the corresponding kernel threads. Most systems only support some maximum number of kernel threads. Examples Windows Linux Solaris 9 and later NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

M:M -Multi-threading model In a many-to-many model, a set of user threads is multiplexed onto a (smaller or equal) set of kernel threads. You need to have an extra mechanism that allocates each user thread to a kernel thread. A many-to-many scheme avoids many of the disadvantages of both above schemes. Examples : Solaris prior to version 9 Windows with Thread Fiber package NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Java threads As well as any threads defined in a Java program, there are a number of extra threads running on behalf of the JVM. For instance: a thread to listen and react to the mouse/keyboard; a thread to do garbage collection; a thread to handle timer events (e.g. the sleep() method). NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Interprocess Communication – Message Passing Mechanism for processes to communicate and to synchronize their actions Message system – processes communicate with each other without resorting to shared variables IPC facility provides two operations: send(message) receive(message) The message size is either fixed or variable To pass messages between processes, a communication link( Hardware Bus , Network , shared memory) must be established.

Direct Communication Processes must name each other explicitly: send (P, message) – send a message to process P receive(Q, message) – receive a message from process Q Properties of communication link Links are established automatically A link is associated with exactly one pair of communicating processes Between each pair there exists exactly one link The link may be unidirectional, but is usually bi-directional

Indirect Communication Messages are directed and received from mailboxes (also referred to as ports) Each mailbox has a unique id Processes can communicate only if they share a mailbox Properties of communication link Link established only if processes share a common mailbox A link may be associated with many processes Each pair of processes may share several communication links Link may be unidirectional or bi-directional

Indirect Communication send(A, message) – send a message to mailbox A receive(A, message) – receive a message from mailbox A NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Lecture 03 - Threads and data-sharing NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Summary: ways of sharing data Creating a child process Shared memory Pipes Threads Message passing system NETW3005 (Operating Systems) Lecture 03 - Threads and data-sharing

Next Lecture Scheduling