Пример #1
0
EXPORT int  
stpool_task_wait_all(struct sttask *entry[], int n, long ms) 
{
	int idx, e = 0;
	uint64_t sclock = (ms > 0) ? us_startr() : 0;
	
	do {
		/**
		 * Scan the whole entry to find a task who is not
		 * free now, and then we wait for it in @ms 
		 */
		for (idx=0; idx<n; idx++) 
			if (entry[idx] && !stpool_task_is_free(entry[idx]))
				break;
		
		/**
		 * If there are none busy tasks existing in the entry,
		 * we return 0 imediately 
		 */
		if (idx == n)
			return 0;

		e = stpool_task_wait(entry[idx], ms);

		/**
		 * Caculate the left waiting time if it is necessary 
		 */
		if (ms > 0 && 
			0  > (ms -= us_endr(sclock) / 1000))
			ms = 0;
	} while (!e);

	return e;
}
Пример #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;
}
Пример #3
0
int main()
{
	time_t now;
	int i, c, times;
	int sum, *arg;
	HPOOL hp;
		
	/* Creat a task pool */
	hp = stpool_create(50,  /* max servering threads */
			           0,   /* 0 servering threads that reserved for waiting for tasks */
			           1,   /* suspend the pool */
			           0);  /* default number of priority queue */
	printf("%s\n", stpool_status_print(hp, NULL, 0));
		
	/* Add tasks */
	times = 90000;	
	arg = (int *)malloc(times * sizeof(int));
	for (i=0; i<times; i++) {
		/* It'll take a long time if the program is linked with the debug library */
		if (i % 4000 == 0 || (i + 1) ==times) {
			printf("\rLoading tasks ... %.2f%%  ", (float)i * 100/ times);
			fflush(stdout);
		}
		arg[i] = i;
		stpool_add_routine(hp, "sche", task_run, NULL, (void *)&arg[i], NULL);	
	}
	printf("\nAfter having executed @stpool_add_routine for %d times:\n"
		   "--------------------------------------------------------\n%s\n", 
		   times, stpool_status_print(hp, NULL, 0));
	
	printf("Press any key to resume the pool.\n");
	getchar();
	
	/* Wake up the pool to schedule tasks */
	stpool_resume(hp);

	/* Wait for all tasks' being done. */
	stpool_task_wait(hp, NULL, -1);
	
	/* Get the sum */
	for (i=0, sum=0; i<times; i++)
		sum += arg[i];
	free(arg);
	
	now = time(NULL);
	printf("--OK. finished. <arg: %d> %s\n%s\n", 
		sum, ctime(&now), stpool_status_print(hp, NULL, 0));
#if 0
	/* You can use debug library to watch the status of the pool */
	while ('q' != getchar()) {
		for (i=0; i<40; i++)
			stpool_add_routine(hp, "debug", task_run, NULL, &sum, NULL);	
		msleep(1);
	}

	/* Clear the stdio cache */
	while ((c=getchar()) && c != '\n' && c != EOF)
		;
#endif
	
	/* Release the pool */
	printf("Shut down the pool now.\n");
	stpool_release(hp);
	getchar();
		
	return 0;
}