static void demo_thread_entry(void)
{
device_t *testser;
char test[260];
unsigned i = 0;
unsigned j = 10;
//int retcode = 1;
printf("START TX\n");
testser = device_lookup("uart",0);
if (!testser) {
printf("ERROR 1 !!!\n");
}
memset(test, 0, sizeof(test));
while (1) {
snprintf(test, sizeof(test),teststring,i++);
j++;
if (j > strlen(test)) {
j = 0;
memset(test, 0, sizeof(test));
}
printf("%s\n",test);
//retcode = device_io(testser, FALSE, test, j);
//if (retcode < 0) {
// printf("ERROR %d !!!\n", retcode);
//}
//thread_suspend();
thread_delay(500);
}
}
static uint32_t barrier_test(per_thread_mem_t *per_thread_mem,
odp_bool_t no_barrier_test)
{
global_shared_mem_t *global_mem;
uint32_t barrier_errs, iterations, cnt, i_am_slow_thread;
uint32_t thread_num, slow_thread_num, next_slow_thread, num_threads;
uint32_t lock_owner_delay, barrier_cnt1, barrier_cnt2;
thread_num = odp_thread_id();
global_mem = per_thread_mem->global_mem;
num_threads = global_mem->g_num_threads;
iterations = BARRIER_ITERATIONS;
barrier_errs = 0;
lock_owner_delay = SLOW_BARRIER_DELAY;
for (cnt = 1; cnt < iterations; cnt++) {
/* Wait here until all of the threads reach this point */
custom_barrier_wait(&global_mem->custom_barrier1[cnt]);
barrier_cnt1 = LOAD_U32(global_mem->barrier_cnt1);
barrier_cnt2 = LOAD_U32(global_mem->barrier_cnt2);
if ((barrier_cnt1 != cnt) || (barrier_cnt2 != cnt)) {
printf("thread_num=%" PRIu32 " barrier_cnts of %" PRIu32
" %" PRIu32 " cnt=%" PRIu32 "\n",
thread_num, barrier_cnt1, barrier_cnt2, cnt);
barrier_errs++;
}
/* Wait here until all of the threads reach this point */
custom_barrier_wait(&global_mem->custom_barrier2[cnt]);
slow_thread_num = LOAD_U32(global_mem->slow_thread_num);
i_am_slow_thread = thread_num == slow_thread_num;
next_slow_thread = slow_thread_num + 1;
if (num_threads < next_slow_thread)
next_slow_thread = 1;
/*
* Now run the test, which involves having all but one thread
* immediately calling odp_barrier_wait(), and one thread wait a
* moderate amount of time and then calling odp_barrier_wait().
* The test fails if any of the first group of threads
* has not waited for the "slow" thread. The "slow" thread is
* responsible for re-initializing the barrier for next trial.
*/
if (i_am_slow_thread) {
thread_delay(per_thread_mem, lock_owner_delay);
lock_owner_delay += BASE_DELAY;
if ((LOAD_U32(global_mem->barrier_cnt1) != cnt) ||
(LOAD_U32(global_mem->barrier_cnt2) != cnt) ||
(LOAD_U32(global_mem->slow_thread_num)
!= slow_thread_num))
barrier_errs++;
}
if (no_barrier_test == 0)
odp_barrier_wait(&global_mem->test_barriers[cnt]);
STORE_U32(global_mem->barrier_cnt1, cnt + 1);
odp_mb_full();
if (i_am_slow_thread) {
STORE_U32(global_mem->slow_thread_num, next_slow_thread);
STORE_U32(global_mem->barrier_cnt2, cnt + 1);
odp_mb_full();
} else {
uint32_t cnt2 = LOAD_U32(global_mem->barrier_cnt2);
while (cnt2 != (cnt + 1)){
thread_delay(per_thread_mem, BASE_DELAY);
cnt2 = LOAD_U32(global_mem->barrier_cnt2);
}
}
}
if ((global_mem->g_verbose) && (barrier_errs != 0))
printf("\nThread %" PRIu32 " (id=%d core=%d) had %" PRIu32
" barrier_errs in %" PRIu32 " iterations\n", thread_num,
per_thread_mem->thread_id,
per_thread_mem->thread_core, barrier_errs, iterations);
return barrier_errs;
}
