自学教程：C++ task_alloc函数代码示例

taskqid_ttaskq_dispatch(taskq_t *tq, task_func_t func, void *arg, uint_t tqflags){	task_t *t;	if (taskq_now) {		func(arg);		return (1);	}	mutex_enter(&tq->tq_lock);	ASSERT(tq->tq_flags & TASKQ_ACTIVE);	if ((t = task_alloc(tq, tqflags)) == NULL) {		mutex_exit(&tq->tq_lock);		return (0);	}	t->task_next = &tq->tq_task;	t->task_prev = tq->tq_task.task_prev;	t->task_next->task_prev = t;	t->task_prev->task_next = t;	t->task_func = func;	t->task_arg = arg;	cv_signal(&tq->tq_dispatch_cv);	mutex_exit(&tq->tq_lock);	return (1);}

void testAllocHandlesOutOfMemory(void){	long i;	int dealtWithOutOfMemory = 0;		printf(" => testAllocHandlesOutOfMemory/n");	REAL_TASK_COUNT = 0;	for(i = FAIR_TASK_COUNT; i <= MAX_TASK_COUNT && dealtWithOutOfMemory == 0; i++){		/* Point test slot i to the actual task_alloc() result. */		tasks[i] = NULL;		tasks[i] = task_alloc();		if (tasks[i] != NULL){			/* Slots must be in the allocated space */			assert( (unsigned long)tasks[i] <= ( (unsigned long)get_MEM_BLOCK_START() + MEM_BLOCK_SIZE ) );		} else {			/* If the allocation was out of memory, NULL may have been returned, which passes the test */			dealtWithOutOfMemory = 1;			REAL_TASK_COUNT = i;		}	}	assert(REAL_TASK_COUNT >= FAIR_TASK_COUNT);	assert(REAL_TASK_COUNT <= MAX_TASK_COUNT);	assert( dealtWithOutOfMemory );}

/*ARGSUSED*/taskq_t *taskq_create(const char *name, int nthreads, pri_t pri,	int minalloc, int maxalloc, uint_t flags){	taskq_t *tq = kmem_zalloc(sizeof (taskq_t), KM_SLEEP);	int t;	rw_init(&tq->tq_threadlock, NULL, RW_DEFAULT, NULL);	mutex_init(&tq->tq_lock, NULL, MUTEX_DEFAULT, NULL);	cv_init(&tq->tq_dispatch_cv, NULL, CV_DEFAULT, NULL);	cv_init(&tq->tq_wait_cv, NULL, CV_DEFAULT, NULL);	tq->tq_flags = flags | TASKQ_ACTIVE;	tq->tq_active = nthreads;	tq->tq_nthreads = nthreads;	tq->tq_minalloc = minalloc;	tq->tq_maxalloc = maxalloc;	tq->tq_task.task_next = &tq->tq_task;	tq->tq_task.task_prev = &tq->tq_task;	tq->tq_threadlist = kmem_alloc(nthreads * sizeof (pthread_t), KM_SLEEP);	if (flags & TASKQ_PREPOPULATE) {		mutex_enter(&tq->tq_lock);		while (minalloc-- > 0)			task_free(tq, task_alloc(tq, KM_SLEEP));		mutex_exit(&tq->tq_lock);	}	for (t = 0; t < nthreads; t++)		pthread_create(&tq->tq_threadlist[t], NULL, taskq_thread, tq);	return (tq);}

void testAllocUniqueFreeMemory(void){	int i;	task_t *prev_task = NULL;	printf(" => testAllocUniqueFreeMemory/n");	for(i = 0; i < FAIR_TASK_COUNT; i++){		/* Point test slot i to the actual task_alloc() result. */		tasks[i] = task_alloc();		/* Slots must be allocated */		assert(tasks[i] != NULL);		/* Cannot assert: Slots must be in the allocated space */		/* Try and set some data */		tasks[i]->id = i;				/* Compare and set prev_task */		if (prev_task != NULL){			/* Slots must be unique in pointer reference */			assert(tasks[i] != prev_task);			/* Slots must thus be unique in value */			assert(tasks[i]->id != prev_task->id);		}		prev_task = tasks[i];		/* Keep track of the amount of tasks*/	}}

void testAllocUniqueFreeMemory(void){	int i;	task_t *prev_task = NULL;	printf(" => testAllocUniqueFreeMemory/n");	for(i = 0; i < FAIR_TASK_COUNT; i++){		/* Point test slot i to the actual task_alloc() result. */		tasks[i] = task_alloc();		/* Slots must be allocated */		assert(tasks[i] != NULL);		/* Slots must be in the allocated space */		assert( (unsigned long)tasks[i] <= ( (unsigned long)get_MEM_BLOCK_START() + MEM_BLOCK_SIZE ) );		/* Try and set some data */		tasks[i]->id = i;				/* Compare and set prev_task */		if (prev_task != NULL){			/* Slots must be unique in pointer reference */			assert(tasks[i] != prev_task);			/* Slots must thus be unique in value */			assert(tasks[i]->id != prev_task->id);		}		prev_task = tasks[i];	}}

struct TASK *task_init(struct MEMMAN *memman){    int i;    struct TASK *task;    struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;    taskctl = (struct TASKCTL *) memman_alloc_4k(memman, sizeof(struct TASKCTL));    for (i = 0; i < MAX_TASKS; i++) {	taskctl->tasks0[i].flags = 0;	taskctl->tasks0[i].sel = (TASK_GDT0 + i) * 8;	set_segmdesc(gdt + TASK_GDT0 + i, 103, (int) &taskctl->tasks0[i].tss, AR_TSS32);    }    for (i = 0; i < MAX_TASKLEVELS; i++) {		taskctl->level[i].running = 0;		taskctl->level[i].now = 0;	}    task = task_alloc();    task->flags = 2;    task->priority = 2;    task->level = 0;    task_add(task);    task_switchsub();    load_tr(task->sel);    task_timer = timer_alloc();    timer_settime(task_timer, task->priority);    return task;}

static intspmd_add_resolver_task(struct resolver_sock *rshead){    struct task *t;    struct resolver_sock *rs = NULL;    if (!rshead) {        SPMD_PLOG(SPMD_L_INTERR, "Argument rshead is NULL");        return -1;    }    rs = rshead;    while (rs) {        t = task_alloc(MAX_UDP_DNS_SIZE);        t->fd = rs->s;        t->flags = 0;        t->sa = &rs->sock.sa;        t->salen = sizeof(rs->sock);/* cant use SPMD_SALEN() */        t->func = query_recv;        task_list_add(t, &spmd_task_root->read);        rs = rs->next;    }    return 0;}

struct SHEET *open_console(struct SHTCTL *shtctl, unsigned int memtotal){	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;	struct SHEET *sht = sheet_alloc(shtctl);	unsigned char *buf = (unsigned char *) memman_alloc_4k(memman, 256 * 165);	struct TASK *task = task_alloc();	int *cons_fifo = (int *) memman_alloc_4k(memman, 128 * 4);	sheet_setbuf(sht, buf, 256, 165, -1); /* 透明色なし */	make_window8(buf, 256, 165, "console", 0);	make_textbox8(sht, 8, 28, 240, 128, COL8_000000);	task->cons_stack = memman_alloc_4k(memman, 64 * 1024);	task->tss.esp = task->cons_stack + 64 * 1024 - 12;	task->tss.eip = (int) &console_task;	task->tss.es = 1 * 8;	task->tss.cs = 2 * 8;	task->tss.ss = 1 * 8;	task->tss.ds = 1 * 8;	task->tss.fs = 1 * 8;	task->tss.gs = 1 * 8;	*((int *) (task->tss.esp + 4)) = (int) sht;	*((int *) (task->tss.esp + 8)) = memtotal;	task_run(task, 2, 2); /* level=2, priority=2 */	sht->task = task;	sht->flags |= 0x20;	/* カ
C++ task_cpu函数代码示例
C++ taskSpawn函数代码示例