Fix issues with 'Success_' stats reported by ProxBinSearchProfile 51/61051/7
authorSerhiy Pshyk <serhiyx.pshyk@intel.com>
Fri, 17 Aug 2018 15:35:41 +0000 (16:35 +0100)
committerSerhiy Pshyk <serhiyx.pshyk@intel.com>
Thu, 23 Aug 2018 08:48:53 +0000 (09:48 +0100)
List of changes:
  - Added 'Status' field to indicate status of each search iteration.
    Possible values are 'Success', 'Failure', 'Result'.
  - Removed reporting of duplicated stats with 'Success_' prefix.
    Instead 'Status' field is set to 'Success'
  - Removed reporting of duplicated stats with 'Result_' prefix.
    Instead 'Status' field is set to 'Result'
  - Updated Prox_BM_L2FWD-4Port_MultiSize-1518452496550.json dashboard
    to query success and result status by 'Status' field value.

JIRA: YARDSTICK-1386

Change-Id: I9a21a102af6cb4db137e805011b5d81c4943d77b
Signed-off-by: Serhiy Pshyk <serhiyx.pshyk@intel.com>
dashboard/Prox_BM_L2FWD-4Port_MultiSize-1518452496550.json
yardstick/network_services/traffic_profile/prox_binsearch.py
yardstick/tests/unit/network_services/traffic_profile/test_prox_binsearch.py

index 3c78ab1..6595225 100644 (file)
@@ -44,6 +44,7 @@
   "annotations": {
     "list": []
   },
+  "editMode": false,
   "editable": true,
   "gnetId": null,
   "graphTooltip": 0,
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.xe0.out_packets\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE $timeFilter GROUP BY time($interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.xe0.out_packets\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE $timeFilter GROUP BY time($interval) fill(null)",
               "rawQuery": false,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.xe0.in_packets"
+                      "tg__0.collect_stats.xe0.in_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe1.in_packets"
+                      "tg__0.collect_stats.xe1.in_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe2.in_packets"
+                      "tg__0.collect_stats.xe2.in_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe3.in_packets"
+                      "tg__0.collect_stats.xe3.in_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe0.out_packets"
+                      "tg__0.collect_stats.xe0.out_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe1.out_packets"
+                      "tg__0.collect_stats.xe1.out_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe2.out_packets"
+                      "tg__0.collect_stats.xe2.out_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.xe3.out_packets"
+                      "tg__0.collect_stats.xe3.out_packets"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.TxThroughput"
+                      "tg__0.collect_stats.TxThroughput"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.RxThroughput"
+                      "tg__0.collect_stats.RxThroughput"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.PktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
+              "query": "SELECT mean(\"tg__0.collect_stats.tx_total\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.Status\" = 'Success' AND $timeFilter GROUP BY time($__interval) fill(none)",
+              "rawQuery": false,
               "refId": "B",
               "resultFormat": "time_series",
               "select": [
                 [
                   {
                     "params": [
-                      "tg__0.Success_tx_total"
+                      "tg__0.collect_stats.tx_total"
                     ],
                     "type": "field"
                   },
                   }
                 ]
               ],
-              "tags": []
+              "tags": [
+                {
+                  "key": "tg__0.collect_stats.Status",
+                  "operator": "=",
+                  "value": "Success"
+                }
+              ]
             },
             {
               "alias": "SUCCESS Rx Total",
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
+              "query": "SELECT mean(\"tg__0.collect_stats.rx_total\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.Status\" = 'Success' AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "rawQuery": false,
               "refId": "A",
               "resultFormat": "time_series",
               "select": [
                 [
                   {
                     "params": [
-                      "tg__0.Success_rx_total"
+                      "tg__0.collect_stats.rx_total"
                     ],
                     "type": "field"
                   },
                   }
                 ]
               ],
-              "tags": []
+              "tags": [
+                {
+                  "key": "tg__0.collect_stats.Status",
+                  "operator": "=",
+                  "value": "Success"
+                }
+              ]
             },
             {
               "alias": "SUCCESS ALLOWABLE LOST PACKETS",
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
+              "query": "SELECT mean(\"tg__0.collect_stats.can_be_lost\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.Status\" = 'Success' AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "rawQuery": false,
               "refId": "C",
               "resultFormat": "time_series",
               "select": [
                 [
                   {
                     "params": [
-                      "tg__0.Success_can_be_lost"
+                      "tg__0.collect_stats.can_be_lost"
                     ],
                     "type": "field"
                   },
                   }
                 ]
               ],
-              "tags": []
+              "tags": [
+                {
+                  "key": "tg__0.collect_stats.Status",
+                  "operator": "=",
+                  "value": "Success"
+                }
+              ]
             }
           ],
           "thresholds": [],
                 [
                   {
                     "params": [
-                      "tg__0.duration"
+                      "tg__0.collect_stats.duration"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.test_duration"
+                      "tg__0.collect_stats.test_duration"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.test_precision"
+                      "tg__0.collect_stats.test_precision"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.tolerated_loss"
+                      "tg__0.collect_stats.tolerated_loss"
                     ],
                     "type": "field"
                   },
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 64 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 64 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "64"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 64 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 64 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "64"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 64 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 64 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "64"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 128 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 128 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "128"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 128 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 128 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "128"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 128 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 128 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "128"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 256 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 256 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSiuze",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "256"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 256 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 256 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "256"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 256 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 256 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "256"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 512 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 512 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "512"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 512 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 512 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "512"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 512 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 512 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "512"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1024 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1024 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1024"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1024 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1024 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1024"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1024 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1024 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1024"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1280 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1280 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_pktSize"
+                      "tg__0.collect_stats.PktSize"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1280"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1280 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1280 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_theor_max_throughput"
+                      "tg__0.collect_stats.theor_max_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1280"
                 }
               "measurement": "tc_prox_baremetal_l2fwd-4",
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1280 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1280 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.Result_Actual_throughput"
+                      "tg__0.collect_stats.Actual_throughput"
                     ],
                     "type": "field"
                   },
               ],
               "tags": [
                 {
-                  "key": "tg__0.Result_pktSize",
+                  "key": "tg__0.collect_stats.PktSize",
                   "operator": "=",
                   "value": "1280"
                 }
               ],
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_pktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1518 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.PktSize\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1518 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
               ],
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1518 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.theor_max_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1518 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
               ],
               "orderByTime": "ASC",
               "policy": "default",
-              "query": "SELECT mean(\"tg__0.Result_Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.Result_pktSize\" = 1518 AND $timeFilter GROUP BY time($__interval) fill(null)",
+              "query": "SELECT mean(\"tg__0.collect_stats.Actual_throughput\") FROM \"tc_prox_baremetal_l2fwd-4\" WHERE \"tg__0.collect_stats.PktSize\" = 1518 AND  \"tg__0.collect_stats.Status\" = 'Result' AND $timeFilter GROUP BY time($__interval) fill(null)",
               "rawQuery": true,
               "refId": "A",
               "resultFormat": "time_series",
                 [
                   {
                     "params": [
-                      "tg__0.LatencyAvg.5"
+                      "tg__0.collect_stats.LatencyAvg.5"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyMax.5"
+                      "tg__0.collect_stats.LatencyMax.5"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyAvg.6"
+                      "tg__0.collect_stats.LatencyAvg.6"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyMax.6"
+                      "tg__0.collect_stats.LatencyMax.6"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyAvg.7"
+                      "tg__0.collect_stats.LatencyAvg.7"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyMax.7"
+                      "tg__0.collect_stats.LatencyMax.7"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyAvg.8"
+                      "tg__0.collect_stats.LatencyAvg.8"
                     ],
                     "type": "field"
                   },
                 [
                   {
                     "params": [
-                      "tg__0.LatencyMax.8"
+                      "tg__0.collect_stats.LatencyMax.8"
                     ],
                     "type": "field"
                   },
     "list": []
   },
   "time": {
-    "from": "2018-02-12T15:17:27.733Z",
-    "to": "2018-02-12T16:44:28.270Z"
+    "from": "now-2d",
+    "to": "now"
   },
   "timepicker": {
     "refresh_intervals": [
   },
   "timezone": "browser",
   "title": "Prox_BM_L2FWD-4Port_MultiSize",
-  "version": 29
-}
\ No newline at end of file
+  "version": 12
+}
index 506a880..16a0411 100644 (file)
@@ -25,6 +25,14 @@ from yardstick.common import constants as overall_constants
 
 LOG = logging.getLogger(__name__)
 
+STATUS_SUCCESS = "Success"
+STATUS_FAIL = "Failure"
+STATUS_RESULT = "Result"
+STEP_CONFIRM = "Confirm retry"
+STEP_INCREASE_LOWER = "Increase lower"
+STEP_DECREASE_LOWER = "Decrease lower"
+STEP_DECREASE_UPPER = "Decrease upper"
+
 
 class ProxBinSearchProfile(ProxProfile):
     """
@@ -85,18 +93,16 @@ class ProxBinSearchProfile(ProxProfile):
         # success, the binary search will complete on an integer multiple
         # of the precision, rather than on a fraction of it.
 
-        theor_max_thruput = actual_max_thruput = 0
+        theor_max_thruput = 0
 
         result_samples = {}
 
-        # Store one time only value in influxdb
-        single_samples = {
+        test_data = {
             "test_duration": traffic_gen.scenario_helper.scenario_cfg["runner"]["duration"],
             "test_precision": self.params["traffic_profile"]["test_precision"],
             "tolerated_loss": self.params["traffic_profile"]["tolerated_loss"],
             "duration": duration
         }
-        self.queue.put(single_samples)
         self.prev_time = time.time()
 
         # throughput and packet loss from the most recent successful test
@@ -110,85 +116,88 @@ class ProxBinSearchProfile(ProxProfile):
             neg_retry = 0
             total_retry = 0
 
-            LOG.info("Checking MAX %s MIN %s TEST %s",
-                self.current_upper, self.lower_bound, test_value)
+            LOG.info("Checking MAX %s MIN %s TEST %s", self.current_upper,
+                     self.lower_bound, test_value)
+
             while (pos_retry <= ok_retry) and (neg_retry <= ok_retry):
 
                 total_retry = total_retry + 1
+
                 result, port_samples = self._profile_helper.run_test(pkt_size, duration,
                                                                      test_value,
                                                                      self.tolerated_loss,
                                                                      line_speed)
-                if (total_retry > (ok_retry * 3)) and (ok_retry is not 0):
-                    LOG.info("Failure.!! .. RETRY EXCEEDED ... decrease lower bound")
 
+                if (total_retry > (ok_retry * 3)) and (ok_retry is not 0):
+                    status = STATUS_FAIL
+                    next_step = STEP_DECREASE_LOWER
                     successful_pkt_loss = result.pkt_loss
-                    samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
-
                     self.current_upper = test_value
                     neg_retry = total_retry
                 elif result.success:
                     if (pos_retry < ok_retry) and (ok_retry is not 0):
-                        neg_retry = 0
-                        LOG.info("Success! ... confirm retry")
-
+                        status = STATUS_SUCCESS
+                        next_step = STEP_CONFIRM
                         successful_pkt_loss = result.pkt_loss
-                        samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
-
+                        neg_retry = 0
                     else:
-                        LOG.info("Success! Increasing lower bound")
+                        status = STATUS_SUCCESS
+                        next_step = STEP_INCREASE_LOWER
                         self.current_lower = test_value
-
                         successful_pkt_loss = result.pkt_loss
-                        samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
-
-                        # store results with success tag in influxdb
-                        success_samples = \
-                            {'Success_' + key: value for key, value in samples.items()}
-
-                        success_samples["Success_rx_total"] = int(result.rx_total)
-                        success_samples["Success_tx_total"] = int(result.tx_total)
-                        success_samples["Success_can_be_lost"] = int(result.can_be_lost)
-                        success_samples["Success_drop_total"] = int(result.drop_total)
-                        success_samples["Success_RxThroughput"] = samples["RxThroughput"]
-                        success_samples["Success_RxThroughput_gbps"] = \
-                            (samples["RxThroughput"] / 1000) * ((pkt_size + 20)* 8)
-                        LOG.info(">>>##>>Collect SUCCESS TG KPIs %s %s",
-                                 datetime.datetime.now(), success_samples)
-                        self.queue.put(success_samples, True, overall_constants.QUEUE_PUT_TIMEOUT)
-
-                        # Store Actual throughput for result samples
-                        actual_max_thruput = success_samples["Success_RxThroughput"]
 
                     pos_retry = pos_retry + 1
 
                 else:
                     if (neg_retry < ok_retry) and (ok_retry is not 0):
-
+                        status = STATUS_FAIL
+                        next_step = STEP_CONFIRM
                         pos_retry = 0
-                        LOG.info("failure! ... confirm retry")
                     else:
-                        LOG.info("Failure... Decreasing upper bound")
+                        status = STATUS_FAIL
+                        next_step = STEP_DECREASE_UPPER
                         self.current_upper = test_value
 
                     neg_retry = neg_retry + 1
-                    samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
+
+                LOG.info(
+                    "Status = '%s' Next_Step = '%s'", status, next_step)
+
+                samples = result.get_samples(pkt_size, successful_pkt_loss, port_samples)
 
                 if theor_max_thruput < samples["TxThroughput"]:
                     theor_max_thruput = samples['TxThroughput']
-                    self.queue.put({'theor_max_throughput': theor_max_thruput})
-
-                LOG.info(">>>##>>Collect TG KPIs %s %s", datetime.datetime.now(), samples)
+                samples['theor_max_throughput'] = theor_max_thruput
+
+                samples["rx_total"] = int(result.rx_total)
+                samples["tx_total"] = int(result.tx_total)
+                samples["can_be_lost"] = int(result.can_be_lost)
+                samples["drop_total"] = int(result.drop_total)
+                samples["RxThroughput_gbps"] = \
+                    (samples["RxThroughput"] / 1000) * ((pkt_size + 20) * 8)
+                samples['Status'] = status
+                samples['Next_Step'] = next_step
                 samples["MAX_Rate"] = self.current_upper
                 samples["MIN_Rate"] = self.current_lower
                 samples["Test_Rate"] = test_value
                 samples["Step_Id"] = step_id
                 samples["Confirmation_Retry"] = total_retry
+
+                samples.update(test_data)
+
+                if status == STATUS_SUCCESS and next_step == STEP_INCREASE_LOWER:
+                    # Store success samples for result samples
+                    result_samples = samples
+
+                LOG.info(">>>##>>Collect TG KPIs %s %s", datetime.datetime.now(), samples)
+
                 self.queue.put(samples, True, overall_constants.QUEUE_PUT_TIMEOUT)
 
-        LOG.info(">>>##>> Result Reached PktSize %s Theor_Max_Thruput %s Actual_throughput %s",
-                 pkt_size, theor_max_thruput, actual_max_thruput)
-        result_samples["Result_pktSize"] = pkt_size
-        result_samples["Result_theor_max_throughput"] = theor_max_thruput
-        result_samples["Result_Actual_throughput"] = actual_max_thruput
+        LOG.info(
+            ">>>##>> Result Reached PktSize %s Theor_Max_Thruput %s Actual_throughput %s",
+            pkt_size, theor_max_thruput, result_samples.get("RxThroughput", 0))
+        result_samples["Status"] = STATUS_RESULT
+        result_samples["Next_Step"] = ""
+        result_samples["Actual_throughput"] = result_samples.get("RxThroughput", 0)
+        result_samples["theor_max_throughput"] = theor_max_thruput
         self.queue.put(result_samples)
index c062308..c099033 100644 (file)
@@ -71,38 +71,43 @@ class TestProxBinSearchProfile(unittest.TestCase):
         self.assertEqual(len(runs), 77)
 
         # Result Samples inc theor_max
-        result_tuple = {'Result_Actual_throughput': 5e-07,
-                        'Result_theor_max_throughput': 7.5e-07,
-                        'Result_pktSize': 200}
-
-        profile.queue.put.assert_called_with(result_tuple)
-
-        success_result_tuple = {"Success_CurrentDropPackets": 0.5,
-                                "Success_DropPackets": 0.5,
-                                "Success_LatencyAvg": 5.3,
-                                "Success_LatencyMax": 5.2,
-                                "Success_LatencyMin": 5.1,
-                                "Success_PktSize": 200,
-                                "Success_RxThroughput": 7.5e-07,
-                                "Success_Throughput": 7.5e-07,
-                                "Success_TxThroughput": 0.00012340000000000002}
+        result_tuple = {'Actual_throughput': 5e-07,
+                        'theor_max_throughput': 7.5e-07,
+                        'PktSize': 200,
+                        'Status': 'Result'}
+
+        test_results = profile.queue.put.call_args[0]
+        for k in result_tuple:
+            self.assertEqual(result_tuple[k], test_results[0][k])
+
+        success_result_tuple = {"CurrentDropPackets": 0.5,
+                                "DropPackets": 0.5,
+                                "LatencyAvg": 5.3,
+                                "LatencyMax": 5.2,
+                                "LatencyMin": 5.1,
+                                "PktSize": 200,
+                                "RxThroughput": 7.5e-07,
+                                "Throughput": 7.5e-07,
+                                "TxThroughput": 0.00012340000000000002,
+                                "Status": 'Success'}
 
         calls = profile.queue.put(success_result_tuple)
         profile.queue.put.assert_has_calls(calls)
 
-        success_result_tuple2 = {"Success_CurrentDropPackets": 0.5,
-                                "Success_DropPackets": 0.5,
-                                "Success_LatencyAvg": 5.3,
-                                "Success_LatencyMax": 5.2,
-                                "Success_LatencyMin": 5.1,
-                                "Success_PktSize": 200,
-                                "Success_RxThroughput": 7.5e-07,
-                                "Success_Throughput": 7.5e-07,
-                                "Success_TxThroughput": 123.4,
-                                "Success_can_be_lost": 409600,
-                                "Success_drop_total": 20480,
-                                "Success_rx_total": 4075520,
-                                "Success_tx_total": 4096000}
+        success_result_tuple2 = {"CurrentDropPackets": 0.5,
+                                "DropPackets": 0.5,
+                                "LatencyAvg": 5.3,
+                                "LatencyMax": 5.2,
+                                "LatencyMin": 5.1,
+                                "PktSize": 200,
+                                "RxThroughput": 7.5e-07,
+                                "Throughput": 7.5e-07,
+                                "TxThroughput": 123.4,
+                                "can_be_lost": 409600,
+                                "drop_total": 20480,
+                                "rx_total": 4075520,
+                                "tx_total": 4096000,
+                                "Status": 'Success'}
 
         calls = profile.queue.put(success_result_tuple2)
         profile.queue.put.assert_has_calls(calls)
@@ -183,17 +188,16 @@ class TestProxBinSearchProfile(unittest.TestCase):
 
 
         # Result Samples
-        result_tuple = {'Result_Actual_throughput': 0, "Result_theor_max_throughput": 0,
-                        "Result_pktSize": 200}
+        result_tuple = {'Actual_throughput': 0, 'theor_max_throughput': 0,
+                        "Status": 'Result', "Next_Step": ''}
         profile.queue.put.assert_called_with(result_tuple)
 
         # Check for success_ tuple (None expected)
         calls = profile.queue.put.mock_calls
         for call in calls:
             for call_detail in call[1]:
-                for k in call_detail:
-                    if "Success_" in k:
-                        self.assertRaises(AttributeError)
+                if call_detail["Status"] == 'Success':
+                    self.assertRaises(AttributeError)
 
     def test_execute_4(self):
 
@@ -237,38 +241,43 @@ class TestProxBinSearchProfile(unittest.TestCase):
         self.assertEqual(len(runs), 7)
 
         # Result Samples inc theor_max
-        result_tuple = {'Result_Actual_throughput': 5e-07,
-                        'Result_theor_max_throughput': 7.5e-07,
-                        'Result_pktSize': 200}
-
-        profile.queue.put.assert_called_with(result_tuple)
-
-        success_result_tuple = {"Success_CurrentDropPackets": 0.5,
-                                "Success_DropPackets": 0.5,
-                                "Success_LatencyAvg": 5.3,
-                                "Success_LatencyMax": 5.2,
-                                "Success_LatencyMin": 5.1,
-                                "Success_PktSize": 200,
-                                "Success_RxThroughput": 7.5e-07,
-                                "Success_Throughput": 7.5e-07,
-                                "Success_TxThroughput": 0.00012340000000000002}
+        result_tuple = {'Actual_throughput': 5e-07,
+                        'theor_max_throughput': 7.5e-07,
+                        'PktSize': 200,
+                        "Status": 'Result'}
+
+        test_results = profile.queue.put.call_args[0]
+        for k in result_tuple:
+            self.assertEqual(result_tuple[k], test_results[0][k])
+
+        success_result_tuple = {"CurrentDropPackets": 0.5,
+                                "DropPackets": 0.5,
+                                "LatencyAvg": 5.3,
+                                "LatencyMax": 5.2,
+                                "LatencyMin": 5.1,
+                                "PktSize": 200,
+                                "RxThroughput": 7.5e-07,
+                                "Throughput": 7.5e-07,
+                                "TxThroughput": 0.00012340000000000002,
+                                "Status": 'Success'}
 
         calls = profile.queue.put(success_result_tuple)
         profile.queue.put.assert_has_calls(calls)
 
-        success_result_tuple2 = {"Success_CurrentDropPackets": 0.5,
-                                 "Success_DropPackets": 0.5,
-                                 "Success_LatencyAvg": 5.3,
-                                 "Success_LatencyMax": 5.2,
-                                 "Success_LatencyMin": 5.1,
-                                 "Success_PktSize": 200,
-                                 "Success_RxThroughput": 7.5e-07,
-                                 "Success_Throughput": 7.5e-07,
-                                 "Success_TxThroughput": 123.4,
-                                 "Success_can_be_lost": 409600,
-                                 "Success_drop_total": 20480,
-                                 "Success_rx_total": 4075520,
-                                 "Success_tx_total": 4096000}
+        success_result_tuple2 = {"CurrentDropPackets": 0.5,
+                                 "DropPackets": 0.5,
+                                 "LatencyAvg": 5.3,
+                                 "LatencyMax": 5.2,
+                                 "LatencyMin": 5.1,
+                                 "PktSize": 200,
+                                 "RxThroughput": 7.5e-07,
+                                 "Throughput": 7.5e-07,
+                                 "TxThroughput": 123.4,
+                                 "can_be_lost": 409600,
+                                 "drop_total": 20480,
+                                 "rx_total": 4075520,
+                                 "tx_total": 4096000,
+                                 "Status": 'Success'}
 
         calls = profile.queue.put(success_result_tuple2)
         profile.queue.put.assert_has_calls(calls)