← Back to branch summary

~ubuntu-branches/ubuntu/vivid/cctools/vivid

« back to all changes in this revision

Viewing changes to dttools/src/microbench.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Hanke
  • Date: 2011-05-07 09:05:00 UTC
  • Revision ID: james.westby@ubuntu.com-20110507090500-lqpmdtwndor6e7os
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
dttools/src/microbench.c
 
1
/*
 
2
Copyright (C) 2009- The University of Notre Dame
 
3
This software is distributed under the GNU General Public License.
 
4
See the file COPYING for details.
 
5
*/
 
6
 
 
7
#include "timer.h"
 
8
 
 
9
#include <errno.h>
 
10
#include <stdio.h>
 
11
#include <stdlib.h>
 
12
#include <string.h>
 
13
 
 
14
#include <sys/types.h>
 
15
#include <sys/stat.h>
 
16
#include <fcntl.h>
 
17
#include <unistd.h>
 
18
 
 
19
enum {
 
20
        OP_STAT,
 
21
        OP_OPEN,
 
22
        OP_WRITE,
 
23
        OP_READ,
 
24
        OP_FSYNC,
 
25
        OP_CLOSE,
 
26
        NOPS
 
27
};
 
28
 
 
29
#define BUFFER_SIZE 8192
 
30
 
 
31
const char *OP_STRINGS[NOPS] = { "stat ", "open ", "write", "read ", "fsync", "close" };
 
32
 
 
33
static int OPEN_FLAGS = O_RDONLY;
 
34
 
 
35
static void show_help(const char *cmd)
 
36
{
 
37
        printf("Use: %s <path> <runs> [write]\n", cmd);
 
38
}
 
39
 
 
40
static void do_stat(const char *path)
 
41
{
 
42
        struct stat buf;
 
43
        int result;
 
44
 
 
45
        timer_start(OP_STAT); 
 
46
        result = stat(path, &buf);
 
47
        timer_stop(OP_STAT);
 
48
 
 
49
        if (result < 0) {
 
50
                printf("could not stat %s: %s\n", path, strerror(errno));
 
51
                exit(EXIT_FAILURE);
 
52
        }
 
53
}
 
54
 
 
55
static void do_open(const char *path, int *fd)
 
56
{
 
57
        timer_start(OP_OPEN); 
 
58
        *fd = open(path, OPEN_FLAGS);
 
59
        timer_stop(OP_OPEN);
 
60
 
 
61
        if (*fd < 0) {
 
62
                printf("could not open %s: %s\n", path, strerror(errno));
 
63
                exit(EXIT_FAILURE);
 
64
        }
 
65
}
 
66
 
 
67
static void do_write(int fd)
 
68
{
 
69
        char buffer[BUFFER_SIZE];
 
70
        int result, count = 0;
 
71
 
 
72
        timer_start(OP_WRITE);
 
73
        do {
 
74
                result = write(fd, &buffer[count], BUFFER_SIZE - count);
 
75
                count += result;
 
76
        } while (result != -1 && count < BUFFER_SIZE);
 
77
        timer_stop(OP_WRITE);
 
78
 
 
79
        if (result < 0) {
 
80
                printf("could not write: %s\n", strerror(errno));
 
81
                exit(EXIT_FAILURE);
 
82
        }
 
83
}
 
84
 
 
85
static void do_read(int fd)
 
86
{
 
87
        char buffer[BUFFER_SIZE];
 
88
        int result;
 
89
 
 
90
        timer_start(OP_READ);
 
91
        result = read(fd, buffer, BUFFER_SIZE);
 
92
        timer_stop(OP_READ);
 
93
 
 
94
        if (result < 0) {
 
95
                printf("could not read: %s\n", strerror(errno));
 
96
                exit(EXIT_FAILURE);
 
97
        }
 
98
}
 
99
 
 
100
static void do_fsync(int fd)
 
101
{
 
102
        int result;
 
103
 
 
104
        timer_start(OP_FSYNC); 
 
105
        result = fsync(fd);
 
106
        timer_stop(OP_FSYNC);
 
107
 
 
108
        if (result < 0) {
 
109
                printf("could not fsync: %s\n", strerror(errno));
 
110
                exit(EXIT_FAILURE);
 
111
        }
 
112
}
 
113
 
 
114
static void do_close(int fd)
 
115
{
 
116
        timer_start(OP_CLOSE); 
 
117
        close(fd);
 
118
        timer_stop(OP_CLOSE);
 
119
}
 
120
 
 
121
int main(int argc, char *argv[])
 
122
{
 
123
        char *path;
 
124
        int i, fd, runs;
 
125
 
 
126
        if (argc < 3) {
 
127
                show_help(argv[0]);
 
128
                return (EXIT_FAILURE);
 
129
        }
 
130
 
 
131
        path = argv[1];
 
132
        runs = atoi(argv[2]);
 
133
 
 
134
        if (4 == argc && 0 == strcmp(argv[3], "write")) {
 
135
                OPEN_FLAGS = O_RDWR;
 
136
        }
 
137
 
 
138
        timer_init(NOPS, OP_STRINGS);
 
139
 
 
140
        do_stat(path); 
 
141
        timer_reset(OP_STAT);
 
142
 
 
143
        for (i = 0; i < runs; i++) {
 
144
                do_stat(path);
 
145
                do_open(path, &fd);
 
146
                if (O_RDWR == OPEN_FLAGS) do_write(fd);
 
147
                do_read(fd);
 
148
                do_fsync(fd);
 
149
                do_close(fd);
 
150
        }
 
151
 
 
152
        timer_print_summary(0);
 
153
        timer_destroy();
 
154
 
 
155
        return (EXIT_SUCCESS);
 
156
}
 
157
 
 
158
/*
 
159
 * vim: sts=8 sw=8 ts=8 ft=c
 
160
 */