/alps/fwbench

To get this branch, use:
bzr branch http://darksoft.org/webbzr/alps/fwbench

« back to all changes in this revision

Viewing changes to seqreader.c

  • Committer: Suren A. Chilingaryan
  • Date: 2012-11-29 01:45:06 UTC
  • Revision ID: csa@dside.dyndns.org-20121129014506-c36ro0w3sug7n238
Better directory mode in seqreader

Show diffs side-by-side

added added

removed removed

Lines of Context:
seqreader.c
18
18
 
19
19
#define SYNC_MODE
20
20
#define AIO_MODE 2
 
21
//#define FS_SYNC_MODE
21
22
#define EXTRA_BUFFERS 2
22
23
#define WRITE_INTERVAL 1
23
24
 
38
39
#ifdef AIO_MODE
39
40
# define BUFSIZE (BLOCK_SIZE * (AIO_MODE + EXTRA_BUFFERS))
40
41
#else /* AIO_MODE */
41
 
# define BUFSIZE BLOCK_SIZE
 
42
# define BUFSIZE (1024 * RAID_STRIP_SIZE * RAID_DISKS) 
42
43
#endif /* AIO_MODE */
43
44
 
44
45
 
47
48
    size_t SKIP = 1;
48
49
    DIR *dir;
49
50
    struct dirent *ent;
50
 
    struct timeval start, tv;
 
51
    struct timeval start, fstart, tv;
51
52
    size_t us;
52
53
    size_t files = 0;
53
54
    size_t total_size = 0;
58
59
    size_t ready;
59
60
    ssize_t res;
60
61
    size_t max_size = (size_t)-1;
61
 
    char *buffer;//[BUFSIZE];
 
62
    char *buffer;
62
63
    long double mcoef = 1000000. / (1024 * 1024);
63
64
    int flags = O_RDONLY|O_NOATIME|O_LARGEFILE;
64
65
 
74
75
    struct io_event ev[AIO_MODE];
75
76
#endif /* AIO_MODE */
76
77
 
77
 
#ifdef SYNC_MODE
78
 
    flags |= O_DIRECT;
79
 
#endif
80
 
 
81
 
    printf("Used buffer: %i MB, Block: %i KB\n", BUFSIZE / 1024 / 1024, BLOCK_SIZE/1024);
82
78
 
83
79
    posix_memalign((void**)&buffer, FASTWRITER_SYNCIO_ALIGN, BUFSIZE);
84
80
    
93
89
            max_size *= 1024 * 1024 * 1024;
94
90
        }
95
91
 
 
92
#ifdef SYNC_MODE
 
93
        flags |= O_DIRECT;
 
94
#endif
 
95
        
 
96
        printf("Used buffer: %i MB, Block: %i KB\n", BUFSIZE / 1024 / 1024, BLOCK_SIZE/1024);
 
97
 
 
98
 
96
99
        int fd = open(argv[1], flags, 0);
97
100
        if (fd < 0) {
98
101
            printf("Unable to open device %s\n", argv[1]);
219
222
        return 0;
220
223
    }
221
224
 
 
225
#ifdef FS_SYNC_MODE
 
226
    flags |= O_DIRECT;
 
227
#endif /* FS_SYNC_MODE */
 
228
        
222
229
    chdir(argv[1]);
223
230
 
224
231
    if (argc > 2) {
239
246
        if (stat(ent->d_name, &st)) continue;
240
247
        if (!S_ISREG(st.st_mode)) continue;
241
248
 
 
249
        int size = st.st_blksize;
 
250
 
242
251
#ifdef F_MODE
243
252
        FILE *f = fopen(ent->d_name, "r");
244
253
        if (!f) continue;
245
254
#else   
246
255
        int fd = open(ent->d_name, flags, 0);
247
256
        if (fd < 0) continue;
 
257
 
 
258
# ifdef FS_SYNC_MODE
 
259
        if (size < BLOCK_SIZE) size = BLOCK_SIZE;
 
260
# endif /* FS_SYNC_MODE */
248
261
#endif  
249
 
        
250
 
        int size = st.st_blksize;
 
262
 
 
263
        if (!files)
 
264
            printf("Reading %s, Block: %i KB\n", ent->d_name, size / 1024);
251
265
        
252
266
        if (size > BUFSIZE) {
253
267
            printf("Buffer too small\n");
254
268
            exit(1);
255
269
        }
256
270
 
 
271
        size_t last_file_write = 0;
 
272
        size_t last_file_size = 0;
 
273
        size_t file_size = 0;
 
274
        gettimeofday(&fstart, NULL);
257
275
 
258
276
#ifdef F_MODE
259
277
        while (!feof(f)) {
260
 
            err = fread(buffer, 1, size, f);
261
 
            if (err < 0) break;
262
 
        }
 
278
            ssize_t ret = fread(buffer, 1, size, f);
263
279
#else
264
 
# ifdef SYNC_MODE
265
 
        if (size < BLOCK_SIZE) size = BLOCK_SIZE;
266
 
# endif
267
 
        err = read(fd, buffer, size);
268
 
        while (err > 0) {
269
 
            err = read(fd, buffer, size);
270
 
        }
 
280
        while (1) {
 
281
            ssize_t ret = read(fd, buffer, size);
271
282
#endif
272
 
 
273
 
        if (err < 0) {
 
283
            if (ret <= 0) break;
 
284
            
 
285
            file_size += ret;
 
286
 
 
287
            gettimeofday(&tv, NULL);
 
288
            us = (tv.tv_sec - fstart.tv_sec) * 1000000 + (tv.tv_usec - fstart.tv_usec);
 
289
 
 
290
            if ((us - last_file_write) > WRITE_INTERVAL * 1000000) {
 
291
                printf("Reading: %s (%lu GB),  Measured speed: %zu MB/s, Current speed: %zu MB/s\n", ent->d_name, file_size / 1024 / 1024 / 1024, (size_t)(mcoef * file_size / us), (size_t)(mcoef * (file_size - last_file_size) / (us - last_file_write)));
 
292
                last_file_write = us;
 
293
                last_file_size = file_size;
 
294
            }
 
295
        }
 
296
 
 
297
        if (!file_size) {
274
298
            printf("Read failed\n");
275
299
            exit(1);
276
300
        }
286
310
        
287
311
        gettimeofday(&tv, NULL);
288
312
        us = (tv.tv_sec - start.tv_sec) * 1000000 + (tv.tv_usec - start.tv_usec);
289
 
        printf("Reading: %s (%lu MB), Read: %lu files (%lu GB),  Measured speed: %zu MB/s\n", ent->d_name, st.st_size/1024/1024, files, total_size / 1024 / 1024 / 1024, (size_t)(mcoef * total_size / us));
 
313
        if ((us - last_write) > WRITE_INTERVAL * 1000000) {
 
314
            last_write = us;
 
315
            printf("Read: %lu files (%lu GB) at %zu MB/s", files, total_size / 1024 / 1024 / 1024, (size_t)(mcoef * total_size / us));
 
316
 
 
317
            us = (tv.tv_sec - fstart.tv_sec) * 1000000 + (tv.tv_usec - fstart.tv_usec);
 
318
            printf(", Last: %s (%lu MB) at %zu MB/s\n", ent->d_name, st.st_size/1024/1024, (size_t)(mcoef * file_size / us));
 
319
        }
290
320
      }
291
321
      closedir(dir);
 
322
 
 
323
      us = (tv.tv_sec - start.tv_sec) * 1000000 + (tv.tv_usec - start.tv_usec);
 
324
      printf("Total: %lu files (%lu GB) at %zu MB/s\n", files, total_size / 1024 / 1024 / 1024, (size_t)(mcoef * total_size / us));
292
325
    }
293
326
    
294
327
    free(buffer);