int start_test(const int argc, const char *const *const argv)
{
scoped_test_enabler test_setup(argc, argv);
log4cxx::Logger::getLogger("coherent.util.unittests")->setLevel(coherent::log::log_TRACE);
int err;
pthread_t thread1 = 0, thread2 = 0;
{
spin_mutex::scoped_lock l(mutex);
err = pthread_create(&thread1, NULL, incrementer, NULL);
r_assert(err == 0, "failed to create thread, errno=" << errno);
err = pthread_create(&thread2, NULL, incrementer, NULL);
r_assert(err == 0, "failed to create thread, errno=" << errno);
}
err = pthread_join(thread1, NULL);
r_assert(err == 0, "failed to join thread, errno=" << errno);
err = pthread_join(thread2, NULL);
r_assert(err == 0, "failed to join thread, errno=" << errno);
r_assert(k == num_iteratrions * 2, "Expected k=" << num_iteratrions * 2 << ", but k=" << k);
return 0;
}
void memory_session::unfreeze()
{
d_assert(frozen.get());
if (!*frozen.get())
return;
scoped_lock l(mutex);
if (unfrozen_threads_count == 0)
{
memory_manager::instance->reserve_ram_bytes(&unfreeze_condition, ram_limit_bytes);
++unfrozen_threads_count;
frozen.reset(new bool(false));
r_assert(default_sub_session->unfreeze());
}
}
void memory_session::unfreeze()
{
if (!is_frozen())
return;
scoped_lock l(mutex);
d_assert(unfrozen_threads_count >= 0);
if (unfrozen_threads_count == 0)
{
memory_manager::instance->reserve_ram_bytes(ram_limit_bytes, &unfreeze_condition, 0, total_limit_bytes);
++unfrozen_threads_count;
*frozen.get() = false;
const bool res = default_sub_session->unfreeze();
r_assert(res, "Default sub session unfreezing failed on session unfreezing");
}
}
rboolean
r_test_clock_update_time (RClock * clock, RClockTime ts)
{
RTestClock * testclock;
rboolean ret;
/* Segfault or assert if test misuses the clock */
r_assert (R_CLOCK_IS_TEST_CLOCK (clock));
testclock = (RTestClock *) clock;
r_mutex_lock (&testclock->mutex);
if ((ret = (ts >= testclock->ts))) {
testclock->ts = ts;
r_cond_broadcast (&testclock->cond);
}
r_mutex_unlock (&testclock->mutex);
return ret;
}
bool memory_session::timed_unfreeze(const boost::system_time& abs_time)
{
d_assert(frozen.get());
if (!*frozen.get())
return true;
scoped_lock l(mutex);
if (unfrozen_threads_count == 0)
{
if (!memory_manager::instance->timed_reserve_ram_bytes(&unfreeze_condition, ram_limit_bytes, abs_time))
return false;
++unfrozen_threads_count;
frozen.reset(new bool(false));
r_assert(default_sub_session->unfreeze());
}
return true;
}
bool memory_session::try_unfreeze()
{
d_assert(frozen.get());
if (!*frozen.get())
return true;
scoped_lock l(mutex);
if (unfrozen_threads_count == 0)
{
if (!memory_manager::instance->try_reserve_ram_bytes(ram_limit_bytes))
return false;
++unfrozen_threads_count;
frozen.reset(new bool(false));
r_assert(default_sub_session->unfreeze());
}
return true;
}
bool memory_session::timed_unfreeze(const boost::system_time& abs_time)
{
if (!is_frozen())
return true;
scoped_lock l(mutex);
d_assert(unfrozen_threads_count >= 0);
if (unfrozen_threads_count == 0)
{
if (!memory_manager::instance->timed_reserve_ram_bytes(ram_limit_bytes, &unfreeze_condition, abs_time, 0, total_limit_bytes))
return false;
++unfrozen_threads_count;
*frozen.get() = false;
const bool res = default_sub_session->unfreeze();
r_assert(res, "Default sub session unfreezing failed on session unfreezing");
}
return true;
}
static RClockTime
r_test_clock_wait (RClock * clock, RClockTime ts)
{
RTestClock * testclock;
RClockTime now;
/* Segfault or assert if test misuses the clock */
r_assert (R_CLOCK_IS_TEST_CLOCK (clock));
testclock = (RTestClock *) clock;
if (testclock->update_on_wait) {
r_test_clock_update_time (clock, ts);
now = testclock->ts;
} else {
r_mutex_lock (&testclock->mutex);
while ((now = r_clock_get_time (clock)) < ts)
r_cond_wait (&testclock->cond, &testclock->mutex);
r_mutex_unlock (&testclock->mutex);
}
return now;
}
static void signal_hndlr(int sig)
{
r_assert(false, "Unexpected signal " << sig << " has been received");
}
static void terminate_hndlr()
{
r_assert(false, "Terminate called.");
}
static void unexpected_hndlr()
{
r_assert(false, "An unexpected excpetion has been thrown.");
}
