/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 fwbench.c

  • Committer: Suren A. Chilingaryan
  • Date: 2012-11-25 07:12:08 UTC
  • Revision ID: csa@dside.dyndns.org-20121125071208-5gvrrebp28qypn6y
Generate random data to check way too clever controllers

Show diffs side-by-side

added added

removed removed

Lines of Context:
fwbench.c
21
21
#include "config.h"
22
22
 
23
23
//#define USE_FIFO
 
24
#define WRITE_RANDOM "/dev/frandom"
24
25
#define WRITE_INTERVAL 1
25
26
#define WRITE_SUMMARY 5
26
27
#define DELTA_TOLERANCE 5
34
35
const char *fifo_name = ".fifo";
35
36
 
36
37
struct setup_s {
 
38
    size_t uc;
37
39
    size_t width;
38
40
    size_t height;
39
41
    size_t bpp;
81
83
    OPT_FPF = 'f',
82
84
    OPT_MISSING = 'm',
83
85
    OPT_QUIET = 'q',
 
86
    OPT_UC = 'u',
84
87
    OPT_HELP = 'h'
85
88
} options_t;
86
89
 
111
114
"   -n frames           - Number of frames to write\n"
112
115
"   -g <width>x<height> - Geometry [1024]\n"
113
116
"   -g <pixels>         - Number of megapixels [0.7]\n"
114
 
"   -m <percent>                - Tolerable missing frames  [100%%]\n"
 
117
"   -m <percent>                - Tolerable missing frames  [100%%]\n"
 
118
"   -u <size>           - Use uncompressable data, repeating block (MB)\n"
115
119
"   -q                  - Quiete\n"
116
120
"   -h                  - Help\n"
117
121
"\n\n",
184
188
    setup->tolerance = fail_rate;
185
189
}
186
190
 
 
191
static void request_uncompressable_data(setup_t *setup, size_t uc) {
 
192
    setup->uc = uc;
 
193
}
187
194
 
188
195
static int callback(setup_t *s, size_t result, void *buffer);
189
196
 
230
237
    size_t i;
231
238
    struct timeval tv;
232
239
    size_t size = setup->width * setup->height * setup->bpp;
233
 
    char buffer[size];
 
240
    size_t pos = 0, mult = setup->uc / size;
 
241
    char *buffer = malloc((mult + 1) * size);
234
242
    double interval = 1000000. / setup->fps, nextus;
235
243
    ssize_t tmp;
236
244
    size_t nexts;
237
245
 
 
246
    g_assert(buffer);
 
247
    
 
248
    if (!mult) mult = 1;
 
249
 
 
250
# ifdef WRITE_RANDOM
 
251
    if (setup->uc) {
 
252
        printf("Generating %zu MB of randomness...\n", mult * size / 1024 / 1024);
 
253
        int rfd = open(WRITE_RANDOM, O_RDONLY);
 
254
        g_assert(rfd >= 0);
 
255
        read(rfd, buffer, mult * size);
 
256
        close(rfd);
 
257
    }
 
258
# endif /* WRITE_RANDOM */
 
259
 
238
260
    setup->run_started = 1;
239
261
 
240
 
#ifdef USE_FIFO
 
262
# ifdef USE_FIFO
241
263
    int fd = open(fifo_name, O_WRONLY);
242
264
    g_assert(fd >= 0);
243
 
#endif /* USE_FIFO */
 
265
# endif /* USE_FIFO */
 
266
 
244
267
    gettimeofday(&tv, NULL); 
245
268
    nexts = tv.tv_sec;
246
269
    nextus = tv.tv_usec + interval;
247
270
    for (i = 0; i < setup->iters; i++) {
248
 
#ifdef USE_FIFO
249
 
        ssize_t res = write(fd, buffer, size);
 
271
# ifdef USE_FIFO
 
272
        ssize_t res = write(fd, buffer + pos * size, size);
250
273
        g_assert(res == size);
251
 
#else /* USE_FIFO */
252
 
        callback(setup, size, buffer);
253
 
#endif /* USE_FIFO */
 
274
# else /* USE_FIFO */
 
275
        callback(setup, size, buffer + pos * size);
 
276
# endif /* USE_FIFO */
254
277
 
 
278
        if ((++pos) == mult) pos = 0;
 
279
        
255
280
        tmp = ((size_t)round(nextus)) / 1000000;
256
281
        nexts += tmp;
257
282
        nextus -= tmp * 1000000;
263
288
        nextus += interval;
264
289
    }
265
290
 
266
 
#ifdef USE_FIFO
 
291
# ifdef USE_FIFO
267
292
    close(fd);
268
 
#endif /* USE_FIFO */
 
293
# endif /* USE_FIFO */
269
294
 
 
295
    free(buffer);
270
296
#endif /* USE_UFO_GENERATOR */
271
297
 
272
298
    return NULL;
400
426
    size_t height = 768;
401
427
    size_t speed = 850;
402
428
    size_t size = 0;
 
429
    size_t uc = 0;
403
430
    size_t run_time = 0;
404
431
    size_t iters = 0x7FFFFFFF;
405
432
    size_t fw_buffer = 0;
418
445
 
419
446
 
420
447
 
421
 
    while ((c = getopt(argc, argv, "hqo:s:t:r:n:g:f:m:b:")) != (unsigned char)-1) {
 
448
    while ((c = getopt(argc, argv, "hqo:s:u:t:r:n:g:f:m:b:")) != (unsigned char)-1) {
422
449
        switch (c) {
423
450
         case OPT_OUTPUT:
424
451
            out = optarg;
429
456
         case OPT_SIZE:
430
457
            size = atol(optarg);
431
458
            break;
 
459
         case OPT_UC:
 
460
            uc = atol(optarg);
 
461
            break;
432
462
         case OPT_TIME:
433
463
            run_time = atol(optarg);
434
464
            break;
484
514
    set_fail_tolerance(&setup, fail_rate);
485
515
    set_frames_per_file(&setup, fpf);
486
516
 
 
517
    request_uncompressable_data(&setup, uc * 1024 * 1024);
487
518
 
488
519
    setup.fw = fastwriter_init(setup.fs, FASTWRITER_FLAGS_OVERWRITE);
489
520
    g_assert(setup.fw);