summaryrefslogtreecommitdiffstats
path: root/fwbench.c
diff options
context:
space:
mode:
Diffstat (limited to 'fwbench.c')
-rw-r--r--fwbench.c301
1 files changed, 196 insertions, 105 deletions
diff --git a/fwbench.c b/fwbench.c
index af514e7..b8051d0 100644
--- a/fwbench.c
+++ b/fwbench.c
@@ -1,3 +1,4 @@
+#define _BSD_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -10,15 +11,25 @@
#include <sys/time.h>
#include <fastwriter.h>
-#include <ufo/ufo-graph.h>
+
+#ifdef USE_UFO_GENERATOR
+# include <ufo/ufo-graph.h>
+#endif /* USE_UFO_GENERATOR */
#include "config.h"
+//#define USE_FIFO
#define FW_BUFFER 4096l
#define WRITE_INTERVAL 1
#define WRITE_SUMMARY 5
+#define DELTA_TOLERANCE 5
#define NEWFILE 10
+#ifdef USE_UFO_GENERATOR
+# ifndef USE_FIFO
+# define USE_FIFO
+# endif /* !USE_FIFO */
+#endif /* USE_UFO_GENERATOR */
#define run_time 3600
const char *fifo_name = ".fifo";
@@ -28,47 +39,74 @@ struct setup_s {
size_t height;
size_t bpp;
size_t fps;
-
+
size_t iters;
volatile int run_started;
+
+ struct timeval tv_started;
+ struct timeval tv_last_written;
+
+ int broken_frame;
+ unsigned long frames, lost;
+ unsigned long last_frames, last_lost;
+
+ size_t frame_size;
+ size_t num_read;
+ size_t buf_max;
+
+ size_t writeouts;
+
+ fastwriter_t *fw;
};
typedef struct setup_s setup_t;
-void handle_error(GError *error) {
+
+#ifdef USE_UFO_GENERATOR
+static void handle_error(GError *error) {
if (error != NULL) {
g_print("%s\n", error->message);
g_error_free(error);
exit(EXIT_FAILURE);
}
}
+#endif /* USE_UFO_GENERATOR */
-void set_speed(setup_t *setup, size_t speed) {
+
+static void set_dim(setup_t *setup, size_t width, size_t height) {
setup->bpp = sizeof(float);
- setup->width = 1024;
- setup->height = 768;
+ setup->width = width;
+ setup->height = height;
+
+ setup->frame_size = setup->width * setup->height * setup->bpp;
+}
+
+static void set_speed(setup_t *setup, size_t speed) {
setup->fps = 1 + speed / setup->width / setup->height / setup->bpp;
}
-void set_size(setup_t *setup, size_t size) {
+static void set_size(setup_t *setup, size_t size) {
setup->iters = size / setup->width / setup->height / setup->bpp;
}
-void set_time(setup_t *setup, size_t time) {
+static void set_time(setup_t *setup, size_t time) {
setup->iters = time * setup->fps;
}
+static int callback(setup_t *s, size_t result, void *buffer);
+
static void *run(setup_t *setup) {
+#ifdef USE_UFO_GENERATOR
GError *error = NULL;
UfoGraph *graph = NULL;
/* If you want to use system-wide installed filters:
* graph = ufo_graph_new(); */
graph = g_object_new(UFO_TYPE_GRAPH,
-#ifdef METABALLS_PATH
+# ifdef METABALLS_PATH
"paths", METABALLS_PATH,
-#endif /* METABALLS_PATH */
+# endif /* METABALLS_PATH */
NULL);
// printf("%lu %lu %lu %lu\n", setup->width, setup->height, setup->iters, setup->width * setup->height * setup->iters * sizeof(float));
@@ -92,46 +130,158 @@ static void *run(setup_t *setup) {
handle_error(error);
setup->run_started = 1;
+
ufo_graph_run(graph, &error);
handle_error(error);
+#else /* USE_UFO_GENERATOR */
+ size_t i;
+ struct timeval tv;
+ size_t size = setup->width * setup->height * setup->bpp;
+ char buffer[size];
+ double interval = 1000000. / setup->fps, nextus;
+ ssize_t tmp;
+ size_t nexts;
+ setup->run_started = 1;
-// g_print("Wrote %lu bytes\n", width * height * num_iterations * sizeof(float));
+#ifdef USE_FIFO
+ int fd = open(fifo_name, O_WRONLY);
+ g_assert(fd >= 0);
+#endif /* USE_FIFO */
+
+ gettimeofday(&tv, NULL);
+ nexts = tv.tv_sec;
+ nextus = tv.tv_usec + interval;
+ for (i = 0; i < setup->iters; i++) {
+#ifdef USE_FIFO
+ ssize_t res = write(fd, buffer, size);
+ g_assert(res == size);
+#else /* USE_FIFO */
+ callback(setup, size, buffer);
+#endif /* USE_FIFO */
+
+ tmp = ((size_t)round(nextus)) / 1000000;
+ nexts += tmp;
+ nextus -= tmp * 1000000;
+
+ gettimeofday(&tv, NULL);
+ tmp = (nexts - tv.tv_sec)*1000000 + (nextus - tv.tv_usec);
+ if (tmp > 10) usleep(tmp);
+
+ nextus += interval;
+ }
+
+#ifdef USE_FIFO
+ close(fd);
+#endif /* USE_FIFO */
+
+#endif /* USE_UFO_GENERATOR */
g_thread_exit(NULL);
return NULL;
}
+static int callback(setup_t *s, size_t result, void *buffer) {
+ int err;
+ struct timeval tv;
+
+ fastwriter_t *fw = s->fw;
+ fastwriter_stats_t stats;
+
+ size_t duration, last_duration, expected;
+ long delta;
+ if (!s->broken_frame) {
+ err = fastwriter_push(fw, result, buffer);
+ if (err) {
+ if (err == EWOULDBLOCK) {
+ if (s->num_read) fastwriter_cancel(fw);
+ s->broken_frame = 1;
+ } else {
+ if (err) printf("FastWriter returned error %i\n", err);
+ g_assert(!err);
+ }
+ }
+ }
+
+ s->num_read += result;
+
+ if (s->num_read < s->frame_size) return 0;
+
+ s->num_read = 0;
+
+ if (s->broken_frame) {
+ s->lost++;
+ s->broken_frame = 0;
+ } else {
+ err = fastwriter_commit(fw);
+ s->frames++;
+ }
+
+ gettimeofday(&tv, NULL);
+ if (!s->tv_started.tv_sec) {
+ memcpy(&s->tv_started, &tv, sizeof(struct timeval));
+ if (s->tv_started.tv_usec >= (1000000 / s->fps))
+ s->tv_started.tv_usec -= (1000000 / s->fps);
+ else {
+ s->tv_started.tv_sec--;
+ s->tv_started.tv_usec += 1000000 - (1000000 / s->fps);
+ }
+ memcpy(&s->tv_last_written, &s->tv_started, sizeof(struct timeval));
+ }
+
+ fastwriter_get_stats(fw, &stats);
+ if (stats.buffer_used > s->buf_max) s->buf_max = stats.buffer_used;
+
+ if ((tv.tv_sec - s->tv_last_written.tv_sec) >= WRITE_INTERVAL) {
+ last_duration = (tv.tv_sec - s->tv_last_written.tv_sec) * 1000000 + (tv.tv_usec - s->tv_last_written.tv_usec);
+
+ printf("Lost %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*(s->lost - s->last_lost) / (s->lost + s->frames - s->last_lost - s->last_frames), s->lost - s->last_lost, s->lost + s->frames - (s->last_lost + s->last_frames), 1. * s->frame_size * (s->frames - s->last_frames) / 1024 / 1024 / 1024, 1000000. * s->frame_size * (s->frames - s->last_frames) / last_duration / 1024 / 1024, 100.*s->buf_max/stats.buffer_size);
+
+ if (((++s->writeouts)%WRITE_SUMMARY)==0) {
+ duration = (tv.tv_sec - s->tv_started.tv_sec) * 1000000 + (tv.tv_usec - s->tv_started.tv_usec);
+ expected = (tv.tv_sec - s->tv_started.tv_sec) * s->fps + round(1.*(tv.tv_usec - s->tv_started.tv_usec)*s->fps/1000000);
+ delta = expected - s->lost - s->frames;
+ if ((delta > DELTA_TOLERANCE)||(delta < -DELTA_TOLERANCE))
+ printf(" *** Unexpected frame rate: %.2lf (%lu), delta: %li (%lu, %lu)\n", 1000000. * (s->frames + s->lost) / duration, s->fps, delta, s->lost + s->frames, expected);
+
+ printf("Total %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100. * s->lost / (s->lost + s->frames), s->lost, s->lost + s->frames, 1. * s->frames * s->frame_size / 1024 / 1024 / 1024, 1000000. * s->frames * s->frame_size / duration / 1024 / 1024, 100.*stats.buffer_max / stats.buffer_size);
+ }
+
+ s->buf_max = 0;
+ memcpy(&s->tv_last_written, &tv, sizeof(struct timeval));
+ s->last_frames = s->frames;
+ s->last_lost = s->lost;
+ }
+
+ return 0;
+}
+
int main(int argc, char const* argv[])
{
int err;
+
+#ifdef USE_FIFO
GError *gerr;
GThread *thr;
+#endif /* USE_FIFO */
+
setup_t setup;
- fastwriter_t *fw;
- fastwriter_stats_t stats;
const char *out = "/dev/null";
+ size_t width = 1024;
+ size_t height = 768;
size_t speed = 850;
- size_t num_read = 0;
- size_t buf_max = 0;
-
- int broken_frame = 0;
- size_t writeouts = 0;
- size_t duration, last_duration;
- struct timeval tv;
- struct timeval tv_started = {0};
- struct timeval tv_last_written = {0};
- unsigned long frames = 0, lost = 0;
- unsigned long delta, expected;
- unsigned long last_frames = 0, last_lost = 0;
-
+ fastwriter_t *fw;
+ fastwriter_stats_t stats;
- g_thread_init(NULL);
+ g_thread_init(NULL);
+
+#ifdef USE_UFO_GENERATOR
g_type_init();
+#endif /* USE_UFO_GENERATOR */
if (argc > 1) {
out = argv[1];
@@ -141,30 +291,35 @@ int main(int argc, char const* argv[])
speed = atoi(argv[2]);
}
+#ifdef USE_FIFO
unlink(fifo_name);
g_assert(!mkfifo(fifo_name, S_IWUSR | S_IRUSR));
+#endif /* USE_FIFO */
fw = fastwriter_init(out, FASTWRITER_FLAGS_OVERWRITE);
g_assert(fw);
err = fastwriter_open(fw, out, FASTWRITER_FLAGS_OVERWRITE);
if (err) printf("FastWriter returned error %i\n", err);
-
g_assert(!err);
fastwriter_set_buffer_size(fw, FW_BUFFER * 1024 * 1024);
fastwriter_get_stats(fw, &stats);
- printf("*** Writing to %s, speed: %lu MB/s, buffer: %lu MB\n", out, speed, stats.buffer_size);
memset(&setup, 0, sizeof(setup_t));
+
+ setup.fw = fw;
+ set_dim(&setup, width, height);
set_speed(&setup, speed * 1024 * 1024);
set_size(&setup, run_time * speed * 1024 * 1024);
- size_t frame_size = setup.width * setup.height * setup.bpp;
- void *buffer = malloc(frame_size);
+ printf("*** Writing to %s, rate: %lu, data: %lu MB/s, buffer: %lu MB\n", out, setup.fps, speed, stats.buffer_size);
+
+ void *buffer = malloc(setup.frame_size);
g_assert(buffer);
+#ifdef USE_FIFO
thr = g_thread_create((GThreadFunc)run, &setup, 1, &gerr);
g_assert(thr);
@@ -173,93 +328,29 @@ int main(int argc, char const* argv[])
int fd = open(fifo_name, O_RDONLY);
g_assert(fd);
- ssize_t result = read(fd, buffer, frame_size);
+ ssize_t result = read(fd, buffer, setup.frame_size);
while (result > 0) {
- if (!broken_frame) {
- err = fastwriter_push(fw, result, buffer);
- if (err) {
- if (err == EWOULDBLOCK) {
- if (num_read) fastwriter_cancel(fw);
- broken_frame = 1;
- } else {
- if (err) printf("FastWriter returned error %i\n", err);
- g_assert(!err);
- }
- }
- }
-
- num_read += result;
-
- if (num_read < frame_size) {
- result = read(fd, buffer, frame_size - num_read);
- continue;
- }
-
- gettimeofday(&tv, NULL);
- if (!tv_started.tv_sec) {
- memcpy(&tv_started, &tv, sizeof(struct timeval));
- if (tv_started.tv_usec >= (1000000 / setup.fps))
- tv_started.tv_usec -= (1000000 / setup.fps);
- else {
- tv_started.tv_sec--;
- tv_started.tv_usec += 1000000 - (1000000 / setup.fps);
- }
- memcpy(&tv_last_written, &tv_started, sizeof(struct timeval));
- }
-
- num_read = 0;
-
- if (broken_frame) {
- lost++;
- } else {
- err = fastwriter_commit(fw);
- frames++;
- }
-
- fastwriter_get_stats(fw, &stats);
- if (stats.buffer_used > buf_max) buf_max = stats.buffer_used;
-
- if ((tv.tv_sec - tv_last_written.tv_sec) >= WRITE_INTERVAL) {
- last_duration = (tv.tv_sec - tv_last_written.tv_sec) * 1000000 + (tv.tv_usec - tv_last_written.tv_usec);
-
-/* expected = (tv.tv_sec - tv_last_summary.tv_sec) * setup.fps + (tv.tv_usec - tv_last_summary.tv_usec) * setup.fps / 1000000;
- delta = expected - lost - frames;
- if (delta > 0) delta--;*/
-
- printf("Lost %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*(lost - last_lost) / (lost + frames - last_lost - last_frames), lost - last_lost, lost + frames - (last_lost + last_frames), 1. * frame_size * (frames - last_frames) / 1024 / 1024 / 1024, 1000000. * frame_size * (frames - last_frames) / last_duration / 1024 / 1024, 100.*buf_max/stats.buffer_size);
-
- if (((++writeouts)%WRITE_SUMMARY)==0) {
- duration = (tv.tv_sec - tv_started.tv_sec) * 1000000 + (tv.tv_usec - tv_started.tv_usec);
-
- expected = (tv.tv_sec - tv_started.tv_sec) * setup.fps + round(1.*(tv.tv_usec - tv_started.tv_usec)*setup.fps/1000000);
-
- delta = expected - lost - frames;
- if ((delta > 1)||(delta < 1))
- printf(" *** Unexpected frame rate: %.2lf (%lu), delta: %li (%lu, %lu)\n", 1000000. * (frames + lost) / duration, setup.fps, delta, lost + frames, expected);
-
- printf("Total %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*lost / (lost + frames), lost, lost + frames, 1. * frames * frame_size / 1024 / 1024 / 1024, 1000000. * frames * frame_size / duration / 1024 / 1024, 100.*stats.buffer_max / stats.buffer_size);
- }
-
- buf_max = 0;
- memcpy(&tv_last_written, &tv, sizeof(struct timeval));
- last_frames = frames;
- last_lost = lost;
- }
-
- result = read(fd, buffer, frame_size);
+ callback(&setup, result, buffer);
+ result = read(fd, buffer, setup.frame_size - setup.num_read);
}
- printf("Wrote %lu GB\n", frame_size * frames / 1024 / 1024 / 1024);
+ printf("Wrote %lu GB\n", setup.frame_size * setup.frames / 1024 / 1024 / 1024);
g_thread_join(thr);
close(fd);
+#else /* USE_FIFO */
+ run(&setup);
+#endif /* USE_FIFO */
free(buffer);
fastwriter_close(fw);
fastwriter_destroy(fw);
+
+#ifdef USE_FIFO
unlink(fifo_name);
+#endif /* USE_FIFO */
return 0;
}