�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Ftest%2F'>test</a>/</p><hr><h3>✏️ Editing: time-sem.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* 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 &quot;License&quot;); 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 &quot;AS IS&quot; 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&#039;s
intended for timing differences between various methods on an
architecture.  In practice we&#039;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&#039;t have too many processes use SEM_UNDO, there
        might be a tuneable somewhere that increases the limit from 29.
        We&#039;re not sure what the tunable is, so there&#039;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&#039;ll also need to define NEED_UNION_SEMUN
        under solaris.

You&#039;ll need to define USE_SHMGET_SCOREBOARD if anonymous shared mmap()
doesn&#039;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 &lt;errno.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;unistd.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;sys/wait.h&gt;
#include &lt;sys/mman.h&gt;
#include &lt;signal.h&gt;

#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;          /* -&quot;- */
    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;        /* -&quot;- */
    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(&quot;opening test-lock-thing in current directory\n&quot;);
    fcntl_fd = open(&quot;test-lock-thing&quot;, O_CREAT | O_WRONLY | O_EXCL, 0644);
    if (fcntl_fd == -1)
    {
        perror (&quot;open&quot;);
        fprintf (stderr, &quot;Cannot open lock file: %s\n&quot;, &quot;test-lock-thing&quot;);
        exit (1);
    }
    unlink(&quot;test-lock-thing&quot;);
}

void accept_mutex_on(void)
{
    int ret;

    while ((ret = fcntl(fcntl_fd, F_SETLKW, &amp;lock_it)) &lt; 0 &amp;&amp; errno == EINTR)
        continue;

    if (ret &lt; 0) {
        perror (&quot;fcntl lock_it&quot;);
        exit(1);
    }
}

void accept_mutex_off(void)
{
    if (fcntl (fcntl_fd, F_SETLKW, &amp;unlock_it) &lt; 0)
    {
        perror (&quot;fcntl unlock_it&quot;);
        exit(1);
    }
}

#elif defined(USE_FLOCK_SERIALIZED_ACCEPT)

#include &lt;sys/file.h&gt;

static int flock_fd=-1;

#define FNAME &quot;test-lock-thing&quot;

/*
 * Initialize mutex lock.
 * Must be safe to call this on a restart.
 */
void accept_mutex_init(void)
{

    printf(&quot;opening &quot; FNAME &quot; in current directory\n&quot;);
    flock_fd = open(FNAME, O_CREAT | O_WRONLY | O_EXCL, 0644);
    if (flock_fd == -1)
    {
        perror (&quot;open&quot;);
        fprintf (stderr, &quot;Cannot open lock file: %s\n&quot;, &quot;test-lock-thing&quot;);
        exit (1);
    }
}

void accept_mutex_child_init(void)
{
    flock_fd = open(FNAME, O_WRONLY, 0600);
    if (flock_fd == -1) {
        perror(&quot;open&quot;);
        exit(1);
    }
}

void accept_mutex_cleanup(void)
{
    unlink(FNAME);
}

void accept_mutex_on(void)
{
    int ret;

    while ((ret = flock(flock_fd, LOCK_EX)) &lt; 0 &amp;&amp; errno == EINTR)
        continue;

    if (ret &lt; 0) {
        perror (&quot;flock(LOCK_EX)&quot;);
        exit(1);
    }
}

void accept_mutex_off(void)
{
    if (flock (flock_fd, LOCK_UN) &lt; 0)
    {
        perror (&quot;flock(LOCK_UN)&quot;);
        exit(1);
    }
}

#elif defined (USE_SYSVSEM_SERIALIZED_ACCEPT)

#include &lt;sys/types.h&gt;
#include &lt;sys/ipc.h&gt;
#include &lt;sys/sem.h&gt;

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 &lt; 0) {
       perror (&quot;semget&quot;);
       exit (1);
    }
    ick.val = 1;
    if (semctl(sem_id, 0, SETVAL, ick) &lt; 0) {
       perror (&quot;semctl&quot;);
        exit(1);
    }
#ifdef NO_SEM_UNDO
    sigfillset(&amp;accept_block_mask);
    sigdelset(&amp;accept_block_mask, SIGHUP);
    sigdelset(&amp;accept_block_mask, SIGTERM);
    sigdelset(&amp;accept_block_mask, SIGUSR1);
#endif
}

void accept_mutex_on()
{
    struct sembuf op;

#ifdef NO_SEM_UNDO
    if (sigprocmask(SIG_BLOCK, &amp;accept_block_mask, &amp;accept_previous_mask)) {
        perror(&quot;sigprocmask(SIG_BLOCK)&quot;);
        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, &amp;op, 1) &lt; 0) {
        perror (&quot;accept_mutex_on&quot;);
        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, &amp;op, 1) &lt; 0) {
        perror (&quot;accept_mutex_off&quot;);
        exit (1);
    }
#ifdef NO_SEM_UNDO
    if (sigprocmask(SIG_SETMASK, &amp;accept_previous_mask, NULL)) {
        perror(&quot;sigprocmask(SIG_SETMASK)&quot;);
        exit (1);
    }
#endif
}

#elif defined (USE_PTHREAD_SERIALIZED_ACCEPT)

/* note: pthread mutexes aren&#039;t released on child death, hence the
 * signal goop ... in a real implementation we&#039;d do special things
 * during hup, term, usr1.
 */

#include &lt;pthread.h&gt;

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 (&quot;/dev/zero&quot;, O_RDWR);
    if (fd == -1) {
        perror (&quot;open(/dev/zero)&quot;);
        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 (&quot;mmap&quot;);
        exit (1);
    }
    close (fd);
    if (pthread_mutexattr_init(&amp;mattr)) {
        perror (&quot;pthread_mutexattr_init&quot;);
        exit (1);
    }
    if (pthread_mutexattr_setpshared(&amp;mattr, PTHREAD_PROCESS_SHARED)) {
        perror (&quot;pthread_mutexattr_setpshared&quot;);
        exit (1);
    }
    if (pthread_mutex_init(mutex, &amp;mattr)) {
        perror (&quot;pthread_mutex_init&quot;);
        exit (1);
    }
    sigfillset(&amp;accept_block_mask);
    sigdelset(&amp;accept_block_mask, SIGHUP);
    sigdelset(&amp;accept_block_mask, SIGTERM);
    sigdelset(&amp;accept_block_mask, SIGUSR1);
}

void accept_mutex_on()
{
    if (sigprocmask(SIG_BLOCK, &amp;accept_block_mask, &amp;accept_previous_mask)) {
        perror(&quot;sigprocmask(SIG_BLOCK)&quot;);
        exit (1);
    }
    if (pthread_mutex_lock (mutex)) {
        perror (&quot;pthread_mutex_lock&quot;);
        exit (1);
    }
}

void accept_mutex_off()
{
    if (pthread_mutex_unlock (mutex)) {
        perror (&quot;pthread_mutex_unlock&quot;);
        exit (1);
    }
    if (sigprocmask(SIG_SETMASK, &amp;accept_previous_mask, NULL)) {
        perror(&quot;sigprocmask(SIG_SETMASK)&quot;);
        exit (1);
    }
}

#elif defined (USE_USLOCK_SERIALIZED_ACCEPT)

#include &lt;ulocks.h&gt;

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(&quot;usconfig&quot;);
        exit(-1);
    }
    if ((old = usconfig(CONF_LOCKTYPE, US_NODEBUG)) == -1) {
        perror(&quot;usconfig&quot;);
        exit(-1);
    }
    if ((old = usconfig(CONF_ARENATYPE, US_SHAREDONLY)) == -1) {
        perror(&quot;usconfig&quot;);
        exit(-1);
    }
    if ((us = usinit(&quot;/dev/zero&quot;)) == NULL) {
        perror(&quot;usinit&quot;);
        exit(-1);
    }
    if ((uslock = usnewlock(us)) == NULL) {
        perror(&quot;usnewlock&quot;);
        exit(-1);
    }
}
void accept_mutex_on()
{
    switch(ussetlock(uslock)) {
        case 1:
            /* got lock */
            break;
        case 0:
            fprintf(stderr, &quot;didn&#039;t get lock\n&quot;);
            exit(-1);
        case -1:
            perror(&quot;ussetlock&quot;);
            exit(-1);
    }
}
void accept_mutex_off()
{
    if (usunsetlock(uslock) == -1) {
        perror(&quot;usunsetlock&quot;);
        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 (&quot;mmap&quot;);
        exit (1);
    }
    return result;
}
#else
#include &lt;sys/types.h&gt;
#include &lt;sys/ipc.h&gt;
#ifdef HAVE_SYS_MUTEX_H
#include &lt;sys/mutex.h&gt;
#endif
#include &lt;sys/shm.h&gt;

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(&quot;shmget&quot;);
        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 &quot;way up there&quot;,
     * attach the segment and then move break back down. Ugly
     */
    if ((obrk = sbrk(MOVEBREAK)) == (char *) -1) {
        perror(&quot;sbrk&quot;);
    }
#endif

#define BADSHMAT  ((void *)(-1))
    if ((result = shmat(shmid, 0, 0)) == BADSHMAT) {
        perror(&quot;shmat&quot;);
    }
    /*
     * We must avoid leaving segments in the kernel&#039;s
     * (small) tables.
     */
    if (shmctl(shmid, IPC_RMID, NULL) != 0) {
        perror(&quot;shmctl(IPC_RMID)&quot;);
    }
    if (result == BADSHMAT)  /* now bailout */
        exit(1);

#ifdef MOVEBREAK
    if (obrk == (char *) -1)
        return;  /* nothing else to do */
    if (sbrk(-(MOVEBREAK)) == (char *) -1) {
        perror(&quot;sbrk 2&quot;);
    }
#endif
    return result;
}
#endif

#ifdef _POSIX_PRIORITY_SCHEDULING
/* don&#039;t ask */
#define _P __P
#include &lt;sched.h&gt;
#define YIELD  sched_yield()
#else
#define YIELD  do { struct timeval zero; zero.tv_sec = zero.tv_usec = 0; select(0,0,0,0,&amp;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, &quot;Usage: time-sem num-child num iter\n&quot;);
        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 &lt; num_child; ++i) {
        pid = fork();
        if (pid == 0) {
            /* child, do our thing */
            accept_mutex_child_init();
            for (i = 0; i &lt; 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 (&quot;fork&quot;);
            accept_mutex_off ();
            exit (1);
        }
    }

    /* a quick test to see that nothing is screwed up */
    if (*shared_counter != 0) {
        puts (&quot;WTF! shared_counter != 0 before the children have been started!&quot;);
        accept_mutex_off ();
        exit (1);
    }

    gettimeofday (&amp;first, NULL);
    /* launch children into action */
    accept_mutex_off ();
    for (i = 0; i &lt; num_child; ++i) {
        if (wait(NULL) == -1) {
            perror (&quot;wait&quot;);
        }
    }
    gettimeofday (&amp;last, NULL);

    if (*shared_counter != num_child * num_iter) {
        printf (&quot;WTF! shared_counter != num_child * num_iter!\n&quot;
                &quot;shared_counter = %lu\nnum_child = %d\nnum_iter=%d\n&quot;,
                *shared_counter,
                num_child, num_iter);
    }

    last.tv_sec -= first.tv_sec;
    ms = last.tv_usec - first.tv_usec;
    if (ms &lt; 0) {
        --last.tv_sec;
        ms += 1000000;
    }
    last.tv_usec = ms;
    printf (&quot;%8lu.%06lu\n&quot;, last.tv_sec, last.tv_usec);

    accept_mutex_cleanup();

    exit(0);
}

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Ftest'>🔙 Back</a></p>