Upload 8 files

test_cpp/.gitignore

@@ -0,0 +1,3 @@
+build
+configure.txt
+passContext.txt 

test_cpp/CMakeLists.txt

@@ -0,0 +1,86 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(app VERSION 1.0.0 LANGUAGES C CXX)
+
+set(RYZEN_AI_INSTALLATION_PATH $ENV{RYZEN_AI_INSTALLATION_PATH})
+set(ONNXRUNTIME_ROOTDIR "${RYZEN_AI_INSTALLATION_PATH}/onnxruntime")
+set(PYTHONHOME "$ENV{CONDA_PREFIX}")
+
+message(STATUS "RYZEN_AI_INSTALLATION_PATH = ${RYZEN_AI_INSTALLATION_PATH}")
+message(STATUS "ONNXRUNTIME_ROOTDIR        = ${ONNXRUNTIME_ROOTDIR}")
+message(STATUS "PYTHONHOME                 = ${PYTHONHOME}")
+
+set(CMAKE_CONFIGURATION_TYPES Release)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_INSTALL_PREFIX .)
+set(CMAKE_PREFIX_PATH .)
+set(BUILD_SHARED_LIBS OFF)
+
+add_compile_options(
+  /Zc:__cplusplus
+  /wd4100
+  /wd4996
+  /WX
+  /std:c++latest
+)
+
+include_directories(
+  "${ONNXRUNTIME_ROOTDIR}/include/onnxruntime/core/session"
+  src
+)
+
+add_compile_options(
+    /Qspectre
+    /ZH:SHA_256
+    /guard:cf
+    /W3
+    /Zi
+    /Zc:__cplusplus
+)
+add_link_options(
+    /CETCOMPAT
+    /DEBUG
+)
+
+link_directories("${ONNXRUNTIME_ROOTDIR}/lib")
+link_directories("${CMAKE_INSTALL_PREFIX}/lib")
+
+add_executable(${PROJECT_NAME} src/main.cpp src/npu_util.cpp)
+
+target_link_libraries(${PROJECT_NAME} onnxruntime)
+
+
+# -- Copy the RyzenAI runtime DLLs in folder containing the executable
+
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/dyn_dispatch_core.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/onnxruntime.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/onnxruntime_providers_shared.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/onnxruntime_providers_vitisai.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/onnxruntime_vitisai_ep.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/transaction.dll")
+list(APPEND dll_list "${RYZEN_AI_INSTALLATION_PATH}/deployment/voe/xclbin.dll")
+
+foreach(DLL_FILE ${dll_list})
+  add_custom_command(
+    TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DLL_FILE} $<TARGET_FILE_DIR:${PROJECT_NAME}>
+  )
+endforeach()
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different 
+  "${RYZEN_AI_INSTALLATION_PATH}/quicktest/test_model.onnx" $<TARGET_FILE_DIR:${PROJECT_NAME}>
+)
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different 
+  "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/phoenix/1x4.xclbin"
+  $<TARGET_FILE_DIR:${PROJECT_NAME}>/xclbins/phoenix/1x4.xclbin
+)
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different 
+  "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/strix/AMD_AIE2P_Nx4_Overlay.xclbin"
+  $<TARGET_FILE_DIR:${PROJECT_NAME}>/xclbins/strix/AMD_AIE2P_Nx4_Overlay.xclbin
+)
+
+
+
+

test_cpp/README.md

@@ -0,0 +1,99 @@
+# Simple ONNX RT C++ Example for the NPU
+
+A simple C++ program which runs an ONNX model on the CPU and then on the NPU (if the system configuration allows it).
+
+## Requirements
+
+To build the example, the following software must be installed:
+- Ryzen AI 1.4
+- Cmake
+- Visual Studio 2022
+
+## Instructions
+
+- Build the example
+
+```
+conda activate <RAI env>
+compile.bat
+```
+
+- Run the example
+
+```
+run.bat
+```
+
+Note: it is not necessary to run the example from within the RyzenAI conda environment.
+
+## Notes
+
+- The CMakeLists.txt copies all the required files (DLLs, XCLBINs) from the RyzenAI installation tree into the folder where the executable is created. With this approach, there is no runtime dependency on the RyzenAI installation tree. Once built, the example can be run on machines without RyzenAI installed.
+
+- This example shows that it is possible to run without any dependency on Python.
+
+- The example uses the test_model.onnx model from the quicktest folder.
+
+- Like the Python quicktest, this example runs the model with random data and doesn't test the output results.
+
+- The application uses the VAI-EP session options to specify the XCLBIN, and it explicitly unsets the XLNX_VART_FIRMWARE and XLNX_TARGET_NAME env vars.
+
+- The example uses the helper functions in `npu_util.cpp` to check whether VAI-EP 1.4 can be used on the deployment machine, and to determine the type of NPU present (PHX/HPT or STX/KRK).
+
+- The test program only supports models with exactly 1 input node and 1 output node. But the code can easily be extended to support an arbitrary number of nodes if need be.
+
+
+## Sample Output
+
+Sample output of a successful run:
+
+```
+>run.bat
+
+-------------------------------------------------------
+Running quicktest on CPU
+-------------------------------------------------------
+Creating ORT env
+Initializing session options
+Creating ONNX Session
+ONNX model : c:\temp\quicktest_cpp\build\Release\test_model.onnx
+  input -1x3x32x32
+  output -1x10
+Dynamic batch size detected. Setting batch size to 1.
+Running the model
+-------------------------------------------------------
+Test PASSED!
+-------------------------------------------------------
+
+-------------------------------------------------------
+Performing compatibility check for VitisAI EP 1.4
+-------------------------------------------------------
+ - NPU Device ID     : 0x1502
+ - NPU Device Name   : NPU Compute Accelerator Device
+ - NPU Driver Version: 32.0.203.252
+Environment compatible for VitisAI EP
+
+-------------------------------------------------------
+Running quicktest on NPU
+-------------------------------------------------------
+Creating ORT env
+Initializing session options
+Configuring VAI EP
+Creating ONNX Session
+WARNING: Logging before InitGoogleLogging() is written to STDERR
+I20250221 12:48:40.532923 76424 vitisai_compile_model.cpp:1046] Vitis AI EP Load ONNX Model Success
+I20250221 12:48:40.532923 76424 vitisai_compile_model.cpp:1047] Graph Input Node Name/Shape (1)
+I20250221 12:48:40.532923 76424 vitisai_compile_model.cpp:1051]          input : [-1x3x32x32]
+I20250221 12:48:40.532923 76424 vitisai_compile_model.cpp:1057] Graph Output Node Name/Shape (1)
+I20250221 12:48:40.532923 76424 vitisai_compile_model.cpp:1061]          output : [-1x10]
+[Vitis AI EP] No. of Operators :   CPU     2    NPU   18e
+[Vitis AI EP] No. of Subgraphs :   CPU     1    NPU     1 Actually running on NPU     1
+ONNX model : C:\temp\quicktest_cpp\build\Release\test_model.onnx
+  input -1x3x32x32
+  output -1x10
+Dynamic batch size detected. Setting batch size to 1.
+Running the model
+-------------------------------------------------------
+Test PASSED!
+-------------------------------------------------------
+```

test_cpp/compile.bat

@@ -0,0 +1,13 @@
+@echo off
+
+if "%CONDA_PREFIX%" == "" echo CONDA_PREFIX not set. This script must be executed from within the RyzenAI conda environment. & goto :error
+if "%RYZEN_AI_INSTALLATION_PATH%" == "" echo RYZEN_AI_INSTALLATION_PATH not set. This script requires the RYZEN_AI_INSTALLATION_PATH env var to be set to the RyzenAI installation folder. & goto :error
+
+cmake -DCMAKE_CONFIGURATION_TYPES=Release -A x64 -T host=x64  -B build -S . -G "Visual Studio 17 2022"
+
+cmake --build .\build --config Release --target ALL_BUILD
+
+echo.
+
+:error
+exit /b %errorlevel%

test_cpp/run.bat

@@ -0,0 +1,6 @@
+@echo off
+
+build\Release\app.exe
+
+echo.
+

test_cpp/src/main.cpp

@@ -0,0 +1,281 @@
+/***********************************************************************************
+MIT License
+
+Copyright (c) 2023, Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ************************************************************************************/
+#include <assert.h>
+#include <onnxruntime_cxx_api.h>
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <codecvt>
+#include <filesystem>
+
+#include "npu_util.h"
+
+
+static int get_num_elements(const std::vector<int64_t>& v) {
+    int total = 1;
+    for (auto& i : v)
+        total *= (int)i;
+    return total;
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
+{
+    os << "[";
+    for (int i = 0; i < v.size(); ++i)
+    {
+        os << v[i];
+        if (i != v.size() - 1)
+        {
+            os << ", ";
+        }
+    }
+    os << "]";
+    return os;
+}
+
+// pretty prints a shape dimension vector
+static std::string print_shape(const std::vector<int64_t>& v) {
+    std::stringstream ss("");
+    for (size_t i = 0; i < v.size() - 1; i++)
+        ss << v[i] << "x";
+    ss << v[v.size() - 1];
+    return ss.str();
+}
+
+static std::string print_tensor(Ort::Value& tensor) {
+    auto shape = tensor.GetTensorTypeAndShapeInfo().GetShape();
+    auto nelem = get_num_elements(shape);
+    auto tensor_ptr = tensor.GetTensorMutableData<float>();
+
+    std::stringstream ss("");
+    for (auto i = 0; i < nelem; i++)
+        ss << tensor_ptr[i] << " ";
+    return ss.str();
+}
+
+template <typename T>
+Ort::Value vec_to_tensor(std::vector<T>& data, const std::vector<std::int64_t>& shape) {
+  Ort::MemoryInfo mem_info =
+      Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);
+  auto tensor = Ort::Value::CreateTensor<T>(mem_info, data.data(), data.size(), shape.data(), shape.size());
+  return tensor;
+}
+
+std::string get_program_dir()
+{
+    char* exe_path; _get_pgmptr(&exe_path); // full path and name of the executable
+    return std::filesystem::path(exe_path).parent_path().string(); // directory in which the executable is located
+}
+
+
+int runtest(std::string& model_name, std::unordered_map<std::string, std::string>& vai_ep_options)
+{    
+    int64_t batch_size  = 1;
+
+    printf("Creating ORT env\n");
+    Ort::Env env(ORT_LOGGING_LEVEL_ERROR, "quicktest");
+
+    printf("Initializing session options\n");
+    auto session_options = Ort::SessionOptions();
+
+    if (vai_ep_options.empty()==false) // If VAI EP options are provided, initialize the VitisAI EP
+    {
+        printf("Configuring VAI EP\n");
+        try {
+            session_options.AppendExecutionProvider_VitisAI(vai_ep_options);
+        }
+        catch (const std::exception& e) {
+            std::cerr << "Exception occurred in appending execution provider: " << e.what() << std::endl;
+        }
+    }
+
+    printf("Creating ONNX Session\n");
+    auto session = Ort::Session(env, std::basic_string<ORTCHAR_T>(model_name.begin(), model_name.end()).c_str(), session_options);
+
+    // Get names and shapes of model inputs and outputs
+    Ort::AllocatorWithDefaultOptions allocator;
+    auto input_count       = session.GetInputCount();
+    auto input_names       = std::vector<std::string>();
+    auto input_names_char  = std::vector<const char*>();
+    auto input_shapes      = std::vector<std::vector<int64_t>>();
+    auto output_count      = session.GetOutputCount();
+    auto output_names      = std::vector<std::string>();
+    auto output_names_char = std::vector<const char*>();
+    auto output_shapes     = std::vector<std::vector<int64_t>>();
+    for (size_t i = 0; i < input_count; i++)
+    {
+        auto shape = session.GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
+        std::string name = session.GetInputNameAllocated(i, allocator).get();
+        input_names.emplace_back(name);
+        input_names_char.emplace_back(input_names.at(i).c_str());
+        input_shapes.emplace_back(shape);
+    }
+    for (size_t i = 0; i < output_count; i++)
+    {
+        auto shape = session.GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape();
+        std::string name = session.GetOutputNameAllocated(i, allocator).get();
+        output_names.emplace_back(name);
+        output_names_char.emplace_back(output_names.at(i).c_str());
+        output_shapes.emplace_back(shape);
+    }
+
+    // Display model info
+    std::cout << "ONNX model : " << model_name << std::endl;
+    for (size_t i = 0; i < input_count; i++)
+        std::cout << "  " << input_names.at(i) << " " << print_shape(input_shapes.at(i)) << std::endl;
+    for (size_t i = 0; i < output_count; i++)
+        std::cout << "  " << output_names.at(i) << " " << print_shape(output_shapes.at(i)) << std::endl;
+
+    // The code which follows expects the model to have 1 input node and 1 output node.
+    if (output_count != 1 && input_count != 1) {
+        std::cout << "This version of the program only supports models with 1 input node and 1 output node. Exiting." << std::endl;
+        exit(-1);
+    }
+
+    // If input shape has dynamic batch size, set it to a fixed value
+    auto input_shape = input_shapes[0];
+    if (input_shape[0] < 0) {
+        std::cout << "Dynamic batch size detected. Setting batch size to " << batch_size << "." << std::endl;        
+        input_shape[0] = batch_size;
+    }
+
+    printf("Running the model\n");
+    for (int i = 0; i < 1; i++)
+    {
+        // Initialize input data with random numbers in the range [0, 255]
+        std::vector<float> input_tensor_values(get_num_elements(input_shape));
+        std::generate(input_tensor_values.begin(), input_tensor_values.end(), [&] { return (float)(rand() % 255); });
+
+        // Initialize input tensor with input data
+        std::vector<Ort::Value> input_tensors;
+        input_tensors.emplace_back(vec_to_tensor<float>(input_tensor_values, input_shape));
+
+        // Pass input tensors through model
+        try {
+            auto output_tensors = session.Run(
+                    Ort::RunOptions(), 
+                    input_names_char.data(), input_tensors.data(), input_names_char.size(), 
+                    output_names_char.data(), output_names_char.size()
+            );
+            // std::cout << i << " : " << print_tensor(output_tensors[0]) << std::endl;
+        }
+        catch (const Ort::Exception& exception) {
+            std::cout << "ERROR running model inference: " << exception.what() << std::endl;
+            exit(-1);
+        }
+    }
+    printf("-------------------------------------------------------\n");
+    printf("Test PASSED!\n");
+    printf("-------------------------------------------------------\n");
+    printf("\n");
+    
+    return 0;
+}
+
+
+int run_on_cpu(std::string& model_name, std::string& exe_dir)
+{
+    // Leave VitisAI EP options empty to run on CPU
+    std::unordered_map<std::string, std::string> vai_ep_options;
+
+    // Full path to the ONNX model
+    std::string model_path = exe_dir + "\\" + model_name;
+
+    // Run test
+    printf("-------------------------------------------------------\n");
+    printf("Running quicktest on CPU                               \n");    
+    printf("-------------------------------------------------------\n");
+    return runtest(model_path, vai_ep_options);
+}
+
+int run_on_npu(std::string& model_name, std::string& exe_dir)
+{
+    printf("-------------------------------------------------------\n");
+    printf("Performing compatibility check for VitisAI EP 1.4      \n");
+    printf("-------------------------------------------------------\n");
+    auto npu_info = npu_util::checkCompatibility_RAI_1_4();
+
+    std::cout << " - NPU Device ID     : 0x" << std::hex << npu_info.device_id << std::dec << std::endl;
+    std::cout << " - NPU Device Name   : " << npu_info.device_name << std::endl;
+    std::cout << " - NPU Driver Version: " << npu_info.driver_version_string << std::endl;  
+    switch (npu_info.check) {
+        case npu_util::Status::OK:          
+            std::cout << "Environment compatible for VitisAI EP" << std::endl;
+            break;
+        case npu_util::Status::NPU_UNRECOGNIZED:
+            std::cout << "NPU type not recognized." << std::endl;
+            std::cout << "Skipping run with VitisAI EP." << std::endl;
+            return -1;           
+            break;
+        case npu_util::Status::DRIVER_TOO_OLD: 
+            std::cout << "Installed drivers are too old." << std::endl;
+            std::cout << "Skipping run with VitisAI EP." << std::endl;
+            return -1;           
+            break;
+        case npu_util::Status::EP_TOO_OLD:
+            std::cout << "VitisAI EP is too old." << std::endl;
+            std::cout << "Skipping run with VitisAI EP." << std::endl;
+            return -1;           
+            break;
+        default:
+            std::cout << "Unknown state." << std::endl;
+            std::cout << "Skipping run with VitisAI EP." << std::endl;
+            return -1;           
+            break;
+    }
+    std::cout << std::endl;
+
+    // Set VitisAI EP options
+    std::unordered_map<std::string, std::string> vai_ep_options;
+    switch(npu_info.device_id) {
+        case 0x1502: // PHX/HPT NPU
+            vai_ep_options["cacheDir"] = exe_dir + "\\modelcache"; 
+            vai_ep_options["cacheKey"] = "testmodel_phx"; 
+            vai_ep_options["xclbin"]   = exe_dir + "\\xclbins\\phoenix\\1x4.xclbin";; 
+            break;
+        case 0x17F0: // STX/KRK NPU
+            vai_ep_options["cacheDir"] = exe_dir + "\\modelcache"; 
+            vai_ep_options["cacheKey"] = "testmodel_stx"; 
+            vai_ep_options["xclbin"]   = exe_dir + "\\xclbins\\strix\\AMD_AIE2P_Nx4_Overlay.xclbin"; 
+            break;
+        default:
+            std::cout << "Unsupported NPU device ID." << std::endl;
+            return -1;
+            break;
+    }
+
+    // Set environment variables
+    _putenv("XLNX_VART_FIRMWARE=");           // Unset XLNX_VART_FIRMWARE (use VAI-EP option to set XCLBIN)
+    _putenv("XLNX_TARGET_NAME=");             // Unset XLNX_TARGET_NAME   (rely on default value: AMD_AIE2P_Nx4_Overlay)
+
+    // Full path to the ONNX model
+    std::string model_path = exe_dir + "\\" + model_name;
+
+    // Run test
+    printf("-------------------------------------------------------\n");
+    printf("Running quicktest on NPU                               \n");    
+    printf("-------------------------------------------------------\n");
+    return runtest(model_path, vai_ep_options);
+}
+
+int main(int argc, char* argv[]) 
+{
+    std::string exe_dir = get_program_dir();
+    std::string model_name ="test_model.onnx";
+ 
+    run_on_cpu(model_name, exe_dir);
+    run_on_npu(model_name, exe_dir);
+
+    return 0;
+}

test_cpp/src/npu_util.cpp

@@ -0,0 +1,193 @@
+/***********************************************************************************
+MIT License
+
+Copyright (c) 2023, Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+software and associated documentation files (the "Software"), to deal in the Software 
+without restriction, including without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit 
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall 
+be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+OTHER DEALINGS IN THE SOFTWARE.
+************************************************************************************/
+
+// compile using: /std:c++latest
+
+#pragma comment(lib, "setupapi.lib")
+
+#include <chrono>
+#include <vector>
+#include <mutex>
+
+#include <Windows.h>
+#include <setupapi.h>
+#include <devguid.h>
+
+#include "npu_util.h"
+
+
+namespace npu_util {
+
+    std::string DriverHexToString(DWORDLONG ver) {
+        std::stringstream string_stream;
+        string_stream << ((ver >> 48) & 0xffff) << "." << ((ver >> 32) & 0xffff) << "." << ((ver >> 16) & 0xffff) << "." << ((ver >> 0) & 0xffff);
+        return string_stream.str();
+    }
+
+    DWORDLONG DriverNumberToHex(DWORDLONG a, DWORDLONG b, DWORDLONG c, DWORDLONG d) {
+        DWORDLONG ver = ((a & 0xffff) << 48) | ((b & 0xffff) << 32) | ((c & 0xffff) << 16) | ((d & 0xffff) << 0) ;
+        return ver;
+    }
+
+    // Extract NPU information
+    NPUInfo extractNPUInfo()
+    {
+        // Make extractNPUInfo thread-safe
+        static std::mutex function_mutex;
+        std::lock_guard<std::mutex> guard(function_mutex);
+
+        NPUInfo npu_info;
+        npu_info.device_id = -1; 
+        npu_info.device_name = "";
+        npu_info.driver_version_number = -1;
+        npu_info.driver_version_string = "";
+        npu_info.check = Status::UNKNOWN;
+
+        static const std::vector<std::pair<std::string, int>> PCI_IDS = {
+            { "PCI\\VEN_1022&DEV_1502", 0x1502 }, // AIE2
+            { "PCI\\VEN_1022&DEV_17F0", 0x17F0 }  // AIE2P
+        };
+
+        static const std::vector<const GUID*> DEV_CLASSES = {
+            &GUID_DEVCLASS_COMPUTEACCELERATOR,
+            &GUID_DEVCLASS_SYSTEM
+        };
+
+        for (const auto& devClass : DEV_CLASSES) {
+            HDEVINFO deviceInfoSet = SetupDiGetClassDevs(devClass, nullptr, nullptr, DIGCF_PRESENT);
+            if (deviceInfoSet == INVALID_HANDLE_VALUE) {
+                continue;
+            }
+
+            SP_DEVINFO_DATA deviceInfoData = { 0 };
+            deviceInfoData.cbSize = sizeof(deviceInfoData);
+
+            DWORD index = 0;
+            while (npu_info.device_id == -1 && SetupDiEnumDeviceInfo(deviceInfoSet, index, &deviceInfoData)) {
+                DWORD requiredSize = 0;
+
+                SetupDiGetDeviceRegistryPropertyA(deviceInfoSet, &deviceInfoData, SPDRP_HARDWAREID, nullptr, nullptr, 0, &requiredSize);
+
+                std::vector<BYTE> buffer(requiredSize);
+
+                if (SetupDiGetDeviceRegistryPropertyA(deviceInfoSet, &deviceInfoData, SPDRP_HARDWAREID, nullptr, buffer.data(), requiredSize, nullptr)) {
+                    std::string hardwareId(reinterpret_cast<const char*>(buffer.data()));
+
+                    for (const auto& entry : PCI_IDS) {
+                        if (hardwareId.find(entry.first) != std::string::npos) {
+                            npu_info.device_id = entry.second;
+                            requiredSize = 0;
+                            SetupDiGetDeviceRegistryPropertyA(deviceInfoSet, &deviceInfoData, SPDRP_DEVICEDESC, nullptr, nullptr, 0, &requiredSize);
+
+                            buffer.resize(requiredSize);
+                            if (SetupDiGetDeviceRegistryPropertyA(deviceInfoSet, &deviceInfoData, SPDRP_DEVICEDESC, nullptr, buffer.data(), requiredSize, nullptr)) {
+                                std::string dev_desc(reinterpret_cast<const char*>(buffer.data()));
+                                npu_info.device_name = dev_desc;
+                            }
+                            SP_DEVINSTALL_PARAMS DeviceInstallParams;
+                            ZeroMemory(&DeviceInstallParams, sizeof(DeviceInstallParams));
+                            DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
+                            DeviceInstallParams.FlagsEx |= (DI_FLAGSEX_INSTALLEDDRIVER | DI_FLAGSEX_ALLOWEXCLUDEDDRVS);
+                            if (SetupDiSetDeviceInstallParams(deviceInfoSet, &deviceInfoData, &DeviceInstallParams)) {
+                                if (SetupDiBuildDriverInfoList(deviceInfoSet, &deviceInfoData, SPDIT_COMPATDRIVER)) {
+                                    SP_DRVINFO_DATA DriverInfoData;
+                                    DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
+                                    if (SetupDiEnumDriverInfo(deviceInfoSet, &deviceInfoData, SPDIT_COMPATDRIVER, 0, &DriverInfoData)) {
+                                        npu_info.driver_version_number = DriverInfoData.DriverVersion;
+                                        npu_info.driver_version_string = DriverHexToString(DriverInfoData.DriverVersion).c_str();
+                                    }
+                                }
+                                SetupDiDestroyDriverInfoList(deviceInfoSet, &deviceInfoData, SPDIT_COMPATDRIVER);
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                ++index;
+            }
+
+            SetupDiDestroyDeviceInfoList(deviceInfoSet);
+
+            if (npu_info.device_id != -1) {
+                break;
+            }
+        }
+        return npu_info;
+    }
+
+    NPUInfo checkCompatibility(DWORDLONG min_driver_version, std::chrono::year_month_day max_date)
+    {
+        NPUInfo info = extractNPUInfo();
+
+        // Check if supported NPU is present
+        if (info.device_id==-1) {
+            info.check = Status::NPU_UNRECOGNIZED; 
+            return info;
+        }
+
+        // Check if minimum version of driver is installed
+        if (info.driver_version_number<min_driver_version) {
+            info.check = Status::DRIVER_TOO_OLD; 
+            return info;            
+        }
+
+        // Check for 3 yr EP/driver compatibility window
+        std::chrono::year_month_day current_date{std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())};;
+        if (current_date>max_date) {
+            info.check = Status::EP_TOO_OLD; 
+            return info;              
+        }
+
+        info.check = Status::OK; 
+        return info;
+    }
+
+    NPUInfo checkCompatibility_RAI_1_2()
+    {
+        // Min driver: 32.0.201.204
+        // Max date  : 2027-07-30 (3 yrs after the release date of RyzenAI 1.2)
+        return checkCompatibility(DriverNumberToHex(32,0,201,204), { std::chrono::July / 30 / 2027 });
+    }
+
+    NPUInfo checkCompatibility_RAI_1_3()
+    {
+        // Min driver: 32.0.203.237
+        // Max date  : 2027-11-26 (3 yrs after the release date of RyzenAI 1.3)
+        return checkCompatibility(DriverNumberToHex(32,0,203,237), { std::chrono::November / 26 / 2027 });
+    }
+   
+    NPUInfo checkCompatibility_RAI_1_3_1()
+    {
+        // Min driver: 32.0.203.242
+        // Max date  : 2028-01-17 (3 yrs after the release date of RyzenAI 1.3)
+        return checkCompatibility(DriverNumberToHex(32,0,203,242), { std::chrono::January / 15 / 2028 });
+    }
+
+    NPUInfo checkCompatibility_RAI_1_4()
+    {
+        // Min driver: 32.0.203.257 (May change before the release)
+        // Max date  : 2028-03-25   (Will change before the release)
+        return checkCompatibility(DriverNumberToHex(32,0,203,257), { std::chrono::March / 25 / 2028 });
+    }    
+
+} // npu_util

test_cpp/src/npu_util.h

@@ -0,0 +1,61 @@
+/***********************************************************************************
+MIT License
+
+Copyright (c) 2023, Advanced Micro Devices, Inc. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this 
+software and associated documentation files (the "Software"), to deal in the Software 
+without restriction, including without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit 
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall 
+be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+OTHER DEALINGS IN THE SOFTWARE.
+************************************************************************************/
+
+#pragma once
+
+#include <string>
+
+#include <Windows.h>
+
+
+namespace npu_util {
+
+    enum Status {
+        OK = 0,
+        UNKNOWN,
+        NPU_UNRECOGNIZED,
+        DRIVER_TOO_OLD,
+        EP_TOO_OLD
+    };
+
+    struct NPUInfo {
+        int device_id;
+        std::string device_name;
+        DWORDLONG driver_version_number;
+        std::string driver_version_string;
+        Status check;
+    };
+
+    // Checks whether the system configuration is compatible for VitisAI EP 1.2
+    NPUInfo checkCompatibility_RAI_1_2();
+
+    // Checks whether the system configuration is compatible for VitisAI EP 1.3
+    NPUInfo checkCompatibility_RAI_1_3();
+
+    // Checks whether the system configuration is compatible for VitisAI EP 1.3.1
+    NPUInfo checkCompatibility_RAI_1_3_1();
+
+    // Checks whether the system configuration is compatible for VitisAI EP 1.4
+    NPUInfo checkCompatibility_RAI_1_4();
+
+} // npu_util
+