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