Add a descprition at the top of the report

measure-analysis/measure-analysis.py

@@ -13,6 +13,15 @@ import matplotlib.pyplot as plt
 
 class MeasureSetHandler:
 
+    report_description = ("This report was generated with the measure-analysis.py script. json formated measures "
+                         "were imported in the measures folder using the import functionnality of the script. This report was then "
+                         "generated using these measures. Metadatas are included with the measures, such as the kernel "
+                         "version used, the boot parameters passed, various others parameters specific to the measure, etc... "
+                         "Measures measuring the same propriety are grouped together in tables and graphs, and are identified "
+                         "by their diverging metadatas. This is useful to analyse the effect of specific parameters on the  "
+                         "measured propriety.")
+                         
+
     measures_dir = "measures"
     graphs_dir = "{}/graphs".format(measures_dir)
     measure_sets_file_name = "measure_sets.json"
@@ -213,6 +222,7 @@ class MeasureSetHandler:
         with open(self.measures_dir + "/" + "measure-report.md", 'w+') as report:
 
             report.write("## Measurements\n\n")
+            report.write("{}\n\n".format(MeasureSetHandler.report_description))
 
             report.write("### Abbreviations used\n\n")
             for abbr_name in MeasureSet.abbreviations:
@@ -278,26 +288,26 @@ class MeasureSet:
 
     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"
+                                                     "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"
+                      '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"
+                      '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_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"
+                      '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.",
                   }
 

measure-analysis/measures/measure-report.md

 ## Measurements
 
+This report was generated with the measure-analysis.py script. json formated measures were imported in the measures folder using the import functionnality of the script. This report was then generated using these measures. Metadatas are included with the measures, such as the kernel version used, the boot parameters passed, various others parameters specific to the measure, etc... Measures measuring the same propriety are grouped together in tables and graphs, and are identified by their diverging metadatas. This is useful to analyse the effect of specific parameters on the  measured propriety.
+
 ### Abbreviations used
 
 * ker: Linux kernel version
@@ -13,7 +15,7 @@
 
 ### 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`
+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`
 
 **Common test metadata:** Linux kernel version: 4.19, Boot Parameters: isolcpus, Interval: 200us, ETF qdisc delta: 200us, Task priority: 99, qdisc: pfifo_fast
 
@@ -29,7 +31,7 @@ Emerald, 24h, ssh         | 12.0000us           | 80.0000us           | 15.4101u
 
 ### packet_send_timestamps results
 
-Similar to packet_recv_timestamps, but on the transmitting board.
+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
 
@@ -46,7 +48,7 @@ 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.
+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.
 
 **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
 
@@ -62,7 +64,7 @@ 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.
+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.
 
 **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
 
@@ -77,7 +79,7 @@ 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.
+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.
 
 **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