[201911] [Flex counters] Add SAI_INGRESS_PRIORITY_GROUP_STAT_DROPPED_PACKETS counter, create new FlexCounter group

orchagent/flexcounterorch.cpp

@@ -26,6 +26,7 @@ unordered_map<string, string> flexCounterGroupMap =
     {"PFCWD", PFC_WD_FLEX_COUNTER_GROUP},
     {"QUEUE_WATERMARK", QUEUE_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP},
     {"PG_WATERMARK", PG_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP},
+    {"PG_DROP", PG_DROP_STAT_COUNTER_FLEX_COUNTER_GROUP},
     {BUFFER_POOL_WATERMARK_KEY, BUFFER_POOL_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP},
     {"RIF", RIF_STAT_COUNTER_FLEX_COUNTER_GROUP},
     {"DEBUG_COUNTER", DEBUG_COUNTER_FLEX_COUNTER_GROUP},

orchagent/portsorch.cpp

@@ -48,6 +48,7 @@ extern FdbOrch *gFdbOrch;
 #define QUEUE_FLEX_STAT_COUNTER_POLL_MSECS "10000"
 #define QUEUE_WATERMARK_FLEX_STAT_COUNTER_POLL_MSECS "10000"
 #define PG_WATERMARK_FLEX_STAT_COUNTER_POLL_MSECS "10000"
+#define PG_DROP_FLEX_STAT_COUNTER_POLL_MSECS "10000"
 
 
 static map<string, sai_port_fec_mode_t> fec_mode_map =
@@ -141,6 +142,11 @@ static const vector<sai_ingress_priority_group_stat_t> ingressPriorityGroupWater
     SAI_INGRESS_PRIORITY_GROUP_STAT_SHARED_WATERMARK_BYTES,
 };
 
+static const vector<sai_ingress_priority_group_stat_t> ingressPriorityGroupDropStatIds =
+{
+    SAI_INGRESS_PRIORITY_GROUP_STAT_DROPPED_PACKETS
+};
+
 static char* hostif_vlan_tag[] = {
     [SAI_HOSTIF_VLAN_TAG_STRIP]     = "SAI_HOSTIF_VLAN_TAG_STRIP",
     [SAI_HOSTIF_VLAN_TAG_KEEP]      = "SAI_HOSTIF_VLAN_TAG_KEEP",
@@ -230,6 +236,11 @@ PortsOrch::PortsOrch(DBConnector *db, vector<table_name_with_pri_t> &tableNames)
         fieldValues.emplace_back(POLL_INTERVAL_FIELD, PG_WATERMARK_FLEX_STAT_COUNTER_POLL_MSECS);
         fieldValues.emplace_back(STATS_MODE_FIELD, STATS_MODE_READ_AND_CLEAR);
         m_flexCounterGroupTable->set(PG_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP, fieldValues);
+
+        fieldValues.clear();
+        fieldValues.emplace_back(POLL_INTERVAL_FIELD, PG_DROP_FLEX_STAT_COUNTER_POLL_MSECS);
+        fieldValues.emplace_back(STATS_MODE_FIELD, STATS_MODE_READ);
+        m_flexCounterGroupTable->set(PG_DROP_STAT_COUNTER_FLEX_COUNTER_GROUP, fieldValues);
     }
     catch (const runtime_error &e)
     {
@@ -1568,6 +1579,11 @@ string PortsOrch::getPriorityGroupWatermarkFlexCounterTableKey(string key)
     return string(PG_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP) + ":" + key;
 }
 
+string PortsOrch::getPriorityGroupDropPacketsFlexCounterTableKey(string key)
+{
+    return string(PG_DROP_STAT_COUNTER_FLEX_COUNTER_GROUP) + ":" + key;
+}
+
 bool PortsOrch::initPort(const string &alias, const set<int> &lane_set)
 {
     SWSS_LOG_ENTER();
@@ -3726,6 +3742,22 @@ void PortsOrch::generatePriorityGroupMapPerPort(const Port& port)
         fieldValues.emplace_back(PG_COUNTER_ID_LIST, counters_stream.str());
 
         m_flexCounterTable->set(key, fieldValues);
+
+        delimiter = "";
+        std::ostringstream ingress_pg_drop_packets_counters_stream;
+        key = getPriorityGroupDropPacketsFlexCounterTableKey(id);
+        /* Add dropped packets counters to flex_counter */
+        for (const auto& it: ingressPriorityGroupDropStatIds)
+        {
+            ingress_pg_drop_packets_counters_stream << delimiter << sai_serialize_ingress_priority_group_stat(it);
+            if (delimiter.empty())
+            {
+                delimiter = comma;
+            }
+        }
+        fieldValues.clear();
+        fieldValues.emplace_back(PG_COUNTER_ID_LIST, ingress_pg_drop_packets_counters_stream.str());
+        m_flexCounterTable->set(key, fieldValues);
     }
 
     m_pgTable->set("", pgVector);

orchagent/portsorch.h

@@ -17,6 +17,7 @@
 #define QUEUE_STAT_COUNTER_FLEX_COUNTER_GROUP "QUEUE_STAT_COUNTER"
 #define QUEUE_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP "QUEUE_WATERMARK_STAT_COUNTER"
 #define PG_WATERMARK_STAT_COUNTER_FLEX_COUNTER_GROUP "PG_WATERMARK_STAT_COUNTER"
+#define PG_DROP_STAT_COUNTER_FLEX_COUNTER_GROUP "PG_DROP_STAT_COUNTER"
 
 
 typedef std::vector<sai_uint32_t> PortSupportedSpeeds;
@@ -114,6 +115,7 @@ class PortsOrch : public Orch, public Subject
     std::string getPortFlexCounterTableKey(std::string s);
     std::string getPortBuffDropFlexCounterTableKey(std::string s);
     std::string getPriorityGroupWatermarkFlexCounterTableKey(std::string s);
+    std::string getPriorityGroupDropPacketsFlexCounterTableKey(std::string s);
 
     shared_ptr<DBConnector> m_counter_db;
     shared_ptr<DBConnector> m_flex_db;

tests/test_pg_drop_counter.py

@@ -0,0 +1,88 @@
+from swsscommon import swsscommon
+import os
+import re
+import time
+import json
+import pytest
+import redis
+
+
+pg_drop_attr = "SAI_INGRESS_PRIORITY_GROUP_STAT_DROPPED_PACKETS"
+
+class TestPGDropCounter(object):
+    DEFAULT_POLL_INTERVAL = 10
+
+    def enable_unittests(self, dvs, status):
+        db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
+        ntf = swsscommon.NotificationProducer(db, "SAI_VS_UNITTEST_CHANNEL")
+        fvp = swsscommon.FieldValuePairs()
+        ntf.send("enable_unittests", status, fvp)
+
+    def set_counter(self, dvs, obj_id, attr, val):
+
+        db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
+        ntf = swsscommon.NotificationProducer(db, "SAI_VS_UNITTEST_CHANNEL")
+
+        r = redis.Redis(unix_socket_path=dvs.redis_sock, db=swsscommon.ASIC_DB)
+        rid = r.hget("VIDTORID", obj_id)
+
+        assert rid is not None
+        fvp = swsscommon.FieldValuePairs([(attr, val)])
+        key = rid
+
+        ntf.send("set_stats", key, fvp)
+
+    def populate_asic(self, dvs, val):
+        for obj_id in self.pgs:
+            self.set_counter(dvs, obj_id, pg_drop_attr, val)
+
+    def verify_value(self, dvs, obj_ids, entry_name, expected_value):
+        counters_db = swsscommon.DBConnector(swsscommon.COUNTERS_DB, dvs.redis_sock, 0)
+        table = swsscommon.Table(counters_db, "COUNTERS")
+
+        for obj_id in obj_ids:
+            ret = table.get(obj_id)
+            status = ret[0]
+            assert status
+            keyvalues = ret[1]
+            found = False
+            for key, value in keyvalues:
+              if key == entry_name:
+                  assert value == expected_value, "Saved value not the same as expected"
+                  found = True
+            assert found, "no such entry found"
+
+    def get_oids(self, dvs, obj_type):
+        db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
+        tbl = swsscommon.Table(db, "ASIC_STATE:{0}".format(obj_type))
+        keys = tbl.getKeys()
+        return keys
+
+    def set_up_flex_counter(self, dvs):
+        for pg in self.pgs:
+            dvs.runcmd("redis-cli -n 5 hset 'FLEX_COUNTER_TABLE:PG_DROP_STAT_COUNTER:{}' ".format(pg) + "PG_COUNTER_ID_LIST '{}'".format(pg_drop_attr))
+
+        dvs.runcmd("redis-cli -n 4 hset 'FLEX_COUNTER_TABLE|PG_DROP' 'FLEX_COUNTER_STATUS' 'enable'")
+
+        self.populate_asic(dvs, "0")
+
+
+    def test_pg_drop(self, dvs):
+        try:
+            self.pgs = self.get_oids(dvs, "SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP")
+            self.set_up_flex_counter(dvs)
+
+            self.populate_asic(dvs, "100")
+            time.sleep(self.DEFAULT_POLL_INTERVAL + 1)
+            self.verify_value(dvs, self.pgs, pg_drop_attr , "100")
+
+            self.populate_asic(dvs, "123")
+            time.sleep(self.DEFAULT_POLL_INTERVAL + 1)
+            self.verify_value(dvs, self.pgs, pg_drop_attr, "123")
+        finally:
+            dvs.runcmd("redis-cli -n 4 DEL 'FLEX_COUNTER_TABLE|PG_DROP'")
+
+            for pg in self.pgs:
+                dvs.runcmd("redis-cli -n 5 DEL 'FLEX_COUNTER_TABLE:PG_DROP_STAT_COUNTER:{}' ".format(pg))
+
+