Skip to content

Commit 28ec34a

Browse files
author
Sihui Han
committed
[Flex_counter]: Remove poll interval from db key
Signed-off-by: Sihui Han <[email protected]>
1 parent f8b9385 commit 28ec34a

3 files changed

Lines changed: 172 additions & 164 deletions

File tree

‎syncd/syncd.cpp‎

Lines changed: 72 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -2535,8 +2535,59 @@ sai_status_t processEvent(
25352535
return status;
25362536
}
25372537

2538+
void processFlexCounterGeneralFields(
2539+
_In_ swss::KeyOpFieldsValuesTuple kco,
2540+
_In_ std::string tableName)
2541+
{
2542+
SWSS_LOG_ENTER();
2543+
2544+
const auto &op = kfvOp(kco);
2545+
const auto values = kfvFieldsValues(kco);
2546+
2547+
if (op == DEL_COMMAND)
2548+
{
2549+
FlexCounter::removeCounterPlugin(tableName);
2550+
return;
2551+
}
2552+
2553+
for (const auto& valuePair : values)
2554+
{
2555+
const auto field = fvField(valuePair);
2556+
const auto value = fvValue(valuePair);
2557+
2558+
if (op == SET_COMMAND)
2559+
{
2560+
if (field == POLL_INTERVAL_FIELD)
2561+
{
2562+
FlexCounter::setPollInterval(stoi(value), tableName);
2563+
}
2564+
else if (field == QUEUE_PLUGIN_FIELD)
2565+
{
2566+
auto shaStrings = swss::tokenize(value, ',');
2567+
for (const auto &sha : shaStrings)
2568+
{
2569+
FlexCounter::addQueueCounterPlugin(sha, tableName);
2570+
}
2571+
}
2572+
else if (field == PORT_PLUGIN_FIELD)
2573+
{
2574+
auto shaStrings = swss::tokenize(value, ',');
2575+
for (const auto &sha : shaStrings)
2576+
{
2577+
FlexCounter::addPortCounterPlugin(sha, tableName);
2578+
}
2579+
}
2580+
else
2581+
{
2582+
SWSS_LOG_ERROR("Object type not supported");
2583+
}
2584+
}
2585+
}
2586+
}
2587+
25382588
void processFlexCounterEvent(
2539-
_In_ swss::ConsumerStateTable &consumer)
2589+
_In_ swss::ConsumerTable &consumer,
2590+
_In_ std::string tableName)
25402591
{
25412592
SWSS_LOG_ENTER();
25422593

@@ -2548,42 +2599,26 @@ void processFlexCounterEvent(
25482599
const auto &key = kfvKey(kco);
25492600
const auto &op = kfvOp(kco);
25502601

2551-
std::size_t delimiter = key.find_last_of(":");
2552-
2553-
if (delimiter == std::string::npos)
2602+
if (key == GENERAL)
25542603
{
2555-
SWSS_LOG_ERROR("Failed to parse the key %s", key.c_str());
2556-
return;
2557-
}
2558-
2559-
const auto intervalStr = key.substr(delimiter + 1);
2560-
const auto vidStr = key.substr(0, delimiter);
2561-
int pollInterval;
2562-
2563-
try
2564-
{
2565-
pollInterval = std::stoi(intervalStr);
2566-
}
2567-
catch(const std::invalid_argument)
2568-
{
2569-
SWSS_LOG_ERROR("Failed to convert the poll intervall, key = %s", key.c_str());
2604+
processFlexCounterGeneralFields(kco, tableName);
25702605
return;
25712606
}
25722607

25732608
sai_object_id_t vid = SAI_NULL_OBJECT_ID;
2574-
sai_deserialize_object_id(vidStr, vid);
2609+
sai_deserialize_object_id(key, vid);
25752610
sai_object_id_t rid = translate_vid_to_rid(vid);
25762611
sai_object_type_t objectType = sai_object_type_query(rid);
25772612

25782613
if (op == DEL_COMMAND)
25792614
{
25802615
if (objectType == SAI_OBJECT_TYPE_PORT)
25812616
{
2582-
FlexCounter::removePort(vid, pollInterval);
2617+
FlexCounter::removePort(vid, tableName);
25832618
}
25842619
else if (objectType == SAI_OBJECT_TYPE_QUEUE)
25852620
{
2586-
FlexCounter::removeQueue(vid, pollInterval);
2621+
FlexCounter::removeQueue(vid, tableName);
25872622
}
25882623
else
25892624
{
@@ -2601,7 +2636,7 @@ void processFlexCounterEvent(
26012636
{
26022637
auto idStrings = swss::tokenize(value, ',');
26032638

2604-
if (objectType == SAI_OBJECT_TYPE_PORT && field == PFC_WD_PORT_COUNTER_ID_LIST)
2639+
if (objectType == SAI_OBJECT_TYPE_PORT && field == PORT_COUNTER_ID_LIST)
26052640
{
26062641
std::vector<sai_port_stat_t> portCounterIds;
26072642
for (const auto &str : idStrings)
@@ -2610,9 +2645,9 @@ void processFlexCounterEvent(
26102645
sai_deserialize_port_stat(str, stat);
26112646
portCounterIds.push_back(stat);
26122647
}
2613-
FlexCounter::setPortCounterList(vid, rid, pollInterval, portCounterIds);
2648+
FlexCounter::setPortCounterList(vid, rid, tableName, portCounterIds);
26142649
}
2615-
else if (objectType == SAI_OBJECT_TYPE_QUEUE && field == PFC_WD_QUEUE_COUNTER_ID_LIST)
2650+
else if (objectType == SAI_OBJECT_TYPE_QUEUE && field == QUEUE_COUNTER_ID_LIST)
26162651
{
26172652
std::vector<sai_queue_stat_t> queueCounterIds;
26182653
for (const auto &str : idStrings)
@@ -2621,9 +2656,9 @@ void processFlexCounterEvent(
26212656
sai_deserialize_queue_stat(str, stat);
26222657
queueCounterIds.push_back(stat);
26232658
}
2624-
FlexCounter::setQueueCounterList(vid, rid, pollInterval, queueCounterIds);
2659+
FlexCounter::setQueueCounterList(vid, rid, tableName, queueCounterIds);
26252660
}
2626-
else if (objectType == SAI_OBJECT_TYPE_QUEUE && field == PFC_WD_QUEUE_ATTR_ID_LIST)
2661+
else if (objectType == SAI_OBJECT_TYPE_QUEUE && field == QUEUE_ATTR_ID_LIST)
26272662
{
26282663
std::vector<sai_queue_attr_t> queueAttrIds;
26292664
for (const auto &str : idStrings)
@@ -2633,7 +2668,7 @@ void processFlexCounterEvent(
26332668
queueAttrIds.push_back(attr);
26342669
}
26352670

2636-
FlexCounter::setQueueAttrList(vid, rid, pollInterval, queueAttrIds);
2671+
FlexCounter::setQueueAttrList(vid, rid, tableName, queueAttrIds);
26372672
}
26382673
else
26392674
{
@@ -2643,73 +2678,6 @@ void processFlexCounterEvent(
26432678
}
26442679
}
26452680

2646-
void processFlexCounterPluginEvent(
2647-
_In_ swss::ConsumerStateTable &consumer)
2648-
{
2649-
SWSS_LOG_ENTER();
2650-
2651-
std::lock_guard<std::mutex> lock(g_mutex);
2652-
2653-
swss::KeyOpFieldsValuesTuple kco;
2654-
consumer.pop(kco);
2655-
2656-
const auto &key = kfvKey(kco);
2657-
const auto &op = kfvOp(kco);
2658-
2659-
std::size_t delimiter = key.find_last_of(":");
2660-
2661-
if (delimiter == std::string::npos)
2662-
{
2663-
SWSS_LOG_ERROR("Failed to parse the key %s", key.c_str());
2664-
return;
2665-
}
2666-
2667-
const auto intervalStr = key.substr(delimiter + 1);
2668-
const auto sha = key.substr(0, delimiter);
2669-
int pollInterval;
2670-
2671-
try
2672-
{
2673-
pollInterval = std::stoi(intervalStr);
2674-
}
2675-
catch(const std::invalid_argument)
2676-
{
2677-
SWSS_LOG_ERROR("Failed to convert the poll intervall, key = %s", key.c_str());
2678-
return;
2679-
}
2680-
2681-
if (op == DEL_COMMAND)
2682-
{
2683-
FlexCounter::removeCounterPlugin(sha, pollInterval);
2684-
return;
2685-
}
2686-
2687-
const auto values = kfvFieldsValues(kco);
2688-
for (const auto& valuePair : values)
2689-
{
2690-
const auto field = fvField(valuePair);
2691-
const auto value = fvValue(valuePair);
2692-
2693-
if (field != SAI_OBJECT_TYPE)
2694-
{
2695-
continue;
2696-
}
2697-
2698-
if (value == sai_serialize_object_type(SAI_OBJECT_TYPE_PORT))
2699-
{
2700-
FlexCounter::addPortCounterPlugin(sha, pollInterval);
2701-
}
2702-
else if (value == sai_serialize_object_type(SAI_OBJECT_TYPE_QUEUE))
2703-
{
2704-
FlexCounter::addQueueCounterPlugin(sha, pollInterval);
2705-
}
2706-
else
2707-
{
2708-
SWSS_LOG_ERROR("Plugin for %s is not supported", value.c_str());
2709-
}
2710-
}
2711-
}
2712-
27132681
void printUsage()
27142682
{
27152683
SWSS_LOG_ENTER();
@@ -3292,14 +3260,14 @@ int syncd_main(int argc, char **argv)
32923260

32933261
std::shared_ptr<swss::DBConnector> dbAsic = std::make_shared<swss::DBConnector>(ASIC_DB, swss::DBConnector::DEFAULT_UNIXSOCKET, 0);
32943262
std::shared_ptr<swss::DBConnector> dbNtf = std::make_shared<swss::DBConnector>(ASIC_DB, swss::DBConnector::DEFAULT_UNIXSOCKET, 0);
3295-
std::shared_ptr<swss::DBConnector> dbFlexCounter = std::make_shared<swss::DBConnector>(PFC_WD_DB, swss::DBConnector::DEFAULT_UNIXSOCKET, 0);
3263+
std::shared_ptr<swss::DBConnector> dbFlexCounter = std::make_shared<swss::DBConnector>(FLEX_COUNTER_DB, swss::DBConnector::DEFAULT_UNIXSOCKET, 0);
32963264

32973265
g_redisClient = std::make_shared<swss::RedisClient>(dbAsic.get());
32983266

32993267
std::shared_ptr<swss::ConsumerTable> asicState = std::make_shared<swss::ConsumerTable>(dbAsic.get(), ASIC_STATE_TABLE);
33003268
std::shared_ptr<swss::NotificationConsumer> restartQuery = std::make_shared<swss::NotificationConsumer>(dbAsic.get(), "RESTARTQUERY");
3301-
std::shared_ptr<swss::ConsumerStateTable> flexCounterState = std::make_shared<swss::ConsumerStateTable>(dbFlexCounter.get(), PFC_WD_STATE_TABLE);
3302-
std::shared_ptr<swss::ConsumerStateTable> flexCounterPlugin = std::make_shared<swss::ConsumerStateTable>(dbFlexCounter.get(), PLUGIN_TABLE);
3269+
std::shared_ptr<swss::ConsumerTable> pfcWdFlexCounter = std::make_shared<swss::ConsumerTable>(dbFlexCounter.get(), FLEX_PFC_WD_TABLE);
3270+
std::shared_ptr<swss::ConsumerTable> statFlexCounter = std::make_shared<swss::ConsumerTable>(dbFlexCounter.get(), FLEX_STAT_COUNTER_TABLE);
33033271

33043272
/*
33053273
* At the end we cant use producer consumer concept since if one proces
@@ -3388,8 +3356,8 @@ int syncd_main(int argc, char **argv)
33883356

33893357
s.addSelectable(asicState.get());
33903358
s.addSelectable(restartQuery.get());
3391-
s.addSelectable(flexCounterState.get());
3392-
s.addSelectable(flexCounterPlugin.get());
3359+
s.addSelectable(pfcWdFlexCounter.get());
3360+
s.addSelectable(statFlexCounter.get());
33933361

33943362
SWSS_LOG_NOTICE("starting main loop");
33953363

@@ -3414,13 +3382,13 @@ int syncd_main(int argc, char **argv)
34143382
warmRestartHint = handleRestartQuery(*restartQuery);
34153383
break;
34163384
}
3417-
else if (sel == flexCounterState.get())
3385+
else if (sel == pfcWdFlexCounter.get())
34183386
{
3419-
processFlexCounterEvent(*(swss::ConsumerStateTable*)sel);
3387+
processFlexCounterEvent(*(swss::ConsumerTable*)sel, FLEX_PFC_WD_TABLE);
34203388
}
3421-
else if (sel == flexCounterPlugin.get())
3389+
else if (sel == statFlexCounter.get())
34223390
{
3423-
processFlexCounterPluginEvent(*(swss::ConsumerStateTable*)sel);
3391+
processFlexCounterEvent(*(swss::ConsumerTable*)sel, FLEX_STAT_COUNTER_TABLE);
34243392
}
34253393
else if (result == swss::Select::OBJECT)
34263394
{

0 commit comments

Comments
 (0)