Merge pull request #1179 from pbalcer/coverity-issues

[L0] coverity fixes

source/adapters/level_zero/adapter.cpp

@@ -156,17 +156,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterRetain(ur_adapter_handle_t) {
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterGetLastError(
- [[maybe_unused]] ur_adapter_handle_t
- AdapterHandle, ///< [in] handle of the platform instance
+ ur_adapter_handle_t, ///< [in] handle of the platform instance
  const char **Message, ///< [out] pointer to a C string where the adapter
  ///< specific error message will be stored.
- [[maybe_unused]] int32_t
- *Error ///< [out] pointer to an integer where the adapter specific
- ///< error code will be stored.
+ int32_t *Error ///< [out] pointer to an integer where the adapter specific
+ ///< error code will be stored.
 ) {
- AdapterHandle = &Adapter;
  *Message = ErrorMessage;
- Error = &ErrorAdapterNativeCode;
+ *Error = ErrorAdapterNativeCode;
 
  return ErrorMessageCode;
 }

source/adapters/level_zero/device.cpp

@@ -12,6 +12,7 @@
 #include "ur_level_zero.hpp"
 #include <algorithm>
 #include <climits>
+#include <optional>
 
 UR_APIEXPORT ur_result_t UR_APICALL urDeviceGet(
  ur_platform_handle_t Platform, ///< [in] handle of the platform instance
@@ -353,8 +354,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
  UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE));
  case UR_DEVICE_INFO_PARTITION_TYPE: {
  // For root-device there is no partitioning to report.
- if (pSize && !Device->isSubDevice()) {
- *pSize = 0;
+ if (Device->SubDeviceCreationProperty == std::nullopt ||
+ !Device->isSubDevice()) {
+ if (pSize)
+ *pSize = 0;
  return UR_RESULT_SUCCESS;
  }
 
@@ -365,7 +368,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
  return ReturnValue(cslice);
  }
 
- return ReturnValue(Device->SubDeviceCreationProperty);
+ return ReturnValue(*Device->SubDeviceCreationProperty);
  }
  // Everything under here is not supported yet
  case UR_EXT_DEVICE_INFO_OPENCL_C_VERSION:
@@ -1218,16 +1221,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urDevicePartition(
  UR_ASSERT(NumDevices == EffectiveNumDevices, UR_RESULT_ERROR_INVALID_VALUE);
 
  for (uint32_t I = 0; I < NumDevices; I++) {
- Device->SubDevices[I]->SubDeviceCreationProperty =
- Properties->pProperties[0];
- if (Properties->pProperties[0].type ==
- UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
+ auto prop = Properties->pProperties[0];
+ if (prop.type == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
  // In case the value is NEXT_PARTITIONABLE, we need to change it to the
  // chosen domain. This will always be NUMA since that's the only domain
  // supported by level zero.
- Device->SubDevices[I]->SubDeviceCreationProperty.value.affinity_domain =
- UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
+ prop.value.affinity_domain = UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
  }
+ Device->SubDevices[I]->SubDeviceCreationProperty = prop;
 
  OutDevices[I] = Device->SubDevices[I];
  // reusing the same pi_device needs to increment the reference count

source/adapters/level_zero/device.hpp

@@ -12,6 +12,7 @@
 #include <cassert>
 #include <list>
 #include <map>
+#include <optional>
 #include <stdarg.h>
 #include <string>
 #include <unordered_map>
@@ -116,7 +117,7 @@ struct ur_device_handle_t_ : _ur_object {
 
  // If this device is a subdevice, this variable contains the properties that
  // were used during its creation.
- ur_device_partition_property_t SubDeviceCreationProperty;
+ std::optional<ur_device_partition_property_t> SubDeviceCreationProperty;
 
  // PI platform to which this device belongs.
  // This field is only set at _ur_device_handle_t creation time, and cannot

source/adapters/level_zero/kernel.hpp

@@ -16,13 +16,15 @@
 struct ur_kernel_handle_t_ : _ur_object {
  ur_kernel_handle_t_(ze_kernel_handle_t Kernel, bool OwnZeHandle,
  ur_program_handle_t Program)
- : Program{Program}, ZeKernel{Kernel}, SubmissionsCount{0}, MemAllocs{} {
+ : Context{nullptr}, Program{Program}, ZeKernel{Kernel},
+ SubmissionsCount{0}, MemAllocs{} {
  OwnNativeHandle = OwnZeHandle;
  }
 
  ur_kernel_handle_t_(ze_kernel_handle_t Kernel, bool OwnZeHandle,
  ur_context_handle_t Context)
- : Context{Context}, ZeKernel{Kernel}, SubmissionsCount{0}, MemAllocs{} {
+ : Context{Context}, Program{nullptr}, ZeKernel{Kernel},
+ SubmissionsCount{0}, MemAllocs{} {
  OwnNativeHandle = OwnZeHandle;
  }
 

source/adapters/level_zero/memory.cpp

@@ -2078,9 +2078,9 @@ ur_result_t _ur_buffer::getZeHandle(char *&ZeHandle, access_mode_t AccessMode,
  auto &Allocation = Allocations[Device];
 
  // Sub-buffers don't maintain own allocations but rely on parent buffer.
- if (isSubBuffer()) {
- UR_CALL(SubBuffer.Parent->getZeHandle(ZeHandle, AccessMode, Device));
- ZeHandle += SubBuffer.Origin;
+ if (SubBuffer) {
+ UR_CALL(SubBuffer->Parent->getZeHandle(ZeHandle, AccessMode, Device));
+ ZeHandle += SubBuffer->Origin;
  // Still store the allocation info in the PI sub-buffer for
  // getZeHandlePtr to work. At least zeKernelSetArgumentValue needs to
  // be given a pointer to the allocation handle rather than its value.
@@ -2312,7 +2312,7 @@ ur_result_t _ur_buffer::free() {
 // Buffer constructor
 _ur_buffer::_ur_buffer(ur_context_handle_t Context, size_t Size, char *HostPtr,
  bool ImportedHostPtr = false)
- : ur_mem_handle_t_(Context), Size(Size), SubBuffer{nullptr, 0} {
+ : ur_mem_handle_t_(Context), Size(Size) {
 
  // We treat integrated devices (physical memory shared with the CPU)
  // differently from discrete devices (those with distinct memories).
@@ -2347,7 +2347,7 @@ _ur_buffer::_ur_buffer(ur_context_handle_t Context, ur_device_handle_t Device,
 _ur_buffer::_ur_buffer(ur_context_handle_t Context, size_t Size,
  ur_device_handle_t Device, char *ZeMemHandle,
  bool OwnZeMemHandle)
- : ur_mem_handle_t_(Context, Device), Size(Size), SubBuffer{nullptr, 0} {
+ : ur_mem_handle_t_(Context, Device), Size(Size) {
 
  // Device == nullptr means host allocation
  Allocations[Device].ZeHandle = ZeMemHandle;

source/adapters/level_zero/memory.hpp

@@ -13,6 +13,7 @@
 #include <cassert>
 #include <list>
 #include <map>
+#include <optional>
 #include <stdarg.h>
 #include <string>
 #include <unordered_map>
@@ -84,7 +85,8 @@ struct ur_mem_handle_t_ : _ur_object {
  virtual ~ur_mem_handle_t_() = default;
 
 protected:
- ur_mem_handle_t_(ur_context_handle_t Context) : UrContext{Context} {}
+ ur_mem_handle_t_(ur_context_handle_t Context)
+ : UrContext{Context}, UrDevice{nullptr} {}
 
  ur_mem_handle_t_(ur_context_handle_t Context, ur_device_handle_t Device)
  : UrContext{Context}, UrDevice(Device) {}
@@ -101,7 +103,7 @@ struct _ur_buffer final : ur_mem_handle_t_ {
  // Sub-buffer constructor
  _ur_buffer(_ur_buffer *Parent, size_t Origin, size_t Size)
  : ur_mem_handle_t_(Parent->UrContext),
- Size(Size), SubBuffer{Parent, Origin} {}
+ Size(Size), SubBuffer{{Parent, Origin}} {}
 
  // Interop-buffer constructor
  _ur_buffer(ur_context_handle_t Context, size_t Size,
@@ -121,8 +123,7 @@ struct _ur_buffer final : ur_mem_handle_t_ {
  ur_device_handle_t Device = nullptr) override;
 
  bool isImage() const override { return false; }
-
- bool isSubBuffer() const { return SubBuffer.Parent != nullptr; }
+ bool isSubBuffer() const { return SubBuffer != std::nullopt; }
 
  // Frees all allocations made for the buffer.
  ur_result_t free();
@@ -174,10 +175,11 @@ struct _ur_buffer final : ur_mem_handle_t_ {
  size_t Size;
  size_t getAlignment() const;
 
- struct {
+ struct SubBuffer_t {
  _ur_buffer *Parent;
- size_t Origin; // only valid if Parent != nullptr
- } SubBuffer;
+ size_t Origin;
+ };
+ std::optional<SubBuffer_t> SubBuffer;
 };
 
 struct _ur_image final : ur_mem_handle_t_ {

source/adapters/level_zero/platform.hpp

@@ -10,11 +10,13 @@
 #pragma once
 
 #include "common.hpp"
+#include "ze_api.h"
 
 struct ur_device_handle_t_;
 
 struct ur_platform_handle_t_ : public _ur_platform {
- ur_platform_handle_t_(ze_driver_handle_t Driver) : ZeDriver{Driver} {}
+ ur_platform_handle_t_(ze_driver_handle_t Driver)
+ : ZeDriver{Driver}, ZeApiVersion{ZE_API_VERSION_CURRENT} {}
  // Performs initialization of a newly constructed PI platform.
  ur_result_t initialize();
 

source/adapters/level_zero/queue.cpp

@@ -219,7 +219,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueGetInfo(
  if (ImmCmdList == Queue->CommandListMap.end())
  continue;
 
- auto EventList = ImmCmdList->second.EventList;
+ const auto &EventList = ImmCmdList->second.EventList;
  for (auto It = EventList.crbegin(); It != EventList.crend(); It++) {
  ze_result_t ZeResult =
  ZE_CALL_NOCHECK(zeEventQueryStatus, ((*It)->ZeEvent));
@@ -391,11 +391,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreate(
  // At this point only the thread creating the queue will have associated
  // command-lists. Other threads have not accessed the queue yet. So we can
  // only warmup the initial thread's command-lists.
- auto QueueGroup = Q->ComputeQueueGroupsByTID.get();
+ const auto &QueueGroup = Q->ComputeQueueGroupsByTID.get();
  UR_CALL(warmupQueueGroup(false, QueueGroup.UpperIndex -
  QueueGroup.LowerIndex + 1));
  if (Q->useCopyEngine()) {
- auto QueueGroup = Q->CopyQueueGroupsByTID.get();
+ const auto &QueueGroup = Q->CopyQueueGroupsByTID.get();
  UR_CALL(warmupQueueGroup(true, QueueGroup.UpperIndex -
  QueueGroup.LowerIndex + 1));
  }

source/adapters/level_zero/queue.hpp

@@ -424,7 +424,8 @@ struct ur_queue_handle_t_ : _ur_object {
  // checked. Otherwise, the OpenCommandList containing compute commands is
  // checked.
  bool hasOpenCommandList(bool IsCopy) const {
- auto CommandBatch = (IsCopy) ? CopyCommandBatch : ComputeCommandBatch;
+ const auto &CommandBatch =
+ (IsCopy) ? CopyCommandBatch : ComputeCommandBatch;
  return CommandBatch.OpenCommandList != CommandListMap.end();
  }