Complete the renaming

Author: sergey-semenov

sycl/include/sycl/handler.hpp

@@ -862,7 +862,7 @@ class __SYCL_EXPORT handler {
       constexpr std::string_view KernelNameStr =
           detail::getKernelName<KernelName>();
       MKernelName = KernelNameStr;
-      setKernelNameBasedDataPtr(&detail::getDeviceKernelInfo<KernelName>());
+      setDeviceKernelInfoPtr(&detail::getDeviceKernelInfo<KernelName>());
     } else {
       // In case w/o the integration header it is necessary to process
       // accessors from the list(which are associated with this handler) as
@@ -3688,8 +3688,7 @@ class __SYCL_EXPORT handler {
   void setKernelNameBasedCachePtr(
       detail::KernelNameBasedCacheT *KernelNameBasedCachePtr);
 #endif
-  void setKernelNameBasedDataPtr(
-      detail::DeviceKernelInfo *KernelNameBasedDataPtr);
+  void setDeviceKernelInfoPtr(detail::DeviceKernelInfo *DeviceKernelInfoPtr);
 
   queue getQueue();
 

sycl/source/detail/cg.hpp

@@ -254,7 +254,7 @@ class CGExecKernel : public CG {
   std::shared_ptr<detail::kernel_bundle_impl> MKernelBundle;
   std::vector<ArgDesc> MArgs;
   KernelNameStrT MKernelName;
-  DeviceKernelInfo &MKernelNameBasedData;
+  DeviceKernelInfo &MDeviceKernelInfo;
   std::vector<std::shared_ptr<detail::stream_impl>> MStreams;
   std::vector<std::shared_ptr<const void>> MAuxiliaryResources;
   /// Used to implement ext_oneapi_graph dynamic_command_group. Stores the list
@@ -269,8 +269,7 @@ class CGExecKernel : public CG {
                std::shared_ptr<detail::kernel_impl> SyclKernel,
                std::shared_ptr<detail::kernel_bundle_impl> KernelBundle,
                CG::StorageInitHelper CGData, std::vector<ArgDesc> Args,
-               KernelNameStrT KernelName,
-               DeviceKernelInfo &DeviceKernelInfo,
+               KernelNameStrT KernelName, DeviceKernelInfo &DeviceKernelInfo,
                std::vector<std::shared_ptr<detail::stream_impl>> Streams,
                std::vector<std::shared_ptr<const void>> AuxiliaryResources,
                CGType Type, ur_kernel_cache_config_t KernelCacheConfig,
@@ -279,8 +278,8 @@ class CGExecKernel : public CG {
       : CG(Type, std::move(CGData), std::move(loc)), MNDRDesc(NDRDesc),
         MHostKernel(std::move(HKernel)), MSyclKernel(std::move(SyclKernel)),
         MKernelBundle(std::move(KernelBundle)), MArgs(std::move(Args)),
-        MKernelName(std::move(KernelName)),
-        MKernelNameBasedData(DeviceKernelInfo), MStreams(std::move(Streams)),
+        MKernelName(std::move(KernelName)), MDeviceKernelInfo(DeviceKernelInfo),
+        MStreams(std::move(Streams)),
         MAuxiliaryResources(std::move(AuxiliaryResources)),
         MAlternativeKernels{}, MKernelCacheConfig(std::move(KernelCacheConfig)),
         MKernelIsCooperative(KernelIsCooperative),

sycl/source/detail/global_handler.cpp

@@ -251,11 +251,11 @@ ThreadPool &GlobalHandler::getHostTaskThreadPool() {
 
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 KernelNameBasedCacheT *GlobalHandler::createKernelNameBasedCache() {
-  static std::deque<DeviceKernelInfo> &KernelNameBasedDataStorage =
-      getOrCreate(MKernelNameBasedDataStorage);
-  LockGuard LG{MKernelNameBasedDataStorage.Lock};
+  static std::deque<DeviceKernelInfo> &DeviceKernelInfoStorage =
+      getOrCreate(MDeviceKernelInfoStorage);
+  LockGuard LG{MDeviceKernelInfoStorage.Lock};
   return reinterpret_cast<KernelNameBasedCacheT *>(
-      &KernelNameBasedDataStorage.emplace_back());
+      &DeviceKernelInfoStorage.emplace_back());
 }
 #endif
 
@@ -394,9 +394,9 @@ void shutdown_late() {
   Handler->MProgramManager.Inst.reset(nullptr);
 
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-  // Kernel cache, which is part of kernel name based data,
+  // Kernel cache, which is part of device kernel info,
   // stores handles to the adapter, so clear it before releasing adapters.
-  Handler->MKernelNameBasedDataStorage.Inst.reset(nullptr);
+  Handler->MDeviceKernelInfoStorage.Inst.reset(nullptr);
 #endif
 
   // Clear the adapters and reset the instance if it was there.

sycl/source/detail/global_handler.hpp

@@ -138,7 +138,7 @@ class GlobalHandler {
   // Thread pool for host task and event callbacks execution
   InstWithLock<ThreadPool> MHostTaskThreadPool;
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-  InstWithLock<std::deque<DeviceKernelInfo>> MKernelNameBasedDataStorage;
+  InstWithLock<std::deque<DeviceKernelInfo>> MDeviceKernelInfoStorage;
 #endif
 };
 } // namespace detail

sycl/source/detail/graph/graph_impl.cpp

@@ -741,7 +741,7 @@ ur_exp_command_buffer_sync_point_t exec_graph_impl::enqueueNodeDirect(
                                         CGExec->MLine, CGExec->MColumn);
     std::tie(CmdTraceEvent, InstanceID) = emitKernelInstrumentationData(
         StreamID, CGExec->MSyclKernel, CodeLoc, CGExec->MIsTopCodeLoc,
-        CGExec->MKernelName.data(), CGExec->MKernelNameBasedData, nullptr,
+        CGExec->MKernelName.data(), CGExec->MDeviceKernelInfo, nullptr,
         CGExec->MNDRDesc, CGExec->MKernelBundle.get(), CGExec->MArgs);
     if (CmdTraceEvent)
       sycl::detail::emitInstrumentationGeneral(
@@ -1574,8 +1574,7 @@ void exec_graph_impl::populateURKernelUpdateStructs(
     EliminatedArgMask = SyclKernelImpl->getKernelArgMask();
   } else {
     BundleObjs = sycl::detail::ProgramManager::getInstance().getOrCreateKernel(
-        ContextImpl, DeviceImpl, ExecCG.MKernelName,
-        ExecCG.MKernelNameBasedData);
+        ContextImpl, DeviceImpl, ExecCG.MKernelName, ExecCG.MDeviceKernelInfo);
     UrKernel = BundleObjs->MKernelHandle;
     EliminatedArgMask = BundleObjs->MKernelArgMask;
   }

sycl/source/detail/handler_impl.hpp

@@ -243,9 +243,9 @@ class handler_impl {
   bool MKernelIsESIMD = false;
   bool MKernelHasSpecialCaptures = true;
 
-  // A pointer to kernel name based data. Cached on the application side in
+  // A pointer to device kernel information. Cached on the application side in
   // headers or retrieved from program manager.
-  DeviceKernelInfo *MKernelNameBasedDataPtr = nullptr;
+  DeviceKernelInfo *MDeviceKernelInfoPtr = nullptr;
 };
 
 } // namespace detail

sycl/source/detail/kernel_name_based_data.hpp

@@ -80,11 +80,12 @@ struct FastKernelSubcacheT {
   FastKernelSubcacheMutexT Mutex;
 };
 
-// This class is used for aggregating kernel name based information.
-// Pointers to instances of this class are stored in header function templates
-// as a static variable to avoid repeated runtime lookup overhead.
+// This class aggregates information specific to device kernels (i.e.
+// information that is uniform between different submissions of the same
+// kernel). Pointers to instances of this class are stored in header function
+// templates as a static variable to avoid repeated runtime lookup overhead.
 // TODO Currently this class duplicates information fetched from the program
-// manager. Instead, we should merge all of the kernel name based information
+// manager. Instead, we should merge all of this information
 // into this structure and get rid of the other KernelName -> * maps.
 class DeviceKernelInfo : public CompileTimeKernelInfoTy {
 public:

sycl/source/detail/program_manager/program_manager.cpp

@@ -1823,7 +1823,7 @@ ProgramManager::kernelImplicitLocalArgPos(KernelNameStrRefT KernelName) const {
 DeviceKernelInfo &
 ProgramManager::getOrCreateDeviceKernelInfo(const CompileTimeKernelInfoTy &Info) {
   auto Result =
-      m_KernelNameBasedDataMap.try_emplace(KernelNameStrT{Info.Name}, Info);
+      m_DeviceKernelInfoMap.try_emplace(KernelNameStrT{Info.Name}, Info);
   return Result.first->second;
 }
 
@@ -2234,7 +2234,7 @@ void ProgramManager::removeImages(sycl_device_binaries DeviceBinary) {
         // share lifetime.
         m_KernelUsesAssert.erase(Name);
         m_KernelImplicitLocalArgPos.erase(Name);
-        m_KernelNameBasedDataMap.erase(Name);
+        m_DeviceKernelInfoMap.erase(Name);
         m_KernelNameRefCount.erase(RefCountIt);
         if (Name2IDIt != m_KernelName2KernelIDs.end())
           m_KernelName2KernelIDs.erase(Name2IDIt);

sycl/source/detail/program_manager/program_manager.hpp

@@ -459,7 +459,7 @@ class ProgramManager {
 
   /// Keeps track of binary image to kernel name reference count.
   /// Used for checking if the last image referencing the kernel name
-  /// is removed in order to trigger cleanup of kernel name based information.
+  /// is removed in order to trigger cleanup of kernel specific information.
   /// Access must be guarded by the m_KernelIDsMutex mutex.
   std::unordered_map<KernelNameStrT, int> m_KernelNameRefCount;
 
@@ -539,10 +539,9 @@ class ProgramManager {
   KernelUsesAssertSet m_KernelUsesAssert;
   std::unordered_map<KernelNameStrT, int> m_KernelImplicitLocalArgPos;
 
-  // Map for storing kernel name based data. Runtime lookup should be avoided
+  // Map for storing device kernel information. Runtime lookup should be avoided
   // by caching the pointers when possible.
-  std::unordered_map<KernelNameStrT, DeviceKernelInfo>
-      m_KernelNameBasedDataMap;
+  std::unordered_map<KernelNameStrT, DeviceKernelInfo> m_DeviceKernelInfoMap;
 
   // Sanitizer type used in device image
   SanitizerType m_SanitizerFoundInImage;

sycl/source/detail/queue_impl.hpp

@@ -871,7 +871,7 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
       // Kernel only uses assert if it's non interop one
       KernelUsesAssert =
           (!Handler.MKernel || Handler.MKernel->hasSYCLMetadata()) &&
-          Handler.impl->MKernelNameBasedDataPtr->usesAssert();
+          Handler.impl->MDeviceKernelInfoPtr->usesAssert();
 
     auto &PostProcess = *PostProcessorFunc;
     PostProcess(IsKernel, KernelUsesAssert, Event);