[flex counter] handle router interface stats (#410)

mykolaf · lguohan · commit 145ea447bca1 · 2019-02-01T20:02:29.000-08:00
* [flex counter] handle router interface stats

Signed-off-by: Mykola Faryma &lt;mykolaf@mellanox.com&gt;

* allign with new SAI headers

Signed-off-by: Mykola Faryma &lt;mykolaf@mellanox.com&gt;

* update aspellcheck dictionary

Signed-off-by: Mykola Faryma &lt;mykolaf@mellanox.com&gt;
diff --git a/meta/sai_serialize.h b/meta/sai_serialize.h
@@ -90,6 +90,9 @@ std::string sai_serialize_port_pool_stat(
 std::string sai_serialize_queue_stat(
         _In_ const sai_queue_stat_t counter);
 
+std::string sai_serialize_router_interface_stat(
+        _In_ const sai_router_interface_stat_t counter);
+
 std::string sai_serialize_ingress_priority_group_stat(
         _In_ const sai_ingress_priority_group_stat_t counter);
 
diff --git a/meta/saiserialize.cpp b/meta/saiserialize.cpp
@@ -826,6 +826,14 @@ std::string sai_serialize_queue_stat(
     return sai_serialize_enum(counter, &sai_metadata_enum_sai_queue_stat_t);
 }
 
+std::string sai_serialize_router_interface_stat(
+        _In_ const sai_router_interface_stat_t counter)
+{
+    SWSS_LOG_ENTER();
+
+    return sai_serialize_enum(counter, &sai_metadata_enum_sai_router_interface_stat_t);
+}
+
 std::string sai_serialize_ingress_priority_group_stat(
         _In_ const sai_ingress_priority_group_stat_t counter)
 {
diff --git a/syncd/syncd.cpp b/syncd/syncd.cpp
@@ -2884,6 +2884,10 @@ void processFlexCounterEvent(
         {
             FlexCounter::removePriorityGroup(vid, groupName);
         }
+        else if (objectType == SAI_OBJECT_TYPE_ROUTER_INTERFACE)
+        {
+            FlexCounter::removeRif(vid, groupName);
+        }
         else
         {
             SWSS_LOG_ERROR("Object type for removal not supported, %s", objectTypeStr.c_str());
@@ -2957,6 +2961,17 @@ void processFlexCounterEvent(
 
                 FlexCounter::setPriorityGroupAttrList(vid, rid, groupName, pgAttrIds);
             }
+            else if (objectType == SAI_OBJECT_TYPE_ROUTER_INTERFACE && field == RIF_COUNTER_ID_LIST)
+            {
+                std::vector<sai_router_interface_stat_t> rifCounterIds;
+                for (const auto &str : idStrings)
+                {
+                    sai_router_interface_stat_t stat;
+                    sai_deserialize_router_interface_stat(str.c_str(), &stat);
+                    rifCounterIds.push_back(stat);
+                }
+                FlexCounter::setRifCounterList(vid, rid, groupName, rifCounterIds);
+            }
             else
             {
                 SWSS_LOG_ERROR("Object type and field combination is not supported, object type %s, field %s", objectTypeStr.c_str(), field.c_str());
diff --git a/syncd/syncd_flex_counter.cpp b/syncd/syncd_flex_counter.cpp
@@ -8,6 +8,7 @@ static std::map<std::string, std::shared_ptr<FlexCounter>> g_flex_counters_map;
 static std::set<sai_port_stat_t> supportedPortCounters;
 static std::set<sai_queue_stat_t> supportedQueueCounters;
 static std::set<sai_ingress_priority_group_stat_t> supportedPriorityGroupCounters;
+static std::set<sai_router_interface_stat_t> supportedRifCounters;
 
 FlexCounter::PortCounterIds::PortCounterIds(
         _In_ sai_object_id_t port,
@@ -49,6 +50,14 @@ FlexCounter::IngressPriorityGroupCounterIds::IngressPriorityGroupCounterIds(
     SWSS_LOG_ENTER();
 }
 
+FlexCounter::RifCounterIds::RifCounterIds(
+        _In_ sai_object_id_t rif,
+        _In_ const std::vector<sai_router_interface_stat_t> &rifIds):
+    rifId(rif), rifCounterIds(rifIds)
+{
+    SWSS_LOG_ENTER();
+}
+
 void FlexCounter::setPollInterval(
         _In_ uint32_t pollInterval,
         _In_ std::string instanceId)
@@ -364,6 +373,62 @@ void FlexCounter::setPriorityGroupAttrList(
     }
 }
 
+void FlexCounter::setRifCounterList(
+        _In_ sai_object_id_t rifVid,
+        _In_ sai_object_id_t rifId,
+        _In_ std::string instanceId,
+        _In_ const std::vector<sai_router_interface_stat_t> &counterIds)
+{
+    SWSS_LOG_ENTER();
+
+    FlexCounter &fc = getInstance(instanceId);
+
+    // Initialize the supported counters list before setting
+    if (supportedRifCounters.empty())
+    {
+        fc.saiUpdateSupportedRifCounters(rifId);
+    }
+
+    // Remove unsupported counters
+    std::vector<sai_router_interface_stat_t> supportedIds;
+    for (auto &counter : counterIds)
+    {
+        if (fc.isRifCounterSupported(counter))
+        {
+            supportedIds.push_back(counter);
+        }
+    }
+
+    if (supportedIds.empty())
+    {
+        SWSS_LOG_ERROR("Router interface %s does not have supported counters", sai_serialize_object_id(rifId).c_str());
+
+        // Remove flex counter if all counter IDs and plugins are unregistered
+        if (fc.isEmpty())
+        {
+            removeInstance(instanceId);
+        }
+
+        return;
+    }
+
+    auto it = fc.m_rifCounterIdsMap.find(rifVid);
+    if (it != fc.m_rifCounterIdsMap.end())
+    {
+        (*it).second->rifCounterIds = supportedIds;
+        return;
+    }
+
+    auto rifCounterIds = std::make_shared<RifCounterIds>(rifId, supportedIds);
+    fc.m_rifCounterIdsMap.emplace(rifVid, rifCounterIds);
+
+    // Start flex counter thread in case it was not running due to empty counter IDs map
+    if (fc.m_pollInterval > 0)
+    {
+        fc.startFlexCounterThread();
+    }
+}
+
 void FlexCounter::removePort(
         _In_ sai_object_id_t portVid,
         _In_ std::string instanceId)
@@ -465,6 +530,35 @@ void FlexCounter::removePriorityGroup(
     }
 }
 
+void FlexCounter::removeRif(
+        _In_ sai_object_id_t rifVid,
+        _In_ std::string instanceId)
+{
+    SWSS_LOG_ENTER();
+
+    FlexCounter &fc = getInstance(instanceId);
+
+    auto it = fc.m_rifCounterIdsMap.find(rifVid);
+    if (it == fc.m_rifCounterIdsMap.end())
+    {
+        SWSS_LOG_NOTICE("Trying to remove nonexisting router interface counter from Id 0x%lx", rifVid);
+        // Remove flex counter if all counter IDs and plugins are unregistered
+        if (fc.isEmpty())
+        {
+            removeInstance(instanceId);
+        }
+        return;
+    }
+
+    fc.m_rifCounterIdsMap.erase(it);
+
+    // Remove flex counter if all counter IDs and plugins are unregistered
+    if (fc.isEmpty())
+    {
+        removeInstance(instanceId);
+    }
+}
+
 void FlexCounter::addPortCounterPlugin(
         _In_ std::string sha,
         _In_ std::string instanceId)
@@ -609,6 +703,13 @@ bool FlexCounter::isPriorityGroupCounterSupported(sai_ingress_priority_group_sta
     return supportedPriorityGroupCounters.count(counter) != 0;
 }
 
+bool FlexCounter::isRifCounterSupported(sai_router_interface_stat_t counter) const
+{
+    SWSS_LOG_ENTER();
+
+    return supportedRifCounters.count(counter) != 0;
+}
+
 FlexCounter::FlexCounter(std::string instanceId) : m_instanceId(instanceId)
 {
     SWSS_LOG_ENTER();
@@ -644,6 +745,7 @@ void FlexCounter::collectCounters(
     std::map<sai_object_id_t, std::shared_ptr<QueueAttrIds>> queueAttrIdsMap;
     std::map<sai_object_id_t, std::shared_ptr<IngressPriorityGroupCounterIds>> priorityGroupCounterIdsMap;
     std::map<sai_object_id_t, std::shared_ptr<IngressPriorityGroupAttrIds>> priorityGroupAttrIdsMap;
+    std::map<sai_object_id_t, std::shared_ptr<RifCounterIds>> rifCounterIdsMap;
 
     {
         std::lock_guard<std::mutex> lock(g_mutex);
@@ -652,6 +754,7 @@ void FlexCounter::collectCounters(
         queueAttrIdsMap = m_queueAttrIdsMap;
         priorityGroupCounterIdsMap = m_priorityGroupCounterIdsMap;
         priorityGroupAttrIdsMap = m_priorityGroupAttrIdsMap;
+        rifCounterIdsMap = m_rifCounterIdsMap;
     }
 
     // Collect stats for every registered port
@@ -870,6 +973,41 @@ void FlexCounter::collectCounters(
 
         countersTable.set(priorityGroupVidStr, values, "");
     }
+    // Collect stats for every registered router interface
+    for (const auto &kv: rifCounterIdsMap)
+    {
+        const auto &rifVid = kv.first;
+        const auto &rifId = kv.second->rifId;
+        const auto &rifCounterIds = kv.second->rifCounterIds;
+
+        std::vector<uint64_t> rifStats(rifCounterIds.size());
+
+        // Get rif stats
+        sai_status_t status = sai_metadata_sai_router_interface_api->get_router_interface_stats(
+                rifId,
+                static_cast<uint32_t>(rifCounterIds.size()),
+                (const sai_stat_id_t *)rifCounterIds.data(),
+                rifStats.data());
+        if (status != SAI_STATUS_SUCCESS)
+        {
+            SWSS_LOG_ERROR("Failed to get stats of router interface 0x%lx: %d", rifId, status);
+            continue;
+        }
+
+        // Push all counter values to a single vector
+        std::vector<swss::FieldValueTuple> values;
+
+        for (size_t i = 0; i != rifCounterIds.size(); i++)
+        {
+            const std::string &counterName = sai_serialize_router_interface_stat(rifCounterIds[i]);
+            values.emplace_back(counterName, std::to_string(rifStats[i]));
+        }
+
+        // Write counters to DB
+        std::string rifVidStr = sai_serialize_object_id(rifVid);
+
+        countersTable.set(rifVidStr, values, "");
+    }
 
     countersTable.flush();
 }
@@ -1094,3 +1232,28 @@ void FlexCounter::saiUpdateSupportedPriorityGroupCounters(
         }
     }
 }
+
+void FlexCounter::saiUpdateSupportedRifCounters(sai_object_id_t rifId)
+{
+    SWSS_LOG_ENTER();
+
+    uint64_t value;
+    for (int cntr_id = SAI_ROUTER_INTERFACE_STAT_IN_OCTETS; cntr_id <= SAI_ROUTER_INTERFACE_STAT_OUT_ERROR_PACKETS; ++cntr_id)
+    {
+        sai_router_interface_stat_t counter = static_cast<sai_router_interface_stat_t>(cntr_id);
+
+        sai_status_t status = sai_metadata_sai_router_interface_api->get_router_interface_stats(rifId, 1, (const sai_stat_id_t *)&counter, &value);
+
+        if (status != SAI_STATUS_SUCCESS)
+        {
+            SWSS_LOG_INFO("Counter %s is not supported on router interface RID %s: %s",
+                    sai_serialize_router_interface_stat(counter).c_str(),
+                    sai_serialize_object_id(rifId).c_str(),
+                    sai_serialize_status(status).c_str());
+
+            continue;
+        }
+
+        supportedRifCounters.insert(counter);
+    }
+}
diff --git a/syncd/syncd_flex_counter.h b/syncd/syncd_flex_counter.h
@@ -32,6 +32,11 @@ class FlexCounter
                 _In_ sai_object_id_t priorityGroupId,
                 _In_ std::string instanceId,
                 _In_ const std::vector<sai_ingress_priority_group_stat_t> &counterIds);
+        static void setRifCounterList(
+                _In_ sai_object_id_t rifVid,
+                _In_ sai_object_id_t rifId,
+                _In_ std::string instanceId,
+                _In_ const std::vector<sai_router_interface_stat_t> &counterIds);
         static void setQueueAttrList(
                 _In_ sai_object_id_t queueVid,
                 _In_ sai_object_id_t queueId,
@@ -58,6 +63,9 @@ class FlexCounter
         static void removePriorityGroup(
                 _In_ sai_object_id_t priorityGroupVid,
                 _In_ std::string instanceId);
+        static void removeRif(
+                _In_ sai_object_id_t rifVid,
+                _In_ std::string instanceId);
 
         static void addPortCounterPlugin(
                 _In_ std::string sha,
@@ -130,6 +138,16 @@ class FlexCounter
             std::vector<sai_port_stat_t> portCounterIds;
         };
 
+        struct RifCounterIds
+        {
+            RifCounterIds(
+                    _In_ sai_object_id_t rif,
+                    _In_ const std::vector<sai_router_interface_stat_t> &rifIds);
+
+            sai_object_id_t rifId;
+            std::vector<sai_router_interface_stat_t> rifCounterIds;
+        };
+
         FlexCounter(std::string instanceId);
         static FlexCounter& getInstance(std::string instanceId);
         static void removeInstance(std::string instanceId);
@@ -143,9 +161,11 @@ class FlexCounter
         void saiUpdateSupportedPortCounters(sai_object_id_t portId);
         void saiUpdateSupportedQueueCounters(sai_object_id_t queueId, const std::vector<sai_queue_stat_t> &counterIds);
         void saiUpdateSupportedPriorityGroupCounters(sai_object_id_t priorityGroupId, const std::vector<sai_ingress_priority_group_stat_t> &counterIds);
+        void saiUpdateSupportedRifCounters(sai_object_id_t rifId);
         bool isPortCounterSupported(sai_port_stat_t counter) const;
         bool isQueueCounterSupported(sai_queue_stat_t counter) const;
         bool isPriorityGroupCounterSupported(sai_ingress_priority_group_stat_t counter) const;
+        bool isRifCounterSupported(sai_router_interface_stat_t counter) const;
         bool isEmpty();
 
         // Key is a Virtual ID
@@ -154,6 +174,7 @@ class FlexCounter
         std::map<sai_object_id_t, std::shared_ptr<QueueAttrIds>> m_queueAttrIdsMap;
         std::map<sai_object_id_t, std::shared_ptr<IngressPriorityGroupCounterIds>> m_priorityGroupCounterIdsMap;
         std::map<sai_object_id_t, std::shared_ptr<IngressPriorityGroupAttrIds>> m_priorityGroupAttrIdsMap;
+        std::map<sai_object_id_t, std::shared_ptr<RifCounterIds>> m_rifCounterIdsMap;
 
         // Plugins
         std::set<std::string> m_queuePlugins;
diff --git a/tests/aspell.en.pws b/tests/aspell.en.pws
@@ -150,6 +150,8 @@ removedVidToRid
 RID
 RIDs
 RIDTOVID
+rif
+RIF
 RO
 RPC
 runtime

Original file line number	Diff line number	Diff line change
`@@ -826,6 +826,14 @@ std::string sai_serialize_queue_stat(`
`826`	`826`	`return sai_serialize_enum(counter, &sai_metadata_enum_sai_queue_stat_t);`
`827`	`827`	`}`
`828`	`828`
	`829`	`+std::string sai_serialize_router_interface_stat(`
	`830`	`+ _In_ const sai_router_interface_stat_t counter)`
	`831`	`+{`
	`832`	`+ SWSS_LOG_ENTER();`
	`833`	`+`
	`834`	`+ return sai_serialize_enum(counter, &sai_metadata_enum_sai_router_interface_stat_t);`
	`835`	`+}`
	`836`	`+`
`829`	`837`	`std::string sai_serialize_ingress_priority_group_stat(`
`830`	`838`	`_In_ const sai_ingress_priority_group_stat_t counter)`
`831`	`839`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2884,6 +2884,10 @@ void processFlexCounterEvent(`
`2884`	`2884`	`{`
`2885`	`2885`	`FlexCounter::removePriorityGroup(vid, groupName);`
`2886`	`2886`	`}`
	`2887`	`+ else if (objectType == SAI_OBJECT_TYPE_ROUTER_INTERFACE)`
	`2888`	`+ {`
	`2889`	`+ FlexCounter::removeRif(vid, groupName);`
	`2890`	`+ }`
`2887`	`2891`	`else`
`2888`	`2892`	`{`
`2889`	`2893`	`SWSS_LOG_ERROR("Object type for removal not supported, %s", objectTypeStr.c_str());`
`@@ -2957,6 +2961,17 @@ void processFlexCounterEvent(`
`2957`	`2961`
`2958`	`2962`	`FlexCounter::setPriorityGroupAttrList(vid, rid, groupName, pgAttrIds);`
`2959`	`2963`	`}`
	`2964`	`+ else if (objectType == SAI_OBJECT_TYPE_ROUTER_INTERFACE && field == RIF_COUNTER_ID_LIST)`
	`2965`	`+ {`
	`2966`	`+ std::vector<sai_router_interface_stat_t> rifCounterIds;`
	`2967`	`+ for (const auto &str : idStrings)`
	`2968`	`+ {`
	`2969`	`+ sai_router_interface_stat_t stat;`
	`2970`	`+ sai_deserialize_router_interface_stat(str.c_str(), &stat);`
	`2971`	`+ rifCounterIds.push_back(stat);`
	`2972`	`+ }`
	`2973`	`+ FlexCounter::setRifCounterList(vid, rid, groupName, rifCounterIds);`
	`2974`	`+ }`
`2960`	`2975`	`else`
`2961`	`2976`	`{`
`2962`	`2977`	`SWSS_LOG_ERROR("Object type and field combination is not supported, object type %s, field %s", objectTypeStr.c_str(), field.c_str());`
-Original file line number
+Diff line change
 RID
 RIDs
 RIDTOVID
 +rif
 +RIF
 RO
 RPC
 runtime