computer science 213 © 2006 donald acton 342 layering yet again! application programs operating...

Layering Yet Again!Layering Yet Again!

Application programs

Operating system

Hardware

General Layering

Structure

Application

Transport

Network

Layering

Application

Unix I/O

File System

Disk Drive

File System

Layering

On to protocolsOn to protocols

• We just finished file systems and explored what happened from the disk to the application

• A layered approach was used to organize things

• We are going to start at the application layer and explore computer protocols

Communication Between Processes

• When talking about shells the concept of pipes was introduced

grep "ok:" inputfile | sort | less

• This is really just one process sending data to another. It is a form of Interprocess Communication (IPC).

Local IPCLocal IPC

Process1

Process2

Remote IPCRemote IPC

Process1

Process2

What Problems Does this Present?

Process1

Process2

Problem SummaryProblem Summary

• Initiator needs– something to write

to– to identify the

recipient– to define the

“language” of the data exchange

– a mechanism to make the call

• Receiver needs– something to read

from– to define the

“language” of the data exchange

– a mechanism to accept a call

– “caller ID” (sort of)

IPC StagesIPC Stages

A communication between processes can be decomposed into 3 stages:

1. Establishing the connection between the callee and caller

2. Transferring of data3. Disconnecting (closing) the connection

The collection of calls involved in the above phases is the Socket API

Identifying the CalleeIdentifying the Callee

• Must identify the machine being called– DNS Name (www.cs.ubc.ca) is the human

readable form– Gets translated to an IP address

(142.103.6.5, 127.0.0.1)

• Must identify the recipient on the machine– Port number – Port 80 (www-http), 194 (irc)

Internet ConnectionsInternet Connections

Connection socket pair(128.2.194.242 :51213, 208.216.181.15:80)

Receiver(port 80)

Sender

Sender socket address128.2.194.242:51213

Receiver socket address208.216.181.15:80

Sender host address128.2.194.242

Receiver host address208.216.181.15

Adapted from: Computer Systems: A Programmer’s Perspective

Establishing the Connection (1)Establishing the Connection (1)

• Caller– Creating the

“endpoint”

int fd;

fd = socket(PF_INET,SOCK_STREAM,0);

• Caller– Getting ready to make the call

struct sockaddr_in remoteAddr;unsigned long remoteIP = htonl(0xAB112090);

memset(&remoteAddr, 0, sizeof(remoteAddr));remoteAddr.sin_family = PF_INET;memcpy(&remoteAddr.sin_addr.s_addr, &remoteIP, sizeof(remoteIP));remoteAddr.sin_port = htons(7891);

• Caller– Making the actual call

connect(fd, (struct sockaddr *) &remoteAddr, sizeof(remoteAddr));

• Ready to transmit/receive data when the call returns

CalleeCallee

Caller1. Create a socket

2. Connect to

callee3. Transfer data4. Close

connection

Callee1. Create socket2. Specify contact

point (binding)3. Listen for calls4. Accept call5. Transfer data6. Close connection

Callee – struct sockaddr_in callerAddr; memset(&callerAddr,0,sizeof(callerAddr)); callerAddr.sin_family = PF_INET; callerAddr.sin_addr.s_addr =

htonl(INADDR_ANY);

callerAddr.sin_port = htons(7891); bind(fd, (struct sockaddr *) &callerAddr, sizeof(callerAddr))

Purpose of BindPurpose of Bind

• Consider a machine with multiple network cards – Wireless and wired– Server on more than one network

• Callee – must tell the system it is ready to listen for connectionslisten(fd, 4)– fd – file descriptor of socket to listen– 2nd argument is how many unanswered

calls to queue up (your call is important to us please stay on the line!)

• Callee needs to actually accept the call

struct sockaddr_in caller;int cl_len = sizeof(caller);int callerFD;callerFD = accept(fd, (struct sockaddr *)&caller, &cl_len);

Setting up a ConnectionSetting up a Connection

listenfd(3)

Caller

1. Callee blocks in accept, waiting for connection request on listening descriptor listenfd.

clientfd

Callee

listenfd(3)

Caller

clientfd

Callee 2. Caller makes connection request bycalling and blocking in connect.

listenfd(3)

Caller

clientfd

Callee

3. Callee returns connfd from accept.Caller returns from connect. Connection is now established between clientfd

and connfd.

connectionrequest

connfd(4)

Who Called?Who Called?

• Callee can determine caller by examining 2nd parameter

unsigned long callerIP = ntohl(caller.sin_addr.s_addr);unsigned short = ntohs(caller.sin_port);

DisconnectingDisconnecting

• Either caller or callee can terminate a connection with the close() system call

close(callerFD);

Exchanging DataExchanging Data

• Once the connection is established caller and callee can both send and receive data– i.e. the connection is bi-directional– The data is not interpreted by the

sockets and it is just a series of bytes. – Calls to send and receive are:

•send()/write()•recv()/read()

The CallerThe Caller#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <time.h>int main(){ int fd; fd = socket(PF_INET, SOCK_STREAM,

struct sockaddr_in remoteAddr; unsigned long remoteIP = htonl(0x7F000001); memset(&remoteAddr, 0,

sizeof(remoteAddr));

remoteAddr.sin_family = PF_INET; memcpy(&remoteAddr.sin_addr.s_addr, &remoteIP, sizeof(remoteIP)); remoteAddr.sin_port = htons(7891);

if (connect(fd, (struct sockaddr *) &remoteAddr, sizeof(remoteAddr)) < 0) {

perror("Connection failed"); } else { char *msg = "Hi there\n"; time_t ltime; char buff[256]; time(&ltime); write(fd, &ltime, sizeof(ltime)); write(fd, msg, 10); int amt; amt = read(fd, buff, 256); while( amt > 0) { printf("Buffer %s", buff); amt = read(fd, buff, 256); } }}

Caller´ (1)Caller´ (1)

#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <time.h>int main(){ int fd; fd = socket(PF_INET, SOCK_STREAM, 0);

struct sockaddr_in remoteAddr;

unsigned long remoteIP = htonl(0x7F000001);

memset(&remoteAddr, 0, sizeof(remoteAddr));

remoteAddr.sin_family = PF_INET;

memcpy(&remoteAddr.sin_addr.s_addr, &remoteIP, sizeof(remoteIP));

remoteAddr.sin_port = htons(7891);

if (connect(fd, (struct sockaddr *) &remoteAddr, sizeof(remoteAddr)) < 0) {

perror("Connection failed"); } else { char *msg = "Hi there\n"; time_t ltime; char buff[256]; time(&ltime); write(fd, &ltime, sizeof(ltime)); write(fd, msg, 10); int amt;

Caller´Caller´

amt = read(fd, buff, 256);

while( amt > 0) {

printf("Buffer %s", buff);

amt = read(fd, buff, 256);

CalleeCallee#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <netdb.h>#include <time.h>int main(){ int fd; fd = socket(PF_INET, SOCK_STREAM, 0); struct sockaddr_in callerAddr; memset(&callerAddr, 0, sizeof(callerAddr)); callerAddr.sin_family = PF_INET; callerAddr.sin_addr.s_addr = htonl(INADDR_ANY); callerAddr.sin_port = htons(7891); bind(fd, (struct sockaddr *) &callerAddr,

sizeof(callerAddr)); listen(fd, 4); struct sockaddr_in caller;

while(1) { int cl_len = sizeof(caller); int callerFD; callerFD = accept(fd,

(struct sockaddr *)&caller, &cl_len);

char buff[256]; int amt; time_t rtime; recv(callerFD, &rtime, sizeof(time_t), 0); amt = recv(callerFD, buff, 256, 0); printf("%s", buff); struct hostent *hp; hp = gethostbyaddr((char *)

&caller.sin_addr.s_addr, sizeof(long), PF_INET);

amt = snprintf(buff,256, "Connection from %s (%x) %x at %s",

hp->h_name, ntohl(caller.sin_addr.s_addr), (long) ntohs(caller.sin_port), ctime(&rtime));

send(callerFD, buff, amt, 0); sleep(10); send(callerFD, "Bye\n", 5, 0); close(callerFD); }}

Callee (1)Callee (1)

#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <netdb.h>#include <time.h>int main(){ int fd;

fd = socket(PF_INET, SOCK_STREAM, 0);

struct sockaddr_in callerAddr;

memset(&callerAddr, 0, sizeof(callerAddr));

callerAddr.sin_family = PF_INET;

callerAddr.sin_addr.s_addr = htonl(INADDR_ANY);

callerAddr.sin_port = htons(7891);

Callee (3)Callee (3) bind(fd, (struct sockaddr *) &callerAddr, sizeof(callerAddr));

listen(fd, 4);

struct sockaddr_in caller;

while(1) {

int cl_len = sizeof(caller);

int callerFD

callerFD = accept(fd, (struct sockaddr *)&caller, &cl_len);

char buff[256];

int amt;

time_t rtime;

recv(callerFD, &rtime, sizeof(time_t), 0);

amt = recv(callerFD, buff, 256, 0);

printf("%s", buff);

Callee (5) Callee (5)

struct hostent *hp; hp = gethostbyaddr((char *) &caller.sin_addr.s_addr, sizeof(long),PF_INET);

amt = snprintf(buff,256, "Connection from %s (%x) %x at %s",

hp->h_name, ntohl(caller.sin_addr.s_addr), (long) ntohs(caller.sin_port), ctime(&rtime));

send(callerFD, buff, amt, 0);

sleep(10);

send(callerFD, "Bye\n", 5,0);

close(callerFD);

Typical Call ProgressTypical Call ProgressCaller Callee

socket socket

listen

accept

writeread

connect

Connectionrequest

Await connectionrequest fromnext caller

BSD Socket API SummaryBSD Socket API Summary• socket() – creates the socket• connect() – initiate a connection• bind() – indicates the IP address to use• listen() – marks the socket to receive

connections• read()/recv() – reads data• write()/send() - writes data• close() – shuts down the connection

Other Useful FunctionsOther Useful Functions

• inet_aton() – string to network address

• inet_ntoa() – network address to string

• gethostbyname() gethostbyaddr() given a host name or address look it up

Client Server ModelClient Server Model

• When designing a network based application how can we decide what goes where?

• One approach is to divide the functionality into client and server components

Client/ServerClient/Server

• Client – is a process that is requesting some sort of service

• Server – is a process that supplies a service

• A particular process can be both a client and server

Changing RolesChanging Roles

Database

HTTP Server

Request/ResponseRequest/Response

Clientprocess

Serverprocess

1. Client sends request

2. Server processes

request

3. Server sends response4. Client processesresponse

Resource

The Chat ProblemThe Chat Problem

• Consider the following application scenario– Two network connected computers – Want to implement “chat”– When each user types their typing

appears on the other screen– User’s do not have to take turns and can

type at any time

The Application’s TaskThe Application’s Task• Each application has two things to do

it must:– Read input from the keyboard and send

it to the remote machine– Read input from the remote machine

and write it to the screen

Start with what we knowStart with what we know

• Assume we have the network connection established

while(1) {

read from networkwrite to screenread from keyboardwrite to network

Do it with Fork!Do it with Fork!

if (fork()) { // parent

read from network

write to screen

} else { //child

read from keyboard

write to network

Fork()Fork()

Chat ChatSocket

Chat Chat

That was easy!That was easy!

• But…..– The overhead of forking the process is

high especially if the child is short lived– Exchanging information between the

child and parent is difficult– It is difficult for the parent to track the

children for resource management issues

HTTP Server ExampleHTTP Server Example

• Accepts connections• Client sends commands

– GET, POST, OPTIONS, HEAD, PUT, DELETE

• Commands are in plain text ASCII• Server parses the request and sends

back content• 99% of HTTP requests are GETs

Niave HTTP serverNiave HTTP server

while (1) {

accept connection

perform http request

close connection

Request TimelineRequest Timeline

HTTP Server – fork()HTTP Server – fork()while (1) {accept connection

if (fork() == 0) { perform http request processing} else {

if (too many workers) { wait for worker

Observations about ServerObservations about Server

• We would like to control the number of processes created

• Each request is computationally light and has little state and is small

• Also, could we have a design that, if appropriate, doesn’t force the client to open a new connection for each request?

Worker PoolWorker Pool

• How about a model where there are a bunch of workers

• One worker checks for a connection to see if data arrives

• On data arrival worker services request

• New worker starts waiting

Worker Pool DemonstrationWorker Pool Demonstration

Process ShortcomingsProcess Shortcomings

• Switching between processes (i.e. scheduling) is slow

• Sharing large amounts of data through pipes or sockets is difficult

ThreadsThreads

• To get rid of some of the problems of processes we can use threads

• Threads– Are started by a process and stay within

that process– Execute independently of each other– Share the same memory space

Threads and ProcessesThreads and Processes

Computer

Thread StatesThread States

Blocked

DeadRunning

Thread APIThread API

• Defined by POSIX.1c• The API defines > 60 functions!!!• Java Thread class is much smaller

and many of the methods are informational

Most Useful Thread FunctionsMost Useful Thread Functions

• Creating a thread• Starting the thread• Waiting for a thread to terminate• Terminating a thread• To simplify the using of threads let’s

develop an encapsulation of the simplest thread functions

Encapsulation StrategyEncapsulation Strategy

Recall that an object is:–A collection of data that captures the state of the object

–A collection of methods that operate on the state

Is there some way to emulate this in a language like C?

Approach?Approach?

What C construct could be used to aggregate data?

structsWhat about methods?

functions

OrganizationOrganization

Java• new

C• A function that

allocates and initializes the struct and returns a pointer to the struct

struct Point { float x; float y; };

void *newPoint() {

struct Point *pt;

if (pt = malloc(sizeof(struct Point))) {

pt->x = pt->y = 0;

return pt;

Organization cont’dOrganization cont’d

Java• Method invocation

point.method()

C• Just call a function,

but make the first parameter be the “object”

void *pt;

pt = newPoint();

setPoint(pt, 3.4, 1.3);

Encapsulation ExampleEncapsulation Example

struct Point { float x; float y; };

void *newPoint() {

struct Point *pt;

if (pt = malloc(sizeof(struct Point))) {

pt->x = pt->y = 0;

return pt;

void setPoint(void * obj, float x, float y) {

struct Point *pt = obj;

pt->x = x;

pt->y = y;

main() {

void *pt;

pt = newPoint();

setPoint(pt, 3.4, 1.3);

Relationship Between Thread Encapsulation and pthread

pthread

Thread

Needed FunctionalityNeeded Functionality• Creation

– int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine, void*), void *arg);

• Cancellation – int pthread_cancel( pthread_t target_thread);

Functionality cont’dFunctionality cont’d

• Join– int pthread_join(pthread_t thread,

void **status);

• Detach– int pthread_detach( pthread_t thread);

Thread StructThread Struct

struct Thread {

void *(*entry_pt)(void*);

void *arg;

pthread_t id; // the thread ID

};int pthread_create(pthread_t *thread,

const pthread_attr_t *attr, void *(*start_routine, void*), void *arg);

Thread FunctionsThread Functions

void *createThread(void* (*func)(void*),

void *parm);

int runThread(void *vthread, pthread_attr_t *attr);

int cancelThread(void * vthread);

int joinThread(void * vthread, void **thread_return);

Thread Functions cont’dThread Functions cont’d

int detachThread(void *vthread);

pthread_t getThreadID( void *vthread);

void* getThreadArg( void *vthread);

createThreadcreateThread

void *createThread(void* (*func)(void*), void * parm) {

struct Thread *thread; thread = malloc(sizeof(struct Thread)); if (thread) { thread->entry_pt = func; thread->arg = parm; } return thread;}

runThreadrunThreadint runThread(void *vthread, pthread_attr_t *attr) { struct Thread *thread = vthread; if (vthread) { return pthread_create(&thread->id, attr,

thread->entry_pt, thread->arg ); } return -10;}

int cancelThread(void * vthread){ struct Thread *thread = vthread; return pthread_cancel(thread->id);}

joinThreadjoinThreadint joinThread(void * vthread, void **thread_return){ struct Thread *thread = vthread; return pthread_join(thread->id, thread_return);}

int detachThread(void *vthread) // reaps a thread{ struct Thread *thread = vthread; return pthread_detach(thread->id);}

AccessorsAccessorspthread_t getThreadID(void *vthread){ struct Thread *thread = vthread; return thread->id;}

void* getThreadArg(void * vthread){ struct Thread *thread = vthread; return thread->arg;}

Creating and Running a ThreadCreating and Running a Thread

void *sortAndPrint(void *array) { … }

void *t2;t2 = createThread(sortAndPrint, ar1);runThread(t2, NULL);detachThread(t2); // Only call after

// runcancelThread(t2);free(t2);

JoiningJoining

• Threads can only execute as long as their containing process exists

• The main() body of a program is a thread

• If any thread either directly or indirectly calls exit() or _exit() the process will be terminated

Joining cont’dJoining cont’d

• If all the process’s work is being done by threads started from main() then main must not return prematurely

• Any thread can wait for another thread with the pthread_join() call encapsulated by:

joinThread(t2, NULL);

Example Sorting and Printing

• Have a function that takes as an argument an array of integers, sorts, and then prints them

• main() – Creates 3 arrays of integers– Creates 3 threads – Starts all 3 threads “simultaneously”

Sort and PrintSort and Printint cs213Compare(const void *a, const void *b) { return *(int *)a - *(int *)b;}

void *sortAndPrint(void *array) { int i; int *b; b = (int *) array; qsort(array, aSize, sizeof(int), cs213Compare); for (i=0; i<aSize; i++) { printf("%3d ", b[i]); fflush(stdout); } printf("\n"); return NULL;}

Sort and PrintSort and Print

int main(int argc, char * argv[]){ int array1[aSize]; int array2[aSize]; int array3[aSize]; int i; srandom(time(NULL)); for (i = 0; i < aSize; i++) { array1[i] = random() % (aSize * 10); array2[i] = random() % (aSize * 10); array3[i] = random() % (aSize * 10); printf("%3d %3d %3d\n", array1[i], array2[i],

array3[i]); }

Sort and PrintSort and Print printf("\n");

void *t1, *t2, *t3; t1 = createThread(sortAndPrint, array1); t2 = createThread(sortAndPrint, array2); t3 = createThread(sortAndPrint, array3);

runThread(t2, NULL); pthread_attr_t attr; pthread_attr_init(&attr); runThread(t3, &attr); runThread(t1, NULL);

joinThread(t1, NULL); joinThread(t2, NULL); joinThread(t3, NULL); return 0;}

Compare FunctionCompare Function

int cs213Compare(const void *a, const void *b) {

return *(int *)a - *(int *)b;

Sort and Print FunctionSort and Print Function

void *sortAndPrint(void *array) { int i; int *b; b = (int *) array; qsort(array, aSize, sizeof(int), cs213Compare); for (i=0; i<10; i++) { printf("%3d ", b[i]); fflush(stdout); } printf("\n"); }

Filling the arraysFilling the arrays

srandom(time(NULL));

for (i = 0; i < aSize; i++) {

array1[i] = random() % (aSize * 10);

printf("%3d %3d %3d\n", array1[i], array2[i], array3[i]);

Running the ThreadsRunning the Threadsvoid *t1, *t2, *t3;t1 = createThread(sortAndPrint, array1);t2 = createThread(sortAndPrint, array2);t3 = createThread(sortAndPrint, array3);

runThread(t2, NULL);pthread_attr_t attr; pthread_attr_init(&attr);runThread(t3, &attr); runThread(t1, NULL); joinThread(t1, NULL);joinThread(t2, NULL);joinThread(t3, NULL);

Output 1Output 1 53 14 27 2 31 85

30 11 67

50 7 39

29 16 79

3 99 90

40 26 32

29 82 64

15 61 73

75 38 23

This is the output from main of the unsorted numbers

Output 2Output 2

2 3 15 29 29 30 40 50 53 75 7 11 14 16 26 31 38 61 82 99

23 27 32 39 64 67 73 79 85 90

Output 3Output 3

2 3 15 29 7 61 … 53 75 99

23 27 32 39 64 67 73 79 85 90

2 3 15 29 7 … 99 50 53 32 75 39

64 67 73 79 85 90

What Happened?What Happened?

• Before one thread finished, its quantum expired and another thread was run

• The thread switched out hadn’t finished

• Exactly when the switch occurs is unpredictable; therefore the output is unpredictable

But why?But why?

• What is being shared?– The file descriptor attached to stdout, in

this example it is the screen (window)– Each time the thread is given a time

quantum it writes to stdout– The threads are taking turns writing to

stdout, hence the mixed output

Real life examplesReal life examples

• Can you think of some real life examples where there is some notion of sharing, how is it regulated?

Semaphores, the Computer Equivalent

• Developed by Edsger Dijkstra to solve synchronization problem in concurrent programming environments

• A special global variable, s, that can only be manipulated by the operations P(s) (proberen) and V(s) (verhogen)

• Works for both processes and threads

AtomicAtomic

Definition: A series of actions is said to be

atomic if the execution of the actions has the exact same result as if the actions had been performed sequentially without interruption.

Semaphore SemanticsSemaphore Semantics

• V(s) [ s = s + 1]– Operation is performed atomically

• P(s) [while (s == 0) {wait}; s = s – 1]– The test for 0 and decrement are done

atomically– If s is 0 then the process waits until the

value of s is modified by a V operation

Underlying Semaphore Implementation

We know– That an application can be interrupted

at any time– That the kernel can schedule a new

process to run– When executing in the kernel interrupts

are disabled therefore any series of instructions is atomic

Semaphore APISemaphore API

• Part of POSIX 1003.1b• Supplies semaphores in various

formats• Upon creation the semaphore values

is normally set to 0, although other values are allowed

• You will work with the supplied Semaphore class

Semaphore EncapsulationSemaphore Encapsulation

void P(sem_t *_sysSem);

void V(sem_t *_sysSem);

sem_t createSemaphore();void destroySemaphore(sem_t

**_sysSem);

createSemaphore()createSemaphore()

sem_t *createSemaphore(int count) { sem_t *_sysSem = malloc(sizeof(sem_t)); if (_sysSem) { memset( _sysSem, 0, sizeof( sem_t ) ); if (sem_init(_sysSem, 0, count) != 0) { // perror("Getting semaphore failed"); free(_sysSem); _sysSem = NULL; } } return _sysSem;}

destroySemaphore()destroySemaphore()

void destroySemaphore(sem_t **_sysSem ) { if (_sysSem && *_sysSem) { if (sem_destroy(*_sysSem) != 0) { perror("Semaphore Destr. failed"); } else { free(*_sysSem); *_sysSem = NULL;

P()P()

void P(sem_t * _sysSem) { // wait, lock if (sem_wait(_sysSem) != 0) {

perror("Semaphore P() blocking");

pthread_cancel(pthread_self());

for(;;) sleep(60000);

V()V()

void V(sem_t *_sysSem) { //signal, unlock

if (sem_post(_sysSem) != 0) {

perror("Sem V()blocking");

pthread_cancel(pthread_self());

for(;;) sleep(60000);

V()P()

Semaphores in ActionSemaphores in Action

P() V()T1

Using P() and V() in Sort and Print ExampleUsing P() and V() in

Sort and Print Example• All threads must use the same

semaphore • Given the way we have put things

together a global variable for the semaphore will be needed

• Add code sem_t *s = createSemaphore(1);

before the definition of sortAndPrint()

Where do P() and V() go?Where do P() and V() go?

void *sortAndPrint(void *array) { int i; int *b; b = (int *) array; qsort(array, aSize, sizeof(int), cs213Compare); for (i=0; i<10; i++) { printf("%3d ", b[i]); fflush(stdout); } printf("\n"); }

Semaphores & BanksSemaphores & Banks

•Consider a banking system that has a method to transfer money from one account to another

•Uses semaphores to prevent multiple simultaneous transfers from updating the same account at once

Solution 1Solution 1

void transfer(int amt, BankA *a1, BankA *a2){

if (valid balance) {

Withdraw(a1, amt);

Deposit(a2, amt);

Problem with Solution 1Problem with Solution 1

• Withdraw and deposit methods could take a long time if they involve going to disk

• With a single global semaphore no other transfers can be done while waiting, even if the transfer involves completely different accounts

Solution 2Solution 2

void transfer(int amt, BankA *a1, BankA *a2){

P(a1->s); P(a2->s); if (valid balance) {

Withdraw(a1, amt);Deposit(a2, amt);

}V(a2->s); V(a1->s);

Does solution 2 work?Does solution 2 work?

transfer(100,a1,a2);

1. P(a1->s);

2. P(a2->s);

transfer(100,a2,a1);

1. P(a2->s);

2. P(a1->s);

At this point each thread/process is waiting for the other so no further progress, by either thread/process, can be made.

DeadlockDeadlock

Definition:A deadlock occurs when two or more processes/threads cannot make computational progress because the processes/threads, either directly or indirectly, are waiting for a resource the other process/thread holds.

Wait-for-graphWait-for-graph

– For each process draw a square– For each resource (semaphore) draw a circle– If a resource is held by a process draw an

arrow from the resource to the process – If a process is waiting for a resource draw

an arrow from the process to the resource

If a cycle exists then there is a deadlock in the system

Bank – wait-for-graphBank – wait-for-graph

Deadlock DetectionDeadlock Detection

• Can be done by keeping wait-for-graph

• Keeping a wait-for-graph is expensive as each time a resource is acquired, released, or waited for, the graph must be updated

• Running the cycle detection algorithm can consume many resources if it is done too frequently

So you found a deadlock, what should be done?

• Something must be done otherwise the system will remain blocked

• Select one of the blocked process and return acquisition call failure

• Which process should be selected– Oldest?– One involved in the most cycles?– One involved in the least cycles?

Other StrategiesOther Strategies

• Have a timeout associated with resource acquisition– Don’t have to do deadlock detection– May timeout when there isn’t a deadlock

• Put the onus on the designer to develop deadlock free algorithms

Bank -> Deadlock FreeBank -> Deadlock Free

• All process agree to acquire resources in a specific order

LivelockLivelock

• More difficult to deal with than deadlock

• Occurs when 2 or more processes change their state in response to each other

• State change has the appearance of doing work (unlike a deadlock) but no computational progress is being made

Okay, where were we?Okay, where were we?

• Started this section out with http server

• Wanted threads to replace fork()• Can’t have an unlimited number of

threads so use a worker pool• Need semaphores to help with the

problem of sharing

HTTP Server Again!HTTP Server Again!

while (1) {accept connection

if (fork() == 0) { perform http request processing} else {

if (too many workers) { wait for worker

Thread Design ModelThread Design Model

Master

threadBuffer

Accept

connections

Insert Request

descriptor Remove

Request

Worker

thread

Worker

thread

Client

Service client

Pool of worker threads

Server Machine

HTTP Server MainHTTP Server Main

main() {setup Socket to listen oninitialize semaphoresstart pool of workerswhile (1) {

accept new connectionprepare requestput request in queue

Worker ThreadWorker Thread

void *worker(void *data)

while (1) {

remove request from queue

service request

close connection

Queue Access RulesQueue Access Rules

Observations:– There is a single queue of requests

accessed by both the workers and main thread

– Queue has a maximum size– Main thread can only add to queue if

there is room– Worker threads can only remove

something from the queue if something is there

ProblemsProblems

• How does the main thread know if the queue is full?

• How do worker threads know if there is work to do?

Try 1: A Single SemaphoreTry 1: A Single Semaphore

• Suppose you had a single semaphore, could one determine if there was work to do?

Semaphore TricksSemaphore Tricks

• The process/thread that does a P() doesn’t have to be the one to do the V()

• Multiple V()’s can be done to increase the semaphore count – This produces a counting semaphore

and can be used when there are multiple units of a resource

Try 2 SemaphoresTry 2 Semaphores

Main ThreadP(nonempty);

Start worker(s)

while (1) {

P(empty);

add req

V(nonempty);

Worker Thread

while (1) {

P(nonempty);

remove req

V(empty);

More Workers and the Queue

• Works if there can be only 1 request• If we allowed N requests should we

have 1 semaphore per request/queue slot?

Try 3 SemaphoresTry 3 Semaphores1. queue – semaphore

• Used to control the shared queue access

2. nonempty – counting semaphore• Initially 0• and indicates non-empty slots

3. empty – counting semaphore• Indicates empty slots initially N• Acquired by main() for each item

Maintaining the QueueMaintaining the Queue

Main Threadwhile (1) {

P(empty);

P(queue);

add req

V(queue);

V(nonempty)

Worker Threadwhile (1){

P(nonempty);

P(queue);

remove req

V(queue);

V(empty);

The Missing MethodsThe Missing Methods

• Status of a thread running or dead• Setting attributes

– Permitted memory usage– Scheduling policy

• Thread specific data• Concurrency control

– Mutexes– Condition variables– Reader/writer locking

When to use fork()When to use fork()

• The task to be performed is logically separate from the “parent’s”

• Protection needed between children• e.g. command execution for a shell

– Shell doesn’t know how long command will take

– Commands are logically separate from the shell

When to use threadsWhen to use threads

• The range of actions to be performed is small

• There needs to be information sharing between the “parent” and “child” or between children

computer science 213 © 2006 donald acton 342 layering yet again! application programs operating...

computer science

donald acton

computer systems

computer protocols

pipe slide

irc slide

htons7891 slide

returns slide

Documents

application layering vs application isolation

patterns and layering

protocol layering

layering & application layer -...

darren sault - sellickconsultants.com.au · • new acton...

scanmaster designer › s3... · application-specific...

light layering

cs 204: layering

wedeco acton pe - xylem inc. · 2019. 8. 20. · model #...

tcp/ip. 2 경북대학교 이동통신망 연구실 layering...

a technical overview of citrix application layering echnica...

layering and division - wakefield ffa...types of artifi cial...

network applications 9/14/2009. 2 outline recap r iso/osi...

air layering portfolio: the process of air layering in...

contour layering project

‘layering cardiff’

laporan pembiakan vegetatif dengan cara merunduk (layering)...

layering with acrylics

part x protocol layering - openloop technologies ·...

incentive layering workshop