summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.bzrignore6
-rw-r--r--CMakeLists.txt32
-rw-r--r--config.h.in1
-rw-r--r--fwbench.c265
4 files changed, 304 insertions, 0 deletions
diff --git a/.bzrignore b/.bzrignore
new file mode 100644
index 0000000..b3ab8b2
--- /dev/null
+++ b/.bzrignore
@@ -0,0 +1,6 @@
+CMakeCache.txt
+CMakeFiles
+Makefile
+config.h
+cmake_install.cmake
+fwbench
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..d78d9a6
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,32 @@
+project(fwbench)
+
+set(FWBENCH_VERSION "0.0.1")
+
+cmake_minimum_required(VERSION 2.8)
+
+find_package(PkgConfig REQUIRED)
+
+pkg_check_modules(GLIB2 glib-2.0>=2.24 REQUIRED)
+pkg_check_modules(GOBJECT2 gobject-2.0>=2.24 REQUIRED)
+pkg_check_modules(UFO ufo<=0.2 REQUIRED)
+pkg_check_modules(FASTWRITER fastwriter REQUIRED)
+
+
+FIND_PATH(METABALLS_PATH
+ NAMES
+ metaballs.so
+)
+
+add_definitions("-fPIC --std=c99 -Wall -O2")
+
+include_directories(
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${GLIB2_INCLUDE_DIRS}
+ ${UFO_INCLUDE_DIRS}
+ ${FASTWRITER_INCLUDE_DIRS}
+)
+
+add_executable(fwbench fwbench.c)
+target_link_libraries(fwbench m ufo fastwriter ${GLIB2_LIBRARIES})
+
+configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)
diff --git a/config.h.in b/config.h.in
new file mode 100644
index 0000000..d2ad2bd
--- /dev/null
+++ b/config.h.in
@@ -0,0 +1 @@
+#cmakedefine METABALLS_PATH "@METABALLS_PATH@"
diff --git a/fwbench.c b/fwbench.c
new file mode 100644
index 0000000..af514e7
--- /dev/null
+++ b/fwbench.c
@@ -0,0 +1,265 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <glib.h>
+#include <math.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include <fastwriter.h>
+#include <ufo/ufo-graph.h>
+
+#include "config.h"
+
+#define FW_BUFFER 4096l
+#define WRITE_INTERVAL 1
+#define WRITE_SUMMARY 5
+#define NEWFILE 10
+
+
+#define run_time 3600
+const char *fifo_name = ".fifo";
+
+struct setup_s {
+ size_t width;
+ size_t height;
+ size_t bpp;
+ size_t fps;
+
+ size_t iters;
+
+ volatile int run_started;
+};
+
+typedef struct setup_s setup_t;
+
+void handle_error(GError *error) {
+ if (error != NULL) {
+ g_print("%s\n", error->message);
+ g_error_free(error);
+ exit(EXIT_FAILURE);
+ }
+}
+
+void set_speed(setup_t *setup, size_t speed) {
+ setup->bpp = sizeof(float);
+ setup->width = 1024;
+ setup->height = 768;
+ setup->fps = 1 + speed / setup->width / setup->height / setup->bpp;
+}
+
+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) {
+ setup->iters = time * setup->fps;
+}
+
+static void *run(setup_t *setup) {
+ 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
+ "paths", 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));
+ UfoFilter *metaballs = ufo_graph_get_filter(graph, "metaballs", &error);
+ handle_error(error);
+ g_object_set(G_OBJECT(metaballs),
+ "width", setup->width,
+ "height", setup->height,
+ "num-balls", 1,
+ "num-iterations", setup->iters,
+ "frames-per-second", setup->fps,
+ NULL);
+
+ UfoFilter *writer = ufo_graph_get_filter(graph, "pipeoutput", &error);
+ handle_error(error);
+ g_object_set(G_OBJECT(writer),
+ "pipe-name", fifo_name,
+ NULL);
+
+ ufo_filter_connect_to(metaballs, writer, &error);
+ handle_error(error);
+
+ setup->run_started = 1;
+ ufo_graph_run(graph, &error);
+ handle_error(error);
+
+
+// g_print("Wrote %lu bytes\n", width * height * num_iterations * sizeof(float));
+
+ g_thread_exit(NULL);
+ return NULL;
+}
+
+
+
+
+int main(int argc, char const* argv[])
+{
+ int err;
+ GError *gerr;
+ GThread *thr;
+ setup_t setup;
+ fastwriter_t *fw;
+ fastwriter_stats_t stats;
+ const char *out = "/dev/null";
+ 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;
+
+
+ g_thread_init(NULL);
+ g_type_init();
+
+ if (argc > 1) {
+ out = argv[1];
+ }
+
+ if (argc > 2) {
+ speed = atoi(argv[2]);
+ }
+
+ unlink(fifo_name);
+ g_assert(!mkfifo(fifo_name, S_IWUSR | S_IRUSR));
+
+ 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));
+ 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);
+ g_assert(buffer);
+
+ thr = g_thread_create((GThreadFunc)run, &setup, 1, &gerr);
+ g_assert(thr);
+
+ while (!setup.run_started);
+
+ int fd = open(fifo_name, O_RDONLY);
+ g_assert(fd);
+
+ ssize_t result = read(fd, buffer, 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);
+ }
+
+ printf("Wrote %lu GB\n", frame_size * frames / 1024 / 1024 / 1024);
+
+ g_thread_join(thr);
+
+ close(fd);
+
+ free(buffer);
+ fastwriter_close(fw);
+ fastwriter_destroy(fw);
+ unlink(fifo_name);
+
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 06:16:54 +0000