latester: Cleanup and correct subtraction with negative results

[can-benchmark.git] / latester / latester.c

diff --git a/latester/latester.c b/latester/latester.c
index 2e8f6e31eb9854d4fde58a39d490e9530b820f8f..60e106b564d8b9f636ab4c02d59899eee510527f 100644 (file)
--- a/latester/latester.c
+++ b/latester/latester.c
@@ -4,6 +4,7 @@
 /* License: GPLv2                                                             */
 /*******************************************************************************/
 
 /* License: GPLv2                                                             */
 /*******************************************************************************/
 

+#define _GNU_SOURCE

 #include <ctype.h>
 #include <errno.h>
 #include <error.h>
 #include <ctype.h>
 #include <errno.h>
 #include <error.h>


@@ -100,7 +101,6 @@ struct msg_info {
        struct timespec ts_rx_onwire, ts_rx_onwire_kern;
        struct timespec ts_rx_final, ts_rx_final_kern;
        struct can_frame sent, received;
        struct timespec ts_rx_onwire, ts_rx_onwire_kern;
        struct timespec ts_rx_final, ts_rx_final_kern;
        struct can_frame sent, received;

-       unsigned lat_measured_us, tx_time_us;

 };
 
 #define MAX_INFOS 10000
 };
 
 #define MAX_INFOS 10000


@@ -161,16 +161,27 @@ static inline char *tstamp_str(const void *ctx, struct timespec *tstamp)
                               tstamp->tv_sec, tstamp->tv_nsec/1000);
 }
 
                               tstamp->tv_sec, tstamp->tv_nsec/1000);
 }
 

-void msg_info_print(FILE *f, struct msg_info *mi)
+int timespec_subtract (struct timespec *result, const struct timespec *x, const struct timespec *yy);
+
+static inline unsigned get_timestamp_diff_us(struct msg_info *mi);
+
+void msg_info_process(FILE *f, struct msg_info *mi)

 {
        struct timespec diff;
        void *local = talloc_new (NULL);
        static long num = 0;
        char sent[64], received[64];
 {
        struct timespec diff;
        void *local = talloc_new (NULL);
        static long num = 0;
        char sent[64], received[64];

+       int diff_us = get_timestamp_diff_us(mi);
+       int tx_time_us = calc_frame_length(&mi->received);
+
+       /* Update histograms */
+       histogram_add(&histogram, diff_us);
+       histogram_add(&histogram_gw, diff_us - tx_time_us);

 
        if (!f)
                return;
 
 
        if (!f)
                return;
 

+       /* Print information to a file */

        sprint_canframe(sent, &mi->sent, true);
        sprint_canframe(received, &mi->received, true);
 
        sprint_canframe(sent, &mi->sent, true);
        sprint_canframe(received, &mi->received, true);
 


@@ -183,10 +194,10 @@ void msg_info_print(FILE *f, struct msg_info *mi)
                        num, S(mi->ts_sent), sent, S(mi->ts_rx_final_kern), S(mi->ts_rx_final), received,
                        DIFF(mi->ts_sent, mi->ts_rx_final_kern),
                        DIFF(mi->ts_sent, mi->ts_rx_final),
                        num, S(mi->ts_sent), sent, S(mi->ts_rx_final_kern), S(mi->ts_rx_final), received,
                        DIFF(mi->ts_sent, mi->ts_rx_final_kern),
                        DIFF(mi->ts_sent, mi->ts_rx_final),

-                       mi->tx_time_us);
+                       tx_time_us);

                break;
        case 3:
                break;
        case 3:

-               fprintf(f, "%ld: %s %s -> %s (%s) -> %s (%s) %s = %s (%s), %s (%s) %d\n",
+               fprintf(f, "%ld: %s %s -> %s (%s) -> %s (%s) %s = %s (%s), %s (%s) %d %.6f\n",

                        num, S(mi->ts_sent), sent,
                        S(mi->ts_rx_onwire_kern), S(mi->ts_rx_onwire),
                        S(mi->ts_rx_final_kern), S(mi->ts_rx_final), received,
                        num, S(mi->ts_sent), sent,
                        S(mi->ts_rx_onwire_kern), S(mi->ts_rx_onwire),
                        S(mi->ts_rx_final_kern), S(mi->ts_rx_final), received,


@@ -194,7 +205,8 @@ void msg_info_print(FILE *f, struct msg_info *mi)
                        DIFF(mi->ts_sent, mi->ts_rx_onwire),
                        DIFF(mi->ts_rx_onwire_kern, mi->ts_rx_final_kern),
                        DIFF(mi->ts_rx_onwire, mi->ts_rx_final),
                        DIFF(mi->ts_sent, mi->ts_rx_onwire),
                        DIFF(mi->ts_rx_onwire_kern, mi->ts_rx_final_kern),
                        DIFF(mi->ts_rx_onwire, mi->ts_rx_final),

-                       mi->tx_time_us);
+                       tx_time_us,
+                       1e-6*(diff_us - tx_time_us));

                break;
        }
 #undef S
                break;
        }
 #undef S


@@ -206,7 +218,7 @@ void msg_info_print(FILE *f, struct msg_info *mi)
 /* Subtract the `struct timespec' values X and Y, storing the result in
    RESULT.  Return 1 if the difference is negative, otherwise 0.  */
 
 /* Subtract the `struct timespec' values X and Y, storing the result in
    RESULT.  Return 1 if the difference is negative, otherwise 0.  */
 

-int timespec_subtract (struct timespec *result, struct timespec *x, struct timespec *yy)
+int timespec_subtract (struct timespec *result, const struct timespec *x, const struct timespec *yy)

 {
        struct timespec ylocal = *yy, *y = &ylocal;
        /* Perform the carry for the later subtraction by updating Y. */
 {
        struct timespec ylocal = *yy, *y = &ylocal;
        /* Perform the carry for the later subtraction by updating Y. */


@@ -236,7 +248,7 @@ void dbg_print_timespec(char *msg, struct timespec *tv)
        printf("%s sec=%ld nsec=%ld\n", msg, tv->tv_sec, tv->tv_nsec);
 }
 
        printf("%s sec=%ld nsec=%ld\n", msg, tv->tv_sec, tv->tv_nsec);
 }
 

-static inline void calc_msg_latencies(struct msg_info *mi)
+static inline unsigned get_timestamp_diff_us(struct msg_info *mi)

 {
        struct timespec diff;
        switch (num_interfaces) {
 {
        struct timespec diff;
        switch (num_interfaces) {


@@ -253,10 +265,10 @@ static inline void calc_msg_latencies(struct msg_info *mi)
                        timespec_subtract(&diff, &mi->ts_rx_final_kern, &mi->ts_sent);
                break;
        default:
                        timespec_subtract(&diff, &mi->ts_rx_final_kern, &mi->ts_sent);
                break;
        default:

-               return;
+               return 0;

        }
        }

-       mi->lat_measured_us = diff.tv_sec * 1000000 + diff.tv_nsec/1000;
-       mi->tx_time_us = calc_frame_length(&mi->received);
+       unsigned us = diff.tv_sec * 1000000 + diff.tv_nsec/1000;
+       return us;

 }
 
 void set_sched_policy_and_prio(int policy, int rtprio)
 }
 
 void set_sched_policy_and_prio(int policy, int rtprio)


@@ -291,7 +303,7 @@ static inline int sock_get_if_index(int s, const char *if_name)
        return ifr.ifr_ifindex;
 }
 
        return ifr.ifr_ifindex;
 }
 

-static inline get_tstamp(struct timespec *ts)
+static inline void get_tstamp(struct timespec *ts)

 {
        clock_gettime(CLOCK_REALTIME, ts);
 }
 {
        clock_gettime(CLOCK_REALTIME, ts);
 }


@@ -300,7 +312,7 @@ static inline get_tstamp(struct timespec *ts)
 int trace_fd = -1;
 int marker_fd = -1;
 
 int trace_fd = -1;
 int marker_fd = -1;
 

-int init_ftrace()
+void init_ftrace()

 {
 #ifdef FTRACE
        char *debugfs;
 {
 #ifdef FTRACE
        char *debugfs;


@@ -402,7 +414,7 @@ int send_frame(int socket)
        return ret;
 }
 
        return ret;
 }
 

-static inline send_and_check(int s)
+static inline void send_and_check(int s)

 {
        int ret;
        ret = send_frame(s);
 {
        int ret;
        ret = send_frame(s);


@@ -418,26 +430,34 @@ static inline send_and_check(int s)
        }
 }
 
        }
 }
 

-static inline void get_next_timeout(struct timespec *timeout)
+static inline void get_next_timeout(struct timespec *timeout, bool advance)

 {
        struct timespec now;
        static struct timespec last = {-1, 0 };
 
        clock_gettime(CLOCK_MONOTONIC, &now);
 
 {
        struct timespec now;
        static struct timespec last = {-1, 0 };
 
        clock_gettime(CLOCK_MONOTONIC, &now);
 

-       if (last.tv_sec == -1)
+       if (last.tv_sec == -1) {

                last = now;
                last = now;

+               last.tv_nsec = last.tv_nsec/1000000*1000000;
+       }

        if (opt.period_us != 0) {
        if (opt.period_us != 0) {

-               last.tv_sec += opt.period_us/1000000;
-               last.tv_nsec += (opt.period_us%1000000)*1000;
-               while (last.tv_nsec >= 1000000000) {
-                       last.tv_nsec -= 1000000000;
-                       last.tv_sec++;
+               if (advance) {
+                       last.tv_sec += opt.period_us/1000000;
+                       last.tv_nsec += (opt.period_us%1000000)*1000;
+                       while (last.tv_nsec >= 1000000000) {
+                               last.tv_nsec -= 1000000000;
+                               last.tv_sec++;
+                       }

                }
                if (timespec_subtract(timeout, &last, &now) /* is negative */) {
                        stats.overrun++;
                        memset(timeout, 0, sizeof(*timeout));
                }
                }
                if (timespec_subtract(timeout, &last, &now) /* is negative */) {
                        stats.overrun++;
                        memset(timeout, 0, sizeof(*timeout));
                }

+/*             printf("next %ld.%06ld  now %ld.%06ld  --> timeout %ld.%06ld\n", */
+/*                    last.tv_sec, last.tv_nsec/1000, */
+/*                    now.tv_sec, now.tv_nsec/1000, */
+/*                    timeout->tv_sec, timeout->tv_nsec/1000); */

        } else if (opt.timeout_ms != 0) {
                timeout->tv_sec = opt.timeout_ms/1000;
                timeout->tv_nsec = (opt.timeout_ms%1000)*1000000;
        } else if (opt.timeout_ms != 0) {
                timeout->tv_sec = opt.timeout_ms/1000;
                timeout->tv_nsec = (opt.timeout_ms%1000)*1000000;


@@ -480,9 +500,12 @@ void receive(int s, struct can_frame *frame, struct timespec *ts_kern, struct ti
             cmsg && (cmsg->cmsg_level == SOL_SOCKET);
             cmsg = CMSG_NXTHDR(&msg,cmsg)) {
                if (cmsg->cmsg_type == SO_TIMESTAMPNS)
             cmsg && (cmsg->cmsg_level == SOL_SOCKET);
             cmsg = CMSG_NXTHDR(&msg,cmsg)) {
                if (cmsg->cmsg_type == SO_TIMESTAMPNS)

-                       *ts_kern = *(struct timespec *)CMSG_DATA(cmsg);
-               else if (cmsg->cmsg_type == SO_RXQ_OVFL)
-                       dropcnt += *(__u32 *)CMSG_DATA(cmsg);
+                       memcpy(ts_kern, CMSG_DATA(cmsg), sizeof(struct timespec));
+               else if (cmsg->cmsg_type == SO_RXQ_OVFL) {
+                       uint32_t ovfl;
+                       memcpy(&ovfl, CMSG_DATA(cmsg), sizeof(ovfl));
+                       dropcnt += ovfl;
+               }

        }
 
 }
        }
 
 }


@@ -494,7 +517,7 @@ void process_tx(int s)
 
 void process_on_wire_rx(int s)
 {
 
 void process_on_wire_rx(int s)
 {

-       struct timespec ts_kern, ts_user, ts_diff;
+       struct timespec ts_kern, ts_user;

        struct can_frame frame;
        struct msg_info *mi;
        receive(s, &frame, &ts_kern, &ts_user);
        struct can_frame frame;
        struct msg_info *mi;
        receive(s, &frame, &ts_kern, &ts_user);


@@ -509,7 +532,7 @@ void process_on_wire_rx(int s)
 
 void process_final_rx(int s)
 {
 
 void process_final_rx(int s)
 {

-       struct timespec ts_kern, ts_user, ts_diff;
+       struct timespec ts_kern, ts_user;

        struct can_frame frame;
        struct msg_info *mi;
        int ret;
        struct can_frame frame;
        struct msg_info *mi;
        int ret;


@@ -520,11 +543,6 @@ void process_final_rx(int s)
        mi->ts_rx_final = ts_user;
        mi->received = frame;
 
        mi->ts_rx_final = ts_user;
        mi->received = frame;
 

-       calc_msg_latencies(mi);
-
-       histogram_add(&histogram, mi->lat_measured_us);
-       histogram_add(&histogram_gw, mi->lat_measured_us - mi->tx_time_us);
-

        ret = write(completion_pipe[1], &mi, sizeof(mi));
        if (ret == -1)
                error(1, errno, "completion_pipe write");
        ret = write(completion_pipe[1], &mi, sizeof(mi));
        if (ret == -1)
                error(1, errno, "completion_pipe write");


@@ -536,7 +554,6 @@ void *measure_thread(void *arg)
        struct pollfd pfd[3];
        struct timespec timeout;
        struct sockaddr_can addr;
        struct pollfd pfd[3];
        struct timespec timeout;
        struct sockaddr_can addr;

-       sigset_t set;

        int consecutive_timeouts = 0;
 
        MEMSET_ZERO(pfd);
        int consecutive_timeouts = 0;
 
        MEMSET_ZERO(pfd);


@@ -585,11 +602,12 @@ void *measure_thread(void *arg)
                SEND();
 
        get_tstamp(&stats.tic);
                SEND();
 
        get_tstamp(&stats.tic);

-
+       ret = 0;

        while (!finish_flag &&
               (opt.count == 0 || count < opt.count || msg_in_progress != 0)) {
 
        while (!finish_flag &&
               (opt.count == 0 || count < opt.count || msg_in_progress != 0)) {
 

-               get_next_timeout(&timeout);
+               get_next_timeout(&timeout, ret == 0);
+               //printf("timeout %ld.%06ld\n", timeout.tv_sec, timeout.tv_nsec/1000);

                //printf("ppoll"); fflush(stdout);
                ret = ppoll(pfd, num_interfaces, &timeout, NULL);
                //printf("=%d\n", ret);
                //printf("ppoll"); fflush(stdout);
                ret = ppoll(pfd, num_interfaces, &timeout, NULL);
                //printf("=%d\n", ret);


@@ -642,7 +660,7 @@ void *measure_thread(void *arg)
                                }
                        }
                        if (pfd[i].revents & ~POLLIN)
                                }
                        }
                        if (pfd[i].revents & ~POLLIN)

-                               error(1, 0, "Unexpected pfd[%d].revents: 0x%04x\n", pfd[i].revents);
+                               error(1, 0, "Unexpected pfd[%d].revents: 0x%04x\n", i, pfd[i].revents);

                }
        }
 
                }
        }
 


@@ -745,7 +763,6 @@ void print_progress()
 int main(int argc, const char *argv[])
 {
        pthread_t thread;
 int main(int argc, const char *argv[])
 {
        pthread_t thread;

-       sigset_t set;

        int ret, i;
 
        parse_options(argc, argv);
        int ret, i;
 
        parse_options(argc, argv);


@@ -795,7 +812,8 @@ int main(int argc, const char *argv[])
                        ret = read(completion_pipe[0], &mi, sizeof(mi));
                        if (ret < sizeof(mi))
                                error(1, errno, "read completion returned %d", ret);
                        ret = read(completion_pipe[0], &mi, sizeof(mi));
                        if (ret < sizeof(mi))
                                error(1, errno, "read completion returned %d", ret);

-                       msg_info_print(opt.f_msgs, mi);
+
+                       msg_info_process(opt.f_msgs, mi);

                        msg_info_free(mi);
                        completed++;
                }
                        msg_info_free(mi);
                        completed++;
                }


@@ -846,6 +864,7 @@ int main(int argc, const char *argv[])
                fclose(opt.f_msgs);
 
        if (opt.f_stat) {
                fclose(opt.f_msgs);
 
        if (opt.f_stat) {

+               struct histogram_stats hs;

                fprintf(opt.f_stat, "cmdline='");
                for (i=0; i<argc; i++)
                        fprintf(opt.f_stat, "%s%s", argv[i], i < argc-1 ? " " : "");
                fprintf(opt.f_stat, "cmdline='");
                for (i=0; i<argc; i++)
                        fprintf(opt.f_stat, "%s%s", argv[i], i < argc-1 ? " " : "");


@@ -853,7 +872,7 @@ int main(int argc, const char *argv[])
 
                timespec_subtract(&diff, &stats.tac, &stats.tic);
                fprintf(opt.f_stat, "duration=%s # seconds\n", tstamp_str(NULL, &diff));
 
                timespec_subtract(&diff, &stats.tac, &stats.tic);
                fprintf(opt.f_stat, "duration=%s # seconds\n", tstamp_str(NULL, &diff));

-       
+

                fprintf(opt.f_stat, "sent=%d\n", count);
                fprintf(opt.f_stat, "overrun=%d\n", stats.overrun);
                if (stats.overrun && !opt.quiet)
                fprintf(opt.f_stat, "sent=%d\n", count);
                fprintf(opt.f_stat, "overrun=%d\n", stats.overrun);
                if (stats.overrun && !opt.quiet)


@@ -871,6 +890,14 @@ int main(int argc, const char *argv[])
                if (stats.timeouts && !opt.quiet)
                        printf("invalid_frame=%d\n", stats.timeouts);
 
                if (stats.timeouts && !opt.quiet)
                        printf("invalid_frame=%d\n", stats.timeouts);
 

+               histogram_stats(&histogram_gw, &hs);
+               double avg = hs.count ? (double)hs.sum/hs.count : 0;
+               fprintf(opt.f_stat, "avg=%g\n", avg);
+               fprintf(opt.f_stat, "out_of_range_below=%d\n", hs.below);
+               fprintf(opt.f_stat, "out_of_range_above=%d\n", hs.above);
+               for (i = 0; i <= 20; i++)
+                       fprintf(opt.f_stat, "percentile%d=%d\n", i*5, hs.percentile[i*5]);
+

                fclose(opt.f_stat);
        }
 
                fclose(opt.f_stat);
        }