int rcS(char *pattern, char *param, void (*q_empty)(struct runqueue *)) { runqueue_init(&q); q.empty_cb = q_empty; q.max_running_tasks = 1; return _rc(&q, "/etc/rc.d", pattern, "*", param); }
kstat_t krhino_init(void) { g_sys_stat = RHINO_STOPPED; #if (RHINO_CONFIG_USER_HOOK > 0) krhino_init_hook(); #endif runqueue_init(&g_ready_queue); tick_list_init(); #if (RHINO_CONFIG_SYSTEM_STATS > 0) kobj_list_init(); #endif #if (RHINO_CONFIG_MM_TLF > 0) k_mm_init(); #endif #if (RHINO_CONFIG_KOBJ_DYN_ALLOC > 0) klist_init(&g_res_list); krhino_sem_create(&g_res_sem, "res_sem", 0); dyn_mem_proc_task_start(); #endif #if (RHINO_CONFIG_CPU_NUM > 1) for (uint8_t i = 0; i < RHINO_CONFIG_CPU_NUM; i++) { krhino_task_cpu_create(&g_idle_task[i], "idle_task", NULL, RHINO_IDLE_PRI, 0, &g_idle_task_stack[i][0], RHINO_CONFIG_IDLE_TASK_STACK_SIZE, idle_task, i, 1u); } #else krhino_task_create(&g_idle_task[0], "idle_task", NULL, RHINO_IDLE_PRI, 0, &g_idle_task_stack[0][0], RHINO_CONFIG_IDLE_TASK_STACK_SIZE, idle_task, 1u); #endif #if (RHINO_CONFIG_WORKQUEUE > 0) workqueue_init(); #endif #if (RHINO_CONFIG_TIMER > 0) ktimer_init(); #endif #if (RHINO_CONFIG_CPU_USAGE_STATS > 0) cpu_usage_stats_start(); #endif rhino_stack_check_init(); return RHINO_SUCCESS; }
/** * @brief Allocate user-stacks and initializes the kernel contexts of the * given threads. * * This function assumes that: * - num_tasks < number of tasks allowed on the system. * - the tasks have already been deemed schedulable and have been appropriately * scheduled. In particular, this means that the task list is sorted in order * of priority -- higher priority tasks come first. * * @param tasks A list of scheduled task descriptors. * @param size The number of tasks is the list. */ void allocate_tasks(task_t** ptasks, size_t num_tasks) { //set up system tcb for each task in 'tasks' - loop through each task uint8_t i; runqueue_init(); dev_init(); for(i = 1; i <= num_tasks; i++) { tcb_init(ptasks[i], &system_tcb[i], i); runqueue_add(&system_tcb[i], i); } /* add the idle task */ idle_init(); }
/** * @brief Allocate user-stacks and initializes the kernel contexts of the * given threads. * * This function assumes that: * - num_tasks < number of tasks allowed on the system. * - the tasks have already been deemed schedulable and have been appropriately * scheduled. In particular, this means that the task list is sorted in order * of priority -- higher priority tasks come first. * * @param tasks A list of scheduled task descriptors. * @param size The number of tasks is the list. */ void allocate_tasks(task_t** tasks, size_t num_tasks) { size_t i = 1; for(; i <= num_tasks; i++) { tcb_t *task_tcb = &(system_tcb[i]); task_tcb->native_prio = i; task_tcb->cur_prio = i; // Context sched_context_t *ctx = &(task_tcb->context); ctx->r4 = (uint32_t) (tasks[i-1]->lambda); ctx->r5 = (uint32_t) (tasks[i-1]->data); ctx->r6 = (uint32_t) (tasks[i-1]->stack_pos); ctx->r8 = global_data; ctx->sp = ((char *)(task_tcb->kstack) + OS_KSTACK_SIZE); // Easy way to launch task fo first time ctx->lr = (void *)launch_task; task_tcb->holds_lock = 0; task_tcb->sleep_queue = (tcb_t *)0; } initialize_idle(); runqueue_init(); runqueue_add(&(system_tcb[IDLE_PRIO]), IDLE_PRIO); for(i=1; i <= num_tasks; i++) { runqueue_add(&(system_tcb[i]), i); } // Set current tcb as IDLE dispatch_init(&(system_tcb[IDLE_PRIO])); }
static void __attribute__((constructor)) rc_init() { runqueue_init(&r); r.empty_cb = r_empty; r.max_running_tasks = 8; }
void scripts_init(void) { runqueue_init(&runq); runq.max_running_tasks = 1; }