Skip to content

Commit bc8ca4c

Browse files
stephenxsstephenxs
committed
Support setting bulk size
Signed-off-by: Stephen Sun <[email protected]>
1 parent 95858c8 commit bc8ca4c

4 files changed

Lines changed: 107 additions & 35 deletions

File tree

‎lib/RedisRemoteSaiInterface.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -568,6 +568,7 @@ sai_status_t RedisRemoteSaiInterface::notifyCounterGroupOperations(
568568
std::string key((const char*)flexCounterGroupParam->counter_group_name.list, flexCounterGroupParam->counter_group_name.count);
569569

570570
emplaceStrings(POLL_INTERVAL_FIELD, flexCounterGroupParam->poll_interval, entries);
571+
emplaceStrings(BULK_CHUNK_SIZE_FIELD, flexCounterGroupParam->bulk_chunk_size, entries);
571572
emplaceStrings(STATS_MODE_FIELD, flexCounterGroupParam->stats_mode, entries);
572573
emplaceStrings(flexCounterGroupParam->plugin_name, flexCounterGroupParam->plugins, entries);
573574
emplaceStrings(FLEX_COUNTER_STATUS_FIELD, flexCounterGroupParam->operation, entries);

‎lib/sairedis.h‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -140,6 +140,13 @@ typedef struct _sai_redis_flex_counter_group_parameter_t
140140
*/
141141
sai_s8_list_t plugins;
142142

143+
/**
144+
* @brief The bulk chunk size of the counter group
145+
*
146+
* It should be a number representing the bulk chunk size.
147+
*/
148+
sai_s8_list_t bulk_chunk_size;
149+
143150
} sai_redis_flex_counter_group_parameter_t;
144151

145152
typedef struct _sai_redis_flex_counter_parameter_t

‎syncd/FlexCounter.cpp‎

Lines changed: 91 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -39,8 +39,9 @@ const std::map<std::string, std::string> FlexCounter::m_plugIn2CounterType = {
3939
{TUNNEL_PLUGIN_FIELD, COUNTER_TYPE_TUNNEL},
4040
{FLOW_COUNTER_PLUGIN_FIELD, COUNTER_TYPE_FLOW}};
4141

42-
BaseCounterContext::BaseCounterContext(const std::string &name):
43-
m_name(name)
42+
BaseCounterContext::BaseCounterContext(const std::string &name, const std::string &instance):
43+
m_name(name),
44+
m_instanceId(instance)
4445
{
4546
SWSS_LOG_ENTER();
4647
}
@@ -71,6 +72,13 @@ void BaseCounterContext::setNoDoubleCheckBulkCapability(
7172
no_double_check_bulk_capability = noDoubleCheckBulkCapability;
7273
}
7374

75+
void BaseCounterContext::setBulkChunkSize(
76+
_In_ uint32_t bulkChunkSize)
77+
{
78+
SWSS_LOG_ENTER();
79+
default_bulk_chunk_size = bulkChunkSize;
80+
}
81+
7482
template <typename StatType,
7583
typename Enable = void>
7684
struct CounterIds
@@ -387,10 +395,11 @@ class CounterContext : public BaseCounterContext
387395

388396
CounterContext(
389397
_In_ const std::string &name,
398+
_In_ const std::string &instance,
390399
_In_ sai_object_type_t object_type,
391400
_In_ sairedis::SaiInterface *vendor_sai,
392401
_In_ sai_stats_mode_t &stats_mode):
393-
BaseCounterContext(name), m_objectType(object_type), m_vendorSai(vendor_sai), m_groupStatsMode(stats_mode)
402+
BaseCounterContext(name, instance), m_objectType(object_type), m_vendorSai(vendor_sai), m_groupStatsMode(stats_mode)
394403
{
395404
SWSS_LOG_ENTER();
396405
}
@@ -574,6 +583,9 @@ class CounterContext : public BaseCounterContext
574583
{
575584
return;
576585
}
586+
587+
SWSS_LOG_INFO("Before running plugin %s %s", m_instanceId.c_str(), m_name.c_str());
588+
577589
std::vector<std::string> idStrings;
578590
idStrings.reserve(m_objectIdsMap.size());
579591
std::transform(m_objectIdsMap.begin(),
@@ -592,6 +604,8 @@ class CounterContext : public BaseCounterContext
592604
std::for_each(m_plugins.begin(),
593605
m_plugins.end(),
594606
[&] (auto &sha) { runRedisScript(counters_db, sha, idStrings, argv); });
607+
608+
SWSS_LOG_INFO("After running plugin %s %s", m_instanceId.c_str(), m_name.c_str());
595609
}
596610

597611
bool hasObject() const override
@@ -694,20 +708,43 @@ class CounterContext : public BaseCounterContext
694708
{
695709
SWSS_LOG_ENTER();
696710
auto statsMode = m_groupStatsMode == SAI_STATS_MODE_READ ? SAI_STATS_MODE_BULK_READ : SAI_STATS_MODE_BULK_READ_AND_CLEAR;
697-
sai_status_t status = m_vendorSai->bulkGetStats(
698-
SAI_NULL_OBJECT_ID,
699-
m_objectType,
700-
static_cast<uint32_t>(ctx.object_keys.size()),
701-
ctx.object_keys.data(),
702-
static_cast<uint32_t>(ctx.counter_ids.size()),
703-
reinterpret_cast<const sai_stat_id_t *>(ctx.counter_ids.data()),
704-
statsMode,
705-
ctx.object_statuses.data(),
706-
ctx.counters.data());
707-
if (SAI_STATUS_SUCCESS != status)
711+
uint32_t bulk_chunk_size = default_bulk_chunk_size;
712+
uint32_t size = static_cast<uint32_t>(ctx.object_keys.size());
713+
if (bulk_chunk_size > size || bulk_chunk_size == 0)
708714
{
709-
SWSS_LOG_WARN("Failed to bulk get stats for %s: %u", m_name.c_str(), status);
715+
bulk_chunk_size = size;
710716
}
717+
uint32_t current = 0;
718+
719+
SWSS_LOG_INFO("Before getting bulk %s %s size %u bulk chunk size %u current %u", m_instanceId.c_str(), m_name.c_str(), size, bulk_chunk_size, current);
720+
721+
while (current < size)
722+
{
723+
sai_status_t status = m_vendorSai->bulkGetStats(
724+
SAI_NULL_OBJECT_ID,
725+
m_objectType,
726+
bulk_chunk_size,
727+
ctx.object_keys.data() + current,
728+
static_cast<uint32_t>(ctx.counter_ids.size()),
729+
reinterpret_cast<const sai_stat_id_t *>(ctx.counter_ids.data()),
730+
statsMode,
731+
ctx.object_statuses.data() + current,
732+
ctx.counters.data() + current * ctx.counter_ids.size());
733+
if (SAI_STATUS_SUCCESS != status)
734+
{
735+
SWSS_LOG_WARN("Failed to bulk get stats for %s: %u", m_name.c_str(), status);
736+
}
737+
current += bulk_chunk_size;
738+
739+
SWSS_LOG_INFO("After getting bulk %s %s index %u(advanced to %u) bulk chunk size %u", m_instanceId.c_str(), m_name.c_str(), current - bulk_chunk_size, current, bulk_chunk_size);
740+
741+
if (size - current < bulk_chunk_size)
742+
{
743+
bulk_chunk_size = size - current;
744+
}
745+
}
746+
747+
auto time_stamp = std::chrono::steady_clock::now().time_since_epoch().count();
711748

712749
std::vector<swss::FieldValueTuple> values;
713750
for (size_t i = 0; i < ctx.object_keys.size(); i++)
@@ -723,9 +760,12 @@ class CounterContext : public BaseCounterContext
723760
{
724761
values.emplace_back(serializeStat(ctx.counter_ids[j]), std::to_string(ctx.counters[i * ctx.counter_ids.size() + j]));
725762
}
763+
values.emplace_back(m_instanceId + "_time_stamp", std::to_string(time_stamp));
726764
countersTable.set(sai_serialize_object_id(vid), values, "");
727765
values.clear();
728766
}
767+
768+
SWSS_LOG_INFO("After pushing db %s %s", m_instanceId.c_str(), m_name.c_str());
729769
}
730770

731771
auto getBulkStatsContext(
@@ -932,10 +972,11 @@ class AttrContext : public CounterContext<AttrType>
932972
typedef CounterContext<AttrType> Base;
933973
AttrContext(
934974
_In_ const std::string &name,
975+
_In_ const std::string &instance,
935976
_In_ sai_object_type_t object_type,
936977
_In_ sairedis::SaiInterface *vendor_sai,
937978
_In_ sai_stats_mode_t &stats_mode):
938-
CounterContext<AttrType>(name, object_type, vendor_sai, stats_mode)
979+
CounterContext<AttrType>(name, instance, object_type, vendor_sai, stats_mode)
939980
{
940981
SWSS_LOG_ENTER();
941982
}
@@ -1132,6 +1173,7 @@ void FlexCounter::addCounterPlugin(
11321173
SWSS_LOG_ENTER();
11331174

11341175
m_isDiscarded = false;
1176+
uint32_t bulkChunkSize = 0;
11351177

11361178
for (auto& fvt: values)
11371179
{
@@ -1144,6 +1186,15 @@ void FlexCounter::addCounterPlugin(
11441186
{
11451187
setPollInterval(stoi(value));
11461188
}
1189+
else if (field == BULK_CHUNK_SIZE_FIELD)
1190+
{
1191+
bulkChunkSize = stoi(value);
1192+
for (auto &context : m_counterContext)
1193+
{
1194+
context.second->setBulkChunkSize(bulkChunkSize);
1195+
SWSS_LOG_NOTICE("Set counter context %s %s bulk size %u", m_instanceId.c_str(), COUNTER_TYPE_PORT.c_str(), bulkChunkSize);
1196+
}
1197+
}
11471198
else if (field == FLEX_COUNTER_STATUS_FIELD)
11481199
{
11491200
setStatus(value);
@@ -1166,6 +1217,12 @@ void FlexCounter::addCounterPlugin(
11661217

11671218
SWSS_LOG_NOTICE("Do not double check bulk capability counter context %s %s", m_instanceId.c_str(), counterTypeRef->second.c_str());
11681219
}
1220+
1221+
if (bulkChunkSize > 0)
1222+
{
1223+
getCounterContext(counterTypeRef->second)->setBulkChunkSize(bulkChunkSize);
1224+
SWSS_LOG_NOTICE("Create counter context %s %s with bulk size %u", m_instanceId.c_str(), counterTypeRef->second.c_str(), bulkChunkSize);
1225+
}
11691226
}
11701227
else
11711228
{
@@ -1225,18 +1282,19 @@ bool FlexCounter::allPluginsEmpty() const
12251282
}
12261283

12271284
std::shared_ptr<BaseCounterContext> FlexCounter::createCounterContext(
1228-
_In_ const std::string& context_name)
1285+
_In_ const std::string& context_name,
1286+
_In_ const std::string& instance)
12291287
{
12301288
SWSS_LOG_ENTER();
12311289
if (context_name == COUNTER_TYPE_PORT)
12321290
{
1233-
auto context = std::make_shared<CounterContext<sai_port_stat_t>>(context_name, SAI_OBJECT_TYPE_PORT, m_vendorSai.get(), m_statsMode);
1291+
auto context = std::make_shared<CounterContext<sai_port_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_PORT, m_vendorSai.get(), m_statsMode);
12341292
context->always_check_supported_counters = true;
12351293
return context;
12361294
}
12371295
else if (context_name == COUNTER_TYPE_PORT_DEBUG)
12381296
{
1239-
auto context = std::make_shared<CounterContext<sai_port_stat_t>>(context_name, SAI_OBJECT_TYPE_PORT, m_vendorSai.get(), m_statsMode);
1297+
auto context = std::make_shared<CounterContext<sai_port_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_PORT, m_vendorSai.get(), m_statsMode);
12401298
context->always_check_supported_counters = true;
12411299
context->use_sai_stats_capa_query = false;
12421300
context->use_sai_stats_ext = true;
@@ -1245,25 +1303,25 @@ std::shared_ptr<BaseCounterContext> FlexCounter::createCounterContext(
12451303
}
12461304
else if (context_name == COUNTER_TYPE_QUEUE)
12471305
{
1248-
auto context = std::make_shared<CounterContext<sai_queue_stat_t>>(context_name, SAI_OBJECT_TYPE_QUEUE, m_vendorSai.get(), m_statsMode);
1306+
auto context = std::make_shared<CounterContext<sai_queue_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_QUEUE, m_vendorSai.get(), m_statsMode);
12491307
context->always_check_supported_counters = true;
12501308
context->double_confirm_supported_counters = true;
12511309
return context;
12521310
}
12531311
else if (context_name == COUNTER_TYPE_PG)
12541312
{
1255-
auto context = std::make_shared<CounterContext<sai_ingress_priority_group_stat_t>>(context_name, SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, m_vendorSai.get(), m_statsMode);
1313+
auto context = std::make_shared<CounterContext<sai_ingress_priority_group_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, m_vendorSai.get(), m_statsMode);
12561314
context->always_check_supported_counters = true;
12571315
context->double_confirm_supported_counters = true;
12581316
return context;
12591317
}
12601318
else if (context_name == COUNTER_TYPE_RIF)
12611319
{
1262-
return std::make_shared<CounterContext<sai_router_interface_stat_t>>(context_name, SAI_OBJECT_TYPE_ROUTER_INTERFACE, m_vendorSai.get(), m_statsMode);
1320+
return std::make_shared<CounterContext<sai_router_interface_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_ROUTER_INTERFACE, m_vendorSai.get(), m_statsMode);
12631321
}
12641322
else if (context_name == COUNTER_TYPE_SWITCH_DEBUG)
12651323
{
1266-
auto context = std::make_shared<CounterContext<sai_switch_stat_t>>(context_name, SAI_OBJECT_TYPE_SWITCH, m_vendorSai.get(), m_statsMode);
1324+
auto context = std::make_shared<CounterContext<sai_switch_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_SWITCH, m_vendorSai.get(), m_statsMode);
12671325
context->always_check_supported_counters = true;
12681326
context->use_sai_stats_capa_query = false;
12691327
context->use_sai_stats_ext = true;
@@ -1272,51 +1330,51 @@ std::shared_ptr<BaseCounterContext> FlexCounter::createCounterContext(
12721330
}
12731331
else if (context_name == COUNTER_TYPE_MACSEC_FLOW)
12741332
{
1275-
auto context = std::make_shared<CounterContext<sai_macsec_flow_stat_t>>(context_name, SAI_OBJECT_TYPE_MACSEC_FLOW, m_vendorSai.get(), m_statsMode);
1333+
auto context = std::make_shared<CounterContext<sai_macsec_flow_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_MACSEC_FLOW, m_vendorSai.get(), m_statsMode);
12761334
context->use_sai_stats_capa_query = false;
12771335
return context;
12781336
}
12791337
else if (context_name == COUNTER_TYPE_MACSEC_SA)
12801338
{
1281-
auto context = std::make_shared<CounterContext<sai_macsec_sa_stat_t>>(context_name, SAI_OBJECT_TYPE_MACSEC_SA, m_vendorSai.get(), m_statsMode);
1339+
auto context = std::make_shared<CounterContext<sai_macsec_sa_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_MACSEC_SA, m_vendorSai.get(), m_statsMode);
12821340
context->use_sai_stats_capa_query = false;
12831341
return context;
12841342
}
12851343
else if (context_name == COUNTER_TYPE_FLOW)
12861344
{
1287-
auto context = std::make_shared<CounterContext<sai_counter_stat_t>>(context_name, SAI_OBJECT_TYPE_COUNTER, m_vendorSai.get(), m_statsMode);
1345+
auto context = std::make_shared<CounterContext<sai_counter_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_COUNTER, m_vendorSai.get(), m_statsMode);
12881346
context->use_sai_stats_capa_query = false;
12891347
context->use_sai_stats_ext = true;
12901348

12911349
return context;
12921350
}
12931351
else if (context_name == COUNTER_TYPE_TUNNEL)
12941352
{
1295-
auto context = std::make_shared<CounterContext<sai_tunnel_stat_t>>(context_name, SAI_OBJECT_TYPE_TUNNEL, m_vendorSai.get(), m_statsMode);
1353+
auto context = std::make_shared<CounterContext<sai_tunnel_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_TUNNEL, m_vendorSai.get(), m_statsMode);
12961354
context->use_sai_stats_capa_query = false;
12971355
return context;
12981356
}
12991357
else if (context_name == COUNTER_TYPE_BUFFER_POOL)
13001358
{
1301-
auto context = std::make_shared<CounterContext<sai_buffer_pool_stat_t>>(context_name, SAI_OBJECT_TYPE_BUFFER_POOL, m_vendorSai.get(), m_statsMode);
1359+
auto context = std::make_shared<CounterContext<sai_buffer_pool_stat_t>>(context_name, instance, SAI_OBJECT_TYPE_BUFFER_POOL, m_vendorSai.get(), m_statsMode);
13021360
context->always_check_supported_counters = true;
13031361
return context;
13041362
}
13051363
else if (context_name == ATTR_TYPE_QUEUE)
13061364
{
1307-
return std::make_shared<AttrContext<sai_queue_attr_t>>(context_name, SAI_OBJECT_TYPE_QUEUE, m_vendorSai.get(), m_statsMode);
1365+
return std::make_shared<AttrContext<sai_queue_attr_t>>(context_name, instance, SAI_OBJECT_TYPE_QUEUE, m_vendorSai.get(), m_statsMode);
13081366
}
13091367
else if (context_name == ATTR_TYPE_PG)
13101368
{
1311-
return std::make_shared<AttrContext<sai_ingress_priority_group_attr_t>>(context_name, SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, m_vendorSai.get(), m_statsMode);
1369+
return std::make_shared<AttrContext<sai_ingress_priority_group_attr_t>>(context_name, instance, SAI_OBJECT_TYPE_INGRESS_PRIORITY_GROUP, m_vendorSai.get(), m_statsMode);
13121370
}
13131371
else if (context_name == ATTR_TYPE_MACSEC_SA)
13141372
{
1315-
return std::make_shared<AttrContext<sai_macsec_sa_attr_t>>(context_name, SAI_OBJECT_TYPE_MACSEC_SA, m_vendorSai.get(), m_statsMode);
1373+
return std::make_shared<AttrContext<sai_macsec_sa_attr_t>>(context_name, instance, SAI_OBJECT_TYPE_MACSEC_SA, m_vendorSai.get(), m_statsMode);
13161374
}
13171375
else if (context_name == ATTR_TYPE_ACL_COUNTER)
13181376
{
1319-
return std::make_shared<AttrContext<sai_acl_counter_attr_t>>(context_name, SAI_OBJECT_TYPE_ACL_COUNTER, m_vendorSai.get(), m_statsMode);
1377+
return std::make_shared<AttrContext<sai_acl_counter_attr_t>>(context_name, instance, SAI_OBJECT_TYPE_ACL_COUNTER, m_vendorSai.get(), m_statsMode);
13201378
}
13211379

13221380
SWSS_LOG_THROW("Invalid counter type %s", context_name.c_str());
@@ -1335,7 +1393,7 @@ std::shared_ptr<BaseCounterContext> FlexCounter::getCounterContext(
13351393
return iter->second;
13361394
}
13371395

1338-
auto ret = m_counterContext.emplace(name, createCounterContext(name));
1396+
auto ret = m_counterContext.emplace(name, createCounterContext(name, m_instanceId));
13391397
return ret.first->second;
13401398
}
13411399

‎syncd/FlexCounter.h‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,13 +20,16 @@ namespace syncd
2020
class BaseCounterContext
2121
{
2222
public:
23-
BaseCounterContext(const std::string &name);
23+
BaseCounterContext(const std::string &name, const std::string &instance);
2424
void addPlugins(
2525
_In_ const std::vector<std::string>& shaStrings);
2626

2727
void setNoDoubleCheckBulkCapability(
2828
_In_ bool);
2929

30+
void setBulkChunkSize(
31+
_In_ uint32_t bulkChunkSize);
32+
3033
bool hasPlugin() const {return !m_plugins.empty();}
3134

3235
void removePlugins() {m_plugins.clear();}
@@ -51,6 +54,7 @@ namespace syncd
5154

5255
protected:
5356
std::string m_name;
57+
std::string m_instanceId;
5458
std::set<std::string> m_plugins;
5559

5660
public:
@@ -59,6 +63,7 @@ namespace syncd
5963
bool use_sai_stats_ext = false;
6064
bool double_confirm_supported_counters = false;
6165
bool no_double_check_bulk_capability = false;
66+
uint32_t default_bulk_chunk_size = 0;
6267
};
6368
class FlexCounter
6469
{
@@ -118,7 +123,8 @@ namespace syncd
118123
_In_ const std::string &name);
119124

120125
std::shared_ptr<BaseCounterContext> createCounterContext(
121-
_In_ const std::string &name);
126+
_In_ const std::string &name,
127+
_In_ const std::string &instance);
122128

123129
void removeCounterContext(
124130
_In_ const std::string &name);

0 commit comments

Comments
 (0)