contrib/bind9/lib/isc/taskpool.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2007, 2011, 2012  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2001  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id$ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <isc/mem.h>
  25 #include <isc/random.h>
  26 #include <isc/taskpool.h>
  27 #include <isc/util.h>
  28
  29 /***
  30  *** Types.
  31  ***/
  32
  33 struct isc_taskpool {
  34         isc_mem_t *                     mctx;
  35         isc_taskmgr_t *                 tmgr;
  36         unsigned int                    ntasks;
  37         unsigned int                    quantum;
  38         isc_task_t **                   tasks;
  39 };
  40
  41 /***
  42  *** Functions.
  43  ***/
  44
  45 static isc_result_t
  46 alloc_pool(isc_taskmgr_t *tmgr, isc_mem_t *mctx, unsigned int ntasks,
  47            unsigned int quantum, isc_taskpool_t **poolp)
  48 {
  49         isc_taskpool_t *pool;
  50         unsigned int i;
  51
  52         pool = isc_mem_get(mctx, sizeof(*pool));
  53         if (pool == NULL)
  54                 return (ISC_R_NOMEMORY);
  55         pool->mctx = mctx;
  56         pool->ntasks = ntasks;
  57         pool->quantum = quantum;
  58         pool->tmgr = tmgr;
  59         pool->tasks = isc_mem_get(mctx, ntasks * sizeof(isc_task_t *));
  60         if (pool->tasks == NULL) {
  61                 isc_mem_put(mctx, pool, sizeof(*pool));
  62                 return (ISC_R_NOMEMORY);
  63         }
  64         for (i = 0; i < ntasks; i++)
  65                 pool->tasks[i] = NULL;
  66
  67         *poolp = pool;
  68         return (ISC_R_SUCCESS);
  69 }
  70
  71 isc_result_t
  72 isc_taskpool_create(isc_taskmgr_t *tmgr, isc_mem_t *mctx,
  73                     unsigned int ntasks, unsigned int quantum,
  74                     isc_taskpool_t **poolp)
  75 {
  76         unsigned int i;
  77         isc_taskpool_t *pool = NULL;
  78         isc_result_t result;
  79
  80         INSIST(ntasks > 0);
  81
  82         /* Allocate the pool structure */
  83         result = alloc_pool(tmgr, mctx, ntasks, quantum, &pool);
  84         if (result != ISC_R_SUCCESS)
  85                 return (result);
  86
  87         /* Create the tasks */
  88         for (i = 0; i < ntasks; i++) {
  89                 result = isc_task_create(tmgr, quantum, &pool->tasks[i]);
  90                 if (result != ISC_R_SUCCESS) {
  91                         isc_taskpool_destroy(&pool);
  92                         return (result);
  93                 }
  94                 isc_task_setname(pool->tasks[i], "taskpool", NULL);
  95         }
  96
  97         *poolp = pool;
  98         return (ISC_R_SUCCESS);
  99 }
 100
 101 void
 102 isc_taskpool_gettask(isc_taskpool_t *pool, isc_task_t **targetp) {
 103         isc_uint32_t i;
 104         isc_random_get(&i);
 105         isc_task_attach(pool->tasks[i % pool->ntasks], targetp);
 106 }
 107
 108 int
 109 isc_taskpool_size(isc_taskpool_t *pool) {
 110         REQUIRE(pool != NULL);
 111         return (pool->ntasks);
 112 }
 113
 114 isc_result_t
 115 isc_taskpool_expand(isc_taskpool_t **sourcep, unsigned int size,
 116                     isc_taskpool_t **targetp)
 117 {
 118         isc_result_t result;
 119         isc_taskpool_t *pool;
 120
 121         REQUIRE(sourcep != NULL && *sourcep != NULL);
 122         REQUIRE(targetp != NULL && *targetp == NULL);
 123
 124         pool = *sourcep;
 125         if (size > pool->ntasks) {
 126                 isc_taskpool_t *newpool = NULL;
 127                 unsigned int i;
 128
 129                 /* Allocate a new pool structure */
 130                 result = alloc_pool(pool->tmgr, pool->mctx, size,
 131                                     pool->quantum, &newpool);
 132                 if (result != ISC_R_SUCCESS)
 133                         return (result);
 134
 135                 /* Copy over the tasks from the old pool */
 136                 for (i = 0; i < pool->ntasks; i++) {
 137                         newpool->tasks[i] = pool->tasks[i];
 138                         pool->tasks[i] = NULL;
 139                 }
 140
 141                 /* Create new tasks */
 142                 for (i = pool->ntasks; i < size; i++) {
 143                         result = isc_task_create(pool->tmgr, pool->quantum,
 144                                                  &newpool->tasks[i]);
 145                         if (result != ISC_R_SUCCESS) {
 146                                 isc_taskpool_destroy(&newpool);
 147                                 return (result);
 148                         }
 149                         isc_task_setname(newpool->tasks[i], "taskpool", NULL);
 150                 }
 151
 152                 isc_taskpool_destroy(&pool);
 153                 pool = newpool;
 154         }
 155
 156         *sourcep = NULL;
 157         *targetp = pool;
 158         return (ISC_R_SUCCESS);
 159 }
 160
 161 void
 162 isc_taskpool_destroy(isc_taskpool_t **poolp) {
 163         unsigned int i;
 164         isc_taskpool_t *pool = *poolp;
 165         for (i = 0; i < pool->ntasks; i++) {
 166                 if (pool->tasks[i] != NULL) {
 167                         isc_task_detach(&pool->tasks[i]);
 168                 }
 169         }
 170         isc_mem_put(pool->mctx, pool->tasks,
 171                     pool->ntasks * sizeof(isc_task_t *));
 172         isc_mem_put(pool->mctx, pool, sizeof(*pool));
 173         *poolp = NULL;
 174 }
 175
 176