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