void taskh_func(long tid)
{
RTIME time;
unsigned int msg = 0, wait;
rt_send(&taskm, msg);
rt_send(&taskl, msg);
while (1) {
rt_receive(&taskm, &msg);
time = rt_get_time_ns();
if (MUTEX_LOCK(&mutex) <= 1) {
if ((wait = (int)(rt_get_time_ns() - time)) > 250000) {
rt_printk("PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000);
} else {
rt_printk("NO PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000);
}
if (SemType) {
MUTEX_LOCK(&mutex);
MUTEX_LOCK(&mutex);
rt_busy_sleep(100000);
MUTEX_LOCK(&mutex);
}
rt_busy_sleep(100000);
if (SemType) {
rt_sem_signal(&mutex);
rt_busy_sleep(100000);
rt_sem_signal(&mutex);
rt_sem_signal(&mutex);
}
rt_sem_signal(&mutex);
} else {
rt_task_suspend(0);
}
}
}
static void *fast_fun(void *arg)
{
int jit, period;
RTIME expected;
if (!(Fast_Task = rt_thread_init(nam2num("FSTSK"), 2, 0, SCHED_FIFO, CPUMAP))) {
printf("CANNOT INIT FAST TASK\n");
exit(1);
}
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
rt_sem_wait_barrier(barrier);
period = nano2count(FASTMUL*TICK_TIME);
expected = start + 6*nano2count(TICK_TIME);
rt_task_make_periodic(Fast_Task, expected, period);
while (!end) {
jit = abs(count2nano(rt_get_time() - expected));
if (jit > fastjit) {
fastjit = jit;
}
rt_busy_sleep((FASTMUL*TICK_TIME*USEDFRAC)/100);
expected += period;
END("FE\n");
rt_task_wait_period();
BEGIN("FB\n");
}
rt_sem_wait_barrier(barrier);
rt_make_soft_real_time();
rt_thread_delete(Fast_Task);
return 0;
}
void cleanup_module(void)
{
stop_rt_timer();
rt_busy_sleep(nano2count(TICK_PERIOD));
rt_qCleanup(&agentask);
rt_task_delete(&agentask);
}
static __exit void hello_exit(void)
{
stop_rt_timer();
rt_busy_sleep(10000000);
rt_task_delete(&thread);
printk(KERN_ALERT "Q8 Test Module removed.\n");
}
static void fun(long none)
{
volatile double s, a[MAXDIM], b[MAXDIM];
long msg;
RTIME period, wait_delay, sync_time, aim_time;
*worst_lat = -2000000000;
wait_delay = nano2count(WAIT_DELAY);
period = nano2count(PERIOD);
for(msg = 0; msg < MAXDIM; msg++) {
a[msg] = b[msg] = 3.141592;
}
rtai_cli();
aim_time = rt_get_time();
sync_time = aim_time + wait_delay;
aim_time += period;
while (!rt_receive_if(NULL, &msg)) {
WAIT_AIM_TIME();
sync_time = rt_get_time();
msg = abs((long)(sync_time - aim_time));
sync_time = aim_time + wait_delay;
aim_time += period;
if (msg > *worst_lat) {
*worst_lat = msg;
}
s = dot(a,b, MAXDIM);
rt_busy_sleep(WORKING_TIME);
rt_sleep_until(sync_time);
}
rtai_sti();
}
void cleanup_module(void)
{
int i;
stop_rt_timer();
for (i = 0; i < NUM_CHILDREN; i++) {
rt_task_delete(&child_task[i]);
}
rt_busy_sleep(nano2count(TICK_PERIOD));
rt_task_delete(&parent_task);
}
void taskm_func(long tid)
{
unsigned int msg = 0;
rt_receive(0, &msg);
rt_send(&taskl, msg);
while (1) {
rt_receive(&taskl, &msg);
rt_send(&taskh, msg);
rt_busy_sleep(5000000);
}
}
void cleanup_module (void)
{
stop_rt_timer();
rt_busy_sleep(10000000);
rt_task_delete(&thread);
rtai_kfree(nam2num(SHMNAM));
rtai_kfree(nam2num(SHMNAM));
rtai_kfree(nam2num(SHMNAM));
rtai_kfree(nam2num(SHMNAM));
rtai_kfree(nam2num(SHMNAM));
rtai_kfree(nam2num(SHMNAM));
}
void cleanup_module(void)
{
int cpuid;
stop_rt_timer();
rt_busy_sleep(10000000);
rt_task_delete(&thread);
rtf_destroy(CMDF);
printk("\n\nCPU USE SUMMARY\n");
for (cpuid = 0; cpuid < NR_RT_CPUS; cpuid++) {
printk("# %d -> %d\n", cpuid, cpu_used[cpuid]);
}
printk("END OF CPU USE SUMMARY\n\n");
}
void taskl_func(long tid)
{
unsigned int msg = 0;
rt_receive(0, &msg);
rt_receive(0, &msg);
while (MUTEX_LOCK(&mutex) <= 1) {
if (SemType) {
MUTEX_LOCK(&mutex);
rt_busy_sleep(100000);
MUTEX_LOCK(&mutex);
}
rt_send(&taskm, msg);
rt_busy_sleep(100000);
if (SemType) {
rt_sem_signal(&mutex);
rt_busy_sleep(100000);
rt_sem_signal(&mutex);
}
rt_sem_signal(&mutex);
rt_sleep(nano2count(500000000));
}
rt_task_suspend(0);
}
void cleanup_module(void)
{
int i, cpuid;
rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);
stop_rt_timer();
rt_busy_sleep(10000000);
for (i = 0; i < NTASKS; i++) {
rt_task_delete(&thread[i]);
}
printk("\n\nCPU USE SUMMARY\n");
for (cpuid = 0; cpuid < NR_RT_CPUS; cpuid++) {
printk("# %d -> %d\n", cpuid, cpu_used[cpuid]);
}
printk("END OF CPU USE SUMMARY\n\n");
}
static void Fast_Thread(long dummy)
{
int jit;
RTIME svt, t;
svt = rt_get_cpu_time_ns() - FASTMUL*TICK_TIME;
while (1) {
jit = (int) ((t = rt_get_cpu_time_ns()) - svt - FASTMUL*TICK_TIME);
svt = t;
if (jit) { jit = - jit; }
if (jit > fastjit) { fastjit = jit; }
cpu_used[hard_cpu_id()]++;
rt_busy_sleep(FASTMUL/2*TICK_TIME);
rt_task_wait_period();
}
}
void cleanup_module(void)
{
int cpuid;
rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);
stop_rt_timer();
rt_busy_sleep(10000000);
rt_task_delete(&read);
rt_task_delete(&chrono);
rt_task_delete(&clock);
rt_task_delete(&write);
rtf_destroy(Keyboard);
rtf_destroy(Screen);
printk("\n\nCPU USE SUMMARY\n");
for (cpuid = 0; cpuid < NR_RT_CPUS; cpuid++) {
printk("# %d -> %d\n", cpuid, cpu_used[cpuid]);
}
printk("END OF CPU USE SUMMARY\n\n");
}
static void fun(long idx)
{
unsigned int loops = LOOPS;
while(loops--) {
rt_printk("TASK %d 1 COND/TIMED PREWLOCKED\n", idx);
if (idx%2) {
if (rt_rwl_wrlock_if(&rwl)) {
rt_printk("TASK %d 1 COND PREWLOCKED FAILED GO UNCOND\n", idx);
rt_rwl_wrlock(&rwl);
}
} else if (rt_rwl_wrlock_timed(&rwl, nano2count(20000)) >= SEM_TIMOUT) {
rt_printk("TASK %d 1 TIMED PREWLOCKED FAILED GO UNCOND\n", idx);
rt_rwl_wrlock(&rwl);
}
rt_printk("TASK %d 1 WLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 COND PREWLOCK\n", idx);
if (rt_rwl_wrlock_if(&rwl)) {
rt_printk("TASK %d 2 COND PREWLOCK FAILED GO UNCOND\n", idx);
rt_rwl_wrlock(&rwl);
}
rt_printk("TASK %d 2 WLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PREWLOCK\n", idx);
rt_rwl_wrlock(&rwl);
rt_printk("TASK %d 3 WLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PREWUNLOCK\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 3 WUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 PREWUNLOCK\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 2 WUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 PREWUNLOCKED\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 1 WUNLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 COND/TIMED PRERDLOCKED\n", idx);
if (idx%2) {
if (rt_rwl_rdlock_if(&rwl)) {
rt_printk("TASK %d 1 COND PRERDLOCKED FAILED GO UNCOND\n", idx);
rt_rwl_rdlock(&rwl);
}
} else if (rt_rwl_rdlock_timed(&rwl, nano2count(20000)) >= SEM_TIMOUT) {
rt_printk("TASK %d 1 TIMED PRERDLOCKED FAILED GO UNCOND\n", idx);
rt_rwl_rdlock(&rwl);
}
rt_printk("TASK %d 1 RDLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 COND PRERDLOCK\n", idx);
if (rt_rwl_rdlock_if(&rwl)) {
rt_printk("TASK %d 2 COND PRERDLOCK FAILED GO UNCOND\n", idx);
rt_rwl_rdlock(&rwl);
}
rt_printk("TASK %d 2 RDLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PRERDLOCK\n", idx);
rt_rwl_rdlock(&rwl);
rt_printk("TASK %d 3 RDLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PRERDUNLOCK\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 3 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 PRERDUNLOCK\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 2 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 PRERDUNLOCK\n", idx);
rt_rwl_unlock(&rwl);
rt_printk("TASK %d 1 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
}
extcnt[idx - 1] = loops;
rt_sleep(nano2count(10000000));
rt_printk("TASK %d EXITED\n", idx);
}
static void *thread_fun(int idx)
{
unsigned int loops = LOOPS;
struct timespec abstime;
char name[7];
sprintf(name, "TASK%d", idx);
pthread_setschedparam_np(NTASKS - idx + 1, SCHED_FIFO, 0, 0x1, PTHREAD_HARD_REAL_TIME_NP);
mlockall(MCL_CURRENT | MCL_FUTURE);
RT_SET_REAL_TIME_MODE();
while(loops--) {
DISPLAY("TASK %d 1 COND/TIMED PREWLOCKED\n", idx);
clock_gettime(0, &abstime);
abstime.tv_sec += 2;
if (idx%2) {
if (pthread_rwlock_trywrlock(rwl)) {
DISPLAY("TASK %d 1 COND PREWLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(rwl);
}
} else if (pthread_rwlock_timedwrlock(rwl, &abstime) >= SEM_TIMOUT) {
DISPLAY("TASK %d 1 TIMED PREWLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(rwl);
}
DISPLAY("TASK %d 1 WLOCKED\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 2 COND PREWLOCK\n", idx);
if (pthread_rwlock_trywrlock(rwl)) {
DISPLAY("TASK %d 2 COND PREWLOCK FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(rwl);
}
DISPLAY("TASK %d 2 WLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 3 PREWLOCK\n", idx);
pthread_rwlock_wrlock(rwl);
DISPLAY("TASK %d 3 WLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 3 PREWUNLOCK\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 3 WUNLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 2 PREWUNLOCK\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 2 WUNLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 1 PREWUNLOCKED\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 1 WUNLOCKED\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 1 COND/TIMED PRERDLOCKED\n", idx);
clock_gettime(0, &abstime);
abstime.tv_sec += 2;
if (idx%2) {
if (pthread_rwlock_tryrdlock(rwl)) {
DISPLAY("TASK %d 1 COND PRERDLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(rwl);
}
} else if (pthread_rwlock_timedrdlock(rwl, &abstime) >= SEM_TIMOUT) {
DISPLAY("TASK %d 1 TIMED PRERDLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(rwl);
}
DISPLAY("TASK %d 1 RDLOCKED\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 2 COND PRERDLOCK\n", idx);
if (pthread_rwlock_tryrdlock(rwl)) {
DISPLAY("TASK %d 2 COND PRERDLOCK FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(rwl);
}
DISPLAY("TASK %d 2 RDLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 3 PRERDLOCK\n", idx);
pthread_rwlock_rdlock(rwl);
DISPLAY("TASK %d 3 RDLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 3 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 3 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 2 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 2 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
DISPLAY("TASK %d 1 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(rwl);
DISPLAY("TASK %d 1 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
}
rt_make_soft_real_time();
pthread_barrier_wait(&barrier);
DISPLAY("TASK %d EXITED\n", idx);
return NULL;
}
static void *fun(int idx)
{
unsigned int loops = LOOPS;
while(loops--) {
rt_printk("TASK %d 1 COND/TIMED PREWLOCKED\n", idx);
if (idx%2) {
if (pthread_rwlock_trywrlock(&rwl)) {
rt_printk("TASK %d 1 COND PREWLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(&rwl);
}
} else {
struct timespec abstime;
abstime.tv_sec = llimd(rt_get_cpu_time_ns(), 1, 1000000000);
abstime.tv_nsec = 20000;
if (pthread_rwlock_timedwrlock(&rwl, &abstime) < 0) {
rt_printk("TASK %d 1 TIMED PREWLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(&rwl);
}
}
rt_printk("TASK %d 1 WLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 COND PREWLOCK\n", idx);
if (pthread_rwlock_trywrlock(&rwl)) {
rt_printk("TASK %d 2 COND PREWLOCK FAILED GO UNCOND\n", idx);
pthread_rwlock_wrlock(&rwl);
}
rt_printk("TASK %d 2 WLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PREWLOCK\n", idx);
pthread_rwlock_wrlock(&rwl);
rt_printk("TASK %d 3 WLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PREWUNLOCK\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 3 WUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 PREWUNLOCK\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 2 WUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 PREWUNLOCKED\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 1 WUNLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 COND/TIMED PRERDLOCKED\n", idx);
if (idx%2) {
if (pthread_rwlock_tryrdlock(&rwl)) {
rt_printk("TASK %d 1 COND PRERDLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(&rwl);
}
} else {
struct timespec abstime;
abstime.tv_sec = llimd(rt_get_cpu_time_ns(), 1, 1000000000);
abstime.tv_nsec = 20000;
if (pthread_rwlock_timedrdlock(&rwl, &abstime) < 0) {
rt_printk("TASK %d 1 TIMED PRERDLOCKED FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(&rwl);
}
}
rt_printk("TASK %d 1 RDLOCKED\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 COND PRERDLOCK\n", idx);
if (pthread_rwlock_tryrdlock(&rwl)) {
rt_printk("TASK %d 2 COND PRERDLOCK FAILED GO UNCOND\n", idx);
pthread_rwlock_rdlock(&rwl);
}
rt_printk("TASK %d 2 RDLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PRERDLOCK\n", idx);
pthread_rwlock_rdlock(&rwl);
rt_printk("TASK %d 3 RDLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 3 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 3 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 2 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 2 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
rt_printk("TASK %d 1 PRERDUNLOCK\n", idx);
pthread_rwlock_unlock(&rwl);
rt_printk("TASK %d 1 RDUNLOCK\n", idx);
rt_busy_sleep(100000);
}
extcnt[idx - 1] = loops;
rt_sleep(nano2count(10000000));
rt_printk("TASK %d EXITED\n", idx);
cleanup = 1;
return 0;
}
