tools/tests/libMicro/cascade_lockf.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms
   5  * of the Common Development and Distribution License
   6  * (the "License").  You may not use this file except
   7  * in compliance with the License.
   8  *
   9  * You can obtain a copy of the license at
  10  * src/OPENSOLARIS.LICENSE
  11  * or http://www.opensolaris.org/os/licensing.
  12  * See the License for the specific language governing
  13  * permissions and limitations under the License.
  14  *
  15  * When distributing Covered Code, include this CDDL
  16  * HEADER in each file and include the License file at
  17  * usr/src/OPENSOLARIS.LICENSE.  If applicable,
  18  * add the following below this CDDL HEADER, with the
  19  * fields enclosed by brackets "[]" replaced with your
  20  * own identifying information: Portions Copyright [yyyy]
  21  * [name of copyright owner]
  22  *
  23  * CDDL HEADER END
  24  */
  25
  26 /*
  27  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 /*
  32  * The "cascade" test case is a multiprocess/multithread batten-passing model
  33  * using lock primitives alone for synchronisation. Threads are arranged in a
  34  * ring. Each thread has two locks of its own on which it blocks, and is able
  35  * to manipulate the two locks belonging to the thread which follows it in the
  36  * ring.
  37  *
  38  * The number of threads (nthreads) is specified by the generic libMicro -P/-T
  39  * options. With nthreads == 1 (the default) the uncontended case can be timed.
  40  *
  41  * The main logic is generic and allows any simple blocking API to be tested.
  42  * The API-specific component is clearly indicated.
  43  */
  44
  45 #include <unistd.h>
  46 #include <stdlib.h>
  47 #include <stdio.h>
  48 #include <fcntl.h>
  49
  50 #include "libmicro.h"
  51
  52 typedef struct {
  53         int                     ts_once;
  54         int                     ts_id;
  55         int                     ts_us0;         /* our lock indices */
  56         int                     ts_us1;
  57         int                     ts_them0;       /* their lock indices */
  58         int                     ts_them1;
  59 } tsd_t;
  60
  61 static int                      nthreads;
  62
  63 /*
  64  * API-specific code BEGINS here
  65  */
  66
  67 #define DEFD                    "/private/tmp"
  68
  69 static char                     *optd = DEFD;
  70 static int                      nfiles;
  71 static int                      *files;
  72
  73 int
  74 benchmark_init()
  75 {
  76         lm_tsdsize = sizeof (tsd_t);
  77
  78         (void) sprintf(lm_optstr, "d:");
  79
  80         lm_defN = "cscd_lockf";
  81
  82         (void) sprintf(lm_usage,
  83             "       [-d directory for temp files (default %s)]\n"
  84             "notes: thread cascade using lockf file locking\n",
  85             DEFD);
  86
  87         return (0);
  88 }
  89
  90 int
  91 benchmark_optswitch(int opt, char *optarg)
  92 {
  93         switch (opt) {
  94         case 'd':
  95                 optd = optarg;
  96                 break;
  97         default:
  98                 return (-1);
  99         }
 100         return (0);
 101 }
 102
 103 int
 104 benchmark_initrun()
 105 {
 106         int                     i;
 107         int                     errors = 0;
 108         char                    fname[1024];
 109
 110         nthreads = lm_optP * lm_optT;
 111         nfiles = nthreads * 2;
 112         (void) setfdlimit(nfiles + 10);
 113         files = (int *)malloc(nfiles * sizeof (int));
 114         if (files == NULL) {
 115                 return (1);
 116         }
 117
 118         (void) sprintf(fname, "%s/cascade.%ld", optd, getpid());
 119
 120         for (i = 0; i < nfiles; i++) {
 121                 files[i] = open(fname, O_CREAT | O_TRUNC | O_RDWR, 0600);
 122                 if (files[i] == -1) {
 123                         errors++;
 124                 }
 125                 if (unlink(fname)) {
 126                         errors++;
 127                 }
 128         }
 129
 130         return (errors);
 131 }
 132
 133 int
 134 block(int index)
 135 {
 136         return (lockf(files[index], F_LOCK, 0) == -1);
 137 }
 138
 139 int
 140 unblock(int index)
 141 {
 142         return (lockf(files[index], F_ULOCK, 0) == -1);
 143 }
 144
 145 /*
 146  * API-specific code ENDS here
 147  */
 148
 149 int
 150 benchmark_initbatch(void *tsd)
 151 {
 152         tsd_t                   *ts = (tsd_t *)tsd;
 153         int                     e = 0;
 154
 155         if (ts->ts_once == 0) {
 156                 int             us, them;
 157
 158 #if !defined(__APPLE__)
 159         us = (getpindex() * lm_optT) + gettindex();
 160 #else
 161         us = gettsdindex(tsd);
 162 #endif /* __APPLE__ */
 163
 164                 them = (us + 1) % (lm_optP * lm_optT);
 165
 166                 ts->ts_id = us;
 167
 168                 /* lock index asignment for us and them */
 169                 ts->ts_us0 = (us * 2);
 170                 ts->ts_us1 = (us * 2) + 1;
 171                 if (us < nthreads - 1) {
 172                         /* straight-thru connection to them */
 173                         ts->ts_them0 = (them * 2);
 174                         ts->ts_them1 = (them * 2) + 1;
 175                 } else {
 176                         /* cross-over connection to them */
 177                         ts->ts_them0 = (them * 2) + 1;
 178                         ts->ts_them1 = (them * 2);
 179                 }
 180
 181                 ts->ts_once = 1;
 182         }
 183
 184         /* block their first move */
 185         e += block(ts->ts_them0);
 186
 187         return (e);
 188 }
 189
 190 int
 191 benchmark(void *tsd, result_t *res)
 192 {
 193         tsd_t                   *ts = (tsd_t *)tsd;
 194         int                     i;
 195         int                     e = 0;
 196
 197         /* wait to be unblocked (id == 0 will not block) */
 198         e += block(ts->ts_us0);
 199
 200         for (i = 0; i < lm_optB; i += 2) {
 201                 /* allow them to block us again */
 202                 e += unblock(ts->ts_us0);
 203
 204                 /* block their next + 1 move */
 205                 e += block(ts->ts_them1);
 206
 207                 /* unblock their next move */
 208                 e += unblock(ts->ts_them0);
 209
 210                 /* wait for them to unblock us */
 211                 e += block(ts->ts_us1);
 212
 213                 /* repeat with locks reversed */
 214                 e += unblock(ts->ts_us1);
 215                 e += block(ts->ts_them0);
 216                 e += unblock(ts->ts_them1);
 217                 e += block(ts->ts_us0);
 218         }
 219
 220         /* finish batch with nothing blocked */
 221         e += unblock(ts->ts_them0);
 222         e += unblock(ts->ts_us0);
 223
 224         res->re_count = i;
 225         res->re_errors = e;
 226
 227         return (0);
 228 }