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                 return -ENOMEM;
 127
 128         if (ep == EP_ISO_IN) {
 129                 libusb_fill_iso_transfer(xfr, devh, ep, buf,
 130                                 sizeof(buf), num_iso_pack, cb_xfr, NULL, 0);
 131                 libusb_set_iso_packet_lengths(xfr, sizeof(buf)/num_iso_pack);
 132         } else
 133                 libusb_fill_bulk_transfer(xfr, devh, ep, buf,
 134                                 sizeof(buf), cb_xfr, NULL, 0);
 135
 136         get_timestamp(&tv_start);
 137
 138         /* NOTE: To reach maximum possible performance the program must
 139          * submit *multiple* transfers here, not just one.
 140          *
 141          * When only one transfer is submitted there is a gap in the bus
 142          * schedule from when the transfer completes until a new transfer
 143          * is submitted by the callback. This causes some jitter for
 144          * isochronous transfers and loss of throughput for bulk transfers.
 145          *
 146          * This is avoided by queueing multiple transfers in advance, so
 147          * that the host controller is always kept busy, and will schedule
 148          * more transfers on the bus while the callback is running for
 149          * transfers which have completed on the bus.
 150          */
 151
 152         return libusb_submit_transfer(xfr);
 153 }
 154
 155 static void measure(void)
 156 {
 157         struct timeval tv_stop;
 158         unsigned long diff_msec;
 159
 160         get_timestamp(&tv_stop);
 161
 162         diff_msec = (tv_stop.tv_sec - tv_start.tv_sec) * 1000L;
 163         diff_msec += (tv_stop.tv_usec - tv_start.tv_usec) / 1000L;
 164
 165         printf("%lu transfers (total %lu bytes) in %lu milliseconds => %lu bytes/sec\n",
 166                 num_xfer, num_bytes, diff_msec, (num_bytes * 1000L) / diff_msec);
 167 }
 168
 169 static void sig_hdlr(int signum)
 170 {
 171         (void)signum;
 172
 173         measure();
 174         do_exit = 1;
 175 }
 176
 177 int main(void)
 178 {
 179         int rc;
 180
 181 #if defined(PLATFORM_POSIX)
 182         struct sigaction sigact;
 183
 184         sigact.sa_handler = sig_hdlr;
 185         sigemptyset(&sigact.sa_mask);
 186         sigact.sa_flags = 0;
 187         (void)sigaction(SIGINT, &sigact, NULL);
 188 #else
 189         (void)signal(SIGINT, sig_hdlr);
 190 #endif
 191
 192         rc = libusb_init(NULL);
 193         if (rc < 0) {
 194                 fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
 195                 exit(1);
 196         }
 197
 198         devh = libusb_open_device_with_vid_pid(NULL, 0x16c0, 0x0763);
 199         if (!devh) {
 200                 fprintf(stderr, "Error finding USB device\n");
 201                 goto out;
 202         }
 203
 204         rc = libusb_claim_interface(devh, 2);
 205         if (rc < 0) {
 206                 fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rc));
 207                 goto out;
 208         }
 209
 210         benchmark_in(EP_ISO_IN);
 211
 212         while (!do_exit) {
 213                 rc = libusb_handle_events(NULL);
 214                 if (rc != LIBUSB_SUCCESS)
 215                         break;
 216         }
 217
 218         /* Measurement has already been done by the signal handler. */
 219
 220         libusb_release_interface(devh, 2);
 221 out:
 222         if (devh)
 223                 libusb_close(devh);
 224         libusb_exit(NULL);
 225         return rc;
 226 }