Introduction to Operating Systemswith Dr. Ramamurthy

Substitution lecture: Project Tips, IPCScott Settembre, TASeptember 21, 2010

Project Tips

• What does a process look like?• Pointers and Arrays? Those are easy!• What is a “segmentation fault”?– Two main issues that you will have– Debugging a segmentation fault

Visualize a Process space

Code

Data

Global variables

Stack

Program Counter (PC)

Code

Line 1Line 2Line 3Line 4…

Code

Data

Global variables

Stack

Code

Line 1Line 2Line 3Line 4…

Where are variables stored?#include <stdio.h>

int a_counter = 1;

int main(int argc, char *argv[]) {

int b_counter = 10;

}

What is a pointer in C?int a = 10;…a++;printf(“%i”,a); 11

int * b;b = &a;…*b++;printf(“%i”,a); 12

printf(“%i”,*b);

12

12

b++;printf(“%i”,a);

printf(“%i”,*b); Possible segmentation fault

“a” is an integer

“b” is a pointer to an integer“b” is now pointing to the location in memory that stores “a”

“b” uses the “*” operator to reference the memory it points to

The address that “b” holds, is incremented by the length of an int

What is an array in C?char c = ‘a’;

char ca[10] = “hello”;

a

h e l l o null ? ? ? ?

char * cb;cb = &ca[0]; “cb” is pointing to the first character of the “ca” char array

printf(“%c”,c); a

printf(“%c”,ca[0]); h

printf(“%s”,ca); hello

printf(“%s”,cb); hello

printf(“%s”,&ca[0]); hello

printf(“%c”,&ca[0]); compiler error

Note: zero term

inated string

automatically done for constant

assignment

How do pointers and arrays relate?

• Easy! In C, a pointer IS AN array and an array IS A pointer!

• Differences?– Using the sizeof() operator for an array will give

the total size of the array, but for a pointer it will give the size of a pointer

– The sizeof() operator is a compiler operator and not a callable function

Code issue : Segmentation Faults

• You get a “segmentation fault” when you:– Try to access memory that you are not allowed in– Change a pointer incorrectly– Pass a pointer to a local variable (remember, local

variables are on the stack and subject to disappearing when the go out of scope)

• “Bus error” is like a segmentation fault, but from misuse of the stack

Example of a “Seg Fault”char * arg[2];const char * alphabet = ”abcdefghijklmnopqrstuvwxyz”;strcpy(arg[0],alphabet);

Visualize arg[2]: char * char *

arg[0] arg[1]

4 bytes

Some other memory…

Visualize alphabet: a

1 byte

b c d e x y z null Some other memory………

strc

py Possible segmentation fault

Some other memory…

Indirect example of a “Seg Fault”char * arg[2];int * fa [100]; // Very important financial dataconst char * alphabet = ”abcdefghijklmnopqrstuvwxyz”;strcpy(arg[0],alphabet);

Visualize our memory layout:

int * int *

arg[0] arg[1]

int * int * int * int *

fa[0] fa[1] fa[2] fa[3]

strc

py

printf(“Scott’s 401K plan value: %i”, *fa[0]); Possible segmentation fault

Advice on debugging faults

• For project 1, most faults are due to:– Not using a char array or allocating memory for a

char * to use– Passing a local pointer back from a function– Not zero-terminating your strings– Parsing a string, storing the beginning of a “token”,

but then using that pointer in a string.h function which expects a NULL terminated string

Inter-process Communication

• Process vs. Thread coding issues– Shared memory, shared resources

• What is an “atomic” instruction?• How can I use a semaphore properly?– Protect with a semaphore– Signal with a semaphore– What is going on behind the scenes?

• Example: Larry, Curly, and Moe IPC problem

Visualize Threads

Code

Data

Line 1Line 2Line 3Line 4…

Thread Pool

PC 1

1 2 3 4

PC 2PC 3PC 4

Visualize Multi-processes

Code

Data

Line 1Line 2Line 3Line 4…

Thread Pool

PC 1

1

Code

Data

Line 1Line 2Line 3Line 4…

Thread Pool

PC 1

1

Atomic instructions// Simple additionint a = 5;a = a + 1; expand this into atomic

instructions 1. Value of “a” from memory into register2. Register gets incremented by 13. Register is put back into memory

Code

Data

a -> rr ++r -> a

a == 5

PC

a == 6

THE Problem that arises

Code

Data

while loop {

a -> rr ++r -> a

}

Thread Pool

PC 1

1 2

PC 2

For example, let’s say:a == 10

There will be a case where:

PC1 runs ‘a->r’ so r==10PC2 runs ‘a->r’ so r==10PC1 runs ‘r++’ so r==11PC2 runs ‘r++’ so r==11PC1 runs ‘r->a’ so a==11PC2 runs ‘r->a’ so a==11

But this is BAD, since two additions occurred!

The value of ‘a’ should be 12!

Concurrency Problem

Semaphore

What is a semaphore?

• A programming object in a multiple process/threaded environment that can:– Restrict access to a common resource– Help synchronize processes/threads

Thread 1

Thread 2

Uses printer buffer

Uses printer buffer

Concurrency Problem

Wait

Wait

Signal

Signal

Blocked

What is a mutex?

• It is a “binary semaphore”– A semaphore with only two states: locked/unlocked– Previous example was a binary semaphore

• Short for “Mutual Exclusion”

• You can always use a binary semaphore in place of a mutex, however, you may want to use a mutex for other reasons

Uses of a semaphore

• Simplistically, you can use a semaphore to achieve two goal perspectives:

– Protect a critical resource/critical section so that only N number of processes/threads can access it at a time

– Signal between N number of processes/threads when it is time for another process/thread can proceed

Use #1 : Protection

Thread 1

Thread 2

Thread 3

Some shared

resource or variable

Semaphore

Wait

WaitBlocked

Blocked

Reads or Writes to variable/resource

Process 1

Process 2

Process 3

Semaphore A

Semaphore B

Semaphore C

Use #2 : Signal

Wait

Wait

Wait

Blocked

Blocked

Blocked

Sign

al

Modify

Signal

Modify

Modify

Signal

Visualize a semaphore

Semaphore

Thread 1

Thread 2

Thread N

…..

Some shared

resource or variable

Current value0 1 2 N…..Wait

Wait

Wait

Blocked

Blocked

Thread modifies the resource or variableSignal

Thread modifies the resource or variableBlocked

Signal

Process “starvation”

• Semaphores do not wake blocked processes in any specific order– In other words, it does not use a FIFO queue– This means, starvation of a process can occur

Visualize a “starvation” scenario

Semaphore

Thread 1

Thread 2

Thread N

…..

Some shared

resource or variable

Wait

Wait

Wait

Blocked

Blocked

Thread modifies the resource or variableSignal

Process “deadlocks”

• Semaphores do not prevent deadlock– They can prevent deadlock, if used cleverly (this

will be discussed more in Lecture – “Dining Philosophers”)

Visualize a “deadlock”

Process 1

Process 2

Some shared

resource or variable

“A”

Some shared

resource or variable

“B”

Wait/Request

Wait/Request

Modify/Assigned

Wait/Request

Wait/Request

Modify/Assigned

Blocked BlockedDeadlock!

Example: Larry, Curley, Moe (LCM) IPC problem

• 3 Farmers named Larry, Curley and Moe

Photo order above is: Curley, Moe, and Larry.

LCM Problem

• There is one shovel• Larry and Moe need to use the shovel to dig• Larry only digs holes• Curley only plants seeds in open holes• Moe only fills holes up after seed planted• Larry can only dig “N” holes ahead of Moe– (Why? Because Larry is attached by chain to Moe.

It is super-comedy-riffic, you see!)

What to understand

• There are three farmers (i.e. three processes)

• Two farmers (i.e. two processes) require the same shovel (i.e. share a resource) to get the job done.

• Farmers can work in parallel, but must also work in sequence– For example: Larry can dig a hole, while Curley plants a

different hole, but they cannot dig and plant the same one.– Also, Curley can plant a hole, while Moe fills an already planted

hole, but they cannot plant and fill the same one.

Visualize LCM

Larry

Curley

Moe

Or we can say, 3 threads running 3 different functions.

Shovel

Or we can say, the shovel is a critical resource (or a critical section).

Think “protect” with a semaphore.

Since only one process can use at a time, think “binary semaphore” or “mutex”.

Holes

Also a critical resource, since for any specific hole, only one farmer can work with it.

However, think “signal” here instead of “protect”. Have the farmers communicate with each other when done with a hole.

Let’s build the code

Larry (digger) Curley (planter) Moe (filler)

Larry digs holewait(Shovel)

signal(Shovel)Moe fills holewait(Shovel)

signal(Shovel)

signal(Curley2go)

wait(Curley2go)

signal(Moe2go)

wait(Moe2go)

Curley plants hole

Hole digging limitation

Larry (digger)

Larry digs holewait(Shovel)

signal(Shovel)

signal(Curley2go)

Let’s pretend Curley and Moe are napping in the field.How many holes would Larry be allowed to dig?

According to the problem, he can only dig N holes ahead of Moe. So if we create a semaphore called “DigHole”, have Larry wait on it, and then signal it N times, he would then dig N holes!

wait(DigHole)

How do we signal the semaphore N times?

We just initialize “DigHole” to have an initial value of N!

The Elegant coding solution

Have 4 semaphores: DigHole = N, Curley2go = 0, Moe2go = 0, and Shovel = 1.

Larry (digger) Curley (planter) Moe (filler)

Larry digs holewait(Shovel)

signal(Shovel)Moe fills holewait(Shovel)

signal(Shovel)

signal(Curley2go)

wait(Curley2go)

signal(Moe2go)

wait(Moe2go)

Curley plants hole

wait(DigHole)

signal(DigHole)

Test tips

• Be sure to understand the LCM IPC problem– There is always some type of IPC problem, but not

usually harder than LCM• Difference between Processes and Threads• Be sure to finish project 1– Review the main system calls– Why you used them