const TAO::ObjectKey &
TAO_Stub::object_key (void) const
{
// Return the profile in use's object key if you see one.
if (this->profile_in_use_)
return this->profile_in_use_->object_key ();
if (this->forward_profiles_)
{
// Double-checked
// FUZZ: disable check_for_ACE_Guard
ACE_Guard<TAO_SYNCH_MUTEX> obj (
const_cast <TAO_SYNCH_MUTEX&>(this->profile_lock_));
// FUZZ: enable check_for_ACE_Guard
if (obj.locked () != 0 && this->forward_profiles_ != 0)
return this->forward_profiles_->get_profile (0)->object_key ();
}
// If no forwarded profiles, just use the base profile
return this->base_profiles_.get_profile (0)->object_key ();
}
static void
test_timed_wait (int nesting_level,
ACE_TEST_MUTEX *rm)
{
// Make sure that we're inside of a recursive level.
if (nesting_level == 0)
test_timed_wait (nesting_level + 1,
rm);
else
{
ACE_OS::srand ((u_int) ACE_OS::time (0));
for (size_t i = 0; i < ACE_MAX_ITERATIONS / 2; i++)
{
int result = 0;
// First attempt to acquire the mutex with a timeout to verify
// that mutex timeouts are working.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) = trying timed acquire on ")
ACE_TEXT ("iteration %d\n"),
i));
ACE_Time_Value delta (1, 0); // One second timeout
ACE_Time_Value timeout = ACE_OS::gettimeofday ();
timeout += delta; // Must pass absolute time to acquire().
if (rm->acquire (timeout) != 0)
{
if (errno == ETIME)
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) = mutex acquisition ")
ACE_TEXT ("timed out\n")));
else if (errno == ENOTSUP)
{
#if !defined (ACE_HAS_MUTEX_TIMEOUTS)
if (!reported_notsup)
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t) %p, but ACE_HAS_MUTEX_TIMEOUTS is not defined - Ok\n"),
ACE_TEXT ("mutex timed acquire")));
reported_notsup = 1;
}
#else
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p - maybe ACE_HAS_MUTEX_TIMEOUTS should not be defined?\n"),
ACE_TEXT ("mutex timed acquire")));
#endif /* ACE_HAS_MUTEX_TIMEOUTS */
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("(%P|%t) %p\n%a"),
ACE_TEXT ("mutex timeout failed\n")));
return;
}
}
else
{
result = rm->release ();
ACE_TEST_ASSERT (result == 0);
}
// Now try the standard mutex.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) = trying to acquire on iteration %d\n"),
i));
result = rm->acquire ();
ACE_TEST_ASSERT (result == 0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) = acquired on iteration %d\n"),
i));
// Sleep for a random amount of time between 0 and 2 seconds.
// Note that it's ok to use rand() here because we are running
// within the critical section defined by the Thread_Mutex.
ACE_OS::sleep (ACE_OS::rand () % 2);
result = rm->release ();
ACE_TEST_ASSERT (result == 0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) = released on iteration %d\n"),
i));
// FUZZ: disable check_for_ACE_Guard
// Basic ACE_Guard usage - automatically acquire the mutex on
// guard construction and automatically release it on
// destruction.
{
// Construct an ACE_Guard to implicitly acquire the mutex.
ACE_Guard<ACE_TEST_MUTEX> guard (*rm);
ACE_TEST_ASSERT (guard.locked () != 0);
// Perform some operation which might exit the current scope
// prematurely, e.g. by returning or throwing an exception.
// ...
// ACE_Guard object is destroyed when exiting scope and guard
// destructor automatically releases mutex.
}
// Use an ACE_Guard to automatically acquire a mutex, but release
// the mutex early.
{
// Construct an ACE_Guard to implicitly acquire the mutex.
ACE_Guard<ACE_TEST_MUTEX> guard (*rm);
ACE_TEST_ASSERT (guard.locked () != 0);
// Perform some operation which might exit the current scope
// prematurely, e.g. by returning or throwing an exception.
// ...
// Release the mutex since we no longer need it.
guard.release ();
ACE_TEST_ASSERT (guard.locked () == 0);
// Do something else which does not require the mutex to be locked.
// ...
// ACE_Guard object's destructor will not release the mutex.
}
// Use an ACE_Guard to automatically acquire a mutex, but
// relinquish ownership of the lock so that the mutex is not
// automatically released on guard destruction. This is useful
// when an operation might not release the mutex in some
// conditions, in which case responsibility for releasing it is
// passed to someone else.
{
// Construct an ACE_Guard to implicitly acquire the mutex.
ACE_Guard<ACE_TEST_MUTEX> guard (*rm);
ACE_TEST_ASSERT (guard.locked () != 0);
// Perform some operation which might exit the current scope
// prematurely, e.g. by returning or throwing an exception.
// ...
// Relinquish ownership of the mutex lock. Someone else must
// now release it.
guard.disown ();
ACE_TEST_ASSERT (guard.locked () == 0);
// ACE_Guard object's destructor will not release the mutex.
}
// We are now responsible for releasing the mutex.
result = rm->release ();
ACE_TEST_ASSERT (result == 0);
// Construct an ACE_Guard without automatically acquiring the lock.
{
// Construct an ACE_Guard object without automatically
// acquiring the mutex or taking ownership of an existing
// lock. The third parameter tells the guard that the mutex
// has not been locked.
ACE_Guard<ACE_TEST_MUTEX> guard (*rm, 0, 0);
ACE_TEST_ASSERT (guard.locked () == 0);
// Conditionally acquire the mutex.
if (i % 2 == 0)
{
guard.acquire ();
ACE_TEST_ASSERT (guard.locked () != 0);
}
// Perform some operation that might exit the current scope
// prematurely, e.g. by returning or throwing an exception.
// ...
// ACE_Guard object is destroyed when exiting scope and guard
// destructor automatically releases if it was acquired above.
}
// Use an ACE_Guard to take ownership of a previously acquired
// mutex.
timeout = ACE_OS::gettimeofday ();
timeout += delta; // Must pass absolute time to acquire().
if (rm->acquire (timeout) == 0)
{
// Construct an ACE_Guard object without automatically
// acquiring the mutex, but instead take ownership of the
// existing lock. The third parameter tells the guard that
// the mutex has already been locked.
ACE_Guard<ACE_TEST_MUTEX> guard (*rm, 0, 1);
ACE_TEST_ASSERT (guard.locked () != 0);
// Perform some operation which might exit the current scope
// prematurely, e.g. by returning or throwing an exception.
// ...
// ACE_Guard object is destroyed when exiting scope and guard
// destructor automatically releases mutex.
}
// FUZZ: enable check_for_ACE_Guard
}
return;
}
}