You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@apr.apache.org by ia...@apache.org on 2001/09/10 17:47:25 UTC
cvs commit: apr/test testlockperf.c .cvsignore Makefile.in
ianh 01/09/10 08:47:25
Modified: test .cvsignore Makefile.in
Added: test testlockperf.c
Log:
This test attempts to asses the performance characterists of various mutex
strategies we use in APR. It resembles a test from W. Richard Stevens
in his _UNIX Network Programming: Interprocess Communications_ Vol 2,
Second Ed., Appendix A. In these tests a number of threads are created,
and each thread iterates MAX_COUNTER times (currently 1 million).
In each iteration through this loop, the thread will lock a mutex,
increment a counter, and unlock. The total time taken (in usec) is then
printed. I have some more optimizations that will be tested for efficacy
using this test.
Submitted by: Aaron Bannert <aa...@clove.org>
Reviewed by: IanH@apache.org
Revision Changes Path
1.29 +2 -0 apr/test/.cvsignore
Index: .cvsignore
===================================================================
RCS file: /home/cvs/apr/test/.cvsignore,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -r1.28 -r1.29
--- .cvsignore 2001/08/15 01:59:08 1.28
+++ .cvsignore 2001/09/10 15:47:25 1.29
@@ -1,5 +1,6 @@
Makefile
*.lo
+*.swp
.libs
testmd5
testmmap
@@ -41,6 +42,7 @@
*.dbg
testmem
testlock
+testlockperf
*.core
testsockets
testuser
1.66 +4 -0 apr/test/Makefile.in
Index: Makefile.in
===================================================================
RCS file: /home/cvs/apr/test/Makefile.in,v
retrieving revision 1.65
retrieving revision 1.66
diff -u -r1.65 -r1.66
--- Makefile.in 2001/08/13 21:49:08 1.65
+++ Makefile.in 2001/09/10 15:47:25 1.66
@@ -11,6 +11,7 @@
testsock@EXEEXT@ \
testthread@EXEEXT@ \
testlock@EXEEXT@ \
+ testlockperf@EXEEXT@ \
testtime@EXEEXT@ \
testargs@EXEEXT@ \
testud@EXEEXT@ \
@@ -82,6 +83,9 @@
testlock@EXEEXT@: testlock.lo $(LOCAL_LIBS)
$(LINK) testlock.lo $(LOCAL_LIBS) $(ALL_LIBS)
+
+testlockperf@EXEEXT@: testlockperf.lo $(LOCAL_LIBS)
+ $(LINK) testlockperf.lo $(LOCAL_LIBS) $(ALL_LIBS)
testsock@EXEEXT@: testsock.lo client@EXEEXT@ server@EXEEXT@ sendfile@EXEEXT@ $(LOCAL_LIBS)
$(LINK) testsock.lo $(LOCAL_LIBS) $(ALL_LIBS)
1.1 apr/test/testlockperf.c
Index: testlockperf.c
===================================================================
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
#include "apr_thread_proc.h"
#include "apr_thread_mutex.h"
#include "apr_thread_rwlock.h"
#include "apr_file_io.h"
#include "apr_lock.h"
#include "apr_errno.h"
#include "apr_general.h"
#include "apr_getopt.h"
#include "errno.h"
#include <stdio.h>
#include <stdlib.h>
#include "test_apr.h"
#include <sys/time.h> /* replace me with apr_time.h */
#if !APR_HAS_THREADS
int main(void)
{
printf("This program won't work on this platform because there is no "
"support for threads.\n");
return 0;
}
#else /* !APR_HAS_THREADS */
#define MAX_COUNTER 1000000
#define MAX_ITER 40000
static long mutex_counter;
static apr_lock_t *inter_lock;
static apr_thread_mutex_t *thread_lock;
void * APR_THREAD_FUNC inter_mutex_func(apr_thread_t *thd, void *data);
void * APR_THREAD_FUNC thread_mutex_func(apr_thread_t *thd, void *data);
apr_status_t test_inter_mutex(void); /* apr_lock_t -- INTRAPROCESS */
apr_status_t test_thread_mutex(void); /* apr_thread_mutex_t */
static apr_lock_t *inter_rwlock;
static apr_thread_rwlock_t *thread_rwlock;
void * APR_THREAD_FUNC inter_rwlock_func(apr_thread_t *thd, void *data);
void * APR_THREAD_FUNC thread_rwlock_func(apr_thread_t *thd, void *data);
apr_status_t test_inter_rwlock(void); /* apr_lock_t -- READWRITE */
apr_status_t test_thread_rwlock(void); /* apr_thread_rwlock_t */
apr_pool_t *pool;
int i = 0, x = 0;
void * APR_THREAD_FUNC inter_mutex_func(apr_thread_t *thd, void *data)
{
int i;
for (i = 0; i < MAX_COUNTER; i++) {
apr_lock_acquire(inter_lock);
mutex_counter++;
apr_lock_release(inter_lock);
}
return NULL;
}
void * APR_THREAD_FUNC thread_mutex_func(apr_thread_t *thd, void *data)
{
int i;
for (i = 0; i < MAX_COUNTER; i++) {
apr_thread_mutex_lock(thread_lock);
mutex_counter++;
apr_thread_mutex_unlock(thread_lock);
}
return NULL;
}
void * APR_THREAD_FUNC inter_rwlock_func(apr_thread_t *thd, void *data)
{
int i;
for (i = 0; i < MAX_COUNTER; i++) {
apr_lock_acquire_rw(inter_rwlock, APR_WRITER);
mutex_counter++;
apr_lock_release(inter_rwlock);
}
return NULL;
}
void * APR_THREAD_FUNC thread_rwlock_func(apr_thread_t *thd, void *data)
{
int i;
for (i = 0; i < MAX_COUNTER; i++) {
apr_thread_rwlock_wrlock(thread_rwlock);
mutex_counter++;
apr_thread_rwlock_unlock(thread_rwlock);
}
return NULL;
}
int test_inter_mutex(void)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
apr_time_t time_start, time_stop;
mutex_counter = 0;
printf("apr_lock(INTRAPROCESS, MUTEX) Lock Tests\n");
printf("%-60s", " Initializing the apr_lock_t");
s1 = apr_lock_create(&inter_lock, APR_MUTEX, APR_INTRAPROCESS,
"lock.file", pool);
if (s1 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
apr_lock_acquire(inter_lock);
/* set_concurrency(4)? -aaron */
printf("%-60s"," Starting all the threads");
s1 = apr_thread_create(&t1, NULL, inter_mutex_func, NULL, pool);
s2 = apr_thread_create(&t2, NULL, inter_mutex_func, NULL, pool);
s3 = apr_thread_create(&t3, NULL, inter_mutex_func, NULL, pool);
s4 = apr_thread_create(&t4, NULL, inter_mutex_func, NULL, pool);
if (s1 != APR_SUCCESS || s2 != APR_SUCCESS ||
s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
time_start = apr_time_now();
apr_lock_release(inter_lock);
/* printf("%-60s", " Waiting for threads to exit"); */
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
/* printf("OK\n"); */
time_stop = apr_time_now();
printf("microseconds: %" APR_INT64_T_FMT " usec\n",
(time_stop - time_start));
if (mutex_counter != MAX_COUNTER * 4)
printf("error: counter = %ld\n", mutex_counter);
return APR_SUCCESS;
}
int test_thread_mutex(void)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
apr_time_t time_start, time_stop;
mutex_counter = 0;
printf("apr_thread_mutex_t Tests\n");
printf("%-60s", " Initializing the apr_thread_mutex_t");
s1 = apr_thread_mutex_create(&thread_lock, pool);
if (s1 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
apr_thread_mutex_lock(thread_lock);
/* set_concurrency(4)? -aaron */
printf("%-60s"," Starting all the threads");
s1 = apr_thread_create(&t1, NULL, thread_mutex_func, NULL, pool);
s2 = apr_thread_create(&t2, NULL, thread_mutex_func, NULL, pool);
s3 = apr_thread_create(&t3, NULL, thread_mutex_func, NULL, pool);
s4 = apr_thread_create(&t4, NULL, thread_mutex_func, NULL, pool);
if (s1 != APR_SUCCESS || s2 != APR_SUCCESS ||
s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
time_start = apr_time_now();
apr_thread_mutex_unlock(thread_lock);
/* printf("%-60s", " Waiting for threads to exit"); */
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
/* printf("OK\n"); */
time_stop = apr_time_now();
printf("microseconds: %" APR_INT64_T_FMT " usec\n",
(time_stop - time_start));
if (mutex_counter != MAX_COUNTER * 4)
printf("error: counter = %ld\n", mutex_counter);
return APR_SUCCESS;
}
int test_inter_rwlock(void)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
apr_time_t time_start, time_stop;
mutex_counter = 0;
printf("apr_lock(INTRAPROCESS, READWRITE) Lock Tests\n");
printf("%-60s", " Initializing the apr_lock_t");
s1 = apr_lock_create(&inter_rwlock, APR_READWRITE, APR_INTRAPROCESS,
"lock.file", pool);
if (s1 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
apr_lock_acquire_rw(inter_rwlock, APR_WRITER);
/* set_concurrency(4)? -aaron */
s1 = apr_thread_create(&t1, NULL, inter_rwlock_func, NULL, pool);
s2 = apr_thread_create(&t2, NULL, inter_rwlock_func, NULL, pool);
s3 = apr_thread_create(&t3, NULL, inter_rwlock_func, NULL, pool);
s4 = apr_thread_create(&t4, NULL, inter_rwlock_func, NULL, pool);
if (s1 != APR_SUCCESS || s2 != APR_SUCCESS ||
s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
time_start = apr_time_now();
apr_lock_release(inter_rwlock);
/* printf("%-60s", " Waiting for threads to exit"); */
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
/* printf("OK\n"); */
time_stop = apr_time_now();
printf("microseconds: %" APR_INT64_T_FMT " usec\n",
(time_stop - time_start));
if (mutex_counter != MAX_COUNTER * 4)
printf("error: counter = %ld\n", mutex_counter);
return APR_SUCCESS;
}
int test_thread_rwlock(void)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
apr_time_t time_start, time_stop;
mutex_counter = 0;
printf("apr_thread_mutex_t Tests\n");
printf("%-60s", " Initializing the apr_thread_mutex_t");
s1 = apr_thread_rwlock_create(&thread_rwlock, pool);
if (s1 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
printf("OK\n");
apr_thread_rwlock_wrlock(thread_rwlock);
/* set_concurrency(4)? -aaron */
s1 = apr_thread_create(&t1, NULL, thread_rwlock_func, NULL, pool);
s2 = apr_thread_create(&t2, NULL, thread_rwlock_func, NULL, pool);
s3 = apr_thread_create(&t3, NULL, thread_rwlock_func, NULL, pool);
s4 = apr_thread_create(&t4, NULL, thread_rwlock_func, NULL, pool);
if (s1 != APR_SUCCESS || s2 != APR_SUCCESS ||
s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
printf("Failed!\n");
return s1;
}
time_start = apr_time_now();
apr_thread_rwlock_unlock(thread_rwlock);
/* printf("%-60s", " Waiting for threads to exit"); */
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
/* printf("OK\n"); */
time_stop = apr_time_now();
printf("microseconds: %" APR_INT64_T_FMT " usec\n",
(time_stop - time_start));
if (mutex_counter != MAX_COUNTER * 4)
printf("error: counter = %ld\n", mutex_counter);
return APR_SUCCESS;
}
int main(int argc, const char * const *argv)
{
apr_status_t rv;
char errmsg[200];
const char *lockname = "multi.lock";
apr_getopt_t *opt;
char optchar;
const char *optarg;
printf("APR Lock Performance Test\n==============\n\n");
apr_initialize();
atexit(apr_terminate);
if (apr_pool_create(&pool, NULL) != APR_SUCCESS)
exit(-1);
if ((rv = apr_getopt_init(&opt, pool, argc, argv)) != APR_SUCCESS) {
fprintf(stderr, "Could not set up to parse options: [%d] %s\n",
rv, apr_strerror(rv, errmsg, sizeof errmsg));
exit(-1);
}
while ((rv = apr_getopt(opt, "f:", &optchar, &optarg)) == APR_SUCCESS) {
if (optchar == 'f') {
lockname = optarg;
}
}
if (rv != APR_SUCCESS && rv != APR_EOF) {
fprintf(stderr, "Could not parse options: [%d] %s\n",
rv, apr_strerror(rv, errmsg, sizeof errmsg));
exit(-1);
}
if ((rv = test_inter_mutex()) != APR_SUCCESS) {
fprintf(stderr,"apr_lock(INTRAPROCESS, MUTEX) test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-2);
}
if ((rv = test_thread_mutex()) != APR_SUCCESS) {
fprintf(stderr,"thread_mutex test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-3);
}
if ((rv = test_inter_rwlock()) != APR_SUCCESS) {
fprintf(stderr,"apr_lock(INTRAPROCESS, READWRITE) test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-2);
}
if ((rv = test_thread_rwlock()) != APR_SUCCESS) {
fprintf(stderr,"thread_rwlock test failed : [%d] %s\n",
rv, apr_strerror(rv, (char*)errmsg, 200));
exit(-3);
}
return 0;
}
#endif /* !APR_HAS_THREADS */