Skip to content

Commit bdd31cc

Browse files
wenju-hewenju-he
committed
MipmapFree, createUrMemFromZeImage, urMemRelease
1 parent 8b9e994 commit bdd31cc

File tree

3 files changed

+57
-98
lines changed

3 files changed

+57
-98
lines changed

‎source/adapters/level_zero/image.cpp

Lines changed: 18 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -595,10 +595,9 @@ urBindlessImagesSampledImageHandleDestroyExp(ur_context_handle_t hContext,
595595
ur_device_handle_t hDevice,
596596
ur_exp_image_handle_t hImage) {
597597
// Sampled image is a combination of unsampled image and sampler.
598-
UR_CALL(urBindlessImagesUnsampledImageHandleDestroyExp(hContext, hDevice,
599-
hImage));
600-
601-
return UR_RESULT_SUCCESS;
598+
// Sampler is released in urSamplerRelease.
599+
return urBindlessImagesUnsampledImageHandleDestroyExp(hContext, hDevice,
600+
hImage);
602601
}
603602

604603
UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageAllocateExp(
@@ -621,15 +620,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageAllocateExp(
621620
(hContext->ZeContext, hDevice->ZeDevice, &ZeImageDesc, &ZeImage));
622621
ZE2UR_CALL(zeContextMakeImageResident,
623622
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
624-
try {
625-
auto UrImage = new _ur_image(hContext, ZeImage, /*OwnZeMemHandle*/ true);
626-
UrImage->ZeImageDesc = ZeImageDesc;
627-
*phImageMem = reinterpret_cast<ur_exp_image_mem_handle_t>(UrImage);
628-
} catch (const std::bad_alloc &) {
629-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
630-
} catch (...) {
631-
return UR_RESULT_ERROR_UNKNOWN;
632-
}
623+
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
624+
ZeImageDesc, phImageMem));
633625
return UR_RESULT_SUCCESS;
634626
}
635627

@@ -638,17 +630,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImageFreeExp(
638630
ur_exp_image_mem_handle_t hImageMem) {
639631
std::ignore = hContext;
640632
std::ignore = hDevice;
641-
auto *UrImage = reinterpret_cast<_ur_image *>(hImageMem);
642-
if (!UrImage->RefCount.decrementAndTest())
643-
return UR_RESULT_SUCCESS;
644-
645-
if (UrImage->OwnNativeHandle) {
646-
auto ZeResult = ZE_CALL_NOCHECK(zeImageDestroy, (UrImage->ZeImage));
647-
// Gracefully handle the case that L0 was already unloaded.
648-
if (ZeResult && ZeResult != ZE_RESULT_ERROR_UNINITIALIZED)
649-
return ze2urResult(ZeResult);
650-
}
651-
delete UrImage;
633+
UR_CALL(urMemRelease(reinterpret_cast<ur_mem_handle_t>(hImageMem)));
652634
return UR_RESULT_SUCCESS;
653635
}
654636

@@ -657,42 +639,34 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
657639
ur_exp_image_mem_handle_t hImageMem, const ur_image_format_t *pImageFormat,
658640
const ur_image_desc_t *pImageDesc, ur_mem_handle_t *phMem,
659641
ur_exp_image_handle_t *phImage) {
660-
std::ignore = phMem;
661642
std::shared_lock<ur_shared_mutex> Lock(hContext->Mutex);
662643

663644
ZeStruct<ze_image_desc_t> ZeImageDesc;
664645
UR_CALL(ur2zeImageDesc(pImageFormat, pImageDesc, ZeImageDesc));
665646

666-
_ur_image *UrImage = nullptr;
647+
ze_image_handle_t ZeImage;
667648

668649
ze_memory_allocation_properties_t MemAllocProperties{
669650
ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
670651
ZE2UR_CALL(zeMemGetAllocProperties,
671652
(hContext->ZeContext, hImageMem, &MemAllocProperties, nullptr));
672653
if (MemAllocProperties.type == ZE_MEMORY_TYPE_UNKNOWN) {
673-
UrImage = reinterpret_cast<_ur_image *>(hImageMem);
654+
_ur_image *UrImage = reinterpret_cast<_ur_image *>(hImageMem);
674655
if (!isSameImageDesc(&UrImage->ZeImageDesc, &ZeImageDesc)) {
675656
ze_image_bindless_exp_desc_t ZeImageBindlessDesc;
676657
ZeImageBindlessDesc.stype = ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC;
677658
ZeImageBindlessDesc.pNext = nullptr;
678659
ZeImageBindlessDesc.flags = ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS;
679660
ZeImageDesc.pNext = &ZeImageBindlessDesc;
680-
ze_image_handle_t ZeImageView;
681661
ZE2UR_CALL(zeImageViewCreateExt,
682662
(hContext->ZeContext, hDevice->ZeDevice, &ZeImageDesc,
683-
UrImage->ZeImage, &ZeImageView));
663+
UrImage->ZeImage, &ZeImage));
684664
ZE2UR_CALL(zeContextMakeImageResident,
685-
(hContext->ZeContext, hDevice->ZeDevice, ZeImageView));
686-
try {
687-
UrImage = new _ur_image(hContext, ZeImageView, /*OwnZeMemHandle*/ true);
688-
UrImage->ZeImageDesc = ZeImageDesc;
689-
*phMem = UrImage;
690-
} catch (const std::bad_alloc &) {
691-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
692-
} catch (...) {
693-
return UR_RESULT_ERROR_UNKNOWN;
694-
}
665+
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
666+
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
667+
ZeImageDesc, phMem));
695668
} else {
669+
ZeImage = UrImage->ZeImage;
696670
*phMem = nullptr;
697671
}
698672
} else {
@@ -708,20 +682,12 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
708682

709683
ZeImageDesc.pNext = &BindlessDesc;
710684

711-
ze_image_handle_t ZeImage;
712685
ZE2UR_CALL(zeImageCreate, (hContext->ZeContext, hDevice->ZeDevice,
713686
&ZeImageDesc, &ZeImage));
714687
ZE2UR_CALL(zeContextMakeImageResident,
715688
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
716-
try {
717-
UrImage = new _ur_image(hContext, ZeImage, /*OwnZeMemHandle*/ true);
718-
UrImage->ZeImageDesc = ZeImageDesc;
719-
*phMem = UrImage;
720-
} catch (const std::bad_alloc &) {
721-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
722-
} catch (...) {
723-
return UR_RESULT_ERROR_UNKNOWN;
724-
}
689+
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
690+
ZeImageDesc, phMem));
725691
}
726692

727693
static std::once_flag InitFlag;
@@ -738,9 +704,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
738704
if (!zeImageGetDeviceOffsetExpFunctionPtr)
739705
return UR_RESULT_ERROR_INVALID_OPERATION;
740706

741-
uint64_t DeviceOffset;
742-
ZE2UR_CALL(zeImageGetDeviceOffsetExpFunctionPtr,
743-
(UrImage->ZeImage, &DeviceOffset));
707+
uint64_t DeviceOffset{};
708+
ZE2UR_CALL(zeImageGetDeviceOffsetExpFunctionPtr, (ZeImage, &DeviceOffset));
744709
*phImage = reinterpret_cast<ur_exp_image_handle_t>(DeviceOffset);
745710

746711
return UR_RESULT_SUCCESS;
@@ -936,11 +901,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp(
936901
UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp(
937902
ur_context_handle_t hContext, ur_device_handle_t hDevice,
938903
ur_exp_image_mem_handle_t hMem) {
939-
std::ignore = hContext;
940-
std::ignore = hDevice;
941-
std::ignore = hMem;
942-
urPrint("[UR][L0] %s function not implemented!\n", __FUNCTION__);
943-
return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
904+
return urBindlessImagesImageFreeExp(hContext, hDevice, hMem);
944905
}
945906

946907
UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImportOpaqueFDExp(

‎source/adapters/level_zero/memory.cpp

Lines changed: 22 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1518,30 +1518,21 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreate(
15181518
ZE2UR_CALL(zeImageCreate,
15191519
(Context->ZeContext, Device->ZeDevice, &ZeImageDesc, &ZeImage));
15201520

1521-
try {
1522-
auto UrImage = new _ur_image(Context, ZeImage, true /*OwnZeMemHandle*/);
1523-
*Mem = reinterpret_cast<ur_mem_handle_t>(UrImage);
1524-
1525-
#ifndef NDEBUG
1526-
UrImage->ZeImageDesc = ZeImageDesc;
1527-
#endif // !NDEBUG
1528-
1529-
if ((Flags & UR_MEM_FLAG_USE_HOST_POINTER) != 0 ||
1530-
(Flags & UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) != 0) {
1531-
// Initialize image synchronously with immediate offload.
1532-
// zeCommandListAppendImageCopyFromMemory must not be called from
1533-
// simultaneous threads with the same command list handle, so we need
1534-
// exclusive lock.
1535-
std::scoped_lock<ur_mutex> Lock(Context->ImmediateCommandListMutex);
1536-
ZE2UR_CALL(zeCommandListAppendImageCopyFromMemory,
1537-
(Context->ZeCommandListInit, ZeImage, Host, nullptr, nullptr,
1538-
0, nullptr));
1539-
}
1540-
} catch (const std::bad_alloc &) {
1541-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
1542-
} catch (...) {
1543-
return UR_RESULT_ERROR_UNKNOWN;
1521+
UR_CALL(createUrMemFromZeImage(Context, ZeImage, /*OwnZeMemHandle*/ true,
1522+
ZeImageDesc, Mem));
1523+
1524+
if ((Flags & UR_MEM_FLAG_USE_HOST_POINTER) != 0 ||
1525+
(Flags & UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) != 0) {
1526+
// Initialize image synchronously with immediate offload.
1527+
// zeCommandListAppendImageCopyFromMemory must not be called from
1528+
// simultaneous threads with the same command list handle, so we need
1529+
// exclusive lock.
1530+
std::scoped_lock<ur_mutex> Lock(Context->ImmediateCommandListMutex);
1531+
ZE2UR_CALL(zeCommandListAppendImageCopyFromMemory,
1532+
(Context->ZeCommandListInit, ZeImage, Host, nullptr, nullptr, 0,
1533+
nullptr));
15441534
}
1535+
15451536
return UR_RESULT_SUCCESS;
15461537
}
15471538

@@ -1560,30 +1551,20 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageCreateWithNativeHandle(
15601551

15611552
ze_image_handle_t ZeHImage = ur_cast<ze_image_handle_t>(NativeMem);
15621553

1563-
_ur_image *Image = nullptr;
1564-
try {
1565-
Image = new _ur_image(Context, ZeHImage, Properties->isNativeHandleOwned);
1566-
*Mem = reinterpret_cast<ur_mem_handle_t>(Image);
1567-
1554+
ZeStruct<ze_image_desc_t> ZeImageDesc;
15681555
#ifndef NDEBUG
1569-
ZeStruct<ze_image_desc_t> ZeImageDesc;
1570-
ur_result_t Res = ur2zeImageDesc(ImageFormat, ImageDesc, ZeImageDesc);
1571-
if (Res != UR_RESULT_SUCCESS) {
1572-
delete Image;
1573-
*Mem = nullptr;
1574-
return Res;
1575-
}
1576-
Image->ZeImageDesc = ZeImageDesc;
1556+
ur_result_t Res = ur2zeImageDesc(ImageFormat, ImageDesc, ZeImageDesc);
1557+
if (Res != UR_RESULT_SUCCESS) {
1558+
*Mem = nullptr;
1559+
return Res;
1560+
}
15771561
#else
15781562
std::ignore = ImageFormat;
15791563
std::ignore = ImageDesc;
15801564
#endif // !NDEBUG
15811565

1582-
} catch (const std::bad_alloc &) {
1583-
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
1584-
} catch (...) {
1585-
return UR_RESULT_ERROR_UNKNOWN;
1586-
}
1566+
UR_CALL(createUrMemFromZeImage(
1567+
Context, ZeHImage, Properties->isNativeHandleOwned, ZeImageDesc, Mem));
15871568

15881569
return UR_RESULT_SUCCESS;
15891570
}

‎source/adapters/level_zero/memory.hpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -212,3 +212,20 @@ struct _ur_image final : ur_mem_handle_t_ {
212212
// Level Zero image handle.
213213
ze_image_handle_t ZeImage;
214214
};
215+
216+
template <typename T>
217+
ur_result_t
218+
createUrMemFromZeImage(ur_context_handle_t Context, ze_image_handle_t ZeImage,
219+
bool OwnZeMemHandle,
220+
const ZeStruct<ze_image_desc_t> &ZeImageDesc, T *UrMem) {
221+
try {
222+
auto UrImage = new _ur_image(Context, ZeImage, OwnZeMemHandle);
223+
UrImage->ZeImageDesc = ZeImageDesc;
224+
*UrMem = reinterpret_cast<T>(UrImage);
225+
} catch (const std::bad_alloc &) {
226+
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;
227+
} catch (...) {
228+
return UR_RESULT_ERROR_UNKNOWN;
229+
}
230+
return UR_RESULT_SUCCESS;
231+
}

0 commit comments

Comments
 (0)