static void *
worker (void *)
{
for (int iterations = 1;
iterations <= n_iterations;
iterations++)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_Time_Value wait (0,
iterations * 1000 * 100); // Wait 'iter' msec
//FUZZ: enable check_for_lack_ACE_OS
ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
if (evt.wait (&tv) == -1)
{
// verify that we have ETIME
if (ACE_OS::last_error() != ETIME)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Worker should be ETIME but is")));
}
else
++timeouts;
ACE_Time_Value diff = ACE_OS::gettimeofday ();
diff = diff - tv; // tv should have been reset to time acquired
long diff_msec = diff.msec ();
if (diff_msec > ACE_ALLOWED_SLACK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Acquire fails time reset test\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Diff btw now and returned time: %d ms; ")
ACE_TEXT ("%d allowed\n"),
(int)diff_msec,
(int)ACE_ALLOWED_SLACK));
test_result = 1;
}
// Hold the lock for a while.
ACE_OS::sleep (ACE_Time_Value (0,
(ACE_OS::rand () % 1000) * 1000));
evt.signal ();
}
ACE_Thread::yield ();
}
return 0;
}
void
AMI_Primary_Replication_Strategy::add_member(const FTRT::ManagerInfo & info,
CORBA::ULong object_group_ref_version)
{
ACE_Auto_Event event;
const FtRtecEventChannelAdmin::EventChannelList& backups =
GroupInfoPublisher::instance()->backups();
size_t num_backups = backups.length();
ObjectGroupManagerHandler add_member_handler(event, num_backups+1);
// The extra one is to prevent the event been signaled prematurely.
PortableServer::ObjectId_var oid =
root_poa_->activate_object(&add_member_handler);
TAO::Utils::Implicit_Deactivator deactivator(&add_member_handler);
CORBA::Object_var obj =
root_poa_->id_to_reference(oid.in());
FTRT::AMI_ObjectGroupManagerHandler_var handler =
FTRT::AMI_ObjectGroupManagerHandler::_narrow(obj.in());
for (unsigned i = 0; i < num_backups; ++i) {
try{
backups[i]->sendc_add_member(handler.in(),
info,
object_group_ref_version);
}
catch (...){
add_member_handler.add_member_excep(0);
}
}
// decrement the number of members so the event can be signaled once
// all replys have been received.
add_member_handler.add_member_excep(0);
event.wait();
}
// Tests the amount of time spent in a timed wait.
static int
test_timeout (void)
{
int status = 0;
// milliseconds...
long msecs_expected;
long msecs_waited;
long msecs_diff;
// Wait a little longer each time
static long wait_secs = 3;
ACE_Time_Value wait = ACE_OS::gettimeofday ();
ACE_Time_Value begin = wait;
wait.sec (wait.sec () + wait_secs);
if (evt.wait (&wait) == -1)
{
if (errno != ETIME)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("test_timeout should be ETIME but is")));
status = -1;
}
}
ACE_Time_Value wait_diff = ACE_OS::gettimeofday () - begin;
msecs_waited = wait_diff.msec ();
msecs_expected = wait_secs * 1000;
msecs_diff = labs (msecs_expected - msecs_waited);
if (msecs_diff > ACE_ALLOWED_SLACK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Timed wait fails length test\n")));
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Expected %d ms, actual %d ms; %d allowed\n"),
(int)msecs_expected,
(int)msecs_waited,
(int)ACE_ALLOWED_SLACK));
status = -1;
}
++wait_secs;
return status;
}
int
Simple_Handler::handle_signal (int, siginfo_t *s, ucontext_t *)
{
ACE_HANDLE handle = s->si_handle_;
this->handle_signal_count_++;
if (this->handle_signal_count_ == 1)
this->reactor ()->suspend_handler (event1_.handle ());
else if (this->handle_signal_count_ == 2)
{
this->reactor ()->resume_handler (event1_.handle ());
this->reactor ()->suspend_handler (event2_.handle ());
}
else if (this->handle_signal_count_ == 3)
{
this->reactor ()->remove_handler (event1_.handle (),
ACE_Event_Handler::NULL_MASK);
this->reactor ()->remove_handler (event2_.handle (),
ACE_Event_Handler::NULL_MASK);
}
return 0;
}
int run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("Auto_Event_Test"));
#if defined (ACE_HAS_THREADS)
parse_args (argc, argv);
ACE_OS::srand ((u_int) ACE_OS::time (0L));
//Test timed waits.
for (size_t i = 0; i < test_timeout_count; i++)
if (test_timeout () != 0)
test_result = 1;
if (ACE_Thread_Manager::instance ()->spawn_n
(static_cast<size_t> (n_workers),
ACE_THR_FUNC (worker),
0,
THR_NEW_LWP) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("spawn_n")),
1);
// Release the first worker.
evt.signal ();
ACE_Thread_Manager::instance ()->wait ();
size_t percent = (timeouts * 100) / (n_workers * n_iterations);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Worker threads timed out %d percent of the time\n"),
(int)percent));
if (test_result == 0)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Auto_Event Test successful\n")));
#else
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
ACE_ERROR ((LM_INFO,
ACE_TEXT ("Threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return test_result;
}
void
AMI_Primary_Replication_Strategy::replicate_request(
const FTRT::State& state,
RollbackOperation rollback,
const FtRtecEventChannelAdmin::ObjectId& oid)
{
ACE_Auto_Event event;
Update_Manager* manager = 0;
bool success = false;
FTRT::TransactionDepth transaction_depth =
Request_Context_Repository().get_transaction_depth();
const FtRtecEventChannelAdmin::EventChannelList& backups =
GroupInfoPublisher::instance()->backups();
size_t num_backups = backups.length();
if ((size_t)transaction_depth > num_backups) {
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::TransactionDepthTooHigh\n"));
throw FTRT::TransactionDepthTooHigh();
}
ACE_NEW_THROW_EX(manager,
Update_Manager(event, backups.length(), transaction_depth-1, success),
CORBA::NO_MEMORY());
Request_Context_Repository().set_transaction_depth(0);
for (size_t i = 0; i < num_backups; ++i) {
PortableServer::ObjectId oid;
try{
FTRT::AMI_UpdateableHandler_ptr handler = handler_.activate(manager, i, oid);
FtRtecEventChannelAdmin::EventChannel_ptr obj = backups[i];
// send set_update request to all the backup replicas
obj->sendc_set_update(handler, state);
}
catch (const CORBA::Exception& ex){
ex._tao_print_exception (
"AMI_Primary_Replication_Strategy::replicate_request : ");
manager->handle_exception(i);
if (oid.length())
poa_->deactivate_object(oid);
}
}
// wait until the first transaction_depth replicas replied.
event.wait();
if (!success) { // replication failed, transaction depth too high
for (size_t i =0; i < num_backups; ++i) {
try{
FtRtecEventChannelAdmin::EventChannel_ptr ec = backups[i];
(ec->*rollback)(oid);
}
catch (...){
}
}
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::TransactionDepthTooHigh\n"));
throw FTRT::TransactionDepthTooHigh();
}
}
