C++ create_task函数代码示例

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;
}