Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Process_Semaphore Class Reference

Wrapper for Dijkstra style general semaphores that work across processes. More...

#include <Process_Semaphore.h>

Collaboration diagram for ACE_Process_Semaphore:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Process_Semaphore (u_int count=1, const ACE_TCHAR *name=0, void *=0, int max=0x7FFFFFFF)
int remove (void)
int acquire (void)
int tryacquire (void)
int release (void)
 Increment the semaphore, potentially unblocking a waiting thread.

int acquire_read (void)
int acquire_write (void)
int tryacquire_read (void)
int tryacquire_write (void)
int tryacquire_write_upgrade (void)
const ACE_sema_t & lock (void) const
 Return the underlying lock.

void dump (void) const
 Dump the state of an object.


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.


Protected Attributes

ACE_Semaphore lock_

Detailed Description

Wrapper for Dijkstra style general semaphores that work across processes.

Definition at line 41 of file Process_Semaphore.h.

Constructor & Destructor Documentation

ACE_Process_Semaphore::ACE_Process_Semaphore (  u_int  count = 1,
const ACE_TCHAR *  name = 0,
void *  = 0,
int  max = 0x7FFFFFFF
) 
 

Initialize the semaphore, with an initial value of count and a maximum value of max.

Definition at line 28 of file Process_Semaphore.cpp.

References ACE_TCHAR, and ACE_TEXT_ALWAYS_CHAR. 

00033   : lock_ (count, USYNC_PROCESS, name, arg, max)
00034 #else
00035   : lock_ (ACE_TEXT_ALWAYS_CHAR (name),
00036            ACE_SV_Semaphore_Complex::ACE_CREATE,
00037            count)
00038 #endif /* ACE_WIN32 || ACE_HAS_POSIX_SEM */
00039 {
00040   arg = arg;
00041   max = max;
00042 // ACE_TRACE ("ACE_Process_Semaphore::ACE_Process_Semaphore");
00043 }

Member Function Documentation

int ACE_Process_Semaphore::acquire (  void   ) 
 

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

Definition at line 63 of file Process_Semaphore.cpp.

References ACE_Semaphore::acquire(), and SEM_UNDO.

Referenced by acquire_read(), and acquire_write(). 

00064 {
00065 // ACE_TRACE ("ACE_Process_Semaphore::acquire");
00066 #if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM)
00067   return this->lock_.acquire ();
00068 #else
00069   return this->lock_.acquire (0, SEM_UNDO);
00070 #endif /* defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) */
00071 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_Process_Semaphore::acquire_read (  void   ) 
 

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

Definition at line 21 of file Process_Semaphore.inl.

References acquire(). 

00022 {
00023   return this->acquire ();
00024 }

ACE_INLINE int ACE_Process_Semaphore::acquire_write (  void   ) 
 

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

Definition at line 31 of file Process_Semaphore.inl.

References acquire(). 

00032 {
00033   return this->acquire ();
00034 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_Process_Semaphore::dump (  void   )  const
 

Dump the state of an object.

Definition at line 18 of file Process_Semaphore.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_Semaphore::dump(), and LM_DEBUG. 

00019 {
00020 #if defined (ACE_HAS_DUMP)
00021 // ACE_TRACE ("ACE_Process_Semaphore::dump");
00022   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00023   this->lock_.dump ();
00024   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00025 #endif /* ACE_HAS_DUMP */
00026 }

const ACE_sema_t& ACE_Process_Semaphore::lock (  void   )  const
 

Return the underlying lock.

int ACE_Process_Semaphore::release (  void   ) 
 

Increment the semaphore, potentially unblocking a waiting thread.

Definition at line 91 of file Process_Semaphore.cpp.

References ACE_Semaphore::release(), and SEM_UNDO. 

00092 {
00093 // ACE_TRACE ("ACE_Process_Semaphore::release");
00094 #if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM)
00095   return this->lock_.release ();
00096 #else
00097   return this->lock_.release (0, SEM_UNDO);
00098 #endif /* defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) */
00099 }

int ACE_Process_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 53 of file Process_Semaphore.cpp.

References ACE_Semaphore::remove(). 

00054 {
00055 // ACE_TRACE ("ACE_Process_Semaphore::remove");
00056   return this->lock_.remove ();
00057 }

int ACE_Process_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 77 of file Process_Semaphore.cpp.

References SEM_UNDO, and ACE_Semaphore::tryacquire().

Referenced by tryacquire_read(), and tryacquire_write(). 

00078 {
00079 // ACE_TRACE ("ACE_Process_Semaphore::tryacquire");
00080 #if defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM)
00081   return this->lock_.tryacquire ();
00082 #else
00083   return this->lock_.tryacquire (0, SEM_UNDO);
00084 #endif /* defined (ACE_WIN32) || defined (ACE_HAS_POSIX_SEM) */
00085 }

ACE_INLINE int ACE_Process_Semaphore::tryacquire_read (  void   ) 
 

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

Definition at line 41 of file Process_Semaphore.inl.

References tryacquire(). 

00042 {
00043   return this->tryacquire ();
00044 }

ACE_INLINE int ACE_Process_Semaphore::tryacquire_write (  void   ) 
 

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

Definition at line 51 of file Process_Semaphore.inl.

References tryacquire(). 

00052 {
00053   return this->tryacquire ();
00054 }

ACE_INLINE int ACE_Process_Semaphore::tryacquire_write_upgrade (  void   ) 
 

This is only here to make the ACE_Process_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 61 of file Process_Semaphore.inl. 

00062 {
00063   return 0;
00064 }

Member Data Documentation

ACE_Process_Semaphore::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Definition at line 129 of file Process_Semaphore.h.

ACE_Semaphore ACE_Process_Semaphore::lock_ [protected]
 

Definition at line 133 of file Process_Semaphore.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:27:25 2006 for ACE by doxygen 1.3.6