diff --git a/amdsmi_cli/amdsmi_commands.py b/amdsmi_cli/amdsmi_commands.py
index 786fa1398c..9c5aa09f3e 100644
--- a/amdsmi_cli/amdsmi_commands.py
+++ b/amdsmi_cli/amdsmi_commands.py
@@ -451,6 +451,9 @@ class AMDSMICommands():
 
                 try:
                     numa_affinity = amdsmi_interface.amdsmi_get_gpu_topo_numa_affinity(args.gpu)
+                    # -1 means No numa node is assigned to the GPU, so there is no numa affinity
+                    if self.logger.is_human_readable_format() and numa_affinity == -1:
+                        numa_affinity = "NONE"
                 except amdsmi_exception.AmdSmiLibraryException as e:
                     numa_affinity = "N/A"
                     logging.debug("Failed to get numa affinity for gpu %s | %s", gpu_id, e.get_error_info())
diff --git a/example/amd_smi_nodrm_example.cc b/example/amd_smi_nodrm_example.cc
index eaf1b688dc..ec02ec53d8 100644
--- a/example/amd_smi_nodrm_example.cc
+++ b/example/amd_smi_nodrm_example.cc
@@ -140,7 +140,9 @@ int main() {
             printf("\tDeviceID: 0x%lx\n", asic_info.device_id);
             printf("\tVendorID: 0x%x\n", asic_info.vendor_id);
             printf("\tRevisionID: 0x%x\n", asic_info.rev_id);
-            printf("\tAsic serial: 0x%s\n\n", asic_info.asic_serial);
+            printf("\tAsic serial: 0x%s\n", asic_info.asic_serial);
+            printf("\tXGMI physical id: 0x%x\n\n",
+                            asic_info.xgmi_physical_id);
 
             // Get VBIOS info
             amdsmi_vbios_info_t vbios_info = {};
diff --git a/example/amdsmi_esmi_intg_example.cc b/example/amdsmi_esmi_intg_example.cc
index 363124bb01..28d4784121 100644
--- a/example/amdsmi_esmi_intg_example.cc
+++ b/example/amdsmi_esmi_intg_example.cc
@@ -43,13 +43,13 @@
 #include <assert.h>
 #include <stdint.h>
 #include <unistd.h>
-
 #include <vector>
 #include <iostream>
 #include <bitset>
 #include <iomanip>
 #include "amd_smi/amdsmi.h"
 #include <cstring>
+#include <cmath>
 
 using namespace std;
 
@@ -317,7 +317,7 @@ int main(int argc, char **argv) {
 
     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";
+            <<ret<<"]: "<<*amdsmi_get_esmi_err_msg(ret, &err_str)<<"\n";
         return ret;
     }
 
@@ -339,6 +339,325 @@ int main(int argc, char **argv) {
         cout<<" NA (Err:" <<ret<<"     |";
     }
     cout<<"\n-------------------------------------------------\n";
+
+    uint32_t boost_limit = 0;
+    const char *err_str1;
+    ret = amdsmi_get_cpu_core_boostlimit(processor_handles[i], i, &boost_limit);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to get core"<<"["<<i<<"] boostlimit, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+    else
+        cout<<"| core["<<i<<"] boostlimit (MHz)\t | "<<boost_limit<<" \t |\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    boost_limit = 0;
+    cout<<"\nEnter the boost limit to be set:\n";
+    cin>>boost_limit;
+    ret = amdsmi_set_cpu_core_boostlimit(processor_handles[i], i, boost_limit);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed: to set core"<<"["<<i<<"] boostlimit, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+
+    ret = amdsmi_get_cpu_core_boostlimit(processor_handles[i], i, &boost_limit);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to get core"<<"["<<i<<"] boostlimit, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+    else
+        cout<<"| core["<<i<<"] boostlimit (MHz)\t | "<<boost_limit<<" \t |\n";
+    cout<<"\n-------------------------------------------------\n";
+
+    ret = amdsmi_set_cpu_socket_boostlimit(sockets[i], i, boost_limit);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to set socket"<<"["<<i<<"] boostlimit, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+
+    cout<<"\n-------------------------------------------------\n";
+
+    uint32_t residency = 0;
+    ret = amdsmi_get_cpu_socket_c0_residency(sockets[i], i, &residency);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed: to get socket"<<"["<<i<<"] c0_residency, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+    else
+        cout<<"| socket["<<i<<"] c0_residency(%)   | "<<residency<<"   |\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    cout<<"\n| DDR Bandwidth\t\t\t\t |\n";
+    amdsmi_ddr_bw_metrics_t ddr;
+    ret = amdsmi_get_cpu_ddr_bw(sockets[i], &ddr);
+    CHK_AMDSMI_RET(ret)
+
+    if(!ret) {
+        cout<<"\n| \tDDR Max BW (GB/s)\t |"<<ddr.max_bw<<"\t|"<<endl;
+        cout<<"\n| \tDDR Utilized BW (GB/s)\t |"<<ddr.utilized_bw<<"\t|"<<endl;
+        cout<<"\n| \tDDR Utilized Percent(%)\t |"<<ddr.utilized_pct<<"\t|"<<endl;
+      }
+
+    cout<<"\n-------------------------------------------------\n";
+
+    uint32_t tmon;
+    cout<<"\n| Socket temperature (°C)\t\t |";
+    ret = amdsmi_get_cpu_socket_temperature(sockets[i], i, &tmon);
+    CHK_AMDSMI_RET(ret)
+
+    if (!ret) {
+            cout<<fixed<<setprecision(3)<<""<<(double)tmon/1000<<"|";
+     } else {
+            err_bits |= 1 << ret;
+            cout<<" NA (Err: "<<ret<<")     |";
+     }
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_temp_range_refresh_rate_t rate;
+    uint8_t dimm_addr;
+    cout<<"\n| Socket DIMM temp range and refresh rate\t\t |\n";
+    ret = amdsmi_get_cpu_dimm_temp_range_and_refresh_rate(sockets[i], i, dimm_addr, &rate);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret) {
+        cout<<"\n| \tDIMM temp range\t |"<<rate.range<<"\t|"<<endl;
+        cout<<"\n| \tRefresh rate\t |"<<rate.ref_rate<<"\t|"<<endl;
+    } else
+        cout<<"Failed: to get socket"<<"["<<i<<"] DIMM temperature range and refresh rate, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_dimm_power_t pow;
+    cout<<"\n| Socket DIMM power consumption\t\t |\n";
+    ret = amdsmi_get_cpu_dimm_power_consumption(sockets[i], i, dimm_addr, &pow);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret) {
+        cout<<"\n| Power(mWatts)\t\t |"<<pow.power<<"\t|"<<endl;
+        cout<<"\n| Power update rate(ms)\t |"<<pow.update_rate<<"\t|"<<endl;
+        cout<<"\n| Dimm address \t\t |"<<pow.dimm_addr<<"\t|"<<endl;
+    } else
+        cout<<"Failed: to get socket"<<"["<<i<<"] DIMM power and update rate, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_dimm_thermal_t d_sensor;
+    cout<<"\n| Socket DIMM thermal sensor\t\t |\n";
+    ret = amdsmi_get_cpu_dimm_thermal_sensor(sockets[i], i, dimm_addr, &d_sensor);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret) {
+        cout<<"\n| Temperature(°C)\t |"<<d_sensor.temp<<"\t|"<<endl;
+        cout<<"\n| Update rate(ms)\t |"<<d_sensor.update_rate<<"\t|"<<endl;
+        cout<<"\n| Dimm address returned\t |"<<d_sensor.dimm_addr<<"\t|"<<endl;
+    } else
+        cout<<"Failed: to get socket"<<"["<<i<<"] DIMM temperature and update rate, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+
+    cout<<"\n-------------------------------------------------\n";
+
+    uint8_t min, max;
+    cout<<"\nEnter the XGMI min value to be set:\n";
+    cin>>min;
+    cout<<"\nEnter the XGMI max value to be set:\n";
+    cin>>max;
+
+    ret = amdsmi_set_cpu_xgmi_width(sockets[i], min, max);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to set xGMI link width, Err["<<ret<<"]: "
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"xGMI link width (min:"<<min<< "max:"<<max<<") is set successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    uint8_t min_link_width, max_link_width;
+    cout<<"\nEnter the GMI3 link width min value to be set:\n";
+    cin>>min_link_width;
+    cout<<"\nEnter the GMI3 link width max value to be set:\n";
+    cin>>max_link_width;
+
+    ret = amdsmi_set_cpu_gmi3_link_width_range(sockets[i], i, min_link_width, max_link_width);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed to set gmi3 link width for socket["<<i<<"] Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"Gmi3 link width range is set successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    ret = amdsmi_cpu_apb_enable(sockets[i], i);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to enable DF performance boost algo on socket["<<i<<"] Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"APB is enabled successfully on socket["<<i<<"]\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    int32_t pstate;
+    cout<<"\nEnter the pstate to be set:\n";
+    cin>>pstate;
+    ret = amdsmi_cpu_apb_disable(sockets[i], i, pstate);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret)
+        cout<<"Failed: to set socket["<<i<<"] DF pstate, Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"APB is disabled, P-state is set to ["<<pstate<<"] on socket["<<i<<"] successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    uint8_t min_val=0, max_val=2;
+    uint8_t nbio_id=1;
+
+    ret = amdsmi_set_cpu_socket_lclk_dpm_level(sockets[i], i, nbio_id, min_val, max_val);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed: to set lclk dpm level for socket["<<i<<"], nbioid["<<unsigned(nbio_id)<<"], Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"Socket["<<i<<"] nbio["<<unsigned(nbio_id)<<"] LCLK frequency set successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_dpm_level_t nbio;
+    ret = amdsmi_get_cpu_socket_lclk_dpm_level(sockets[i], i, nbio_id, &nbio);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed: to get lclk dpm level for socket["<<i<<"], nbioid["<<unsigned(nbio_id)<<"], Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else {
+        cout<<"| \tMIN\t | "<<unsigned(nbio.min_dpm_level)<<"\t   |\n";
+        cout<<"| \tMAX\t | "<<unsigned(nbio.max_dpm_level)<<"\t   |\n";
+     }
+
+     cout<<"\n-------------------------------------------------\n";
+
+    uint8_t rate_ctrl;
+    uint8_t prev_mode;
+    string pcie_strings[] = {
+           "automatically detect based on bandwidth utilisation",
+           "limited to Gen4 rate",
+           "limited to Gen5 rate"
+           };
+    cout<<"\nEnter the rate ctrl to be set:\n";
+    cin>>rate_ctrl;
+
+    ret = amdsmi_set_cpu_pcie_link_rate(sockets[i], i, rate_ctrl, &prev_mode);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed to set pcie link rate control for socket["<<i<<"], Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else {
+        cout<<"Pcie link rate is set to "<<rate_ctrl<<" (i.e. "<<pcie_strings[rate_ctrl]<<") successfully.\n";
+        cout<<"\nPrevious pcie link rate control was : "<<prev_mode<<"\n";
+     }
+
+    cout<<"\n-------------------------------------------------\n";
+    uint8_t max_pstate, min_pstate;
+    cout<<"\nEnter the max_pstate to be set:\n";
+    cin>>max_pstate;
+    cout<<"\nEnter the min_pstate to be set:\n";
+    cin>>min_pstate;
+
+    ret = amdsmi_set_cpu_df_pstate_range(sockets[i], i, max_pstate, min_pstate);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed to set df pstate range, Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"Data Fabric PState range(max:"<<unsigned(max_pstate)
+            <<" min:"<<unsigned(min_pstate)<<") set successfully\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_link_id_bw_type_t io_link;
+    uint32_t bw;
+    char *link = "P0";
+    io_link.link_name = link;
+    io_link.bw_type = static_cast<io_bw_encoding>(1) ;
+    ret = amdsmi_get_cpu_current_io_bandwidth(sockets[i], i, io_link, &bw);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed to get io bandwidth width for socket ["<<i<<"], Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"| Current IO Aggregate bandwidth of link"<<io_link.link_name<<" | "<<bw<<" Mbps |\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    amdsmi_link_id_bw_type_t xgmi_link;
+    uint32_t bw1;
+    char *link1 = "P0";
+    int bw_ind = 1;
+    xgmi_link.link_name = link1;
+    xgmi_link.bw_type = static_cast<io_bw_encoding>(1<<bw_ind) ;
+    ret = amdsmi_get_cpu_current_xgmi_bw(sockets[i], xgmi_link, &bw1);
+    CHK_AMDSMI_RET(ret)
+
+    if(ret != AMDSMI_STATUS_SUCCESS)
+        cout<<"Failed to get xgmi bandwidth width, Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     else
+        cout<<"| Current "<<bw_string[bw_ind]<<"bandwidth of xGMI link "<<xgmi_link.link_name<<" | "<<bw<<" Mbps |\n";
+
+     cout<<"\n-------------------------------------------------\n";
+
+    uint32_t met_ver;
+    ret = amdsmi_get_metrics_table_version(sockets[i], &met_ver);
+    CHK_AMDSMI_RET(ret)
+
+    if (ret != AMDSMI_STATUS_SUCCESS) {
+        cout<<"Failed to get Metrics Table Version, Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     } else
+        cout<<"\n| METRICS TABLE Version   |  "<<met_ver<<" \t\t |\n";
+
+    cout<<"\n-------------------------------------------------\n";
+
+    double fraction_q10 = 1/pow(2,10);
+    double fraction_uq10 = fraction_q10;
+    double fraction_uq16 = 1/pow(2,16);
+
+    struct hsmp_metric_table mtbl = {0};
+    ret = amdsmi_get_metrics_table(sockets[i], i, &mtbl);
+    CHK_AMDSMI_RET(ret)
+
+    if (ret != AMDSMI_STATUS_SUCCESS) {
+        cout<<"Failed to get Metrics Table for socket["<<i<<"], Err["<<ret<<"]:"
+            <<*amdsmi_get_esmi_err_msg(ret, &err_str1)<<endl;
+     } else {
+        cout<<"\n| METRICS TABLE  \t\t |\n";
+        cout<<"\n| ACCUMULATOR COUNTER                   |  "<<mtbl.accumulation_counter<<"\t\t|\n";
+        cout<<"\n| SOCKET POWER LIMIT                    |  "<<(mtbl.socket_power_limit * fraction_uq10)<<" W\t\t|\n";
+        cout<<"\n| MAX SOCKET POWER LIMIT                    |  "<<(mtbl.max_socket_power_limit * fraction_uq10)<<" W\t\t|\n";
+        cout<<"\n| SOCKET POWER                     |  "<<(mtbl.socket_power * fraction_uq10)<<" W\t\t|\n";
+    }
+    cout<<"\n-------------------------------------------------\n";
+
   }
   // Clean up resources allocated at amdsmi_init
   ret = amdsmi_shut_down();
diff --git a/include/amd_smi/amdsmi.h b/include/amd_smi/amdsmi.h
index 13897a9f83..5b85077f4c 100644
--- a/include/amd_smi/amdsmi.h
+++ b/include/amd_smi/amdsmi.h
@@ -444,7 +444,8 @@ typedef struct {
   uint64_t device_id;   //< The device id of a GPU
   uint32_t rev_id;
   char asic_serial[AMDSMI_NORMAL_STRING_LENGTH];
-  uint32_t reserved[19];
+  uint16_t xgmi_physical_id;   //< 0xFFFF if not supported
+  uint16_t reserved[37];
 } amdsmi_asic_info_t;
 
 typedef struct{
@@ -4285,6 +4286,36 @@ amdsmi_status_t amdsmi_get_cpu_current_xgmi_bw(amdsmi_cpusocket_handle socket_ha
 
 /** @} */
 
+/*---------------------------------------------------------------------------*/
+/**  @defgroup MetQuer Metrics Table                                         */
+/*---------------------------------------------------------------------------*/
+/** @{  */
+
+/**
+ *  @brief Get metrics table version
+ *
+ *  @param[in]      socket_handle Cpu socket which to query
+ *  @param[in,out]  metrics_version input buffer to return the metrics table version.
+ *
+ *  @return ::amdsmi_status_t | ::AMDSMI_STATUS_SUCCESS on success, non-zero on fail
+ */
+amdsmi_status_t amdsmi_get_metrics_table_version(amdsmi_cpusocket_handle socket_handle,
+        uint32_t *metrics_version);
+
+/**
+ *  @brief Get metrics table
+ *
+ *  @param[in]      socket_handle Cpu socket which to query
+ *  @param[in]		sock_ind - socket index
+ *  @param[in,out]  metrics_table input buffer to return the metrics table.
+ *
+ *  @return ::amdsmi_status_t | ::AMDSMI_STATUS_SUCCESS on success, non-zero on fail
+ */
+amdsmi_status_t amdsmi_get_metrics_table(amdsmi_cpusocket_handle socket_handle, uint8_t sock_ind,
+         struct hsmp_metric_table *metrics_table);
+
+/** @} */
+
 /*---------------------------------------------------------------------------*/
 /**  @defgroup auxiquer     Auxillary functions                              */
 /*---------------------------------------------------------------------------*/
diff --git a/py-interface/amdsmi_wrapper.py b/py-interface/amdsmi_wrapper.py
index 74240ad597..2d2e8bde27 100644
--- a/py-interface/amdsmi_wrapper.py
+++ b/py-interface/amdsmi_wrapper.py
@@ -23,7 +23,7 @@
 import os
 # -*- coding: utf-8 -*-
 #
-# TARGET arch is: ['-I/usr/lib64/clang/16/include']
+# TARGET arch is: ['-I/usr/lib64/clang/17/include']
 # WORD_SIZE is: 8
 # POINTER_SIZE is: 8
 # LONGDOUBLE_SIZE is: 16
@@ -754,7 +754,8 @@ struct_amdsmi_asic_info_t._fields_ = [
     ('device_id', ctypes.c_uint64),
     ('rev_id', ctypes.c_uint32),
     ('asic_serial', ctypes.c_char * 32),
-    ('reserved', ctypes.c_uint32 * 19),
+    ('xgmi_physical_id', ctypes.c_uint16),
+    ('reserved', ctypes.c_uint16 * 37),
 ]
 
 amdsmi_asic_info_t = struct_amdsmi_asic_info_t
@@ -839,6 +840,16 @@ amdsmi_process_handle_t = ctypes.c_uint32
 class struct_amdsmi_proc_info_t(Structure):
     pass
 
+class struct_engine_usage_(Structure):
+    pass
+
+struct_engine_usage_._pack_ = 1 # source:False
+struct_engine_usage_._fields_ = [
+    ('gfx', ctypes.c_uint64),
+    ('enc', ctypes.c_uint64),
+    ('reserved', ctypes.c_uint32 * 12),
+]
+
 class struct_memory_usage_(Structure):
     pass
 
@@ -850,16 +861,6 @@ struct_memory_usage_._fields_ = [
     ('reserved', ctypes.c_uint32 * 10),
 ]
 
-class struct_engine_usage_(Structure):
-    pass
-
-struct_engine_usage_._pack_ = 1 # source:False
-struct_engine_usage_._fields_ = [
-    ('gfx', ctypes.c_uint64),
-    ('enc', ctypes.c_uint64),
-    ('reserved', ctypes.c_uint32 * 12),
-]
-
 struct_amdsmi_proc_info_t._pack_ = 1 # source:False
 struct_amdsmi_proc_info_t._fields_ = [
     ('name', ctypes.c_char * 32),
diff --git a/rocm_smi/include/rocm_smi/rocm_smi.h b/rocm_smi/include/rocm_smi/rocm_smi.h
index c041eb24a5..44179e07f0 100755
--- a/rocm_smi/include/rocm_smi/rocm_smi.h
+++ b/rocm_smi/include/rocm_smi/rocm_smi.h
@@ -1599,6 +1599,23 @@ rsmi_status_t rsmi_dev_subsystem_vendor_id_get(uint32_t dv_ind, uint16_t *id);
  */
 rsmi_status_t rsmi_dev_unique_id_get(uint32_t dv_ind, uint64_t *id);
 
+
+/**
+ *  @brief Get the XGMI physical id associated with the device
+ *
+ *  @details Given a device index @p dv_ind and a pointer to a uint32_t to
+ *  which the XGMI physical id will be written
+ *
+ *  @param[in] dv_ind a device index
+ *
+ *  @param[inout] revision a pointer to uint32_t to which the XGMI physical id
+ *  will be written
+ *
+ *  @retval ::RSMI_STATUS_SUCCESS is returned upon successful call.
+ *
+ */
+rsmi_status_t rsmi_dev_xgmi_physical_id_get(uint32_t dv_ind, uint16_t *id);
+
 /** @} */  // end of IDQuer
 
 /*****************************************************************************/
diff --git a/rocm_smi/include/rocm_smi/rocm_smi_device.h b/rocm_smi/include/rocm_smi/rocm_smi_device.h
index 8640bae9c1..d0743029f9 100755
--- a/rocm_smi/include/rocm_smi/rocm_smi_device.h
+++ b/rocm_smi/include/rocm_smi/rocm_smi_device.h
@@ -102,6 +102,7 @@ enum DevInfoTypes {
   kDevOverDriveLevel,
   kDevMemOverDriveLevel,
   kDevDevID,
+  kDevXGMIPhysicalID,
   kDevDevRevID,
   kDevDevProdName,
   kDevDevProdNum,
diff --git a/rocm_smi/src/rocm_smi.cc b/rocm_smi/src/rocm_smi.cc
index 1d9da410d1..cbaf9af45d 100755
--- a/rocm_smi/src/rocm_smi.cc
+++ b/rocm_smi/src/rocm_smi.cc
@@ -861,6 +861,21 @@ rsmi_dev_id_get(uint32_t dv_ind, uint16_t *id) {
   return ret;
 }
 
+rsmi_status_t
+rsmi_dev_xgmi_physical_id_get(uint32_t dv_ind, uint16_t *id) {
+  std::ostringstream ss;
+  rsmi_status_t ret;
+  ss << __PRETTY_FUNCTION__ << "| ======= start =======";
+  LOG_TRACE(ss);
+  CHK_SUPPORT_NAME_ONLY(id)
+
+  ret = get_id(dv_ind, amd::smi::kDevXGMIPhysicalID, id);
+  ss << __PRETTY_FUNCTION__ << " | ======= end ======="
+     << ", reporting " << amd::smi::getRSMIStatusString(ret);
+  LOG_TRACE(ss);
+  return ret;
+}
+
 rsmi_status_t
 rsmi_dev_revision_get(uint32_t dv_ind, uint16_t *revision) {
   std::ostringstream outss;
diff --git a/rocm_smi/src/rocm_smi_device.cc b/rocm_smi/src/rocm_smi_device.cc
index a1a45795e2..572ade8f35 100755
--- a/rocm_smi/src/rocm_smi_device.cc
+++ b/rocm_smi/src/rocm_smi_device.cc
@@ -85,6 +85,7 @@ static const char *kDevPerfLevelFName = "power_dpm_force_performance_level";
 static const char *kDevDevProdNameFName = "product_name";
 static const char *kDevDevProdNumFName = "product_number";
 static const char *kDevDevIDFName = "device";
+static const char* kDevXGMIPhysicalIDFName = "xgmi_physical_id";
 static const char *kDevDevRevIDFName = "revision";
 static const char *kDevVendorIDFName = "vendor";
 static const char *kDevBoardInfoFName = "board_info";
@@ -243,6 +244,7 @@ static const std::map<DevInfoTypes, const char *> kDevAttribNameMap = {
     {kDevDevProdName, kDevDevProdNameFName},
     {kDevDevProdNum, kDevDevProdNumFName},
     {kDevDevID, kDevDevIDFName},
+    {kDevXGMIPhysicalID, kDevXGMIPhysicalIDFName},
     {kDevDevRevID, kDevDevRevIDFName},
     {kDevVendorID, kDevVendorIDFName},
     {kDevPCieVendorID, kDevPCieVendorIDFName},
@@ -385,6 +387,7 @@ static const std::map<const char *, dev_depends_t> kDevFuncDependsMap = {
     // Functions with only mandatory dependencies
   {"rsmi_dev_vram_vendor_get",           {{kDevVramVendorFName}, {}}},
   {"rsmi_dev_id_get",                    {{kDevDevIDFName}, {}}},
+  {"rsmi_dev_xgmi_physical_id_get",      {{kDevXGMIPhysicalIDFName}, {}}},
   {"rsmi_dev_revision_get",              {{kDevDevRevIDFName}, {}}},
   {"rsmi_dev_vendor_id_get",             {{kDevVendorIDFName}, {}}},
   {"rsmi_dev_name_get",                  {{kDevVendorIDFName,
@@ -929,6 +932,7 @@ int Device::readDevInfo(DevInfoTypes type, uint64_t *val) {
     case kDevVendorID:
     case kDevPCieVendorID:
     case kDevErrCntFeatures:
+    case kDevXGMIPhysicalID:
       ret = readDevInfoStr(type, &tempStr);
       RET_IF_NONZERO(ret);
 
@@ -1104,6 +1108,7 @@ int Device::readDevInfo(DevInfoTypes type, std::string *val) {
     case kDevComputePartition:
     case kDevMemoryPartition:
     case kDevNumaNode:
+    case kDevXGMIPhysicalID:
       return readDevInfoStr(type, val);
       break;
 
diff --git a/rocm_smi/src/rocm_smi_main.cc b/rocm_smi/src/rocm_smi_main.cc
index 2e5b322f28..bed19c3f36 100755
--- a/rocm_smi/src/rocm_smi_main.cc
+++ b/rocm_smi/src/rocm_smi_main.cc
@@ -84,6 +84,7 @@ amd::smi::RocmSMI::devInfoTypesStrings = {
   {amd::smi::kDevOverDriveLevel, amdSMI + "kDevOverDriveLevel"},
   {amd::smi::kDevMemOverDriveLevel, amdSMI + "kDevMemOverDriveLevel"},
   {amd::smi::kDevDevID, amdSMI + "kDevDevID"},
+  {amd::smi::kDevXGMIPhysicalID, amdSMI + "kDevXGMIPhysicalID"},
   {amd::smi::kDevDevRevID, amdSMI + "kDevDevRevID"},
   {amd::smi::kDevDevProdName, amdSMI + "kDevDevProdName"},
   {amd::smi::kDevBoardInfo, amdSMI + "kDevBoardInfo"},
diff --git a/src/amd_smi/amd_smi.cc b/src/amd_smi/amd_smi.cc
index b9e61efcd4..201881b462 100644
--- a/src/amd_smi/amd_smi.cc
+++ b/src/amd_smi/amd_smi.cc
@@ -721,6 +721,11 @@ amdsmi_get_gpu_asic_info(amdsmi_processor_handle processor_handle, amdsmi_asic_i
     status =  rsmi_wrapper(rsmi_dev_pcie_vendor_name_get, processor_handle,
                     info->vendor_name, AMDSMI_MAX_STRING_LENGTH);
 
+    // default to 0xffff as not supported
+    info->xgmi_physical_id = std::numeric_limits<uint16_t>::max();
+    status =  rsmi_wrapper(rsmi_dev_xgmi_physical_id_get, processor_handle,
+                    &(info->xgmi_physical_id));
+
     return AMDSMI_STATUS_SUCCESS;
 }
 
@@ -2685,8 +2690,7 @@ amdsmi_status_t amdsmi_set_cpu_socket_lclk_dpm_level(amdsmi_cpusocket_handle soc
     if (r != AMDSMI_STATUS_SUCCESS)
         return r;
 
-    status = static_cast<amdsmi_status_t>(esmi_socket_lclk_dpm_level_set(sock_ind,
-                                                                        nbio_id, min, max));
+    status = static_cast<amdsmi_status_t>(esmi_socket_lclk_dpm_level_set(sock_ind, nbio_id, min, max));
     if (status != AMDSMI_STATUS_SUCCESS)
         return status;
 
@@ -2813,6 +2817,52 @@ amdsmi_status_t amdsmi_get_cpu_current_xgmi_bw(amdsmi_cpusocket_handle socket_ha
     return AMDSMI_STATUS_SUCCESS;
 }
 
+amdsmi_status_t amdsmi_get_metrics_table_version(amdsmi_cpusocket_handle socket_handle,
+                uint32_t *metrics_version)
+{
+    amdsmi_status_t status;
+    uint32_t metrics_tbl_ver;
+
+    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_metrics_table_version_get(&metrics_tbl_ver));
+    *metrics_version = metrics_tbl_ver;
+
+    if (status != AMDSMI_STATUS_SUCCESS)
+        return status;
+
+    return AMDSMI_STATUS_SUCCESS;
+}
+
+amdsmi_status_t amdsmi_get_metrics_table(amdsmi_cpusocket_handle socket_handle, uint8_t sock_ind,
+                struct hsmp_metric_table *metrics_table)
+{
+    amdsmi_status_t status;
+    struct hsmp_metric_table metrics_tbl;
+
+    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_metrics_table_get(sock_ind, &metrics_tbl));
+    *metrics_table = metrics_tbl;
+
+    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);