From: Christian Grothoff Date: Sun, 1 Jan 2012 21:12:17 +0000 (+0000) Subject: changing scheduler priorities to revert to DEFAULT instead of inheriting parent-task... X-Git-Tag: initial-import-from-subversion-38251~15492 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=64c442461b84953230d3dc4e78cb649db6c54abc;p=oweals%2Fgnunet.git changing scheduler priorities to revert to DEFAULT instead of inheriting parent-task priority unless something else is explicitly specified --- diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c index e8e1113f0..4c78e6fe7 100644 --- a/src/arm/gnunet-service-arm.c +++ b/src/arm/gnunet-service-arm.c @@ -805,8 +805,9 @@ delayed_restart_task (void *cls, (unsigned long long) lowestRestartDelay.rel_value); #endif child_restart_task = - GNUNET_SCHEDULER_add_delayed (lowestRestartDelay, - &delayed_restart_task, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &delayed_restart_task, NULL); } } @@ -922,7 +923,8 @@ maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) GNUNET_SCHEDULER_cancel (child_restart_task); child_restart_task = GNUNET_SCHEDULER_add_with_priority - (GNUNET_SCHEDULER_PRIORITY_IDLE, &delayed_restart_task, NULL); + (GNUNET_SCHEDULER_PRIORITY_IDLE, + &delayed_restart_task, NULL); } else { diff --git a/src/chat/gnunet-chat.c b/src/chat/gnunet-chat.c index af4eb53f3..4abc58c9f 100644 --- a/src/chat/gnunet-chat.c +++ b/src/chat/gnunet-chat.c @@ -572,9 +572,10 @@ handle_command (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) next: handle_cmd_task = - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply - (GNUNET_TIME_UNIT_MILLISECONDS, 100), - &handle_command, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_relative_multiply + (GNUNET_TIME_UNIT_MILLISECONDS, 100), + GNUNET_SCHEDULER_PRIORITY_UI, + &handle_command, NULL); return; out: diff --git a/src/datastore/gnunet-service-datastore.c b/src/datastore/gnunet-service-datastore.c index bf89c1bc2..1d7e8cd2b 100644 --- a/src/datastore/gnunet-service-datastore.c +++ b/src/datastore/gnunet-service-datastore.c @@ -326,7 +326,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size, if (key == NULL) { expired_kill_task = - GNUNET_SCHEDULER_add_delayed (MAX_EXPIRE_DELAY, &delete_expired, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (MAX_EXPIRE_DELAY, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &delete_expired, NULL); return GNUNET_SYSERR; } now = GNUNET_TIME_absolute_get (); @@ -334,7 +336,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size, { /* finished processing */ expired_kill_task = - GNUNET_SCHEDULER_add_delayed (MAX_EXPIRE_DELAY, &delete_expired, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (MAX_EXPIRE_DELAY, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &delete_expired, NULL); return GNUNET_SYSERR; } #if DEBUG_DATASTORE @@ -348,7 +352,9 @@ expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size, GNUNET_YES); GNUNET_CONTAINER_bloomfilter_remove (filter, key); expired_kill_task = - GNUNET_SCHEDULER_add_delayed (MIN_EXPIRE_DELAY, &delete_expired, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (MIN_EXPIRE_DELAY, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &delete_expired, NULL); return GNUNET_NO; } diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c index 293638732..2b1e51031 100644 --- a/src/fs/fs_api.c +++ b/src/fs/fs_api.c @@ -1356,7 +1356,8 @@ deserialize_publish_file (void *cls, const char *filename) GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task); pc->upload_task = GNUNET_SCHEDULER_add_with_priority - (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc); + (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, + &GNUNET_FS_publish_main_, pc); } if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)) { diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c index 164e264c6..4711c09e6 100644 --- a/src/fs/gnunet-service-fs_cp.c +++ b/src/fs/gnunet-service-fs_cp.c @@ -1816,7 +1816,9 @@ cron_flush_trust (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) return; if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) return; - GNUNET_SCHEDULER_add_delayed (TRUST_FLUSH_FREQ, &cron_flush_trust, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (TRUST_FLUSH_FREQ, + GNUNET_SCHEDULER_PRIORITY_HIGH, + &cron_flush_trust, NULL); } diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h index 9b8c57ff3..e16ccc511 100644 --- a/src/include/gnunet_scheduler_lib.h +++ b/src/include/gnunet_scheduler_lib.h @@ -111,7 +111,9 @@ enum GNUNET_SCHEDULER_Priority /** * Run with the default priority (normal - * P2P operations). Higher than BACKGROUND. + * P2P operations). Any task that is scheduled + * without an explicit priority being specified + * will run with this priority. */ GNUNET_SCHEDULER_PRIORITY_DEFAULT = 3, @@ -262,7 +264,7 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p); * * @return reason(s) why the current task is run */ enum GNUNET_SCHEDULER_Reason -GNUNET_SCHEDULER_get_reason (); +GNUNET_SCHEDULER_get_reason (void); /** @@ -290,10 +292,25 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, enum GNUNET_SCHEDULER_Reason reason); +/** + * Continue the current execution with the given function. This is + * similar to the other "add" functions except that there is no delay + * and the reason code can be specified. + * + * @param task main function of the task + * @param task_cls closure for 'main' + * @param reason reason for task invocation + * @param priority priority to use for the task + */ +void +GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, void *task_cls, + enum GNUNET_SCHEDULER_Reason reason, + enum GNUNET_SCHEDULER_Priority priority); + + /** * Schedule a new task to be run after the specified prerequisite task - * has completed. It will be run with the priority of the calling - * task. + * has completed. It will be run with DEFAULT priority. * * * @param prerequisite_task run this task after the task with the given * task identifier completes (and any of our other @@ -327,7 +344,7 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, /** * Schedule a new task to be run as soon as possible. The task - * will be run with the priority of the calling task. + * will be run with the DEFAULT priority. * * * @param task main function of the task * @param task_cls closure of task @@ -361,7 +378,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, /** * Schedule a new task to be run with a specified delay. The task * will be scheduled for execution once the delay has expired. It - * will be run with the priority of the calling task. + * will be run with the DEFAULT priority. * * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -375,13 +392,30 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_Task task, void *task_cls); +/** + * Schedule a new task to be run with a specified delay. The task + * will be scheduled for execution once the delay has expired. + * + * @param delay when should this operation time out? Use + * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" + * @param priority priority to use for the task + * @param task main function of the task + * @param task_cls closure of task + * @return unique task identifier for the job + * only valid until "task" is started! + */ +GNUNET_SCHEDULER_TaskIdentifier +GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority priority, + GNUNET_SCHEDULER_Task task, void *task_cls); + + /** * Schedule a new task to be run with a specified delay or when the * specified file descriptor is ready for reading. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -402,8 +436,7 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, * specified file descriptor is ready for writing. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -424,8 +457,7 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, * specified file descriptor is ready for reading. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -446,8 +478,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, * specified file descriptor is ready for writing. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c index 30493851e..6617fdfea 100644 --- a/src/nse/gnunet-service-nse.c +++ b/src/nse/gnunet-service-nse.c @@ -911,7 +911,9 @@ find_proof (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) my_proof = counter; } proof_task = - GNUNET_SCHEDULER_add_delayed (proof_find_delay, &find_proof, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &find_proof, NULL); } diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c index 799fdc6d8..d6e52d4b4 100644 --- a/src/peerinfo/gnunet-service-peerinfo.c +++ b/src/peerinfo/gnunet-service-peerinfo.c @@ -293,8 +293,9 @@ cron_scan_directory_data_hosts (void *cls, count = 0; if (GNUNET_SYSERR == GNUNET_DISK_directory_create (networkIdDirectory)) { - GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ, - &cron_scan_directory_data_hosts, NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &cron_scan_directory_data_hosts, NULL); return; } GNUNET_DISK_directory_scan (networkIdDirectory, @@ -302,8 +303,10 @@ cron_scan_directory_data_hosts (void *cls, if ((0 == count) && (0 == (++retries & 31))) GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, _("Still no peers found in `%s'!\n"), networkIdDirectory); - GNUNET_SCHEDULER_add_delayed (DATA_HOST_FREQ, &cron_scan_directory_data_hosts, - NULL); + GNUNET_SCHEDULER_add_delayed_with_priority (DATA_HOST_FREQ, + GNUNET_SCHEDULER_PRIORITY_IDLE, + &cron_scan_directory_data_hosts, + NULL); } diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c index 2ab682494..9faa213ae 100644 --- a/src/util/crypto_hash.c +++ b/src/util/crypto_hash.c @@ -105,6 +105,11 @@ struct GNUNET_CRYPTO_FileHashContext */ GNUNET_SCHEDULER_TaskIdentifier task; + /** + * Priority we use. + */ + enum GNUNET_SCHEDULER_Priority priority; + /** * Blocksize. */ @@ -162,7 +167,8 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) file_hash_finish (fhc, res); return; } - fhc->task = GNUNET_SCHEDULER_add_now (&file_hash_task, fhc); + fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority, + &file_hash_task, fhc); } @@ -213,6 +219,7 @@ GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority, GNUNET_free (fhc); return NULL; } + fhc->priority = priority; fhc->task = GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc); return fhc; diff --git a/src/util/scheduler.c b/src/util/scheduler.c index 1acc9a6d6..5f91ffbbc 100644 --- a/src/util/scheduler.c +++ b/src/util/scheduler.c @@ -1054,10 +1054,12 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task) * @param task main function of the task * @param task_cls closure for 'main' * @param reason reason for task invocation + * @param priority priority to use for the task */ void -GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, - enum GNUNET_SCHEDULER_Reason reason) +GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, void *task_cls, + enum GNUNET_SCHEDULER_Reason reason, + enum GNUNET_SCHEDULER_Priority priority) { struct Task *t; @@ -1083,7 +1085,7 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, t->start_time = GNUNET_TIME_absolute_get (); #endif t->reason = reason; - t->priority = current_priority; + t->priority = priority; t->lifeness = current_lifeness; #if DEBUG_TASKS LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id, @@ -1093,11 +1095,28 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, } +/** + * Continue the current execution with the given function. This is + * similar to the other "add" functions except that there is no delay + * and the reason code can be specified. + * + * @param task main function of the task + * @param task_cls closure for 'main' + * @param reason reason for task invocation + */ +void +GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls, + enum GNUNET_SCHEDULER_Reason reason) +{ + GNUNET_SCHEDULER_add_continuation_with_priority (task, task_cls, + reason, + GNUNET_SCHEDULER_PRIORITY_DEFAULT); +} + /** * Schedule a new task to be run after the specified prerequisite task - * has completed. It will be run with the priority of the calling - * task. + * has completed. It will be run with the DEFAULT priority. * * @param prerequisite_task run this task after the task with the given * task identifier completes (and any of our other @@ -1114,7 +1133,7 @@ GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, GNUNET_SCHEDULER_Task task, void *task_cls) { - return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, + return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, prerequisite_task, GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, task_cls); } @@ -1142,22 +1161,21 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio, /** * Schedule a new task to be run with a specified delay. The task - * will be scheduled for execution once the delay has expired. It - * will be run with the priority of the calling task. + * will be scheduled for execution once the delay has expired. * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" + * @param priority priority to use for the task * @param task main function of the task * @param task_cls closure of task * @return unique task identifier for the job * only valid until "task" is started! */ GNUNET_SCHEDULER_TaskIdentifier -GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, - GNUNET_SCHEDULER_Task task, void *task_cls) +GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority priority, + GNUNET_SCHEDULER_Task task, void *task_cls) { -#if 1 - /* new, optimized version */ struct Task *t; struct Task *pos; struct Task *prev; @@ -1183,7 +1201,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, t->start_time = GNUNET_TIME_absolute_get (); #endif t->timeout = GNUNET_TIME_relative_to_absolute (delay); - t->priority = current_priority; + t->priority = priority; t->lifeness = current_lifeness; /* try tail first (optimization in case we are * appending to a long list of tasks with timeouts) */ @@ -1227,20 +1245,34 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, t->backtrace_strings[i]); #endif return t->id; - -#else - /* unoptimized version */ - return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - GNUNET_SCHEDULER_NO_TASK, delay, NULL, - NULL, task, task_cls); -#endif } +/** + * Schedule a new task to be run with a specified delay. The task + * will be scheduled for execution once the delay has expired. It + * will be run with the DEFAULT priority. + * + * @param delay when should this operation time out? Use + * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" + * @param task main function of the task + * @param task_cls closure of task + * @return unique task identifier for the job + * only valid until "task" is started! + */ +GNUNET_SCHEDULER_TaskIdentifier +GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, + GNUNET_SCHEDULER_Task task, void *task_cls) +{ + return GNUNET_SCHEDULER_add_delayed_with_priority (delay, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + task, task_cls); +} + /** * Schedule a new task to be run as soon as possible. The task - * will be run with the priority of the calling task. + * will be run with the DEFAULT priority. * * @param task main function of the task * @param task_cls closure of task @@ -1250,10 +1282,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskIdentifier GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls) { - return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, - GNUNET_SCHEDULER_NO_TASK, - GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, - task_cls); + return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO, task, task_cls); } @@ -1279,7 +1308,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, GNUNET_SCHEDULER_TaskIdentifier ret; ret = - GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP, + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SCHEDULER_NO_TASK, GNUNET_TIME_UNIT_ZERO, NULL, NULL, task, task_cls); @@ -1289,8 +1318,6 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, } - - /** * Schedule a new task to be run with a specified delay or when any of * the specified file descriptor sets is ready. The delay can be used @@ -1310,6 +1337,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, * * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever", * which means that the task will only be run after we receive SIGTERM + * @param priority priority to use * @param rfd file descriptor we want to read (can be -1) * @param wfd file descriptors we want to write (can be -1) * @param task main function of the task @@ -1319,7 +1347,9 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness, */ #ifndef MINGW static GNUNET_SCHEDULER_TaskIdentifier -add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, +add_without_sets (struct GNUNET_TIME_Relative delay, + enum GNUNET_SCHEDULER_Priority priority, + int rfd, int wfd, GNUNET_SCHEDULER_Task task, void *task_cls) { struct Task *t; @@ -1381,7 +1411,7 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, #endif t->prereq_id = GNUNET_SCHEDULER_NO_TASK; t->timeout = GNUNET_TIME_relative_to_absolute (delay); - t->priority = check_priority (current_priority); + t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority); t->lifeness = current_lifeness; t->next = pending; pending = t; @@ -1408,8 +1438,7 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd, * specified file descriptor is ready for reading. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -1432,13 +1461,15 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay, rs = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_set (rs, rfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, - task, task_cls); + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, + GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, + task, task_cls); GNUNET_NETWORK_fdset_destroy (rs); return ret; #else - return add_without_sets (delay, GNUNET_NETWORK_get_fd (rfd), -1, task, + return add_without_sets (delay, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + GNUNET_NETWORK_get_fd (rfd), -1, task, task_cls); #endif } @@ -1473,14 +1504,16 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, ws = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_set (ws, wfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), - GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, + GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, task, task_cls); GNUNET_NETWORK_fdset_destroy (ws); return ret; #else GNUNET_assert (GNUNET_NETWORK_get_fd (wfd) >= 0); - return add_without_sets (delay, -1, GNUNET_NETWORK_get_fd (wfd), task, + return add_without_sets (delay, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + -1, GNUNET_NETWORK_get_fd (wfd), task, task_cls); #endif } @@ -1491,8 +1524,7 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay, * specified file descriptor is ready for reading. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -1515,7 +1547,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, rs = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_handle_set (rs, rfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL, task, task_cls); GNUNET_NETWORK_fdset_destroy (rs); @@ -1524,7 +1556,9 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, int fd; GNUNET_DISK_internal_file_handle_ (rfd, &fd, sizeof (int)); - return add_without_sets (delay, fd, -1, task, task_cls); + return add_without_sets (delay, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + fd, -1, task, task_cls); #endif } @@ -1535,8 +1569,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay, * specified file descriptor is ready for writing. The delay can be * used as a timeout on the socket being ready. The task will be * scheduled for execution once either the delay has expired or the - * socket operation is ready. It will be run with the priority of - * the calling task. + * socket operation is ready. It will be run with the DEFAULT priority. * * @param delay when should this operation time out? Use * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" @@ -1559,7 +1592,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, ws = GNUNET_NETWORK_fdset_create (); GNUNET_NETWORK_fdset_handle_set (ws, wfd); ret = - GNUNET_SCHEDULER_add_select (check_priority (current_priority), + GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws, task, task_cls); GNUNET_NETWORK_fdset_destroy (ws); @@ -1569,7 +1602,9 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay, GNUNET_DISK_internal_file_handle_ (wfd, &fd, sizeof (int)); GNUNET_assert (fd >= 0); - return add_without_sets (delay, -1, fd, task, task_cls); + return add_without_sets (delay, + GNUNET_SCHEDULER_PRIORITY_DEFAULT, + -1, fd, task, task_cls); #endif }