int main() { TIL311 = 0x98; srand(); sem_init(&lcd_sem); lcd_init(); serial_start(SERIAL_SAFE); puts("Hello! Starting tasks.\n"); enter_critical(); create_task(&task_time,0); create_task(&task_echo,0); create_task(&task_scroller,0); create_task(&task_wav_play,0); /* for (int i = 0; i < 16; i++) create_task(&breeder_task,0);*/ leave_critical(); yield(); puts("Tasks started, main() returning.\n"); return 0; }
volatile task_t* timer_callback(task_t *regs) { tick++; millis_from_boot += 1000 / timer_frequency; #ifdef DEBUG #ifdef TIMER_VERBOSE_TICKS kprintf("[%s : %d]\r\n", "Tick", tick); #endif #endif io_out8(0x20, 0x20); //重设时钟中断 volatile task_t* oregs = regs; if (a) { create_task(regs, stb + 4096, taskb); create_task(regs, sta + 4096, taska); a = false; ptra = sta + 4096 - sizeof(task_t); ptrb = stb + 4096 - sizeof(task_t); oregs = ptra; } else if (!b) { ptra = regs; oregs = ptrb; } else { ptrb = regs; oregs = ptra; } b=!b; // return oregs; }
int main(void) { unsigned int user_stacks[TASK_LIMIT][STACK_SIZE]; unsigned int *usertasks[TASK_LIMIT]; size_t task_count = 0; size_t current_task; task_init(); print_str("OS: Starting...\n"); print_str("OS: First create task 1\n"); usertasks[0] = create_task(user_stacks[0], &task1_func); task_count += 1; print_str("OS: Back to OS, create task 2\n"); usertasks[1] = create_task(user_stacks[1], &task2_func); task_count += 1; print_str("\nOS: Start round-robin scheduler!\n"); /* SysTick configuration */ *SYSTICK_LOAD = ( SystemCoreClock / TICK_RATE_HZ) - 1UL; *SYSTICK_VAL = 0; *SYSTICK_CTRL = 0x07; current_task = 0; while (1) { print_str("OS: Activate next task\n"); usertasks[current_task] = activate(usertasks[current_task]); print_str("OS: Back to OS\n"); current_task = current_task == (task_count - 1) ? 0 : current_task + 1; } return 0; }
int main(void) { if(init_kernel() != OK) { /* Memory allocation problems */ while(1); } if(create_task( car_movement, 3000 ) != OK ) { /* Memory allocation problems */ while(1); } if (create_task(cruisecontrol, 3500 ) != OK ) { /* Memory allocation problems */ while(1); } if ((mbi=create_mailbox(1,sizeof(int))) == NULL) { /* Memory allocation problems */ while (1); } if ((mbf=create_mailbox(1,sizeof(double))) == NULL) { /* Memory allocation problems */ while (1); } run(); return 0; }
/******************************************************** MAIN *********************************************************/ int main(void) { int map[XMAX][YMAX], bmap[XMAX][YMAX][2]; SPLAYER player; LPTCB task; floor_cnt = 1; init_genrand((unsigned long)time(NULL)); // 必ずmainに入れること init_task(); init_monster(); task = create_task(title_load, NULL, PRIO_00); task->p[0] = &player; task->p[1] = &floor_cnt; task = create_task(game_start, NULL, PRIO_00); task->p[0] = map; task->p[1] = &player; task->p[2] = bmap; loop_task(); // printf("taskcnt =%d\n", count_task()); return 0; }
int main(void) { unsigned int user_stacks[TASK_LIMIT][STACK_SIZE]; unsigned int *usertasks[TASK_LIMIT]; size_t task_count = 0; size_t current_task; usart_init(); task_init(); print_str("OS: Starting...\n"); print_str("OS: First create task 1\n"); usertasks[0] = create_task(user_stacks[0], &task1_func); task_count += 1; print_str("OS: Back to OS, create task 2\n"); usertasks[1] = create_task(user_stacks[1], &task2_func); task_count += 1; print_str("\nOS: Start multitasking, back to OS till task yield!\n"); current_task = 0; while (1) { print_str("OS: Activate next task\n"); usertasks[current_task] = activate(usertasks[current_task]); print_str("OS: Back to OS\n"); current_task = current_task == (task_count - 1) ? 0 : current_task + 1; } return 0; }
static void Init(rtems_task_argument arg) { test_context *ctx = &test_instance; TEST_BEGIN(); ctx->low = rtems_task_self(); create_task(&ctx->mid, 3); create_task(&ctx->high, 1); create_task(&ctx->inversion, 2); create_sema(&ctx->sem_a); create_sema(&ctx->sem_b); obtain_sema(ctx->sem_a); start_task(ctx->mid, mid_task); start_task(ctx->high, high_task); /* * Here we see that the priority of the high priority task blocked on * semaphore B propagated to the low priority task owning semaphore A * on which the owner of semaphore B depends. */ assert_prio(ctx->low, 1); assert_prio(ctx->mid, 1); assert_prio(ctx->high, 1); assert_prio(ctx->inversion, 2); TEST_END(); rtems_test_exit(0); }
static void initialize(int minor) { console_tbl *ct = &Console_Port_Tbl [minor]; uart_bridge_master_control *control = ct->pDeviceParams; intercom_type type = control->type; qoriq_intercom_service_install(type, uart_bridge_master_service, control); create_task('R', receive_task, control); control->transmit_task = create_task('T', transmit_task, control); }
int main(int argc, char** argv, char** envp) { if(argv[1]) { if(strcmp(argv[1], "-gui") == 0) create_task(tmain_gui); else if(strcmp(argv[1], "-text") == 0) create_task(tmain_text); else _exit(-1); } }
void init_multitasking() { asm volatile("cli"); //memset((void*)(200*1024*1024),0,(40*1024*1024)); kernel_proc = create_process("microkernel", 0, 1, 0); new_process = (uint32_t)kernel_proc; current_task = (uint32_t)create_task("initiating_task",tasking_initiator, 20, 0x202, kernel_proc); //Scheduler initalization task old_task = current_task; Idle_task = create_task("System_idle_task",idle, 20, 0x202, kernel_proc); //default task Activate_task_direct(Idle_task); Activate_task_direct(create_task("idle2",idle2, 10, 0x202, kernel_proc)); Activate_task_direct(create_task("idle3",idle3, 10, 0x202, kernel_proc)); Activate_task_direct(create_task("idle4",idle4, 10, 0x202, kernel_proc)); Activate_task_direct(create_task("idle5",idle5, 10, 0x202, kernel_proc)); Activate_task_direct(create_task("idle6",idle6, 10, 0x202, kernel_proc)); //Activate_task_direct(create_task("Main_Kernel",kernel_main, 10, 0x202, kernel_proc)); Shell_proc = create_process("Shell", 0, 1, kernel_proc); Activate_task_direct(create_task("Shell_Ostream", Console_Writer, 10, 0x202, Shell_proc)); reached_bottom = 0; Scheduler_init(); // Let the FUN Begin :D Lets Switch from the old monotasking world to Multitasking World :D defined in tasking.asm }
int create_kernel_task(tid_t* id, entry_point_t ep, void* args, uint8_t prio) { if (prio > MAX_PRIO) prio = NORMAL_PRIO; return create_task(id, ep, args, prio, CORE_ID); }
dove_status dcs_statistics_init(char *pythonpath) { dove_status status = DOVE_STATUS_OK; do { status = python_functions_init(pythonpath); if (status != DOVE_STATUS_OK) { break; } /* Initialize mutex and condition variable objects */ if (pthread_mutex_init(&dps_statistics_mp, NULL) != 0) { status = DOVE_STATUS_INVALID_PARAMETER; break; } if (pthread_cond_init (&dps_statistics_cv, NULL) != 0) { status = DOVE_STATUS_INVALID_PARAMETER; break; } /* Create a thread for statistics collection */ if (create_task((const char *)"Stat", 0, OSW_DEFAULT_STACK_SIZE, dps_statistics_main, 0, &statisticsTaskId) != OSW_OK) { status = DOVE_STATUS_THREAD_FAILED; break; } } while (0); return status; }
int create_kernel_task_on_core(tid_t* id, entry_point_t ep, void* args, uint8_t prio, uint32_t core_id) { if (prio > MAX_PRIO) prio = NORMAL_PRIO; return create_task(id, ep, args, prio, core_id); }
/** * All data has been delivered. Your implementation should now finish writing out sorted data and verbose info. * The output stream will be closed for you after this call returns */ void stream_end() { // do awesome stuff // then print to outfile e.g. menqueue(NULL); //merge = 1; //create_task(NULL, 0, nitems); int i; worker_funcs(NULL); for(i = 1; i < nthreads; i++){ pthread_join(tid[i], NULL); } merge = 1; //create_task(NULL, 0, nitems); for(i = 1; i < nthreads; i++){ pthread_create(&tid[i], NULL, worker_merge, NULL); } create_task(NULL, 0, nitems); worker_merge(NULL); for(i = 1; i < nthreads; i++){ pthread_join(tid[i], NULL); } for(int i = 0; i < nitems ;i++) fprintf(outfile,"%d\n", data[i]); if(outfile != stdout) fclose(outfile); }
dove_status dps_statistics_start(void) { dove_status status = DOVE_STATUS_OK; do { if (search_task("Stat") != 0) { log_info(PythonDataHandlerLogLevel, "Thread is running\r\n"); break; } log_info(PythonDataHandlerLogLevel, "Starting thread\r\n"); /* Re-initialize resources and create a thread */ if (pthread_mutex_init(&dps_statistics_mp, NULL) != 0) { status = DOVE_STATUS_INVALID_PARAMETER; break; } if (pthread_cond_init (&dps_statistics_cv, NULL) != 0) { status = DOVE_STATUS_INVALID_PARAMETER; break; } if (create_task((const char *)"Stat", 0, OSW_DEFAULT_STACK_SIZE, dps_statistics_main, 0, &statisticsTaskId) != OSW_OK) { status = DOVE_STATUS_THREAD_FAILED; break; } } while (0); return status; }
akj::tTAFHandle cFontLoader::CreateTexAtlasFont( tFaceHandle handle, uint32_t initial_size) { if(!handle.IsValid()) return tTAFHandle(); FreeTypeFace& face = TypeFace(handle); cCreateTexAtlasTask create_task(face, initial_size); while(!create_task.IsDone()) create_task.DoWork(); std::unique_ptr<cTexAtlasFont> taf( new cTexAtlasFont(face, std::unique_ptr<FreeTypeLibrary>(new FreeTypeLibrary), std::move(create_task.GetFinishedAtlas()))); cArray<16, uint32_t> sizes = {14, 12, 21}; for(uint32_t i: sizes) { if(i == initial_size) continue; cCreateTexAtlasTask create_task2(face, i); while(!create_task2.IsDone()) create_task2.DoWork(); taf->AddAtlas(create_task2.GetFinishedAtlas()); } taf->RepackAtlasTexture(); return InsertTAF(std::move(taf)); }
void rb_mtp_thread_set_device_name (RBMtpThread *thread, const char *name) { RBMtpThreadTask *task = create_task (SET_DEVICE_NAME); task->name = g_strdup (name); queue_task (thread, task); }
static int create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j, unsigned reclevel) { int ret; struct starpu_task *task = create_task(TAG21_AUX(k, j, reclevel)); task->cl = &cl21; /* which sub-data is manipulated ? */ task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k); task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j); if (j == k+1) { task->priority = STARPU_MAX_PRIO; } /* enforce dependencies ... */ if (k > 0) { starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 2, TAG11_AUX(k, reclevel), TAG22_AUX(k-1, k, j, reclevel)); } else { starpu_tag_declare_deps(TAG21_AUX(k, j, reclevel), 1, TAG11_AUX(k, reclevel)); } int n = starpu_matrix_get_nx(task->handles[0]); task->flops = FLOPS_STRSM(n, n); ret = starpu_task_submit(task); if (ret != -ENODEV) STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit"); return ret; }
static struct starpu_task * create_task_11(starpu_data_handle_t dataA, unsigned k) { /* FPRINTF(stdout, "task 11 k = %d TAG = %llx\n", k, (TAG11(k))); */ struct starpu_task *task = create_task(TAG11(k)); task->cl = &cl11; /* which sub-data is manipulated ? */ task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k); /* this is an important task */ if (!noprio) task->priority = STARPU_MAX_PRIO; /* enforce dependencies ... */ if (k > 0) { starpu_tag_declare_deps(TAG11(k), 1, TAG22(k-1, k, k)); } int n = starpu_matrix_get_nx(task->handles[0]); task->flops = FLOPS_SPOTRF(n); return task; }
void Directory::refresh() { need_update = false; refresh_timer.restart(); if (uri.isEmpty()) { emit error(tr("Address is empty")); return; } if (Special_uri(uri).name() == Special_uri::mounts) { //mounting of unmounted volume was requested //uri is something like "places/mounts/42" int id = uri.split("/").last().toInt(); QList<Gio_volume*> volumes = core->get_mount_manager()->get_volumes(); if (id < 0 || id >= volumes.count()) { emit error(tr("Invalid volume id")); return; } GVolume* volume = volumes.at(id)->get_gvolume(); interrupt_gio_operation(); gcancellable = g_cancellable_new(); async_result_type = async_result_mount_volume; g_volume_mount(volume, GMountMountFlags(), 0, gcancellable, async_result, this); return; } create_task(uri); }
static void allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht) { gsize offset; struct taskdata_checksrv_s td_scheme; GHashTableIter iter_serv; gpointer k, v; TRACE_POSITION(); g_hash_table_iter_init(&iter_serv, ht); while (g_hash_table_iter_next(&iter_serv, &k, &v)) { struct service_info_s *si = v; memset(&td_scheme, 0x00, sizeof(td_scheme)); offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID); addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset); g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1); if (!_agent_check_enabled(si)) { GRID_DEBUG("Task [%s] disabled by " NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name); } else if (!is_task_scheduled(td_scheme.task_name)) { GError *error_local = NULL; task_t *task = NULL; struct taskdata_checksrv_s *task_data; TRACE_POSITION(); agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key)); g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1); /* prepare the task structure */ task_data = g_memdup(&td_scheme, sizeof(td_scheme)); if (!task_data) { ERROR("Memory allocation failure"); continue; } task = create_task(period_check_services, td_scheme.task_name); task = set_task_callbacks(task, _check_tcp_service_task, g_free, task_data); if (!task) { ERROR("Memory allocation failure"); continue; } /* now start the task! */ if (add_task_to_schedule(task, &error_local)) INFO("Task started: %s", td_scheme.task_name); else { ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local)); g_free(task); } if (error_local) g_clear_error(&error_local); } } TRACE_POSITION(); }
static gboolean task_starter(gpointer udata, GError **error) { gpointer ns_k, ns_v; GHashTableIter ns_iterator; task_t *task; gchar ns_id[sizeof(TASK_ID)+1+LIMIT_LENGTH_NSNAME]; namespace_data_t *ns_data; (void)udata; g_hash_table_iter_init(&ns_iterator, namespaces); while (g_hash_table_iter_next(&ns_iterator,&ns_k,&ns_v)) { ns_data = ns_v; g_snprintf(ns_id,sizeof(ns_id),TASK_ID".%s",ns_data->name); if (!namespace_is_available(ns_data)) { if (!is_task_scheduled(ns_id)) { task = create_task(period_get_ns, ns_id); task = set_task_callbacks(task, task_worker, g_free, g_strdup(ns_data->name)); if (!add_task_to_schedule(task, error)) { ERROR("[task_id="TASK_ID"] Failed to start a sub worker for namespace '%s'", (gchar*)ns_k); g_free(task); } else INFO("[task_id="TASK_ID"] subtask started [%s]", ns_id); } } } task_done(TASK_ID); return 1; }
int insert_timer_directional(u_int8_t task_type, u_int64_t delay, u_int8_t retries, u_int32_t src_ip, u_int32_t dst_ip, unsigned char tos) { task *new_timer = NULL; new_timer = create_task(task_type); // get memory if (!(new_timer)) { printk("Error allocating timer!\n"); return -ENOMEM; } new_timer->src_ip = src_ip; new_timer->dst_ip = dst_ip; new_timer->tos = tos; if (delay != 0) new_timer->time = getcurrtime() + delay; else if (task_type == TASK_RESEND_RREQ) { new_timer->retries = retries; new_timer->ttl = 30; new_timer->time = getcurrtime() + ((2 ^ (RREQ_RETRIES - retries)) * NET_TRAVERSAL_TIME); } else new_timer->time = getcurrtime() + delay; queue_timer(new_timer); //update_timer_queue(); return 0; }
static void create_task_12(starpu_data_handle *dataAp, unsigned nblocks, unsigned k, unsigned j, starpu_data_handle (* get_block)(starpu_data_handle *, unsigned, unsigned, unsigned)) { // printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); struct starpu_task *task = create_task(); task->cl = &cl12; task->cl_arg = NULL; /* which sub-data is manipulated ? */ task->buffers[0].handle = get_block(dataAp, nblocks, k, k); task->buffers[0].mode = STARPU_R; task->buffers[1].handle = get_block(dataAp, nblocks, j, k); task->buffers[1].mode = STARPU_RW; if (!no_prio && (j == k+1)) { task->priority = STARPU_MAX_PRIO; } /* enforce dependencies ... */ #if 0 starpu_tag_declare_deps(TAG12(k, i), 1, PIVOT(k, i)); #endif if (k > 0) { starpu_task_declare_deps_array(task, 1, &EVENT(k,k)); starpu_task_declare_deps_array(task, 1, &EVENT(k,j)); } else { starpu_task_declare_deps_array(task, 1, &EVENT(k,k)); } starpu_task_submit(task, NULL); }
rust_scheduler::rust_scheduler(rust_kernel *kernel, rust_message_queue *message_queue, rust_srv *srv, const char *name) : interrupt_flag(0), _log(srv, this), log_lvl(log_note), srv(srv), name(name), newborn_tasks(this, "newborn"), running_tasks(this, "running"), blocked_tasks(this, "blocked"), dead_tasks(this, "dead"), cache(this), root_task(NULL), curr_task(NULL), rval(0), kernel(kernel), message_queue(message_queue) { LOGPTR(this, "new dom", (uintptr_t)this); isaac_init(this, &rctx); #ifndef __WIN32__ pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, 1024 * 1024); pthread_attr_setdetachstate(&attr, true); #endif root_task = create_task(NULL, name); }
static void create_task_21(starpu_data_handle_t dataA, unsigned k, unsigned j) { int ret; struct starpu_task *task = create_task(TAG21(k, j)); task->cl = &cl21; /* which sub-data is manipulated ? */ task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k); task->handles[1] = starpu_data_get_sub_data(dataA, 2, k, j); if (!no_prio && (j == k+1)) { task->priority = STARPU_MAX_PRIO; } /* enforce dependencies ... */ if (k > 0) { starpu_tag_declare_deps(TAG21(k, j), 2, TAG11(k), TAG22(k-1, k, j)); } else { starpu_tag_declare_deps(TAG21(k, j), 1, TAG11(k)); } ret = starpu_task_submit(task); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit"); }
int main( int argc, char **argv ) { void *pTaskHandle = NULL; enable_log( 1 ); set_log( LOG_TYPE_CONSOLE, NULL, 0 ); if( init_session( ) < 0 ) return -1; pTaskHandle = create_task( task_test, 5, 100 ); if ( pTaskHandle ) { CMessage stMsg; memset( &stMsg, 0x00, sizeof(stMsg) ); post_task_msg( pTaskHandle, &stMsg ); log_print( "create task ok................." ); } else log_print( "create task failed?????????????????????" ); while ( 1 ) os_sleep( 1000 ); release_session( ); return 0; }
static void create_task_12(starpu_data_handle_t dataA, unsigned k, unsigned i) { int ret; /* printf("task 12 k,i = %d,%d TAG = %llx\n", k,i, TAG12(k,i)); */ struct starpu_task *task = create_task(TAG12(k, i)); task->cl = &cl12; /* which sub-data is manipulated ? */ task->handles[0] = starpu_data_get_sub_data(dataA, 2, k, k); task->handles[1] = starpu_data_get_sub_data(dataA, 2, i, k); if (!no_prio && (i == k+1)) { task->priority = STARPU_MAX_PRIO; } /* enforce dependencies ... */ if (k > 0) { starpu_tag_declare_deps(TAG12(k, i), 2, TAG11(k), TAG22(k-1, i, k)); } else { starpu_tag_declare_deps(TAG12(k, i), 1, TAG11(k)); } ret = starpu_task_submit(task); STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit"); }
cFontLoader::tDistanceFontHandle cFontLoader::CreateDistanceFieldFont(FreeTypeFace& face, uint32_t tex_size) { std::unique_ptr<cDistanceFieldFont> font; try { cCreateBitmapFontTask create_task(face, tex_size); do { Log::Debug("Font creation progress: %d", static_cast<int>(100.0f*create_task.Progress())); create_task.DoWork(); } while (!create_task.IsDone()); font = create_task.GetCompletedFont(); } catch(const FreeTypeException& fail) { Log::Error("Failed Distance font creation with freetype error:" "\n\t%s: \"%s\"",fail.what(), FreeTypeLibrary::ErrorString(fail.mFreeTypeError)); return tDistanceFontHandle(); } return InsertDistanceFont(std::move(font)); }
/* ****************************************************************************** * dcs_server_rest_init *//** * * \brief - Initializes the DCS Server REST infrastructure * * \param[in] rest_port - The Port on which the REST Services should run on * * \retval DOVE_STATUS_RESTC_INIT_FAILED Cannot initialize REST Client * \retval DOVE_STATUS_THREAD_FAILED Cannot start HTTP Server * \retval DOVE_STATUS_OK Success * ****************************************************************************** */ dove_status dcs_server_rest_init(short rest_port) { int ret = 0; dove_status status = DOVE_STATUS_OK; log_notice(RESTHandlerLogLevel, "dcs_server_rest_init Enter: Port %d", rest_port); do { ret = dove_rest_client_init(); if (ret) { status = DOVE_STATUS_RESTC_INIT_FAILED; break; } log_notice(RESTHandlerLogLevel, "dcs_server_rest_init: Initialized REST Client"); /* Create a thread for configuration sync */ if (create_task((const char *)"RSTS", 0, OSW_DEFAULT_STACK_SIZE, http_server_main, (void *)(long)rest_port, &httpsrvTaskId) != OSW_OK) { status = DOVE_STATUS_THREAD_FAILED; break; } }while(0); log_notice(RESTHandlerLogLevel, "dcs_server_rest_init Exit: status %s", DOVEStatusToString(status)); return status; }