Make task quantum dynamic: smaller if there are more tasks waiting.

diff --git a/bin/delv/delv.c b/bin/delv/delv.c
index 8754d1b328d143fdd4a45baddcb7806390a6e003..658400b88a75fa1851683b07eec8d26e0dcc2b44 100644 (file)
--- a/bin/delv/delv.c
+++ b/bin/delv/delv.c
@@ -1623,7 +1623,7 @@ main(int argc, char *argv[]) {
                fatal("failed to create mctx");
 
        CHECK(isc_appctx_create(mctx, &actx));
-       CHECK(isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr));
+       CHECK(isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr));
        CHECK(isc_socketmgr_createinctx(mctx, actx, &socketmgr));
        CHECK(isc_timermgr_createinctx(mctx, actx, &timermgr));
 

diff --git a/bin/dig/dighost.c b/bin/dig/dighost.c
index 2b6cab552e8c37f5a742fc84a0de14a6f0dadd48..d588c910b189f1cb14c766a9b18ad4208f468f64 100644 (file)
--- a/bin/dig/dighost.c
+++ b/bin/dig/dighost.c
@@ -1363,7 +1363,7 @@ setup_libs(void) {
 
        isc_log_setdebuglevel(lctx, 0);
 
-       result = isc_taskmgr_create(mctx, 1, 0, &taskmgr);
+       result = isc_taskmgr_create(mctx, 1, &taskmgr);
        check_result(result, "isc_taskmgr_create");
 
        result = isc_task_create(taskmgr, 0, &global_task);

diff --git a/bin/dnssec/dnssec-signzone.c b/bin/dnssec/dnssec-signzone.c
index 7e2e6c67c1c7691ef30d25141f47ec5b8bc4bc69..0dc23bded5cf6dacd1d0f66f150a61c1dd7f178d 100644 (file)
--- a/bin/dnssec/dnssec-signzone.c
+++ b/bin/dnssec/dnssec-signzone.c
@@ -3853,7 +3853,7 @@ main(int argc, char *argv[]) {
        print_time(outfp);
        print_version(outfp);
 
-       result = isc_taskmgr_create(mctx, ntasks, 0, &taskmgr);
+       result = isc_taskmgr_create(mctx, ntasks, &taskmgr);
        if (result != ISC_R_SUCCESS)
                fatal("failed to create task manager: %s",
                      isc_result_totext(result));

diff --git a/bin/named/main.c b/bin/named/main.c
index 7c1d1fa6f1d0d7b7c7924f0cf06b719972268a15..15f048e04d11379a2c8a8d6b8e6ccbbb5384968d 100644 (file)
--- a/bin/named/main.c
+++ b/bin/named/main.c
@@ -803,7 +803,7 @@ create_managers(void) {
                      "using %u UDP listener%s per interface",
                      named_g_udpdisp, named_g_udpdisp == 1 ? "" : "s");
 
-       result = isc_taskmgr_create(named_g_mctx, named_g_cpus, 0,
+       result = isc_taskmgr_create(named_g_mctx, named_g_cpus,
                                    &named_g_taskmgr);
        if (result != ISC_R_SUCCESS) {
                UNEXPECTED_ERROR(__FILE__, __LINE__,

diff --git a/bin/nsupdate/nsupdate.c b/bin/nsupdate/nsupdate.c
index 7ffba6be547008c916661445ef451fdb8d3b91c6..5d2ed67639552dd3169103d71c991030027de98c 100644 (file)
--- a/bin/nsupdate/nsupdate.c
+++ b/bin/nsupdate/nsupdate.c
@@ -885,7 +885,7 @@ setup_system(void) {
        result = isc_timermgr_create(gmctx, &timermgr);
        check_result(result, "dns_timermgr_create");
 
-       result = isc_taskmgr_create(gmctx, 1, 0, &taskmgr);
+       result = isc_taskmgr_create(gmctx, 1, &taskmgr);
        check_result(result, "isc_taskmgr_create");
 
        result = isc_task_create(taskmgr, 0, &global_task);

diff --git a/bin/rndc/rndc.c b/bin/rndc/rndc.c
index 48682de9db2c1dba9a2b9255677df96ce28eabc8..497efe2e62f545c0fc7ac5162311b72f6e96f68d 100644 (file)
--- a/bin/rndc/rndc.c
+++ b/bin/rndc/rndc.c
@@ -934,7 +934,7 @@ main(int argc, char **argv) {
 
        DO("create memory context", isc_mem_create(0, 0, &rndc_mctx));
        DO("create socket manager", isc_socketmgr_create(rndc_mctx, &socketmgr));
-       DO("create task manager", isc_taskmgr_create(rndc_mctx, 1, 0, &taskmgr));
+       DO("create task manager", isc_taskmgr_create(rndc_mctx, 1, &taskmgr));
        DO("create task", isc_task_create(taskmgr, 0, &task));
 
        DO("create logging context", isc_log_create(rndc_mctx, &log, &logconfig));

diff --git a/bin/tests/optional/adb_test.c b/bin/tests/optional/adb_test.c
index 8eeef45a47300369c6cc5be9cbb4bb0f90e23fc8..d36c00f89646e2d7ddc92200a92c597a9e170737 100644 (file)
--- a/bin/tests/optional/adb_test.c
+++ b/bin/tests/optional/adb_test.c
@@ -146,7 +146,7 @@ create_managers(void) {
        isc_result_t result;
 
        taskmgr = NULL;
-       result = isc_taskmgr_create(mctx, 5, 0, &taskmgr);
+       result = isc_taskmgr_create(mctx, 5, &taskmgr);
        check_result(result, "isc_taskmgr_create");
 
        timermgr = NULL;

diff --git a/bin/tests/optional/byaddr_test.c b/bin/tests/optional/byaddr_test.c
index 05e6c5ded31e438d246f83771730d95b16115ce1..2670a9077a9b173896cb0a5f6e679068f8841e0b 100644 (file)
--- a/bin/tests/optional/byaddr_test.c
+++ b/bin/tests/optional/byaddr_test.c
@@ -114,7 +114,7 @@ main(int argc, char *argv[]) {
        }
 
        taskmgr = NULL;
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr)
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &taskmgr)
                      == ISC_R_SUCCESS);
        task = NULL;
        RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task)

diff --git a/bin/tests/optional/byname_test.c b/bin/tests/optional/byname_test.c
index c48baec0bd1deb1083ae687b0cfc6935fae49502..f4658aff472f6236939287e1671787d81bb31676 100644 (file)
--- a/bin/tests/optional/byname_test.c
+++ b/bin/tests/optional/byname_test.c
@@ -228,7 +228,7 @@ main(int argc, char *argv[]) {
        }
 
        taskmgr = NULL;
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &taskmgr) ==
                      ISC_R_SUCCESS);
        task = NULL;
        RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task) ==

diff --git a/bin/tests/optional/gsstest.c b/bin/tests/optional/gsstest.c
index badb346609a5b75ed5ad96c5a82675e467431287..d09daca806d2019e7d7e0c93652c2a42b104e698 100644 (file)
--- a/bin/tests/optional/gsstest.c
+++ b/bin/tests/optional/gsstest.c
@@ -472,7 +472,7 @@ main(int argc, char *argv[]) {
        RUNCHECK(dst_lib_init(mctx, NULL));
 
        taskmgr = NULL;
-       RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
+       RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
        task = NULL;
        RUNCHECK(isc_task_create(taskmgr, 0, &task));
        timermgr = NULL;

diff --git a/bin/tests/optional/ratelimiter_test.c b/bin/tests/optional/ratelimiter_test.c
index 02eadace52620e69507ae5e3df64c86df2896104..a405e05df4510aaefa839c7349d97abca5325bc5 100644 (file)
--- a/bin/tests/optional/ratelimiter_test.c
+++ b/bin/tests/optional/ratelimiter_test.c
@@ -104,8 +104,7 @@ main(int argc, char *argv[]) {
        isc_interval_set(&linterval, 1, 0);
 
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, 3, 0, &taskmgr) ==
-                     ISC_R_SUCCESS);
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, 3, &taskmgr) == ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) ==
                      ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_task_create(taskmgr, 0, &g_task) ==

diff --git a/bin/tests/optional/shutdown_test.c b/bin/tests/optional/shutdown_test.c
index 1eeaf07ea77c10d7fa34275f647476987aec625f..e2fe58e062effa4bdc38dddef41ca7b02b84314e 100644 (file)
--- a/bin/tests/optional/shutdown_test.c
+++ b/bin/tests/optional/shutdown_test.c
@@ -183,7 +183,7 @@ main(int argc, char *argv[]) {
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
        mctx2 = NULL;
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx2) == ISC_R_SUCCESS);
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &task_manager) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &task_manager) ==
                      ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_timermgr_create(mctx, &timer_manager) ==
                      ISC_R_SUCCESS);

diff --git a/bin/tests/optional/sig0_test.c b/bin/tests/optional/sig0_test.c
index 9db47c66b8cb9e1bc56ca65cd91b0a9f68528fdd..7b6d8f72e72ab743079b409d9d1e3439ade191c4 100644 (file)
--- a/bin/tests/optional/sig0_test.c
+++ b/bin/tests/optional/sig0_test.c
@@ -228,8 +228,7 @@ main(int argc, char *argv[]) {
        dst_result_register();
 
        taskmgr = NULL;
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, 0, &taskmgr) ==
-                     ISC_R_SUCCESS);
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, &taskmgr) == ISC_R_SUCCESS);
        task1 = NULL;
        RUNTIME_CHECK(isc_task_create(taskmgr, 0, &task1) == ISC_R_SUCCESS);
 

diff --git a/bin/tests/optional/sock_test.c b/bin/tests/optional/sock_test.c
index f13a3ffe64c8077edb197dda18306ba4b612f719..54b813987ff2d6e81a0d8cbaae8008d5894e7d18 100644 (file)
--- a/bin/tests/optional/sock_test.c
+++ b/bin/tests/optional/sock_test.c
@@ -297,7 +297,7 @@ main(int argc, char *argv[]) {
         * The task manager is independent (other than memory context)
         */
        manager = NULL;
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &manager) ==
                      ISC_R_SUCCESS);
 
        /*

diff --git a/bin/tests/optional/task_test.c b/bin/tests/optional/task_test.c
index 108801034928b881a8ae32722901c337f30d836d..3f823302fd6411801f58985c059c6b74a68e93dc 100644 (file)
--- a/bin/tests/optional/task_test.c
+++ b/bin/tests/optional/task_test.c
@@ -81,7 +81,7 @@ main(int argc, char *argv[]) {
 
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
 
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, 0, &manager) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, workers, &manager) ==
                      ISC_R_SUCCESS);
 
        RUNTIME_CHECK(isc_task_create(manager, 0, &t1) == ISC_R_SUCCESS);

diff --git a/bin/tests/optional/timer_test.c b/bin/tests/optional/timer_test.c
index 53d3b35ca22e301a099a121ac079960a0a13b958..580a7eb8488e363578e82daa4860d5af45578969 100644 (file)
--- a/bin/tests/optional/timer_test.c
+++ b/bin/tests/optional/timer_test.c
@@ -110,7 +110,7 @@ main(int argc, char *argv[]) {
        printf("%u workers\n", workers);
 
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx1) == ISC_R_SUCCESS);
-       RUNTIME_CHECK(isc_taskmgr_create(mctx1, workers, 0, &manager) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx1, workers, &manager) ==
                      ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_timermgr_create(mctx1, &timgr) == ISC_R_SUCCESS);
 

diff --git a/bin/tests/optional/zone_test.c b/bin/tests/optional/zone_test.c
index b26acea0b17ff42a85c897d3a74d37c291ee025b..3b8406d3ff0550c7c8aab032d85567124f2cc968 100644 (file)
--- a/bin/tests/optional/zone_test.c
+++ b/bin/tests/optional/zone_test.c
@@ -284,7 +284,7 @@ main(int argc, char **argv) {
 
        RUNTIME_CHECK(isc_app_start() == ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
-       RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, 0, &taskmgr) ==
+       RUNTIME_CHECK(isc_taskmgr_create(mctx, 2, &taskmgr) ==
                      ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_timermgr_create(mctx, &timermgr) == ISC_R_SUCCESS);
        RUNTIME_CHECK(isc_socketmgr_create(mctx, &socketmgr) == ISC_R_SUCCESS);

diff --git a/bin/tests/system/pipelined/pipequeries.c b/bin/tests/system/pipelined/pipequeries.c
index 74de833fc16ff87720da7d26f10ca0b2d59d4d4e..9d8dddc21603c5b7bdf0a593c68bc8971ab0e1d0 100644 (file)
--- a/bin/tests/system/pipelined/pipequeries.c
+++ b/bin/tests/system/pipelined/pipequeries.c
@@ -279,7 +279,7 @@ main(int argc, char *argv[]) {
        RUNCHECK(dst_lib_init(mctx, NULL));
 
        taskmgr = NULL;
-       RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
+       RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
        task = NULL;
        RUNCHECK(isc_task_create(taskmgr, 0, &task));
        timermgr = NULL;

diff --git a/bin/tests/system/tkey/keycreate.c b/bin/tests/system/tkey/keycreate.c
index c39f6a4ec18f5c5b342fe982792c2547dc673a03..935ee7bb6a9272c1abd59f037859efc107596bf6 100644 (file)
--- a/bin/tests/system/tkey/keycreate.c
+++ b/bin/tests/system/tkey/keycreate.c
@@ -239,7 +239,7 @@ main(int argc, char *argv[]) {
        RUNCHECK(dst_lib_init(mctx, NULL));
 
        taskmgr = NULL;
-       RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
+       RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
        task = NULL;
        RUNCHECK(isc_task_create(taskmgr, 0, &task));
        timermgr = NULL;

diff --git a/bin/tests/system/tkey/keydelete.c b/bin/tests/system/tkey/keydelete.c
index 547e8d03d3e4519bde356c1942a0cde7bbf21f2f..465076edafbbfcaefb9a653e64bf67f4b8628eae 100644 (file)
--- a/bin/tests/system/tkey/keydelete.c
+++ b/bin/tests/system/tkey/keydelete.c
@@ -178,7 +178,7 @@ main(int argc, char **argv) {
        RUNCHECK(dst_lib_init(mctx, NULL));
 
        taskmgr = NULL;
-       RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
+       RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
        task = NULL;
        RUNCHECK(isc_task_create(taskmgr, 0, &task));
        timermgr = NULL;

diff --git a/bin/tools/mdig.c b/bin/tools/mdig.c
index 35942687fe30959f477e5c2e1c450c60d94a5de8..39a3c16dd8bad51c9003dc1b052a7bd3ef5c5711 100644 (file)
--- a/bin/tools/mdig.c
+++ b/bin/tools/mdig.c
@@ -1981,7 +1981,7 @@ main(int argc, char *argv[]) {
                fatal("can't choose between IPv4 and IPv6");
 
        taskmgr = NULL;
-       RUNCHECK(isc_taskmgr_create(mctx, 1, 0, &taskmgr));
+       RUNCHECK(isc_taskmgr_create(mctx, 1, &taskmgr));
        task = NULL;
        RUNCHECK(isc_task_create(taskmgr, 0, &task));
        timermgr = NULL;

diff --git a/lib/dns/client.c b/lib/dns/client.c
index 9b7a212cf76b53c1423ab088a0c7733a93e7b5b7..bb73a6b490baf7ced13c1c2bfbfb4bc6042f189c 100644 (file)
--- a/lib/dns/client.c
+++ b/lib/dns/client.c
@@ -379,7 +379,7 @@ dns_client_create(dns_client_t **clientp, unsigned int options) {
        result = isc_app_ctxstart(actx);
        if (result != ISC_R_SUCCESS)
                goto cleanup;
-       result = isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr);
+       result = isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr);
        if (result != ISC_R_SUCCESS)
                goto cleanup;
        result = isc_socketmgr_createinctx(mctx, actx, &socketmgr);

diff --git a/lib/dns/dispatch.c b/lib/dns/dispatch.c
index b6fdd52051e8e457d257bd72fa4e55daa2d641d5..b151254511493932bf11c196460f5cfdffde172f 100644 (file)
--- a/lib/dns/dispatch.c
+++ b/lib/dns/dispatch.c
@@ -2468,7 +2468,7 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 
        disp->ntasks = 1;
        disp->task[0] = NULL;
-       result = isc_task_create(taskmgr, 50, &disp->task[0]);
+       result = isc_task_create(taskmgr, 0, &disp->task[0]);
        if (result != ISC_R_SUCCESS)
                goto kill_socket;
 

diff --git a/lib/dns/tests/dnstest.c b/lib/dns/tests/dnstest.c
index c2f927095d9092f3abb47353c5f46b4ed6f43b9f..303ed77e2e4b0f70175aef24155ce774bb16d90d 100644 (file)
--- a/lib/dns/tests/dnstest.c
+++ b/lib/dns/tests/dnstest.c
@@ -109,7 +109,7 @@ create_managers(void) {
        isc_result_t result;
        ncpus = isc_os_ncpus();
 
-       CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
+       CHECK(isc_taskmgr_create(mctx, ncpus, &taskmgr));
        CHECK(isc_timermgr_create(mctx, &timermgr));
        CHECK(isc_socketmgr_create(mctx, &socketmgr));
        CHECK(isc_task_create(taskmgr, 0, &maintask));

diff --git a/lib/irs/context.c b/lib/irs/context.c
index 1e56786b09d45b13d49dd548b18f0192b3e89401..28873babb1971975e2fd9661bf8d6489cc050942 100644 (file)
--- a/lib/irs/context.c
+++ b/lib/irs/context.c
@@ -104,7 +104,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
        if (result != ISC_R_SUCCESS)
                goto fail;
 
-       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
+       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
        if (result != ISC_R_SUCCESS)
                goto fail;
 

diff --git a/lib/isc/include/isc/task.h b/lib/isc/include/isc/task.h
index b2d9c4838460b256481932db37056ac598bdd6d0..239dfb664eef7164846bf3f1d9378ef196929bb3 100644 (file)
--- a/lib/isc/include/isc/task.h
+++ b/lib/isc/include/isc/task.h
@@ -631,11 +631,10 @@ isc_task_privilege(isc_task_t *task);
 
 isc_result_t
 isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
-                       unsigned int workers, unsigned int default_quantum,
-                       isc_taskmgr_t **managerp);
+                       unsigned int workers, isc_taskmgr_t **managerp);
 isc_result_t
 isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
-                  unsigned int default_quantum, isc_taskmgr_t **managerp);
+                  isc_taskmgr_t **managerp);
 /*%<
  * Create a new task manager.  isc_taskmgr_createinctx() also associates
  * the new manager with the specified application context.
@@ -648,10 +647,6 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
  *     create 'workers' threads, but if at least one thread creation
  *     succeeds, isc_taskmgr_create() may return ISC_R_SUCCESS.
  *
- *\li  If 'default_quantum' is non-zero, then it will be used as the default
- *     quantum value when tasks are created.  If zero, then an implementation
- *     defined default quantum will be used.
- *
  * Requires:
  *
  *\li      'mctx' is a valid memory context.

diff --git a/lib/isc/task.c b/lib/isc/task.c
index a51d3359abfcc42137126362420c4bc8ea46b898..fcd4cd9a4895020bb251485af9ebe16c51b55334 100644 (file)
--- a/lib/isc/task.c
+++ b/lib/isc/task.c
@@ -134,6 +134,7 @@ struct isc__taskqueue {
        isc_condition_t                 work_available;
        isc_thread_t                    thread;
        unsigned int                    threadid;
+       unsigned int                    tasks_waiting;
        isc__taskmgr_t                  *manager;
 };
 
@@ -151,7 +152,6 @@ struct isc__taskmgr {
        isc__taskqueue_t                *queues;
 
        /* Locked by task manager lock. */
-       unsigned int                    default_quantum;
        LIST(isc__task_t)               tasks;
        isc_taskmgrmode_t               mode;
        bool                            pause_requested;
@@ -176,7 +176,17 @@ void
 isc__taskmgr_resume(isc_taskmgr_t *manager0);
 
 
-#define DEFAULT_DEFAULT_QUANTUM                25
+/*
+ * Unless specified otherwise when creating task we  normally run
+ * DEFAULT_QUANTUM events from a task in a single worker loop.
+ * If there are more than CONGESTED_TASK_LIMIT tasks waiting in the same queue
+ * we switch to CONGESTED_QUANTUM tasks per loop.
+ */
+
+#define DEFAULT_QUANTUM                        25
+#define CONGESTED_QUANTUM              10
+#define CONGESTED_TASK_LIMIT           5
+
 #define FINISHED(m)                    ((m)->exiting && EMPTY((m)->tasks))
 
 /*%
@@ -292,7 +302,7 @@ isc_task_create_bound(isc_taskmgr_t *manager0, unsigned int quantum,
        INIT_LIST(task->events);
        INIT_LIST(task->on_shutdown);
        task->nevents = 0;
-       task->quantum = (quantum > 0) ? quantum : manager->default_quantum;
+       task->quantum = quantum;
        task->flags = 0;
        task->now = 0;
        isc_time_settoepoch(&task->tnow);
@@ -932,6 +942,7 @@ pop_readyq(isc__taskmgr_t *manager, int c) {
 
        if (task != NULL) {
                DEQUEUE(manager->queues[c].ready_tasks, task, ready_link);
+               manager->queues[c].tasks_waiting--;
                if (ISC_LINK_LINKED(task, ready_priority_link)) {
                        DEQUEUE(manager->queues[c].ready_priority_tasks, task,
                                ready_priority_link);
@@ -950,6 +961,7 @@ pop_readyq(isc__taskmgr_t *manager, int c) {
 static inline void
 push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c) {
        ENQUEUE(manager->queues[c].ready_tasks, task, ready_link);
+       manager->queues[c].tasks_waiting++;
        if ((task->flags & TASK_F_PRIVILEGED) != 0) {
                ENQUEUE(manager->queues[c].ready_priority_tasks, task,
                        ready_priority_link);
@@ -1095,6 +1107,16 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
                task = pop_readyq(manager, threadid);
                if (task != NULL) {
                        unsigned int dispatch_count = 0;
+                       unsigned int quantum = task->quantum;
+                       if (quantum == 0) {
+                               if (manager->queues[threadid].tasks_waiting
+                                   < CONGESTED_TASK_LIMIT)
+                               {
+                                       quantum = DEFAULT_QUANTUM;
+                               } else {
+                                       quantum = CONGESTED_QUANTUM;
+                               }
+                       }
                        bool done = false;
                        bool requeue = false;
                        bool finished = false;
@@ -1201,7 +1223,7 @@ dispatch(isc__taskmgr_t *manager, unsigned int threadid) {
                                        } else
                                                task->state = task_state_idle;
                                        done = true;
-                               } else if (dispatch_count >= task->quantum) {
+                               } else if (dispatch_count >= quantum) {
                                        /*
                                         * Our quantum has expired, but
                                         * there is more work to be done.
@@ -1343,7 +1365,7 @@ manager_free(isc__taskmgr_t *manager) {
 
 isc_result_t
 isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
-                   unsigned int default_quantum, isc_taskmgr_t **managerp)
+                  isc_taskmgr_t **managerp)
 {
        unsigned int i;
        isc__taskmgr_t *manager;
@@ -1369,10 +1391,6 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 
        manager->workers = workers;
 
-       if (default_quantum == 0) {
-               default_quantum = DEFAULT_DEFAULT_QUANTUM;
-       }
-       manager->default_quantum = default_quantum;
        INIT_LIST(manager->tasks);
        manager->queues = isc_mem_get(mctx, workers * sizeof(isc__taskqueue_t));
        RUNTIME_CHECK(manager->queues != NULL);
@@ -1400,6 +1418,7 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 
                manager->queues[i].manager = manager;
                manager->queues[i].threadid = i;
+               manager->queues[i].tasks_waiting = 0;
                RUNTIME_CHECK(isc_thread_create(run, &manager->queues[i],
                                                &manager->queues[i].thread)
                              == ISC_R_SUCCESS);
@@ -1708,11 +1727,6 @@ isc_taskmgr_renderxml(isc_taskmgr_t *mgr0, xmlTextWriterPtr writer) {
        TRY0(xmlTextWriterWriteFormatString(writer, "%d", mgr->workers));
        TRY0(xmlTextWriterEndElement(writer)); /* worker-threads */
 
-       TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "default-quantum"));
-       TRY0(xmlTextWriterWriteFormatString(writer, "%d",
-                                           mgr->default_quantum));
-       TRY0(xmlTextWriterEndElement(writer)); /* default-quantum */
-
        TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "tasks-running"));
        TRY0(xmlTextWriterWriteFormatString(writer, "%d",
                                            (int) mgr->tasks_running));
@@ -1809,10 +1823,6 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
        CHECKMEM(obj);
        json_object_object_add(tasks, "worker-threads", obj);
 
-       obj = json_object_new_int(mgr->default_quantum);
-       CHECKMEM(obj);
-       json_object_object_add(tasks, "default-quantum", obj);
-
        obj = json_object_new_int(mgr->tasks_running);
        CHECKMEM(obj);
        json_object_object_add(tasks, "tasks-running", obj);
@@ -1885,13 +1895,11 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
 
 isc_result_t
 isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
-                       unsigned int workers, unsigned int default_quantum,
-                       isc_taskmgr_t **managerp)
+                       unsigned int workers, isc_taskmgr_t **managerp)
 {
        isc_result_t result;
 
-       result = isc_taskmgr_create(mctx, workers, default_quantum,
-                                      managerp);
+       result = isc_taskmgr_create(mctx, workers, managerp);
 
        if (result == ISC_R_SUCCESS)
                isc_appctx_settaskmgr(actx, *managerp);

diff --git a/lib/isc/tests/isctest.c b/lib/isc/tests/isctest.c
index 66ca877e03eb6b7d6c8d00685fd7b347162e2f8a..79e27ccb1ccb7934e080d41cd9b533e0fa138b9b 100644 (file)
--- a/lib/isc/tests/isctest.c
+++ b/lib/isc/tests/isctest.c
@@ -86,7 +86,7 @@ create_managers(unsigned int workers) {
                workers = atoi(p);
        }
 
-       CHECK(isc_taskmgr_create(mctx, workers, 0, &taskmgr));
+       CHECK(isc_taskmgr_create(mctx, workers, &taskmgr));
        CHECK(isc_task_create(taskmgr, 0, &maintask));
        isc_taskmgr_setexcltask(taskmgr, maintask);
 

diff --git a/lib/isc/tests/task_test.c b/lib/isc/tests/task_test.c
index 18c1717b9a04a34992c1d386ce18810f3845d747..f23d6b85c9081c7d7679c9e12db9fa87b59ab7c2 100644 (file)
--- a/lib/isc/tests/task_test.c
+++ b/lib/isc/tests/task_test.c
@@ -712,7 +712,7 @@ manytasks(void **state) {
        result = isc_mem_create(0, 0, &mctx);
        assert_int_equal(result, ISC_R_SUCCESS);
 
-       result = isc_taskmgr_create(mctx, 4, 0, &taskmgr);
+       result = isc_taskmgr_create(mctx, 4, &taskmgr);
        assert_int_equal(result, ISC_R_SUCCESS);
 
        done = false;

diff --git a/lib/ns/tests/nstest.c b/lib/ns/tests/nstest.c
index 85c641bcd4828f8b7517799129d79db1544501d5..ac75a6991c41d834bb60ed6ae9d2f9403c1b9ef5 100644 (file)
--- a/lib/ns/tests/nstest.c
+++ b/lib/ns/tests/nstest.c
@@ -182,7 +182,7 @@ create_managers(void) {
        isc_event_t *event = NULL;
        ncpus = isc_os_ncpus();
 
-       CHECK(isc_taskmgr_create(mctx, ncpus, 0, &taskmgr));
+       CHECK(isc_taskmgr_create(mctx, ncpus, &taskmgr));
        CHECK(isc_task_create(taskmgr, 0, &maintask));
        isc_taskmgr_setexcltask(taskmgr, maintask);
        CHECK(isc_task_onshutdown(maintask, shutdown_managers, NULL));

diff --git a/lib/samples/nsprobe.c b/lib/samples/nsprobe.c
index 2fb49b1b616976f1a9c36d535372e6d90a51e263..3178fc12f4d287e366708824342d017358642bbb 100644 (file)
--- a/lib/samples/nsprobe.c
+++ b/lib/samples/nsprobe.c
@@ -226,7 +226,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
        if (result != ISC_R_SUCCESS)
                goto fail;
 
-       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
+       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
        if (result != ISC_R_SUCCESS)
                goto fail;
 

diff --git a/lib/samples/resolve.c b/lib/samples/resolve.c
index 7965b3e261fb1a57a5f7986bef4be8e2bf171c8d..5424f4f9a6bf9afa4cbf42f5d0d5ceb13d9df6b5 100644 (file)
--- a/lib/samples/resolve.c
+++ b/lib/samples/resolve.c
@@ -381,7 +381,7 @@ main(int argc, char *argv[]) {
        result = isc_app_ctxstart(actx);
        if (result != ISC_R_SUCCESS)
                goto cleanup;
-       result = isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr);
+       result = isc_taskmgr_createinctx(mctx, actx, 1, &taskmgr);
        if (result != ISC_R_SUCCESS)
                goto cleanup;
        result = isc_socketmgr_createinctx(mctx, actx, &socketmgr);

diff --git a/lib/samples/sample-async.c b/lib/samples/sample-async.c
index f383fa2a8eabbd46478f57f8123bf9d43d10bedb..bf6eb208f002ccdcd41e3c08a7321782d2a78a6e 100644 (file)
--- a/lib/samples/sample-async.c
+++ b/lib/samples/sample-async.c
@@ -108,7 +108,7 @@ ctxs_init(isc_mem_t **mctxp, isc_appctx_t **actxp,
        if (result != ISC_R_SUCCESS)
                goto fail;
 
-       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, 0, taskmgrp);
+       result = isc_taskmgr_createinctx(*mctxp, *actxp, 1, taskmgrp);
        if (result != ISC_R_SUCCESS)
                goto fail;