summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/CMakeLists.txt2
-rw-r--r--test/benchmark.c282
2 files changed, 222 insertions, 62 deletions
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 5797621..4686b84 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -41,7 +41,9 @@ endif()
add_executable(grab grab.c)
add_executable(grab-async grab-async.c)
+add_executable(benchmark benchmark.c)
+target_link_libraries(benchmark uca ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES})
target_link_libraries(grab uca ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES})
target_link_libraries(grab-async uca ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES})
diff --git a/test/benchmark.c b/test/benchmark.c
index 0d7962a..0b4f6f8 100644
--- a/test/benchmark.c
+++ b/test/benchmark.c
@@ -15,87 +15,245 @@
with this library; if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA 02110, USA */
-#define __USE_BSD
-#include <unistd.h>
-#undef __USE_BSD
-#include <sys/time.h>
-#include <stdio.h>
+#include <glib-object.h>
+#include <signal.h>
+#include <string.h>
#include <stdlib.h>
+#include "uca-camera.h"
-#include "uca.h"
+typedef void (*GrabFrameFunc) (UcaCamera *camera, gpointer buffer, guint n_frames);
-static __suseconds_t time_diff(struct timeval *start, struct timeval *stop)
+static UcaCamera *camera = NULL;
+
+static void
+sigint_handler(int signal)
+{
+ g_print ("Closing down libuca\n");
+ uca_camera_stop_recording (camera, NULL);
+ g_object_unref (camera);
+ exit (signal);
+}
+
+static void
+print_usage (void)
+{
+ gchar **types;
+
+ g_print ("Usage: benchmark (");
+ types = uca_camera_get_types ();
+
+ for (guint i = 0; types[i] != NULL; i++) {
+ if (types[i+1] == NULL)
+ g_print ("%s)", types[i]);
+ else
+ g_print ("%s | ", types[i]);
+ }
+
+ g_print ("\n");
+ g_strfreev (types);
+}
+
+static void
+log_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user)
+{
+ gsize n_written;
+ GError *error = NULL;
+ GIOChannel *channel = user;
+
+#if GLIB_CHECK_VERSION(2, 26, 0)
+ GTimeZone *tz;
+ GDateTime *date_time;
+ gchar *new_message;
+
+ tz = g_time_zone_new_local ();
+ date_time = g_date_time_new_now (tz);
+
+ new_message = g_strdup_printf ("[%s] %s\n",
+ g_date_time_format (date_time, "%FT%H:%M:%S%z"), message);
+
+ g_time_zone_unref (tz);
+ g_date_time_unref (date_time);
+
+ g_io_channel_write_chars (channel, new_message, strlen (new_message), &n_written, &error);
+ g_assert_no_error (error);
+ g_free (new_message);
+#else
+ g_io_channel_write_chars (channel, message, strlen (message), &n_written, &error);
+ g_assert_no_error (error);
+#endif
+
+ g_io_channel_flush (channel, &error);
+ g_assert_no_error (error);
+}
+
+static void
+grab_frames_sync (UcaCamera *camera, gpointer buffer, guint n_frames)
{
- return (stop->tv_sec - start->tv_sec)*1000000 + (stop->tv_usec - start->tv_usec);
+ GError *error = NULL;
+
+ uca_camera_start_recording (camera, &error);
+
+ for (guint i = 0; i < n_frames; i++) {
+ uca_camera_grab(camera, &buffer, &error);
+
+ if (error != NULL) {
+ g_warning ("Error grabbing frame %02i/%i: `%s'", i, n_frames, error->message);
+ g_error_free (error);
+ error = NULL;
+ }
+ }
+
+ uca_camera_stop_recording (camera, &error);
}
-void grab_callback_raw(uint32_t image_number, void *buffer, void *meta_data, void *user)
+static void
+grab_callback (gpointer data, gpointer user_data)
{
- uint32_t *count = (uint32_t *) user;
- *count = image_number;
+ guint *n_acquired_frames = user_data;
+ *n_acquired_frames += 1;
+}
+
+static void
+grab_frames_async (UcaCamera *camera, gpointer buffer, guint n_frames)
+{
+ GError *error = NULL;
+ guint n_acquired_frames = 0;
+
+ uca_camera_set_grab_func (camera, grab_callback, &n_acquired_frames);
+ uca_camera_start_recording (camera, &error);
+
+ /*
+ * Behold! Spinlooping is probably a bad idea but nowadays single core
+ * machines are relatively rare.
+ */
+ while (n_acquired_frames < n_frames)
+ ;
+
+ uca_camera_stop_recording (camera, &error);
+
}
-void benchmark_cam(uca_camera *cam)
+static void
+benchmark_method (UcaCamera *camera, gpointer buffer, GrabFrameFunc func, guint n_runs, guint n_frames, guint n_bytes)
{
- char name[256];
- uca_cam_get_property(cam, UCA_PROP_NAME, name, 256);
-
- uint32_t val = 5000;
- uca_cam_set_property(cam, UCA_PROP_EXPOSURE, &val);
- val = 0;
- uca_cam_set_property(cam, UCA_PROP_DELAY, &val);
-
- uint32_t width, height, bits;
- uca_cam_get_property(cam, UCA_PROP_WIDTH, &width, 0);
- uca_cam_get_property(cam, UCA_PROP_HEIGHT, &height, 0);
- uca_cam_get_property(cam, UCA_PROP_BITDEPTH, &bits, 0);
- int pixel_size = bits == 8 ? 1 : 2;
-
- struct timeval start, stop;
-
- for (int i = 0; i < 2; i++) {
- char *buffer = (char *) malloc(width*height*pixel_size);
- uca_cam_set_property(cam, UCA_PROP_HEIGHT, &height);
- uca_cam_alloc(cam, 20);
-
- /*
- * Experiment 1: Grab n frames manually
- */
- gettimeofday(&start, NULL);
- uca_cam_start_recording(cam);
- for (int i = 0; i < 1000; i++)
- uca_cam_grab(cam, (char *) buffer, NULL);
-
- uca_cam_stop_recording(cam);
- gettimeofday(&stop, NULL);
-
- float seconds = time_diff(&start, &stop) / 1000000.0;
- printf("%f,%s;%i;%i;1;%.2f;%.2f\n", seconds,
- name, width, height, 1000.0 / seconds,
- width*height*pixel_size*1000.0/ (1024*1024*seconds));
-
- height /= 2;
- free(buffer);
+ GTimer *timer;
+ gdouble fps;
+ gdouble bandwidth;
+ gdouble total_time = 0.0;
+ GError *error = NULL;
+
+ g_print ("%-10i%-10i", n_frames, n_runs);
+ timer = g_timer_new ();
+ g_assert_no_error (error);
+
+ for (guint run = 0; run < n_runs; run++) {
+ g_message ("Start run %i of %i", run, n_runs);
+ g_timer_start (timer);
+
+ func (camera, buffer, n_frames);
+
+ g_timer_stop (timer);
+ total_time += g_timer_elapsed (timer, NULL);
}
+
+ g_assert_no_error (error);
+
+ fps = n_runs * n_frames / total_time;
+ bandwidth = n_bytes * fps / 1024 / 1024;
+ g_print ("%-16.2f%-16.2f\n", fps, bandwidth);
+
+ g_timer_destroy (timer);
+}
+
+static void
+benchmark (UcaCamera *camera)
+{
+ const guint n_runs = 3;
+ const guint n_frames = 100;
+
+ guint sensor_width;
+ guint sensor_height;
+ guint roi_width;
+ guint roi_height;
+ guint bits;
+ guint n_bytes_per_pixel;
+ guint n_bytes;
+ gdouble exposure = 0.00001;
+ gpointer buffer;
+
+ g_object_set (G_OBJECT (camera),
+ "exposure-time", exposure,
+ NULL);
+
+ g_object_get (G_OBJECT (camera),
+ "sensor-width", &sensor_width,
+ "sensor-height", &sensor_height,
+ "sensor-bitdepth", &bits,
+ "roi-width", &roi_width,
+ "roi-height", &roi_height,
+ "exposure-time", &exposure,
+ NULL);
+
+ g_print ("# --- General information ---\n");
+ g_print ("# Sensor size: %ix%i\n", sensor_width, sensor_height);
+ g_print ("# ROI size: %ix%i\n", roi_width, roi_height);
+ g_print ("# Exposure time: %fs\n", exposure);
+
+ /* Synchronous frame acquisition */
+ g_print ("# %-10s%-10s%-10s%-16s%-16s\n", "type", "n_frames", "n_runs", "frames/s", "MiB/s");
+ g_print (" %-10s", "sync");
+
+ g_message ("Start synchronous benchmark");
+
+ n_bytes_per_pixel = bits > 8 ? 2 : 1;
+ n_bytes = roi_width * roi_height * n_bytes_per_pixel;
+ buffer = g_malloc0(n_bytes);
+
+ benchmark_method (camera, buffer, grab_frames_sync, n_runs, n_frames, n_bytes);
+
+ /* Asynchronous frame acquisition */
+ g_object_set (G_OBJECT(camera),
+ "transfer-asynchronously", TRUE,
+ NULL);
+
+ g_message ("Start asynchronous benchmark");
+ g_print (" %-10s", "async");
+
+ benchmark_method (camera, buffer, grab_frames_async, n_runs, n_frames, n_bytes);
+
+ g_free (buffer);
}
-int main(int argc, char *argv[])
+int
+main (int argc, char *argv[])
{
- uca *u = uca_init(NULL);
- if (u == NULL) {
- printf("Couldn't find a camera\n");
+ GIOChannel *log_channel;
+ GError *error = NULL;
+
+ (void) signal (SIGINT, sigint_handler);
+
+ if (argc < 2) {
+ print_usage();
return 1;
}
- printf("# camera;width;height;experiment;frames-per-second;throughput in MB/s\n");
+ log_channel = g_io_channel_new_file ("error.log", "a+", &error);
+ g_assert_no_error (error);
+ g_log_set_handler (NULL, G_LOG_LEVEL_MASK, log_handler, log_channel);
+
+ g_type_init();
+ camera = uca_camera_new(argv[1], &error);
- /* take first camera */
- uca_camera *cam = u->cameras;
- while (cam != NULL) {
- benchmark_cam(cam);
- cam = cam->next;
+ if (camera == NULL) {
+ g_error ("Initialization: %s", error->message);
+ return 1;
}
- uca_destroy(u);
+ benchmark (camera);
+
+ g_object_unref (camera);
+ g_io_channel_shutdown (log_channel, TRUE, &error);
+ g_assert_no_error (error);
+
return 0;
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-11 01:33:03 +0000