Re: Use semaphore for producer/consumer case...

Re: Use semaphore for producer/consumer case...

[Manfred Spraul]

>      consumer()

>             /* Let's wait for 10 items */
>             atomic_set(&sem->count, -10);

That doesn't work, at least the i386 semaphore implementation doesn't
support semaphore counts < 0.

--
    Manfred

Re: Use semaphore for producer/consumer case...

[Stelian Pop]

On Fri, Mar 23, 2001 at 07:34:07PM +0100, Manfred Spraul wrote:
> >      consumer()
> 
> >             /* Let's wait for 10 items */
> >             atomic_set(&sem->count, -10);
> 
> That doesn't work, at least the i386 semaphore implementation doesn't
> support semaphore counts < 0.

Does that mean that kernel semaphore can not be used for something
else than mutual exclusion ?

Stelian.
-- 
Stelian Pop <stelian.pop@fr.alcove.com>
|------------- Ingénieur Informatique Libre --------------|
| Alcôve - http://www.alcove.com - Tel: +33 1 49 22 68 00 |
|----------- Alcôve, l'informatique est libre ------------|

Re: Use semaphore for producer/consumer case...

[Manfred Spraul]

From: "Stelian Pop" <stelian.pop@fr.alcove.com>
> >
> > That doesn't work, at least the i386 semaphore implementation
doesn't
> > support semaphore counts < 0.
>
> Does that mean that kernel semaphore can not be used for something
> else than mutual exclusion ?
>
It's a bit better: counts >= 0 are supported, i.e. you can call up()
before down(), and that's used in several places.

The for loop that Nigel proposed should solve your problem. Multiple
up's are handled correctly.

--
    Manfred

Re: Use semaphore for producer/consumer case...

[Stelian Pop]

On Mon, Mar 26, 2001 at 07:12:55PM +0200, Manfred Spraul wrote:

> > > That doesn't work, at least the i386 semaphore implementation
> doesn't
> > > support semaphore counts < 0.
> >
> > Does that mean that kernel semaphore can not be used for something
> > else than mutual exclusion ?
> >
> It's a bit better: counts >= 0 are supported, i.e. you can call up()
> before down(), and that's used in several places.

I see... it's somewhat different than the classical semaphore 
implementation, but usable anyway.

> The for loop that Nigel proposed should solve your problem. Multiple
> up's are handled correctly.

Now I understand his suggestion. Thanks to both of you.

Stelian.
-- 
Stelian Pop <stelian.pop@fr.alcove.com>
|------------- Ingénieur Informatique Libre --------------|
| Alcôve - http://www.alcove.com - Tel: +33 1 49 22 68 00 |
|----------- Alcôve, l'informatique est libre ------------|

Use semaphore for producer/consumer case...

[Stelian Pop]

Hi, 

I want to use a semaphore for the classic producer/consumer case
(put the consumer to wait until X items are produced, where X != 1).

If X is 1, the semaphore is a simple MUTEX, ok.

But if the consumer wants to wait for several items, it doesn't
seem to work (or something is bad in my code).

What is wrong in the following ?

	DECLARE_MUTEX(sem);

	producer() {
		/* One item produced */
		up(&sem);
	}
	
	consumer() {
		/* Let's wait for 10 items */
		atomic_set(&sem->count, -10);
	
		/* This starts the producers, they will call producer()
		   some time in the future */
		start_producers();
	
		/* Wait for completion */
		down(&sem);
	}

I can get around this by using a mutex and a separate atomic_t 
'count' variable, but it's more a workaround that a solution...

Thanks,

Stelian.
-- 
Stelian Pop <stelian.pop@fr.alcove.com>
|------------- Ingénieur Informatique Libre --------------|
| Alcôve - http://www.alcove.com - Tel: +33 1 49 22 68 00 |
|----------- Alcôve, l'informatique est libre ------------|

Re: Use semaphore for producer/consumer case...

[Nigel Gamble]

On Fri, 23 Mar 2001, Stelian Pop wrote:
> I want to use a semaphore for the classic producer/consumer case
> (put the consumer to wait until X items are produced, where X != 1).
> 
> If X is 1, the semaphore is a simple MUTEX, ok.
> 
> But if the consumer wants to wait for several items, it doesn't
> seem to work (or something is bad in my code).
> 
> What is wrong in the following ?
> 
> 	DECLARE_MUTEX(sem);

For the producer/consumer case, you want to initialize the semaphore to
0, not 1 which DECLARE_MUTEX(sem) does.  So I would use

__DECLARE_SEMAPHORE_GENERIC(sem, 0)

The count is then the number of items produced but not yet consumed.

> 	producer() {
> 		/* One item produced */
> 		up(&sem);
> 	}
> 	
> 	consumer() {
> 		/* Let's wait for 10 items */
> 		atomic_set(&sem->count, -10);
> 	
> 		/* This starts the producers, they will call producer()
> 		   some time in the future */
> 		start_producers();
> 	
> 		/* Wait for completion */
> 		down(&sem);
> 	}

Then consumer could be:

	consumer()
	{
		int i;

		start_producers();

		/* Wait for 10 items to be produced */
		for (i = 0; i < 10; i++)
			down(&sem);
	}


Nigel Gamble                                    nigel@nrg.org
Mountain View, CA, USA.                         http://www.nrg.org/

MontaVista Software                             nigel@mvista.com

Re: Use semaphore for producer/consumer case...

[Stelian Pop]

On Fri, Mar 23, 2001 at 03:52:54PM -0800, Nigel Gamble wrote:

> For the producer/consumer case, you want to initialize the semaphore to
> 0, not 1 which DECLARE_MUTEX(sem) does.  So I would use
> 
> __DECLARE_SEMAPHORE_GENERIC(sem, 0)

You're right that the DECLARE_MUTEX does not (entirely) do the job, 
but I set manually the value of sem->count:
> > 		atomic_set(&sem->count, -10);

> Then consumer could be:
> 		/* Wait for 10 items to be produced */
> 		for (i = 0; i < 10; i++)
> 			down(&sem);

IMHO, this will not work, because the producer could be issuing
more than one 'up(&sem)' at the time...

Stelian.
-- 
Stelian Pop <stelian.pop@fr.alcove.com>
|------------- Ingénieur Informatique Libre --------------|
| Alcôve - http://www.alcove.com - Tel: +33 1 49 22 68 00 |
|----------- Alcôve, l'informatique est libre ------------|