Fix sample to handle multiple drivers

Signed-off-by: Neil R. Spruit <neil.r.spruit@intel.com>

Author: nrspruit

samples/zello_world/zello_world.cpp

@@ -82,6 +82,8 @@ int main( int argc, char *argv[] )
     ze_device_handle_t pDevice = nullptr;
     uint32_t driverCount = 0;
     zel_tracer_handle_t tracer = nullptr;
+    std::vector<ze_driver_handle_t> drivers;
+    std::vector<std::vector<ze_device_handle_t>> devices_per_driver;
     if( init_ze(legacy_init, driverCount, driverTypeDesc) )
     {
 
@@ -106,7 +108,6 @@ int main( int argc, char *argv[] )
             }
         }
 
-        std::vector<ze_driver_handle_t> drivers;
         if (legacy_init) {
             status = zeDriverGet(&driverCount, nullptr);
             if(status != ZE_RESULT_SUCCESS) {
@@ -131,87 +132,98 @@ int main( int argc, char *argv[] )
 
         for( uint32_t driver = 0; driver < driverCount; ++driver )
         {
+            std::vector<ze_device_handle_t> devices;
             std::cout << "Driver # " << driver << "\n";
             pDriver = drivers[driver];
             pDevice = findDevice( pDriver, type );
+            if (pDevice) {
+                devices.push_back(pDevice);
+            }
+            devices_per_driver.push_back(devices);
         }
     }
 
-    if( !pDevice )
+    if( devices_per_driver.empty() || drivers.empty() )
     {
         std::cout << "Did NOT find matching " << to_string(type) <<" device!" << "\n";
         return -1;
     }
 
+    for (size_t driver_idx = 0; driver_idx < drivers.size(); ++driver_idx) {
+        pDriver = drivers[driver_idx];
+        for (size_t device_idx = 0; device_idx < devices_per_driver[driver_idx].size(); ++device_idx) {
+            pDevice = devices_per_driver[driver_idx][device_idx];
+            std::cout << "Executing on Driver #" << driver_idx << ", Device #" << device_idx << std::endl;
+            // Create the context
+            ze_context_handle_t context;
+            ze_context_desc_t context_desc = {};
+            context_desc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
+            status = zeContextCreate(pDriver, &context_desc, &context);
+            if(status != ZE_RESULT_SUCCESS) {
+                std::cout << "zeContextCreate Failed with return code: " << to_string(status) << std::endl;
+                continue;
+            }
 
-    // Create the context
-    ze_context_handle_t context;
-    ze_context_desc_t context_desc = {};
-    context_desc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
-    status = zeContextCreate(pDriver, &context_desc, &context);
-    if(status != ZE_RESULT_SUCCESS) {
-        std::cout << "zeContextCreate Failed with return code: " << to_string(status) << std::endl;
-        exit(1);
-    }
-
-    // Create an immediate command list for direct submission
-    ze_command_queue_desc_t altdesc = {};
-    altdesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
-    ze_command_list_handle_t command_list = {};
-    status = zeCommandListCreateImmediate(context, pDevice, &altdesc, &command_list);
-    if(status != ZE_RESULT_SUCCESS) {
-        std::cout << "zeCommandListCreateImmediate Failed with return code: " << to_string(status) << std::endl;
-        exit(1);
-    }
+            // Create an immediate command list for direct submission
+            ze_command_queue_desc_t altdesc = {};
+            altdesc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
+            ze_command_list_handle_t command_list = {};
+            status = zeCommandListCreateImmediate(context, pDevice, &altdesc, &command_list);
+            if(status != ZE_RESULT_SUCCESS) {
+                std::cout << "zeCommandListCreateImmediate Failed with return code: " << to_string(status) << std::endl;
+                continue;
+            }
 
-    // Create an event to be signaled by the device
-    ze_event_pool_desc_t ep_desc = {};
-    ep_desc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
-    ep_desc.count = 1;
-    ep_desc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
-    ze_event_desc_t ev_desc = {};
-    ev_desc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
-    ev_desc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
-    ev_desc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
-    ze_event_handle_t event;
-    ze_event_pool_handle_t event_pool;
-
-    status = zeEventPoolCreate(context, &ep_desc, 1, &pDevice, &event_pool);
-    if(status != ZE_RESULT_SUCCESS) {
-        std::cout << "zeEventPoolCreate Failed with return code: " << to_string(status) << std::endl;
-        exit(1);
-    }
+            // Create an event to be signaled by the device
+            ze_event_pool_desc_t ep_desc = {};
+            ep_desc.stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC;
+            ep_desc.count = 1;
+            ep_desc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+            ze_event_desc_t ev_desc = {};
+            ev_desc.stype = ZE_STRUCTURE_TYPE_EVENT_DESC;
+            ev_desc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+            ev_desc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
+            ze_event_handle_t event;
+            ze_event_pool_handle_t event_pool;
+
+            status = zeEventPoolCreate(context, &ep_desc, 1, &pDevice, &event_pool);
+            if(status != ZE_RESULT_SUCCESS) {
+                std::cout << "zeEventPoolCreate Failed with return code: " << to_string(status) << std::endl;
+                continue;
+            }
 
-    status = zeEventCreate(event_pool, &ev_desc, &event);
-    if(status != ZE_RESULT_SUCCESS) {
-        std::cout << "zeEventCreate Failed with return code: " << to_string(status) << std::endl;
-        exit(1);
-    }
+            status = zeEventCreate(event_pool, &ev_desc, &event);
+            if(status != ZE_RESULT_SUCCESS) {
+                std::cout << "zeEventCreate Failed with return code: " << to_string(status) << std::endl;
+                continue;
+            }
 
-    // signal the event from the device and wait for completion
-    zeCommandListAppendSignalEvent(command_list, event);
-    zeEventHostSynchronize(event, UINT64_MAX );
-    std::cout << "Congratulations, the device completed execution!\n";
-
-    zeContextDestroy(context);
-    zeCommandListDestroy(command_list);
-    zeEventDestroy(event);
-    zeEventPoolDestroy(event_pool);
-
-    if (tracing_enabled) {
-        status = zelTracerDestroy(tracer);
-        if(status != ZE_RESULT_SUCCESS) {
-            std::cout << "zelTracerDestroy Failed with return code: " << to_string(status) << std::endl;
-            exit(1);
-        }
-    }
+            // signal the event from the device and wait for completion
+            zeCommandListAppendSignalEvent(command_list, event);
+            zeEventHostSynchronize(event, UINT64_MAX );
+            std::cout << "Congratulations, Executing on Driver #" << driver_idx << ", Device #" << device_idx << " completed execution!" << std::endl;
+
+            zeContextDestroy(context);
+            zeCommandListDestroy(command_list);
+            zeEventDestroy(event);
+            zeEventPoolDestroy(event_pool);
+
+            if (tracing_enabled) {
+                status = zelTracerDestroy(tracer);
+                if(status != ZE_RESULT_SUCCESS) {
+                    std::cout << "zelTracerDestroy Failed with return code: " << to_string(status) << std::endl;
+                    exit(1);
+                }
+            }
 
-    if (tracing_runtime_enabled) {
-        std::cout << "Disable Tracing Layer after init" << std::endl;
-        status = zelDisableTracingLayer();
-        if(status != ZE_RESULT_SUCCESS) {
-            std::cout << "zelDisableTracingLayer Failed with return code: " << to_string(status) << std::endl;
-            exit(1);
+            if (tracing_runtime_enabled) {
+                std::cout << "Disable Tracing Layer after init" << std::endl;
+                status = zelDisableTracingLayer();
+                if(status != ZE_RESULT_SUCCESS) {
+                    std::cout << "zelDisableTracingLayer Failed with return code: " << to_string(status) << std::endl;
+                    exit(1);
+                }
+            }
         }
     }