robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Copyright (c) International Business Machines Corp., 2002 |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation; either version 2 of the License, or |
| 8 | * (at your option) any later version. |
| 9 | * |
| 10 | * This program is distributed in the hope that it will be useful, |
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| 13 | * the GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, write to the Free Software |
Wanlong Gao | 4548c6c | 2012-10-19 18:03:36 +0800 | [diff] [blame] | 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
| 20 | /* Group Bull & IBM Corporation */ |
| 21 | /* 11/20/2002 Port to LTP robbiew@us.ibm.com */ |
| 22 | /* jacky.malcles@bull.net */ |
| 23 | /* IBM Corporation */ |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 24 | /* 06/30/2001 Port to Linux nsharoff@us.ibm.com */ |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 25 | |
| 26 | /* |
| 27 | * fptest02.c -- Floating point test. |
| 28 | * |
| 29 | * This is similar to fptest1. Random values are used for some of the |
| 30 | * math in routine "gauss". The value "avgspd" computed in routine |
| 31 | * "term()" should come out to a known value. If this happens this |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 32 | * program prints a "passed" message and exits 0, otherwise a "failed" |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 33 | * message is printed and it exits with value 1. |
| 34 | * |
| 35 | */ |
| 36 | |
| 37 | #include <stdio.h> |
robbiew | a70576c | 2003-03-04 18:33:41 +0000 | [diff] [blame] | 38 | #include <errno.h> |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 39 | #include <math.h> |
| 40 | #include <stdlib.h> |
| 41 | #include <unistd.h> |
| 42 | #include <sys/types.h> |
| 43 | #include <sys/stat.h> |
| 44 | #include <fcntl.h> |
| 45 | #include <time.h> |
| 46 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 47 | #define MAGIC 0.777807 |
| 48 | #define DIFF 0.001 |
| 49 | #define EVENTMX 256 |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 50 | #define BIG 1.e50 |
| 51 | #define FALSE 0 |
| 52 | #define TRUE 1 |
| 53 | #define TRYCRIT 1 |
| 54 | #define ENTERCRIT 2 |
| 55 | #define LEAVECRIT 3 |
| 56 | #define ATBARRIER 4 |
| 57 | #define ENTERWORK 5 |
| 58 | #define LEAVEWORK 6 |
| 59 | #define NULLEVENT 999 |
| 60 | |
| 61 | /** LTP Port **/ |
| 62 | #include "test.h" |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 63 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 64 | char *TCID = "fptest02"; /* Test program identifier. */ |
| 65 | int TST_TOTAL = 1; /* Total number of test cases. */ |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 66 | /**************/ |
| 67 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 68 | int init(); |
| 69 | int doevent(); |
| 70 | int term(); |
| 71 | int addevent(); |
| 72 | |
| 73 | void gaussinit(); |
| 74 | double gauss(); |
| 75 | |
| 76 | struct event { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 77 | int proc; |
| 78 | int type; |
| 79 | double time; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 80 | }; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 81 | |
| 82 | struct event eventtab[EVENTMX]; |
| 83 | struct event rtrevent; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 84 | int waiting[EVENTMX]; /* array of waiting processors */ |
| 85 | int nwaiting; /* number of waiting processors */ |
| 86 | double sgtime; /* global clock */ |
| 87 | double lsttime; /* time used for editing */ |
| 88 | double dtc, dts, alpha; /* timing parameters */ |
| 89 | int nproc; /* number of processors */ |
| 90 | int barcnt; /* number of processors ATBARRIER */ |
| 91 | int ncycle; /* number of cycles completed */ |
| 92 | int ncycmax; /* number of cycles to run */ |
| 93 | int critfree; /* TRUE if critical section not occupied */ |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 94 | |
| 95 | struct event *nextevent(); |
| 96 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 97 | int main(argc, argv) |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 98 | int argc; |
| 99 | char *argv[]; |
| 100 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 101 | struct event *ev; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 102 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 103 | nproc = 128; |
| 104 | ncycmax = 10; |
| 105 | dtc = 0.01; |
| 106 | dts = 0.0; |
| 107 | alpha = 0.1; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 108 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 109 | init(); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 110 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 111 | while ((ev = nextevent()) != NULL) { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 112 | doevent(ev); |
| 113 | } |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 114 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 115 | term(); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 116 | tst_resm(TPASS, "PASS"); |
Garrett Cooper | 4b20b1d | 2010-12-18 01:06:11 -0800 | [diff] [blame] | 117 | tst_exit(); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 121 | initialize all processes to "entering work section" |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 122 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 123 | int init() |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 124 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 125 | int p; |
| 126 | double dtw, dtwsig; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 127 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 128 | ncycle = 0; |
| 129 | sgtime = 0; |
| 130 | lsttime = 0; |
| 131 | barcnt = 0; |
| 132 | nwaiting = 0; |
| 133 | critfree = TRUE; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 134 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 135 | dtw = 1. / nproc; /* mean process work time */ |
| 136 | dtwsig = dtw * alpha; /* std deviation of work time */ |
| 137 | gaussinit(dtw, dtwsig, time(0)); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 138 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 139 | for (p = 1; p <= nproc; p++) { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 140 | eventtab[p].type = NULLEVENT; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 141 | } |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 142 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 143 | for (p = 1; p <= nproc; p++) { |
| 144 | addevent(ENTERWORK, p, sgtime); |
| 145 | } |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 146 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 147 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 148 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 149 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 150 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 151 | print edit quantities |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 152 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 153 | int term() |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 154 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 155 | double avgspd; |
| 156 | double v; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 157 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 158 | avgspd = ncycle / sgtime; |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 159 | v = avgspd - MAGIC; |
| 160 | if (v < 0.0) |
| 161 | v *= -1.0; |
| 162 | if (v > DIFF) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 163 | tst_resm(TFAIL, "FAIL"); |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 164 | v = avgspd - MAGIC; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 165 | tst_resm(TINFO, "avgspd = %.15f\n", avgspd); |
| 166 | tst_resm(TINFO, "expected %.15f\n", MAGIC); |
| 167 | tst_resm(TINFO, "diff = %.15f\n", v); |
Garrett Cooper | 4b20b1d | 2010-12-18 01:06:11 -0800 | [diff] [blame] | 168 | tst_exit(); |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 169 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 170 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 171 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 172 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 173 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 174 | add an event to the event queue |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 175 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 176 | int addevent(type, proc, t) |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 177 | int type, proc; |
| 178 | double t; |
| 179 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 180 | int i; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 181 | int ok = FALSE; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 182 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 183 | for (i = 1; i <= nproc; i++) { |
| 184 | if (eventtab[i].type == NULLEVENT) { |
| 185 | eventtab[i].type = type; |
| 186 | eventtab[i].proc = proc; |
| 187 | eventtab[i].time = t; |
| 188 | ok = TRUE; |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 189 | break; |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 190 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 191 | } |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 192 | if (ok) |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 193 | return (0); |
Garrett Cooper | 4b20b1d | 2010-12-18 01:06:11 -0800 | [diff] [blame] | 194 | else |
| 195 | tst_brkm(TBROK, NULL, "No room for event"); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 196 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 197 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 198 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 199 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 200 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 201 | get earliest event in event queue |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 202 | */ |
| 203 | struct event *nextevent() |
| 204 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 205 | double mintime = BIG; |
| 206 | int imin = 0; |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 207 | int i; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 208 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 209 | for (i = 1; i <= nproc; i++) { |
| 210 | if ((eventtab[i].type != NULLEVENT) |
| 211 | && (eventtab[i].time < mintime)) { |
| 212 | imin = i; |
| 213 | mintime = eventtab[i].time; |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 214 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 215 | } |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 216 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 217 | if (imin) { |
| 218 | rtrevent.type = eventtab[imin].type; |
| 219 | rtrevent.proc = eventtab[imin].proc; |
| 220 | rtrevent.time = eventtab[imin].time; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 221 | eventtab[imin].type = NULLEVENT; |
| 222 | return (&rtrevent); |
| 223 | } else |
Cyril Hrubis | cf0d626 | 2014-09-23 14:03:31 +0200 | [diff] [blame] | 224 | return (NULL); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 225 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 226 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 227 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 228 | add a processor to the waiting queue |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 229 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 230 | int addwaiting(p) |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 231 | int p; |
| 232 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 233 | waiting[++nwaiting] = p; |
| 234 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 235 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 236 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 237 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 238 | remove the next processor from the waiting queue |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 239 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 240 | int getwaiting() |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 241 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 242 | if (nwaiting) |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 243 | return (waiting[nwaiting--]); |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 244 | else |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 245 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 246 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 247 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 248 | double dtcrit() |
| 249 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 250 | return (dtc); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 251 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 252 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 253 | double dtspinoff() |
| 254 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 255 | return (dts); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 256 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 257 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 258 | double dtwork() |
| 259 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 260 | return (gauss()); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 261 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 262 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 263 | /* |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 264 | take the action prescribed by 'ev', update the clock, and |
| 265 | generate any subsequent events |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 266 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 267 | int doevent(ev) |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 268 | struct event *ev; |
| 269 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 270 | double nxttime; |
| 271 | int i, p, proc; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 272 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 273 | sgtime = ev->time; |
| 274 | proc = ev->proc; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 275 | |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 276 | switch (ev->type) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 277 | case TRYCRIT: |
| 278 | if (critfree == TRUE) |
| 279 | addevent(ENTERCRIT, proc, sgtime); |
| 280 | else |
| 281 | addwaiting(proc); |
| 282 | break; |
| 283 | case ENTERCRIT: |
| 284 | critfree = FALSE; |
| 285 | nxttime = sgtime + dtcrit(); |
| 286 | addevent(LEAVECRIT, proc, nxttime); |
| 287 | break; |
| 288 | case LEAVECRIT: |
| 289 | critfree = TRUE; |
| 290 | addevent(ATBARRIER, proc, sgtime); |
| 291 | if ((p = getwaiting()) != 0) { |
| 292 | nxttime = sgtime; |
| 293 | addevent(ENTERCRIT, p, nxttime); |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 294 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 295 | break; |
| 296 | case ATBARRIER: |
| 297 | barcnt++; |
| 298 | if (barcnt == nproc) { |
| 299 | nxttime = sgtime; |
| 300 | for (i = 1; i <= nproc; i++) { |
| 301 | nxttime += dtspinoff(); |
| 302 | addevent(ENTERWORK, i, nxttime); |
| 303 | } |
| 304 | barcnt = 0; |
| 305 | ncycle++; |
| 306 | } |
| 307 | break; |
| 308 | case ENTERWORK: |
| 309 | nxttime = sgtime + dtwork(); |
| 310 | if (ncycle < ncycmax) |
| 311 | addevent(LEAVEWORK, proc, nxttime); |
| 312 | break; |
| 313 | case LEAVEWORK: |
| 314 | addevent(TRYCRIT, proc, sgtime); |
| 315 | break; |
| 316 | default: |
| 317 | tst_brkm(TBROK, NULL, "Illegal event"); |
| 318 | break; |
| 319 | } |
| 320 | return (0); |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 321 | } |
| 322 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 323 | static int alternator = 1; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 324 | static double mean; |
| 325 | static double stdev; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 326 | static double u1, u2; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 327 | static double twopi; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 328 | static double rnorm = 2147483647; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 329 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 330 | void gaussinit(m, s, seed) |
| 331 | double m, s; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 332 | int seed; |
| 333 | { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 334 | srand48(seed); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 335 | mean = m; |
| 336 | stdev = s; |
| 337 | twopi = 2. * acos((double)-1.0); |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 338 | return; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 339 | } |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 340 | |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 341 | double gauss() |
| 342 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 343 | double x1, x2; |
robbiew | bd00249 | 2002-12-04 22:01:15 +0000 | [diff] [blame] | 344 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 345 | if (alternator == 1) { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 346 | alternator = -1; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 347 | u1 = lrand48() / rnorm; |
| 348 | u2 = lrand48() / rnorm; |
| 349 | x1 = sqrt(-2.0 * log(u1)) * cos(twopi * u2); |
| 350 | return (mean + stdev * x1); |
| 351 | } else { |
robbiew | 4b26447 | 2003-04-25 18:22:45 +0000 | [diff] [blame] | 352 | alternator = 1; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 353 | x2 = sqrt(-2.0 * log(u1)) * sin(twopi * u2); |
| 354 | return (mean + stdev * x2); |
| 355 | } |
Chris Dearman | ec6edca | 2012-10-17 19:54:01 -0700 | [diff] [blame] | 356 | } |