Example code for bulk get

lib/inc/Recorder.h

@@ -157,6 +157,14 @@ namespace sairedis
                     _In_ sai_status_t status,
                     _In_ const std::vector<swss::FieldValueTuple>& arguments);
 
+            void recordBulkGenericGet(
+                    _In_ const std::string& objectType,
+                    _In_ const std::vector<swss::FieldValueTuple>& entriesWithStatus);
+
+            void recordBulkGenericGetResponse(
+                    _In_ const std::string& objectType,
+                    _In_ const std::vector<swss::FieldValueTuple>& entriesWithStatus);
+
         public: // create ENTRY
 
             SAI_REDIS_RECORDER_DECLARE_RECORD_CREATE(fdb_entry);

lib/inc/RedisRemoteSaiInterface.h

@@ -182,6 +182,15 @@ namespace sairedis
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses) override;
 
+            virtual sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ uint32_t object_count,
+                    _In_ const sai_object_id_t *object_id,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses) override;
+
         public: // bulk create ENTRY
 
             SAIREDIS_REDISREMOTESAIINTERFACE_DECLARE_BULK_CREATE_ENTRY(fdb_entry);
@@ -339,6 +348,14 @@ namespace sairedis
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses);
 
+            sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ const std::vector<std::string> &serialized_object_ids,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses);
+
         private: // QUAD API response
 
             /**
@@ -380,6 +397,14 @@ namespace sairedis
                     _In_ uint32_t object_count,
                     _Out_ sai_status_t *object_statuses);
 
+            sai_status_t waitForBulkGetResponse(
+                    _In_ sai_object_type_t object_type,
+                    _In_ const std::vector<std::string> &serialized_object_ids,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _Out_ sai_status_t *object_statuses,
+                    _Out_ swss::KeyOpFieldsValuesTuple &kco);
+
         private: // stats API response
 
             sai_status_t waitForGetStatsResponse(

lib/inc/Sai.h

@@ -174,6 +174,15 @@ namespace sairedis
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses) override;
 
+            virtual sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ uint32_t object_count,
+                    _In_ const sai_object_id_t *object_id,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses) override;
+
         public: // bulk create ENTRY
 
             SAIREDIS_SAI_DECLARE_BULK_CREATE_ENTRY(fdb_entry);

lib/inc/SaiInterface.h

@@ -165,6 +165,15 @@ namespace sairedis
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses) = 0;
 
+            virtual sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ uint32_t object_count,
+                    _In_ const sai_object_id_t *object_id,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses) = 0;
+
         public: // bulk create ENTRY
 
             SAIREDIS_SAIINTERFACE_DECLARE_BULK_CREATE_ENTRY(fdb_entry);

lib/inc/sai_redis.h

@@ -307,6 +307,27 @@ PRIVATE extern std::shared_ptr<sairedis::Sai>   redis_sai;
             object_statuses);                       \
 }
 
+#define REDIS_BULK_GET_NEW(OT,fname)                \
+    static sai_status_t redis_bulk_get_ ## fname(   \
+            _In_ uint32_t object_count,             \
+            _In_ const sai_object_id_t *object_id,  \
+            _In_ const uint32_t *attr_count,        \
+            _Inout_ sai_attribute_t **attr_list,    \
+            _In_ sai_bulk_op_error_mode_t mode,     \
+            _Out_ sai_status_t *object_statuses)    \
+{                                                   \
+    SWSS_LOG_ENTER();                               \
+    /*SWSS_LOG_WARN("Example implementation");*/    \
+    return redis_sai->bulkGet(                      \
+            SAI_OBJECT_TYPE_ ## OT,                 \
+            object_count,                           \
+            object_id,                              \
+            attr_count,                             \
+            attr_list,                              \
+            mode,                                   \
+            object_statuses);                       \
+}
+
 #define REDIS_BULK_GET(OT,fname)                    \
     static sai_status_t redis_bulk_get_ ## fname(   \
             _In_ uint32_t object_count,             \

lib/src/Recorder.cpp

@@ -614,6 +614,46 @@ void Recorder::recordGenericGetResponse(
     recordLine("G|" + sai_serialize_status(status) + "|" + joinFieldValues(arguments));
 }
 
+void Recorder::recordBulkGenericGet(
+        _In_ const std::string& objectType,
+        _In_ const std::vector<swss::FieldValueTuple>& entriesWithStatus)
+{
+    SWSS_LOG_ENTER();
+
+    std::string joined;
+
+    for (const auto &e: entriesWithStatus)
+    {
+        // ||obj_id|attr=val|attr=val|status||obj_id|attr=val|attr=val|status
+
+        joined += "||" + fvField(e) + "|" + fvValue(e);
+    }
+
+    // capital 'b' stands for bulk GET operation.
+
+    recordLine("b|" + objectType + joined);
+}
+
+void Recorder::recordBulkGenericGetResponse(
+        _In_ const std::string& objectType,
+        _In_ const std::vector<swss::FieldValueTuple>& entriesWithStatus)
+{
+    SWSS_LOG_ENTER();
+
+    std::string joined;
+
+    for (const auto &e: entriesWithStatus)
+    {
+        // ||obj_id|attr=val|attr=val|status||obj_id|attr=val|attr=val|status
+
+        joined += "||" + fvField(e) + "|" + fvValue(e);
+    }
+
+    // capital 'B' stands for bulk GET operation.
+
+    recordLine("B|" + objectType + joined);
+}
+
 void Recorder::recordGenericGetStats(
         _In_ sai_object_type_t object_type,
         _In_ sai_object_id_t object_id,

lib/src/RedisRemoteSaiInterface.cpp

@@ -1582,6 +1582,127 @@ sai_status_t RedisRemoteSaiInterface::bulkSet(
     return waitForBulkResponse(SAI_COMMON_API_BULK_SET, (uint32_t)serialized_object_ids.size(), object_statuses);
 }
 
+sai_status_t RedisRemoteSaiInterface::bulkGet(
+        _In_ sai_object_type_t object_type,
+        _In_ uint32_t object_count,
+        _In_ const sai_object_id_t *object_id,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _In_ sai_bulk_op_error_mode_t mode,
+        _Out_ sai_status_t *object_statuses)
+{
+    SWSS_LOG_ENTER();
+
+    std::vector<std::string> serializedObjectIds;
+
+//    SWSS_LOG_NOTICE("SYNCD BULK ENTER SHELL");
+
+    for (uint32_t idx = 0; idx < object_count; idx++)
+    {
+//        SWSS_LOG_NOTICE("SYNCD BULK EMPLACE OID %" PRIx64, object_id[idx]);
+        serializedObjectIds.emplace_back(sai_serialize_object_id(object_id[idx]));
+    }
+
+    return bulkGet(object_type, serializedObjectIds, attr_count, attr_list, mode, object_statuses);
+}
+
+sai_status_t RedisRemoteSaiInterface::bulkGet(
+        _In_ sai_object_type_t object_type,
+        _In_ const std::vector<std::string> &serialized_object_ids,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _In_ sai_bulk_op_error_mode_t mode,
+        _Out_ sai_status_t *object_statuses)
+{
+    SWSS_LOG_ENTER();
+
+    // TODO support mode
+
+//    SWSS_LOG_NOTICE("SYNCD BULK ENTER DO");
+
+    std::string str_object_type = sai_serialize_object_type(object_type);
+
+    std::vector<swss::FieldValueTuple> entries;
+
+    for (size_t idx = 0; idx < serialized_object_ids.size(); ++idx)
+    {
+        auto entry = SaiAttributeList::serialize_attr_list(object_type, attr_count[idx], attr_list[idx], false);
+
+        std::string str_attr = joinFieldValues(entry);
+
+        swss::FieldValueTuple fvtNoStatus(serialized_object_ids[idx] , str_attr);
+
+        entries.push_back(fvtNoStatus);
+    }
+
+    /*
+     * We are adding number of entries to actually add ':' to be compatible
+     * with previous
+     */
+
+    // key:         object_type:count
+    // field:       object_id
+    // value:       object_attrs
+    std::string key = str_object_type + ":" + std::to_string(entries.size());
+
+    m_recorder->recordBulkGenericGet(str_object_type, entries);
+
+    m_communicationChannel->set(key, entries, REDIS_ASIC_STATE_COMMAND_BULK_GET);
+
+    swss::KeyOpFieldsValuesTuple kco;
+    auto status = waitForBulkGetResponse(object_type, serialized_object_ids, attr_count, attr_list, object_statuses, kco);
+
+    m_recorder->recordBulkGenericGetResponse(str_object_type, kfvFieldsValues(kco));
+
+    return status;
+}
+
+sai_status_t RedisRemoteSaiInterface::waitForBulkGetResponse(
+        _In_ sai_object_type_t object_type,
+        _In_ const std::vector<std::string> &serialized_object_ids,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _Out_ sai_status_t *object_statuses,
+        _Out_ swss::KeyOpFieldsValuesTuple &kco)
+{
+    SWSS_LOG_ENTER();
+
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_GETRESPONSE, kco);
+
+    auto &values = kfvFieldsValues(kco);
+
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        SWSS_LOG_THROW("logic error, get bulk response returned non zero %d", status);
+        return status;
+    }
+
+    uint32_t attr_index = 0;
+
+    // Fetch all the status
+    for(uint32_t obj_index = 0; obj_index < serialized_object_ids.size(); obj_index++)
+    {
+//        sai_deserialize_status(fvField(values[obj_index]), object_statuses[obj_index]);
+        object_statuses[obj_index] = SAI_STATUS_SUCCESS;
+    }
+//    values.erase(values.begin(), values.begin() + serialized_object_ids.size());
+
+    // Fetch attribute list for each object
+    SaiAttributeList list(object_type, values, false);
+
+//    SWSS_LOG_NOTICE("BULK GET OBJECTS %d", serialized_object_ids.size());
+
+    for(uint32_t obj_index = 0; obj_index < serialized_object_ids.size(); obj_index++)
+    {
+//        SWSS_LOG_NOTICE("BULK GET BEFORE TRANSFER %s %d attr index %d", serialized_object_ids[obj_index].c_str(), list.get_attr_list()[attr_index].value.u32, attr_index);
+        transfer_attributes(object_type, attr_count[obj_index], &(list.get_attr_list()[attr_index]), attr_list[obj_index], false);
+//        SWSS_LOG_NOTICE("BULK GET AFTER TRANSFER %s %d attr index %d", serialized_object_ids[obj_index].c_str(), attr_list[obj_index][0].value.u32);
+        attr_index += attr_count[obj_index];
+    }
+
+    return status;
+}
+
 sai_status_t RedisRemoteSaiInterface::bulkCreate(
         _In_ sai_object_type_t object_type,
         _In_ sai_object_id_t switch_id,

lib/src/Sai.cpp

@@ -479,6 +479,32 @@ sai_status_t Sai::bulkSet(
             object_statuses);
 }
 
+sai_status_t Sai::bulkGet(
+        _In_ sai_object_type_t object_type,
+        _In_ uint32_t object_count,
+        _In_ const sai_object_id_t *object_id,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _In_ sai_bulk_op_error_mode_t mode,
+        _Out_ sai_status_t *object_statuses)
+{
+    MUTEX();
+    SWSS_LOG_ENTER();
+    REDIS_CHECK_API_INITIALIZED();
+    REDIS_CHECK_CONTEXT(*object_id);
+
+//    SWSS_LOG_NOTICE("SYNCD BULK GET Sai stub");
+
+    return context->m_meta->bulkGet(
+            object_type,
+            object_count,
+            object_id,
+            attr_count,
+            attr_list,
+            mode,
+            object_statuses);
+}
+
 // BULK QUAD ENTRY
 
 #define DECLARE_BULK_CREATE_ENTRY(OT,ot)                    \

lib/src/sai_redis_port.cpp

@@ -18,7 +18,7 @@ REDIS_GENERIC_STATS(PORT_POOL,port_pool);
 REDIS_BULK_CREATE(PORT,port);
 REDIS_BULK_REMOVE(PORT,port);
 REDIS_BULK_SET(PORT,port);
-REDIS_BULK_GET(PORT,port);
+REDIS_BULK_GET_NEW(PORT,port);
 
 const sai_port_api_t redis_port_api = {
 

lib/src/sai_redis_schedulergroup.cpp

@@ -5,7 +5,7 @@ REDIS_GENERIC_QUAD(SCHEDULER_GROUP,scheduler_group);
 REDIS_BULK_CREATE(SCHEDULER_GROUP,scheduler_group);
 REDIS_BULK_REMOVE(SCHEDULER_GROUP,scheduler_group);
 REDIS_BULK_SET(SCHEDULER_GROUP,scheduler_group);
-REDIS_BULK_GET(SCHEDULER_GROUP,scheduler_group);
+REDIS_BULK_GET_NEW(SCHEDULER_GROUP,scheduler_group);
 
 const sai_scheduler_group_api_t redis_scheduler_group_api = {
 

meta/DummySaiInterface.cpp

@@ -363,6 +363,19 @@ sai_status_t DummySaiInterface::bulkSet(
     return m_status;
 }
 
+sai_status_t DummySaiInterface::bulkGet(
+        _In_ sai_object_type_t object_type,
+        _In_ uint32_t object_count,
+        _In_ const sai_object_id_t *object_id,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _In_ sai_bulk_op_error_mode_t mode,
+        _Out_ sai_status_t *object_statuses)
+{
+    SWSS_LOG_NOTICE("SYNCD BULK GET DummySaiInterface stub");
+    return SAI_STATUS_SUCCESS;
+}
+
 sai_status_t DummySaiInterface::bulkCreate(
         _In_ sai_object_type_t object_type,
         _In_ sai_object_id_t switch_id,

meta/DummySaiInterface.h

@@ -173,6 +173,15 @@ namespace saimeta
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses) override;
 
+            virtual sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ uint32_t object_count,
+                    _In_ const sai_object_id_t *object_id,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses) override;
+
         public: // bulk create ENTRY
 
             SAIMETA_DUMMYSAIINTERFACE_DECLARE_BULK_CREATE_ENTRY(fdb_entry);