X-Git-Url: http://47.100.26.94:8080/?a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjni%2Flibusb-1.0.22%2Fexamples%2Fsam3u_benchmark.c;fp=app%2Fsrc%2Fmain%2Fjni%2Flibusb-1.0.22%2Fexamples%2Fsam3u_benchmark.c;h=7189b22d169890c91f02b475a0216f1715b7ff2e;hb=577426ccc66649228285c4a0b6ba8752836059c6;hp=0000000000000000000000000000000000000000;hpb=b7202442677d0cf41e6e59870cd6c34e5619b8b9;p=rtmpclient.git diff --git a/app/src/main/jni/libusb-1.0.22/examples/sam3u_benchmark.c b/app/src/main/jni/libusb-1.0.22/examples/sam3u_benchmark.c new file mode 100644 index 0000000..7189b22 --- /dev/null +++ b/app/src/main/jni/libusb-1.0.22/examples/sam3u_benchmark.c @@ -0,0 +1,193 @@ +/* + * libusb example program to measure Atmel SAM3U isochronous performance + * Copyright (C) 2012 Harald Welte + * + * Copied with the author's permission under LGPL-2.1 from + * http://git.gnumonks.org/cgi-bin/gitweb.cgi?p=sam3u-tests.git;a=blob;f=usb-benchmark-project/host/benchmark.c;h=74959f7ee88f1597286cd435f312a8ff52c56b7e + * + * An Atmel SAM3U test firmware is also available in the above repository. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include +#include + +#include + + +#define EP_DATA_IN 0x82 +#define EP_ISO_IN 0x86 + +static int do_exit = 0; +static struct libusb_device_handle *devh = NULL; + +static unsigned long num_bytes = 0, num_xfer = 0; +static struct timeval tv_start; + +static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr) +{ + int i; + + if (xfr->status != LIBUSB_TRANSFER_COMPLETED) { + fprintf(stderr, "transfer status %d\n", xfr->status); + libusb_free_transfer(xfr); + exit(3); + } + + if (xfr->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) { + for (i = 0; i < xfr->num_iso_packets; i++) { + struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i]; + + if (pack->status != LIBUSB_TRANSFER_COMPLETED) { + fprintf(stderr, "Error: pack %u status %d\n", i, pack->status); + exit(5); + } + + printf("pack%u length:%u, actual_length:%u\n", i, pack->length, pack->actual_length); + } + } + + printf("length:%u, actual_length:%u\n", xfr->length, xfr->actual_length); + for (i = 0; i < xfr->actual_length; i++) { + printf("%02x", xfr->buffer[i]); + if (i % 16) + printf("\n"); + else if (i % 8) + printf(" "); + else + printf(" "); + } + num_bytes += xfr->actual_length; + num_xfer++; + + if (libusb_submit_transfer(xfr) < 0) { + fprintf(stderr, "error re-submitting URB\n"); + exit(1); + } +} + +static int benchmark_in(uint8_t ep) +{ + static uint8_t buf[2048]; + static struct libusb_transfer *xfr; + int num_iso_pack = 0; + + if (ep == EP_ISO_IN) + num_iso_pack = 16; + + xfr = libusb_alloc_transfer(num_iso_pack); + if (!xfr) + return -ENOMEM; + + if (ep == EP_ISO_IN) { + libusb_fill_iso_transfer(xfr, devh, ep, buf, + sizeof(buf), num_iso_pack, cb_xfr, NULL, 0); + libusb_set_iso_packet_lengths(xfr, sizeof(buf)/num_iso_pack); + } else + libusb_fill_bulk_transfer(xfr, devh, ep, buf, + sizeof(buf), cb_xfr, NULL, 0); + + gettimeofday(&tv_start, NULL); + + /* NOTE: To reach maximum possible performance the program must + * submit *multiple* transfers here, not just one. + * + * When only one transfer is submitted there is a gap in the bus + * schedule from when the transfer completes until a new transfer + * is submitted by the callback. This causes some jitter for + * isochronous transfers and loss of throughput for bulk transfers. + * + * This is avoided by queueing multiple transfers in advance, so + * that the host controller is always kept busy, and will schedule + * more transfers on the bus while the callback is running for + * transfers which have completed on the bus. + */ + + return libusb_submit_transfer(xfr); +} + +static void measure(void) +{ + struct timeval tv_stop; + unsigned int diff_msec; + + gettimeofday(&tv_stop, NULL); + + diff_msec = (tv_stop.tv_sec - tv_start.tv_sec)*1000; + diff_msec += (tv_stop.tv_usec - tv_start.tv_usec)/1000; + + printf("%lu transfers (total %lu bytes) in %u miliseconds => %lu bytes/sec\n", + num_xfer, num_bytes, diff_msec, (num_bytes*1000)/diff_msec); +} + +static void sig_hdlr(int signum) +{ + switch (signum) { + case SIGINT: + measure(); + do_exit = 1; + break; + } +} + +int main(int argc, char **argv) +{ + int rc; + struct sigaction sigact; + + sigact.sa_handler = sig_hdlr; + sigemptyset(&sigact.sa_mask); + sigact.sa_flags = 0; + sigaction(SIGINT, &sigact, NULL); + + rc = libusb_init(NULL); + if (rc < 0) { + fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc)); + exit(1); + } + + devh = libusb_open_device_with_vid_pid(NULL, 0x16c0, 0x0763); + if (!devh) { + fprintf(stderr, "Error finding USB device\n"); + goto out; + } + + rc = libusb_claim_interface(devh, 2); + if (rc < 0) { + fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rc)); + goto out; + } + + benchmark_in(EP_ISO_IN); + + while (!do_exit) { + rc = libusb_handle_events(NULL); + if (rc != LIBUSB_SUCCESS) + break; + } + + /* Measurement has already been done by the signal handler. */ + + libusb_release_interface(devh, 0); +out: + if (devh) + libusb_close(devh); + libusb_exit(NULL); + return rc; +}