[apple/xnu.git] / tools / tests / libMicro / apple / lmbench_lat_ctx.c

/*
 * Copyright (c) 2006 Apple Inc.  All Rights Reserved.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */


/*
 *      Order of Execution
 *
 *      benchmark_init
 *
 *      benchmark_optswitch
 *
 *              benchmark_initrun
 *
 *                      benchmark_initworker
 *                              benchmark_initbatch
 *                                      benchmark
 *                              benchmark_finibatch
 *                              benchmark_initbatch
 *                                      benchmark
 *                              benchmark_finibatch, etc.
 *                      benchmark_finiworker
 *
 *              benchmark_result
 *
 *              benchmark_finirun
 *
 *      benchmark_fini
 */



#ifdef  __sun
#pragma ident   "@(#)trivial.c  1.0     08/17/06 Apple Inc."
#endif



#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#include <signal.h>
#include <strings.h>

#include <sys/sysctl.h>
#include "../libmicro.h"

#if 1
# define debug(fmt, args...)    (void) fprintf(stderr, fmt "\n" , ##args)
#else
# define debug(fmt, args...)
#endif


#define MAXPROC 2048
#define CHUNK   (4<<10)
#define TRIPS   5
#ifndef max
#define max(a, b)       ((a) > (b) ? (a) : (b))
#endif


/*
 *      Your state variables should live in the tsd_t struct below
 */
typedef struct {
        int     process_size;
        double  overhead;
        int     procs;
        pid_t*  pids;
        int     **p;
        void*   data;
} tsd_t;

static int      opts = 1;

void    doit(int rd, int wr, int process_size);
int             create_pipes(int **p, int procs);
int             create_daemons(int **p, pid_t *pids, int procs, int process_size);
void    initialize_overhead(void* tsd);
void    cleanup_overhead(void* tsd);
void    benchmark_overhead(void* tsd);
void    initialize(void* tsd);
void    cleanup(void* tsd);
long    bread(void* buf, long nbytes);


#pragma mark *** lmbench routines

/*
 * lmbench routines, etc. brought over for this benchmark
 */
 
void
morefds(void)
{
#ifdef  RLIMIT_NOFILE
        struct  rlimit r;

        getrlimit(RLIMIT_NOFILE, &r);
        r.rlim_cur = r.rlim_max;
        setrlimit(RLIMIT_NOFILE, &r);
#endif
}

void
doit(int rd, int wr, int process_size)
{
        int     msg;
        void*   data = NULL;

        if (process_size) {
                data = malloc(process_size);
                if (data) bzero(data, process_size);
        }
        for ( ;; ) {
                if (read(rd, &msg, sizeof(msg)) != sizeof(msg)) {
                        debug("read/write on pipe"); 
                        break;
                }
                bread(data, process_size);
                if (write(wr, &msg, sizeof(msg)) != sizeof(msg)) {
                        debug("read/write on pipe");
                        break;
                }
        }
        exit(0);
}

/*
 * Return the number of processors in this host
 */
int
sched_ncpus()
{
#ifdef MP_NPROCS
        /* SGI IRIX interface */
        return sysmp(MP_NPROCS);
#elif defined(HAVE_MPCTL)
        /* HP-UX interface */
        return mpctl(MPC_GETNUMSPUS_SYS, 0, 0);
#elif defined(_SC_NPROCESSORS_ONLN)
        /* AIX, Solaris, and Linux interface */
        return sysconf(_SC_NPROCESSORS_ONLN);
#elif __APPLE__
        char *name="hw.activecpu";
        int cpus, retval;       
        size_t len = 4;
        retval=sysctlbyname(name, &cpus, &len, NULL, 0);
        /* Check retval here */ 
        debug("cpus = %d retval = %d", cpus, retval);
        return cpus;
#endif
        return 1;
}

/*
 * Use to get sequentially created processes "far" away from
 * each other in an SMP.
 *
 * XXX: probably doesn't work for NCPUS not a power of two.
 */
int
reverse_bits(int cpu)
{
        int     i;
        int     nbits;
        int     max = sched_ncpus() - 1;
        int     cpu_reverse = 0;

        for (i = max>>1, nbits = 1; i > 0; i >>= 1, nbits++)
          ;
        /* now reverse the bits */
        for (i = 0; i < nbits; i++) {
                if (cpu & (1<<i))
                        cpu_reverse |= (1<<(nbits-i-1));
        }
        return cpu_reverse;
}


/*
 * The interface used by benchmp.
 *
 * childno is the "logical" child id number.  
 *      In range [0, ..., parallel-1].
 * benchproc is the "logical" id within the benchmark process.  The
 *      benchmp-created process is logical ID zero, child processes
 *      created by the benchmark range from [1, ..., nbenchprocs].
 * nbenchprocs is the number of child processes that each benchmark
 *      process will create.  Most benchmarks will leave this zero,
 *      but some such as the pipe() benchmarks will not.
 */
int
handle_scheduler(int childno, int benchproc, int nbenchprocs)
{
        int     cpu = 0;
        char*   sched = getenv("LMBENCH_SCHED");
        
        if (!sched || strcasecmp(sched, "DEFAULT") == 0) {
                /* do nothing.  Allow scheduler to control placement */
                return 0;
        } else if (strcasecmp(sched, "SINGLE") == 0) {
                /* assign all processes to CPU 0 */
                cpu = 0;
        } else if (strcasecmp(sched, "BALANCED") == 0) {
                /* assign each benchmark process to its own processor,
                 * but child processes will share the CPU with the
                 * parent.
                 */
                cpu = childno;
        } else if (strcasecmp(sched, "BALANCED_SPREAD") == 0) {
                /* 
                 * assign each benchmark process to its own processor, 
                 * logically as far away from neighboring IDs as 
                 * possible.  This can help identify bus contention
                 * issues in SMPs with hierarchical busses or NUMA
                 * memory.
                 */
                cpu = reverse_bits(childno);
        } else if (strcasecmp(sched, "UNIQUE") == 0) {
                /*
                 * assign each benchmark process and each child process
                 * to its own processor.
                 */
                cpu = childno * (nbenchprocs + 1) + benchproc;
        } else if (strcasecmp(sched, "UNIQUE_SPREAD") == 0) {
                /* 
                 * assign each benchmark process and each child process
                 * to its own processor, logically as far away from 
                 * neighboring IDs as possible.  This can help identify 
                 * bus contention issues in SMPs with hierarchical busses
                 * or NUMA memory.
                 */
                cpu = reverse_bits(childno * (nbenchprocs + 1) + benchproc);
        } 
#if 0 // BLOB
          else if (strncasecmp(sched, "CUSTOM ", strlen("CUSTOM ")) == 0) {
                cpu = custom(sched + strlen("CUSTOM"), childno);
        } else if (strncasecmp(sched, "CUSTOM_UNIQUE ", strlen("CUSTOM_UNIQUE ")) == 0) {
                cpu = custom(sched + strlen("CUSTOM_UNIQUE"), 
                             childno * (nbenchprocs + 1) + benchproc);
        } 
#endif // BLOB
                else {
                /* default action: do nothing */
                return 0;
        }
        debug("cpu = %d, sched_ncpus() = %d", cpu, sched_ncpus());
        return 0;
//      return sched_pin(cpu % sched_ncpus());
}

int
create_daemons(int **p, pid_t *pids, int procs, int process_size)
{
        int     i, j;
        int     msg;

        /*
         * Use the pipes as a ring, and fork off a bunch of processes
         * to pass the byte through their part of the ring.
         *
         * Do the sum in each process and get that time before moving on.
         */
        handle_scheduler(getpid(), 0, procs-1);
        for (i = 1; i < procs; ++i) {
                switch (pids[i] = fork()) {
                    case -1:    /* could not fork, out of processes? */
                        return i;

                    case 0:     /* child */
                        handle_scheduler(getpid(), i, procs-1);
                        for (j = 0; j < procs; ++j) {
                                if (j != i - 1) close(p[j][0]);
                                if (j != i) close(p[j][1]);
                        }
                        doit(p[i-1][0], p[i][1], process_size);
                        /* NOTREACHED */

                    default:    /* parent */
                        ;
                }
        }

        /*
         * Go once around the loop to make sure that everyone is ready and
         * to get the token in the pipeline.
         */
        if (write(p[0][1], &msg, sizeof(msg)) != sizeof(msg) ||
            read(p[procs-1][0], &msg, sizeof(msg)) != sizeof(msg)) {
                debug("write/read/write on pipe"); 
                exit(1);
        }
        return procs;
}

int
create_pipes(int **p, int procs)
{
        int     i;
        /*
         * Get a bunch of pipes.
         */
        morefds();
        for (i = 0; i < procs; ++i) {
                if (pipe(p[i]) == -1) {
                        return i;
                }
        }
        return procs;
}

void
initialize_overhead(void* cookie)
{
    int i;
    int procs;
    int* p;
    tsd_t       *pState = (tsd_t *)cookie;

    pState->pids = NULL;
    pState->p = (int**)malloc(pState->procs * (sizeof(int*) + 2 * sizeof(int)));
    p = (int*)&pState->p[pState->procs];
    for (i = 0; i < pState->procs; ++i) {
        pState->p[i] = p;
        p += 2;
    }

    pState->data = (pState->process_size > 0) ? malloc(pState->process_size) : NULL;
    if (pState->data)
        bzero(pState->data, pState->process_size);

    procs = create_pipes(pState->p, pState->procs);
    if (procs < pState->procs) {
        debug("procs < pState->procs");
        cleanup_overhead(cookie);
        exit(1);
    }
}

void
cleanup_overhead(void* tsd)
{
        int     i;
        tsd_t   *ts = (tsd_t *)tsd;

        for (i = 0; i < ts->procs; ++i) {
                close(ts->p[i][0]);
                close(ts->p[i][1]);
        }

        free(ts->p);
        if (ts->data) free(ts->data);
}

void
cleanup(void* cookie)
{
    int         i;
    tsd_t       *pState = (tsd_t *)cookie;


    /*
     * Close the pipes and kill the children.
     */
    cleanup_overhead(cookie);
        for (i = 1; pState->pids && i < pState->procs; ++i) {
        if (pState->pids[i] > 0) {
            kill(pState->pids[i], SIGKILL);
            waitpid(pState->pids[i], NULL, 0);
        }
    }
    if (pState->pids)
        free(pState->pids);
    pState->pids = NULL;
}

void
benchmark_overhead(void* tsd)
{
        tsd_t   *ts = (tsd_t *)tsd;
        int     i = 0;
        int     msg = 1;

        for (i = 0; i < lm_optB; i++) {
                if (write(ts->p[i][1], &msg, sizeof(msg)) != sizeof(msg)) {
                        debug("read/write on pipe");
                        exit(1);                                
                }
                if (read(ts->p[i][0], &msg, sizeof(msg)) != sizeof(msg)) {
                        debug("read/write on pipe");
                        exit(1);
                }
                if (++i == ts->procs) {
                        i = 0;
                }
                bread(ts->data, ts->process_size);
        }
}

/* analogous to bzero, bcopy, etc., except that it just reads
 * data into the processor
 */
long
bread(void* buf, long nbytes)
{
        long sum = 0;
        register long *p, *next;
        register char *end;

        p = (long*)buf;
        end = (char*)buf + nbytes;
        for (next = p + 128; (void*)next <= (void*)end; p = next, next += 128) {
                sum +=
                        p[0]+p[1]+p[2]+p[3]+p[4]+p[5]+p[6]+p[7]+
                        p[8]+p[9]+p[10]+p[11]+p[12]+p[13]+p[14]+
                        p[15]+p[16]+p[17]+p[18]+p[19]+p[20]+p[21]+
                        p[22]+p[23]+p[24]+p[25]+p[26]+p[27]+p[28]+
                        p[29]+p[30]+p[31]+p[32]+p[33]+p[34]+p[35]+
                        p[36]+p[37]+p[38]+p[39]+p[40]+p[41]+p[42]+
                        p[43]+p[44]+p[45]+p[46]+p[47]+p[48]+p[49]+
                        p[50]+p[51]+p[52]+p[53]+p[54]+p[55]+p[56]+
                        p[57]+p[58]+p[59]+p[60]+p[61]+p[62]+p[63]+
                        p[64]+p[65]+p[66]+p[67]+p[68]+p[69]+p[70]+
                        p[71]+p[72]+p[73]+p[74]+p[75]+p[76]+p[77]+
                        p[78]+p[79]+p[80]+p[81]+p[82]+p[83]+p[84]+
                        p[85]+p[86]+p[87]+p[88]+p[89]+p[90]+p[91]+
                        p[92]+p[93]+p[94]+p[95]+p[96]+p[97]+p[98]+
                        p[99]+p[100]+p[101]+p[102]+p[103]+p[104]+
                        p[105]+p[106]+p[107]+p[108]+p[109]+p[110]+
                        p[111]+p[112]+p[113]+p[114]+p[115]+p[116]+
                        p[117]+p[118]+p[119]+p[120]+p[121]+p[122]+
                        p[123]+p[124]+p[125]+p[126]+p[127];
        }
        for (next = p + 16; (void*)next <= (void*)end; p = next, next += 16) {
                sum +=
                        p[0]+p[1]+p[2]+p[3]+p[4]+p[5]+p[6]+p[7]+
                        p[8]+p[9]+p[10]+p[11]+p[12]+p[13]+p[14]+
                        p[15];
        }
        for (next = p + 1; (void*)next <= (void*)end; p = next, next++) {
                sum += *p;
        }
        return sum;
}

#pragma mark *** darbench routines


/*ARGSUSED*/
int
benchmark_initbatch(void *tsd)
{
        /*
         * initialize your state variables here second
         */
        tsd_t                   *ts = (tsd_t *)tsd;
        int procs;

        initialize_overhead(tsd);

        ts->pids = (pid_t*)malloc(ts->procs * sizeof(pid_t));
        if (ts->pids == NULL)
                exit(1);
        bzero((void*)ts->pids, ts->procs * sizeof(pid_t));
        procs = create_daemons(ts->p, ts->pids, 
                               ts->procs, ts->process_size);
        if (procs < ts->procs) {
                cleanup(tsd);
                exit(1);
        }
        return (0);
}

int
benchmark_finirun()
{
        return (0);
}

int
benchmark_init()
{
        /* 
         *      the lm_optstr must be defined here or no options for you
         *
         *      ...and the framework will throw an error
         *
         */
        (void) sprintf(lm_optstr, "s:");
        /*
         *      working hypothesis:
         *      
         *      tsd_t is the struct that we can pass around our
         *      state info in
         *
         *      lm_tsdsize will allocate the space we need for this
         *      structure throughout the rest of the framework
         */
        lm_tsdsize = sizeof (tsd_t);

        (void) sprintf(lm_usage,
                "               [-s kbytes]\n"
                "               processes [processes ...]\n");

        return (0);
}

int
benchmark_fini()
{
        return (0);
}

int
benchmark_finibatch(void *tsd)
{
        tsd_t                   *ts = (tsd_t *)tsd;
        int i;
        
        /*
         * Close the pipes and kill the children.
         */
        cleanup_overhead(tsd);
        for (i = 1; ts->pids && i < ts->procs; ++i) {
                if (ts->pids[i] > 0) {
                        kill(ts->pids[i], SIGKILL);
                        waitpid(ts->pids[i], NULL, 0);
                }
        }
        if (ts->pids)
                free(ts->pids);
        ts->pids = NULL;
        return (0);
}

char *
benchmark_result()
{
        static char             result = '\0';
        return (&result);
}

int
benchmark_finiworker(void *tsd)
{
        return (0);
}

int
benchmark_optswitch(int opt, char *optarg)
{
        
        switch (opt) {
        case 's':
                opts = sizetoint(optarg);
                break;
        default:
                return (-1);
        }
        return (0);
}

int
benchmark_initworker(void *tsd)
{
        tsd_t           *ts = (tsd_t *)tsd;
        
        ts->process_size = opts;
         
        return (0);
}

int
benchmark_initrun()
{
        return (0);
}

int
benchmark(void *tsd, result_t *res)
{
        /* 
         *      initialize your state variables here last
         * 
         *      and realize that you are paying for your initialization here
         *      and it is really a bad idea
         */
        tsd_t           *ts = (tsd_t *)tsd;
        int                     i;
        int                     msg=1;
        
        for (i = 0; i < lm_optB; i++) {
                if (write(ts->p[0][1], &msg, sizeof(msg)) !=
                    sizeof(msg)) {
                        debug("read/write on pipe");
                        exit(1);
                }
                if (read(ts->p[ts->procs-1][0], &msg, sizeof(msg)) != sizeof(msg)) {
                        debug("read/write on pipe");
                        exit(1);
                }
                bread(ts->data, ts->process_size);
        }
        res->re_count = i;

        return (0);
}