ACE_Semaphore Class Reference

Wrapper for Dijkstra style general semaphores. More...

#include <Semaphore.h>

Inheritance diagram for ACE_Semaphore:

[legend]

List of all members.

Public Member Functions
	ACE_Semaphore (unsigned int count=1, int type=USYNC_THREAD, const ACE_TCHAR *name=0, void *=0, int max=0x7fffffff)
	Initialize the semaphore, with initial value of "count".
	~ACE_Semaphore (void)
	Implicitly destroy the semaphore.
int	remove (void)
int	acquire (void)
int	acquire (ACE_Time_Value &tv)
int	acquire (ACE_Time_Value *tv)
int	tryacquire (void)
int	release (void)
int	release (unsigned int release_count)
int	acquire_read (void)
int	acquire_write (void)
int	tryacquire_read (void)
int	tryacquire_write (void)
int	tryacquire_write_upgrade (void)
void	dump (void) const
	Dump the state of an object.
const ACE_sema_t &	lock (void) const
	Return the underlying lock.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Attributes
ACE_sema_t	semaphore_
bool	removed_
Private Member Functions
void	operator= (const ACE_Semaphore &)
	ACE_Semaphore (const ACE_Semaphore &)

---

Detailed Description

Wrapper for Dijkstra style general semaphores.

Definition at line 36 of file Semaphore.h.

---

Constructor & Destructor Documentation

ACE_Semaphore::ACE_Semaphore	(	unsigned int	count = 1,
		int	type = USYNC_THREAD,
		const ACE_TCHAR *	name = 0,
		void *	arg = 0,
		int	max = 0x7fffffff
	)

Initialize the semaphore, with initial value of "count".

Definition at line 32 of file Semaphore.cpp.

  : removed_ (false)
{
// ACE_TRACE ("ACE_Semaphore::ACE_Semaphore");
#if defined(ACE_LACKS_UNNAMED_SEMAPHORE)
// if the user does not provide a name, we generate a unique name here
  ACE_TCHAR iname[ACE_UNIQUE_NAME_LEN];
  if (name == 0)
    ACE::unique_name (this, iname, ACE_UNIQUE_NAME_LEN);
  if (ACE_OS::sema_init (&this->semaphore_, count, type,
                         name ? name : iname,
                         arg, max) != 0)
#else
  if (ACE_OS::sema_init (&this->semaphore_, count, type,
                         name, arg, max) != 0)
#endif
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("ACE_Semaphore::ACE_Semaphore")));
}

ACE_Semaphore::~ACE_Semaphore

(

void

)

Implicitly destroy the semaphore.

Definition at line 57 of file Semaphore.cpp.

{
// ACE_TRACE ("ACE_Semaphore::~ACE_Semaphore");

  this->remove ();
}

ACE_Semaphore::ACE_Semaphore

(

const ACE_Semaphore &

)

[private]

---

Member Function Documentation

int ACE_Semaphore::acquire

(

ACE_Time_Value *

tv

)

If tv == 0 then call <acquire()> directly. Otherwise, Block the thread until the semaphore count becomes greater than 0 (at which point it is decremented) or until tv times out (in which case -1 is returned and errno == ETIME). Note that <*tv> is assumed to be in "absolute" rather than "relative" time. The value of <*tv> is updated upon return to show the actual (absolute) acquisition time.

Note:

Solaris threads do not support timed semaphores. Therefore, if you're running on Solaris you might want to consider using the ACE POSIX pthreads implementation instead, which can be enabled by compiling ACE with -DACE_HAS_PTHREADS, rather than -DACE_HAS_STHREADS or -DACE_HAS_POSIX_SEM.

Definition at line 42 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::acquire");
  return ACE_OS::sema_wait (&this->semaphore_, tv);
}

int ACE_Semaphore::acquire

(

ACE_Time_Value &

tv

)

Block the thread until the semaphore count becomes greater than 0 (at which point it is decremented) or until tv times out (in which case -1 is returned and errno == ETIME). Note that tv is assumed to be in "absolute" rather than "relative" time. The value of tv is updated upon return to show the actual (absolute) acquisition time.

Note:

Solaris threads do not support timed semaphores. Therefore, if you're running on Solaris you might want to consider using the ACE POSIX pthreads implementation instead, which can be enabled by compiling ACE with -DACE_HAS_PTHREADS, rather than -DACE_HAS_STHREADS or -DACE_HAS_POSIX_SEM.

Definition at line 35 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::acquire");
  return ACE_OS::sema_wait (&this->semaphore_, tv);
}

int ACE_Semaphore::acquire

(

void

)

Block the thread until the semaphore count becomes greater than 0, then decrement it.

Definition at line 28 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::acquire");
  return ACE_OS::sema_wait (&this->semaphore_);
}

int ACE_Semaphore::acquire_read

(

void

)

Acquire semaphore ownership. This calls <acquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs.

Definition at line 74 of file Semaphore.inl.

{
  return this->acquire ();
}

int ACE_Semaphore::acquire_write

(

void

)

Acquire semaphore ownership. This calls <acquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs.

Definition at line 84 of file Semaphore.inl.

{
  return this->acquire ();
}

void ACE_Semaphore::dump

(

void

)

const

Dump the state of an object.

Reimplemented in ACE_Thread_Semaphore.

const ACE_sema_t & ACE_Semaphore::lock

(

void

)

const

Return the underlying lock.

Definition at line 8 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::lock");
  return this->semaphore_;
}

void ACE_Semaphore::operator=

(

const ACE_Semaphore &

)

[private]

int ACE_Semaphore::release

(

unsigned int

release_count

)

Increment the semaphore by release_count, potentially unblocking waiting threads.

Definition at line 63 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::release");
  return ACE_OS::sema_post (&this->semaphore_, release_count);
}

int ACE_Semaphore::release

(

void

)

Increment the semaphore by 1, potentially unblocking a waiting thread.

Definition at line 56 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::release");
  return ACE_OS::sema_post (&this->semaphore_);
}

int ACE_Semaphore::remove

(

void

)

Explicitly destroy the semaphore. Note that only one thread should call this method since it doesn't protect against race conditions.

Definition at line 15 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::remove");
  int result = 0;
  if (!this->removed_)
    {
      this->removed_ = true;
      result = ACE_OS::sema_destroy (&this->semaphore_);
    }
  return result;
}

int ACE_Semaphore::tryacquire

(

void

)

Conditionally decrement the semaphore if count is greater than 0 (i.e., won't block). Returns -1 on failure. If we "failed" because someone else already had the lock, errno is set to EBUSY.

Definition at line 49 of file Semaphore.inl.

{
// ACE_TRACE ("ACE_Semaphore::tryacquire");
  return ACE_OS::sema_trywait (&this->semaphore_);
}

int ACE_Semaphore::tryacquire_read

(

void

)

Conditionally acquire semaphore (i.e., won't block). This calls <tryacquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, errno is set to EBUSY.

Definition at line 94 of file Semaphore.inl.

{
  return this->tryacquire ();
}

int ACE_Semaphore::tryacquire_write

(

void

)

Conditionally acquire semaphore (i.e., won't block). This calls <tryacquire> and is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Returns -1 on failure. If we "failed" because someone else already had the lock, errno is set to EBUSY.

Definition at line 104 of file Semaphore.inl.

{
  return this->tryacquire ();
}

int ACE_Semaphore::tryacquire_write_upgrade

(

void

)

This is only here to make the ACE_Semaphore interface consistent with the other synchronization APIs. Assumes the caller has already acquired the semaphore using one of the above calls, and returns 0 (success) always.

Definition at line 114 of file Semaphore.inl.

{
  return 0;
}

---

Member Data Documentation

ACE_Semaphore::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Reimplemented in ACE_Thread_Semaphore.

Definition at line 155 of file Semaphore.h.

bool ACE_Semaphore::removed_ [protected]

Keeps track of whether remove() has been called yet to avoid multiple remove() calls, e.g., explicitly and implicitly in the destructor. This flag isn't protected by a lock, so make sure that you don't have multiple threads simultaneously calling remove () on the same object, which is a bad idea anyway...

Definition at line 168 of file Semaphore.h.

ACE_sema_t ACE_Semaphore::semaphore_ [protected]

Definition at line 161 of file Semaphore.h.

---

The documentation for this class was generated from the following files:

• Semaphore.h
• Semaphore.cpp
• Semaphore.inl