Using semaphores

[Andre S. Veteran]

Hello, this is the first time I need to use semaphores, yes it is for an assignment. I have trouble wrapping my head around the concept. Come to think of it, wrapping a solid spheroidal body around an idea isn't trivial by itself, but anyway I disgress.

I have to write a little program that simulates a network. There are several computers in the network. Only one computer can be executing at any given time, and they must execute one after the other. Also, each computer is responsible for telling the "next" computer that it is its time to execute.

I am supposed to use semaphores to synchronize this. Now I don't see really how can semaphores help me do this. My first idea would be to make a "cycle" object, protected with a mutex, so only one computer can own the cycle at any given time. The computer could write in a global variable the id of the next computer and unlock the mutex when it's done. However, we're supposed to use semaphores, not mutexes.

Oh and it's POSIX semaphores and pthreads btw.

Thanks.

[ViZioN]

I only covered semaphores on my course a few weeks back but I think the basic principle is the same as the mutex in that it creates a critical region that only one thread/process can access at one.

For example:

You spawn 2 threads to carry out some job, but only one can execute at the one time. Initially you set the semaphore to 1.

The first thread to call wait(sem) decrements the semaphore and is allowed to continue. The slower of the two threads is blocked at the wait statement because sem cannot be < 0. When the first thread is finished the work it is to carry out, it performs a signal(sem) which increments the semaphore, allowing the second thread to decrement it, and continue. This could also be looped so they can pass it back and forth between them. You will probably need a small wait after the signal though however to ensure that the other thread has enough time to perform the wait.

Think that's right. Hope it helps.

[Andre S. Veteran]

Thanks, it doesn't seem that difficult. I just spent the day trying to get most of the boilerplate code out the way, and I'll probably be back with questions in a few days. I love programming but man it's so time-consuming. :p

[ViZioN]

I'm no expert but I'll try and help if I can. You're right about time consuming though. Some days you get lots done for what seems like little effort, other days you sit for hours trying to fix the smallest thing.

[Brandon Live Veteran]

Hmm, so you know how to do this using a mutex but not a semaphore? A mutex is basically just a binary semaphore. Of course since you said you need to control the order, right? As in there's a specific ordering to the "computers" and you want to loop through each, activating them in sequence? So couldn't you just have each node in the network provide its own semaphore that it blocks on until the preceding node signals it?

Or are you supposed to using a counting semaphore somehow, or only signal computers that have requested to be called when its their turn?

[TheRealDave]

Semaphore is very systematic. I had to learn it a while ago and it is quite easy. Just practice!

[Andre S. Veteran]

  Quote

Hmm, so you know how to do this using a mutex but not a semaphore? A mutex is basically just a binary semaphore.

Well I know how pthread_mutex works but I never used semaphore.h. Also, I understand the concept of a mutex (locking/unlocking a resource), but I don't get the concept of a "non-binary" one. What, so you can lock the resource a certain number of times before it's, uh, really locked? :unsure:

  Brandon Live said:

Of course since you said you need to control the order, right? As in there's a specific ordering to the "computers" and you want to loop through each, activating them in sequence?

Yes exactly. It should go like this :

Computer 1 does cycle #1

Computer 2 does cycle #1

Computer 3 does cycle #1

Main thread does some checking routine

Computer 1 does cycle #2

Copmuter 2 does cycle #2

etc.

Each computer is its own thread.

  Quote

So couldn't you just have each node in the network provide its own semaphore that it blocks on until the preceding node signals it?

Can you explain your idea a bit further please ?

  Quote

Or are you supposed to using a counting semaphore somehow, or only signal computers that have requested to be called when its their turn?

It just says "use semaphors to order the computers". Edited March 22, 2009 by Dr_Asik

[ViZioN]

  Dr_Asik said:

  Quote

So couldn't you just have each node in the network provide its own semaphore that it blocks on until the preceding node signals it?

Can you explain your idea a bit further please ?

I think he means that the first task signals the semaphore for task 2 so it can begin.

Maybe something like this?

Thread 1

task1 = 1;

wait(task1);

signal(task2);

Thread 2

The task2 semapohre is initially set to 0 until it is signalled from thread 1, so thread 2 blocks at the wait statement.

wait(task2);

.

.

.

.

signal(task3);

etc.

[ekw]

Relinquishing the semaphore key is not a good idea, whos to say computer 3 wont get the key when its computer 2 that wants it.

C subroutines to checkout

sem_post(), sem_wait()

signals.h

in this u can do something like kill(PID, SIGINT); which will send the pid(computer#) a signal interrupt.

..
	signal(SIGINT, s_handler);
...

void s_handler(int sig)
{
	   switch(sig)
	   {
		case SIGINT:
			 //grab key and begin execution
		 }
}

once u set up the signals to recieve sigint, you can communicate with processes to grab the semaphore key instead of all processes waiting for it.

[Andre S. Veteran]

  ekw said:

(snip)

Thanks, but I can't uses processes, I must use threads. Hence the use of semaphores.

I'll be trying to implement ViZion's solution tonight, I'll tell you guys how it's been or if I have any questions.

[Andre S. Veteran]

Ok it was really simple and it worked exactly as advertised. Thank you all very much !

[ViZioN]

Sweet glad it worked out OK. I haven't had to use them in any work yet but they don't look too difficult :)

[Brandon Live Veteran]

You're welcome :p

[vks87]

I never heard about semaphores so that' s why i searched on it and finally i got the this link..:

http://publib.boulder.ibm.com/infocenter/i.../apiexusmem.htm