[NFC][SYCL] Speed up device_impl::CallOnceCache on fast path for libstdc++ (#18597)

libstdc++ implementation of `std::call_once` isn't as performant as it
could be due to ABI compatibility reasons (see
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66146#c53).

We can optimize fast path but paying some price for less important
memory usage/slow path performance.

Based on generated code (https://godbolt.org/z/1YaW5xozY) I wouldn't be
surprised if the same would help on Windows, but I'd prefer to
investigate/implement in a separate PR if necessary.

Author: aelovikov-intel

sycl/source/detail/device_impl.hpp

@@ -220,13 +220,32 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
     }
   };
 
+#if defined(_GLIBCXX_RELEASE)
+  // libstdc++'s std::call_once is significantly slower than libc++
+  // implementation (30-40ns for libc++ CallOnceCache/EagerCache vs 50-60ns for
+  // CallOnceCache when using libstdc++ for queries of simple types like
+  // `ur_device_usm_access_capability_flags_t`). libc++ implements it via
+  // `__cxa_guard_*` (same as function static variables initialization) but
+  // libstdc++ cannot do that without an ABI break:
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66146#c53.
+  //
+  // We do care about performance of the fast path and can pay extra costs in
+  // memory/slow-down during single init call, so add an extra flag to optimize.
+#define GUARD_STD_CALL_ONCE_WITH_EXTRA_CHECK 1
+#else
+#define GUARD_STD_CALL_ONCE_WITH_EXTRA_CHECK 0
+#endif
+
   // CallOnce - initialize on first query, but exactly once so that we could
   // return cached values by reference. Important for `std::vector` /
   // `std::string` values where returning cached values by value would cause
   // heap allocations.
   template <typename Desc> struct CallOnceCached {
     std::once_flag flag;
     typename Desc::return_type value;
+#if GUARD_STD_CALL_ONCE_WITH_EXTRA_CHECK
+    std::atomic_bool initialized = false;
+#endif
   };
 
   template <typename Initializer, typename... Descs>
@@ -241,13 +260,24 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
 
     template <typename Desc> decltype(auto) get() {
       auto &Entry = *static_cast<CallOnceCached<Desc> *>(this);
+#if GUARD_STD_CALL_ONCE_WITH_EXTRA_CHECK
+      if (!Entry.initialized.load(std::memory_order_acquire)) {
+        std::call_once(Entry.flag, [&]() {
+          Initializer::template init<Desc>(device, Entry.value);
+          Entry.initialized.store(true, std::memory_order_release);
+        });
+      }
+#else
       std::call_once(Entry.flag, Initializer::template init<Desc>, device,
                      Entry.value);
+#endif
       // Extra parentheses to return as reference (see `decltype(auto)`).
       return (std::as_const(Entry.value));
     }
   };
 
+#undef GUARD_STD_CALL_ONCE_WITH_EXTRA_CHECK
+
   // get_info and get_info_impl need to know if a particular query is cacheable.
   // It's easier if all the cache instances (eager/call-once * UR/SYCL) are
   // merged into a single object.