Add descriptions, and use relative number of samples for the graphs

measure-analysis/measure-analysis.py

@@ -148,7 +148,7 @@ class MeasureSetHandler:
                 # Set meta graph information 
                 if props_type == 'histogram':
                     ax.set_xlabel('Latency (us)')
-                    ax.set_ylabel('Number of latency samples')
+                    ax.set_ylabel('Percentage of latency samples (%)')
                     ax.set_title('{}, {} histogram'.format(mtype, prop_name))
                 else:
                     ax.set_xlabel('Time (us)')
@@ -225,6 +225,10 @@ class MeasureSetHandler:
 
                 report.write("### {} results\n\n".format(mtype))
 
+                # mtype description
+                if mtype in MeasureSet.descriptions:
+                    report.write('{}\n\n'.format(MeasureSet.descriptions[mtype]))
+
                 measures = []
                 for mid in self.measure_sets[mtype]['ids']:
                     measures.append(self.get_measure_set("{}{}".format(mtype, mid)))
@@ -272,6 +276,31 @@ class MeasureSet:
                       'duration': 'Test duration',
                     }
 
+    descriptions = {
+                      'cyclictest_wake-up_latency': "Uses cyclictest from the rt-tests test suite to measure wake-up latency. "
+                                                     "A real-time thread is run on CPU1, and wakes up at a regular interval"
+                                                     "(specified by the interval parameter) using clock_nanosleep. It then uses"
+                                                     "clock_gettime and computes the difference between the scheduled wake-up"
+                                                     "time and the effective wake-up time measured by clock_gettime. "
+                                                     "The command used is: cyclictest -p `prio` -a1 -t1 -n -h 200 -q -i `interval`",
+
+                      'packet_jitter':              "An UDP packet is periodically sent from one board to another using a real time"
+                                                     "thread. The receiving board calculates the intervals between the packets"
+                                                     "it receives, and sees how much it differs from the scheduled interval.",
+
+                      'packet_recv_timestamps':     "An UDP packet is periodically sent from one board to another using a real time"
+                                                     "thread. The receiving board uses the SO_TIMESTAMPING option to see when"
+                                                     "the packet entered the kernel, and generates timestamps with clock_gettime"
+                                                     "once the packets enters userspace to compute the time the packet spent in"
+                                                     "kernel and user space.",
+
+                      'packet_send_timestamps':      "Similar to packet_recv_timestamps, but on the transmitting board.",
+
+                      'packet_rtt':                  "An UDP packet is periodically sent from one board to another and sent back as"
+                                                      "soon as it arrives using a real time thread. The round trip time is computed"
+                                                      "with clock_gettime on the transmitting board.",
+                  }
+
     def __init__(self):
 
         self.metadata = {}
@@ -444,6 +473,7 @@ class MeasureSet:
 
         bins = [i for i in range(self.min[i], self.max[i] + 1)]
         vals = self.props[i][self.min[i] + self.middle : self.max[i] + self.middle + 1]
+        vals = [ (x * 100) / sum(vals) for x in vals]
 
         min_val = max(vals) / 140
 

measure-analysis/measures/measure-report.md

@@ -13,6 +13,8 @@
 
 ### cyclictest_wake-up_latency results
 
+Uses cyclictest from the rt-tests test suite to measure wake-up latency. A real-time thread is run on CPU1, and wakes up at a regular interval(specified by the interval parameter) using clock_nanosleep. It then usesclock_gettime and computes the difference between the scheduled wake-uptime and the effective wake-up time measured by clock_gettime. The command used is: cyclictest -p `prio` -a1 -t1 -n -h 200 -q -i `interval`
+
 **Common test metadata:** Linux kernel version: 4.19, Boot Parameters: isolcpus, Interval: 200us, ETF qdisc delta: 200us, Task priority: 99, qdisc: pfifo_fast
 
 Metadata                  | Min                 | Max                 | Avg                 | Var                
@@ -27,6 +29,8 @@ Emerald, 24h, ssh         | 12.0000us           | 80.0000us           | 15.4101u
 
 ### packet_send_timestamps results
 
+Similar to packet_recv_timestamps, but on the transmitting board.
+
 **Common test metadata:** Linux kernel version: 4.19, Boot Parameters: isolcpus, ETF qdisc delta: 200us, Task priority: 99, Device and processor load: ssh, qdisc: pfifo_fast
 
 Metadata               | Min                           | Max                           | Avg                           | Var                          
@@ -42,6 +46,8 @@ Slate, 1000us, 0h2     | 1.0000us - 32.0000us          | 12.0000us - 118.0000us
 
 ### packet_recv_timestamps results
 
+An UDP packet is periodically sent from one board to another using a real timethread. The receiving board uses the SO_TIMESTAMPING option to see whenthe packet entered the kernel, and generates timestamps with clock_gettimeonce the packets enters userspace to compute the time the packet spent inkernel and user space.
+
 **Common test metadata:** Board name: Slate, Linux kernel version: 4.19, Boot Parameters: isolcpus, ETF qdisc delta: 200us, Task priority: 99, Device and processor load: ssh, qdisc: pfifo_fast
 
 Metadata        | Min                           | Max                           | Avg                           | Var                          
@@ -56,6 +62,8 @@ Metadata        | Min                           | Max
 
 ### packet_jitter results
 
+An UDP packet is periodically sent from one board to another using a real timethread. The receiving board calculates the intervals between the packetsit receives, and sees how much it differs from the scheduled interval.
+
 **Common test metadata:** Board name: Slate, Linux kernel version: 4.19, Boot Parameters: isolcpus, ETF qdisc delta: 200us, Task priority: 99, Device and processor load: ssh, qdisc: pfifo_fast
 
 Metadata        | Min         | Max        | Avg        | Var       
@@ -69,6 +77,8 @@ Metadata        | Min         | Max        | Avg        | Var
 
 ### packet_rtt results
 
+An UDP packet is periodically sent from one board to another and sent back assoon as it arrives using a real time thread. The round trip time is computedwith clock_gettime on the transmitting board.
+
 **Common test metadata:** Board name: Onyx, Linux kernel version: 4.19, Boot Parameters: isolcpus, Interval: 10000us, ETF qdisc delta: 200us, Task priority: 99, Device and processor load: ssh, Test duration: 0h4, qdisc: pfifo_fast
 
 Min        | Max        | Avg        | Var