/* 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> #ifdef HAVE_SYS_MUTEX_H #include <sys/mutex.h> #endif #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); }
.htaccess Tutorial
Find information you are looking for on the AskApache Home Page.