Exemplo n.º 1
0
EXPORT int
stpool_task_init(struct sttask *ptask, stpool_t *pool,
				const char *name, void (*run)(struct sttask *ptask),
				void (*err_handler)(struct sttask *ptask, long reasons),
				void *arg) 
{	
	__stpool_task_INIT(TASK_CAST_DOWN(ptask), name, run, err_handler, arg);

	return stpool_task_set_p(ptask, pool);
}
Exemplo n.º 2
0
int main() 
{
	stpool_t *pool;
	int i, error, c = 0;
	struct schattr attr = {0, 1, ep_SCHE_TOP};	
	struct sttask *ptsk;
	
	long eCAPs = eCAP_F_DYNAMIC|eCAP_F_SUSPEND|eCAP_F_THROTTLE|eCAP_F_ROUTINE|
			eCAP_F_DISABLEQ|eCAP_F_PRIORITY|eCAP_F_WAIT_ALL;
	
	/** NO buffer */
	setbuf(stdout, 0);
	
	/** Create a pool */
	pool = stpool_create("mypool", /** pool name */
						 eCAPs,    /** neccessary capabilites */
	                     20,	   /** limited threads number*/
				          0,	   /** number of threads reserved to waiting for tasks*/
				          0,	   /** do not suspend the pool */
				          1		   /** priority queue num */
					   );
	if (!pool)
		abort();
	
	/** Print the status of the pool */
	printf("@stpool_create(20, 0, 0, 10)\n%s\n", stpool_stat_print(pool));
		
	/*------------------------------------------------------------/
	/--------------------Test @stpool_adjust(_abs)----------------/
	/------------------------------------------------------------*/
	printf("\nPress any key to test the @stpool_adjust(300, 4) ....\n");
	getchar();
	stpool_adjust_abs(pool, 300, 4);
	printf("@stpool_adjust_abs(pool, 300, 4)\n%s\n", stpool_stat_print(pool));
	
	/** We call @stpool_adjust to recover the pool env */
	printf("\nPress any key to test the @stpool_adjust(-280, -4) ....\n");
	getchar();
	stpool_adjust(pool, -280, -4);
	printf("@stpool_adjust(pool, -280, -4)\n%s\n", stpool_stat_print(pool));
	
	/*------------------------------------------------------------------/
	/----------------Test rescheduling task----------------------------/
	/------------------------------------------------------------------*/
	printf("\nPress any key to test rescheduling task. <then press key to stop testing.>\n");
	getchar();
	
	/** We creat a customed task to do the test */
	ptsk = stpool_task_new(NULL, "test-reschedule", task_reschedule, NULL, &c);
	
	/** Attach the destinational pool */
	error = stpool_task_set_p(ptsk, pool);
	if (error)
		printf("***Err: %d(%s). (try eCAP_F_CUSTOM_TASK)\n", error, stpool_strerror(error));
	else {
		stpool_task_set_userflags(ptsk, 0x1);
		stpool_task_queue(ptsk);
		
		getchar();
		/** Set the flag to notify the task to exit the rescheduling test */
		stpool_task_set_userflags(ptsk, 0);
		stpool_task_wait(ptsk, -1);
	}
	stpool_task_delete(ptsk);
	
	/*-------------------------------------------------------------------/
	/--------------------Test the throttle------------------------------/
	/-------------------------------------------------------------------*/
	printf("\nPress any key to test the throttle ....\n");
	getchar();
	
	/** Turn the throttle on */
	stpool_throttle_enable(pool, 1);
	error = stpool_add_routine(pool, "test-throttle", task_run, task_err_handler, &c, NULL);
	if (error)
		printf("***Err: @stpool_add_task: %d\n", error);
	/** Turn the throttle off */
	stpool_throttle_enable(pool, 0);
	
	/*-------------------------------------------------------------------/
	/------------------Test the priority--------------------------------/
	/-------------------------------------------------------------------*/
	printf("\nPress any key to test the priority ....\n");
	getchar();
	
	stpool_suspend(pool, 0);
	/**
	 * Add a task with zero priority, and the task will be pushed into the 
	 * lowest priority queue. 
	 */
	stpool_add_routine(pool, "zero-priority", task_run, task_err_handler, &c, NULL);
		
	/**
	 * task("non-zero-priority") will be scheduled prior to the task("zero-priority") 
	 * since it has a higher priority.
	 */
	stpool_add_routine(pool, "non-zero-priority", task_run, task_err_handler, &c, &attr); 
	
	/** Wake up the pool to schedule the tasks */
	stpool_resume(pool);

	/** Wait for all tasks' being done completely */
	stpool_wait_all(pool, -1);
	
	/*------------------------------------------------------------------/
	/---------------Test running amount of tasks-----------------------/
	/------------------------------------------------------------------*/
	printf("\nPress any key to add tasks ... <then can press any key to remove them.>\n");
	getchar();
	
	/**
	 * We can suspend the pool firstly, and then resume the pool after delivering our
	 * tasks into the pool, It'll be more effecient to do it like that if there are 
	 * a large amount of tasks that will be added into the pool.
	 */
	for (i=0; i<8000; i++) 
		stpool_add_routine(pool, "task_run", task_run, task_err_handler, &c, NULL);
	
	/*----------------------------------------------------------------/
	/-------------Test stoping all tasks fastly----------------------/
	/----------------------------------------------------------------*/
	printf("\nPress any key to test stoping all tasks fastly.\n");
	getchar();

	stpool_throttle_enable(pool, 1);
	stpool_remove_all(pool, 1);
	
	/** Wait for all tasks' being done */
	stpool_wait_all(pool, -1);
	printf("---------------------------tasks have been finished.\n");
	
	
	/*---------------------------------------------------------------/
	/-------------Release the pool-----------------------------------/
	/---------------------------------------------------------------*/
	printf("Press any key to release the pool...\n");
	getchar();
	
	/** Release the pool */
	printf("%s\n", stpool_stat_print(pool));
	stpool_release(pool);
	
	printf("Press any key to exit ...\n");
	getchar();
	
	return 0;
}