diff options
Diffstat (limited to 'rubbos/app/httpd-2.0.64/test/time-sem.c')
| -rw-r--r-- | rubbos/app/httpd-2.0.64/test/time-sem.c | 588 |
1 files changed, 0 insertions, 588 deletions
diff --git a/rubbos/app/httpd-2.0.64/test/time-sem.c b/rubbos/app/httpd-2.0.64/test/time-sem.c deleted file mode 100644 index bdf09316..00000000 --- a/rubbos/app/httpd-2.0.64/test/time-sem.c +++ /dev/null @@ -1,588 +0,0 @@ -/* 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. - */ - -/* -time-sem.c has the basics of the semaphores we use in http_main.c. It's -intended for timing differences between various methods on an -architecture. In practice we've found many things affect which semaphore -to be used: - - - NFS filesystems absolutely suck for fcntl() and flock() - - - uslock absolutely sucks on single-processor IRIX boxes, but - absolutely rocks on multi-processor boxes. The converse - is true for fcntl. sysvsem seems a moderate balance. - - - Under Solaris you can't have too many processes use SEM_UNDO, there - might be a tuneable somewhere that increases the limit from 29. - We're not sure what the tunable is, so there's a define - NO_SEM_UNDO which can be used to simulate us trapping/blocking - signals to be able to properly release the semaphore on a clean - child death. You'll also need to define NEED_UNION_SEMUN - under solaris. - -You'll need to define USE_SHMGET_SCOREBOARD if anonymous shared mmap() -doesn't work on your system (i.e. linux). - -argv[1] is the #children, argv[2] is the #iterations per child - -You should run each over many different #children inputs, and choose -#iter such that the program runs for at least a second or so... or even -longer depending on your patience. - -compile with: - -gcc -o time-FCNTL -Wall -O time-sem.c -DUSE_FCNTL_SERIALIZED_ACCEPT -gcc -o time-FLOCK -Wall -O time-sem.c -DUSE_FLOCK_SERIALIZED_ACCEPT -gcc -o time-SYSVSEM -Wall -O time-sem.c -DUSE_SYSVSEM_SERIALIZED_ACCEPT -gcc -o time-SYSVSEM2 -Wall -O time-sem.c -DUSE_SYSVSEM_SERIALIZED_ACCEPT -DNO_SEM_UNDO -gcc -o time-PTHREAD -Wall -O time-sem.c -DUSE_PTHREAD_SERIALIZED_ACCEPT -lpthread -gcc -o time-USLOCK -Wall -O time-sem.c -DUSE_USLOCK_SERIALIZED_ACCEPT - -not all versions work on all systems. -*/ - -#include <errno.h> -#include <sys/time.h> -#include <unistd.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <sys/wait.h> -#include <sys/mman.h> -#include <signal.h> - -#if defined(USE_FCNTL_SERIALIZED_ACCEPT) - -static struct flock lock_it; -static struct flock unlock_it; - -static int fcntl_fd=-1; - -#define accept_mutex_child_init() -#define accept_mutex_cleanup() - -/* - * Initialize mutex lock. - * Must be safe to call this on a restart. - */ -void -accept_mutex_init(void) -{ - - lock_it.l_whence = SEEK_SET; /* from current point */ - lock_it.l_start = 0; /* -"- */ - lock_it.l_len = 0; /* until end of file */ - lock_it.l_type = F_WRLCK; /* set exclusive/write lock */ - lock_it.l_pid = 0; /* pid not actually interesting */ - unlock_it.l_whence = SEEK_SET; /* from current point */ - unlock_it.l_start = 0; /* -"- */ - unlock_it.l_len = 0; /* until end of file */ - unlock_it.l_type = F_UNLCK; /* set exclusive/write lock */ - unlock_it.l_pid = 0; /* pid not actually interesting */ - - printf("opening test-lock-thing in current directory\n"); - fcntl_fd = open("test-lock-thing", O_CREAT | O_WRONLY | O_EXCL, 0644); - if (fcntl_fd == -1) - { - perror ("open"); - fprintf (stderr, "Cannot open lock file: %s\n", "test-lock-thing"); - exit (1); - } - unlink("test-lock-thing"); -} - -void accept_mutex_on(void) -{ - int ret; - - while ((ret = fcntl(fcntl_fd, F_SETLKW, &lock_it)) < 0 && errno == EINTR) - continue; - - if (ret < 0) { - perror ("fcntl lock_it"); - exit(1); - } -} - -void accept_mutex_off(void) -{ - if (fcntl (fcntl_fd, F_SETLKW, &unlock_it) < 0) - { - perror ("fcntl unlock_it"); - exit(1); - } -} - -#elif defined(USE_FLOCK_SERIALIZED_ACCEPT) - -#include <sys/file.h> - -static int flock_fd=-1; - -#define FNAME "test-lock-thing" - -/* - * Initialize mutex lock. - * Must be safe to call this on a restart. - */ -void accept_mutex_init(void) -{ - - printf("opening " FNAME " in current directory\n"); - flock_fd = open(FNAME, O_CREAT | O_WRONLY | O_EXCL, 0644); - if (flock_fd == -1) - { - perror ("open"); - fprintf (stderr, "Cannot open lock file: %s\n", "test-lock-thing"); - exit (1); - } -} - -void accept_mutex_child_init(void) -{ - flock_fd = open(FNAME, O_WRONLY, 0600); - if (flock_fd == -1) { - perror("open"); - exit(1); - } -} - -void accept_mutex_cleanup(void) -{ - unlink(FNAME); -} - -void accept_mutex_on(void) -{ - int ret; - - while ((ret = flock(flock_fd, LOCK_EX)) < 0 && errno == EINTR) - continue; - - if (ret < 0) { - perror ("flock(LOCK_EX)"); - exit(1); - } -} - -void accept_mutex_off(void) -{ - if (flock (flock_fd, LOCK_UN) < 0) - { - perror ("flock(LOCK_UN)"); - exit(1); - } -} - -#elif defined (USE_SYSVSEM_SERIALIZED_ACCEPT) - -#include <sys/types.h> -#include <sys/ipc.h> -#include <sys/sem.h> - -static int sem_id = -1; -#ifdef NO_SEM_UNDO -static sigset_t accept_block_mask; -static sigset_t accept_previous_mask; -#endif - -#define accept_mutex_child_init() -#define accept_mutex_cleanup() - -void accept_mutex_init(void) -{ -#ifdef NEED_UNION_SEMUN - /* believe it or not, you need to define this under solaris */ - union semun { - int val; - struct semid_ds *buf; - ushort *array; - }; -#endif - - union semun ick; - - sem_id = semget(999, 1, IPC_CREAT | 0666); - if (sem_id < 0) { - perror ("semget"); - exit (1); - } - ick.val = 1; - if (semctl(sem_id, 0, SETVAL, ick) < 0) { - perror ("semctl"); - exit(1); - } -#ifdef NO_SEM_UNDO - sigfillset(&accept_block_mask); - sigdelset(&accept_block_mask, SIGHUP); - sigdelset(&accept_block_mask, SIGTERM); - sigdelset(&accept_block_mask, SIGUSR1); -#endif -} - -void accept_mutex_on() -{ - struct sembuf op; - -#ifdef NO_SEM_UNDO - if (sigprocmask(SIG_BLOCK, &accept_block_mask, &accept_previous_mask)) { - perror("sigprocmask(SIG_BLOCK)"); - exit (1); - } - op.sem_flg = 0; -#else - op.sem_flg = SEM_UNDO; -#endif - op.sem_num = 0; - op.sem_op = -1; - if (semop(sem_id, &op, 1) < 0) { - perror ("accept_mutex_on"); - exit (1); - } -} - -void accept_mutex_off() -{ - struct sembuf op; - - op.sem_num = 0; - op.sem_op = 1; -#ifdef NO_SEM_UNDO - op.sem_flg = 0; -#else - op.sem_flg = SEM_UNDO; -#endif - if (semop(sem_id, &op, 1) < 0) { - perror ("accept_mutex_off"); - exit (1); - } -#ifdef NO_SEM_UNDO - if (sigprocmask(SIG_SETMASK, &accept_previous_mask, NULL)) { - perror("sigprocmask(SIG_SETMASK)"); - exit (1); - } -#endif -} - -#elif defined (USE_PTHREAD_SERIALIZED_ACCEPT) - -/* note: pthread mutexes aren't released on child death, hence the - * signal goop ... in a real implementation we'd do special things - * during hup, term, usr1. - */ - -#include <pthread.h> - -static pthread_mutex_t *mutex; -static sigset_t accept_block_mask; -static sigset_t accept_previous_mask; - -#define accept_mutex_child_init() -#define accept_mutex_cleanup() - -void accept_mutex_init(void) -{ - pthread_mutexattr_t mattr; - int fd; - - fd = open ("/dev/zero", O_RDWR); - if (fd == -1) { - perror ("open(/dev/zero)"); - exit (1); - } - mutex = (pthread_mutex_t *)mmap ((caddr_t)0, sizeof (*mutex), - PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); - if (mutex == (void *)(caddr_t)-1) { - perror ("mmap"); - exit (1); - } - close (fd); - if (pthread_mutexattr_init(&mattr)) { - perror ("pthread_mutexattr_init"); - exit (1); - } - if (pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED)) { - perror ("pthread_mutexattr_setpshared"); - exit (1); - } - if (pthread_mutex_init(mutex, &mattr)) { - perror ("pthread_mutex_init"); - exit (1); - } - sigfillset(&accept_block_mask); - sigdelset(&accept_block_mask, SIGHUP); - sigdelset(&accept_block_mask, SIGTERM); - sigdelset(&accept_block_mask, SIGUSR1); -} - -void accept_mutex_on() -{ - if (sigprocmask(SIG_BLOCK, &accept_block_mask, &accept_previous_mask)) { - perror("sigprocmask(SIG_BLOCK)"); - exit (1); - } - if (pthread_mutex_lock (mutex)) { - perror ("pthread_mutex_lock"); - exit (1); - } -} - -void accept_mutex_off() -{ - if (pthread_mutex_unlock (mutex)) { - perror ("pthread_mutex_unlock"); - exit (1); - } - if (sigprocmask(SIG_SETMASK, &accept_previous_mask, NULL)) { - perror("sigprocmask(SIG_SETMASK)"); - exit (1); - } -} - -#elif defined (USE_USLOCK_SERIALIZED_ACCEPT) - -#include <ulocks.h> - -static usptr_t *us = NULL; -static ulock_t uslock = NULL; - -#define accept_mutex_child_init() -#define accept_mutex_cleanup() - -void accept_mutex_init(void) -{ - ptrdiff_t old; - /* default is 8 */ -#define CONF_INITUSERS_MAX 15 - if ((old = usconfig(CONF_INITUSERS, CONF_INITUSERS_MAX)) == -1) { - perror("usconfig"); - exit(-1); - } - if ((old = usconfig(CONF_LOCKTYPE, US_NODEBUG)) == -1) { - perror("usconfig"); - exit(-1); - } - if ((old = usconfig(CONF_ARENATYPE, US_SHAREDONLY)) == -1) { - perror("usconfig"); - exit(-1); - } - if ((us = usinit("/dev/zero")) == NULL) { - perror("usinit"); - exit(-1); - } - if ((uslock = usnewlock(us)) == NULL) { - perror("usnewlock"); - exit(-1); - } -} -void accept_mutex_on() -{ - switch(ussetlock(uslock)) { - case 1: - /* got lock */ - break; - case 0: - fprintf(stderr, "didn't get lock\n"); - exit(-1); - case -1: - perror("ussetlock"); - exit(-1); - } -} -void accept_mutex_off() -{ - if (usunsetlock(uslock) == -1) { - perror("usunsetlock"); - exit(-1); - } -} -#endif - - -#ifndef USE_SHMGET_SCOREBOARD -static void *get_shared_mem(apr_size_t size) -{ - void *result; - - /* allocate shared memory for the shared_counter */ - result = (unsigned long *)mmap ((caddr_t)0, size, - PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0); - if (result == (void *)(caddr_t)-1) { - perror ("mmap"); - exit (1); - } - return result; -} -#else -#include <sys/types.h> -#include <sys/ipc.h> -#include <sys/shm.h> - -static void *get_shared_mem(apr_size_t size) -{ - key_t shmkey = IPC_PRIVATE; - int shmid = -1; - void *result; -#ifdef MOVEBREAK - char *obrk; -#endif - - if ((shmid = shmget(shmkey, size, IPC_CREAT | SHM_R | SHM_W)) == -1) { - perror("shmget"); - exit(1); - } - -#ifdef MOVEBREAK - /* - * Some SysV systems place the shared segment WAY too close - * to the dynamic memory break point (sbrk(0)). This severely - * limits the use of malloc/sbrk in the program since sbrk will - * refuse to move past that point. - * - * To get around this, we move the break point "way up there", - * attach the segment and then move break back down. Ugly - */ - if ((obrk = sbrk(MOVEBREAK)) == (char *) -1) { - perror("sbrk"); - } -#endif - -#define BADSHMAT ((void *)(-1)) - if ((result = shmat(shmid, 0, 0)) == BADSHMAT) { - perror("shmat"); - } - /* - * We must avoid leaving segments in the kernel's - * (small) tables. - */ - if (shmctl(shmid, IPC_RMID, NULL) != 0) { - perror("shmctl(IPC_RMID)"); - } - if (result == BADSHMAT) /* now bailout */ - exit(1); - -#ifdef MOVEBREAK - if (obrk == (char *) -1) - return; /* nothing else to do */ - if (sbrk(-(MOVEBREAK)) == (char *) -1) { - perror("sbrk 2"); - } -#endif - return result; -} -#endif - -#ifdef _POSIX_PRIORITY_SCHEDULING -/* don't ask */ -#define _P __P -#include <sched.h> -#define YIELD sched_yield() -#else -#define YIELD do { struct timeval zero; zero.tv_sec = zero.tv_usec = 0; select(0,0,0,0,&zero); } while(0) -#endif - -void main (int argc, char **argv) -{ - int num_iter; - int num_child; - int i; - struct timeval first; - struct timeval last; - long ms; - int pid; - unsigned long *shared_counter; - - if (argc != 3) { - fprintf (stderr, "Usage: time-sem num-child num iter\n"); - exit (1); - } - - num_child = atoi (argv[1]); - num_iter = atoi (argv[2]); - - /* allocate shared memory for the shared_counter */ - shared_counter = get_shared_mem(sizeof(*shared_counter)); - - /* initialize counter to 0 */ - *shared_counter = 0; - - accept_mutex_init (); - - /* parent grabs mutex until done spawning children */ - accept_mutex_on (); - - for (i = 0; i < num_child; ++i) { - pid = fork(); - if (pid == 0) { - /* child, do our thing */ - accept_mutex_child_init(); - for (i = 0; i < num_iter; ++i) { - unsigned long tmp; - - accept_mutex_on (); - tmp = *shared_counter; - YIELD; - *shared_counter = tmp + 1; - accept_mutex_off (); - } - exit (0); - } else if (pid == -1) { - perror ("fork"); - exit (1); - } - } - - /* a quick test to see that nothing is screwed up */ - if (*shared_counter != 0) { - puts ("WTF! shared_counter != 0 before the children have been started!"); - exit (1); - } - - gettimeofday (&first, NULL); - /* launch children into action */ - accept_mutex_off (); - for (i = 0; i < num_child; ++i) { - if (wait(NULL) == -1) { - perror ("wait"); - } - } - gettimeofday (&last, NULL); - - if (*shared_counter != num_child * num_iter) { - printf ("WTF! shared_counter != num_child * num_iter!\n" - "shared_counter = %lu\nnum_child = %d\nnum_iter=%d\n", - *shared_counter, - num_child, num_iter); - } - - last.tv_sec -= first.tv_sec; - ms = last.tv_usec - first.tv_usec; - if (ms < 0) { - --last.tv_sec; - ms += 1000000; - } - last.tv_usec = ms; - printf ("%8lu.%06lu\n", last.tv_sec, last.tv_usec); - - accept_mutex_cleanup(); - - exit(0); -} - |