int main(){ rt_print_auto_init(1); mlockall(MCL_CURRENT|MCL_FUTURE); rt_task_shadow(NULL, "main", 5, T_CPU(0)|T_JOINABLE); #ifdef mutex rt_mutex_create(&a, "Mutex"); rt_mutex_create(&b, "b"); #endif rt_task_create(&task1, "Task1", 0, 1, T_CPU(0)|T_JOINABLE); rt_task_create(&task2, "Task2", 0, 2, T_CPU(0)|T_JOINABLE); rt_task_start(&task1, &semWait1, NULL); rt_task_start(&task2, &semWait2, NULL); rt_printf("sync \n"); rt_task_join(&task1); rt_task_join(&task2); #ifdef mutex rt_mutex_delete(&a); rt_mutex_delete(&b); #endif }
int main(int argc, char* argv[]) { signal(SIGTERM, catch_signal); //signal(SIGINT, catch_signal); int statusA, statusG, statusF, mutexacc, mutexgyro, i,j; logIndex = 0; // enable rt_task_print rt_print_auto_init(1); /* Avoids memory swapping for this program */ mlockall(MCL_CURRENT|MCL_FUTURE); // Create mutexs mutexgyro = rt_mutex_create(&mutex_gyro,NULL); if(mutexgyro!=0){ fprintf(stderr, "Unable to create gyroscope mutex! Exiting...\n"); exit(EXIT_FAILURE); } mutexacc = rt_mutex_create(&mutex_acc,NULL); if(mutexacc!=0){ fprintf(stderr, "Unable to create accelorometer mutex! Exiting...\n"); exit(EXIT_FAILURE); } isRunning = 1; /* * Arguments: &task, name, stack size (0=default), priority, * mode (FPU, start suspended, ...) */ statusA = rt_task_create(&accThread, NULL, 0, 0, T_JOINABLE); statusG = rt_task_create(&gyroThread, NULL, 0, 0, T_JOINABLE); statusF = rt_task_create(&fusThread, NULL, 0, 0, T_JOINABLE); /* * Arguments: &task, task function, function argument */ statusA = rt_task_start(&accThread, &accelerometer, NULL); statusG = rt_task_start(&gyroThread, &gyroscope, NULL); statusF = rt_task_start(&fusThread, &sensor_fusion, NULL); // threads in infinite loop, therefore this prevents the main from finishing // (and killing its threads) statusA = rt_task_join(&gyroThread); statusF = rt_task_join(&fusThread); statusG = rt_task_join(&accThread); printlog[logIndex] = 4000; for (i = 0; i < 50; i++) { printf("Fusion%d: %d\n", i, printlog[i]); } rt_mutex_delete(&mutex_acc); rt_mutex_delete(&mutex_gyro); }
int speed_exit(void) { if (!running) { goto err_not_running; } running = 0; rt_task_delete(&task_hard); rt_task_delete(&task_soft); rt_queue_delete(&queue); rt_mutex_delete(&mutex_average); rt_mutex_delete(&mutex_instant); rt_intr_disable(&intr); rt_intr_delete(&intr); fclose(ostream); /* START DEBUG DEBUG DEBUG */ { FILE * fp = fopen("average", "w"); fprintf(fp, "%f\n", average); fclose(fp); } /* STOP DEBUG DEBUG DEBUG */ return 0; err_not_running: return -1; }
ECRTData::~ECRTData() { rt_task_delete(&(this->supervisorThread)); rt_task_delete(&(this->statusThread)); rt_task_delete(&(this->frThread)); rt_task_delete(&(this->ecThread)); rt_cond_delete(&(this->freeCond)); rt_mutex_delete(&(this->mutexBuffer)); rt_mutex_delete(&(this->mutex)); }
int main() { mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); RT_TASK low, med, high, sync; rt_task_create(&low, "low", 0, 10, T_CPU(1)|T_JOINABLE); rt_task_create(&med, "med", 0, 20, T_CPU(1)|T_JOINABLE); rt_task_create(&high, "high", 0, 30, T_CPU(1)|T_JOINABLE); rt_task_create(&sync, "sync", 0, 99, T_CPU(1)|T_JOINABLE); rt_sem_create(&sem, "sem", 0, S_PRIO); rt_sem_create(&resourceSem, "resourceSem", 1, S_PRIO); rt_mutex_create(&resourceMutex, "resourceMutex"); rt_task_start(&low, &lowFunc, NULL); rt_task_start(&med, &medFunc, NULL); rt_task_start(&high, &highFunc, NULL); rt_task_start(&sync, &syncFunc, NULL); rt_task_join(&low); rt_task_join(&med); rt_task_join(&high); rt_task_join(&sync); rt_sem_delete(&sem); rt_sem_delete(&resourceSem); rt_mutex_delete(&resourceMutex); return 0; }
int main(){ mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); rt_sem_create(&semaphore, "sem", 1, S_PRIO); rt_sem_create(&synca, "sync", 0, S_PRIO); rt_mutex_create(&mutex, "mutex"); RT_TASK L, M, H; rt_task_shadow(NULL, "main", 4, T_CPU(1)|T_JOINABLE); rt_task_create(&L, "low", 0, 1, T_CPU(1)|T_JOINABLE); rt_task_create(&M, "medium", 0, 2, T_CPU(1)|T_JOINABLE); rt_task_create(&H, "high", 0, 3, T_CPU(1)|T_JOINABLE); rt_task_start(&L, &low, (void*) 0); rt_task_start(&M, &medium, (void*) 0); rt_task_start(&H, &high, (void*) 0); usleep(100000); rt_printf("RELEASING SYNC\n"); rt_sem_broadcast(&synca); rt_task_join(&L); rt_task_join(&M); rt_task_join(&H); rt_sem_delete(&synca); rt_sem_delete(&semaphore); rt_mutex_delete(&mutex); return 0; }
~mutex_impl() { int ret = rt_mutex_delete(&m); if (ret != 0) { // Don't throw exceptions from a dtor! logMessage("thread::detail::mutex_impl::%s: Could not delete RT_MUTEX: (%d) %s") % __func__ % -ret % strerror(-ret); } }
int main(int argc, char* argv[]) { rt_print_auto_init(1); signal(SIGTERM, catch_signal); signal(SIGINT, catch_signal); mlockall(MCL_CURRENT|MCL_FUTURE); done=1; int flag=0; while (flag<sizeQ){ gyroQ[flag]=rand()%366; flag++; } int err =rt_mutex_create(&a,"MyMutex");//creating mutex err =rt_mutex_create(&g,NULL); rt_task_create(&Accelerometer,NULL , 0, 0, T_JOINABLE); rt_task_create(&gyroscope, NULL, 0, 0, T_JOINABLE); rt_task_create(&fusion, NULL, 0, 0, T_JOINABLE); rt_task_start(&gyroscope, &gyro,NULL); rt_task_start(&Accelerometer, &Acc, NULL); rt_task_start(&fusion, &fusionT, NULL); rt_task_join(&gyroscope); rt_task_join(&Accelerometer); rt_task_join(&fusion); rt_task_delete(&gyroscope); rt_task_delete(&Accelerometer); rt_task_delete(&fusion); rt_mutex_delete(&a); rt_mutex_delete(&g); flag=0; while (flag<sizeFinal){//print out result rt_printf("Result%d: %d\n",flag,finalNum[flag]); flag++; } }
osStatus osMutexDelete (osMutexId mutex_id) { rt_err_t result; result = rt_mutex_delete(mutex_id); if (result == RT_EOK) return osOK; else return osErrorOS; }
/** * Clean all Semaphores, mutex, condition variable and main task */ void TimerCleanup(void) { rt_sem_delete(&CanFestival_mutex); rt_mutex_delete(&condition_mutex); rt_cond_delete(&timer_set); rt_sem_delete(&control_task); /* normally this will fail with a non-periodic task that has already ended at this time */ if (rt_task_suspend(&timerloop_task) != 0){ printk("Failed to join with Timerloop task\n"); } rt_task_delete(&timerloop_task); }
int main(int argc, char **argv) { mlockall(MCL_CURRENT|MCL_FUTURE); //lock current mem alloc and future mem alloc main mem rt_print_auto_init(1); //hvis vi trenger printf rt_sem_create(&xenomai_semaphore, "Vaarsemafor", SEM_INIT_COUNT, SEM_MODE); rt_sem_create(&resource_semaphore, "ressursemafor", SEM_RES_INIT_COUNT, SEM_MODE); rt_mutex_create(&resMut,"Resource control mutex"); rt_task_create(&taskLow, "task L", AUT0_STCK_SIZE, 50, SINGLE_CORE_MODE); rt_task_create(&taskMed, "task M", AUT0_STCK_SIZE, 75, SINGLE_CORE_MODE); rt_task_create(&taskHigh, "task H", AUT0_STCK_SIZE, 99, SINGLE_CORE_MODE); rt_task_shadow (NULL, "main", 99,SINGLE_CORE_MODE); rt_task_start(&taskLow, &taskL, NULL); rt_task_start(&taskMed, &taskM, NULL); rt_task_start(&taskHigh, &taskH, NULL); rt_printf("Started program\n"); rt_task_sleep(ONE_SEC); rt_printf("One second passed\n"); rt_sem_broadcast(&xenomai_semaphore); while(1){ rt_task_sleep(100000); } rt_sem_delete(&xenomai_semaphore); rt_sem_delete(&resource_semaphore); rt_mutex_delete(&resMut); return 0; }
int ff_del_syncobj(_SYNC_t m) { rt_mutex_delete(m); return RT_TRUE; }
void catch_signal(int sig) { rt_mutex_delete(&mutex_acc); rt_mutex_delete(&mutex_gyro); }
int main(int argc, char* argv[]) { int semDonnee; int semObs; int mutDonnee; int mutObs; /*initialize random seed*/ srand(time(NULL)); mutDonnee = rt_mutex_create(&mutex_donnee,"mutexDonnee"); mutObs = rt_mutex_create(&mutex_obs,"mutexObstacle"); semDonnee = rt_sem_create(&sem_donnee,"Semaphore Donnee",SEM_INIT,SEM_MODE); semObs = rt_sem_create(&sem_obs,"Semaphore Obstacle",SEM_INIT,SEM_MODE); /* Avoids memory swapping for this program */ mlockall(MCL_CURRENT|MCL_FUTURE); gettimeofday(&tim, NULL); start = tim.tv_sec+(tim.tv_usec/1000000.0); /* * Arguments: &task, * name, * stack size (0=default), * priority, * mode (FPU, start suspended, ...) */ rt_task_create(&sensorTaskt, "sensor", 0, 99, 0); rt_task_create(&computationTaskt, "computation", 0, 99, 0); rt_task_create(&printTaskt, "print", 0, 99, 0); /* * Arguments: &task, * task function, * function argument */ rt_task_start(&sensorTaskt, &sensorTask, NULL); rt_task_start(&computationTaskt, &computationTask, NULL); rt_task_start(&printTaskt, &printTask, NULL); pause(); rt_task_delete(&sensorTask); rt_task_delete(&computationTask); rt_task_delete(&printTask); rt_sem_delete(&sem_donnee); rt_sem_delete(&sem_obs); rt_mutex_delete(&mutex_donnee); rt_mutex_delete(&mutex_obs); obstacle* temp1 = obstacleList; obstacle* temp2; while(temp1->nxt != NULL){ temp2 = temp1->nxt; free(temp1); temp1=temp2; } free(temp1); }
int main(void){ /* Perform auto-init of rt_print buffers if the task doesn't do so */ rt_print_auto_init(1); /* Lock memory : avoid memory swapping for this program */ mlockall(MCL_CURRENT|MCL_FUTURE); /* Make main a Real-Time thread */ if(rt_task_shadow(NULL, NULL, RT_MAIN_PRI, T_CPU(CPU_ID) ) != SUCCESS){ printf("RT Thread main failed to be created!\n"); exit(1); }else{ /* print success */ rt_printf("RT Thread main initiated successfully \n"); } /* Create semaphore for synchronized start */ if(rt_sem_create(&sync_sem, "sync_start", 0, S_PRIO) != SUCCESS){ rt_printf("sync semaphore failed to be created \n"); exit(1); } /* Create Barrier */ #ifdef semaphore if(rt_sem_create(&sem, "Barrier_sem", 0, S_PRIO) != SUCCESS){ rt_printf("Barrier_sem failed to be created \n"); exit(1); } #endif #ifdef mutex if(rt_mutex_create(&mut, "Barrier_mut") != SUCCESS){ rt_printf("Barrier_mut failed to be created \n"); exit(1); } #endif /* Initialize Real-Time threads */ int* id; int i; RT_TASK rt_threads[N_RT_THREADS]; for(i=0; i<N_RT_THREADS; i++){ /* Give the new thread the channel to respond to by argument */ int *method = malloc(sizeof(int)); *method = USE_METHOD; /* Create new thread */ if(rt_task_create(&rt_threads[i], NULL, 0, RT_THREADS_PRI[i], T_CPU(CPU_ID)|T_JOINABLE) != SUCCESS){ rt_printf("RT Thread %i failed to be created!\n", i); exit(1); } /* Execute task */ if(rt_task_start(&rt_threads[i], RT_FUNC[i], id) != SUCCESS){ rt_printf("RT Thread %i failed to start!\n", (void*) i); exit(1); } /* print success */ rt_printf("RT Thread %i initiated successfully \n", i); } /* Wait untill all threads have been blocked, restart them */ rt_task_sleep(SLEEP_DELAY); if(rt_sem_broadcast(&sync_sem)!= SUCCESS){ rt_printf("main thread failed to broadcast on BARRIER semaphore \n"); exit(1); } rt_task_sleep(SLEEP_DELAY); /* Wait for all threads to terminate */ for(i=0; i<N_RT_THREADS; i++){ rt_task_join(&rt_threads[i]); } /* Clean up */ rt_sem_delete(&sem); rt_sem_delete(&sync_sem); rt_mutex_delete(&mut); return 0; }
int main(int argc, char **argv) { char tempname[] = "/tmp/sigdebug-XXXXXX"; char buf[BUFSIZ], dev[BUFSIZ]; RT_TASK main_task, rt_task; long int start, trash, end; unsigned char *mayday, *p; struct sigaction sa; int old_wd_value; char r, w, x, s; int tmp_fd, d; FILE *maps; int err; rt_print_auto_init(1); if (argc < 2 || strcmp(argv[1], "--skip-watchdog") != 0) { wd = fopen("/sys/module/xeno_nucleus/parameters/" "watchdog_timeout", "w+"); if (!wd) { fprintf(stderr, "FAILURE: no watchdog available and " "--skip-watchdog not specified\n"); exit(EXIT_FAILURE); } err = fscanf(wd, "%d", &old_wd_value); check("get watchdog", err, 1); err = fprintf(wd, "2"); check("set watchdog", err, 1); fflush(wd); } maps = fopen("/proc/self/maps", "r"); if (maps == NULL) { perror("open /proc/self/maps"); exit(EXIT_FAILURE); } while (fgets(buf, sizeof(buf), maps)) { if (sscanf(buf, "%lx-%lx %c%c%c%c %lx %x:%x %d%s\n", &start, &end, &r, &w, &x, &s, &trash, &d, &d, &d, dev) == 11 && r == 'r' && x == 'x' && !strcmp(dev, "/dev/rtheap") && end - start == 4096) { printf("mayday page starting at 0x%lx [%s]\n" "mayday code:", start, dev); mayday = (unsigned char *)start; for (p = mayday; p < mayday + 32; p++) printf(" %.2x", *p); printf("\n"); } } fclose(maps); sigemptyset(&sa.sa_mask); sa.sa_sigaction = sigdebug_handler; sa.sa_flags = SA_SIGINFO; sigaction(SIGDEBUG, &sa, NULL); sa.sa_sigaction = dummy_handler; sigaction(SIGUSR1, &sa, NULL); printf("mlockall\n"); munlockall(); setup_checkdebug(SIGDEBUG_NOMLOCK); err = rt_task_shadow(&main_task, "main_task", 0, 0); check("rt_task_shadow", err, -EINTR); check_sigdebug_received("SIGDEBUG_NOMLOCK"); mlockall(MCL_CURRENT | MCL_FUTURE); errno = 0; tmp_fd = mkstemp(tempname); check_no_error("mkstemp", -errno); unlink(tempname); check_no_error("unlink", -errno); mem = mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, tmp_fd, 0); check_no_error("mmap", -errno); err = write(tmp_fd, "X", 1); check("write", err, 1); err = rt_task_shadow(&main_task, "main_task", 0, 0); check_no_error("rt_task_shadow", err); err = rt_mutex_create(&prio_invert, "prio_invert"); check_no_error("rt_mutex_create", err); err = rt_mutex_acquire(&prio_invert, TM_INFINITE); check_no_error("rt_mutex_acquire", err); err = rt_sem_create(&send_signal, "send_signal", 0, S_PRIO); check_no_error("rt_sem_create", err); err = rt_task_spawn(&rt_task, "rt_task", 0, 1, T_WARNSW | T_JOINABLE, rt_task_body, NULL); check_no_error("rt_task_spawn", err); err = rt_sem_p(&send_signal, TM_INFINITE); check_no_error("rt_sem_signal", err); pthread_kill(rt_task_thread, SIGUSR1); rt_task_sleep(rt_timer_ns2ticks(20000000LL)); err = rt_mutex_release(&prio_invert); check_no_error("rt_mutex_release", err); err = rt_task_join(&rt_task); check_no_error("rt_task_join", err); err = rt_mutex_delete(&prio_invert); check_no_error("rt_mutex_delete", err); err = rt_sem_delete(&send_signal); check_no_error("rt_sem_delete", err); if (wd) { fprintf(wd, "%d", old_wd_value); fclose(wd); } fprintf(stderr, "Test OK\n"); return 0; }
static void rt_thread_entry1(void* parameter) { rt_err_t result; rt_tick_t tick; /* 1. staic mutex demo */ /* 试图持有互斥量,最大等待10个OS Tick后返回 */ rt_kprintf("thread1 try to get static mutex, wait 10 ticks.\n"); /* 获得当前的OS Tick */ tick = rt_tick_get(); result = rt_mutex_take(&static_mutex, 10); if (result == -RT_ETIMEOUT) { /* 超时后判断是否刚好是10个OS Tick */ if (rt_tick_get() - tick != 10) { rt_mutex_detach(&static_mutex); return; } rt_kprintf("thread1 take static mutex timeout\n"); } else { /* 线程2持有互斥量,且在相当长的时间后才会释放互斥量, * 因此10个tick后线程1不可能获得 */ rt_kprintf("thread1 take a static mutex, failed.\n"); rt_mutex_detach(&static_mutex); return; } /* 永久等待方式持有互斥量 */ rt_kprintf("thread1 try to get static mutex, wait forever.\n"); result = rt_mutex_take(&static_mutex, RT_WAITING_FOREVER); if (result != RT_EOK) { /* 不成功则测试失败 */ rt_kprintf("thread1 take a static mutex, failed.\n"); rt_mutex_detach(&static_mutex); return; } rt_kprintf("thread1 take a staic mutex, done.\n"); /* 脱离互斥量对象 */ rt_mutex_detach(&static_mutex); /* 2. dynamic mutex test */ /* 试图持有互斥量,最大等待10个OS Tick后返回 */ rt_kprintf("thread1 try to get dynamic mutex, wait 10 ticks.\n"); tick = rt_tick_get(); result = rt_mutex_take(dynamic_mutex, 10); if (result == -RT_ETIMEOUT) { /* 超时后判断是否刚好是10个OS Tick */ if (rt_tick_get() - tick != 10) { rt_mutex_delete(dynamic_mutex); return; } rt_kprintf("thread1 take dynamic mutex timeout\n"); } else { /* 线程2持有互斥量,且在相当长的时间后才会释放互斥量, * 因此10个tick后线程1不可能获得 */ rt_kprintf("thread1 take a dynamic mutex, failed.\n"); rt_mutex_delete(dynamic_mutex); return; } /* 永久等待方式持有互斥量 */ rt_kprintf("thread1 try to get dynamic mutex, wait forever.\n"); result = rt_mutex_take(dynamic_mutex, RT_WAITING_FOREVER); if (result != RT_EOK) { /* 不成功则测试失败 */ rt_kprintf("thread1 take a dynamic mutex, failed.\n"); rt_mutex_delete(dynamic_mutex); return; } rt_kprintf("thread1 take a dynamic mutex, done.\n"); /* 删除互斥量对象 */ rt_mutex_delete(dynamic_mutex); }
int main(void) { unsigned long long before; RT_ALARM nalrm; RT_BUFFER nbuf; RT_COND ncond; RT_EVENT nevt; RT_HEAP nheap; RT_MUTEX nmtx; RT_PIPE npipe; RT_QUEUE nq; RT_SEM nsem; RT_TASK ntsk; int failed = 0; mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); rt_fprintf(stderr, "Checking for leaks in native skin services\n"); before = get_used(); check_native(rt_alarm_create(&nalrm, NULL)); check_native(rt_alarm_delete(&nalrm)); check_used("alarm", before, failed); before = get_used(); check_native(rt_buffer_create(&nbuf, NULL, 16384, B_PRIO)); check_native(rt_buffer_delete(&nbuf)); check_used("buffer", before, failed); before = get_used(); check_native(rt_cond_create(&ncond, NULL)); check_native(rt_cond_delete(&ncond)); check_used("cond", before, failed); before = get_used(); check_native(rt_event_create(&nevt, NULL, 0, EV_PRIO)); check_native(rt_event_delete(&nevt)); check_used("event", before, failed); before = get_used(); check_native(rt_heap_create(&nheap, "heap", 16384, H_PRIO | H_SHARED)); check_native(rt_heap_delete(&nheap)); check_used("heap", before, failed); before = get_used(); check_native(rt_mutex_create(&nmtx, NULL)); check_native(rt_mutex_delete(&nmtx)); check_used("mutex", before, failed); before = get_used(); check_native(rt_pipe_create(&npipe, NULL, P_MINOR_AUTO, 0)); check_native(rt_pipe_delete(&npipe)); check_used("pipe", before, failed); before = get_used(); check_native(rt_queue_create(&nq, "queue", 16384, Q_UNLIMITED, Q_PRIO)); check_native(rt_queue_delete(&nq)); check_used("queue", before, failed); before = get_used(); check_native(rt_sem_create(&nsem, NULL, 0, S_PRIO)); check_native(rt_sem_delete(&nsem)); check_used("sem", before, failed); before = get_used(); check_native(rt_task_spawn(&ntsk, NULL, 0, 1, T_JOINABLE, empty, NULL)); check_native(rt_task_join(&ntsk)); sleep(1); /* Leave some time for xnheap * deferred free */ check_used("task", before, failed); return failed ? EXIT_FAILURE : EXIT_SUCCESS; }
/* Task objects cleanup */ void hit_task_cleanup_objects(){ if(hit_task_mutex_created){ hit_task_mutex_created = 0; rt_mutex_delete(&hit_task_mutex); } }
/** Delete a semaphore * @param mutex the mutex to delete */ void sys_mutex_free(sys_mutex_t *mutex) { RT_DEBUG_NOT_IN_INTERRUPT; rt_mutex_delete(*mutex); }
// Supprime toutes les tâches créées par game_init int end_game(void) { err = rt_task_delete(&refresh_task); if (err != 0) { printk("delete refresh task failed: %d\n", err); return -1; } err = rt_task_delete(&move_task); if (err != 0) { printk("delete move task failed: %d\n", err); return -1; } err = rt_task_delete(&ennemi_task); if (err != 0) { printk("delete move task failed: %d\n", err); return -1; } err = rt_task_delete(&shots_impacts_task); if (err != 0) { printk("delete shots_impacts task failed: %d\n", err); return -1; } err = rt_task_delete(&missile_ennemi_task); if (err != 0) { printk("delete shots_impacts task failed: %d\n", err); return -1; } err = rt_task_delete(&switch_events_task); if (err != 0) { printk("delete switch_events task failed: %d\n", err); return -1; } err = rt_task_delete(&gift_task); if (err != 0) { printk("delete gift task failed: %d\n", err); return -1; } err = rt_mutex_delete(&mutex_ennemi); if (err != 0) { printk("delete mutex ennemi failed: %d\n", err); return -1; } err = rt_mutex_delete(&mutex_shots); if (err != 0) { printk("delete mutex shots failed: %d\n", err); return -1; } err = rt_mutex_delete(&mutex_score); if (err != 0) { printk("delete mutex score failed: %d\n", err); return -1; } return 0; }