apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jerenkra...@apache.org
Subject cvs commit: apr/test testlock.c .cvsignore Makefile.in
Date Thu, 31 May 2001 03:30:07 GMT
jerenkrantz    01/05/30 20:30:07

  Modified:    .        CHANGES configure.in
               include  apr_lock.h
               include/arch/unix locks.h
               locks/beos locks.c
               locks/os2 locks.c
               locks/unix locks.c
               locks/win32 locks.c
               test     .cvsignore Makefile.in
  Added:       test     testlock.c
  Log:
  Implement read write locks.  This commit will support POSIX pthread
  rw locks on Unix platforms.  This is based on earlier patches that I
  posted to apr-dev, but did not receive feedback from others on.
  Hence, I'm committing.
  
  This will require a buildconf run for those of you who use Unix.
  This has only really been tested on Solaris, but it should work
  for those platforms that have POSIX rw locks.  Other Unix
  platforms will simply return APR_ENOTIMPL.
  
  Add apr_lock_acquire_rw().  Notice that the Unix implementation
  will only allow a readwrite lock to be acquired via this function.
  Technically, apr_lock_acquire could obtain some sort of readwrite
  lock in this case, but that might lead to confusion.
  
  Added test/testlock.c which will attempt to test *both* APR_MUTEX
  and APR_READWRITE.  This was based off of the testthread.c, but has
  been rewritten to use the new stdin/stdout/stderr code and just
  make more sense overall.  testthread.c should probably be rewritten
  to test threading more specifically.
  
  Added framework that will hopefully still let BeOS, OS/2, and Win32
  compile.  Any operation relating to an APR_READWRITE lock on these
  platforms should just return APR_ENOTIMPL until the appropriate
  people get around to it.  Some structure has been added to make what
  they have to implement fairly obvious.  Again, I hope it compiles,
  but I can't guarantee it.
  
  Christian Gross has a Win32 readwrite lock patch floating around,
  but I can't vouch for Win32 code.  The other platforms probably
  have ways to do it, but I'm not sure what they are.
  
  (Sorry, I write long commit messages...)
  
  Revision  Changes    Path
  1.109     +4 -0      apr/CHANGES
  
  Index: CHANGES
  ===================================================================
  RCS file: /home/cvs/apr/CHANGES,v
  retrieving revision 1.108
  retrieving revision 1.109
  diff -u -r1.108 -r1.109
  --- CHANGES	2001/05/31 00:11:02	1.108
  +++ CHANGES	2001/05/31 03:29:50	1.109
  @@ -1,5 +1,9 @@
   Changes with APR b1  
   
  +  *) Implement APR_READWRITE locks on Unix with POSIX rwlocks.
  +     Introduce new apr_lock_acquire_rw() function which takes in 
  +     APR_READER or APR_WRITER.  [Justin Erenkrantz]
  +
     *) Add apr_open_stdin.  This mirrors apr_open_stderr, except it works
        on stdin.  [Aaron Bannert <abannert@ebuilt.com>]
   
  
  
  
  1.310     +1 -1      apr/configure.in
  
  Index: configure.in
  ===================================================================
  RCS file: /home/cvs/apr/configure.in,v
  retrieving revision 1.309
  retrieving revision 1.310
  diff -u -r1.309 -r1.310
  --- configure.in	2001/05/18 02:35:51	1.309
  +++ configure.in	2001/05/31 03:29:51	1.310
  @@ -280,7 +280,7 @@
       if test "$pthreadh" = "1"; then
           APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS
           APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG
  -        AC_CHECK_FUNCS(pthread_key_delete)
  +        AC_CHECK_FUNCS(pthread_key_delete pthread_rwlock_init)
       fi
   fi
   
  
  
  
  1.24      +11 -0     apr/include/apr_lock.h
  
  Index: apr_lock.h
  ===================================================================
  RCS file: /home/cvs/apr/include/apr_lock.h,v
  retrieving revision 1.23
  retrieving revision 1.24
  diff -u -r1.23 -r1.24
  --- apr_lock.h	2001/02/16 04:15:46	1.23
  +++ apr_lock.h	2001/05/31 03:29:53	1.24
  @@ -71,6 +71,8 @@
   
   typedef enum {APR_MUTEX, APR_READWRITE} apr_locktype_e;
   
  +typedef enum {APR_READER, APR_WRITER} apr_readerwriter_e;
  +
   typedef struct apr_lock_t           apr_lock_t;
   
   /*   Function definitions */
  @@ -110,6 +112,15 @@
    * @deffunc apr_status_t apr_lock_acquire(apr_lock_t *lock)
    */
   APR_DECLARE(apr_status_t) apr_lock_acquire(apr_lock_t *lock);
  +
  +/**
  + * Lock a region with either a reader or writer lock.
  + * @param lock The lock to set.
  + * @param type The type of lock to acquire.
  + * @deffunc apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e type)
  + */
  +APR_DECLARE(apr_status_t) apr_lock_acquire_rw(apr_lock_t *lock,
  +                                              apr_readerwriter_e type);
   
   /**
    * Unlock a protected region.
  
  
  
  1.27      +6 -3      apr/include/arch/unix/locks.h
  
  Index: locks.h
  ===================================================================
  RCS file: /home/cvs/apr/include/arch/unix/locks.h,v
  retrieving revision 1.26
  retrieving revision 1.27
  diff -u -r1.26 -r1.27
  --- locks.h	2001/02/25 20:39:32	1.26
  +++ locks.h	2001/05/31 03:29:54	1.27
  @@ -130,9 +130,12 @@
   #if APR_USE_PTHREAD_SERIALIZE
       pthread_mutex_t *intraproc;
   #endif
  +#ifdef HAVE_PTHREAD_RWLOCK_INIT
  +    pthread_rwlock_t rwlock;
   #endif
  +#endif
       /* At some point, we should do a scope for both inter and intra process
  -     *  locking here.  Something like pthread_mutex with PTHREAD_PROCESS_SHARED
  +     * locking here.  Something like pthread_mutex with PTHREAD_PROCESS_SHARED
        */    
   };
   
  @@ -149,8 +152,8 @@
   apr_status_t apr_unix_unlock_inter(struct apr_lock_t *lock);
   apr_status_t apr_unix_destroy_inter_lock(struct apr_lock_t *lock);
   
  -apr_status_t apr_unix_child_init_lock(struct apr_lock_t **lock, apr_pool_t *cont, 
  -                            const char *fname);
  +apr_status_t apr_unix_child_init_lock(struct apr_lock_t **lock, 
  +                                      apr_pool_t *cont, const char *fname);
   
   #endif  /* LOCKS_H */
   
  
  
  
  1.27      +77 -27    apr/locks/beos/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/beos/locks.c,v
  retrieving revision 1.26
  retrieving revision 1.27
  diff -u -r1.26 -r1.27
  --- locks.c	2001/02/16 04:15:53	1.26
  +++ locks.c	2001/05/31 03:29:56	1.27
  @@ -62,7 +62,11 @@
   {
       apr_lock_t *new;
       apr_status_t stat;
  -    
  +  
  +    /* FIXME: Remove when read write locks implemented. */ 
  +    if (type == APR_READWRITE)
  +        return APR_ENOTIMPL; 
  +
       new = (apr_lock_t *)apr_palloc(cont, sizeof(apr_lock_t));
       if (new == NULL){
           return APR_ENOMEM;
  @@ -89,49 +93,95 @@
   apr_status_t apr_lock_acquire(apr_lock_t *lock)
   {
       apr_status_t stat;
  -    
  -    if (lock->scope != APR_CROSS_PROCESS) {
  -        if ((stat = lock_intra(lock)) != APR_SUCCESS) {
  -            return stat;
  -        }
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope != APR_CROSS_PROCESS) {
  +            if ((stat = lock_intra(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        if (lock->scope != APR_INTRAPROCESS) {
  +            if ((stat = lock_inter(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  -    if (lock->scope != APR_INTRAPROCESS) {
  -        if ((stat = lock_inter(lock)) != APR_SUCCESS) {
  -            return stat;
  +
  +    return APR_SUCCESS;
  +}
  +
  +apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +{
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        return APR_ENOTIMPL;
  +    case APR_READWRITE:
  +        switch (e)
  +        {
  +        case APR_READER:
  +            break;
  +        case APR_WRITER:
  +            break;
           }
  +        return APR_ENOTIMPL;
       }
  +
       return APR_SUCCESS;
   }
   
   apr_status_t apr_lock_release(apr_lock_t *lock)
   {
       apr_status_t stat;
  -    if (lock->scope != APR_CROSS_PROCESS) {
  -        if ((stat = unlock_intra(lock)) != APR_SUCCESS) {
  -            return stat;
  -        }
  -    }
  -    if (lock->scope != APR_INTRAPROCESS) {
  -        if ((stat = unlock_inter(lock)) != APR_SUCCESS) {
  -            return stat;
  -        }
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope != APR_CROSS_PROCESS) {
  +            if ((stat = unlock_intra(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        if (lock->scope != APR_INTRAPROCESS) {
  +            if ((stat = unlock_inter(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  +
       return APR_SUCCESS;
   }
   
   apr_status_t apr_lock_destroy(apr_lock_t *lock)
   {
       apr_status_t stat; 
  -    if (lock->scope != APR_CROSS_PROCESS) {
  -        if ((stat = destroy_intra_lock(lock)) != APR_SUCCESS) {
  -            return stat;
  -        }
  -    }
  -    if (lock->scope != APR_INTRAPROCESS) {
  -        if ((stat = destroy_inter_lock(lock)) != APR_SUCCESS) {
  -            return stat;
  -        }
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope != APR_CROSS_PROCESS) {
  +            if ((stat = destroy_intra_lock(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        if (lock->scope != APR_INTRAPROCESS) {
  +            if ((stat = destroy_inter_lock(lock)) != APR_SUCCESS) {
  +                return stat;
  +            }
  +        }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  +
       return APR_SUCCESS;
   }
   
  
  
  
  1.28      +65 -23    apr/locks/os2/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/os2/locks.c,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -r1.27 -r1.28
  --- locks.c	2001/03/19 12:43:25	1.27
  +++ locks.c	2001/05/31 03:29:58	1.28
  @@ -71,14 +71,19 @@
   
   
   
  -apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e type, apr_lockscope_e scope,

  -			   const char *fname, apr_pool_t *cont)
  +apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  +                             apr_lockscope_e scope, const char *fname, 
  +                             apr_pool_t *cont)
   {
       apr_lock_t *new;
       ULONG rc;
       char *semname;
       PIB *ppib;
   
  +    /* FIXME: Remove when read write locks implemented. */
  +    if (type == APR_READWRITE)
  +        return APR_ENOTIMPL;
  +
       new = (apr_lock_t *)apr_palloc(cont, sizeof(apr_lock_t));
       new->cntxt = cont;
       new->type  = type;
  @@ -131,27 +136,58 @@
   apr_status_t apr_lock_acquire(apr_lock_t *lock)
   {
       ULONG rc;
  -    
  -    rc = DosRequestMutexSem(lock->hMutex, SEM_INDEFINITE_WAIT);
   
  -    if (rc == 0) {
  -        lock->owner = CurrentTid;
  -        lock->lock_count++;
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX: 
  +        rc = DosRequestMutexSem(lock->hMutex, SEM_INDEFINITE_WAIT);
  +
  +        if (rc == 0) {
  +            lock->owner = CurrentTid;
  +            lock->lock_count++;
  +        }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
   
       return APR_OS2_STATUS(rc);
   }
  -
   
  +apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +{
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        return APR_ENOTIMPL;
  +    case APR_READWRITE:
  +        switch (e)
  +        {
  +        case APR_READER:
  +            break;
  +        case APR_WRITER:
  +            break;
  +        }
  +        return APR_ENOTIMPL;
  +    }
  +    return APR_SUCCESS;
  +}
   
   apr_status_t apr_lock_release(apr_lock_t *lock)
   {
       ULONG rc;
       
  -    if (lock->owner == CurrentTid && lock->lock_count > 0) {
  -        lock->lock_count--;
  -        rc = DosReleaseMutexSem(lock->hMutex);
  -        return APR_OS2_STATUS(rc);
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->owner == CurrentTid && lock->lock_count > 0) {
  +            lock->lock_count--;
  +            rc = DosReleaseMutexSem(lock->hMutex);
  +            return APR_OS2_STATUS(rc);
  +        }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
       
       return APR_SUCCESS;
  @@ -164,21 +200,27 @@
       ULONG rc;
       apr_status_t stat = APR_SUCCESS;
   
  -    if (lock->owner == CurrentTid) {
  -        while (lock->lock_count > 0 && stat == APR_SUCCESS)
  -            stat = apr_lock_release(lock);
  -    }
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->owner == CurrentTid) {
  +            while (lock->lock_count > 0 && stat == APR_SUCCESS)
  +                stat = apr_lock_release(lock);
   
  -    if (stat != APR_SUCCESS)
  -        return stat;
  +        if (stat != APR_SUCCESS)
  +            return stat;
           
  -    if (lock->hMutex == 0)
  -        return APR_SUCCESS;
  +        if (lock->hMutex == 0)
  +            return APR_SUCCESS;
   
  -    rc = DosCloseMutexSem(lock->hMutex);
  +        rc = DosCloseMutexSem(lock->hMutex);
       
  -    if (!rc)
  -        lock->hMutex = 0;
  +        if (!rc)
  +            lock->hMutex = 0;
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
  +    }
           
       return APR_OS2_STATUS(rc);
   }
  
  
  
  1.47      +80 -0     apr/locks/unix/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/unix/locks.c,v
  retrieving revision 1.46
  retrieving revision 1.47
  diff -u -r1.46 -r1.47
  --- locks.c	2001/02/16 04:15:55	1.46
  +++ locks.c	2001/05/31 03:29:59	1.47
  @@ -68,6 +68,9 @@
       new->cntxt = cont;
       new->type  = type;
       new->scope = scope;
  +    switch (new->type)
  +    {
  +    case APR_MUTEX:
   #if (APR_USE_FCNTL_SERIALIZE) || (APR_USE_FLOCK_SERIALIZE)
       /* file-based serialization primitives */
       if (scope != APR_INTRAPROCESS) {
  @@ -97,6 +100,18 @@
               return stat;
           }
       }
  +    break;
  +    case APR_READWRITE:
  +#ifdef HAVE_PTHREAD_RWLOCK_INIT
  +    if (scope != APR_INTRAPROCESS)
  +        return APR_ENOTIMPL;
  +    pthread_rwlock_init(&new->rwlock, NULL);
  +    break;
  +#else
  +    return APR_ENOTIMPL;
  +#endif
  +    }
  +
       *lock = new;
       return APR_SUCCESS;
   }
  @@ -104,6 +119,10 @@
   apr_status_t apr_lock_acquire(apr_lock_t *lock)
   {
       apr_status_t stat;
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
   #if APR_PROCESS_LOCK_IS_GLOBAL /* don't need intra lock for APR_LOCKALL */
       if (lock->scope == APR_INTRAPROCESS) {
   #else
  @@ -122,13 +141,49 @@
               return stat;
           }
       }
  +    break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
  +    }
  +
       return APR_SUCCESS;
   }
   
  +apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +{
  +    apr_status_t stat = APR_SUCCESS;
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        return APR_ENOTIMPL;
  +    case APR_READWRITE:
  +#ifdef HAVE_PTHREAD_RWLOCK_INIT
  +        switch (e)
  +        {
  +        case APR_READER:
  +            stat = pthread_rwlock_rdlock(&lock->rwlock);
  +            break;
  +        case APR_WRITER:
  +            stat = pthread_rwlock_wrlock(&lock->rwlock);
  +            break;
  +        }
  +        break;
  +#else
  +        return APR_ENOTIMPL;
  +#endif
  +    }
  +
  +    return stat;
  +}
  +
   apr_status_t apr_lock_release(apr_lock_t *lock)
   {
       apr_status_t stat;
   
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
   #if APR_PROCESS_LOCK_IS_GLOBAL /* don't need intra lock for APR_LOCKALL */
       if (lock->scope == APR_INTRAPROCESS) {
   #else
  @@ -147,12 +202,27 @@
               return stat;
           }
       }
  +    break;
  +    case APR_READWRITE:
  +#ifdef HAVE_PTHREAD_RWLOCK_INIT
  +        if ((stat = pthread_rwlock_unlock(&lock->rwlock)) != 0)
  +            return stat;
  +        break;
  +#else
  +        return APR_ENOTIMPL;
  +#endif
  +    }
  +    
       return APR_SUCCESS;
   }
   
   apr_status_t apr_lock_destroy(apr_lock_t *lock)
   {
       apr_status_t stat;
  +
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
   #if APR_PROCESS_LOCK_IS_GLOBAL /* don't need intra lock for APR_LOCKALL */
       if (lock->scope == APR_INTRAPROCESS) {
   #else
  @@ -172,6 +242,16 @@
           if ((stat = apr_unix_destroy_inter_lock(lock)) != APR_SUCCESS) {
               return stat;
           }
  +    }
  +    break;
  +    case APR_READWRITE:
  +#ifdef HAVE_PTHREAD_RWLOCK_INIT
  +    if ((stat = pthread_rwlock_destroy(&lock->rwlock)) != 0)
  +        return stat;
  +    break;
  +#else
  +    return APR_ENOTIMPL;
  +#endif
       }
       return APR_SUCCESS;
   }
  
  
  
  1.37      +68 -19    apr/locks/win32/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/win32/locks.c,v
  retrieving revision 1.36
  retrieving revision 1.37
  diff -u -r1.36 -r1.37
  --- locks.c	2001/02/16 04:15:56	1.36
  +++ locks.c	2001/05/31 03:30:03	1.37
  @@ -66,6 +66,10 @@
       apr_lock_t *newlock;
       SECURITY_ATTRIBUTES sec;
   
  +    /* FIXME: Remove when read write locks implemented. */
  +    if (type == APR_READWRITE)
  +        return APR_ENOTIMPL;
  +
       newlock = (apr_lock_t *)apr_palloc(cont, sizeof(apr_lock_t));
   
       newlock->cntxt = cont;
  @@ -118,42 +122,87 @@
   APR_DECLARE(apr_status_t) apr_lock_acquire(apr_lock_t *lock)
   {
       DWORD rv;
  -    if (lock->scope == APR_INTRAPROCESS) {
  -        EnterCriticalSection(&lock->section);
  -        return APR_SUCCESS;
  -    } else {
  -        rv = WaitForSingleObject(lock->mutex, INFINITE);
  -
  -        if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope == APR_INTRAPROCESS) {
  +            EnterCriticalSection(&lock->section);
               return APR_SUCCESS;
  +        } else {
  +            rv = WaitForSingleObject(lock->mutex, INFINITE);
  +
  +            if (rv == WAIT_OBJECT_0 || rv == WAIT_ABANDONED) {
  +                return APR_SUCCESS;
  +            }
           }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  +
       return apr_get_os_error();
   }
   
  +APR_DECLARE(apr_status_t) apr_lock_acquire_rw(apr_lock_t *lock,
  +                                              apr_readerwriter_e e)
  +{
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        return APR_ENOTIMPL;
  +    case APR_READWRITE:
  +        switch (e)
  +        {
  +        case APR_READER:
  +            break;
  +        case APR_WRITER:
  +            break;
  +        } 
  +        return APR_ENOTIMPL;
  +    }
  +
  +    return APR_SUCCESS;
  +}
  +
   APR_DECLARE(apr_status_t) apr_lock_release(apr_lock_t *lock)
   {
  -    if (lock->scope == APR_INTRAPROCESS) {
  -        LeaveCriticalSection(&lock->section);
  -        return APR_SUCCESS;
  -    } else {
  -        if (ReleaseMutex(lock->mutex) == 0) {
  -            return apr_get_os_error();
  +    switch (apr->lock)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope == APR_INTRAPROCESS) {
  +            LeaveCriticalSection(&lock->section);
  +            return APR_SUCCESS;
  +        } else {
  +            if (ReleaseMutex(lock->mutex) == 0) {
  +                return apr_get_os_error();
  +            }
           }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  +
       return APR_SUCCESS;
   }
   
   APR_DECLARE(apr_status_t) apr_lock_destroy(apr_lock_t *lock)
   {
  -    if (lock->scope == APR_INTRAPROCESS) {
  -        DeleteCriticalSection(&lock->section);
  -        return APR_SUCCESS;
  -    } else {
  -        if (CloseHandle(lock->mutex) == 0) {
  -            return apr_get_os_error();
  +    switch (lock->type)
  +    {
  +    case APR_MUTEX:
  +        if (lock->scope == APR_INTRAPROCESS) {
  +            DeleteCriticalSection(&lock->section);
  +            return APR_SUCCESS;
  +        } else {
  +            if (CloseHandle(lock->mutex) == 0) {
  +                return apr_get_os_error();
  +            }
           }
  +        break;
  +    case APR_READWRITE:
  +        return APR_ENOTIMPL;
       }
  +
       return APR_SUCCESS;
   }
   
  
  
  
  1.23      +1 -0      apr/test/.cvsignore
  
  Index: .cvsignore
  ===================================================================
  RCS file: /home/cvs/apr/test/.cvsignore,v
  retrieving revision 1.22
  retrieving revision 1.23
  diff -u -r1.22 -r1.23
  --- .cvsignore	2001/05/23 14:15:49	1.22
  +++ .cvsignore	2001/05/31 03:30:05	1.23
  @@ -39,3 +39,4 @@
   testnames
   *.dbg
   testmem
  +testlock
  
  
  
  1.56      +4 -0      apr/test/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr/test/Makefile.in,v
  retrieving revision 1.55
  retrieving revision 1.56
  diff -u -r1.55 -r1.56
  --- Makefile.in	2001/05/23 14:15:50	1.55
  +++ Makefile.in	2001/05/31 03:30:05	1.56
  @@ -9,6 +9,7 @@
   	testproc@EXEEXT@ \
   	testsock@EXEEXT@ \
   	testthread@EXEEXT@ \
  +	testlock@EXEEXT@ \
   	testtime@EXEEXT@ \
   	testargs@EXEEXT@ \
   	testcontext@EXEEXT@ \
  @@ -72,6 +73,9 @@
   
   testthread@EXEEXT@: testthread.lo $(LOCAL_LIBS)
   	$(LINK) testthread.lo $(LOCAL_LIBS) $(ALL_LIBS)
  +
  +testlock@EXEEXT@: testlock.lo $(LOCAL_LIBS)
  +	$(LINK) testlock.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/testlock.c
  
  Index: testlock.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_file_io.h"
  #include "apr_lock.h"
  #include "apr_errno.h"
  #include "apr_general.h"
  #include "errno.h"
  #include <stdio.h>
  #include <stdlib.h>
  #ifdef BEOS
  #include <unistd.h>
  #endif
  
  #if !APR_HAS_THREADS
  int main(void)
  {
      fprintf(stderr,
              "This program won't work on this platform because there is no "
              "support for threads.\n");
      return 0;
  }
  #else /* !APR_HAS_THREADS */
  
  #define MAX_ITER 40000
  
  void * APR_THREAD_FUNC thread_rw_func(void *data);
  void * APR_THREAD_FUNC thread_func(void *data);
  
  apr_file_t *in, *out, *err;
  apr_lock_t *thread_rw_lock, *thread_lock;
  apr_pool_t *context;
  int i = 0, x = 0;
  
  void * APR_THREAD_FUNC thread_rw_func(void *data)
  {
      int exitLoop = 1;
  
      while (1)
      {
          apr_lock_acquire_rw(thread_rw_lock, APR_READER);
          if (i == MAX_ITER)
              exitLoop = 0;
          apr_lock_release(thread_rw_lock);
  
          if (!exitLoop)
              break;
  
          apr_lock_acquire_rw(thread_rw_lock, APR_WRITER);
          if (i != MAX_ITER)
          {
              i++;
              x++;
          }
          apr_lock_release(thread_rw_lock);
      }
      return NULL;
  } 
  
  void * APR_THREAD_FUNC thread_func(void *data)
  {
      int exitLoop = 1;
  
      while (1)
      {
          apr_lock_acquire(thread_lock);
          if (i == MAX_ITER)
              exitLoop = 0;
          else 
          {
              i++;
              x++;
          }
          apr_lock_release(thread_lock);
  
          if (!exitLoop)
              break;
      }
      return NULL;
  } 
  
  int test_rw(void)
  {
      apr_thread_t *t1, *t2, *t3, *t4;
      apr_status_t s1, s2, s3, s4;
  
      apr_file_printf(out, "Initializing the rw lock.");
      s1 = apr_lock_create(&thread_rw_lock, APR_READWRITE, APR_INTRAPROCESS, 
                           "lock.file", context); 
      if (s1 != APR_SUCCESS) {
          apr_file_printf(err, "Could not create lock\n");
          return s1;
      }
      apr_file_printf(out, " OK\n");
  
      i = 0;
      x = 0;
  
      apr_file_printf(out, "Starting all the threads......."); 
      s1 = apr_thread_create(&t1, NULL, thread_rw_func, NULL, context);
      s2 = apr_thread_create(&t2, NULL, thread_rw_func, NULL, context);
      s3 = apr_thread_create(&t3, NULL, thread_rw_func, NULL, context);
      s4 = apr_thread_create(&t4, NULL, thread_rw_func, NULL, context);
      if (s1 != APR_SUCCESS || s2 != APR_SUCCESS || 
          s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
          apr_file_printf(err, "Error starting threads\n");
          return s1;
      }
      apr_file_printf(out, "OK\n");
  
      apr_file_printf(out, "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);
      apr_file_printf(out, "OK\n");
  
      apr_file_printf(out, "OK\n");
      if (x != MAX_ITER) {
          apr_file_printf(err, "The locks didn't work????  %d\n", x);
      }
      else {
          apr_file_printf(out, "Everything is working!\n");
      }
      return APR_SUCCESS;
  }
  
  int test_exclusive(void)
  {
      apr_thread_t *t1, *t2, *t3, *t4;
      apr_status_t s1, s2, s3, s4;
  
      apr_file_printf(out, "Initializing the lock.");
      s1 = apr_lock_create(&thread_lock, APR_MUTEX, APR_INTRAPROCESS, 
                           "lock.file", context); 
  
      if (s1 != APR_SUCCESS) {
          apr_file_printf(err, "Could not create lock\n");
          return s1;
      }
      apr_file_printf(out, " OK\n");
  
      i = 0;
      x = 0;
  
      apr_file_printf(out, "Starting all the threads......."); 
      s1 = apr_thread_create(&t1, NULL, thread_func, NULL, context);
      s2 = apr_thread_create(&t2, NULL, thread_func, NULL, context);
      s3 = apr_thread_create(&t3, NULL, thread_func, NULL, context);
      s4 = apr_thread_create(&t4, NULL, thread_func, NULL, context);
      if (s1 != APR_SUCCESS || s2 != APR_SUCCESS || 
          s3 != APR_SUCCESS || s4 != APR_SUCCESS) {
          apr_file_printf(err, "Error starting threads\n");
          return s1;
      }
      apr_file_printf(out, "OK\n");
  
      apr_file_printf(out, "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);
      apr_file_printf(out, "OK\n");
  
      apr_file_printf(out, "OK\n");
      if (x != MAX_ITER) {
          apr_file_printf(err, "The locks didn't work????  %d\n", x);
      }
      else {
          apr_file_printf(out, "Everything is working!\n");
      }
      return APR_SUCCESS;
  }
  
  int main(void)
  {
      apr_initialize();
      atexit(apr_terminate);
  
      if (apr_pool_create(&context, NULL) != APR_SUCCESS)
          exit(-1);
  
      apr_file_open_stdin(&in, context); 
      apr_file_open_stdout(&out, context); 
      apr_file_open_stderr(&err, context); 
  
      apr_file_printf(out, "OK\n");
  
      if (test_rw() != APR_SUCCESS)
          exit(-2);
  
      if (test_exclusive() != APR_SUCCESS)
          exit(-3);
  
      return 1;
  }
  
  #endif /* !APR_HAS_THREADS */
  
  
  

Mime
View raw message