FAQ for Semaphores & Shared Memory Based Projects

FAQ for Semaphores & Shared Memory Based Projects

Unions and their use.....
What you want is:
```
        union semun {
            int val; 
            struct semid_ds *buf;
            ushort_t *array;
        };
```
without the "arg". That defines the type but doesn't create a variable; you can then use it:
For SETVAL, the fourth argument to semctl must be a thing of type semun. Thus, you have to define semun (almost as you did) and then write:
```
        union semun x;
        x.val = 1;
        semctl(mysem, 0, SETVAL, x);
```
On a lot of machines, it would work just fine to write "1" in place of x. Not on Turing. On a Sparc, there's a huge difference between passing an integer and a union.

What state does a Phil start out in?
thinking
Please correct me if I'm wrong, but it seems like, as a philosopher, we don't really need to enter mutual exclusion when changing our own state from thinking to hungry, because this transition really has nothing to do with putting down or snatching up a fork. So the two states are indistinguishable from the point of view of other philosophers looking for forks, and as long as the waiter enters mutual exclusion when reading the states, the output table should not be affected.
I think that it does matter because if the philosopher process reaches the critical section first then the waiter may still access the state array while the philosopher is updating his state. You don't want the waiter trying to read the state array while one of the philosophers is modifying it.
If the waiter uses a mutex, this does not prevent the philosopher from accessing data if he is not using a mutex. Semaphores only work if everyone is using them! That said, as long as the waiter only reads each entry in the state table once per print cycle, then the output should be fine as long as he uses a mutex to prevent the eating values from changing. The philosophers shouldn't need to use a mutex to change to the hungry state (although it wouldn't hurt I guess.)
you "probably' could get away with not using mutex's to control changing your own state from thinging to hungry, but:
- you will occasionally be off on your counts, e.g., you are going from hungry to thinking. when the waiter makes up the totals you are hungry, when he prints out the entire state table you are thinking. therefore what is printed out is inconsistent.
- in general you are playing with fire if you are not consistent on using mutexes. you will eventually get burned, and while in the phils nothing serious happens, in things like air traffic control it matters
Modulus Operator
It turns out that the line given to us in the pseudo code on the worksheet:
```
  #define LEFT (i-1)%phils
```
can cause a lot of trouble. If there are 'phils' philosophers, and you want to see who sits to the left of philosopher zero, you would hope to get philosopher 'phils-1'.
However, (0-1)%phils evaluates to -1. This could be a big problem when, say, you try to check if philosopher -1 is eating before you pick up your forks.
In the same (pseudo)code, LEFT is defined to be (i-1)%N. When i=0, GCC (for some strange reason), evaluates -1%N to be a negative number. To get around this, define LEFT to be (i+N-1)%N. This should wrap around the other end.
```
    When i=0, GCC (for some strange reason), evaluates -1%N to be a
    negative number.
```
It's actually not gcc, it's the hardware. This option is blessed in the C/C++ standard, and is arguably the correct behavior.
X mod Y is defined as the remainder of X when divided by Y. Most machines implement modulus to satisfy the following equation:
```
    
        X = Q * Y + R
```
Q is the value returned by integer division, and R is the remainder returned by integer modulus. For example, 16 = 5 * 3 + 1 for 16/3 and 16%3. For negative numbers and integer division that truncates toward zero, that implies a negative modulus:
```
        -1 = 0 * 5 + (-1)
        -6 = -1 * 5 + (-1)
```
To get a positive modulus, you need integer division that truncates towards minus infinity:
```
        -1 = -1 * 5 + 4
        -6 = -2 * 5 + 4
```
Creating Shared Memory
shmat will return a pointer to the attached memory, but that memory has no structure. you need to cast the return value to a pointer corresponding to your data structure. After that you can use your the address returned as a pointer to a data structure.
e.g.
```
struct Mesg
{

}

shmid = shmget(../.....)

mesgptr = (struct Mesg *) shmat(shmid, (char *) 0, 0)
```
Through mesgptr shared memory can now be used as a structure, ie., the structure you created to be shared. I believe that you need the caste (struct) to get it to compile.
warning: ANSI C++ forbids implicit conversion from 'void *' in argument
Is there a way to avoid the warning: ANSI C++ forbids implicit conversion from 'void *' in argument passing
when using the shared memory detachment statement:
```
shmdt((void *) stuff);
```
So it's warning you that ansi c++ won't convert your void* to the required char*. You can cast your stuff variable to a char* instead of a void* to get rid of the warning. I think the key thing to realize is that Solaris shared memory is getting you an array of bytes, while your program is using a structure.
void* is a generic pointer (an address without a type associated with it). They use it in the documentation because they don't know what kind of pointer you'll be using. You can assign any pointer to void*, but you have to cast it when you assign the void* to another pointer.
a void * is a pointer to a memory area. You can treat it as a buffer that is castable to whatever type you'd like. In the linux implementation it's a char *, but a void * is more general.
Semaphore Initialization
In the OS book, Tanenbaum creates a semaphore for each philosopher, but does not initialize them. You should probably initialize.
Shared Memory Attachment
Shared memory does not need to be reattached by a child process if it has already been attached by the parent before the fork.

Semaphore Creation
In Solaris semaphores are allocated as a structure. for example, if you need 10 semaphores, then you would ask for that number of semaphores to begin with. thus you might do something like the following:

int mutex;

mutex = semget(key, nsems, semflag)

mutex    - holds the id of your semaphore structure
key      -  i forget exactly what key is, someone else tell the class
nsems    - the number of semaphores you are requesting
semflag  - what you are trying to do with the semaphores, to create use
           IPC_CREAT | O644  - this creates and sets the semaphores so
           they can be easily destroyed - see project description.
           Don't forget this zero!  The number O644 is in octal.

Semaphore Use
In Solaris, you do not just do a signal or a wait. rather, in Solaris you pass a semaphore structure for a semaphore operation request.
semop is the call:

semop(semid, address, numsems)
semid - your semaphore set id, mutex from above.
address - the address of the structure that contains the operations
for each semaphore to be changed.
numsems - number of semaphores in that structure.
where the structure looks like:

sem_num - the particular semaphore number, from 0 - N
sem_op - the operation on that semaphore
sem_flg - whole bunch of options, 0 is the usual case.

thus an example:

// create a semaphore set with 1 semaphore
mutex = semget(semkey, 1, 0644|IPC_CREAT)

// up()   -  V operation

void up()
{
// structure to be sent
   struct sembuf s;
       s.sem_num = 0;
       s.sem_op = 1;
       s.sem_flg = 0;
   
   semop(mutex, &s, 1)
}

Keys
Unless there is some particular key you just need to have, I'd recommend using:

        #define FILE "/tmp/my-data-file"
        #define RANDOMCHAR 'H'
        int key;
        key = ftok(FILE,RANDOMCHAR);

If ftok is given the same file and random character each time, it will return the same key (but things mess up if the file is deleted and then created again because ftok uses the inode number of the file in part of its calculation). With this, multiple processes can get use of the

   shmctl(shmid, IPC_RMID, (struct shmid_ds *) 0 )

sending a 0 pointer that is a pointer to type shmid_ds, which is the structure created for your shared memory.

More Keys

getuid() << 8

.br Creates a unique ID for every person. If you add a static int to this (and increment it for each new request) you can have all of you system resources linked to your user ID. And since everyone else is guaranteed to have a different user ID, your semaphores and shared memory won't be tampered with. The 8-bit shift is more than sufficient because each user can only grab a small number of semaphores. But just in case someone does, it might be a good idea for the second parameter to shmget, to use (IPC_CREAT | 0644) -- this can also be used as the third parameter to "semget".

Problems getting the Barber Shop code to run on Linux:
Error Messages:

 packrat:~/cs110/test> make
 g++ -g -Wall -pedantic   -c semaphore.cc -o semaphore.o
 semaphore.cc: In method `bool semaphore::FreeSem()':
 semaphore.cc:148: conversion from `int' to non-scalar type `semun'
 requested
 semaphore.cc: In method `bool semaphore::SetVal(int)':
 semaphore.cc:174: `semargs' undeclared (first use this function)
 semaphore.cc:174: (Each undeclared identifier is reported only once
 semaphore.cc:174: for each function it appears in.)
 semaphore.cc:177: confused by earlier errors, bailing out
 make: *** [semaphore.o] Error 1

This code compiles fine on turing.
Yes, from the line 148 error it looks like something I found while in 110. Solaris doesn't define something that Linux does, so you have to do it by hand.

#ifdef SOLARIS
union {
  int val;
  struct semid_ds *buf;
  ushort *array;
} semctl_arg;
#endif
#ifdef LINUX
semun semctl_arg;
#endif

If I wanted to make an array of buffer in shared memory, would I do it this way to get the space?
Arraylength is the length of the array. Empirically it seems to work. You then just use array notation to access this memory. I am wondering if there is another way of if you just hack it this way.

  //get the memory
   bufferId = shmget (ftok (".", generate_number),
                    arraylength * sizeof (buffer), (IPC_CREAT | 0664));

You say that you want a robust solution to barber shop. Do we need to handle the problem of someone already using the sem value that we would like to grab through semget?
Yes

I was wondering about counting consistency in counting up the empty and occupied seats.
For these values, I simply outputted the values of the two counting semaphores I am using in my implementation, one which track each value. However, since a process will down one in the beginning and up the other in the end of the updating procedure, it is possible for the total count to be 19 instead of 20 without there being any problem (from what I understand, anyway). Of course, the alternative is to have separate counters that are incremented and decremented at the same time, respectively. However, that seems less useful than outputting the counting semaphores.

So, basically, the question comes down to: given the above information, is it okay that my empty seat count and occupied seat count don't always add up? Would you prefer a counting method that would always add to 20 (although I don't see an implementation of that that would be helpful)?

Answer Either way works. You need to document your output to indicate why the numbers are not always '20'.

Can we assume our input is well-formed?
i.e., we'll always get a two-digit number, and the first digit will always be between 0-2, and the second digit between 1-5? If we can't assume this, what kind of behavior do you want the program to have? Should the sergeant just ignore mal-formed input, or try to print some thing to cerr, or what?

Answer Yes, the input is well formed. The arguments to the program may not be.

A few questions:

The whole circular buffer thing. You want each queue to be circular, correct? In other words, if it has a head and tail then the tail links into the head? What I found is that you really don't have to do this for you code to work, but you still want it this way, correct?
Answer Yes, circular queues because that ensures that you maintain order of the people entering the barbershop. I assume there are many ways to maintain such order, but circular queues are the 'best' :-) Realize that once you start this sucker running, the circular queues slowly dement themselves to ordered linked lists. When we talk about free lists for disk drives, someone might point this out../....

Printing out the barber shop. You want to see each chair, what rank is in that chair, and who follows them, correct?

Answer Yes, there are so many ways to do this that the above is probably the best statement of purpose. for example:

  
grunts
   1  8  9 19 11
  
noncoms
   2  6  10  12 14
  
etc:
  
  
or
    
    1  2  3  4  5  6  7  8  9  10 11  12 13 14 15 16 17 18 19 20
    g  n     n           g  g  n  g   n     n               g
next8                    9  19    0                         11

If a grunt is promoted to noncom status, does he now count as a noncom towards the number of noncoms waiting and final noncoms output count?

Answer No. once a grunt, always a grunt../...

Do you want us to change our display of the contents of the Queue?
as in, indicate which grunts have non-grunt priority? i know you want us to give some info in the totals screen, but i didn't see anything about it for the contents of the buffer.

Answer
This is by design a little unclear, but what i need to be able to see is the position of each grunt in the queue. So depending on how you show queue position this could be done a number of ways. However you do it, you need to be able to show via the printout where each grunt is in the queue.

I was wondering if when someone got their hair cut, did they get it cut in the chair they were sitting in, or some external chair?
Namely, do they stay in the list of 20 or leave it while getting their hair cut?

Answer
There is a barber chair.

I've been asked by cs110 students which man pages to look at for dining philosphers. I found the following pages useful when I took 110:

semaphores:
- semget(2)
- semctl(2)
- semop(2)
shared memory:
- shmget(2)
- shmctl(2)
- shmop(2)
System V IPC in general:
- ftok(3c) (if you wish to use ftok, which I recommend)
- intro(2)
- types(5)
- ipcs(1)
- ipcrm(1)
Note: The number in parentheses is the "section number" which represents which section of the printed manual contains the page in question. When viewing manual pages on the computer, you sometimes need to use the "-s" command to specify the desired section. You can use the "whatis" command to find out what sections contain pages with a particular name. If there's only one page with the name (as should be true for all pages above except intro) then you can leave out the section number. For all of you Linux & BSD users out there, note that the System V version of man requires "-s" when you specify the section, unlike the GNU and BSD versions.
Also, if you wish to print a man page, you can use the "-t" flag. This will cause the output to go the printer as nicely formatted PostScript.
How to make the hungry state last at least 3 seconds when using the algorithm handed out in class. This requirement is no longer used, because it required changes to the book Algorithm.
I took a look at it and noticed that there is definitely a problem with this requirement. the problem comes in the test() function, which sets the state of a philosopher to EATING. The problem is that if the philosopher is sleeping while in the HUNGRY state, then someone else calling test() will cause it to be marked EATING even though it's still doing its sleep(). So the waiter will still print out E for that philosopher, even though that philosopher thinks he is hungry. The end result is that you still have the problem of not seeing the HUNGRY state on printouts, and the printouts will show them EATING longer than they are supposed to. My first attempt to fix this was to move the "state[i]=EATING" statement out of test() and into take_forks(). But then the problem is that if test() is called on i followed by i+1, then i will be told it can eat (by upping its semaphore) but it won't be marked as EATING. So then when test(i+1) is called, it won't see that i is marked as EATING, so it will tell i+1 to eat. so you can get two adjacent philos eating with the same fork. oops. To fix this for real, I ended up having to make a new state called WILLEAT. I changed test() to check for WILLEAT instead of HUNGRY and changed take_forks so that it changes its state to WILLEAT immediately after the call to sleep(). Then, I have the waiter print "H" for both HUNGRY and WILLEAT. This works, although it's a big ugly. I can't see any other way to get correct behavior when using the algorithm handed out in class. It might be possible to get correct behavior from a different algorithm, but I expect most people will try to use the one you handed out. the problem is that HUNGRY is really just a new thinking state. in the original statement of the philosopher problem, HUNGRY means that the philo will eat as soon as he possibly can. In this new version, that's not true. Instead, he just has two different thinking states, followed by the old hungry state (now called WILLEAT). As before, the real hungry state (now WILLEAT) will not necessarily show up on the printout because it could take only a few microseconds. But this is covered up in the printout by printing the same thing for HUNGRY (thinking round 2, really) and WILLEAT."

I've just submitted my code for project 3, and ftok isn't working for me. It returns -1 regardless of how I set up the file and number inputs to it. How can I fix this? Thanks.
Works fine for me. Did you run ./sems in the same directory where semaphore.c exists? (The number returned by ftok was negative, but it wasn't -1.)
The general approach for this kind of problem is to look at the value of the global "errno". An easy way to do that is with strerror. For example:
```
   
 #include 
 #include 
  // ...
 id = ftok(...);
   if (id == -1) {
      cerr << "ftok failed: " <<
      strerror(errno) << endl;
   }
```
If that doesn't make it clear, then look at the man page. The man page gives errors in terms of their abbreviations, such as ENOENT. To translate those into the English used by strerror, look in /usr/include/sys/errno.h. The comments in that file are precisely the messages generated by strerror.

Are we expected to determine if the arguments are valid integers? As far as I can tell, this is non-trivial, given the way atoi() and its cousins are designed. Can you give any pointers if we have to do this?
Don't bother. Seriously invalid integers are usually converted to zero. (More accurately, they're converted to their integral prefix.) Just take the result of atoi and check that for validity as if it were an integer -- i.e., if 0 is illegal, reject it, otherwise accept it as if it were 0.

Last modified Aug 28, 2002 by mike@cs.hmc.edu