int main(int argc, char **argv) { int ret; int i, j, k, toread; FILE *fp_ev; int fp; char *trigger_name, *dev_dir_name, *buf_dir_name; char *data; size_t read_size; struct iio_event_data dat; int dev_num, trig_num; char *buffer_access, *buffer_event; const char *iio_dir = "/sys/bus/iio/devices/"; int scan_size; float gain = 1; /* Find out which iio device is the accelerometer. */ dev_num = find_type_by_name(device_name, "device"); if (dev_num < 0) { printf("Failed to find the %s\n", device_name); ret = -ENODEV; goto error_ret; } printf("iio device number being used is %d\n", dev_num); asprintf(&dev_dir_name, "%sdevice%d", iio_dir, dev_num); /* * Build the trigger name. * In this case we want the lis3l02dq's data ready trigger * for this lis3l02dq. The naming is lis3l02dq_dev[n], where * n matches the device number found above. */ ret = asprintf(&trigger_name, "%s%d", trigger_name_base, dev_num); if (ret < 0) { ret = -ENOMEM; goto error_free_dev_dir_name; } /* * Find the trigger by name. * This is techically unecessary here as we only need to * refer to the trigger by name and that name is already * known. */ trig_num = find_type_by_name(trigger_name, "trigger"); if (trig_num < 0) { printf("Failed to find the %s\n", trigger_name); ret = -ENODEV; goto error_free_triggername; } printf("iio trigger number being used is %d\n", trig_num); /* * Read in the scale value - in a more generic case, first * check for accel_scale, then the indivual channel scales */ ret = read_sysfs_float("accel_scale", dev_dir_name, &gain); if (ret) goto error_free_triggername;; /* * Construct the directory name for the associated buffer. * As we know that the lis3l02dq has only one buffer this may * be built rather than found. */ ret = asprintf(&buf_dir_name, "%sdevice%d:buffer0", iio_dir, dev_num); if (ret < 0) { ret = -ENOMEM; goto error_free_triggername; } /* Set the device trigger to be the data rdy trigger found above */ ret = write_sysfs_string_and_verify("trigger/current_trigger", dev_dir_name, trigger_name); if (ret < 0) { printf("Failed to write current_trigger file\n"); goto error_free_buf_dir_name; } /* Setup ring buffer parameters */ ret = write_sysfs_int("length", buf_dir_name, buf_len); if (ret < 0) goto error_free_buf_dir_name; /* Enable the buffer */ ret = write_sysfs_int("ring_enable", buf_dir_name, 1); if (ret < 0) goto error_free_buf_dir_name; data = malloc(size_from_scanmode(num_vals, scan_ts)*buf_len); if (!data) { ret = -ENOMEM; goto error_free_buf_dir_name; } ret = asprintf(&buffer_access, "/dev/device%d:buffer0:access0", dev_num); if (ret < 0) { ret = -ENOMEM; goto error_free_data; } ret = asprintf(&buffer_event, "/dev/device%d:buffer0:event0", dev_num); if (ret < 0) { ret = -ENOMEM; goto error_free_data; } /* Attempt to open non blocking the access dev */ fp = open(buffer_access, O_RDONLY | O_NONBLOCK); if (fp == -1) { /*If it isn't there make the node */ printf("Failed to open %s\n", buffer_access); ret = -errno; goto error_free_buffer_event; } /* Attempt to open the event access dev (blocking this time) */ fp_ev = fopen(buffer_event, "rb"); if (fp_ev == NULL) { printf("Failed to open %s\n", buffer_event); ret = -errno; goto error_close_buffer_access; } /* Wait for events 10 times */ for (j = 0; j < num_loops; j++) { read_size = fread(&dat, 1, sizeof(struct iio_event_data), fp_ev); switch (dat.id) { case IIO_EVENT_CODE_RING_100_FULL: toread = buf_len; break; case IIO_EVENT_CODE_RING_75_FULL: toread = buf_len*3/4; break; case IIO_EVENT_CODE_RING_50_FULL: toread = buf_len/2; break; default: printf("Unexpecteded event code\n"); continue; } read_size = read(fp, data, toread*size_from_scanmode(num_vals, scan_ts)); if (read_size == -EAGAIN) { printf("nothing available\n"); continue; } scan_size = size_from_scanmode(num_vals, scan_ts); for (i = 0; i < read_size/scan_size; i++) { for (k = 0; k < num_vals; k++) { __s16 val = *(__s16 *)(&data[i*scan_size + (k)*2]); printf("%05f ", (float)val*gain); } printf(" %lld\n", *(__s64 *)(&data[(i + 1) *size_from_scanmode(num_vals, scan_ts) - sizeof(__s64)])); } } /* Stop the ring buffer */ ret = write_sysfs_int("ring_enable", buf_dir_name, 0); if (ret < 0) goto error_close_buffer_event; /* Disconnect from the trigger - just write a dummy name.*/ write_sysfs_string("trigger/current_trigger", dev_dir_name, "NULL"); error_close_buffer_event: fclose(fp_ev); error_close_buffer_access: close(fp); error_free_data: free(data); error_free_buffer_access: free(buffer_access); error_free_buffer_event: free(buffer_event); error_free_buf_dir_name: free(buf_dir_name); error_free_triggername: free(trigger_name); error_free_dev_dir_name: free(dev_dir_name); error_ret: return ret; }
void __log_csv(const char *test_name, int size, int iteration_max, int fd, struct tm *tm, const char *dbgfs_entry, const char *sys_pfx, const char *postfix) { char buf[CSV_MAX_LINE]; extern int errno; int error, fd_dev, len; float request_avg, latency_avg, latency_gb_avg, throughput_avg; int request_min, request_max, request_jitter; int latency_min, latency_max, latency_jitter; int throughput_min, throughput_max, throughput_jitter; unsigned int i; char rx_buf[SYSFS_MAX_INT]; fd_dev = open(dbgfs_entry, O_RDONLY); if (fd_dev < 0) { fprintf(stderr, "unable to open specified device %s\n", dbgfs_entry); return; } /* gather data set */ error = read_sysfs_int(sys_pfx, postfix, "error"); request_min = read_sysfs_int(sys_pfx, postfix, "requests_per_second_min"); request_max = read_sysfs_int(sys_pfx, postfix, "requests_per_second_max"); request_avg = read_sysfs_float(sys_pfx, postfix, "requests_per_second_avg"); latency_min = read_sysfs_int(sys_pfx, postfix, "latency_min"); latency_max = read_sysfs_int(sys_pfx, postfix, "latency_max"); latency_avg = read_sysfs_float(sys_pfx, postfix, "latency_avg"); throughput_min = read_sysfs_int(sys_pfx, postfix, "throughput_min"); throughput_max = read_sysfs_int(sys_pfx, postfix, "throughput_max"); throughput_avg = read_sysfs_float(sys_pfx, postfix, "throughput_avg"); /* derive jitter */ request_jitter = request_max - request_min; latency_jitter = latency_max - latency_min; throughput_jitter = throughput_max - throughput_min; /* append calculated metrics to file */ memset(buf, 0x00, sizeof(buf)); len = snprintf(buf, sizeof(buf), "%u-%u-%u %u:%u:%u,", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); len += snprintf(&buf[len], sizeof(buf) - len, "%s,%s,%u,%u,%u,%u,%u,%f,%u,%u,%u,%f,%u,%u,%u,%f,%u", test_name, sys_pfx, size, iteration_max, error, request_min, request_max, request_avg, request_jitter, latency_min, latency_max, latency_avg, latency_jitter, throughput_min, throughput_max, throughput_avg, throughput_jitter); write(fd, buf, len); /* print basic metrics to stdout - requested feature add */ printf("\n%s\n", buf); /* Write raw latency times to CSV */ for (i = 0; i < iteration_max; i++) { memset(&rx_buf, 0x00, sizeof(rx_buf)); len = read(fd_dev, rx_buf, sizeof(rx_buf)); if (len < 0) { fprintf(stderr, "error reading %s %s\n", dbgfs_entry, strerror(errno)); break; } lseek(fd_dev, SEEK_SET, 0); len = snprintf(buf, sizeof(buf), ",%s", rx_buf); if (write(fd, buf, len) != len) { log_csv_error(0, errno); break; } } if (write(fd, "\n", 1) < 1) log_csv_error(1, errno); /* skip printing large set to stdout just close open handles */ close(fd_dev); }
static int get_results(struct loopback_test *t) { struct loopback_device *d; struct loopback_results *r; int i; for (i = 0; i < t->device_count; i++) { if (!device_enabled(t, i)) continue; d = &t->devices[i]; r = &d->results; r->error = read_sysfs_int(d->sysfs_entry, "error"); r->request_min = read_sysfs_int(d->sysfs_entry, "requests_per_second_min"); r->request_max = read_sysfs_int(d->sysfs_entry, "requests_per_second_max"); r->request_avg = read_sysfs_float(d->sysfs_entry, "requests_per_second_avg"); r->latency_min = read_sysfs_int(d->sysfs_entry, "latency_min"); r->latency_max = read_sysfs_int(d->sysfs_entry, "latency_max"); r->latency_avg = read_sysfs_float(d->sysfs_entry, "latency_avg"); r->throughput_min = read_sysfs_int(d->sysfs_entry, "throughput_min"); r->throughput_max = read_sysfs_int(d->sysfs_entry, "throughput_max"); r->throughput_avg = read_sysfs_float(d->sysfs_entry, "throughput_avg"); r->apbridge_unipro_latency_min = read_sysfs_int(d->sysfs_entry, "apbridge_unipro_latency_min"); r->apbridge_unipro_latency_max = read_sysfs_int(d->sysfs_entry, "apbridge_unipro_latency_max"); r->apbridge_unipro_latency_avg = read_sysfs_float(d->sysfs_entry, "apbridge_unipro_latency_avg"); r->gbphy_firmware_latency_min = read_sysfs_int(d->sysfs_entry, "gbphy_firmware_latency_min"); r->gbphy_firmware_latency_max = read_sysfs_int(d->sysfs_entry, "gbphy_firmware_latency_max"); r->gbphy_firmware_latency_avg = read_sysfs_float(d->sysfs_entry, "gbphy_firmware_latency_avg"); r->request_jitter = r->request_max - r->request_min; r->latency_jitter = r->latency_max - r->latency_min; r->throughput_jitter = r->throughput_max - r->throughput_min; r->apbridge_unipro_latency_jitter = r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min; r->gbphy_firmware_latency_jitter = r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min; } /*calculate the aggregate results of all enabled devices */ if (t->aggregate_output) { r = &t->aggregate_results; r->request_min = get_request_min_aggregate(t); r->request_max = get_request_max_aggregate(t); r->request_avg = get_request_avg_aggregate(t); r->latency_min = get_latency_min_aggregate(t); r->latency_max = get_latency_max_aggregate(t); r->latency_avg = get_latency_avg_aggregate(t); r->throughput_min = get_throughput_min_aggregate(t); r->throughput_max = get_throughput_max_aggregate(t); r->throughput_avg = get_throughput_avg_aggregate(t); r->apbridge_unipro_latency_min = get_apbridge_unipro_latency_min_aggregate(t); r->apbridge_unipro_latency_max = get_apbridge_unipro_latency_max_aggregate(t); r->apbridge_unipro_latency_avg = get_apbridge_unipro_latency_avg_aggregate(t); r->gbphy_firmware_latency_min = get_gbphy_firmware_latency_min_aggregate(t); r->gbphy_firmware_latency_max = get_gbphy_firmware_latency_max_aggregate(t); r->gbphy_firmware_latency_avg = get_gbphy_firmware_latency_avg_aggregate(t); r->request_jitter = r->request_max - r->request_min; r->latency_jitter = r->latency_max - r->latency_min; r->throughput_jitter = r->throughput_max - r->throughput_min; r->apbridge_unipro_latency_jitter = r->apbridge_unipro_latency_max - r->apbridge_unipro_latency_min; r->gbphy_firmware_latency_jitter = r->gbphy_firmware_latency_max - r->gbphy_firmware_latency_min; } return 0; }