diff options
Diffstat (limited to 'test/benchmark.c')
| -rw-r--r-- | test/benchmark.c | 282 |
1 files changed, 220 insertions, 62 deletions
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; } |