tuxload - Enhace tuxload a bit.
[dragonfly.git] / test / stress / tuxload.c
1 /*
2  * TUXLOAD.C
3  *
4  * (c)Copyright 2012 Antonio Huete Jimenez <tuxillo@quantumachine.net>,
5  *    this code is hereby placed in the public domain.
6  *
7  * As a safety the directory 'tmpfiles/' must exist.  This program will
8  * create 500 x 8MB files in tmpfiles/*, memory map the files MAP_SHARED,
9  * R+W, make random modifications, and msync() in a loop.
10  *
11  * The purpose is to stress the VM system.
12  *
13  */
14 #include <stdio.h>
15 #include <unistd.h>
16 #include <fcntl.h>
17 #include <stdlib.h>
18 #include <sys/mman.h>
19 #include <sys/stat.h>
20 #include <err.h>
21 #include <errno.h>
22
23 static void randomfill(int fd);
24 static int mmap01(void *);
25 static int mmap02(void *);
26 static int build_files(void);
27
28 int opt_verbose;
29 int opt_testno;
30 int opt_nofiles;
31 int opt_mbfile;
32 int opt_count;
33 int fliparg;
34
35 int *fd;
36 struct stat *st;
37 char **pp;
38
39 static const struct test {
40         char testdesc[128];
41         int (*testfn)(void *);
42 } testlist[] = {
43         { "mmap01 - Massive mmap / msync (flushing all pages)", mmap01 },
44         { "mmap02 - Massive mmap / msync (flushing only specified pages)", mmap02 },
45         { "", NULL }
46 };
47
48 static int
49 mmap01(void *arg)
50 {
51         int i;
52         int *bug = arg;
53         long jump;
54         size_t size, len;
55
56         if ((build_files()) != 0)
57                 err(1, "Failed to create the files");
58
59         if (opt_verbose)
60                 printf("\n");
61
62         for (i = 0; i <  opt_nofiles; i++) {
63
64                 if (opt_verbose) {
65                         fflush(stdout);
66                         fprintf(stdout, "\rDoing mmap() + msync() [%d/%d] ", i+1, opt_nofiles);
67                 }
68                 size = st[i].st_size;
69                 pp[i] = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd[i], 0);
70                 if (pp[i] == MAP_FAILED)
71                         err(1, "mmap");
72
73                 for (jump = 0; jump < size; jump += 65535) {
74                         pp[i][jump] = jump + i;
75                 }
76
77                 if (fliparg)
78                         len = MS_SYNC;
79                 else
80                         len = 0;
81
82                 if ((msync(pp[i], len, MS_SYNC)) == -1) {
83                         printf("fd %d %p\n", fd[i], pp[i]);
84                         err(1, "msync");
85
86                 }
87         }
88         printf("\n");
89
90         return 0;
91 }
92
93 static int
94 mmap02(void *arg)
95 {
96         fliparg = 1;
97         mmap01(&fliparg);
98
99         return 0;
100 }
101
102 static void
103 usage(void)
104 {
105         int i;
106         const struct test *tp;
107
108         printf("tuxload: [-v] [-c count] [-m megs_per_file] [-n no_of_files] [-t test_to_run] \n"
109             "Available tests: \n");
110
111         for (tp = testlist; tp->testfn != NULL; tp++)
112                 printf("\t%s\n", tp->testdesc);
113         exit(1);
114 }
115
116 int
117 main(int argc, char *argv[])
118 {
119         int forever;
120         char c;
121
122         opt_verbose = opt_testno = 0;
123         opt_nofiles = 500;
124         opt_mbfile = 8;
125         opt_count = 1;
126         fliparg = 0;
127         forever = 0;
128
129         while ((c = getopt(argc, argv, "n:t:m:c:v")) != -1) {
130                 switch(c) {
131                 case 'v':
132                         opt_verbose++;
133                         break;
134                 case 'n':
135                         opt_nofiles = (int)strtol(optarg, NULL, 0);
136                         break;
137                 case 't':
138                         opt_testno = (int)strtol(optarg, NULL, 0);
139                         opt_testno--;
140                         break;
141                 case 'm':
142                         opt_mbfile = (int)strtol(optarg, NULL, 0);
143                         break;
144                 case 'c':
145                         opt_count = (int)strtol(optarg, NULL, 0);
146                         if (opt_count == 0)
147                                 forever++;
148                         break;
149                 default:
150                         usage();
151                         ;
152                 }
153         }
154         argc -= optind;
155         argv += optind;
156
157         if (argc != 0)
158                 usage();
159
160         st = malloc(opt_nofiles * sizeof(*st));
161         fd = malloc(opt_nofiles * sizeof(*fd));
162         pp = malloc(opt_nofiles * sizeof(*pp));
163
164         while (opt_count-- || forever)
165                 testlist[opt_testno].testfn(0);
166
167         return 0;
168 }
169
170 static int
171 build_files(void)
172 {
173         char name[128];
174         int i;
175         int error;
176
177         for (i = 0, error = 0; i <  opt_nofiles; i++) {
178                 snprintf(name, 128, "tmpfiles/file%d", i);
179                 if ((fd[i] = open(name, O_RDWR)) < 1) {
180                         if ((fd[i] = open(name, O_RDWR | O_CREAT, 0644)) < 1) {
181                                 error = errno;
182                                 break;
183                         }
184                         randomfill(fd[i]);
185                 }
186                 if ((fstat(fd[i], &st[i])) == -1) {
187                         error = errno;
188                         break;
189                 }
190                 if (opt_verbose) {
191                         fprintf(stdout, "\rFile creation, random data filled [%d/%d] ", i+1, opt_nofiles);
192                         fflush(stdout);
193                 }
194         }
195
196         return error;
197 }
198
199 static void
200 randomfill(int fd)
201 {
202         char buf[32768];
203         long tot;
204         int i;
205
206         srandomdev();
207         tot = opt_mbfile * 1024L;
208         for (i = 0; i < 32768; ++i)
209                 buf[i] = random();
210         for (i = 0; i < tot; i += 32)   /* 8MB by default */
211                 write(fd, buf, 32768);
212         fsync(fd);
213         lseek(fd, 0L, 0);
214 }