int init_module(void) { int i; DBG_PRINT_INIT; if (rt_task_init(&start_task, start_task_code, 0, 10000, 10, 0, 0) != 0) { printk("Could not start init task\n"); } if (rt_mbx_init(&mbx_in, NUM_TASKS*8) || rt_mbx_init(&mbx_out, NUM_TASKS*8)) { printk("could not create message queue\n"); return 1; } for (i = 0; i < NUM_TASKS; ++i) { rt_sem_init(&sems[i], 0); if (rt_task_init(&tasks[i], task_code, i, 3000, NUM_TASKS - i, 0, 0) != 0) { printk("rt_task_ipc_init failed\n"); return 1; } } #ifdef ONE_SHOT rt_set_oneshot_mode(); #endif start_rt_timer_ns(10000000); checkt = rdtsc(); checkj = jiffies; rt_task_resume(&start_task); for (i = 0; i < NUM_TASKS; ++i) { rt_task_resume(&tasks[i]); } return 0; }
static void mdlStart(SimStruct *S) { #ifndef MATLAB_MEX_FILE char name[7]; MBX *mbx; int i; #ifdef KRTAI i = mbx_rt_get_adr(TargetLedMbxID, MAX_RTAI_LEDS); sprintf(name, "%s%d", TargetLedMbxID, i); rtaiLed[i] = S; mbx = mbx_rt_mbx_init(name, (MBX_RTAI_LED_SIZE/(sizeof(unsigned int))*(sizeof(unsigned int)))); #else for (i = 0; i < MAX_RTAI_LEDS; i++) { sprintf(name, "%s%d", TargetLedMbxID, i); if (!rt_get_adr(nam2num(name))) break; } rtaiLed[i] = S; if (!(mbx = (MBX *)rt_mbx_init(nam2num(name), (MBX_RTAI_LED_SIZE/(sizeof(unsigned int))*(sizeof(unsigned int)))))) { printf("Cannot init mailbox\n"); exit(1); } #endif ssGetPWork(S)[0]= (void *)mbx; #endif }
static void mdlStart(SimStruct *S) { #ifndef MATLAB_MEX_FILE MBX *mbx; char name[7]; int i; int_T *dim = ssGetInputPortDimensions(S,0); #ifdef KRTAI i = mbx_rt_get_adr(TargetLogMbxID,MAX_RTAI_LOGS); sprintf(name, "%s%d", TargetLogMbxID, i); rtaiLog[i] = S; mbx = mbx_rt_mbx_init(name, (MBX_RTAI_LOG_SIZE/(dim[0]*dim[1]*sizeof(float))*(dim[0]*dim[1]*sizeof(float)))); #else for (i = 0; i < MAX_RTAI_LOGS; i++) { sprintf(name, "%s%d", TargetLogMbxID, i); if (!rt_get_adr(nam2num(name))) break; } rtaiLog[i] = S; if (!(mbx = (MBX *)rt_mbx_init(nam2num(name), (MBX_RTAI_LOG_SIZE/(dim[0]*dim[1]*sizeof(float))*(dim[0]*dim[1]*sizeof(float)))))) { printf("Cannot init mailbox\n"); exit(1); } #endif ssGetPWork(S)[0] = (void *)mbx; #endif }
static int init_module(void) { int i; rt_set_oneshot_mode(); start_rt_timer(0); sync_sem = rt_sem_init(nam2num("SYNCSM"), 0); prio_sem = rt_sem_init(nam2num("PRIOSM"), 0); if (!(mbx_in = rt_mbx_init(nam2num("MBXIN"), NUM_TASKS*8)) || !(mbx_out = rt_mbx_init(nam2num("MBXOUT"), NUM_TASKS*8))) { printf("could not create message queues\n"); return 1; } for (i = 0; i < NUM_TASKS; ++i) { sems[i] = rt_sem_init(nam2num(sem[i]), 0); } end_sem = rt_typed_sem_init(nam2num("ENDSEM"), 0, CNT_SEM); print_sem = rt_typed_sem_init(nam2num("PRTSEM"), 1, BIN_SEM); return 0; }
int init_module(void) { tasknode = ddn2nl(TaskNode); rt_mbx_init(&mbx, 1); rt_register(nam2num("HDLMBX"), &mbx, IS_MBX, 0); rt_task_init(&sup_task, sup_fun, 0, 2000, 1, 0, 0); rt_task_resume(&sup_task); rt_request_timer(timer_tick, imuldiv(PERIOD, FREQ_8254, 1000000000), 0); return 0; }
int main(void) { RT_TASK *spktsk, *plrtsk; RTIME period; MBX *mbx; char data, temp; unsigned int msg, i; // ioperm(PORT_ADR, 1, 1); iopl(3); if (!(spktsk = rt_task_init_schmod(nam2num("SPKTSK"), 1, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT SPEAKER TASK\n"); exit(1); } mbx = rt_mbx_init(nam2num("SNDMBX"), 4000); printf("\nSPEAKER TASK RUNNING\n"); rt_set_oneshot_mode(); start_rt_timer(0); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); period = nano2count(PERIOD); rt_task_make_periodic(spktsk, rt_get_time() + 5*period, period); for (i = 0; i < 100; i++) { plrtsk = rt_receive(0, &msg); rt_return(plrtsk, msg); } while(1) { if (!rt_mbx_receive_if(mbx, &data, 1)) { data = filter(data); temp = inb(PORT_ADR); temp &= 0xfd; temp |= (data & 1) << 1; outb(temp, PORT_ADR); } rt_task_wait_period(); if ((plrtsk = rt_receive_if(0, &msg))) { rt_return(plrtsk, msg); break; } } rt_sleep(nano2count(100000000)); rt_make_soft_real_time(); rt_mbx_delete(mbx); stop_rt_timer(); rt_task_delete(spktsk); printf("\nSPEAKER TASK STOPS\n"); return 0; }
/*** * rt_stack_mgr_init */ int rt_stack_mgr_init (struct rtnet_mgr *mgr) { int ret = 0; if ( (ret=rt_mbx_init (&(mgr->mbx), sizeof(struct rtnet_msg))) ) return ret; if ( (ret=rt_task_init(&(mgr->task), &do_stacktask, (int)mgr, 4096, RTNET_STACK_PRIORITY, 0, 0)) ) return ret; if ( (ret=rt_task_resume(&(mgr->task))) ) return ret; return (ret); }
int main(int argc, char *argv[]) { unsigned long rcvnode; RT_TASK *sndtsk, *rcvtsk; MBX *mbx; long rcvport, i; struct sockaddr_in addr; thread = rt_thread_create(endme, NULL, 2000); if (!(sndtsk = rt_task_init_schmod(nam2num("SNDTSK"), 1, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT SENDER TASK\n"); exit(1); } rcvnode = 0; if (argc == 2 && strstr(argv[1], "RcvNode=")) { inet_aton(argv[1] + 8, &addr.sin_addr); rcvnode = addr.sin_addr.s_addr; } if (!rcvnode) { inet_aton("127.0.0.1", &addr.sin_addr); rcvnode = addr.sin_addr.s_addr; } mbx = rt_mbx_init(nam2num("SNDMBX"), 500); while ((rcvport = rt_request_port(rcvnode)) <= 0 && rcvport != -EINVAL); printf("\nSENDER TASK RUNNING\n"); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); for (i = 0; i < MAXLOOPS && !end; i++) { rt_mbx_send(mbx, &i, sizeof(long)); rt_printk("SENT %ld\n", i); RT_sleep(rcvnode, rcvport, 200000000); } i = -1; rt_mbx_send(mbx, &i, sizeof(long)); rt_make_soft_real_time(); while (!(rcvtsk = RT_get_adr(rcvnode, rcvport, "RCVTSK"))) { RT_sleep(rcvnode, rcvport, 100000000); } RT_rpc(rcvnode, rcvport, rcvtsk, i, &i); rt_release_port(rcvnode, rcvport); rt_mbx_delete(mbx); rt_task_delete(sndtsk); printf("\nSENDER TASK STOPS\n"); return 0; }
int main(void) { unsigned int player, msg, cnt; RT_TASK *mytask; MBX *mbx; char data[BUFSIZE]; signal(SIGINT, endme); // rt_allow_nonroot_hrt(); if ((player = open("../../examples/sound/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_mbx_init(nam2num("SNDMBX"), 2000); rt_set_oneshot_mode(); start_rt_timer(0); pthread_create(&thread, NULL, intr_handler, NULL); 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); pthread_join(thread, NULL); return 0; }
int init_module(void) { int i; rt_set_oneshot_mode(); start_rt_timer(0); rt_mbx_init(&mbx, 5); for (i = 0; i < NUM_TASKS; i++) { rt_task_init(&task[i], fun1, i, STACK_SIZE, 0, 0, 0); rt_task_resume(&task[i]); } rt_task_init(&task[NUM_TASKS], fun2, NUM_TASKS, STACK_SIZE, 1, 0, 0); rt_task_resume(&task[NUM_TASKS]); while (atomic_read(&cleanup) < (NUM_TASKS + 1)) { current->state = TASK_INTERRUPTIBLE; schedule_timeout(HZ/10); } return 0; }
static void mdlStart(SimStruct *S) { #ifndef MATLAB_MEX_FILE MBX *mbx; #ifdef KRTAI rtaiSynchronoscope = S; mbx = mbx_rt_mbx_init(TargetSynchronoscopeMbxID, (MBX_RTAI_SYNCHRONOSCOPE_SIZE/(sizeof(float))*(sizeof(float)))); #else rtaiSynchronoscope = S; if (!(mbx = (MBX *)rt_mbx_init(nam2num(TargetSynchronoscopeMbxID), (MBX_RTAI_SYNCHRONOSCOPE_SIZE/(sizeof(float))*(sizeof(float)))))) { printf("Cannot init mailbox\n"); exit(1); } #endif ssGetPWork(S)[0]= (void *)mbx; #endif }
/**** * Initialize the realtime txqueue wakeup manager and its mailbox. */ int rt_wakeup_mgr_init (struct rtnet_mgr *mgr) { int ret = 0; if ( (ret=rt_mbx_init (&(mgr->mbx), sizeof(struct rtnet_msg))) ) return ret; if ( (ret=rt_task_init(&(mgr->task), &rt_wakeup_manager_task, (int)mgr, 4096, RTNET_RT_WAKEUP_PRIORITY, 0, 0)) ) goto rt_mbox_err; if ( (ret=rt_task_resume(&(mgr->task))) ) goto rt_task_err; return (ret); rt_task_err: rt_task_delete(&(mgr->task)); rt_mbox_err: rt_mbx_delete(&(mgr->mbx)); return (ret); }
int main(int argc, char *argv[]) { unsigned long sndnode; long sndport, i, r; RT_TASK *rcvtsk, *sndtsk; struct sockaddr_in addr; static MBX *sndmbx; SERVER = atoi(argv[1]); if (!(rcvtsk = rt_task_init_schmod(nam2num("RCVTSK"), 2, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT RECEIVER TASK\n"); exit(1); } mbx = rt_mbx_init(nam2num("MBX"), 100); athread = rt_thread_create(async_fun, NULL, 10000); sndnode = 0; if (argc == 3 && strstr(argv[2], "SndNode=")) { inet_aton(argv[2] + 8, &addr.sin_addr); sndnode = addr.sin_addr.s_addr; } if (!sndnode) { inet_aton("127.0.0.1", &addr.sin_addr); sndnode = addr.sin_addr.s_addr; } rt_set_oneshot_mode(); start_rt_timer(0); while ((sndport = rt_request_port_mbx(sndnode, mbx)) <= 0 && sndport != -EINVAL); while (!(sndmbx = RT_get_adr(sndnode, sndport, "SNDMBX"))) { rt_sleep(nano2count(100000000)); } sndtsk = RT_get_adr(sndnode, sndport, "SNDTSK"); printf("\nRECEIVER TASK RUNNING\n"); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); while (!end) { r = RT_mbx_receive(sndnode, -sndport, sndmbx, &i, sizeof(long)); rt_printk("RECEIVE %ld %ld\n", r, i); if (SERVER) { rt_sleep(nano2count(100000000)); } else { while (!end && rt_waiting_return(sndnode, sndport)) { rt_sleep(nano2count(1000000)); } if (!end) { unsigned long long retval; long i1, i2; int l1, l2; if (rt_sync_net_rpc(sndnode, -sndport)) { l1 = l2 = sizeof(long); rt_get_net_rpc_ret(mbx, &retval, &i1, &l1, &i2, &l2, 0LL, MBX_RECEIVE); rt_printk("RECEIVER ASYNC MSG: RETVAL = %d, MSG = %ld, LEN = %d.\n", (int)retval, i1, l1); if (i1 < 0) { end = 1; break; } } } } } rt_mbx_delete(mbx); rt_release_port(sndnode, sndport); rt_make_soft_real_time(); rt_thread_join(athread); rt_return(rt_receive(0, &i), i); rt_task_delete(rcvtsk); stop_rt_timer(); printf("\nRECEIVER TASK STOPS\n"); return 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(int argc, char *argv[]) { int diff; int sample; long average; int min_diff; int max_diff; int period; int i; RTIME t, svt; RTIME expected, exectime[3]; MBX *mbx; RT_TASK *task, *latchk; struct sample { long long min; long long max; int index, ovrn; } samp; double s = 0.0, sref; long long max = -1000000000, min = 1000000000; signal(SIGINT, endme); signal(SIGKILL, endme); signal(SIGTERM, endme); if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) { printf("CANNOT CREATE MAILBOX\n"); exit(1); } if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT MASTER LATENCY TASK\n"); exit(1); } printf("\n## RTAI latency calibration tool ##\n"); printf("# period = %i (ns) \n", PERIOD); printf("# average time = %i (s)\n", (int)AVRGTIME); printf("# use the FPU\n"); printf("#%sstart the timer\n", argc == 1 ? " " : " do not "); printf("# timer_mode is %s\n", TIMER_MODE ? "periodic" : "oneshot"); printf("\n"); if (!(hard_timer_running = rt_is_hard_timer_running())) { if (TIMER_MODE) { rt_set_periodic_mode(); } else { rt_set_oneshot_mode(); } period = start_rt_timer(nano2count(PERIOD)); } else { period = nano2count(PERIOD); } for(i = 0; i < MAXDIM; i++) { a[i] = b[i] = 3.141592; } sref = dot(a, b, MAXDIM); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); expected = rt_get_time() + 200*period; rt_task_make_periodic(task, expected, period); svt = rt_get_cpu_time_ns(); i = 0; samp.ovrn = 0; while (!end) { min_diff = 1000000000; max_diff = -1000000000; average = 0; for (sample = 0; sample < SMPLSXAVRG && !end; sample++) { expected += period; if (!rt_task_wait_period()) { if (TIMER_MODE) { diff = (int) ((t = rt_get_cpu_time_ns()) - svt - PERIOD); svt = t; } else { diff = (int) count2nano(rt_get_time() - expected); } } else { samp.ovrn++; diff = 0; if (TIMER_MODE) { svt = rt_get_cpu_time_ns(); } } outb(i = 1 - i, 0x378); if (diff < min_diff) { min_diff = diff; } if (diff > max_diff) { max_diff = diff; } average += diff; s = dot(a, b, MAXDIM); if (fabs((s - sref)/sref) > 1.0e-15) { printf("\nDOT PRODUCT RESULT = %20.16e %20.16e %20.16e\n", s, sref, fabs((s - sref)/sref)); return 0; } } samp.min = min_diff; samp.max = max_diff; samp.index = average/SMPLSXAVRG; #if SOLO if (max < samp.max) max = samp.max; if (min > samp.min) min = samp.min; rt_printk("SOLO * min: %lld/%lld, max: %lld/%lld average: %d (%d) <Hit [RETURN] to stop> *\n", samp.min, min, samp.max, max, samp.index, samp.ovrn); #else rt_mbx_send_if(mbx, &samp, sizeof(samp)); if ((latchk = rt_get_adr(nam2num("LATCHK"))) && (rt_receive_if(latchk, &average) || end)) { rt_return(latchk, average); break; } #endif } while (rt_get_adr(nam2num("LATCHK"))) { rt_sleep(nano2count(1000000)); } rt_make_soft_real_time(); if (!hard_timer_running) { stop_rt_timer(); } rt_get_exectime(task, exectime); if (exectime[1] && exectime[2]) { printf("\n>>> S = %g, EXECTIME = %G\n", s, (double)exectime[0]/(double)(exectime[2] - exectime[1])); } rt_task_delete(task); rt_mbx_delete(mbx); return 0; }
int main(int argc, char *argv[]) { int diff; int skip; long average; int min_diff; int max_diff; int period; int i; RTIME t, svt; RTIME expected, exectime[3]; MBX *mbx; RT_TASK *task, *latchk; struct sample { long long min; long long max; int index, ovrn; } samp; double s; signal(SIGHUP, endme); signal(SIGKILL, endme); signal(SIGTERM, endme); signal(SIGALRM, endme); if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) { printf("CANNOT CREATE MAILBOX\n"); exit(1); } if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT MASTER TASK\n"); exit(1); } printf("\n## RTAI latency calibration tool ##\n"); printf("# period = %i (ns) \n", PERIOD); printf("# average time = %i (s)\n", (int)AVRGTIME); printf("# use the FPU\n"); printf("#%sstart the timer\n", argc == 1 ? " " : " do not "); printf("# timer_mode is %s\n", TIMER_MODE ? "periodic" : "oneshot"); printf("\n"); if (argc == 1) { if (TIMER_MODE) { rt_set_periodic_mode(); } else { rt_set_oneshot_mode(); } period = start_rt_timer(nano2count(PERIOD)); } else { period = nano2count(PERIOD); } for(i = 0; i < MAXDIM; i++) { a[i] = b[i] = 3.141592; } s = dot(a, b, MAXDIM); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); rt_task_make_periodic(task, expected = rt_get_tscnt() + 10*period, period); svt = rt_get_cpu_time_ns(); samp.ovrn = i = 0; while (!end) { min_diff = 1000000000; max_diff = -1000000000; average = 0; for (skip = 0; skip < SKIP && !end; skip++) { expected += period; if (!rt_task_wait_period()) { if (TIMER_MODE) { diff = (int) ((t = rt_get_cpu_time_ns()) - svt - PERIOD); svt = t; } else { diff = (int) count2nano(rt_get_tscnt() - expected); } } else { samp.ovrn++; diff = 0; if (TIMER_MODE) { svt = rt_get_cpu_time_ns(); } } if (diff < min_diff) { min_diff = diff; } if (diff > max_diff) { max_diff = diff; } average += diff; s = dot(a, b, MAXDIM); } samp.min = min_diff; samp.max = max_diff; samp.index = average/SKIP; rt_mbx_send_if(mbx, &samp, sizeof(samp)); if ((latchk = rt_get_adr(nam2num("LATCHK"))) && (rt_receive_if(latchk, (unsigned long *)&average) || end)) { rt_return(latchk, (unsigned long)average); break; } } while (rt_get_adr(nam2num("LATCHK"))) { rt_sleep(nano2count(1000000)); } rt_make_soft_real_time(); if (argc == 1) { stop_rt_timer(); } rt_get_exectime(task, exectime); if (exectime[1] && exectime[2]) { printf("\n>>> S = %g, EXECTIME = %G\n", s, (double)exectime[0]/(double)(exectime[2] - exectime[1])); } rt_task_delete(task); rt_mbx_delete(mbx); return 0; }
int main(int argc, char *argv[]) { int diff; int skip; int average; int min_diff; int max_diff; int period; int i; RTIME expected, ts; MBX *mbx; RT_TASK *task; struct sample { long long min; long long max; int index; double s; int ts; } samp; double s; if (!(mbx = rt_mbx_init(nam2num("LATMBX"), 20*sizeof(samp)))) { printf("CANNOT CREATE MAILBOX\n"); exit(1); } if (!(task = rt_task_init_schmod(nam2num("LATCAL"), 0, 0, 0, SCHED_FIFO, 0xF))) { printf("CANNOT INIT MASTER TASK\n"); exit(1); } if (argc == 1) { rt_set_oneshot_mode(); start_rt_timer(0); } for(i = 0; i < MAXDIM; i++) { a[i] = b[i] = 3.141592; } vdot(a, b, MAXDIM); mlockall(MCL_CURRENT | MCL_FUTURE); rt_make_hard_real_time(); period = nano2count(PERIOD); rt_task_make_periodic(task, expected = rt_get_time() + 5*period, period); #ifdef OVERALL min_diff = 1000000000; max_diff = -1000000000; #endif while (1) { #ifndef OVERALL min_diff = 1000000000; max_diff = -1000000000; #endif average = 0; for (skip = 0; skip < SKIP; skip++) { expected += period; rt_task_wait_period(); diff = (int)count2nano(rt_get_time() - expected); if (diff < min_diff) { min_diff = diff; } if (diff > max_diff) { max_diff = diff; } average += diff; ts = rt_get_time(); s = vdot(a, b, MAXDIM); ts = rt_get_time() - expected; } samp.min = min_diff; samp.max = max_diff; samp.index = average/SKIP; samp.s = (double)s; samp.ts = (int)count2nano(ts); rt_mbx_send_if(mbx, &samp, sizeof(samp)); if (rt_receive_if(rt_get_adr(nam2num("LATCHK")), (unsigned int *)&average)) { rt_return(rt_get_adr(nam2num("LATCHK")), (unsigned int)average); break; } } while (rt_get_adr(nam2num("LATCHK"))) { rt_sleep(nano2count(1000000)); } rt_make_soft_real_time(); if (argc == 1) { stop_rt_timer(); } rt_task_delete(task); rt_mbx_delete(mbx); return 0; }
int main(int argc, char *argv[]) { RT_TASK *buddy, *logmsg_buddy; int i, narg, priority; char *optStr; priority = PRIORITY; narg = argc; for (i = 0; i < argc; i++) { if (strstr(argv[i], "p=")) { priority = atoi(argv[i] + 2); argv[i] = 0; narg--; continue; } if (strstr(argv[i], "o=")) { ovr_chk_stp = atoi(argv[i] + 2); argv[i] = 0; narg--; continue; } if (strstr(argv[i], "nohrt")) { use_hrt = 0; argv[i] = 0; narg--; continue; } } if (narg > 2) { printf("TOO MANY ARGS IN COMMAND LINE.\n"); return 1; } optStr = NULL; for (i = 1; i < argc; i++) { if (argv[i]) { optStr = argv[i]; break; } } if (optStr == NULL) { optStr = "\0"; } rt_allow_nonroot_hrt(); if (!(buddy = rt_task_init_schmod(nam2num("RTWPRG"), 98, 0, 0, SCHED_FIFO, 0xFFFFFFFF))) { printf("CANNOT INIT MAIN TASK BUDDY %p.\n", buddy); return 1; } #ifdef DBGPRT printf("MAIN TASK BUDDY CREATED %p, EXECUTION STARTED.\n", buddy); #endif logfile = fopen("rtw_log", "w"); if (!(logmbx = rt_mbx_init(nam2num("LOGMBX"), LOGMBX_SIZE))) { printf("CANNOT INIT LOG MSG SERVER SUPPORT MAILBOX %p.\n", logmbx); return 1; } #ifdef DBGPRT printf("LOG MSG SERVER SUPPORT MAILBOX CREATED %p.\n", logmbx); #endif iopl(3); pthread_create(&overuns_mon_thread, NULL, overuns_mon_fun, NULL); pthread_create(&logMsg_thread, NULL, logMsg_fun, &buddy); rt_receive(0, (unsigned int *)&logmsg_buddy); rtai_main_buddy = buddy; signal(SIGINT, endme); signal(SIGTERM, endme); #ifdef DBGPRT printf("LOG MSG SERVER BUDDY TASK CREATED %p, LOG MSG SERVER RUNNING.\n", buddy); printf ("CALLING RT_MAIN WITH: HRT %d, PRIORITY %d, OVRCHK %d (s), OPTSTR %s.\n", use_hrt, priority, ovr_chk_stp, optStr); #endif rt_main(MODEL, optStr, NULL, 0, priority, 0); #ifdef DBGPRT printf ("RT_MAIN RETURNED.\n"); #endif pthread_cancel(overuns_mon_thread); pthread_join(overuns_mon_thread, NULL); #ifdef DBGPRT printf("OVERUNS MONITOR STOPPED.\n"); #endif rt_task_delete(logmsg_buddy); pthread_cancel(logMsg_thread); pthread_join(logMsg_thread, NULL); #ifdef DBGPRT printf("LOG MSG SERVER BUDDY TASK %p DELETED, LOG MSG SERVER STOPPED.\n", buddy); #endif rt_mbx_delete(logmbx); #ifdef DBGPRT printf("LOG MSG SERVER SUPPORT MAILBOX %p DELETED.\n", logmbx); #endif rt_task_delete(buddy); #ifdef DBGPRT printf("MAIN TASK BUDDY DELETED %p, EXECUTION TERMINATED.\n", buddy); printf("\nTOTAL OVERUNS: %ld.\n", sysAuxClkOveruns()); #endif fprintf(logfile, "\nTOTAL OVERUNS: %ld.\n", sysAuxClkOveruns()); fclose(logfile); return 0; }