#include <semaphore.h>

Add the following declaration and global variables, before the 'struct try_n_buy' (line 24):

//---------------------------------
// *** SEMAPHORES
#define SEM_FITTING 3
#define SEM_STORE 0
#define SEM_PAY 2
//---------------------------------
// semaphores as global variables
sem_t* sem_fitting;
sem_t* sem_store;
sem_t* sem_pay;

The '#define's value serve as initial values for the semaphore.

The sem_t variables, serve as pointers to the semaphores.

Note: these variables don't really need to be global. It's just simpler in this demo.

Two options: (a) we pass them as arguements (b) each son-process opens the semaphores by himself.

It's fairly intuitive to understand the values of SEM_FITTING and SEM_PAY. However, what's the meaning of " #define SEM_STORE 0 "?

(We'll get back to this in a little while).

• one is in memory - which we will not use in this lab, because they require shared memory.
• The other one is "named semaphore" - i.e. the semaphore has a name (again, just like a file has a name). the name is "/<someting>" (slash followed by some name). For example, "/sem_fitting".

Note: at this phase we will NOT add a semaphore for the storage.

Modify the code, initialize (create) the semaphores

We already have this prototype defined: (line 55): [the function itself is empty/dummy)

//prototype:
void open_all_sem(void);
//--------------------------

We need to add the following code of the function open_all_sem().
This function is at the bottom of the file. It is currently "dummy". Add the following code:

void open_all_sem(void)
{
	sem_fitting = sem_open("/sem_fitting", O_CREAT, S_IRWXU, SEM_FITTING); 
	if (sem_fitting == SEM_FAILED)
	{
		perror("failed to open semaphore /sem_fitting\n");
		exit(EXIT_FAILURE);
	}

	sem_pay = sem_open("/sem_pay", O_CREAT, S_IRWXU, SEM_PAY); 
	if (sem_pay == SEM_FAILED)
	{
		perror("failed to open semaphore /sem_pay\n");
		exit(EXIT_FAILURE);
	}
}

Add the call to open_all_sem

Add the follwing call:

// call to the function
open_all_sem();
//--------------------------

• "/sem_fitting" - the name of the semaphore.
• O_CREAT - create this semaphore, if it does not exist.
• S_IRWXU - permissions. Similar to file permissions [ when calling open() ]. Here we give all permissions, i.e. READ-WRITE-EXECUTE to the USER who runs this process(the 'X' for eXecute is meaningless).
• SEM_FITTING - (integer) initial value.

Instructions:

1. Add the prototype of open_all_sem().[ do nothing, it's already there ]
2. Add the function (e.g. at the bottom of the file).

3. Add actual calls to the semaphore

There are two basic operations we can do on the semaphore:

1. wait - call to sem_wait(...)
2. post - call to sem_post(...) (this is also known sometimes as signal).

Add the following calls in the "right place":

	sem_wait(sem_fitting);
	sem_post(sem_fitting);
	sem_wait(sem_pay);
	sem_post(sem_pay);


So, what is the right place?
we call 'wait' before we use the resource, and we call 'post' or 'signal' after we are done using the resource. So, in our case, call sem_wait(sem_fitting) before we enter the fitting room, and sem_post(sem_fitting) right before we leave this room.

Note: we are using the global variables here. So we don't have to pass them as arguments.

4. Compile and Run

Note: We need to add a special flag to the compilation - either -lrt (it didn't work for me) or -pthread.


gcc -Wall -pthread shop.c -o shop
./shop shopper.txt3

Or you can run the following commands:


# or run the following
./shop shopper.txt3 > sem_a.log3
grep --color fitting sem_a.log3
grep --color pay sem_a.log3

Verify that at most 3 shoppers are in the fitting room and at most 2 shoppers are paying in parallel.

Show/Hide screen-shots







5. Add semaphore for the storage room

Recall that the storage room can serve at most one customer.
Furthermore, it is not open right away when the shop is open, so the initial status of the semaphore is zero. That's why we have the following #define:


#define SEM_STORE 0

---


We need to add the following code to shop.c (but wait a minute with the editing):
1. In function open_all_sem:



	if (sem_unlink("/sem_store")==0)
		fprintf(stderr, "successul unlink of /sem_store\n");
	sem_store = sem_open("/sem_store", O_CREAT, S_IRWXU, SEM_STORE); 
	if (sem_store == SEM_FAILED)
	{
		perror("failed to open semaphore /sem_store\n");
		exit(EXIT_FAILURE);
	}	



2. The function: get_from_store:

Show/Hide the function: get_from_store





3. The function: return_to_store:

Show/Hide the function: return_to_store



מה עושה הפונקציה sem_trywait ומה ההבדל בינה לבין הפונקציה sem_wait ?

ראשית, תשובת בית-הספר היא כמובן לקרוא ב man-page. עשו את זה!

בקצרה, הקריאה sem_wait היא קריאה חוסמת. אם הערך של הסמפור הוא אפס, אנחנו נחסמים עד שערכו יעלה (כלומר, מישהו עשה sem_post). יתכן, שאנחנו לא רוצים להחסם, עבור זה נועדה הקריאה sem_trywait. אם ערכו של הסמפור גדול מאפס, אז לא נחסם, הסמפור יקטן ב-1, בדיוק כמו wait. לעומת זאת, אם ערכו הוא אפס, אזי נחזור מיד, ונקבל אינדיקציה על כך, באמצעות הערך המוחזר מהפונקציה.

6. Update the code and compile

You don't need to edit the code of shop.c. Simply copy the file as shown below:


cp  shop.c-3 shop.c
gcc -Wall -pthread shop.c -o shop

Question:
We are going to run the program. How do you expect it to behave?

Run the following command:


./shop shopper.txt3


What's going on?

7. Examine the 'processes'

While our program seems to be stuck in one terminal, open another terminal , and run the command 'ps'. 'ps' stands for 'process status'. It has tons of options, we'll use the basic form:


ps u
# or the following form:
ps u -H

Do you see something similar to the following screenshot?

Show/Hide the 'ps' screenshot

Note: in the past the name of the program was shoe_store , now it is shop, so you'll see something very similar except for this diff.



Note:
Arrange the two terminals on the screen so that you can see both of them.

8. Start the storage guy

The store guy is kind of lazy. We're stuck because we wait for him to start working (open the store).

In terms of S/W - what is the meaning of that?

We want him to signal that it's ok to get into the storage. i.e. to post or signal the /store semaphore.

1. Examine the code of the file start.c (it's short).
2. compile. Run the following command: (on the second terminal... the first one is still stuck)



gcc -Wall -pthread shop_start.c -o shop_start


Make sure you see both terminals. In one terminal, our program is stuck.. or waiting for some event to happen... On the other terminal, you just compiled start.
3. Now it's time to run this program:



./shop_start

Observe what is happening. Explain.

9. Rerun the program

Suppose we want to rerun the program. Do we need to start the store again?

First think, and then Rerun and observe.

Apparently we're stuck again. Rerun the start.

Qustion: We can run the following command from the bash. Is this going to help?


./shop_start ; ./shop shopper.txt2

10. Remove the sem_unlink

Comment out the following lines, in the function open_all_sem (line ~274 and on):


	if (sem_unlink("/sem_fitting")==0)
		fprintf(stderr, "successul unlink of /sem_fitting\n");
	................
	if (sem_unlink("/sem_store")==0)
		fprintf(stderr, "successul unlink of /sem_store\n");	

What is going to be the impact of that?

Save and compile.

Run again the above combined command, i.e.


./shop_start ; ./shop shopper.txt2

11. Removing the semaphores - from another program

If we did not remove the semaphores (by running sem_unlink) they stay in the kernel - for good... Well, not for good, only until we reboot the machine. This will be clarified and demonstrated by the discussion below.

The program might get stuck now. In such a way, that even if you run ./shop_start will not help.

If this is the case, compile and run the program unlink_sem:


# see the code of the program
cat unlink_sem.c  
#compile it
gcc -Wall -pthread unlink_sem.c -o unlink_sem
#run it
./unlink_sem

Now you can rum shop (run shop_start after launching shop).

You should be able to run shop consecutively.

This is good. Why it happens? Because the previous run of start left the store semaphore, in the value of 1. So, because we did not remove the semaphore (by calling sem_unlink) we can continue with the same semaphore.

This raises a question: is this really how we want the program to behave?

12. Abnormal termination of the program

Another question: suppose the program does not terminate normally... there was "core dump". Or the program was killed by CNTL+C, or by "kill" command... what will happen?

You can try this - run the program, and kill it with CNTL+C. Now run it again, it's probably stuck. Now, even if you run start - won't help. You'll need the clean up the semaphores (run ./unlink_sem ), and start over again.