Cache context offline device setting specified by environment variables

Author: sophimao

include/acl_globals.h

@@ -44,18 +44,8 @@ void acl_reset(void);
 // if it is not.
 cl_bool acl_init_from_hal_discovery(void);
 
-// Looks at environment variable CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA.
-// If it exists and is prefixed by "+" then:
-//    Return a pointer to the device name (without the "+" prefix).
-//    Set *use_offline_ret_only = 1
-// If it exists and is not prefixed by "+" then
-//    Return a pointer to the device name.
-//    Set *use_offline_ret_only = 0
-#define ACL_CONTEXT_OFFLINE_AND_AUTODISCOVERY 0
-#define ACL_CONTEXT_OFFLINE_ONLY 1
-#define ACL_CONTEXT_MSIM 3
-#define ACL_CONTEXT_MPSIM 4
-const char *acl_get_offline_device_user_setting(int *use_offline_only_ret);
+acl_context_offline_mode_t
+acl_get_offline_device_user_setting(std::string *offline_device);
 
 ACL_EXPORT
 extern struct _cl_platform_id acl_platform;

include/acl_types.h

@@ -216,6 +216,20 @@ typedef enum {
   ACL_COMPILER_MODE_NUM_MODES = CL_CONTEXT_COMPILER_MODE_NUM_MODES_INTELFPGA
 } acl_compiler_mode_t;
 
+// Looks at environment variable CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA.
+// If it exists and is prefixed by "+" then:
+//    Return a pointer to the device name (without the "+" prefix).
+//    Set *use_offline_ret_only = 1
+// If it exists and is not prefixed by "+" then
+//    Return a pointer to the device name.
+//    Set *use_offline_ret_only = 0
+typedef enum {
+  ACL_CONTEXT_OFFLINE_AND_AUTODISCOVERY,
+  ACL_CONTEXT_OFFLINE_ONLY,
+  ACL_CONTEXT_MSIM,
+  ACL_CONTEXT_MPSIM
+} acl_context_offline_mode_t;
+
 /* When a feature is still in development, it might need enum values
  * that are distinct from all published enums in the OpenCL token registry.
  * There is a reserved range for values for such "experimental" features.
@@ -1226,7 +1240,8 @@ typedef struct _cl_device_id {
 
   unsigned int address_bits; // cache address bits to avoid GetDeviceInfo calls
 
-  int present; // Is the device present in the host system?
+  bool present; // Is the device present in the host system?
+  bool offline; // Is the device a real (i.e., not simulator) offline device?
 
   // Error notification callback.
   CL_EXCEPTION_TYPE_INTEL device_exception_status;
@@ -1573,9 +1588,16 @@ typedef struct _cl_platform_id
   int device_exception_platform_counter; // indicates number of devices with at
                                          // least one exception
 
-  // The setting of environment variable CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA, if
-  // any.
-  std::string offline_device;
+  // Record whether the platform has (non-simulator) offline device,
+  // value will be:
+  // 1: if there is a valid offline device specified by environment variable
+  // 0: if there is no offline device specified by environment variable
+  // -1: if the offline device specified by environment variable is invalid
+  int has_offline_device;
+  // Cache context offline mode specified by environment variables
+  // CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA, CL_CONTEXT_MPSIM_DEVICE_INTELFPGA
+  // or CL_CONTEXT_MSIM_DEVICE_INTELFPGA
+  acl_context_offline_mode_t offline_mode;
 
   // Should we track and automatically release leaked objects?
   // This helps immensely with the OpenCL conformance tests which tend to

src/acl_context.cpp

@@ -48,7 +48,6 @@ static void
 l_init_kernel_invocation_wrapper(acl_kernel_invocation_wrapper_t *wrapper,
                                  unsigned i);
 static void l_forcibly_release_allocations(cl_context context);
-static cl_device_id l_find_device_by_name(const std::string &name);
 static cl_int l_update_program_library_root(cl_context context,
                                             const char *new_root);
 static cl_int l_update_compile_command(cl_context context, const char *new_cmd);
@@ -553,7 +552,6 @@ static cl_int l_finalize_context(cl_context context, cl_uint num_devices,
 static cl_int l_load_properties(cl_context context,
                                 const cl_context_properties *properties) {
   const char *default_compile_cmd = 0;
-  int env_override = 0;
   acl_assert_locked();
 
   // Set defaults.
@@ -607,9 +605,8 @@ static cl_int l_load_properties(cl_context context,
     }
   }
 
-  // Environment variable can specify we always an offline device.
-  if (!acl_platform.offline_device.empty()) {
-    if (!l_find_device_by_name(acl_platform.offline_device))
+  // Check if environment variable specified offline device is valid
+  if (acl_platform.has_offline_device < 0) {
       ERR_RET(CL_INVALID_VALUE, context,
               "Invalid offline device specified by environment variable "
               "CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA");
@@ -717,8 +714,6 @@ static cl_int l_load_properties(cl_context context,
   // Always terminate list. After all, 'properties' might be empty!
   context->properties[context->num_property_entries++] = 0;
 
-  (void)acl_get_offline_device_user_setting(&env_override);
-
   context->compiles_programs_incompletely = 0;
   switch (context->compiler_mode) {
   case static_cast<acl_compiler_mode_t>(
@@ -788,7 +783,7 @@ static cl_int l_load_properties(cl_context context,
   // We need backing store for the buffers.
   context->device_buffers_have_backing_store = 1;
 
-  if (env_override == ACL_CONTEXT_MPSIM) {
+  if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
     //  Simulator should support save/restore buffers around programming if
     //  reprogramming on-the-fly is supported
     context->saves_and_restores_buffers_for_reprogramming = 1;
@@ -820,17 +815,6 @@ static cl_int l_load_properties(cl_context context,
   return CL_SUCCESS;
 }
 
-static cl_device_id l_find_device_by_name(const std::string &name) {
-  acl_assert_locked();
-
-  for (unsigned i = 0; i < acl_platform.num_devices; ++i) {
-    if (name == acl_platform.device[i].def.autodiscovery_def.name) {
-      return &(acl_platform.device[i]);
-    }
-  }
-  return 0;
-}
-
 // Initialize the given context.
 // Yes, this is like a "placement new".
 //
@@ -886,8 +870,6 @@ static cl_int l_init_context_with_devices(cl_context context,
   int num_present = 0;
   int num_absent = 0;
   for (cl_uint i = 0; i < num_devices; i++) {
-    int usable = devices[i]->present;
-
     // Can't mix both (actually) present and absent devices because there
     // is no consistent way to place device global memory.
     if (devices[i]->present) {
@@ -903,10 +885,7 @@ static cl_int l_init_context_with_devices(cl_context context,
               "Can't create a context with both offline and online devices");
     }
 
-    usable = usable || acl_platform.offline_device ==
-                           devices[i]->def.autodiscovery_def.name;
-
-    if (!usable)
+    if (!devices[i]->present && !devices[i]->offline)
       ERR_RET(CL_DEVICE_NOT_AVAILABLE, context, "Device not available");
 
     // Mark the device(s) as opened

src/acl_device_binary.cpp

@@ -175,13 +175,10 @@ cl_int acl_device_binary_t::load_binary_pkg(int validate_compile_options,
 #define FAILREAD_MSG "Could not read parts of the program binary."
   size_t data_len = 0;
 
-  int env_override = 0;
-
   acl_assert_locked();
 
-  (void)acl_get_offline_device_user_setting(&env_override);
-
-  if (env_override == ACL_CONTEXT_MPSIM && !validate_compile_options &&
+  if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM &&
+      !validate_compile_options &&
       context->compiler_mode != CL_CONTEXT_COMPILER_MODE_OFFLINE_INTELFPGA &&
       get_binary_len() < 1024) {
     // IF the binary is ridiculously small (arbitrary number) we are going
@@ -258,7 +255,7 @@ cl_int acl_device_binary_t::load_binary_pkg(int validate_compile_options,
   // runtime.
   if (acl_pkg_section_exists(pkg, ".acl.rand_hash", &data_len) &&
       dev_prog->device->loaded_bin == nullptr &&
-      env_override != ACL_CONTEXT_MPSIM) {
+      acl_platform.offline_mode != ACL_CONTEXT_MPSIM) {
     std::vector<char> pkg_rand_hash(data_len + 1);
     AND_CHECK(acl_pkg_read_section(pkg, ".acl.rand_hash", pkg_rand_hash.data(),
                                    data_len + 1),
@@ -305,7 +302,7 @@ cl_int acl_device_binary_t::load_binary_pkg(int validate_compile_options,
       // For simulator flow, we treat as if the device has already been
       // programmed and check device global memory layout against
       // dev_prog->device->last_bin
-      if (env_override == ACL_CONTEXT_MPSIM) {
+      if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
         if (validate_memory_layout && dev_prog->device->last_bin) {
           AND_CHECK(get_devdef().autodiscovery_def.num_global_mem_systems <=
                             1 ||
@@ -357,7 +354,7 @@ cl_int acl_device_binary_t::load_binary_pkg(int validate_compile_options,
   is_simulator = 0;
   if (status == CL_SUCCESS &&
       acl_pkg_section_exists(pkg, ".acl.simulator_object", &data_len)) {
-    if (env_override != ACL_CONTEXT_MPSIM) {
+    if (acl_platform.offline_mode != ACL_CONTEXT_MPSIM) {
       acl_context_callback(
           context,
           "aocx contains simulated kernel, but simulation mode not set!");
@@ -382,7 +379,7 @@ cl_int acl_device_binary_t::load_binary_pkg(int validate_compile_options,
         context,
         "aocx contains unsupported legacy opencl emulated kernel for windows!");
   }
-  if (status == CL_SUCCESS && env_override == ACL_CONTEXT_MPSIM &&
+  if (status == CL_SUCCESS && acl_platform.offline_mode == ACL_CONTEXT_MPSIM &&
       !is_simulator) {
     acl_context_callback(context,
                          "Simulation mode set but aocx is for hardware!");

src/acl_globals.cpp

@@ -73,8 +73,10 @@ static void l_reset_present_board() {
 // If it's prefixed by "+", then it's in addition to any auto-discovered
 // devices.
 // If not, then we don't even probe for auto-discovered devices.
-const char *acl_get_offline_device_user_setting(int *use_offline_only_ret) {
-  int use_offline_only = 0;
+acl_context_offline_mode_t
+acl_get_offline_device_user_setting(std::string *offline_device) {
+  acl_context_offline_mode_t use_offline_only =
+      ACL_CONTEXT_OFFLINE_AND_AUTODISCOVERY;
   const char *setting = 0;
   const char *setting_deprecated = 0;
   const char *result = 0;
@@ -136,8 +138,15 @@ const char *acl_get_offline_device_user_setting(int *use_offline_only_ret) {
     }
   }
 
-  *use_offline_only_ret = use_offline_only;
-  return result;
+  if (offline_device) {
+    if (use_offline_only == ACL_CONTEXT_MPSIM) {
+      *offline_device = ACL_MPSIM_DEVICE_NAME;
+    } else if (result) {
+      *offline_device = result;
+    }
+  }
+
+  return use_offline_only;
 }
 
 int acl_init(const acl_system_def_t *newsys) {
@@ -166,11 +175,11 @@ int acl_init(const acl_system_def_t *newsys) {
 // This function returns CL_TRUE if a hal is initialized and CL_FALSE
 // if it is not.
 cl_bool acl_init_from_hal_discovery(void) {
-  int use_offline_only = 0;
   const acl_hal_t *board_hal;
   acl_assert_locked();
 
-  (void)acl_get_offline_device_user_setting(&use_offline_only);
+  acl_context_offline_mode_t use_offline_only =
+      acl_get_offline_device_user_setting(NULL);
 
   // Two jobs:
   // 1. Set the HAL from the linked-in HAL library.
@@ -223,7 +232,8 @@ void acl_reset(void) {
 
   l_reset_present_board();
 
-  acl_platform.offline_device = "";
+  acl_platform.offline_mode = ACL_CONTEXT_OFFLINE_AND_AUTODISCOVERY;
+  acl_platform.has_offline_device = 0;
   acl_platform.num_devices = 0;
   for (unsigned i = 0; i < ACL_MAX_DEVICE; ++i) {
     acl_platform.device[i] = _cl_device_id();

src/acl_hal_mmd.cpp

@@ -1199,7 +1199,6 @@ acl_mmd_get_system_definition(acl_system_def_t *sys,
       buf[MAX_BOARD_NAMES_LEN]; // This is a bit subtle, pointers to device
                                 // names might get cached by various routines
   char *ptr, *saveptr;
-  int use_offline_only;
 
 #ifdef _WIN32
   // We're really relying on this being called before anything else
@@ -1248,7 +1247,8 @@ acl_mmd_get_system_definition(acl_system_def_t *sys,
 #endif
 
   // Dynamically load board mmd & symbols
-  acl_get_offline_device_user_setting(&use_offline_only);
+  acl_context_offline_mode_t use_offline_only =
+      acl_get_offline_device_user_setting(NULL);
   if (use_offline_only == ACL_CONTEXT_MPSIM) {
 
     // Substitute the simulator MMD layer.

src/acl_kernel.cpp

@@ -2918,9 +2918,7 @@ static cl_int l_copy_and_adjust_arguments_for_device(
                                                   [needed_mem_id]);
 #endif
 
-        int env_override = 0;
-        (void)acl_get_offline_device_user_setting(&env_override);
-        if (env_override == ACL_CONTEXT_MPSIM) {
+        if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
           if (!acl_realloc_buffer_for_simulator(mem_obj, needed_physical_id,
                                                 needed_mem_id)) {
             return CL_MEM_OBJECT_ALLOCATION_FAILURE;

src/acl_kernel_if.cpp

@@ -706,7 +706,6 @@ int acl_kernel_if_init(acl_kernel_if *kern, acl_bsp_io bsp_io,
   char description_size_lsb[KERNEL_ROM_SIZE_BYTES_READ + 1];
   unsigned int size_location, version, size;
   int result = 0;
-  int use_offline_only = 0;
   acl_assert_locked();
 
   assert(acl_bsp_io_is_valid(&bsp_io));
@@ -723,8 +722,7 @@ int acl_kernel_if_init(acl_kernel_if *kern, acl_bsp_io bsp_io,
 
   // The simulator doesn't have any kernel interface information until the aocx
   // is loaded, which happens later.
-  acl_get_offline_device_user_setting(&use_offline_only);
-  if (use_offline_only == ACL_CONTEXT_MPSIM) {
+  if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
     std::string err_msg;
     auto parse_result = acl_load_device_def_from_str(
         acl_shipped_board_cfgs[0].cfg, sysdef->device[0].autodiscovery_def,