int Reader_Task::svc (void) { ACE_Profile_Timer timer; ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; barrier_.wait (); // Wait at the barrier. // We start an ACE_Profile_Timer here... timer.start (); for (size_t iterations = 1; iterations <= n_iterations; iterations++) { ACE_Thread::yield (); int result = 0; { #if defined (RW_MUTEX) ACE_Read_Guard<ACE_RW_Thread_Mutex> g (rw_mutex); #else ACE_Guard<ACE_Thread_Mutex> g (mutex); #endif /* RW_MUTEX */ find_last (); #if defined (RW_MUTEX) if (use_try_upgrade) result = rw_mutex.tryacquire_write_upgrade (); #endif /* RW_MUTEX */ // True, when we were able to upgrade. if (result == 0 && use_try_upgrade) { //find_last (); try to find something which is not in //there upgraded++; continue; } } if (result == -1 && errno == EBUSY // we tried and failed || !use_try_upgrade) // we did not try at all { #if defined (RW_MUTEX) ACE_Write_Guard<ACE_RW_Thread_Mutex> g (rw_mutex); #else ACE_Guard<ACE_Thread_Mutex> g (mutex); #endif /* RW_MUTEX */ not_upgraded++; find_last (); } else if (result == -1 && errno != EBUSY) ACE_ERROR ((LM_ERROR, ACE_TEXT (" (%t) failure in upgrading to write lock!\n"), 1)); } // Stop the timer. timer.stop (); timer.elapsed_time (elapsed_time); this->time_Calculation_.report_time (elapsed_time); return 0; }
static void * reader (void *) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) reader starting\n"))); // We use a random pause, around 2msec with 1msec jittering. int usecs = 1000 + ACE_OS::rand() % 2000; ACE_Time_Value pause(0, usecs); for (size_t iterations = 1; iterations <= n_iterations; iterations++) { ACE_OS::sleep (pause); ACE_Read_Guard<ACE_RW_Thread_Mutex> g (rw_mutex); // int n = ++current_readers; // ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) I'm reader number %d\n"), n)); if (current_writers > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) writers found!!!\n"))); ACE_thread_t data = shared_data; for (size_t loop = 1; loop <= n_loops; loop++) { ACE_Thread::yield (); if (!ACE_OS::thr_equal (shared_data, data)) ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) somebody changed %d to %d\n"), data, shared_data)); } int result = rw_mutex.tryacquire_write_upgrade (); if (result == 0) { current_readers--; current_writers++; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) upgraded to write lock!\n"))); ACE_thread_t self = ACE_Thread::self (); shared_data = self; data = self; for (size_t loop = 1; loop <= n_loops; loop++) { if (ACE_OS::thr_equal (shared_data, data) == 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) upgraded writer error: somebody changed %d to %d\n"), data, shared_data)); } current_writers--; // we were a writer } else if (result == -1 && errno == EBUSY) { current_readers--; // we were still a reader ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) could not upgrade to write lock!\n"))); } else // result == -1 { # if defined (ACE_LACKS_RWLOCK_T) // In this case we do not have native RW locks, but therefore the // emulation, which supports upgradable write locks. ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) failure in upgrading to write lock!\n"), 1)); # else // In this case we have native RW locks support, but native RW // locks do not support upgrading! ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) no support for upgradable write locks!\n"), 1)); # endif /* ACE_LACKS_RWLOCK_T */ } //ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) done with reading guarded data\n"))); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) reader finished %d iterations at %T\n"), iterations)); } return 0; }