/*
- Copyright (C) by Andrew Tridgell <tridge@samba.org> 1999, 2001
+ Copyright (C) by Andrew Tridgell <tridge@samba.org> 1999-2007
Copyright (C) 2001 by Martin Pool <mbp@samba.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/* TODO: We could try allowing for different flavours of synchronous
can choose what kind it wants for each OPEN operation. */
#include "dbench.h"
+#include "popt.h"
#include <sys/sem.h>
-int sync_open = 0, sync_dirs = 0;
-char *tcp_options = TCP_OPTIONS;
-static int timelimit = 600, warmup;
-static const char *directory = ".";
-static char *loadfile = DATADIR "/client.txt";
+struct options options = {
+ .timelimit = 600,
+ .loadfile = DATADIR "/client.txt",
+ .directory = ".",
+ .tcp_options = TCP_OPTIONS,
+ .nprocs = 10,
+ .sync_open = 0,
+ .sync_dirs = 0,
+ .do_fsync = 0,
+ .fsync_frequency = 0,
+ .warmup = -1,
+ .targetrate = 0.0,
+ .ea_enable = 0,
+ .clients_per_process = 1,
+ .server = "localhost",
+};
+
static struct timeval tv_start;
static struct timeval tv_end;
static int barrier=-1;
-double targetrate;
-
-#if HAVE_EA_SUPPORT
-int ea_enable=0;
-#endif
+static double throughput;
static FILE *open_loadfile(void)
{
FILE *f;
- if ((f = fopen(loadfile, "rt")) != NULL)
+ if ((f = fopen(options.loadfile, "rt")) != NULL)
return f;
fprintf(stderr,
- "dbench: error opening '%s': %s\n", loadfile,
+ "dbench: error opening '%s': %s\n", options.loadfile,
strerror(errno));
return NULL;
double total_bytes = 0;
int total_lines = 0;
int i;
- int nprocs = children[0].nprocs;
+ int nclients = options.nprocs * options.clients_per_process;
int in_warmup = 0;
double t;
static int in_cleanup;
-
+ double latency;
+ struct timeval tnow;
+ int num_active = 0;
+ int num_finished = 0;
(void)sig;
- for (i=0;i<nprocs;i++) {
+ tnow = timeval_current();
+
+ for (i=0;i<nclients;i++) {
total_bytes += children[i].bytes - children[i].bytes_done_warmup;
if (children[i].bytes == 0) {
in_warmup = 1;
+ } else {
+ num_active++;
}
total_lines += children[i].line;
+ if (children[i].cleanup_finished) {
+ num_finished++;
+ }
}
t = timeval_elapsed(&tv_start);
- if (!in_warmup && warmup>0 && t > warmup) {
- tv_start = timeval_current();
- warmup = 0;
- for (i=0;i<nprocs;i++) {
+ if (!in_warmup && options.warmup>0 && t > options.warmup) {
+ tv_start = tnow;
+ options.warmup = 0;
+ for (i=0;i<nclients;i++) {
children[i].bytes_done_warmup = children[i].bytes;
+ children[i].worst_latency = 0;
+ memset(&children[i].op, 0, sizeof(children[i].op));
}
goto next;
}
- if (t < warmup) {
+ if (t < options.warmup) {
in_warmup = 1;
- } else if (!in_warmup && !in_cleanup && t > timelimit) {
- for (i=0;i<nprocs;i++) {
+ } else if (!in_warmup && !in_cleanup && t > options.timelimit) {
+ for (i=0;i<nclients;i++) {
children[i].done = 1;
}
- tv_end = timeval_current();
+ tv_end = tnow;
in_cleanup = 1;
}
if (t < 1) {
goto next;
}
+ latency = 0;
+ if (!in_cleanup) {
+ for (i=0;i<nclients;i++) {
+ latency = MAX(children[i].max_latency, latency);
+ latency = MAX(latency, timeval_elapsed2(&children[i].lasttime, &tnow));
+ children[i].max_latency = 0;
+ if (latency > children[i].worst_latency) {
+ children[i].worst_latency = latency;
+ }
+ }
+ }
+
if (in_warmup) {
- printf("%4d %8d %7.2f MB/sec warmup %3.0f sec \n",
- nprocs, total_lines/nprocs,
- 1.0e-6 * total_bytes / t, t);
+ printf("%4d %8d %7.2f MB/sec warmup %3.0f sec latency %.03f ms\n",
+ num_active, total_lines/nclients,
+ 1.0e-6 * total_bytes / t, t, latency*1000);
} else if (in_cleanup) {
- printf("%4d %8d %7.2f MB/sec cleanup %3.0f sec \n",
- nprocs, total_lines/nprocs,
- 1.0e-6 * total_bytes / t, t);
+ printf("%4d cleanup %3.0f sec\n", nclients - num_finished, t);
} else {
- printf("%4d %8d %7.2f MB/sec execute %3.0f sec \n",
- nprocs, total_lines/nprocs,
- 1.0e-6 * total_bytes / t, t);
+ printf("%4d %8d %7.2f MB/sec execute %3.0f sec latency %.03f ms\n",
+ nclients, total_lines/nclients,
+ 1.0e-6 * total_bytes / t, t, latency*1000);
+ throughput = 1.0e-6 * total_bytes / t;
}
fflush(stdout);
alarm(PRINT_FREQ);
}
+
+static const struct {
+ const char *name;
+ size_t offset;
+} op_names[] = {
+#define OP_NAME(opname) { #opname, offsetof(struct opnames, op_ ## opname) }
+ OP_NAME(NTCreateX),
+ OP_NAME(Close),
+ OP_NAME(Rename),
+ OP_NAME(Unlink),
+ OP_NAME(Deltree),
+ OP_NAME(Rmdir),
+ OP_NAME(Mkdir),
+ OP_NAME(Qpathinfo),
+ OP_NAME(Qfileinfo),
+ OP_NAME(Qfsinfo),
+ OP_NAME(Sfileinfo),
+ OP_NAME(Find),
+ OP_NAME(WriteX),
+ OP_NAME(ReadX),
+ OP_NAME(LockX),
+ OP_NAME(UnlockX),
+ OP_NAME(Flush),
+};
+
+static void report_latencies(void)
+{
+ struct opnames sum;
+ int i, j, n = (sizeof(op_names)/sizeof(op_names[0]));
+ struct op *op1, *op2;
+ struct child_struct *child;
+
+ memset(&sum, 0, sizeof(sum));
+ for (i=0;i<n;i++) {
+ op1 = (struct op *)(op_names[i].offset + (char *)&sum);
+ for (j=0;j<options.nprocs * options.clients_per_process;j++) {
+ child = &children[j];
+ op2 = (struct op *)(op_names[i].offset + (char *)&child->op);
+ op1->count += op2->count;
+ op1->total_time += op2->total_time;
+ op1->max_latency = MAX(op1->max_latency, op2->max_latency);
+ }
+ }
+ printf(" Operation Count AvgLat MaxLat\n");
+ printf(" ----------------------------------------\n");
+ for (i=0;i<n;i++) {
+ op1 = (struct op *)(op_names[i].offset + (char *)&sum);
+ if (op1->count == 0) continue;
+ printf(" %-12s %7u %9.03f %9.03f\n",
+ op_names[i].name, op1->count,
+ 1000*op1->total_time/op1->count,
+ op1->max_latency*1000);
+ }
+ printf("\n");
+}
+
/* this creates the specified number of child processes and runs fn()
in all of them */
static void create_procs(int nprocs, void (*fn)(struct child_struct *, const char *))
{
+ int nclients = nprocs * options.clients_per_process;
int i, status;
int synccount;
struct timeval tv;
return;
}
- children = shm_setup(sizeof(struct child_struct)*nprocs);
+ children = shm_setup(sizeof(struct child_struct)*nclients);
if (!children) {
printf("Failed to setup shared memory\n");
return;
}
- memset(children, 0, sizeof(*children)*nprocs);
+ memset(children, 0, sizeof(*children)*nclients);
- for (i=0;i<nprocs;i++) {
+ for (i=0;i<nclients;i++) {
children[i].id = i;
- children[i].nprocs = nprocs;
children[i].cleanup = 0;
- children[i].directory = directory;
+ children[i].directory = options.directory;
+ children[i].starttime = timeval_current();
+ children[i].lasttime = timeval_current();
}
if (atexit(sem_cleanup) != 0) {
for (i=0;i<nprocs;i++) {
if (fork() == 0) {
+ int j;
+
setlinebuf(stdout);
- nb_setup(&children[i]);
- sbuf.sem_op = 0;
+ for (j=0;j<options.clients_per_process;j++) {
+ nb_setup(&children[i*options.clients_per_process + j]);
+ }
+
+ sbuf.sem_op = 0;
if (semop(barrier, &sbuf, 1) == -1) {
printf("failed to use the barrier semaphore in child %d\n",getpid());
exit(1);
semctl(barrier,0,IPC_RMID);
- fn(&children[i], loadfile);
+ fn(&children[i*options.clients_per_process], options.loadfile);
_exit(0);
}
}
do {
synccount = semctl(barrier,0,GETZCNT);
t = timeval_elapsed(&tv);
- printf("%d of %d clients prepared for launch %3.0f sec\n", synccount, nprocs, t);
+ printf("%d of %d processes prepared for launch %3.0f sec\n", synccount, nprocs, t);
if (synccount == nprocs) break;
usleep(100*1000);
} while (timeval_elapsed(&tv) < 30);
sig_alarm(SIGALRM);
printf("\n");
+
+ report_latencies();
}
" -c loadfile set location of the loadfile\n" \
" -R target rate (MByte/sec)\n" \
" -s synchronous file IO\n" \
+ " -F fsync on write\n" \
" -S synchronous directories (mkdir, unlink...)\n" \
" -x enable EA support\n" \
" -T options set socket options for tbench\n");
-static int process_opts(int argc, char **argv,
- int *nprocs)
+static int process_opts(int argc, const char **argv)
{
- int c;
- extern int sync_open;
- extern char *server;
-
- targetrate = 0;
-
- while ((c = getopt(argc, argv, "vc:sST:t:xD:R:")) != -1)
- switch (c) {
- case 'c':
- loadfile = optarg;
- break;
- case 's':
- sync_open = 1;
- break;
- case 'S':
- sync_dirs = 1;
- break;
- case 'T':
- tcp_options = optarg;
- break;
- case 't':
- timelimit = atoi(optarg);
- break;
- case 'D':
- directory = optarg;
- break;
- case 'v':
- exit(0);
- break;
- case 'R':
- targetrate = strtod(optarg, NULL);
- break;
- case 'x':
-
-#if HAVE_EA_SUPPORT
- ea_enable = 1;
-#else
- printf("EA suppport not compiled in\n");
- exit(1);
-#endif
- break;
- case '?':
- if (isprint (optopt))
- fprintf (stderr, "Unknown option `-%c'.\n", optopt);
- else
- fprintf (stderr,
- "Unknown option character `\\x%x'.\n",
- optopt);
- return 0;
+ const char **extra_argv;
+ int extra_argc = 0;
+ struct poptOption popt_options[] = {
+ POPT_AUTOHELP
+ { "timelimit", 't', POPT_ARG_INT, &options.timelimit, 0,
+ "timelimit", "integer" },
+ { "loadfile", 'c', POPT_ARG_STRING, &options.loadfile, 0,
+ "loadfile", "filename" },
+ { "directory", 'D', POPT_ARG_STRING, &options.directory, 0,
+ "working directory", NULL },
+ { "tcp-options", 'T', POPT_ARG_STRING, &options.tcp_options, 0,
+ "TCP socket options", NULL },
+ { "target-rate", 'R', POPT_ARG_DOUBLE, &options.targetrate, 0,
+ "target throughput (MB/sec)", NULL },
+ { "sync", 's', POPT_ARG_NONE, &options.sync_open, 0,
+ "use O_SYNC", NULL },
+ { "sync-dir", 'S', POPT_ARG_NONE, &options.sync_dirs, 0,
+ "sync directory changes", NULL },
+ { "fsync", 'F', POPT_ARG_NONE, &options.do_fsync, 0,
+ "fsync on write", NULL },
+ { "xattr", 'x', POPT_ARG_NONE, &options.ea_enable, 0,
+ "use xattrs", NULL },
+ { "no-resolve", 0, POPT_ARG_NONE, &options.no_resolve, 0,
+ "disable name resolution simulation", NULL },
+ { "clients-per-process", 0, POPT_ARG_INT, &options.clients_per_process, 0,
+ "number of clients per process", NULL },
+ { "one-byte-write-fix", 0, POPT_ARG_NONE, &options.one_byte_write_fix, 0,
+ "try to fix 1 byte writes", NULL },
+ { "stat-check", 0, POPT_ARG_NONE, &options.stat_check, 0,
+ "check for pointless calls with stat", NULL },
+ { "fake-io", 0, POPT_ARG_NONE, &options.fake_io, 0,
+ "fake up read/write calls", NULL },
+ POPT_TABLEEND
+ };
+ poptContext pc;
+ int opt;
+
+ pc = poptGetContext(argv[0], argc, argv, popt_options, POPT_CONTEXT_KEEP_FIRST);
+
+ while ((opt = poptGetNextOpt(pc)) != -1) {
+ switch (opt) {
default:
- abort ();
+ fprintf(stderr, "Invalid option %s: %s\n",
+ poptBadOption(pc, 0), poptStrerror(opt));
+ exit(1);
}
+ }
+
+ /* setup the remaining options for the main program to use */
+ extra_argv = poptGetArgs(pc);
+ if (extra_argv) {
+ extra_argv++;
+ while (extra_argv[extra_argc]) extra_argc++;
+ }
+
+ if (extra_argc < 1) {
+ printf("You need to specify NPROCS\n");
+ poptPrintHelp(pc, stdout, 0);
+ exit(1);
+ }
+
+#ifndef HAVE_EA_SUPPORT
+ if (options.ea_enable) {
+ printf("EA suppport not compiled in\n");
+ exit(1);
+ }
+#endif
- if (!argv[optind])
- return 0;
-
- *nprocs = atoi(argv[optind++]);
+ options.nprocs = atoi(extra_argv[0]);
- if (argv[optind])
- server = argv[optind++];
+ if (extra_argc >= 2) {
+ options.server = extra_argv[1];
+ }
return 1;
}
- int main(int argc, char *argv[])
+ int main(int argc, const char *argv[])
{
- int nprocs;
double total_bytes = 0;
- double t;
+ double t, latency=0;
int i;
+ setlinebuf(stdout);
+
printf("dbench version %s - Copyright Andrew Tridgell 1999-2004\n\n", VERSION);
- if (!process_opts(argc, argv, &nprocs))
+ if (!process_opts(argc, argv))
show_usage();
- warmup = timelimit / 5;
+ if (options.warmup == -1) {
+ options.warmup = options.timelimit / 5;
+ }
printf("Running for %d seconds with load '%s' and minimum warmup %d secs\n",
- timelimit, loadfile, warmup);
+ options.timelimit, options.loadfile, options.warmup);
- create_procs(nprocs, child_run);
+ create_procs(options.nprocs, child_run);
- for (i=0;i<nprocs;i++) {
+ for (i=0;i<options.nprocs*options.clients_per_process;i++) {
total_bytes += children[i].bytes - children[i].bytes_done_warmup;
+ latency = MAX(latency, children[i].worst_latency);
}
t = timeval_elapsed2(&tv_start, &tv_end);
- printf("Throughput %g MB/sec%s%s %d procs\n",
- 1.0e-6 * total_bytes / t,
- sync_open ? " (sync open)" : "",
- sync_dirs ? " (sync dirs)" : "", nprocs);
+ printf("Throughput %g MB/sec%s%s %d clients %d procs max_latency=%.03f ms\n",
+ throughput,
+ options.sync_open ? " (sync open)" : "",
+ options.sync_dirs ? " (sync dirs)" : "",
+ options.nprocs*options.clients_per_process,
+ options.nprocs, latency*1000);
return 0;
}