X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftestbed%2Ftestbed_api_operations.c;h=a406c0e0b834b01344cec29ac3034173eb85d9b1;hb=d17a17ea785f91c18b5694eab3372c4e4564d95e;hp=e1dc33f49da8191606bb36e9056d6894cbacacb7;hpb=d48b67def5de194f0eeb169eead9a271822b01b2;p=oweals%2Fgnunet.git diff --git a/src/testbed/testbed_api_operations.c b/src/testbed/testbed_api_operations.c index e1dc33f49..a406c0e0b 100644 --- a/src/testbed/testbed_api_operations.c +++ b/src/testbed/testbed_api_operations.c @@ -1,21 +1,21 @@ /* This file is part of GNUnet - (C) 2008--2013 Christian Grothoff (and other contributing authors) + Copyright (C) 2008--2013 GNUnet e.V. - GNUnet is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3, or (at your - option) any later version. + GNUnet is free software: you can redistribute it and/or modify it + under the terms of the GNU Affero General Public License as published + by the Free Software Foundation, either version 3 of the License, + or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + Affero General Public License for more details. - You should have received a copy of the GNU General Public License - along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + + SPDX-License-Identifier: AGPL3.0-or-later */ /** @@ -236,6 +236,11 @@ struct OperationQueue * #OPERATION_QUEUE_TYPE_ADAPTIVE */ unsigned int overload; + + /** + * Is this queue marked for expiry? + */ + unsigned int expired; }; @@ -369,23 +374,32 @@ struct GNUNET_TESTBED_Operation * Is this a failed operation? */ int failed; - }; /** * DLL head for the ready queue */ -struct ReadyQueueEntry *rq_head; +static struct ReadyQueueEntry *rq_head; /** * DLL tail for the ready queue */ -struct ReadyQueueEntry *rq_tail; +static struct ReadyQueueEntry *rq_tail; + +/** + * Array of operation queues which are to be destroyed + */ +static struct OperationQueue **expired_opqs; + +/** + * Number of expired operation queues in the above array + */ +static unsigned int n_expired_opqs; /** * The id of the task to process the ready queue */ -GNUNET_SCHEDULER_TaskIdentifier process_rq_task_id; +struct GNUNET_SCHEDULER_Task *process_rq_task_id; /** @@ -431,15 +445,19 @@ remove_queue_entry (struct GNUNET_TESTBED_Operation *op, unsigned int index) case OP_STATE_INIT: GNUNET_assert (0); break; + case OP_STATE_WAITING: GNUNET_CONTAINER_DLL_remove (opq->wq_head, opq->wq_tail, entry); break; + case OP_STATE_READY: GNUNET_CONTAINER_DLL_remove (opq->rq_head, opq->rq_tail, entry); break; + case OP_STATE_ACTIVE: GNUNET_CONTAINER_DLL_remove (opq->aq_head, opq->aq_tail, entry); break; + case OP_STATE_INACTIVE: GNUNET_CONTAINER_DLL_remove (opq->nq_head, opq->nq_tail, entry); break; @@ -488,15 +506,19 @@ change_state (struct GNUNET_TESTBED_Operation *op, enum OperationState state) case OP_STATE_INIT: GNUNET_assert (0); break; + case OP_STATE_WAITING: GNUNET_CONTAINER_DLL_insert_tail (opq->wq_head, opq->wq_tail, entry); break; + case OP_STATE_READY: GNUNET_CONTAINER_DLL_insert_tail (opq->rq_head, opq->rq_tail, entry); break; + case OP_STATE_ACTIVE: GNUNET_CONTAINER_DLL_insert_tail (opq->aq_head, opq->aq_tail, entry); break; + case OP_STATE_INACTIVE: GNUNET_CONTAINER_DLL_insert_tail (opq->nq_head, opq->nq_tail, entry); break; @@ -519,10 +541,10 @@ rq_remove (struct GNUNET_TESTBED_Operation *op) GNUNET_CONTAINER_DLL_remove (rq_head, rq_tail, op->rq_entry); GNUNET_free (op->rq_entry); op->rq_entry = NULL; - if ( (NULL == rq_head) && (GNUNET_SCHEDULER_NO_TASK != process_rq_task_id) ) + if ((NULL == rq_head) && (NULL != process_rq_task_id)) { GNUNET_SCHEDULER_cancel (process_rq_task_id); - process_rq_task_id = GNUNET_SCHEDULER_NO_TASK; + process_rq_task_id = NULL; } } @@ -534,16 +556,15 @@ rq_remove (struct GNUNET_TESTBED_Operation *op) * the ready queue. * * @param cls NULL - * @param tc scheduler task context. Not used. */ static void -process_rq_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +process_rq_task (void *cls) { struct GNUNET_TESTBED_Operation *op; struct OperationQueue *queue; unsigned int cnt; - process_rq_task_id = GNUNET_SCHEDULER_NO_TASK; + process_rq_task_id = NULL; GNUNET_assert (NULL != rq_head); GNUNET_assert (NULL != (op = rq_head->op)); rq_remove (op); @@ -577,7 +598,7 @@ rq_add (struct GNUNET_TESTBED_Operation *op) rq_entry->op = op; GNUNET_CONTAINER_DLL_insert_tail (rq_head, rq_tail, rq_entry); op->rq_entry = rq_entry; - if (GNUNET_SCHEDULER_NO_TASK == process_rq_task_id) + if (NULL == process_rq_task_id) process_rq_task_id = GNUNET_SCHEDULER_add_now (&process_rq_task, NULL); } @@ -592,10 +613,10 @@ rq_add (struct GNUNET_TESTBED_Operation *op) static int is_queue_empty (struct OperationQueue *opq) { - if ( (NULL != opq->wq_head) - || (NULL != opq->rq_head) - || (NULL != opq->aq_head) - || (NULL != opq->nq_head) ) + if ((NULL != opq->wq_head) + || (NULL != opq->rq_head) + || (NULL != opq->aq_head) + || (NULL != opq->nq_head)) return GNUNET_NO; return GNUNET_YES; } @@ -671,10 +692,10 @@ decide_capacity (struct OperationQueue *opq, for (n_ops = 0; n_ops < n_evict_entries;) { op = evict_entries[n_ops]->op; - GNUNET_array_append (ops, n_ops, op); /* increments n-ops */ + GNUNET_array_append (ops, n_ops, op); /* increments n-ops */ } - ret: +ret: GNUNET_free_non_null (evict_entries); if (NULL != ops_) *ops_ = ops; @@ -725,7 +746,6 @@ merge_ops (struct GNUNET_TESTBED_Operation ***old, } - /** * Checks for the readiness of an operation and schedules a operation start task * @@ -847,14 +867,15 @@ adaptive_queue_set_max_active (struct OperationQueue *queue, unsigned int n) unsigned int cnt; cleanup_tslots (queue); - n = GNUNET_MIN (n ,fctx->max_active_bound); - fctx->tslots_freeptr = GNUNET_malloc (n * sizeof (struct TimeSlot)); + n = GNUNET_MIN (n, fctx->max_active_bound); + fctx->tslots_freeptr = GNUNET_malloc (n * sizeof(struct TimeSlot)); fctx->nfailed = 0; for (cnt = 0; cnt < n; cnt++) { tslot = &fctx->tslots_freeptr[cnt]; tslot->queue = queue; - GNUNET_CONTAINER_DLL_insert_tail (fctx->alloc_head, fctx->alloc_tail, tslot); + GNUNET_CONTAINER_DLL_insert_tail (fctx->alloc_head, fctx->alloc_tail, + tslot); } GNUNET_TESTBED_operation_queue_reset_max_active_ (queue, n); } @@ -904,7 +925,7 @@ adapt_parallelism (struct OperationQueue *queue) (unsigned int) avg.rel_value_us, &sd)) { - adaptive_queue_set_max_active (queue, queue->max_active); /* no change */ + adaptive_queue_set_max_active (queue, queue->max_active); /* no change */ return; } @@ -925,7 +946,7 @@ adapt_parallelism (struct OperationQueue *queue) if (sd < 0) sd = 0; GNUNET_assert (0 <= sd); - //GNUNET_TESTBED_SD_add_data_ (fctx->sd, (unsigned int) avg.rel_value_us); + // GNUNET_TESTBED_SD_add_data_ (fctx->sd, (unsigned int) avg.rel_value_us); if (0 == sd) { adaptive_queue_set_max_active (queue, queue->max_active * 2); @@ -981,7 +1002,7 @@ update_tslots (struct GNUNET_TESTBED_Operation *op) fctx->nfailed++; for (i = 0; i < op->nqueues; i++) if (queue == op->queues[i]) - break; + break; GNUNET_assert (i != op->nqueues); op->queues[i]->overload += op->nres[i]; } @@ -1052,17 +1073,15 @@ GNUNET_TESTBED_operation_queue_create_ (enum OperationQueueType type, /** - * Destroy an operation queue. The queue MUST be empty - * at this time. + * Cleanup the given operation queue. * - * @param queue queue to destroy + * @param queue the operation queue to destroy */ -void -GNUNET_TESTBED_operation_queue_destroy_ (struct OperationQueue *queue) +static void +queue_destroy (struct OperationQueue *queue) { struct FeedbackCtx *fctx; - GNUNET_break (GNUNET_YES == is_queue_empty (queue)); if (OPERATION_QUEUE_TYPE_ADAPTIVE == queue->type) { cleanup_tslots (queue); @@ -1074,6 +1093,27 @@ GNUNET_TESTBED_operation_queue_destroy_ (struct OperationQueue *queue) } +/** + * Destroys an operation queue. If the queue is still in use by operations it + * is marked as expired and its resources are released in the destructor + * GNUNET_TESTBED_operations_fini(). + * + * @param queue queue to destroy + */ +void +GNUNET_TESTBED_operation_queue_destroy_ (struct OperationQueue *queue) +{ + if (GNUNET_YES != is_queue_empty (queue)) + { + GNUNET_assert (0 == queue->expired); /* Are you calling twice on same queue? */ + queue->expired = 1; + GNUNET_array_append (expired_opqs, n_expired_opqs, queue); + return; + } + queue_destroy (queue); +} + + /** * Destroys the operation queue if it is empty. If not empty return GNUNET_NO. * @@ -1130,8 +1170,8 @@ GNUNET_TESTBED_operation_queue_reset_max_active_ (struct OperationQueue *queue, queue->max_active = max_active; queue->overload = 0; - while ( (queue->active > queue->max_active) - && (NULL != (entry = queue->rq_head)) ) + while ((queue->active > queue->max_active) + && (NULL != (entry = queue->rq_head))) defer (entry->op); recheck_waiting (queue); } @@ -1220,11 +1260,11 @@ GNUNET_TESTBED_operation_inactivate_ (struct GNUNET_TESTBED_Operation *op) GNUNET_assert (OP_STATE_ACTIVE == op->state); change_state (op, OP_STATE_INACTIVE); nqueues = op->nqueues; - ms = sizeof (struct OperationQueue *) * nqueues; + ms = sizeof(struct OperationQueue *) * nqueues; queues = GNUNET_malloc (ms); /* Cloning is needed as the operation be released by waiting operations and hence its nqueues memory ptr will be freed */ - GNUNET_assert (NULL != (queues = memcpy (queues, op->queues, ms))); + GNUNET_memcpy (queues, op->queues, ms); for (i = 0; i < nqueues; i++) recheck_waiting (queues[i]); GNUNET_free (queues); @@ -1241,7 +1281,6 @@ GNUNET_TESTBED_operation_inactivate_ (struct GNUNET_TESTBED_Operation *op) void GNUNET_TESTBED_operation_activate_ (struct GNUNET_TESTBED_Operation *op) { - GNUNET_assert (OP_STATE_INACTIVE == op->state); change_state (op, OP_STATE_ACTIVE); } @@ -1284,8 +1323,10 @@ GNUNET_TESTBED_operation_release_ (struct GNUNET_TESTBED_Operation *op) case OP_STATE_INACTIVE: GNUNET_assert (0); break; + case OP_STATE_WAITING: break; + case OP_STATE_ACTIVE: case OP_STATE_READY: GNUNET_assert (0 != opq->active); @@ -1317,4 +1358,30 @@ GNUNET_TESTBED_operation_mark_failed (struct GNUNET_TESTBED_Operation *op) } +/** + * Cleanup expired operation queues. While doing so, also check for any + * operations which are not completed and warn about them. + */ +void __attribute__ ((destructor)) +GNUNET_TESTBED_operations_fini () +{ + struct OperationQueue *queue; + unsigned int i; + int warn = 0; + + for (i = 0; i < n_expired_opqs; i++) + { + queue = expired_opqs[i]; + if (GNUNET_NO == is_queue_empty (queue)) + warn = 1; + queue_destroy (queue); + } + GNUNET_free_non_null (expired_opqs); + n_expired_opqs = 0; + if (warn) + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Be disciplined. Some operations were not marked as done.\n"); +} + + /* end of testbed_api_operations.c */