void
test_thread_start_params(void) {
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS,
lagopus_thread_start(NULL, false),
"thread is NULL");
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_INVALID_ARGS,
lagopus_thread_start(NULL, true),
"thread is NULL");
}
lagopus_result_t
snmpmgr_start(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
(void)lagopus_mutex_lock(&snmp_state_lock);
if (state == SNMPMGR_RUNNABLE) {
if (is_thread == false) {
state = SNMPMGR_RUNNING;
(void)lagopus_mutex_unlock(&snmp_state_lock);
/* open the session to AgentX master agent here. */
init_snmp(SNMP_TYPE);
/* send_*_trap always return SNMP_ERR_NOERROR */
(void)send_coldStart_trap();
ret = LAGOPUS_RESULT_OK;
lagopus_msg_info("SNMP manager started.\n");
} else {
/* Note:
* If is_thread is true, init_snmp and send_coldStart_trap
* are called inside snmpmgr_thread_loop
*/
(void)lagopus_mutex_unlock(&snmp_state_lock);
ret = lagopus_thread_start(&snmpmgr, false);
}
} else {
(void)lagopus_mutex_unlock(&snmp_state_lock);
ret = LAGOPUS_RESULT_NOT_STARTED;
}
return ret;
}
static lagopus_result_t
dummy_module_start(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
lagopus_msg_debug(5, "called.\n");
if (s_thd != NULL) {
s_lock();
{
if (s_is_initialized == true) {
ret = lagopus_thread_start(&s_thd, false);
if (ret == LAGOPUS_RESULT_OK) {
s_do_loop = true;
}
} else {
ret = LAGOPUS_RESULT_INVALID_STATE_TRANSITION;
}
}
s_unlock();
} else {
ret = LAGOPUS_RESULT_INVALID_OBJECT;
}
return ret;
}
static inline bool
s_check_start_common(lagopus_thread_t *thd_ptr, lagopus_result_t require_ret,
bool autodelete) {
bool result = false;
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
ret = lagopus_thread_start(thd_ptr, autodelete);
if (ret == require_ret) {
if (ret == LAGOPUS_RESULT_OK) {
result = s_check_get_thread_id(thd_ptr, LAGOPUS_RESULT_OK);
} else {
result = true;
}
} else {
lagopus_perror(ret);
TEST_FAIL_MESSAGE("start failed");
result = false;
}
return result;
}
lagopus_result_t
dp_thread_start(lagopus_thread_t *threadptr,
lagopus_mutex_t *lockptr,
bool *runptr) {
lagopus_result_t ret;
lagopus_mutex_lock(lockptr);
if (*runptr == true) {
ret = LAGOPUS_RESULT_ALREADY_EXISTS;
goto done;
}
*runptr = true;
ret = lagopus_thread_start(threadptr, false);
if (ret != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
}
done:
lagopus_mutex_unlock(lockptr);
return ret;
}
int
main(int argc, char const *const argv[]) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
int cpu = 0;
lagopus_thread_t thd = NULL;
if (argc > 1) {
int tmp;
if (lagopus_str_parse_int32(argv[1], &tmp) == LAGOPUS_RESULT_OK &&
tmp > 0) {
cpu = tmp;
}
}
if ((ret = lagopus_thread_create(&thd,
s_main_proc,
NULL,
NULL,
(const char *) "thread",
(void *) NULL)) == LAGOPUS_RESULT_OK) {
if ((ret = lagopus_thread_set_cpu_affinity(&thd,
-1)) == LAGOPUS_RESULT_OK &&
(ret = lagopus_thread_set_cpu_affinity(&thd,
cpu)) == LAGOPUS_RESULT_OK) {
if ((ret = lagopus_thread_start(&thd, false)) == LAGOPUS_RESULT_OK) {
ret = lagopus_thread_wait(&thd, -1LL);
}
}
}
if (ret != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
return 1;
} else {
return 0;
}
}
int
main(int argc, const char *const argv[]) {
int ret = 1;
lagopus_result_t r;
null_thread_t nt;
size_t i;
a_obj_t o;
(void)argc;
(void)argv;
o = a_obj_create();
if (o == NULL) {
goto done;
}
for (i = 0; i < NTHDS; i++) {
nt = &s_thds[i];
if ((r = s_create(&nt, o)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
}
for (i = 0; i < NTHDS; i++) {
nt = &s_thds[i];
if ((r = lagopus_thread_start((lagopus_thread_t *)&nt, false)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
}
sleep(1);
/*
* Cancel all the thread.
*/
for (i = 0; i < NTHDS; i++) {
nt = &s_thds[i];
if ((r = lagopus_thread_cancel((lagopus_thread_t *)&nt)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
}
/*
* Destroy all the thread. If any deadlocks occur, we failed.
*/
for (i = 0; i < NTHDS; i++) {
nt = &s_thds[i];
lagopus_thread_destroy((lagopus_thread_t *)&nt);
}
/*
* And destroy a_obj. If a deadlock occurs, we failed.
*/
a_obj_destroy(o);
ret = 0;
done:
return ret;
}
int
main(int argc, char const *const argv[]) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
int i;
int n = 10000;
lagopus_thread_t thread = NULL;
pthread_t tid = LAGOPUS_INVALID_THREAD;
lagopus_log_set_debug_level(10);
if (argc > 1) {
int tmp;
if (lagopus_str_parse_int32(argv[1], &tmp) == LAGOPUS_RESULT_OK &&
tmp > 0) {
n = tmp;
}
}
/* create, start, wait, destroy */
for (i = 0; i < n; i++) {
thread = NULL;
if ((ret = lagopus_thread_create(
(lagopus_thread_t *)&thread,
(lagopus_thread_main_proc_t)s_main_proc,
(lagopus_thread_finalize_proc_t)s_finalize_proc,
(lagopus_thread_freeup_proc_t)s_freeup_proc,
(const char *) "thread",
(void *) NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't create a thread.\n");
} else {
fprintf(stderr, "create a thread [%d]\n", i);
if ((ret = lagopus_thread_get_pthread_id(&thread, &tid))
!= LAGOPUS_RESULT_NOT_STARTED) {
lagopus_perror(ret);
goto done;
}
}
if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't start the thread.\n");
} else {
ret = lagopus_thread_get_pthread_id(&thread, &tid);
if (ret == LAGOPUS_RESULT_OK ||
ret == LAGOPUS_RESULT_ALREADY_HALTED) {
fprintf(stderr, " start thread: %lu\n", tid);
} else {
lagopus_perror(ret);
goto done;
}
}
s_check_cancelled(&thread, false);
if ((ret = lagopus_thread_wait(&thread, 1000LL * 1000LL * 1000LL)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_msg_error("Can't wait the thread.\n");
} else {
if ((ret = lagopus_thread_get_pthread_id(&thread, &tid))
== LAGOPUS_RESULT_OK) {
lagopus_msg_error(
"Thread has been completed, but I can get thread ID, %lu\n",
tid);
} else if (ret != LAGOPUS_RESULT_ALREADY_HALTED) {
lagopus_perror(ret);
goto done;
}
}
s_check_cancelled(&thread, false);
lagopus_thread_destroy(&thread);
fprintf(stderr, "destroy the thread [%d]\n", i);
fprintf(stderr, "\n");
}
/* create, start, cancel, destroy */
for (i = 0; i < n; i++) {
thread = NULL;
if ((ret = lagopus_thread_create(
(lagopus_thread_t *)&thread,
(lagopus_thread_main_proc_t)s_main_proc_with_sleep,
(lagopus_thread_finalize_proc_t)s_finalize_proc,
(lagopus_thread_freeup_proc_t)s_freeup_proc,
(const char *) "thread",
(void *) NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't create a thread.\n");
} else {
fprintf(stderr, "create a thread [%d]\n", i);
if ((ret = lagopus_thread_get_pthread_id(&thread, &tid))
!= LAGOPUS_RESULT_NOT_STARTED) {
lagopus_perror(ret);
goto done;
}
}
if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't start the thread.\n");
} else {
ret = lagopus_thread_get_pthread_id(&thread, &tid);
if (ret == LAGOPUS_RESULT_OK ||
ret == LAGOPUS_RESULT_ALREADY_HALTED) {
fprintf(stderr, " start thread: %lu\n", tid);
} else {
lagopus_perror(ret);
goto done;
}
}
s_check_cancelled(&thread, false);
if ((ret = lagopus_thread_cancel(&thread)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_msg_error("Can't cancel the thread.\n");
} else {
if ((ret = lagopus_thread_get_pthread_id(&thread, &tid))
== LAGOPUS_RESULT_OK) {
lagopus_msg_error(
"Thread has been canceled, but I can get thread ID, %lu\n",
tid);
} else if (ret != LAGOPUS_RESULT_NOT_STARTED &&
ret != LAGOPUS_RESULT_ALREADY_HALTED) {
lagopus_perror(ret);
goto done;
}
}
s_check_cancelled(&thread, true);
lagopus_thread_destroy(&thread);
fprintf(stderr, "destroy the thread [%d]\n", i);
fprintf(stderr, "\n");
}
/* create, start, destroy */
for (i = 0; i < n; i++) {
thread = NULL;
if ((ret = lagopus_thread_create(
(lagopus_thread_t *)&thread,
(lagopus_thread_main_proc_t)s_main_proc_with_sleep,
(lagopus_thread_finalize_proc_t)s_finalize_proc,
(lagopus_thread_freeup_proc_t)s_freeup_proc,
(const char *) "thread",
(void *) NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't create a thread.\n");
} else {
fprintf(stderr, "create a thread [%d]\n", i);
if ((ret = lagopus_thread_get_pthread_id(&thread, &tid))
!= LAGOPUS_RESULT_NOT_STARTED) {
lagopus_perror(ret);
goto done;
}
}
if ((ret = lagopus_thread_start(&thread, false)) != LAGOPUS_RESULT_OK) {
lagopus_perror(ret);
lagopus_exit_fatal("Can't start the thread.\n");
} else {
ret = lagopus_thread_get_pthread_id(&thread, &tid);
if (ret == LAGOPUS_RESULT_OK ||
ret == LAGOPUS_RESULT_ALREADY_HALTED) {
fprintf(stderr, " start thread: %lu\n", tid);
} else {
lagopus_perror(ret);
goto done;
}
}
lagopus_thread_destroy(&thread);
fprintf(stderr, "destroy the thread [%d]\n", i);
fprintf(stderr, "\n");
}
done:
return (ret == LAGOPUS_RESULT_OK) ? 0 : 1;
}
static int
do_run(size_t nthds, ssize_t nputs) {
int ret = 1;
lagopus_result_t r;
size_t i;
size_t j;
char thdname[16];
lagopus_chrono_t *put_dates = NULL;
size_t n_need_watch = 0;
size_t n_valid_polls = 0;
ssize_t qsz;
test_thread_t tt;
lagopus_bbq_t bbq;
lagopus_chrono_t t_begin;
lagopus_chrono_t t_end;
lagopus_chrono_t p_begin;
lagopus_chrono_t p_t;
ssize_t n_gets = 0;
lagopus_chrono_t p_min = LLONG_MAX;
lagopus_chrono_t p_max = LLONG_MIN;
double p_sum = 0.0;
double p_sum2 = 0.0;
double p_avg;
double p_sd;
lagopus_chrono_t t_total = 0;
double t_avg;
/*
* This is only for choking clang/scan-build.
*/
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_begin);
put_dates = (lagopus_chrono_t *)
malloc(sizeof(lagopus_chrono_t) * (size_t)nputs);
if (put_dates == NULL) {
goto done;
}
if ((r = lagopus_mutex_create(&start_lock)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
if ((r = lagopus_mutex_create(&stop_lock)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Create the qmuxer.
*/
if ((r = lagopus_qmuxer_create(&qmx)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Then create queues.
*/
bbqs = (lagopus_bbq_t *)malloc(sizeof(lagopus_bbq_t) * nthds);
if (bbqs == NULL) {
goto done;
}
for (i = 0; i < nthds; i++) {
if ((r = lagopus_bbq_create(&(bbqs[i]), lagopus_chrono_t,
1000LL * 1000LL,
NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_bbqs++;
}
if (n_created_bbqs == 0) {
goto done;
}
/*
* Then create poll objects for the each queue.
*/
polls = (lagopus_qmuxer_poll_t *)malloc(sizeof(lagopus_qmuxer_poll_t) *
n_created_bbqs);
if (polls == NULL) {
goto done;
}
for (i = 0; i < n_created_bbqs; i++) {
if ((r = lagopus_qmuxer_poll_create(&(polls[i]),
bbqs[i],
LAGOPUS_QMUXER_POLL_READABLE)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_polls++;
}
if (n_created_polls == 0) {
goto done;
}
/*
* Then create threads for the each poll objects/queues.
*/
tts = (test_thread_record *)malloc(sizeof(test_thread_record) *
n_created_polls);
if (tts == NULL) {
goto done;
}
for (i = 0; i < n_created_polls; i++) {
snprintf(thdname, sizeof(thdname), "putter " PFSZS(4, u), i);
tt = &(tts[i]);
if (test_thread_create(&tt, start_lock, bbqs[i], nputs,
(const char *)thdname) != true) {
goto done;
}
n_created_thds++;
}
if (n_created_thds == 0) {
goto done;
}
/*
* Let the initiation begin.
*/
/*
* Ready, note that all the created threads do this lock.
*/
(void)lagopus_mutex_lock(&start_lock);
/*
* Steady,
*/
for (i = 0; i < n_created_thds; i++) {
tt = &(tts[i]);
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
(void)lagopus_mutex_unlock(&start_lock);
goto done;
}
}
fprintf(stdout, "Test for " PFSZ(u) " threads " PFSZ(u)
" events/thdread start.\n", n_created_thds, (size_t)nputs);
/*
* Go.
*/
(void)lagopus_mutex_unlock(&start_lock);
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_begin);
while (true) {
/*
* Like the select(2)/poll(2), initialize poll objects before
* checking events.
*/
n_need_watch = 0;
n_valid_polls = 0;
for (i = 0; i < n_created_thds; i++) {
/*
* Check if the poll has a valid queue.
*/
bbq = NULL;
if ((r = lagopus_qmuxer_poll_get_queue(&(polls[i]), &bbq)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
if (bbq != NULL) {
n_valid_polls++;
}
/*
* Reset the poll status.
*/
if ((r = lagopus_qmuxer_poll_reset(&(polls[i]))) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
n_need_watch++;
}
/*
* If there are no valid queues, exit.
*/
if (n_valid_polls == 0) {
break;
}
/*
* Wait for an event.
*
* Note that we better set timeout, not waiting forever.
*/
r = lagopus_qmuxer_poll(&qmx, (lagopus_qmuxer_poll_t *const)polls,
n_need_watch,
100LL * 1000LL * 1000LL);
if (r > 0) {
/*
* Check which poll got an event. Actually, check all the queues
* in this sample.
*/
size_t n_actual_get = 0LL;
for (i = 0; i < n_created_thds; i++) {
if ((qsz = lagopus_bbq_size(&(bbqs[i]))) > 0) {
lagopus_msg_debug(1, "Got " PFSZS(8, u) " events from the Q"
PFSZS(03, u) ".\n",
(size_t)qsz, (size_t)i);
if ((r = lagopus_bbq_get_n(&(bbqs[i]), (void **)put_dates,
(size_t)nputs, 1LL,
lagopus_chrono_t,
1000LL * 1000LL * 1000LL,
&n_actual_get)) > 0) {
#if 1
WHAT_TIME_IS_IT_NOW_IN_NSEC(p_begin);
#endif
for (j = 0; j < n_actual_get; j++) {
/*
* In this sample, -1LL is kinda 'EOF'. Check if we got
* the EOF.
*/
if (put_dates[j] == -1LL) {
/*
* The queue is kinda 'closed'. From now on we don't
* check this queue anymore. To specify this:
*/
lagopus_msg_debug(1, "Got an EOF from the Q" PFSZS(04, u)
".\n", i);
goto nullify;
}
#if 0
WHAT_TIME_IS_IT_NOW_IN_NSEC(p_begin);
#endif
p_t = p_begin - put_dates[j];
if (p_t < p_min) {
p_min = p_t;
}
if (p_t > p_max) {
p_max = p_t;
}
p_sum += (double)p_t;
p_sum2 += ((double)p_t * (double)p_t);
n_gets++;
}
} else {
/*
* Something wrong for the queue. But we must not exit
* here. Keep on checking other queues. In order to do
* this, set NULL as the queue into the poll object for
* the queue.
*/
lagopus_perror(r);
nullify:
if ((r = lagopus_qmuxer_poll_set_queue(&(polls[i]), NULL)) ==
LAGOPUS_RESULT_OK) {
lagopus_msg_debug(1, "Q" PFSZS(04, u) " is not valid "
"anymore, ignore the queue.\n", i);
break;
} else {
/*
* There is nothing we can do now.
*/
lagopus_perror(r);
goto done;
}
}
}
}
} else if (r == LAGOPUS_RESULT_TIMEDOUT) {
lagopus_msg_debug(1, "Timedout. continue.\n");
continue;
} else {
lagopus_perror(r);
lagopus_msg_debug(1, "Break the loop due to error(s).\n");
goto done;
}
}
ret = 0;
done:
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_end);
if (is_signaled == false) {
fprintf(stdout, "Done.\n");
} else {
fprintf(stdout, "Stopped.\n");
}
fprintf(stdout, "Total # of the events:\t" PFSZS(22, u) "\n\n", n_gets);
p_avg = p_sum / (double)n_gets;
p_sd = (p_sum2 -
2.0 * p_avg * p_sum +
p_avg * p_avg * (double)n_gets) / (double)(n_gets - 1);
p_sd = sqrt(p_sd);
fprintf(stdout, "Queue stats:\n");
fprintf(stdout, "wait time min =\t" PFSZS(22, d) " nsec.\n", p_min);
fprintf(stdout, "wait time max =\t" PFSZS(22, d) " nsec.\n", p_max);
fprintf(stdout, "wait time avg =\t%25.2f nsec.\n", p_avg);
fprintf(stdout, "wait time sd =\t%25.2f.\n\n", p_sd);
t_total = t_end - t_begin;
t_avg = (double)t_total / (double)n_gets;
fprintf(stdout, "Throughput:\n");
fprintf(stdout, "total time:\t" PFSZS(22, d) " msec.\n",
(size_t)(t_total / 1000LL / 1000LL));
fprintf(stdout, "total avg:\t%25.2f nsec/event.\n", t_avg);
s_destroy_all();
free((void *)put_dates);
return ret;
}
int
main(int argc, const char *const argv[]) {
test_thread_record ttr;
test_thread_t tt;
bool is_canceled;
int ret = 1;
(void)argc;
(void)argv;
fprintf(stderr, "Pthread wrapper check: start\n\n");
/*
* Heap object
*/
fprintf(stderr, "Heap object, regular: start\n");
tt = NULL;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't create a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
test_thread_request_stop(tt);
if (lagopus_thread_wait((lagopus_thread_t *)&tt, -1) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't wait the thread.\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
fprintf(stderr, "Heap object, regular: end\n\n");
/*
* Stack object
*/
fprintf(stderr, "Stack object, regular: start\n");
tt = &ttr;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
test_thread_request_stop(tt);
if (lagopus_thread_wait((lagopus_thread_t *)&tt, -1) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't wait the thread.\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
fprintf(stderr, "Stack object, regular: end\n\n");
/*
* Cancel
*/
fprintf(stderr, "Stack object, cancel: start\n");
tt = &ttr;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
if (lagopus_thread_cancel((lagopus_thread_t *)&tt) != LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't cancel the thread.\n");
}
if (lagopus_thread_wait((lagopus_thread_t *)&tt, -1) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't wait the thread.\n");
}
if (lagopus_thread_is_canceled((lagopus_thread_t *)&tt, &is_canceled) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("The returned value must be \"canceled\".\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
fprintf(stderr, "Stack object, cancel: end\n\n");
/*
* Heap object auto deletion
*/
fprintf(stderr, "Heap object, auto deletion: start\n");
s_is_deleted = false;
tt = NULL;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, true) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
test_thread_request_stop(tt);
lagopus_chrono_nanosleep(2LL * 1000LL * 1000LL * 1000LL, NULL);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Heap object, auto deletion: end\n\n");
/*
* Stack object auto deletion
*/
fprintf(stderr, "Stack object, auto deletion: start\n");
s_is_deleted = false;
tt = &ttr;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, true) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
test_thread_request_stop(tt);
lagopus_chrono_nanosleep(2LL * 1000LL * 1000LL * 1000LL, NULL);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Stack object, auto deletion: end\n\n");
/*
* Heap object cancel, auto deletion
*/
fprintf(stderr, "Heap object, cancel, auto deletion: start\n");
s_is_deleted = false;
tt = NULL;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, true) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
if (lagopus_thread_cancel((lagopus_thread_t *)&tt) != LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't cancel the thread.\n");
}
lagopus_chrono_nanosleep(2LL * 1000LL * 1000LL * 1000LL, NULL);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Heap object, cancel, auto deletion: end\n\n");
/*
* Stack object cancel, auto deletion
*/
fprintf(stderr, "Stack object, cancel, auto deletion: start\n");
s_is_deleted = false;
tt = &ttr;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, true) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_chrono_nanosleep(5LL * 1000LL * 1000LL * 1000LL, NULL);
if (lagopus_thread_cancel((lagopus_thread_t *)&tt) != LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't cancel the thread.\n");
}
lagopus_chrono_nanosleep(2LL * 1000LL * 1000LL * 1000LL, NULL);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Stack object, cancel, auto deletion: end\n\n");
/*
* Timed wait
*/
fprintf(stderr, "Timed wait: start\n");
tt = &ttr;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't initialize a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
if (lagopus_thread_wait((lagopus_thread_t *)&tt,
5LL * 1000LL * 1000LL * 1000LL) !=
LAGOPUS_RESULT_TIMEDOUT) {
lagopus_exit_fatal("Must be timed out.\n");
}
test_thread_request_stop(tt);
if (lagopus_thread_wait((lagopus_thread_t *)&tt, -1) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't wait the thread.\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
fprintf(stderr, "Timed wait: end\n\n");
/*
* Force destroy
*/
fprintf(stderr, "Force destroy: start\n");
s_is_deleted = false;
tt = NULL;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't create a test thread object.\n");
}
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
lagopus_exit_fatal("Can't start a thread.\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Force destroy: end\n\n");
/*
* Force destroy, not started
*/
fprintf(stderr, "Force destroy, not started: start\n");
s_is_deleted = false;
tt = NULL;
if (test_thread_create(&tt, 100) != true) {
lagopus_exit_fatal("Can't create a test thread object.\n");
}
lagopus_thread_destroy((lagopus_thread_t *)&tt);
if (s_is_deleted == false) {
lagopus_exit_fatal("The thread object must be freed and "
"the flag must be true.\n");
}
fprintf(stderr, "Force destroy, not started: end\n\n");
ret = 0;
fprintf(stderr, "Pthread wrapper check: end\n");
return ret;
}
