| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #include "apr_general.h" |
| #include "apu.h" |
| #include "apr_reslist.h" |
| #include "apr_thread_pool.h" |
| |
| #if APR_HAVE_TIME_H |
| #include <time.h> |
| #endif /* APR_HAVE_TIME_H */ |
| |
| #include "abts.h" |
| #include "testutil.h" |
| |
| #if APR_HAS_THREADS |
| |
| #define RESLIST_MIN 3 |
| #define RESLIST_SMAX 10 |
| #define RESLIST_HMAX 20 |
| #define RESLIST_TTL APR_TIME_C(35000) /* 35 ms */ |
| #define CONSUMER_THREADS 25 |
| #define CONSUMER_ITERATIONS 250 |
| #define CONSTRUCT_SLEEP_TIME APR_TIME_C(25000) /* 25 ms */ |
| #define DESTRUCT_SLEEP_TIME APR_TIME_C(10000) /* 10 ms */ |
| #define WORK_DELAY_SLEEP_TIME APR_TIME_C(15000) /* 15 ms */ |
| |
| typedef struct { |
| apr_interval_time_t sleep_upon_construct; |
| apr_interval_time_t sleep_upon_destruct; |
| int c_count; |
| int d_count; |
| } my_parameters_t; |
| |
| typedef struct { |
| int id; |
| } my_resource_t; |
| |
| /* Linear congruential generator */ |
| static apr_uint32_t lgc(apr_uint32_t a) |
| { |
| apr_uint64_t z = a; |
| z *= 279470273; |
| z %= APR_UINT64_C(4294967291); |
| return (apr_uint32_t)z; |
| } |
| |
| static apr_status_t my_constructor(void **resource, void *params, |
| apr_pool_t *pool) |
| { |
| my_resource_t *res; |
| my_parameters_t *my_params = params; |
| |
| /* Create some resource */ |
| res = apr_palloc(pool, sizeof(*res)); |
| res->id = my_params->c_count++; |
| |
| /* Sleep for awhile, to simulate construction overhead. */ |
| apr_sleep(my_params->sleep_upon_construct); |
| |
| /* Set the resource so it can be managed by the reslist */ |
| *resource = res; |
| return APR_SUCCESS; |
| } |
| |
| static apr_status_t my_destructor(void *resource, void *params, |
| apr_pool_t *pool) |
| { |
| my_resource_t *res = resource; |
| my_parameters_t *my_params = params; |
| res->id = my_params->d_count++; |
| |
| apr_sleep(my_params->sleep_upon_destruct); |
| |
| return APR_SUCCESS; |
| } |
| |
| typedef struct { |
| int tid; |
| abts_case *tc; |
| apr_reslist_t *reslist; |
| apr_interval_time_t work_delay_sleep; |
| } my_thread_info_t; |
| |
| /* MAX_UINT * .95 = 2**32 * .95 = 4080218931u */ |
| #define PERCENT95th 4080218931u |
| |
| static void * APR_THREAD_FUNC resource_consuming_thread(apr_thread_t *thd, |
| void *data) |
| { |
| int i; |
| apr_uint32_t chance; |
| void *vp; |
| apr_status_t rv; |
| my_resource_t *res; |
| my_thread_info_t *thread_info = data; |
| apr_reslist_t *rl = thread_info->reslist; |
| |
| #if APR_HAS_RANDOM |
| apr_generate_random_bytes((void*)&chance, sizeof(chance)); |
| #else |
| chance = (apr_uint32_t)(apr_time_now() % APR_TIME_C(4294967291)); |
| #endif |
| |
| for (i = 0; i < CONSUMER_ITERATIONS; i++) { |
| rv = apr_reslist_acquire(rl, &vp); |
| ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv); |
| res = vp; |
| apr_sleep(thread_info->work_delay_sleep); |
| |
| /* simulate a 5% chance of the resource being bad */ |
| chance = lgc(chance); |
| if ( chance < PERCENT95th ) { |
| rv = apr_reslist_release(rl, res); |
| ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv); |
| } else { |
| rv = apr_reslist_invalidate(rl, res); |
| ABTS_INT_EQUAL(thread_info->tc, APR_SUCCESS, rv); |
| } |
| } |
| |
| return APR_SUCCESS; |
| } |
| |
| static void test_timeout(abts_case *tc, apr_reslist_t *rl) |
| { |
| apr_status_t rv; |
| my_resource_t *resources[RESLIST_HMAX]; |
| my_resource_t *res; |
| void *vp; |
| int i; |
| |
| apr_reslist_timeout_set(rl, 1000); |
| |
| /* deplete all possible resources from the resource list |
| * so that the next call will block until timeout is reached |
| * (since there are no other threads to make a resource |
| * available) |
| */ |
| |
| for (i = 0; i < RESLIST_HMAX; i++) { |
| rv = apr_reslist_acquire(rl, (void**)&resources[i]); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| |
| /* next call will block until timeout is reached */ |
| rv = apr_reslist_acquire(rl, &vp); |
| ABTS_TRUE(tc, APR_STATUS_IS_TIMEUP(rv)); |
| |
| res = vp; |
| |
| /* release the resources; otherwise the destroy operation |
| * will blow |
| */ |
| for (i = 0; i < RESLIST_HMAX; i++) { |
| rv = apr_reslist_release(rl, resources[i]); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| } |
| |
| static void test_shrinking(abts_case *tc, apr_reslist_t *rl) |
| { |
| apr_status_t rv; |
| my_resource_t *resources[RESLIST_HMAX]; |
| my_resource_t *res; |
| void *vp; |
| int i; |
| int sleep_time = RESLIST_TTL / RESLIST_HMAX; |
| |
| /* deplete all possible resources from the resource list */ |
| for (i = 0; i < RESLIST_HMAX; i++) { |
| rv = apr_reslist_acquire(rl, (void**)&resources[i]); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| |
| /* Free all resources above RESLIST_SMAX - 1 */ |
| for (i = RESLIST_SMAX - 1; i < RESLIST_HMAX; i++) { |
| rv = apr_reslist_release(rl, resources[i]); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| |
| for (i = 0; i < RESLIST_HMAX; i++) { |
| rv = apr_reslist_acquire(rl, &vp); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| res = vp; |
| apr_sleep(sleep_time); |
| rv = apr_reslist_release(rl, res); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| apr_sleep(sleep_time); |
| |
| /* |
| * Now free the remaining elements. This should trigger the shrinking of |
| * the list |
| */ |
| for (i = 0; i < RESLIST_SMAX - 1; i++) { |
| rv = apr_reslist_release(rl, resources[i]); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| } |
| |
| static void test_reslist(abts_case *tc, void *data) |
| { |
| int i; |
| apr_status_t rv; |
| apr_reslist_t *rl; |
| my_parameters_t *params; |
| apr_thread_pool_t *thrp; |
| my_thread_info_t thread_info[CONSUMER_THREADS]; |
| |
| rv = apr_thread_pool_create(&thrp, CONSUMER_THREADS/2, CONSUMER_THREADS, p); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| |
| /* Create some parameters that will be passed into each |
| * constructor and destructor call. */ |
| params = apr_pcalloc(p, sizeof(*params)); |
| params->sleep_upon_construct = CONSTRUCT_SLEEP_TIME; |
| params->sleep_upon_destruct = DESTRUCT_SLEEP_TIME; |
| |
| /* We're going to want 10 blocks of data from our target rmm. */ |
| rv = apr_reslist_create(&rl, RESLIST_MIN, RESLIST_SMAX, RESLIST_HMAX, |
| RESLIST_TTL, my_constructor, my_destructor, |
| params, p); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| |
| for (i = 0; i < CONSUMER_THREADS; i++) { |
| thread_info[i].tid = i; |
| thread_info[i].tc = tc; |
| thread_info[i].reslist = rl; |
| thread_info[i].work_delay_sleep = WORK_DELAY_SLEEP_TIME; |
| rv = apr_thread_pool_push(thrp, resource_consuming_thread, |
| &thread_info[i], 0, NULL); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| |
| rv = apr_thread_pool_destroy(thrp); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| |
| test_timeout(tc, rl); |
| |
| test_shrinking(tc, rl); |
| ABTS_INT_EQUAL(tc, RESLIST_SMAX, params->c_count - params->d_count); |
| |
| rv = apr_reslist_destroy(rl); |
| ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); |
| } |
| |
| #endif /* APR_HAS_THREADS */ |
| |
| abts_suite *testreslist(abts_suite *suite) |
| { |
| suite = ADD_SUITE(suite); |
| |
| #if APR_HAS_THREADS |
| abts_run_test(suite, test_reslist, NULL); |
| #endif |
| |
| return suite; |
| } |