Skip to content

Commit ad8f5e4

Browse files
yxiecayxieca
authored
Revert "[Counters] Improve performance by polling only configured ports buffer queue/pg counters (#2143)" (#2315)
This reverts commit eba212d.
1 parent 2ff763f commit ad8f5e4

11 files changed

Lines changed: 223 additions & 556 deletions

‎orchagent/bufferorch.cpp‎

Lines changed: 1 addition & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
#include "tokenize.h"
22
#include "bufferorch.h"
3-
#include "directory.h"
43
#include "logger.h"
54
#include "sai_serialize.h"
65
#include "warm_restart.h"
@@ -17,7 +16,6 @@ extern sai_switch_api_t *sai_switch_api;
1716
extern sai_buffer_api_t *sai_buffer_api;
1817

1918
extern PortsOrch *gPortsOrch;
20-
extern Directory<Orch*> gDirectory;
2119
extern sai_object_id_t gSwitchId;
2220

2321
#define BUFFER_POOL_WATERMARK_FLEX_STAT_COUNTER_POLL_MSECS "60000"
@@ -950,20 +948,6 @@ task_process_status BufferOrch::processQueue(KeyOpFieldsValuesTuple &tuple)
950948
return handle_status;
951949
}
952950
}
953-
// create/remove a port queue counter for the queue buffer
954-
else
955-
{
956-
auto flexCounterOrch = gDirectory.get<FlexCounterOrch*>();
957-
auto queues = tokens[1];
958-
if (op == SET_COMMAND && flexCounterOrch->getQueueCountersState())
959-
{
960-
gPortsOrch->createPortBufferQueueCounters(port, queues);
961-
}
962-
else if (op == DEL_COMMAND && flexCounterOrch->getQueueCountersState())
963-
{
964-
gPortsOrch->removePortBufferQueueCounters(port, queues);
965-
}
966-
}
967951
}
968952
}
969953
}
@@ -1023,7 +1007,7 @@ task_process_status BufferOrch::processPriorityGroup(KeyOpFieldsValuesTuple &tup
10231007
if (op == SET_COMMAND)
10241008
{
10251009
ref_resolve_status resolve_result = resolveFieldRefValue(m_buffer_type_maps, buffer_profile_field_name,
1026-
buffer_to_ref_table_map.at(buffer_profile_field_name), tuple,
1010+
buffer_to_ref_table_map.at(buffer_profile_field_name), tuple,
10271011
sai_buffer_profile, buffer_profile_name);
10281012
if (ref_resolve_status::success != resolve_result)
10291013
{
@@ -1103,20 +1087,6 @@ task_process_status BufferOrch::processPriorityGroup(KeyOpFieldsValuesTuple &tup
11031087
return handle_status;
11041088
}
11051089
}
1106-
// create or remove a port PG counter for the PG buffer
1107-
else
1108-
{
1109-
auto flexCounterOrch = gDirectory.get<FlexCounterOrch*>();
1110-
auto pgs = tokens[1];
1111-
if (op == SET_COMMAND && flexCounterOrch->getPgWatermarkCountersState())
1112-
{
1113-
gPortsOrch->createPortBufferPgCounters(port, pgs);
1114-
}
1115-
else if (op == DEL_COMMAND && flexCounterOrch->getPgWatermarkCountersState())
1116-
{
1117-
gPortsOrch->removePortBufferPgCounters(port, pgs);
1118-
}
1119-
}
11201090
}
11211091
}
11221092
}

‎orchagent/flexcounterorch.cpp‎

Lines changed: 2 additions & 179 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@
1010
#include "debugcounterorch.h"
1111
#include "directory.h"
1212
#include "copporch.h"
13-
#include <swss/tokenize.h>
1413
#include "routeorch.h"
1514
#include "flowcounterrouteorch.h"
1615

@@ -59,8 +58,6 @@ unordered_map<string, string> flexCounterGroupMap =
5958
FlexCounterOrch::FlexCounterOrch(DBConnector *db, vector<string> &tableNames):
6059
Orch(db, tableNames),
6160
m_flexCounterConfigTable(db, CFG_FLEX_COUNTER_TABLE_NAME),
62-
m_bufferQueueConfigTable(db, CFG_BUFFER_QUEUE_TABLE_NAME),
63-
m_bufferPgConfigTable(db, CFG_BUFFER_PG_TABLE_NAME),
6461
m_flexCounterDb(new DBConnector("FLEX_COUNTER_DB", 0)),
6562
m_flexCounterGroupTable(new ProducerTable(m_flexCounterDb.get(), FLEX_COUNTER_GROUP_TABLE))
6663
{
@@ -147,13 +144,11 @@ void FlexCounterOrch::doTask(Consumer &consumer)
147144
}
148145
else if(key == QUEUE_KEY)
149146
{
150-
gPortsOrch->generateQueueMap(getQueueConfigurations());
151-
m_queue_enabled = true;
147+
gPortsOrch->generateQueueMap();
152148
}
153149
else if(key == PG_WATERMARK_KEY)
154150
{
155-
gPortsOrch->generatePriorityGroupMap(getPgConfigurations());
156-
m_pg_watermark_enabled = true;
151+
gPortsOrch->generatePriorityGroupMap();
157152
}
158153
}
159154
if(gIntfsOrch && (key == RIF_KEY) && (value == "enable"))
@@ -235,16 +230,6 @@ bool FlexCounterOrch::getPortBufferDropCountersState() const
235230
return m_port_buffer_drop_counter_enabled;
236231
}
237232

238-
bool FlexCounterOrch::getPgWatermarkCountersState() const
239-
{
240-
return m_pg_watermark_enabled;
241-
}
242-
243-
bool FlexCounterOrch::getQueueCountersState() const
244-
{
245-
return m_queue_enabled;
246-
}
247-
248233
bool FlexCounterOrch::bake()
249234
{
250235
/*
@@ -286,165 +271,3 @@ bool FlexCounterOrch::bake()
286271
Consumer* consumer = dynamic_cast<Consumer *>(getExecutor(CFG_FLEX_COUNTER_TABLE_NAME));
287272
return consumer->addToSync(entries);
288273
}
289-
290-
map<string, FlexCounterQueueStates> FlexCounterOrch::getQueueConfigurations()
291-
{
292-
SWSS_LOG_ENTER();
293-
294-
map<string, FlexCounterQueueStates> queuesStateVector;
295-
std::vector<std::string> portQueueKeys;
296-
m_bufferQueueConfigTable.getKeys(portQueueKeys);
297-
298-
for (const auto& portQueueKey : portQueueKeys)
299-
{
300-
auto toks = tokenize(portQueueKey, '|');
301-
if (toks.size() != 2)
302-
{
303-
SWSS_LOG_ERROR("Invalid BUFFER_QUEUE key: [%s]", portQueueKey.c_str());
304-
continue;
305-
}
306-
307-
auto configPortNames = tokenize(toks[0], ',');
308-
auto configPortQueues = toks[1];
309-
toks = tokenize(configPortQueues, '-');
310-
311-
for (const auto& configPortName : configPortNames)
312-
{
313-
uint32_t maxQueueNumber = gPortsOrch->getNumberOfPortSupportedQueueCounters(configPortName);
314-
uint32_t maxQueueIndex = maxQueueNumber - 1;
315-
uint32_t minQueueIndex = 0;
316-
317-
if (!queuesStateVector.count(configPortName))
318-
{
319-
FlexCounterQueueStates flexCounterQueueState(maxQueueNumber);
320-
queuesStateVector.insert(make_pair(configPortName, flexCounterQueueState));
321-
}
322-
323-
try {
324-
auto startIndex = to_uint<uint32_t>(toks[0], minQueueIndex, maxQueueIndex);
325-
if (toks.size() > 1)
326-
{
327-
auto endIndex = to_uint<uint32_t>(toks[1], minQueueIndex, maxQueueIndex);
328-
queuesStateVector.at(configPortName).enableQueueCounters(startIndex, endIndex);
329-
}
330-
else
331-
{
332-
queuesStateVector.at(configPortName).enableQueueCounter(startIndex);
333-
}
334-
} catch (std::invalid_argument const& e) {
335-
SWSS_LOG_ERROR("Invalid queue index [%s] for port [%s]", configPortQueues.c_str(), configPortName.c_str());
336-
continue;
337-
}
338-
}
339-
}
340-
341-
return queuesStateVector;
342-
}
343-
344-
map<string, FlexCounterPgStates> FlexCounterOrch::getPgConfigurations()
345-
{
346-
SWSS_LOG_ENTER();
347-
348-
map<string, FlexCounterPgStates> pgsStateVector;
349-
std::vector<std::string> portPgKeys;
350-
m_bufferPgConfigTable.getKeys(portPgKeys);
351-
352-
for (const auto& portPgKey : portPgKeys)
353-
{
354-
auto toks = tokenize(portPgKey, '|');
355-
if (toks.size() != 2)
356-
{
357-
SWSS_LOG_ERROR("Invalid BUFFER_PG key: [%s]", portPgKey.c_str());
358-
continue;
359-
}
360-
361-
auto configPortNames = tokenize(toks[0], ',');
362-
auto configPortPgs = toks[1];
363-
toks = tokenize(configPortPgs, '-');
364-
365-
for (const auto& configPortName : configPortNames)
366-
{
367-
uint32_t maxPgNumber = gPortsOrch->getNumberOfPortSupportedPgCounters(configPortName);
368-
uint32_t maxPgIndex = maxPgNumber - 1;
369-
uint32_t minPgIndex = 0;
370-
371-
if (!pgsStateVector.count(configPortName))
372-
{
373-
FlexCounterPgStates flexCounterPgState(maxPgNumber);
374-
pgsStateVector.insert(make_pair(configPortName, flexCounterPgState));
375-
}
376-
377-
try {
378-
auto startIndex = to_uint<uint32_t>(toks[0], minPgIndex, maxPgIndex);
379-
if (toks.size() > 1)
380-
{
381-
auto endIndex = to_uint<uint32_t>(toks[1], minPgIndex, maxPgIndex);
382-
pgsStateVector.at(configPortName).enablePgCounters(startIndex, endIndex);
383-
}
384-
else
385-
{
386-
pgsStateVector.at(configPortName).enablePgCounter(startIndex);
387-
}
388-
} catch (std::invalid_argument const& e) {
389-
SWSS_LOG_ERROR("Invalid pg index [%s] for port [%s]", configPortPgs.c_str(), configPortName.c_str());
390-
continue;
391-
}
392-
}
393-
}
394-
395-
return pgsStateVector;
396-
}
397-
398-
FlexCounterQueueStates::FlexCounterQueueStates(uint32_t maxQueueNumber)
399-
{
400-
SWSS_LOG_ENTER();
401-
m_queueStates.resize(maxQueueNumber, false);
402-
}
403-
404-
bool FlexCounterQueueStates::isQueueCounterEnabled(uint32_t index) const
405-
{
406-
SWSS_LOG_ENTER();
407-
return m_queueStates[index];
408-
}
409-
410-
void FlexCounterQueueStates::enableQueueCounters(uint32_t startIndex, uint32_t endIndex)
411-
{
412-
SWSS_LOG_ENTER();
413-
for (uint32_t queueIndex = startIndex; queueIndex <= endIndex; queueIndex++)
414-
{
415-
enableQueueCounter(queueIndex);
416-
}
417-
}
418-
419-
void FlexCounterQueueStates::enableQueueCounter(uint32_t queueIndex)
420-
{
421-
SWSS_LOG_ENTER();
422-
m_queueStates[queueIndex] = true;
423-
}
424-
425-
FlexCounterPgStates::FlexCounterPgStates(uint32_t maxPgNumber)
426-
{
427-
SWSS_LOG_ENTER();
428-
m_pgStates.resize(maxPgNumber, false);
429-
}
430-
431-
bool FlexCounterPgStates::isPgCounterEnabled(uint32_t index) const
432-
{
433-
SWSS_LOG_ENTER();
434-
return m_pgStates[index];
435-
}
436-
437-
void FlexCounterPgStates::enablePgCounters(uint32_t startIndex, uint32_t endIndex)
438-
{
439-
SWSS_LOG_ENTER();
440-
for (uint32_t pgIndex = startIndex; pgIndex <= endIndex; pgIndex++)
441-
{
442-
enablePgCounter(pgIndex);
443-
}
444-
}
445-
446-
void FlexCounterPgStates::enablePgCounter(uint32_t pgIndex)
447-
{
448-
SWSS_LOG_ENTER();
449-
m_pgStates[pgIndex] = true;
450-
}

‎orchagent/flexcounterorch.h‎

Lines changed: 0 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -10,30 +10,6 @@ extern "C" {
1010
#include "sai.h"
1111
}
1212

13-
class FlexCounterQueueStates
14-
{
15-
public:
16-
FlexCounterQueueStates(uint32_t maxQueueNumber);
17-
bool isQueueCounterEnabled(uint32_t index) const;
18-
void enableQueueCounters(uint32_t startIndex, uint32_t endIndex);
19-
void enableQueueCounter(uint32_t queueIndex);
20-
21-
private:
22-
std::vector<bool> m_queueStates{};
23-
};
24-
25-
class FlexCounterPgStates
26-
{
27-
public:
28-
FlexCounterPgStates(uint32_t maxPgNumber);
29-
bool isPgCounterEnabled(uint32_t index) const;
30-
void enablePgCounters(uint32_t startIndex, uint32_t endIndex);
31-
void enablePgCounter(uint32_t pgIndex);
32-
33-
private:
34-
std::vector<bool> m_pgStates{};
35-
};
36-
3713
class FlexCounterOrch: public Orch
3814
{
3915
public:
@@ -42,10 +18,6 @@ class FlexCounterOrch: public Orch
4218
virtual ~FlexCounterOrch(void);
4319
bool getPortCountersState() const;
4420
bool getPortBufferDropCountersState() const;
45-
bool getPgWatermarkCountersState() const;
46-
bool getQueueCountersState() const;
47-
map<string, FlexCounterQueueStates> getQueueConfigurations();
48-
map<string, FlexCounterPgStates> getPgConfigurations();
4921
bool getHostIfTrapCounterState() const {return m_hostif_trap_counter_enabled;}
5022
bool getRouteFlowCountersState() const {return m_route_flow_counter_enabled;}
5123
bool bake() override;
@@ -55,13 +27,9 @@ class FlexCounterOrch: public Orch
5527
std::shared_ptr<swss::ProducerTable> m_flexCounterGroupTable = nullptr;
5628
bool m_port_counter_enabled = false;
5729
bool m_port_buffer_drop_counter_enabled = false;
58-
bool m_pg_watermark_enabled = false;
59-
bool m_queue_enabled = false;
6030
bool m_hostif_trap_counter_enabled = false;
6131
bool m_route_flow_counter_enabled = false;
6232
Table m_flexCounterConfigTable;
63-
Table m_bufferQueueConfigTable;
64-
Table m_bufferPgConfigTable;
6533
};
6634

6735
#endif

0 commit comments

Comments
 (0)