Simple little program for populating a filesystem that could look like one DMF might...
[xfstests-dev.git] / src / dmiperf.c
1 /*
2  * Copyright (c) 2006 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #include <sys/param.h>
20 #include <sys/stat.h>
21 #include <sys/time.h>
22 #include <dirent.h>
23 #include <malloc.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <math.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <attr/attributes.h>
32
33 #define MAXNAMELEN 256
34 #ifndef __sgi__
35 typedef unsigned int uint_t;
36 #endif
37
38 /*
39  * Loop over directory sizes:
40  *      make m directories
41  *      touch n files in each directory
42  *      write y bytes to all files in each directory
43  *      set DMF attribute on x files in each directory
44  * Change directory sizes by multiplication or addition.
45  * Allow control of starting & stopping sizes, name length, target directory.
46  * Print size and wallclock time (ms per file).
47  * Output can be used to make graphs (gnuplot)
48  */
49
50 static uint_t   addval;
51 static uint_t   dirchars;
52 static char     *directory;
53 static uint_t   firstsize;
54 static uint_t   lastsize;
55 static uint_t   minchars;
56 static double   mulval;
57 static uint_t   nchars;
58 static uint_t   ndirs;
59 static uint_t   pfxchars;
60 static off64_t  fsize;
61 static char     *buffer;
62 static size_t   bsize;
63
64 static int      mkfile(char *, char *);
65 static void     filename(int, int, char *);
66 static int      hexchars(uint_t);
67 static uint_t   nextsize(uint_t);
68 static double   now(void);
69 static void     usage(void);
70
71 /*
72  * Maximum size allowed, this is pretty nuts.
73  * The largest one we've ever built has been about 2 million.
74  */
75 #define MAX_DIR_SIZE    (16 * 1024 * 1024)
76 #define DFL_FIRST_SIZE  1
77 #define DFL_LAST_SIZE   (1024 * 1024)
78 #define MAX_DIR_COUNT   1024
79 #define MIN_DIR_COUNT   1
80
81 #define DMFATTRLEN      22
82 #define DMFATTRNAME     "SGI_DMI_DMFATTR"
83
84 int
85 main(int argc, char **argv)
86 {
87         int             c;
88         uint_t          cursize;
89         int             i;
90         int             j;
91         char            name[MAXNAMELEN];
92         char            attr[DMFATTRLEN];
93         double          stime;
94
95         while ((c = getopt(argc, argv, "a:b:c:d:f:l:m:n:s:")) != -1) {
96                 switch (c) {
97                 case 'a':
98                         addval = (uint_t)atoi(optarg);
99                         break;
100                 case 'b':
101                         bsize = (size_t)atol(optarg);
102                         break;
103                 case 'c':
104                         nchars = (uint_t)atoi(optarg);
105                         break;
106                 case 'd':
107                         directory = optarg;
108                         break;
109                 case 'f':
110                         firstsize = (uint_t)atoi(optarg);
111                         break;
112                 case 'l':
113                         lastsize = (uint_t)atoi(optarg);
114                         break;
115                 case 'm':
116                         mulval = atof(optarg);
117                         break;
118                 case 'n':
119                         ndirs = (uint_t)atoi(optarg);
120                         break;
121                 case 's':
122                         fsize = (off64_t)atol(optarg);
123                         break;
124                 case '?':
125                 default:
126                         usage();
127                         exit(1);
128                 }
129         }
130         if (!addval && !mulval)
131                 mulval = 2.0;
132         else if ((addval && mulval) || mulval < 0.0) {
133                 usage();
134                 exit(1);
135         }
136         if (!bsize)
137                 bsize = 1024 * 1024;
138         buffer = memalign(getpagesize(), bsize);
139         memset(buffer, 0xfeed, bsize);
140         memset(attr, 0xaaaaaaa, sizeof(attr));
141
142         if (!directory)
143                 directory = ".";
144         else {
145                 if (mkdir(directory, 0777) < 0 && errno != EEXIST) {
146                         perror(directory);
147                         exit(1);
148                 }
149                 if (chdir(directory) < 0) {
150                         perror(directory);
151                         exit(1);
152                 }
153         }
154         if (firstsize == 0)
155                 firstsize = DFL_FIRST_SIZE;
156         else if (firstsize > MAX_DIR_SIZE)
157                 firstsize = MAX_DIR_SIZE;
158         if (lastsize == 0)
159                 lastsize = DFL_LAST_SIZE;
160         else if (lastsize > MAX_DIR_SIZE)
161                 lastsize = MAX_DIR_SIZE;
162         if (lastsize < firstsize)
163                 lastsize = firstsize;
164         minchars = hexchars(lastsize - 1);
165         if (nchars < minchars)
166                 nchars = minchars;
167         else if (nchars >= MAXNAMELEN)
168                 nchars = MAXNAMELEN - 1;
169         if (ndirs > MAX_DIR_COUNT)
170                 ndirs = MAX_DIR_COUNT;
171         if (ndirs < MIN_DIR_COUNT)
172                 ndirs = MIN_DIR_COUNT;
173         dirchars = hexchars(ndirs);
174         pfxchars = nchars - minchars;
175         if (pfxchars)
176                 memset(&name[dirchars + 1], 'a', pfxchars);
177
178         cursize = firstsize;
179         for (j = 0; j < ndirs; j++) {
180                 filename(0, j, name);
181                 name[dirchars] = '\0';
182                 mkdir(name, 0777);
183                 stime = now();
184                 for (i = 0; i < cursize; i++) {
185                         filename((i + j) % cursize, j, name);
186                         close(mkfile(name, attr));
187                 }
188                 printf("%d %.3f\n", cursize,
189                         (now() - stime) * 1.0e3 / (cursize * ndirs));
190                 cursize = nextsize(cursize);
191         }
192         return 0;
193 }
194
195 static int
196 mkfile(char *name, char *attr)
197 {
198         int             fd;
199         ssize_t         wrote, wsize;
200         off64_t         bytes = fsize;
201
202         if ((fd = open(name, O_WRONLY | O_CREAT | O_EXCL | O_DIRECT)) < 0) {
203                 perror("open");
204                 exit(1);
205         }
206         if (attr_setf(fd, DMFATTRNAME, attr, DMFATTRLEN, ATTR_ROOT) < 0) {
207                 perror("attr_setf");
208                 exit(1);
209         }
210         while (bytes > 0) {
211                 wsize = (bsize < bytes) ? bsize : bytes;
212                 if ((wrote = write(fd, buffer, wsize)) < 0) {
213                         perror("write");
214                         exit(1);
215                 }
216                 bytes -= wrote;
217         }
218         return fd;
219 }
220
221 static void
222 filename(int idx, int dir, char *name)
223 {
224         static char     hexc[16] = "0123456789abcdef";
225         int             i;
226
227         for (i = dirchars - 1; i >= 0; i--)
228                 *name++ = hexc[(dir >> (4 * i)) & 0xf];
229         *name++ = '/';
230         name += pfxchars;               /* skip pfx a's */
231         for (i = minchars - 1; i >= 0; i--)
232                 *name++ = hexc[(idx >> (4 * i)) & 0xf];
233         *name = '\0';
234 }
235
236 static int
237 hexchars(uint_t maxval)
238 {
239         if (maxval < 16)
240                 return 1;
241         if (maxval < 16 * 16)
242                 return 2;
243         if (maxval < 16 * 16 * 16)
244                 return 3;
245         if (maxval < 16 * 16 * 16 * 16)
246                 return 4;
247         if (maxval < 16 * 16 * 16 * 16 * 16)
248                 return 5;
249         if (maxval < 16 * 16 * 16 * 16 * 16 * 16)
250                 return 6;
251         if (maxval < 16 * 16 * 16 * 16 * 16 * 16 * 16)
252                 return 7;
253         return 8;
254 }
255
256 static uint_t
257 nextsize(uint_t cursize)
258 {
259         double  n;
260
261         n = cursize;
262         if (addval)
263                 n += addval;
264         else
265                 n *= mulval;
266         if (n > (double)lastsize + 0.5)
267                 return lastsize + 1;    /* i.e. out of bounds */
268         else if ((uint_t)n == cursize)
269                 return cursize + 1;
270         else
271                 return (uint_t)n;
272 }
273
274 static double
275 now(void)
276 {
277         struct timeval  tv;
278
279         gettimeofday(&tv, NULL);
280         return (double)tv.tv_sec + 1.0e-6 * (double)tv.tv_usec;
281 }
282
283 static void
284 usage(void)
285 {
286         fprintf(stderr,
287                 "usage: dirperf [-d dir] [-a addstep | -m mulstep] [-f first] "
288                 "[-l last] [-c nchars] [-n ndirs] [-s size]\n");
289 }