Wrapper APIs and sample tests for esmi power control,

boostlimit monitor, boostlimit control, esmi error status

Change-Id: Id8db926eab2f6be386ed21081e651fcc9b389a22


[ROCm/amdsmi commit: a7d7c5c6e1]

projects/amdsmi/example/amdsmi_esmi_intg_example.cc

@@ -59,10 +59,11 @@ using namespace std;
     {                                                                          \
         if (RET != AMDSMI_STATUS_SUCCESS) {                                    \
             const char *err_str;                                               \
+            const char **status_str;                                           \
             std::cout << "AMDSMI call returned " << RET << " at line "         \
                       << __LINE__ << std::endl;                                \
-            amdsmi_status_code_to_string(RET, &err_str);                               \
-            std::cout << err_str << std::endl;                                 \
+            *status_str = amdsmi_get_esmi_err_msg(RET, &err_str);              \
+            std::cout << *status_str << std::endl;                             \
             return RET;                                                        \
         }                                                                      \
     }
@@ -289,7 +290,46 @@ int main(int argc, char **argv) {
         cout<<" NA (Err:" <<ret<<"     |";
     }
     cout<<"\n-------------------------------------------------\n";
+
+    uint32_t input_power;
+    powermax = 0;
+    cout<<"\nEnter the max power to be set:\n";
+    cin>>input_power;
+    ret = amdsmi_get_cpu_socket_power_cap_max(sockets[i], i, &powermax);
+    CHK_AMDSMI_RET(ret)
+    if ((ret == AMDSMI_STATUS_SUCCESS) && (input_power > powermax)) {
+        cout<<"Input power is more than max power limit,"
+            " limiting to "<<static_cast<double>(powermax)/1000<<"Watts\n";
+        input_power = powermax;
+    }
+    ret = amdsmi_set_cpu_socket_power_cap(sockets[i], i, input_power);
+    CHK_AMDSMI_RET(ret)
+    if (!ret) {
+        cout<<"Socket["<<i<<"] power_limit set to "
+        <<fixed<<setprecision(3)<<static_cast<double>(input_power)/1000<<" Watts successfully\n";
+    }
+    cout<<"\n-------------------------------------------------\n";
+
 #if 0
+    uint8_t mode;
+    const char *err_str;
+    cout <<"Enter the power efficiency mode to be set[0, 1 or 2]:\n";
+    cin>>mode;
+    ret = amdsmi_set_cpu_pwr_efficiency_mode(sockets[i], i, mode);
+    CHK_AMDSMI_RET(ret)
+
+    if (ret != AMDSMI_STATUS_SUCCESS) {
+        cout<<"Failed to set power efficiency mode for socket["<<i<<"], Err["
+            <<ret<<"]: "<<amdsmi_get_esmi_err_msg(ret, &err_str)<<"\n";
+        return ret;
+    }
+
+    if (!ret)
+        cout<<"Power efficiency profile policy is set to "<<mode<<"successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+
     uint32_t svi_power;
     cout<<"\n| SVI Power Telemetry (mWatts) \t |";
 

projects/amdsmi/src/amd_smi/amd_smi.cc

@@ -2179,6 +2179,136 @@ amdsmi_status_t amdsmi_get_cpu_pwr_svi_telemetry_all_rails(amdsmi_cpusocket_hand
     return AMDSMI_STATUS_SUCCESS;
 }
 
+amdsmi_status_t amdsmi_set_cpu_socket_power_cap(amdsmi_cpusocket_handle socket_handle,
+        uint32_t sock_ind, uint32_t pcap)
+{
+    amdsmi_status_t status;
+
+    if (socket_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuSocket* socket = nullptr;
+    amdsmi_status_t r = get_cpu_socket_from_handle(socket_handle, &socket);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_socket_power_cap_set(sock_ind, pcap));
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_set_cpu_pwr_efficiency_mode(amdsmi_cpusocket_handle socket_handle,
+        uint8_t sock_ind, uint8_t mode)
+{
+    amdsmi_status_t status;
+
+    if (socket_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuSocket* socket = nullptr;
+    amdsmi_status_t r = get_cpu_socket_from_handle(socket_handle, &socket);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_pwr_efficiency_mode_set(sock_ind, mode));
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_get_cpu_core_boostlimit(amdsmi_processor_handle processor_handle,
+        uint32_t core_ind, uint32_t *pboostlimit)
+{
+    amdsmi_status_t status;
+    uint32_t boostlimit;
+
+    if (processor_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuCore* core = nullptr;
+    amdsmi_status_t r = get_cpu_core_from_handle(processor_handle, &core);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_core_boostlimit_get(core_ind, &boostlimit));
+    *pboostlimit = boostlimit;
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_get_cpu_socket_c0_residency(amdsmi_cpusocket_handle socket_handle,
+        uint32_t sock_ind, uint32_t *pc0_residency)
+{
+    amdsmi_status_t status;
+    uint32_t res;
+
+    if (socket_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuSocket* socket = nullptr;
+    amdsmi_status_t r = get_cpu_socket_from_handle(socket_handle, &socket);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_socket_c0_residency_get(sock_ind, &res));
+    *pc0_residency = res;
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_set_cpu_core_boostlimit(amdsmi_processor_handle processor_handle,
+        uint32_t core_ind, uint32_t boostlimit)
+{
+    amdsmi_status_t status;
+
+    if (processor_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuCore* core = nullptr;
+    amdsmi_status_t r = get_cpu_core_from_handle(processor_handle, &core);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_core_boostlimit_set(core_ind, boostlimit));
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_set_cpu_socket_boostlimit(amdsmi_cpusocket_handle socket_handle,
+        uint32_t sock_ind, uint32_t boostlimit)
+{
+    amdsmi_status_t status;
+
+    if (socket_handle == nullptr)
+        return AMDSMI_STATUS_INVAL;
+
+    amd::smi::AMDSmiCpuSocket* socket = nullptr;
+    amdsmi_status_t r = get_cpu_socket_from_handle(socket_handle, &socket);
+    if (r != AMDSMI_STATUS_SUCCESS)
+        return r;
+
+    status = static_cast<amdsmi_status_t>(esmi_socket_boostlimit_set(sock_ind, boostlimit));
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
 amdsmi_status_t amdsmi_get_number_of_cpu_sockets(uint32_t sockets)
 {
     amdsmi_status_t status = amd::smi::AMDSmiSystem::getInstance().get_cpu_sockets(sockets);
@@ -2223,4 +2353,15 @@ amdsmi_status_t amdsmi_get_cpu_model(uint32_t model)
 
     return AMDSMI_STATUS_SUCCESS;
 }
+
+const char* amdsmi_get_esmi_err_msg(amdsmi_status_t status, const char **status_string)
+{
+    for (auto& iter : amd::smi::esmi_status_map) {
+        if (iter.first == status) {
+            *status_string = esmi_get_err_msg(static_cast<esmi_status_t>(iter.first));
+            break;
+        }
+    }
+    return *status_string;
+}
 #endif