examples/sam3u_benchmark.c

   1 /*
   2  * libusb example program to measure Atmel SAM3U isochronous performance
   3  * Copyright (C) 2012 Harald Welte <laforge@gnumonks.org>
   4  *
   5  * Copied with the author's permission under LGPL-2.1 from
   6  * http://git.gnumonks.org/cgi-bin/gitweb.cgi?p=sam3u-tests.git;a=blob;f=usb-benchmark-project/host/benchmark.c;h=74959f7ee88f1597286cd435f312a8ff52c56b7e
   7  *
   8  * An Atmel SAM3U test firmware is also available in the above repository.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <config.h>
  26
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #ifdef HAVE_SYS_TIME_H
  32 #include <sys/time.h>
  33 #endif
  34 #include <time.h>
  35
  36 #include "libusb.h"
  37
  38 #define EP_DATA_IN      0x82
  39 #define EP_ISO_IN       0x86
  40
  41 static volatile sig_atomic_t do_exit = 0;
  42 static struct libusb_device_handle *devh = NULL;
  43
  44 static unsigned long num_bytes = 0, num_xfer = 0;
  45 static struct timeval tv_start;
  46
  47 static void get_timestamp(struct timeval *tv)
  48 {
  49 #if defined(PLATFORM_WINDOWS)
  50         static LARGE_INTEGER frequency;
  51         LARGE_INTEGER counter;
  52
  53         if (!frequency.QuadPart)
  54                 QueryPerformanceFrequency(&frequency);
  55
  56         QueryPerformanceCounter(&counter);
  57         counter.QuadPart *= 1000000;
  58         counter.QuadPart /= frequency.QuadPart;
  59
  60         tv->tv_sec = (long)(counter.QuadPart / 1000000ULL);
  61         tv->tv_usec = (long)(counter.QuadPart % 1000000ULL);
  62 #elif defined(HAVE_CLOCK_GETTIME)
  63         struct timespec ts;
  64
  65         (void)clock_gettime(CLOCK_MONOTONIC, &ts);
  66         tv->tv_sec = ts.tv_sec;
  67         tv->tv_usec = (int)(ts.tv_nsec / 1000L);
  68 #else
  69         gettimeofday(tv, NULL);
  70 #endif
  71 }
  72
  73 static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
  74 {
  75         int i;
  76
  77         if (xfr->status != LIBUSB_TRANSFER_COMPLETED) {
  78                 fprintf(stderr, "transfer status %d\n", xfr->status);
  79                 libusb_free_transfer(xfr);
  80                 exit(3);
  81         }
  82
  83         if (xfr->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
  84                 for (i = 0; i < xfr->num_iso_packets; i++) {
  85                         struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i];
  86
  87                         if (pack->status != LIBUSB_TRANSFER_COMPLETED) {
  88                                 fprintf(stderr, "Error: pack %d status %d\n", i, pack->status);
  89                                 exit(5);
  90                         }
  91
  92                         printf("pack%d length:%u, actual_length:%u\n", i, pack->length, pack->actual_length);
  93                 }
  94         }
  95
  96         printf("length:%u, actual_length:%u\n", xfr->length, xfr->actual_length);
  97         for (i = 0; i < xfr->actual_length; i++) {
  98                 printf("%02x", xfr->buffer[i]);
  99                 if (i % 16)
 100                         printf("\n");
 101                 else if (i % 8)
 102                         printf("  ");
 103                 else
 104                         printf(" ");
 105         }
 106         num_bytes += xfr->actual_length;
 107         num_xfer++;
 108
 109         if (libusb_submit_transfer(xfr) < 0) {
 110                 fprintf(stderr, "error re-submitting URB\n");
 111                 exit(1);
 112         }
 113 }
 114
 115 static int benchmark_in(uint8_t ep)
 116 {
 117         static uint8_t buf[2048];
 118         static struct libusb_transfer *xfr;
 119         int num_iso_pack = 0;
 120
 121         if (ep == EP_ISO_IN)
 122                 num_iso_pack = 16;
 123
 124         xfr = libusb_alloc_transfer(num_iso_pack);
 125         if (!xfr) {
 126                 errno = ENOMEM;
 127                 return -1;
 128         }
 129
 130         if (ep == EP_ISO_IN) {
 131                 libusb_fill_iso_transfer(xfr, devh, ep, buf,
 132                                 sizeof(buf), num_iso_pack, cb_xfr, NULL, 0);
 133                 libusb_set_iso_packet_lengths(xfr, sizeof(buf)/num_iso_pack);
 134         } else
 135                 libusb_fill_bulk_transfer(xfr, devh, ep, buf,
 136                                 sizeof(buf), cb_xfr, NULL, 0);
 137
 138         get_timestamp(&tv_start);
 139
 140         /* NOTE: To reach maximum possible performance the program must
 141          * submit *multiple* transfers here, not just one.
 142          *
 143          * When only one transfer is submitted there is a gap in the bus
 144          * schedule from when the transfer completes until a new transfer
 145          * is submitted by the callback. This causes some jitter for
 146          * isochronous transfers and loss of throughput for bulk transfers.
 147          *
 148          * This is avoided by queueing multiple transfers in advance, so
 149          * that the host controller is always kept busy, and will schedule
 150          * more transfers on the bus while the callback is running for
 151          * transfers which have completed on the bus.
 152          */
 153
 154         return libusb_submit_transfer(xfr);
 155 }
 156
 157 static void measure(void)
 158 {
 159         struct timeval tv_stop;
 160         unsigned long diff_msec;
 161
 162         get_timestamp(&tv_stop);
 163
 164         diff_msec = (tv_stop.tv_sec - tv_start.tv_sec) * 1000L;
 165         diff_msec += (tv_stop.tv_usec - tv_start.tv_usec) / 1000L;
 166
 167         printf("%lu transfers (total %lu bytes) in %lu milliseconds => %lu bytes/sec\n",
 168                 num_xfer, num_bytes, diff_msec, (num_bytes * 1000L) / diff_msec);
 169 }
 170
 171 static void sig_hdlr(int signum)
 172 {
 173         (void)signum;
 174
 175         measure();
 176         do_exit = 1;
 177 }
 178
 179 int main(void)
 180 {
 181         int rc;
 182
 183 #if defined(PLATFORM_POSIX)
 184         struct sigaction sigact;
 185
 186         sigact.sa_handler = sig_hdlr;
 187         sigemptyset(&sigact.sa_mask);
 188         sigact.sa_flags = 0;
 189         (void)sigaction(SIGINT, &sigact, NULL);
 190 #else
 191         (void)signal(SIGINT, sig_hdlr);
 192 #endif
 193
 194         rc = libusb_init(NULL);
 195         if (rc < 0) {
 196                 fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
 197                 exit(1);
 198         }
 199
 200         devh = libusb_open_device_with_vid_pid(NULL, 0x16c0, 0x0763);
 201         if (!devh) {
 202                 fprintf(stderr, "Error finding USB device\n");
 203                 goto out;
 204         }
 205
 206         rc = libusb_claim_interface(devh, 2);
 207         if (rc < 0) {
 208                 fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rc));
 209                 goto out;
 210         }
 211
 212         benchmark_in(EP_ISO_IN);
 213
 214         while (!do_exit) {
 215                 rc = libusb_handle_events(NULL);
 216                 if (rc != LIBUSB_SUCCESS)
 217                         break;
 218         }
 219
 220         /* Measurement has already been done by the signal handler. */
 221
 222         libusb_release_interface(devh, 2);
 223 out:
 224         if (devh)
 225                 libusb_close(devh);
 226         libusb_exit(NULL);
 227         return rc;
 228 }