static void driver(int t)
{
RT_TASK *thread[NTASKS];
int i, l;
unsigned int msg = 0;
RTIME now;
for (i = 1; i < NTASKS; i++) {
thread[0] = rt_receive(0, &msg);
thread[msg] = thread[0];
}
for (i = 1; i < NTASKS; i++) {
rt_return(thread[i], i);
}
now = rt_get_time();
rt_task_make_periodic(rt_whoami(), now + NTASKS*tick_period, tick_period);
msg = 0;
l = LOOPS;
while(l--) {
for (i = 1; i < NTASKS; i++) {
cpu_used[hard_cpu_id()]++;
if (i%2) {
rt_rpc(thread[i], msg, &msg);
} else {
rt_send(thread[i], msg);
msg = 1 - msg;
}
rt_task_wait_period();
}
}
for (i = 1; i < NTASKS; i++) {
rt_send(thread[i], END);
}
}
void *thread_fun(void *arg)
{
funtask = rt_task_init_schmod(0xcaccb, 0, 0, 0, SCHED_FIFO, 0x1);
rt_printk("FUN INIT\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
if (!SNDBRCV) {
rt_sleep(nano2count(100000000));
}
if (USE_RPC) {
unsigned long msg;
rt_printk("FUN RPC\n");
rt_rpc(maintask, 0, &msg);
} else {
rt_printk("FUN SEND\n");
rt_send(maintask, 0);
rt_printk("FUN SUSP\n");
rt_task_suspend(funtask);
}
rt_printk("FUN DONE\n");
rt_task_delete(funtask);
rt_printk("FUN END\n");
return 0;
}
void CommandChrono_Get(char *command)
{
static RT_TASK *ackn = 0;
unsigned int get = 'd';
unsigned long msg;
if (ackn != &Chrono) {
ackn = rt_rpc(&Chrono, get, &msg);
}
rt_receive(&Chrono, &msg);
*command = (char)msg;
}
static void *rt_BaseRate(void *args)
{
char name[7];
int i;
static RTIME t0;
for (i = 0; i < MAX_NTARGETS; i++) {
sprintf(name,"BRT%d",i);
if (!rt_get_adr(nam2num(name))) break;
}
if (!(rt_BaseRateTask = rt_task_init_schmod(nam2num(name), *((int *)args), 0, 0, SCHED_FIFO, CpuMap))) {
fprintf(stderr,"Cannot init rt_BaseRateTask.\n");
return (void *)1;
}
sem_post(&err_sem);
iopl(3);
rt_task_use_fpu(rt_BaseRateTask, 1);
MXmain();
grow_and_lock_stack(stackinc);
if (UseHRT) {
rt_make_hard_real_time();
}
rt_rpc(rt_MainTask, 0, (void *)name);
t0 = rt_get_cpu_time_ns();
rt_task_make_periodic(rt_BaseRateTask, rt_get_time() + rt_BaseRateTick, rt_BaseRateTick);
while (!endBaseRate) {
#ifdef TASKDURATION
RTTSKper=rt_get_cpu_time_ns()-RTTSKinit;
#endif
WaitTimingEvent(TimingEventArg);
if (endBaseRate) break;
APPLICATION_Process_Event(TIME_EV);
SIM_TIME = (rt_get_cpu_time_ns() - t0)*1.0E-9;
#ifdef TASKDURATION
RTTSKinit=rt_get_cpu_time_ns();
#endif
}
if (UseHRT) {
rt_make_soft_real_time();
}
rt_task_delete(rt_BaseRateTask);
return 0;
}
void CommandClock_Get(char *command)
{
static RT_TASK *ackn = 0;
unsigned int get = 'b';
unsigned long msg;
if (ackn != rt_get_adr(nam2num("CLKTSK"))) {
ackn = rt_rpc(rt_get_adr(nam2num("CLKTSK")), get, &msg);
}
rt_receive(rt_get_adr(nam2num("CLKTSK")), &msg);
*command = (char)msg;
}
void Display_Get(MenageHmsh_tChain11 *chain, Display_tDest *receiver)
{
static RT_TASK *ackn = 0;
unsigned int get = 'g';
unsigned long msg;
if (ackn != &Display) {
ackn = rt_rpc(&Display, get, &msg);
}
rt_receive(&Display, &msg);
*chain = *((MenageHmsh_tChain11 *)msg);
*receiver = chain->chain[0] == 't' ? destChrono : destClock;
}
void Display_Get(MenageHmsh_tChain11 *chain, Display_tDest *receiver)
{
static RT_TASK *ackn = 0;
unsigned int get = 'g';
unsigned long msg;
if (ackn != rt_get_adr(nam2num("DSPTSK"))) {
ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), get, &msg);
}
rt_receive(rt_get_adr(nam2num("DSPTSK")), &msg);
*chain = *((MenageHmsh_tChain11 *)msg);
*receiver = chain->chain[0] == 't' ? destChrono : destClock;
}
void CommandChrono_Put(char command)
{
static RT_TASK *ackn = 0;
unsigned int put = 'c';
unsigned long msg;
if (ackn != &Chrono) {
ackn = rt_rpc(&Chrono, put, &msg);
}
if ((Chronostatus == running) != (command == 'C')) {
rt_send(&Chrono, (unsigned int)command);
}
}
void CommandClock_Put(char command)
{
static RT_TASK *ackn = 0;
unsigned int put = 'a';
unsigned long msg;
if (ackn != rt_get_adr(nam2num("CLKTSK"))) {
ackn = rt_rpc(rt_get_adr(nam2num("CLKTSK")), put, &msg);
}
if (((Clockstatus == running) == (command == 'T')) || command == 'F') {
rt_send(rt_get_adr(nam2num("CLKTSK")), (unsigned int)command);
}
}
static void fun(int t)
{
unsigned int msg;
rt_rpc(&thread[0], t, &msg);
while(msg != END) {
cpu_used[hard_cpu_id()]++;
rt_receive(&thread[0], &msg);
rt_leds_set_mask(1,msg);
if (rt_isrpc(&thread[0])) {
rt_return(&thread[0], 1 - msg);
}
}
rt_leds_set_mask(1,0);
}
void Display_PutHour(MenageHmsh_tChain11 chain)
{
static MenageHmsh_tChain11 hours;
static RT_TASK *ackn = 0;
unsigned int put = 'p';
unsigned long msg;
if (ackn != &Display) {
ackn = rt_rpc(&Display, put, &msg);
}
hours = chain;
hours.chain[0] = 'h';
rt_send_if(&Display, (unsigned long)hours.chain);
}
void Display_PutHour(MenageHmsh_tChain11 chain)
{
static MenageHmsh_tChain11 hours;
static RT_TASK *ackn = 0;
unsigned int put = 'p';
unsigned long msg;
if (ackn != rt_get_adr(nam2num("DSPTSK"))) {
ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), put, &msg);
}
hours = chain;
hours.chain[0] = 'h';
rt_send_if(rt_get_adr(nam2num("DSPTSK")), (unsigned long)hours.chain);
}
void Display_PutTimes(MenageHmsh_tChain11 chain)
{
static MenageHmsh_tChain11 times;
static RT_TASK *ackn = 0;
unsigned int put = 'P';
unsigned long msg;
if (ackn != rt_get_adr(nam2num("DSPTSK"))) {
ackn = rt_rpc(rt_get_adr(nam2num("DSPTSK")), put, &msg);
}
times = chain;
times.chain[0] = 't';
rt_send_if(rt_get_adr(nam2num("DSPTSK")), (unsigned long)times.chain);
}
void Display_PutTimes(MenageHmsh_tChain11 chain)
{
static MenageHmsh_tChain11 times;
static RT_TASK *ackn = 0;
unsigned int put = 'P';
unsigned long msg;
if (ackn != &Display) {
ackn = rt_rpc(&Display, put, &msg);
}
times = chain;
times.chain[0] = 't';
rt_send_if(&Display, (unsigned long)times.chain);
}
static void sched_task(long t) {
int i, k;
unsigned long msg;
change = 0;
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_task_resume(thread + k);
}
}
t = rdtsc() - t;
rt_printk("\n\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), SUSP/RES SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
change = 1;
for (k = 0; k < ntasks; k++) {
rt_task_resume(thread + k);
}
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_sem_signal(&sem);
}
}
t = rdtsc() - t;
rt_printk("\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), SEM SIG/WAIT SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
change = 2;
for (k = 0; k < ntasks; k++) {
rt_sem_signal(&sem);
}
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_rpc(thread + k, 0, &msg);
}
}
t = rdtsc() - t;
rt_printk("\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), RPC/RCV-RET SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
}
int main(void)
{
pthread_t thread;
unsigned int player, cnt;
unsigned long msg;
RT_TASK *mytask;
MBX *mbx;
char data[BUFSIZE];
signal(SIGINT, endme);
rt_allow_nonroot_hrt();
if ((player = open("../../../share/linux.au", O_RDONLY)) < 0) {
printf("ERROR OPENING SOUND FILE (linux.au)\n");
exit(1);
}
if (!(mytask = rt_task_init(nam2num("SNDMAS"), 2, 0, 0))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
mlockall(MCL_CURRENT | MCL_FUTURE);
printf("\nINIT MASTER TASK %p\n\n(CTRL-C TO END EVERYTHING)\n", mytask);
mbx = rt_typed_named_mbx_init("SNDMBX", 2000, FIFO_Q);
rt_set_oneshot_mode();
start_rt_timer(0);
thread = rt_thread_create(intr_handler, NULL, 10000);
rt_mbx_receive(mbx, &data, 1);
while (!end) {
lseek(player, 0, SEEK_SET);
while(!end && (cnt = read(player, &data, BUFSIZE)) > 0) {
rt_mbx_send(mbx, data, cnt);
}
}
rt_rpc(rt_get_adr(nam2num("SOUND")), msg, &msg);
while (rt_get_adr(nam2num("SOUND"))) {
rt_sleep(nano2count(1000000));
}
rt_task_delete(mytask);
rt_mbx_delete(mbx);
stop_rt_timer();
close(player);
printf("\nEND MASTER TASK %p\n", mytask);
rt_thread_join(thread);
return 0;
}
int main(void)
{
RT_TASK *receiving_task;
RT_TASK *agentask;
int i, *shm;
unsigned int msg, chksum;
struct sched_param mysched;
mysched.sched_priority = 99;
if( sched_setscheduler( 0, SCHED_FIFO, &mysched ) == -1 ) {
puts(" ERROR IN SETTING THE SCHEDULER UP");
perror( "errno" );
exit( 0 );
}
mlockall(MCL_CURRENT | MCL_FUTURE);
receiving_task = rt_task_init(nam2num("RTSK"), 0, 0, 0);
agentask = rt_get_adr(nam2num("ATSK"));
shm = rtai_malloc(nam2num("MEM"), 1);
while(1) {
printf("RECEIVING TASK RPCS TO AGENT TASK %x\n", 0xaaaaaaaa);
rt_rpc(agentask, 0xaaaaaaaa, &msg);
printf("AGENT TASK RETURNED %x\n", msg);
if (msg != 0xeeeeeeee) {
chksum = 0;
for (i = 1; i <= shm[0]; i++) {
chksum += shm[i];
}
printf("RECEIVING TASK: CHECKSUM = %x\n", chksum);
if (chksum != shm[shm[0] + 1]) {
printf("RECEIVING TASK: WRONG SHMEM CHECKSUM\n");
}
printf("RECEIVING TASK SENDS TO AGENT TASK %x\n", 0xaaaaaaaa);
rt_send(agentask, 0xaaaaaaaa);
} else {
printf("RECEIVING TASK DELETES ITSELF\n");
rt_task_delete(receiving_task);
printf("END RECEIVING TASK\n");
exit(1);
}
}
return 0;
}
int rt_Send(pid_t pid, void *smsg, void *rmsg, size_t ssize, size_t rsize)
{
RT_TASK *task, *replier;
MSGCB cb;
unsigned int replylen;
if ((task = pid2rttask(pid))) {
cb.cmd = SYNCMSG;
cb.sbuf = smsg;
cb.sbytes = ssize;
cb.rbuf = rmsg;
cb.rbytes = rsize;
if (!(replier = rt_rpc(task, (unsigned int)&cb, &replylen))) {
return -EINVAL;
} else if (replier != task) {
return -ESRCH;
}
return replylen ;
}
return -ESRCH;
}
// What a proxy agent is supposed to do for synchronous IPC.
static void Proxy_Task(RT_TASK *me)
{
struct proxy_t *my;
MSGCB cb;
unsigned int replylen;
my = (struct proxy_t *)me->stack_bottom;
cb.cmd = PROXY;
cb.sbuf = my->msg;
cb.sbytes = my->nbytes;
cb.rbuf = &replylen;
cb.rbytes = sizeof(replylen);
while(1) {
while (my->nmsgs) {
atomic_dec((atomic_t *)&my->nmsgs);
rt_rpc(my->receiver, (unsigned int)(&cb), &replylen);
}
rt_task_suspend(me);
}
}
int main(void)
{
fd_set input;
struct timeval tv;
unsigned int msg, ch;
MBX *mbx;
struct sample { long long min; long long max; int index; double s; int ts; } samp;
tv.tv_sec = 0;
if (!(task = rt_task_init(nam2num("LATCHK"), 20, 0, 0))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
if (!(mbx = rt_get_adr(nam2num("LATMBX")))) {
printf("CANNOT FIND MAILBOX\n");
exit(1);
}
while (1) {
rt_mbx_receive(mbx, &samp, sizeof(samp));
printf("*** min: %d, max: %d average: %d, dot %f ts %d (ent ends check, a/ent both) ***\n", (int) samp.min, (int) samp.max, samp.index, samp.s, samp.ts);
FD_ZERO(&input);
FD_SET(0, &input);
tv.tv_usec = 20000;
if (select(1, &input, NULL, NULL, &tv)) {
ch = getchar();
break;
}
}
if (ch == 'a') {
rt_rpc(rt_get_adr(nam2num("LATCAL")), msg, &msg);
}
rt_task_delete(task);
exit(0);
}
int main(int argc, char* argv[])
{
unsigned long mtsk_name = nam2num("MTSK");
unsigned long btsk_name = nam2num("BTSK");
unsigned long sem_name = nam2num("SEM");
unsigned long smbx_name = nam2num("SMBX");
unsigned long rmbx_name = nam2num("RMBX");
unsigned long msg;
long long mbx_msg;
long long llmsg = 0xaaaaaaaaaaaaaaaaLL;
RT_TASK *mtsk, *rcvd_from;
SEM *sem;
MBX *smbx, *rmbx;
int pid, count;
if (!(mtsk = rt_task_init_schmod(mtsk_name, 0, 0, 0, SCHED_FIFO, 0x1))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
printf("MASTER TASK INIT: name = %lx, address = %p.\n", mtsk_name, mtsk);
printf("MASTER TASK STARTS THE ONESHOT TIMER\n");
rt_set_oneshot_mode();
start_rt_timer(nano2count(10000000));
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
rt_sleep(1000000);
printf("MASTER TASK MAKES ITSELF PERIODIC WITH A PERIOD OF 1 ms\n");
rt_task_make_periodic(mtsk, rt_get_time(), nano2count(PERIOD));
rt_sleep(nano2count(1000000000));
count = PERIODIC_LOOPS;
printf("MASTER TASK LOOPS ON WAIT_PERIOD FOR %d PERIODS\n", count);
while(count--) {
printf("PERIOD %d\n", count);
rt_task_wait_period();
}
count = SLEEP_LOOPS;
printf("MASTER TASK LOOPS ON SLEEP 0.1 s FOR %d PERIODS\n", count);
while(count--) {
printf("SLEEPING %d\n", count);
rt_sleep(nano2count(DELAY));
}
printf("MASTER TASK YIELDS ITSELF\n");
rt_task_yield();
printf("MASTER TASK CREATES BUDDY TASK\n");
pid = fork();
if (!pid) {
execl("./slave", "./slave", NULL);
}
printf("MASTER TASK SUSPENDS ITSELF, TO BE RESUMED BY BUDDY TASK\n");
rt_task_suspend(mtsk);
printf("MASTER TASK RESUMED BY BUDDY TASK\n");
if (!(sem = rt_sem_init(sem_name, 0))) {
printf("CANNOT CREATE SEMAPHORE %lx\n", sem_name);
exit(1);
}
printf("MASTER TASK CREATES SEM: name = %lx, address = %p.\n", sem_name, sem);
printf("MASTER TASK WAIT_IF ON SEM\n");
rt_sem_wait_if(sem);
printf("MASTER STEP BLOCKS WAITING ON SEM\n");
rt_sem_wait(sem);
printf("MASTER TASK SIGNALLED BY BUDDY TASK WAKES UP AND BLOCKS WAIT TIMED 1 s ON SEM\n");
rt_sem_wait_timed(sem, nano2count(1000000000));
printf("MASTER TASK DELETES SEM\n");
rt_sem_delete(sem);
printf("MASTER TASK BLOCKS RECEIVING FROM ANY\n");
rcvd_from = rt_receive(0, (void *)&msg);
printf("MASTER TASK RECEIVED MESSAGE %lx FROM BUDDY TASK\n", msg);
printf("MASTER TASK RPCS TO BUDDY TASK THE MESSAGE %lx\n", 0xabcdefL);
rcvd_from = rt_rpc(rcvd_from, 0xabcdef, (void *)&msg);
printf("MASTER TASK RECEIVED THE MESSAGE %lx RETURNED BY BUDDY TASK\n", msg);
//exit(1);
if (!(smbx = rt_mbx_init(smbx_name, 1))) {
printf("CANNOT CREATE MAILBOX %lx\n", smbx_name);
exit(1);
}
if (!(rmbx = rt_mbx_init(rmbx_name, 1))) {
printf("CANNOT CREATE MAILBOX %lx\n", rmbx_name);
exit(1);
}
printf("MASTER TASK CREATED TWO MAILBOXES %p %p %p %p \n", smbx, rmbx, &mtsk_name, &msg);
count = MBX_LOOPS;
while(count--) {
rt_mbx_send(smbx, &llmsg, sizeof(llmsg));
printf("%d MASTER TASK SENDS THE MESSAGE %llx MBX\n", count, llmsg);
mbx_msg = 0;
rt_mbx_receive_timed(rmbx, &mbx_msg, sizeof(mbx_msg), nano2count(MSG_DELAY));
printf("%d MASTER TASK RECEIVED THE MESSAGE %llx FROM MBX\n", count, mbx_msg);
rt_sleep(nano2count(DELAY));
}
printf("MASTER TASK SENDS THE MESSAGE %lx TO BUDDY TO ALLOW ITS END\n", 0xeeeeeeeeL);
rt_send(rcvd_from, 0xeeeeeeee);
printf("MASTER TASK WAITS FOR BUDDY TASK END\n");
while (rt_get_adr(btsk_name)) {
rt_sleep(nano2count(1000000000));
}
printf("MASTER TASK STOPS THE PERIODIC TIMER\n");
stop_rt_timer();
printf("MASTER TASK DELETES MAILBOX %p\n", smbx);
rt_mbx_delete(smbx);
printf("MASTER TASK DELETES MAILBOX %p\n", rmbx);
rt_mbx_delete(rmbx);
printf("MASTER TASK DELETES ITSELF\n");
rt_task_delete(mtsk);
printf("END MASTER TASK\n");
return 0;
}
int main(void)
{
RTIME tsr, tss, tsm, trpc;
RT_TASK *mainbuddy;
int i, k, s;
unsigned long msg;
printf("\n\nWait for it ...\n");
if (!(mainbuddy = rt_thread_init(nam2num("MASTER"), 1000, 0, SCHED_FIFO, 0x1))) {
printf("CANNOT INIT TASK %lu\n", nam2num("MASTER"));
exit(1);
}
sem = rt_sem_init(nam2num("SEMAPH"), 1);
change = 0;
for (i = 0; i < NR_RT_TASKS; i++) {
indx[i] = i;
if (!(thread[i] = rt_thread_create(thread_fun, indx + i, 0))) {
printf("ERROR IN CREATING THREAD %d\n", indx[i]);
exit(1);
}
}
do {
msleep(50);
s = 0;
for (i = 0; i < NR_RT_TASKS; i++) {
s += hrt[i];
}
} while (s != NR_RT_TASKS);
mlockall(MCL_CURRENT | MCL_FUTURE);
rt_make_hard_real_time();
tsr = rt_get_cpu_time_ns();
for (i = 0; i < LOOPS; i++) {
for (k = 0; k < NR_RT_TASKS; k++) {
rt_task_resume(mytask[k]);
}
}
tsr = rt_get_cpu_time_ns() - tsr;
change = 1;
for (k = 0; k < NR_RT_TASKS; k++) {
rt_task_resume(mytask[k]);
}
tss = rt_get_cpu_time_ns();
for (i = 0; i < LOOPS; i++) {
for (k = 0; k < NR_RT_TASKS; k++) {
rt_sem_signal(sem);
}
}
tss = rt_get_cpu_time_ns() - tss;
change = 2;
for (k = 0; k < NR_RT_TASKS; k++) {
rt_sem_signal(sem);
}
tsm = rt_get_cpu_time_ns();
for (i = 0; i < LOOPS; i++) {
for (k = 0; k < NR_RT_TASKS; k++) {
rt_send(mytask[k], 0);
}
}
tsm = rt_get_cpu_time_ns() - tsm;
change = 3;
for (k = 0; k < NR_RT_TASKS; k++) {
rt_send(mytask[k], 0);
}
trpc = rt_get_cpu_time_ns();
for (i = 0; i < LOOPS; i++) {
for (k = 0; k < NR_RT_TASKS; k++) {
rt_rpc(mytask[k], 0, &msg);
}
}
trpc = rt_get_cpu_time_ns() - trpc;
rt_make_soft_real_time();
printf("\n\nFOR %d TASKS: ", NR_RT_TASKS);
printf("TIME %d (ms), SUSP/RES SWITCHES %d, ", (int)(tsr/1000000), 2*NR_RT_TASKS*LOOPS);
printf("SWITCH TIME %d (ns)\n", (int)(tsr/(2*NR_RT_TASKS*LOOPS)));
printf("\nFOR %d TASKS: ", NR_RT_TASKS);
printf("TIME %d (ms), SEM SIG/WAIT SWITCHES %d, ", (int)(tss/1000000), 2*NR_RT_TASKS*LOOPS);
printf("SWITCH TIME %d (ns)\n", (int)(tss/(2*NR_RT_TASKS*LOOPS)));
printf("\nFOR %d TASKS: ", NR_RT_TASKS);
printf("TIME %d (ms), SEND/RCV SWITCHES %d, ", (int)(tsm/1000000), 2*NR_RT_TASKS*LOOPS);
printf("SWITCH TIME %d (ns)\n", (int)(tsm/(2*NR_RT_TASKS*LOOPS)));
printf("\nFOR %d TASKS: ", NR_RT_TASKS);
printf("TIME %d (ms), RPC/RCV-RET SWITCHES %d, ", (int)(tsm/1000000), 2*NR_RT_TASKS*LOOPS);
printf("SWITCH TIME %d (ns)\n\n", (int)(trpc/(2*NR_RT_TASKS*LOOPS)));
fflush(stdout);
end = 1;
for (i = 0; i < NR_RT_TASKS; i++) {
rt_rpc(mytask[i], 0, &msg);
}
do {
msleep(50);
s = 0;
for (i = 0; i < NR_RT_TASKS; i++) {
s += hrt[i];
}
} while (s);
rt_sem_delete(sem);
rt_task_delete(mainbuddy);
for (i = 0; i < NR_RT_TASKS; i++) {
rt_thread_join(thread[i]);
}
return 0;
}
