Skip to content

Commit eeb01e6

Browse files
wenju-hewenju-he
committed
Create sampled image from image and sampler descriptors
1 parent a320d70 commit eeb01e6

File tree

4 files changed

+99
-108
lines changed

4 files changed

+99
-108
lines changed

‎source/adapters/level_zero/common.cpp

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -225,6 +225,14 @@ template <> ze_structure_type_t getZeStructureType<ze_command_queue_desc_t>() {
225225
template <> ze_structure_type_t getZeStructureType<ze_image_desc_t>() {
226226
return ZE_STRUCTURE_TYPE_IMAGE_DESC;
227227
}
228+
template <>
229+
ze_structure_type_t getZeStructureType<ze_image_bindless_exp_desc_t>() {
230+
return ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC;
231+
}
232+
template <>
233+
ze_structure_type_t getZeStructureType<ze_image_pitched_exp_desc_t>() {
234+
return ZE_STRUCTURE_TYPE_PITCHED_IMAGE_EXP_DESC;
235+
}
228236
template <> ze_structure_type_t getZeStructureType<ze_module_desc_t>() {
229237
return ZE_STRUCTURE_TYPE_MODULE_DESC;
230238
}

‎source/adapters/level_zero/image.cpp

Lines changed: 88 additions & 108 deletions
Original file line numberDiff line numberDiff line change
@@ -29,24 +29,6 @@ zeMemGetPitchFor2dImage_pfn zeMemGetPitchFor2dImageFunctionPtr = nullptr;
2929

3030
zeImageGetDeviceOffsetExp_pfn zeImageGetDeviceOffsetExpFunctionPtr = nullptr;
3131

32-
/// Return true if the two image_desc are the same.
33-
bool isSameImageDesc(const ze_image_desc_t *Desc1,
34-
const ze_image_desc_t *Desc2) {
35-
auto IsSameImageFormat = [](const ze_image_format_t &Format1,
36-
const ze_image_format_t &Format2) {
37-
return Format1.layout == Format2.layout && Format1.type == Format2.type &&
38-
Format1.x == Format2.x && Format1.y == Format2.y &&
39-
Format1.z == Format2.z && Format1.w == Format2.w;
40-
};
41-
return Desc1->stype == Desc2->stype && Desc1->flags == Desc2->flags &&
42-
Desc1->type == Desc2->type &&
43-
IsSameImageFormat(Desc1->format, Desc2->format) &&
44-
Desc1->width == Desc2->width && Desc1->height == Desc2->height &&
45-
Desc1->depth == Desc2->depth &&
46-
Desc1->arraylevels == Desc2->arraylevels &&
47-
Desc1->miplevels == Desc2->miplevels;
48-
}
49-
5032
/// Construct UR image format from ZE image desc.
5133
ur_result_t ze2urImageFormat(const ze_image_desc_t *ZeImageDesc,
5234
ur_image_format_t *UrImageFormat) {
@@ -431,6 +413,90 @@ uint32_t getPixelSizeBytes(const ur_image_format_t *Format) {
431413
return NumChannels * ChannelTypeSizeInBytes;
432414
}
433415

416+
ur_result_t bindlessImagesCreateImpl(
417+
ur_context_handle_t hContext, ur_device_handle_t hDevice,
418+
ur_exp_image_mem_handle_t hImageMem, const ur_image_format_t *pImageFormat,
419+
const ur_image_desc_t *pImageDesc, ur_sampler_handle_t hSampler,
420+
ur_mem_handle_t *phMem, ur_exp_image_handle_t *phImage) {
421+
std::shared_lock<ur_shared_mutex> Lock(hContext->Mutex);
422+
423+
UR_ASSERT(hContext && hDevice && hImageMem,
424+
UR_RESULT_ERROR_INVALID_NULL_HANDLE);
425+
UR_ASSERT(pImageFormat && pImageDesc && phMem && phImage,
426+
UR_RESULT_ERROR_INVALID_NULL_POINTER);
427+
428+
ZeStruct<ze_image_desc_t> ZeImageDesc;
429+
UR_CALL(ur2zeImageDesc(pImageFormat, pImageDesc, ZeImageDesc));
430+
431+
ZeStruct<ze_image_bindless_exp_desc_t> BindlessDesc;
432+
BindlessDesc.flags = ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS;
433+
ZeImageDesc.pNext = &BindlessDesc;
434+
435+
ZeStruct<ze_sampler_desc_t> ZeSamplerDesc;
436+
if (hSampler) {
437+
ZeSamplerDesc = hSampler->ZeSamplerDesc;
438+
BindlessDesc.pNext = &ZeSamplerDesc;
439+
constexpr int ZE_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE = 2;
440+
BindlessDesc.flags |= ZE_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE;
441+
}
442+
443+
ze_image_handle_t ZeImage;
444+
445+
ze_memory_allocation_properties_t MemAllocProperties{
446+
ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
447+
ZE2UR_CALL(zeMemGetAllocProperties,
448+
(hContext->ZeContext, hImageMem, &MemAllocProperties, nullptr));
449+
if (MemAllocProperties.type == ZE_MEMORY_TYPE_UNKNOWN) {
450+
_ur_image *UrImage = reinterpret_cast<_ur_image *>(hImageMem);
451+
452+
ZE2UR_CALL(zeImageViewCreateExt,
453+
(hContext->ZeContext, hDevice->ZeDevice, &ZeImageDesc,
454+
UrImage->ZeImage, &ZeImage));
455+
ZE2UR_CALL(zeContextMakeImageResident,
456+
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
457+
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
458+
ZeImageDesc, phMem));
459+
} else if (MemAllocProperties.type == ZE_MEMORY_TYPE_DEVICE ||
460+
MemAllocProperties.type == ZE_MEMORY_TYPE_SHARED) {
461+
ZeStruct<ze_image_pitched_exp_desc_t> PitchedDesc;
462+
PitchedDesc.ptr = hImageMem;
463+
if (hSampler) {
464+
ZeSamplerDesc.pNext = &PitchedDesc;
465+
} else {
466+
BindlessDesc.pNext = &PitchedDesc;
467+
}
468+
469+
ZE2UR_CALL(zeImageCreate, (hContext->ZeContext, hDevice->ZeDevice,
470+
&ZeImageDesc, &ZeImage));
471+
ZE2UR_CALL(zeContextMakeImageResident,
472+
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
473+
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
474+
ZeImageDesc, phMem));
475+
} else {
476+
return UR_RESULT_ERROR_INVALID_VALUE;
477+
}
478+
479+
static std::once_flag InitFlag;
480+
std::call_once(InitFlag, [&]() {
481+
ze_driver_handle_t DriverHandle = hContext->getPlatform()->ZeDriver;
482+
auto Result = zeDriverGetExtensionFunctionAddress(
483+
DriverHandle, "zeImageGetDeviceOffsetExp",
484+
(void **)&zeImageGetDeviceOffsetExpFunctionPtr);
485+
if (Result != ZE_RESULT_SUCCESS)
486+
logger::error("zeDriverGetExtensionFunctionAddress "
487+
"zeImageGetDeviceOffsetExpv failed, err = {}",
488+
Result);
489+
});
490+
if (!zeImageGetDeviceOffsetExpFunctionPtr)
491+
return UR_RESULT_ERROR_INVALID_OPERATION;
492+
493+
uint64_t DeviceOffset{};
494+
ZE2UR_CALL(zeImageGetDeviceOffsetExpFunctionPtr, (ZeImage, &DeviceOffset));
495+
*phImage = reinterpret_cast<ur_exp_image_handle_t>(DeviceOffset);
496+
497+
return UR_RESULT_SUCCESS;
498+
}
499+
434500
} // namespace
435501

436502
ur_result_t getImageRegionHelper(ze_image_desc_t ZeImageDesc,
@@ -664,83 +730,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
664730
ur_exp_image_mem_handle_t hImageMem, const ur_image_format_t *pImageFormat,
665731
const ur_image_desc_t *pImageDesc, ur_mem_handle_t *phMem,
666732
ur_exp_image_handle_t *phImage) {
667-
std::shared_lock<ur_shared_mutex> Lock(hContext->Mutex);
668-
669-
UR_ASSERT(hContext && hDevice && hImageMem,
670-
UR_RESULT_ERROR_INVALID_NULL_HANDLE);
671-
UR_ASSERT(pImageFormat && pImageDesc && phMem && phImage,
672-
UR_RESULT_ERROR_INVALID_NULL_POINTER);
673-
674-
ZeStruct<ze_image_desc_t> ZeImageDesc;
675-
UR_CALL(ur2zeImageDesc(pImageFormat, pImageDesc, ZeImageDesc));
676-
677-
ze_image_handle_t ZeImage;
678-
679-
ze_memory_allocation_properties_t MemAllocProperties{
680-
ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES};
681-
ZE2UR_CALL(zeMemGetAllocProperties,
682-
(hContext->ZeContext, hImageMem, &MemAllocProperties, nullptr));
683-
if (MemAllocProperties.type == ZE_MEMORY_TYPE_UNKNOWN) {
684-
_ur_image *UrImage = reinterpret_cast<_ur_image *>(hImageMem);
685-
if (!isSameImageDesc(&UrImage->ZeImageDesc, &ZeImageDesc)) {
686-
ze_image_bindless_exp_desc_t ZeImageBindlessDesc;
687-
ZeImageBindlessDesc.stype = ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC;
688-
ZeImageBindlessDesc.pNext = nullptr;
689-
ZeImageBindlessDesc.flags = ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS;
690-
ZeImageDesc.pNext = &ZeImageBindlessDesc;
691-
ZE2UR_CALL(zeImageViewCreateExt,
692-
(hContext->ZeContext, hDevice->ZeDevice, &ZeImageDesc,
693-
UrImage->ZeImage, &ZeImage));
694-
ZE2UR_CALL(zeContextMakeImageResident,
695-
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
696-
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
697-
ZeImageDesc, phMem));
698-
} else {
699-
ZeImage = UrImage->ZeImage;
700-
*phMem = nullptr;
701-
}
702-
} else if (MemAllocProperties.type == ZE_MEMORY_TYPE_DEVICE ||
703-
MemAllocProperties.type == ZE_MEMORY_TYPE_SHARED) {
704-
ze_image_pitched_exp_desc_t PitchedDesc;
705-
PitchedDesc.stype = ZE_STRUCTURE_TYPE_PITCHED_IMAGE_EXP_DESC;
706-
PitchedDesc.pNext = nullptr;
707-
PitchedDesc.ptr = hImageMem;
708-
709-
ze_image_bindless_exp_desc_t BindlessDesc;
710-
BindlessDesc.stype = ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC;
711-
BindlessDesc.pNext = &PitchedDesc;
712-
BindlessDesc.flags = ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS;
713-
714-
ZeImageDesc.pNext = &BindlessDesc;
715-
716-
ZE2UR_CALL(zeImageCreate, (hContext->ZeContext, hDevice->ZeDevice,
717-
&ZeImageDesc, &ZeImage));
718-
ZE2UR_CALL(zeContextMakeImageResident,
719-
(hContext->ZeContext, hDevice->ZeDevice, ZeImage));
720-
UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
721-
ZeImageDesc, phMem));
722-
} else {
723-
return UR_RESULT_ERROR_INVALID_VALUE;
724-
}
725-
726-
static std::once_flag InitFlag;
727-
std::call_once(InitFlag, [&]() {
728-
ze_driver_handle_t DriverHandle = hContext->getPlatform()->ZeDriver;
729-
auto Result = zeDriverGetExtensionFunctionAddress(
730-
DriverHandle, "zeImageGetDeviceOffsetExp",
731-
(void **)&zeImageGetDeviceOffsetExpFunctionPtr);
732-
if (Result != ZE_RESULT_SUCCESS)
733-
logger::error("zeDriverGetExtensionFunctionAddress "
734-
"zeImageGetDeviceOffsetExpv failed, err = {}",
735-
Result);
736-
});
737-
if (!zeImageGetDeviceOffsetExpFunctionPtr)
738-
return UR_RESULT_ERROR_INVALID_OPERATION;
739-
740-
uint64_t DeviceOffset{};
741-
ZE2UR_CALL(zeImageGetDeviceOffsetExpFunctionPtr, (ZeImage, &DeviceOffset));
742-
*phImage = reinterpret_cast<ur_exp_image_handle_t>(DeviceOffset);
743-
733+
UR_CALL(bindlessImagesCreateImpl(hContext, hDevice, hImageMem, pImageFormat,
734+
pImageDesc, nullptr, phMem, phImage));
744735
return UR_RESULT_SUCCESS;
745736
}
746737

@@ -749,19 +740,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp(
749740
ur_exp_image_mem_handle_t hImageMem, const ur_image_format_t *pImageFormat,
750741
const ur_image_desc_t *pImageDesc, ur_sampler_handle_t hSampler,
751742
ur_mem_handle_t *phMem, ur_exp_image_handle_t *phImage) {
752-
753-
UR_CALL(urBindlessImagesUnsampledImageCreateExp(
754-
hContext, hDevice, hImageMem, pImageFormat, pImageDesc, phMem, phImage));
755-
756-
struct combined_sampled_image_handle {
757-
uint64_t RawImageHandle;
758-
uint64_t RawSamplerHandle;
759-
};
760-
auto *SampledImageHandle =
761-
reinterpret_cast<combined_sampled_image_handle *>(phImage);
762-
SampledImageHandle->RawSamplerHandle =
763-
reinterpret_cast<uint64_t>(hSampler->ZeSampler);
764-
743+
UR_CALL(bindlessImagesCreateImpl(hContext, hDevice, hImageMem, pImageFormat,
744+
pImageDesc, hSampler, phMem, phImage));
765745
return UR_RESULT_SUCCESS;
766746
}
767747

‎source/adapters/level_zero/sampler.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -99,6 +99,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urSamplerCreate(
9999

100100
try {
101101
ur_sampler_handle_t_ *UrSampler = new ur_sampler_handle_t_(ZeSampler);
102+
UrSampler->ZeSamplerDesc = ZeSamplerDesc;
102103
*Sampler = reinterpret_cast<ur_sampler_handle_t>(UrSampler);
103104
} catch (const std::bad_alloc &) {
104105
return UR_RESULT_ERROR_OUT_OF_HOST_MEMORY;

‎source/adapters/level_zero/sampler.hpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,4 +16,6 @@ struct ur_sampler_handle_t_ : _ur_object {
1616

1717
// Level Zero sampler handle.
1818
ze_sampler_handle_t ZeSampler;
19+
20+
ZeStruct<ze_sampler_desc_t> ZeSamplerDesc;
1921
};

0 commit comments

Comments
 (0)