tools/tests/libMicro/apple/trivial.c

   1 /*
   2  * Copyright (c) 2006 Apple Inc.  All Rights Reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29
  30 /*
  31  *      Order of Execution
  32  *
  33  *      benchmark_init
  34  *
  35  *      benchmark_optswitch
  36  *
  37  *              benchmark_initrun
  38  *
  39  *                      benchmark_initworker
  40  *                              benchmark_initbatch
  41  *                                      benchmark
  42  *                              benchmark_finibatch
  43  *                              benchmark_initbatch
  44  *                                      benchmark
  45  *                              benchmark_finibatch, etc.
  46  *                      benchmark_finiworker
  47  *
  48  *              benchmark_result
  49  *
  50  *              benchmark_finirun
  51  *
  52  *      benchmark_fini
  53  */
  54
  55
  56
  57 #ifdef  __sun
  58 #pragma ident   "@(#)trivial.c  1.0     08/17/06 Apple Inc."
  59 #endif
  60
  61
  62
  63 #include <unistd.h>
  64 #include <stdlib.h>
  65 #include <stdio.h>
  66 #include <stdbool.h>
  67 #include <string.h>
  68 // add additional headers needed here.
  69
  70 #include "../libmicro.h"
  71
  72 #if DEBUG
  73 # define debug(fmt, args...)    (void) fprintf(stderr, fmt "\n" , ##args)
  74 #else
  75 # define debug(fmt, args...)
  76 #endif
  77
  78 /*
  79  *      Your state variables should live in the tsd_t struct below
  80  */
  81 typedef struct {
  82         int     ts_once;
  83 } tsd_t;
  84
  85 /*
  86  * You can have any lower-case option you want to define.
  87  * options are specified in the lm_optstr as either a
  88  * single lower-case letter, or a single lower case letter
  89  * with a colon after it.  In this example, you can optionally
  90  * specify -c {str} -e or -t {number}
  91  *    -c takes a string (quote the string if blanks)
  92  *    -e is a boolean
  93  *    -t takes a numeric
  94  * argument.
  95  */
  96 static char *   optc; // allocated in benchmark_init, freed in benchmark_fini.
  97 static bool     opte = false;
  98 static int              optt = 1;
  99
 100
 101 int
 102 benchmark_init()
 103 {
 104         debug("benchmark_init\n");
 105         /*
 106          *      the lm_optstr must be defined here or no options for you
 107          *
 108          *      ...and the framework will throw an error
 109          *
 110          */
 111         (void) sprintf(lm_optstr, "c:et:");
 112         /*
 113          *      tsd_t is the state info struct that we pass around
 114          *
 115          *      lm_tsdsize will allocate the space we need for this
 116          *      structure throughout the rest of the framework
 117          */
 118         lm_tsdsize = sizeof (tsd_t);
 119
 120         (void) sprintf(lm_usage,
 121                 "               [-c string]\n"
 122                 "               [-e] optional parameter\n"
 123             "       [-t int (default 1)]\n"
 124             "notes: measures nothing\n");
 125
 126         optc = malloc(20);
 127         return (0);
 128 }
 129
 130 /*
 131  * This is where you parse your lower-case arguments.
 132  * the format was defined in the lm_optstr assignment
 133  * in benchmark_init
 134  */
 135 int
 136 benchmark_optswitch(int opt, char *optarg)
 137 {
 138         debug("benchmark_optswitch\n");
 139
 140         switch (opt) {
 141         case 'c':
 142                 strncpy(optc, optarg, 20);
 143                 debug("optc = %s\n", optc);
 144                 break;
 145         case 'e':
 146                 opte = true;
 147                 debug("opte = %s\n", opte? "true": "false");
 148                 break;
 149         case 't':
 150                 optt = sizetoint(optarg);
 151                 debug("optt = %d\n", optt);
 152                 break;
 153         default:
 154                 return (-1);
 155         }
 156         return (0);
 157 }
 158
 159 int
 160 benchmark_initrun()
 161 {
 162         debug("benchmark_initrun\n");
 163         return (0);
 164 }
 165
 166 int
 167 benchmark_initworker(void *tsd)
 168 {
 169         /*
 170          *      initialize your state variables here first
 171          */
 172         tsd_t                   *ts = (tsd_t *)tsd;
 173         ts->ts_once = optt;
 174         debug("benchmark_initworker: ts_once = %i\n",ts->ts_once);
 175         return (0);
 176 }
 177
 178 /*ARGSUSED*/
 179 int
 180 benchmark_initbatch(void *tsd)
 181 {
 182         /*
 183          * initialize your state variables here second
 184          */
 185         tsd_t                   *ts = (tsd_t *)tsd;
 186         // useless code to show what you can do.
 187          ts->ts_once++;
 188          ts->ts_once--;
 189         debug("benchmark_initbatch: ts_once = %i\n",ts->ts_once);
 190         return (0);
 191 }
 192
 193 int
 194 benchmark(void *tsd, result_t *res)
 195 {
 196         /*
 197          *      try not to initialize things here.  This is the main
 198          *  loop of things to get timed.  Start a server in
 199          *  benchmark_initbatch
 200          */
 201         tsd_t                   *ts = (tsd_t *)tsd;
 202         int                     i;
 203
 204         debug("in to benchmark - optB = %i : ts_once = %i\n", lm_optB, ts->ts_once);
 205         for (i = 0; i < lm_optB; i++) {
 206                 /*
 207                  *      just to show that ts really contains state
 208                  */
 209                  ts->ts_once++;
 210         }
 211         res->re_count = i;
 212         debug("out of benchmark - optB = %i : ts_once = %i\n", lm_optB, ts->ts_once);
 213
 214         return (0);
 215 }
 216
 217 int
 218 benchmark_finibatch(void *tsd)
 219 {
 220         tsd_t                   *ts = (tsd_t *)tsd;
 221         /*
 222          *      more proof of state passing
 223          */
 224         ts->ts_once = optt;
 225         debug("benchmark_finibatch: ts_once = %i\n",ts->ts_once);
 226         return (0);
 227 }
 228
 229 int
 230 benchmark_finiworker(void *tsd)
 231 {
 232         tsd_t                   *ts = (tsd_t *)tsd;
 233         // useless code to show what you can do.
 234          ts->ts_once++;
 235          ts->ts_once--;
 236         debug("benchmark_finiworker: ts_once = %i\n",ts->ts_once);
 237         return (0);
 238 }
 239
 240 char *
 241 benchmark_result()
 242 {
 243         static char             result = '\0';
 244         debug("benchmark_result\n");
 245         return (&result);
 246 }
 247
 248 int
 249 benchmark_finirun()
 250 {
 251         debug("benchmark_finirun\n");
 252         return (0);
 253 }
 254
 255
 256 int
 257 benchmark_fini()
 258 {
 259         debug("benchmark_fini\n");
 260         free(optc);
 261         return (0);
 262 }
 263