contrib/apr-util/test/testreslist.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19
  20 #include "apr_general.h"
  21 #include "apu.h"
  22 #include "apr_reslist.h"
  23 #include "apr_thread_pool.h"
  24
  25 #if APR_HAVE_TIME_H
  26 #include <time.h>
  27 #endif /* APR_HAVE_TIME_H */
  28
  29 #include "abts.h"
  30 #include "testutil.h"
  31
  32 #if APR_HAS_THREADS
  33
  34 #define RESLIST_MIN   3
  35 #define RESLIST_SMAX 10
  36 #define RESLIST_HMAX 20
  37 #define RESLIST_TTL  APR_TIME_C(35000) /* 35 ms */
  38 #define CONSUMER_THREADS 25
  39 #define CONSUMER_ITERATIONS 250
  40 #define CONSTRUCT_SLEEP_TIME  APR_TIME_C(25000) /* 25 ms */
  41 #define DESTRUCT_SLEEP_TIME   APR_TIME_C(10000) /* 10 ms */
  42 #define WORK_DELAY_SLEEP_TIME APR_TIME_C(15000) /* 15 ms */
  43
  44 typedef struct {
  45     apr_interval_time_t sleep_upon_construct;
  46     apr_interval_time_t sleep_upon_destruct;
  47     int c_count;
  48     int d_count;
  49 } my_parameters_t;
  50
  51 typedef struct {
  52     int id;
  53 } my_resource_t;
  54
  55 /* Linear congruential generator */
  56 static apr_uint32_t lgc(apr_uint32_t a)
  57 {
  58     apr_uint64_t z = a;
  59     z *= 279470273;
  60     z %= APR_UINT64_C(4294967291);
  61     return (apr_uint32_t)z;
  62 }
  63
  64 static apr_status_t my_constructor(void **resource, void *params,
  65                                    apr_pool_t *pool)
  66 {
  67     my_resource_t *res;
  68     my_parameters_t *my_params = params;
  69
  70     /* Create some resource */
  71     res = apr_palloc(pool, sizeof(*res));
  72     res->id = my_params->c_count++;
  73
  74     /* Sleep for awhile, to simulate construction overhead. */
  75     apr_sleep(my_params->sleep_upon_construct);
  76
  77     /* Set the resource so it can be managed by the reslist */
  78     *resource = res;
  79     return APR_SUCCESS;
  80 }
  81
  82 static apr_status_t my_destructor(void *resource, void *params,
  83                                   apr_pool_t *pool)
  84 {
  85     my_resource_t *res = resource;
  86     my_parameters_t *my_params = params;
  87     res->id = my_params->d_count++;
  88
  89     apr_sleep(my_params->sleep_upon_destruct);
  90
  91     return APR_SUCCESS;
  92 }
  93
  94 typedef struct {
  95     int tid;
  96     abts_case *tc;
  97     apr_reslist_t *reslist;
  98     apr_interval_time_t work_delay_sleep;
  99 } my_thread_info_t;
 100
 101 /* MAX_UINT * .95 = 2**32 * .95 = 4080218931u */
 102 #define PERCENT95th 4080218931u
 103
 104 static void * APR_THREAD_FUNC resource_consuming_thread(apr_thread_t *thd,
 105                                                         void *data)
 106 {
 107     int i;
 108     apr_uint32_t chance;
 109     void *vp;
 110     apr_status_t rv;
 111     my_resource_t *res;
 112     my_thread_info_t *thread_info = data;
 113     apr_reslist_t *rl = thread_info->reslist;
 114
 115 #if APR_HAS_RANDOM
 116     apr_generate_random_bytes((void*)&chance, sizeof(chance));
 117 #else
 118     chance = (apr_uint32_t)(apr_time_now() % APR_TIME_C(4294967291));
 119 #endif
 120
 121     for (i = 0; i < CONSUMER_ITERATIONS; i++) {
 122         rv = apr_reslist_acquire(rl, &vp);
 123         ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv);
 124         res = vp;
 125         apr_sleep(thread_info->work_delay_sleep);
 126
 127         /* simulate a 5% chance of the resource being bad */
 128         chance = lgc(chance);
 129         if ( chance < PERCENT95th ) {
 130             rv = apr_reslist_release(rl, res);
 131             ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv);
 132         } else {
 133             rv = apr_reslist_invalidate(rl, res);
 134             ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv);
 135         }
 136     }
 137
 138     return APR_SUCCESS;
 139 }
 140
 141 static void test_timeout(abts_case *tc, apr_reslist_t *rl)
 142 {
 143     apr_status_t rv;
 144     my_resource_t *resources[RESLIST_HMAX];
 145     void *vp;
 146     int i;
 147
 148     apr_reslist_timeout_set(rl, 1000);
 149
 150     /* deplete all possible resources from the resource list
 151      * so that the next call will block until timeout is reached
 152      * (since there are no other threads to make a resource
 153      * available)
 154      */
 155
 156     for (i = 0; i < RESLIST_HMAX; i++) {
 157         rv = apr_reslist_acquire(rl, (void**)&resources[i]);
 158         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 159     }
 160
 161     /* next call will block until timeout is reached */
 162     rv = apr_reslist_acquire(rl, &vp);
 163     ABTS_TRUE(tc, APR_STATUS_IS_TIMEUP(rv));
 164
 165     /* release the resources; otherwise the destroy operation
 166      * will blow
 167      */
 168     for (i = 0; i < RESLIST_HMAX; i++) {
 169         rv = apr_reslist_release(rl, resources[i]);
 170         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 171     }
 172 }
 173
 174 static void test_shrinking(abts_case *tc, apr_reslist_t *rl)
 175 {
 176     apr_status_t rv;
 177     my_resource_t *resources[RESLIST_HMAX];
 178     my_resource_t *res;
 179     void *vp;
 180     int i;
 181     int sleep_time = RESLIST_TTL / RESLIST_HMAX;
 182
 183     /* deplete all possible resources from the resource list */
 184     for (i = 0; i < RESLIST_HMAX; i++) {
 185         rv = apr_reslist_acquire(rl, (void**)&resources[i]);
 186         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 187     }
 188
 189     /* Free all resources above RESLIST_SMAX - 1 */
 190     for (i = RESLIST_SMAX - 1; i < RESLIST_HMAX; i++) {
 191         rv = apr_reslist_release(rl, resources[i]);
 192         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 193     }
 194
 195     for (i = 0; i < RESLIST_HMAX; i++) {
 196         rv = apr_reslist_acquire(rl, &vp);
 197         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 198         res = vp;
 199         apr_sleep(sleep_time);
 200         rv = apr_reslist_release(rl, res);
 201         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 202     }
 203     apr_sleep(sleep_time);
 204
 205     /*
 206      * Now free the remaining elements. This should trigger the shrinking of
 207      * the list
 208      */
 209     for (i = 0; i < RESLIST_SMAX - 1; i++) {
 210         rv = apr_reslist_release(rl, resources[i]);
 211         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 212     }
 213 }
 214
 215 static void test_reslist(abts_case *tc, void *data)
 216 {
 217     int i;
 218     apr_status_t rv;
 219     apr_reslist_t *rl;
 220     my_parameters_t *params;
 221     apr_thread_pool_t *thrp;
 222     my_thread_info_t thread_info[CONSUMER_THREADS];
 223
 224     rv = apr_thread_pool_create(&thrp, CONSUMER_THREADS/2, CONSUMER_THREADS, p);
 225     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 226
 227     /* Create some parameters that will be passed into each
 228      * constructor and destructor call. */
 229     params = apr_pcalloc(p, sizeof(*params));
 230     params->sleep_upon_construct = CONSTRUCT_SLEEP_TIME;
 231     params->sleep_upon_destruct = DESTRUCT_SLEEP_TIME;
 232
 233     /* We're going to want 10 blocks of data from our target rmm. */
 234     rv = apr_reslist_create(&rl, RESLIST_MIN, RESLIST_SMAX, RESLIST_HMAX,
 235                             RESLIST_TTL, my_constructor, my_destructor,
 236                             params, p);
 237     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 238
 239     for (i = 0; i < CONSUMER_THREADS; i++) {
 240         thread_info[i].tid = i;
 241         thread_info[i].tc = tc;
 242         thread_info[i].reslist = rl;
 243         thread_info[i].work_delay_sleep = WORK_DELAY_SLEEP_TIME;
 244         rv = apr_thread_pool_push(thrp, resource_consuming_thread,
 245                                   &thread_info[i], 0, NULL);
 246         ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 247     }
 248
 249     rv = apr_thread_pool_destroy(thrp);
 250     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 251
 252     test_timeout(tc, rl);
 253
 254     test_shrinking(tc, rl);
 255     ABTS_INT_EQUAL(tc, RESLIST_SMAX, params->c_count - params->d_count);
 256
 257     rv = apr_reslist_destroy(rl);
 258     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 259 }
 260
 261 #endif /* APR_HAS_THREADS */
 262
 263 abts_suite *testreslist(abts_suite *suite)
 264 {
 265     suite = ADD_SUITE(suite);
 266
 267 #if APR_HAS_THREADS
 268     abts_run_test(suite, test_reslist, NULL);
 269 #endif
 270
 271     return suite;
 272 }