TEST_F(BthreadTest, bthread_equal) {
bthread_t th1;
ASSERT_EQ(0, bthread_start_urgent(&th1, NULL, do_nothing, NULL));
bthread_t th2;
ASSERT_EQ(0, bthread_start_urgent(&th2, NULL, do_nothing, NULL));
ASSERT_EQ(0, bthread_equal(th1, th2));
bthread_t th3 = th2;
ASSERT_EQ(1, bthread_equal(th3, th2));
ASSERT_EQ(0, bthread_join(th1, NULL));
ASSERT_EQ(0, bthread_join(th2, NULL));
}
TEST_F(BthreadTest, bthread_usleep) {
// NOTE: May fail because worker threads may still be stealing tasks
// after previous cases.
usleep(10000);
bthread_t th1;
ASSERT_EQ(0, bthread_start_urgent(&th1, &BTHREAD_ATTR_PTHREAD,
check_sleep, (void*)1));
ASSERT_EQ(0, bthread_join(th1, NULL));
bthread_t th2;
ASSERT_EQ(0, bthread_start_urgent(&th2, NULL,
check_sleep, (void*)0));
ASSERT_EQ(0, bthread_join(th2, NULL));
}
TEST_F(BthreadTest, too_many_nosignal_threads) {
for (size_t i = 0; i < 100000; ++i) {
bthread_attr_t attr = BTHREAD_ATTR_NORMAL | BTHREAD_NOSIGNAL;
bthread_t tid;
ASSERT_EQ(0, bthread_start_urgent(&tid, &attr, dummy_thread, NULL));
}
}
void* check_sleep(void* pthread_task) {
EXPECT_TRUE(bthread_self() != 0);
// Create a no-signal task that other worker will not steal. The task will be
// run if current bthread does context switch.
bthread_attr_t attr = BTHREAD_ATTR_NORMAL | BTHREAD_NOSIGNAL;
bthread_t th1;
pthread_t run = 0;
const pthread_t pid = pthread_self();
EXPECT_EQ(0, bthread_start_urgent(&th1, &attr, mark_run, &run));
if (pthread_task) {
bthread_usleep(100000L);
// due to NOSIGNAL, mark_run did not run.
// FIXME: actually runs. someone is still stealing.
// EXPECT_EQ((pthread_t)0, run);
// bthread_usleep = usleep for BTHREAD_ATTR_PTHREAD
EXPECT_EQ(pid, pthread_self());
// schedule mark_run
bthread_flush();
} else {
// start_urgent should jump to the new thread first, then back to
// current thread.
EXPECT_EQ(pid, run); // should run in the same pthread
}
EXPECT_EQ(0, bthread_join(th1, NULL));
if (pthread_task) {
EXPECT_EQ(pid, pthread_self());
EXPECT_NE((pthread_t)0, run); // the mark_run should run.
}
return NULL;
}
TEST_F(BthreadTest, start_latency_when_high_idle) {
bool warmup = true;
long elp1 = 0;
long elp2 = 0;
int REP = 0;
for (int i = 0; i < 10000; ++i) {
butil::Timer tm;
tm.start();
bthread_t th;
bthread_start_urgent(&th, NULL, log_start_latency, &tm);
bthread_join(th, NULL);
bthread_t th2;
butil::Timer tm2;
tm2.start();
bthread_start_background(&th2, NULL, log_start_latency, &tm2);
bthread_join(th2, NULL);
if (!warmup) {
++REP;
elp1 += tm.n_elapsed();
elp2 += tm2.n_elapsed();
} else if (i == 100) {
warmup = false;
}
}
LOG(INFO) << "start_urgent=" << elp1 / REP << "ns start_background="
<< elp2 / REP << "ns";
}
int NamingServiceThread::Start(const NamingService* naming_service,
const std::string& service_name,
const GetNamingServiceThreadOptions* opt_in) {
if (naming_service == NULL) {
LOG(ERROR) << "Param[naming_service] is NULL";
return -1;
}
_source_ns = naming_service;
_ns = naming_service->New();
_service_name = service_name;
if (opt_in) {
_options = *opt_in;
}
_last_sockets.clear();
if (_ns->RunNamingServiceReturnsQuickly()) {
RunThis(this);
} else {
int rc = bthread_start_urgent(&_tid, NULL, RunThis, this);
if (rc) {
LOG(ERROR) << "Fail to create bthread: " << berror(rc);
return -1;
}
}
return WaitForFirstBatchOfServers();
}
int Stream::Connect(Socket* ptr, const timespec*,
int (*on_connect)(int, int, void *), void *data) {
CHECK_EQ(ptr->id(), _id);
bthread_mutex_lock(&_connect_mutex);
if (_connect_meta.on_connect != NULL) {
CHECK(false) << "Connect is supposed to be called once";
bthread_mutex_unlock(&_connect_mutex);
return -1;
}
_connect_meta.on_connect = on_connect;
_connect_meta.arg = data;
if (_connected) {
ConnectMeta* meta = new ConnectMeta;
meta->on_connect = _connect_meta.on_connect;
meta->arg = _connect_meta.arg;
meta->ec = _connect_meta.ec;
bthread_mutex_unlock(&_connect_mutex);
bthread_t tid;
if (bthread_start_urgent(&tid, &BTHREAD_ATTR_NORMAL, RunOnConnect, meta) != 0) {
LOG(FATAL) << "Fail to start bthread, " << berror();
RunOnConnect(meta);
}
return 0;
}
bthread_mutex_unlock(&_connect_mutex);
return 0;
}
TEST_F(BthreadTest, bthread_exit) {
bthread_t th1;
bthread_t th2;
pthread_t th3;
bthread_t th4;
bthread_t th5;
const bthread_attr_t attr = BTHREAD_ATTR_PTHREAD;
ASSERT_EQ(0, bthread_start_urgent(&th1, NULL, just_exit, NULL));
ASSERT_EQ(0, bthread_start_background(&th2, NULL, just_exit, NULL));
ASSERT_EQ(0, pthread_create(&th3, NULL, just_exit, NULL));
EXPECT_EQ(0, bthread_start_urgent(&th4, &attr, just_exit, NULL));
EXPECT_EQ(0, bthread_start_background(&th5, &attr, just_exit, NULL));
ASSERT_EQ(0, bthread_join(th1, NULL));
ASSERT_EQ(0, bthread_join(th2, NULL));
ASSERT_EQ(0, pthread_join(th3, NULL));
ASSERT_EQ(0, bthread_join(th4, NULL));
ASSERT_EQ(0, bthread_join(th5, NULL));
}
TEST_F(BthreadTest, stop_sleep) {
bthread_t th;
ASSERT_EQ(0, bthread_start_urgent(
&th, NULL, sleep_for_awhile_with_sleep, (void*)1000000L));
butil::Timer tm;
tm.start();
bthread_usleep(10000);
ASSERT_EQ(0, bthread_stop(th));
ASSERT_EQ(0, bthread_join(th, NULL));
tm.stop();
ASSERT_LE(labs(tm.m_elapsed() - 10), 5);
}
void Stream::TriggerOnConnectIfNeed() {
if (_connect_meta.on_connect != NULL) {
ConnectMeta* meta = new ConnectMeta;
meta->on_connect = _connect_meta.on_connect;
meta->arg = _connect_meta.arg;
meta->ec = _connect_meta.ec;
bthread_mutex_unlock(&_connect_mutex);
bthread_t tid;
if (bthread_start_urgent(&tid, &BTHREAD_ATTR_NORMAL, RunOnConnect, meta) != 0) {
LOG(FATAL) << "Fail to start bthread, " << berror();
RunOnConnect(meta);
}
return;
}
bthread_mutex_unlock(&_connect_mutex);
}
TEST_F(BthreadTest, start_bthreads_frequently) {
sleep_in_adding_func = 0;
char prof_name[32];
snprintf(prof_name, sizeof(prof_name), "start_bthreads_frequently.prof");
const int con = bthread_getconcurrency();
ASSERT_GT(con, 0);
AlignedCounter* counters = new AlignedCounter[con];
bthread_t th[con];
std::cout << "Perf with different parameters..." << std::endl;
//ProfilerStart(prof_name);
for (int cur_con = 1; cur_con <= con; ++cur_con) {
stop = false;
for (int i = 0; i < cur_con; ++i) {
counters[i].value = 0;
ASSERT_EQ(0, bthread_start_urgent(
&th[i], NULL, bthread_starter, &counters[i].value));
}
butil::Timer tm;
tm.start();
bthread_usleep(200000L);
stop = true;
for (int i = 0; i < cur_con; ++i) {
bthread_join(th[i], NULL);
}
tm.stop();
size_t sum = 0;
for (int i = 0; i < cur_con; ++i) {
sum += counters[i].value * 1000 / tm.m_elapsed();
}
std::cout << sum << ",";
}
std::cout << std::endl;
//ProfilerStop();
delete [] counters;
}
