if (this->resourcesReleased) {

return ZE_RESULT_ERROR_DEVICE_LOST;

}

auto engines = neoDevice->getAllEngines();

for (auto &engine : engines) {

auto csr = engine.commandStreamReceiver;

if (csr->isGpuHangDetected()) {

return ZE_RESULT_ERROR_DEVICE_LOST;

}

}

return ZE_RESULT_SUCCESS;

*value = neoDevice->canAccessPeer(queryPeerAccess, freeMemoryAllocation, fromHandle(hPeerDevice)->getNEODevice());

return ZE_RESULT_SUCCESS;

auto deviceImp = device.getSpecializedDevice<Device>();

auto context = Context::fromHandle(deviceImp->getDriverHandle()->getDefaultContext());

context->freeMem(ptr);

ze_command_list_handle_t *commandList) {

if (!this->isQueueGroupOrdinalValid(desc->commandQueueGroupOrdinal)) {

return ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

uint32_t index = 0;

uint32_t commandQueueGroupOrdinal = desc->commandQueueGroupOrdinal;

NEO::SynchronizedDispatchMode syncDispatchMode = NEO::SynchronizedDispatchMode::disabled;

bool copyOffloadHint = NEO::isValueSet(desc->flags, ZE_COMMAND_LIST_FLAG_COPY_OFFLOAD_HINT);

adjustCommandQueueDesc(commandQueueGroupOrdinal, index);

NEO::EngineGroupType engineGroupType = getEngineGroupTypeForOrdinal(commandQueueGroupOrdinal);

auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;

ze_result_t returnValue = ZE_RESULT_SUCCESS;

Device::CmdListCreateFunPtrT createCommandList = &CommandList::create;

auto pNext = reinterpret_cast<const ze_base_desc_t *>(desc->pNext);

while (pNext) {

auto syncDispatchModeVal = getSyncDispatchMode(pNext);

if (syncDispatchModeVal.has_value()) {

syncDispatchMode = syncDispatchModeVal.value();

}

auto newCreateFunc = getCmdListCreateFunc(pNext);

if (newCreateFunc) {

createCommandList = newCreateFunc;

}

if (static_cast<uint32_t>(pNext->stype) == ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES) {

copyOffloadHint = reinterpret_cast<const zex_intel_queue_copy_operations_offload_hint_exp_desc_t *>(pNext)->copyOffloadEnabled;

}

pNext = reinterpret_cast<const ze_base_desc_t *>(pNext->pNext);

}

*commandList = createCommandList(productFamily, this, engineGroupType, desc->flags, returnValue, false);

if (returnValue != ZE_RESULT_SUCCESS) {

return returnValue;

}

auto cmdList = CommandList::fromHandle(*commandList);

UNRECOVERABLE_IF(cmdList == nullptr);

cmdList->setOrdinal(desc->commandQueueGroupOrdinal);

if (syncDispatchMode != NEO::SynchronizedDispatchMode::disabled) {

if (cmdList->isInOrderExecutionEnabled()) {

cmdList->enableSynchronizedDispatch(syncDispatchMode);

} else {

returnValue = ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

}

auto &productHelper = getProductHelper();

auto isBcsPreferredForCopyOffload = NEO::debugManager.flags.EnableBlitterForEnqueueOperations.getIfNotDefault(productHelper.blitEnqueuePreferred(false));

const bool copyOffloadAllowed = cmdList->isInOrderExecutionEnabled() && !getGfxCoreHelper().crossEngineCacheFlushRequired() && isBcsPreferredForCopyOffload &&

(getL0GfxCoreHelper().getDefaultCopyOffloadMode(productHelper.useAdditionalBlitProperties()) != CopyOffloadModes::dualStream);

if (copyOffloadHint && copyOffloadAllowed) {

cmdList->enableCopyOperationOffload();

}

if (returnValue != ZE_RESULT_SUCCESS) {

cmdList->destroy();

cmdList = nullptr;

*commandList = nullptr;

}

return returnValue;

ze_command_list_handle_t *commandList) {

NEO::EngineGroupType engineGroupType = getInternalEngineGroupType();

auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;

ze_result_t returnValue = ZE_RESULT_SUCCESS;

*commandList = CommandList::create(productFamily, this, engineGroupType, desc->flags, returnValue, true);

return returnValue;

ze_command_list_handle_t *phCommandList) {

ze_command_queue_desc_t commandQueueDesc = *desc;

if (!this->isQueueGroupOrdinalValid(commandQueueDesc.ordinal)) {

return ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

adjustCommandQueueDesc(commandQueueDesc.ordinal, commandQueueDesc.index);

NEO::EngineGroupType engineGroupType = getEngineGroupTypeForOrdinal(commandQueueDesc.ordinal);

auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;

ze_result_t returnValue = ZE_RESULT_SUCCESS;

*phCommandList = CommandList::createImmediate(productFamily, this, &commandQueueDesc, false, engineGroupType, returnValue);

if (returnValue == ZE_RESULT_SUCCESS) {

CommandList::fromHandle(*phCommandList)->setOrdinal(commandQueueDesc.ordinal);

}

return returnValue;

auto nodeOrdinal = NEO::debugManager.flags.NodeOrdinal.get();

if (nodeOrdinal != -1) {

const NEO::HardwareInfo &hwInfo = neoDevice->getHardwareInfo();

const NEO::GfxCoreHelper &gfxCoreHelper = neoDevice->getGfxCoreHelper();

auto &engineGroups = getActiveDevice()->getRegularEngineGroups();

auto engineType = NEO::EngineHelpers::remapEngineTypeToHwSpecific(static_cast<aub_stream::EngineType>(nodeOrdinal), neoDevice->getRootDeviceEnvironment());

auto engineGroupType = gfxCoreHelper.getEngineGroupType(engineType, NEO::EngineUsage::regular, hwInfo);

uint32_t currentEngineIndex = 0u;

for (const auto &engine : engineGroups) {

if (engine.engineGroupType == engineGroupType) {

ordinal = currentEngineIndex;

break;

}

currentEngineIndex++;

}

currentEngineIndex = 0u;

for (const auto &engine : engineGroups[ordinal].engines) {

if (engine.getEngineType() == static_cast<aub_stream::EngineType>(nodeOrdinal)) {

index = currentEngineIndex;

break;

}

currentEngineIndex++;

}

}

ze_command_queue_handle_t *commandQueue) {

auto &platform = neoDevice->getHardwareInfo().platform;

NEO::CommandStreamReceiver *csr = nullptr;

ze_command_queue_desc_t commandQueueDesc = *desc;

adjustCommandQueueDesc(commandQueueDesc.ordinal, commandQueueDesc.index);

if (!this->isQueueGroupOrdinalValid(commandQueueDesc.ordinal)) {

return ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

bool isCopyOnly = NEO::EngineHelper::isCopyOnlyEngineType(getEngineGroupTypeForOrdinal(commandQueueDesc.ordinal));

auto queueProperties = CommandQueue::extractQueueProperties(*desc);

if (queueProperties.interruptHint && !neoDevice->getProductHelper().isInterruptSupported(neoDevice->getRootDeviceEnvironment())) {

return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

}

auto ret = getCsrForOrdinalAndIndex(&csr, commandQueueDesc.ordinal, commandQueueDesc.index, commandQueueDesc.priority, queueProperties.priorityLevel, queueProperties.interruptHint);

if (ret != ZE_RESULT_SUCCESS) {

return ret;

}

UNRECOVERABLE_IF(csr == nullptr);

ze_result_t returnValue = ZE_RESULT_SUCCESS;

*commandQueue = CommandQueue::create(platform.eProductFamily, this, csr, &commandQueueDesc, isCopyOnly, false, false, returnValue);

return returnValue;

ze_command_queue_handle_t *commandQueue) {

auto &platform = neoDevice->getHardwareInfo().platform;

auto internalEngine = this->getActiveDevice()->getInternalEngine();

auto csr = internalEngine.commandStreamReceiver;

auto engineGroupType = getInternalEngineGroupType();

auto isCopyOnly = NEO::EngineHelper::isCopyOnlyEngineType(engineGroupType);

UNRECOVERABLE_IF(csr == nullptr);

ze_result_t returnValue = ZE_RESULT_SUCCESS;

*commandQueue = CommandQueue::create(platform.eProductFamily, this, csr, desc, isCopyOnly, true, false, returnValue);

return returnValue;

NEO::Device *activeDevice = this->getActiveDevice();

if (this->isImplicitScalingCapable() == false || activeDevice->getNumSubDevices() == 0) {

return;

}

for (auto &subDevice : activeDevice->getSubDevices()) {

if (subDevice) {

NEO::Device *activeSubDevice = subDevice;

auto &subDeviceEngineGroups = activeSubDevice->getRegularEngineGroups();

uint32_t numSubDeviceEngineGroups = static_cast<uint32_t>(subDeviceEngineGroups.size());

for (uint32_t subDeviceQueueGroupsIter = 0; subDeviceQueueGroupsIter < numSubDeviceEngineGroups; subDeviceQueueGroupsIter++) {

if (NEO::EngineHelper::isCopyOnlyEngineType(subDeviceEngineGroups[subDeviceQueueGroupsIter].engineGroupType)) {

subDeviceCopyEngineGroups.push_back(subDeviceEngineGroups[subDeviceQueueGroupsIter]);

}

}

if (!activeDevice->getRootDeviceEnvironment().isExposeSingleDeviceMode()) {

break;

}

}

}

ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {

uint32_t numSubDeviceCopyEngineGroups = static_cast<uint32_t>(this->subDeviceCopyEngineGroups.size());

if (pCommandQueueGroupProperties == nullptr) {

return numSubDeviceCopyEngineGroups;

}

auto &rootDeviceEnv = this->neoDevice->getRootDeviceEnvironment();

auto &l0GfxCoreHelper = rootDeviceEnv.getHelper<L0GfxCoreHelper>();

uint32_t subDeviceQueueGroupsIter = 0;

for (; subDeviceQueueGroupsIter < std::min(numSubDeviceCopyEngineGroups, numberOfSubDeviceCopyEngineGroupsRequested); subDeviceQueueGroupsIter++) {

pCommandQueueGroupProperties[subDeviceQueueGroupsIter].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY;

pCommandQueueGroupProperties[subDeviceQueueGroupsIter].maxMemoryFillPatternSize = l0GfxCoreHelper.getMaxFillPatternSizeForCopyEngine();

pCommandQueueGroupProperties[subDeviceQueueGroupsIter].numQueues = static_cast<uint32_t>(this->subDeviceCopyEngineGroups[subDeviceQueueGroupsIter].engines.size());

}

return subDeviceQueueGroupsIter;

auto retVal = tryGetCopyEngineOrdinal();

UNRECOVERABLE_IF(!retVal.has_value());

return retVal.value();

auto &engineGroups = neoDevice->getRegularEngineGroups();

uint32_t i = 0;

for (; i < static_cast<uint32_t>(engineGroups.size()); i++) {

if (engineGroups[i].engineGroupType == NEO::EngineGroupType::copy) {

return i;

}

}

if (this->subDeviceCopyEngineGroups.size() != 0) {

return i;

}

return std::nullopt;

ze_command_queue_group_properties_t *pCommandQueueGroupProperties) {

NEO::Device *activeDevice = getActiveDevice();

auto &engineGroups = activeDevice->getRegularEngineGroups();

uint32_t numEngineGroups = static_cast<uint32_t>(engineGroups.size());

uint32_t numSubDeviceCopyEngineGroups = getCopyQueueGroupsFromSubDevice(std::numeric_limits<uint32_t>::max(), nullptr);

uint32_t totalEngineGroups = numEngineGroups + numSubDeviceCopyEngineGroups;

uint32_t additionalEngines = getAdditionalEngines(std::numeric_limits<uint32_t>::max(), nullptr);

totalEngineGroups += additionalEngines;

if (*pCount == 0) {

*pCount = totalEngineGroups;

return ZE_RESULT_SUCCESS;

}

auto &rootDeviceEnv = this->neoDevice->getRootDeviceEnvironment();

auto &l0GfxCoreHelper = rootDeviceEnv.getHelper<L0GfxCoreHelper>();

*pCount = std::min(totalEngineGroups, *pCount);

for (uint32_t i = 0; i < std::min(numEngineGroups, *pCount); i++) {

if (engineGroups[i].engineGroupType == NEO::EngineGroupType::renderCompute) {

pCommandQueueGroupProperties[i].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |

ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY |

ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_METRICS |

ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS;

pCommandQueueGroupProperties[i].maxMemoryFillPatternSize = std::numeric_limits<size_t>::max();

}

if (engineGroups[i].engineGroupType == NEO::EngineGroupType::compute) {

pCommandQueueGroupProperties[i].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |

ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY |

ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS;

pCommandQueueGroupProperties[i].maxMemoryFillPatternSize = std::numeric_limits<size_t>::max();

}

if (engineGroups[i].engineGroupType == NEO::EngineGroupType::copy || engineGroups[i].engineGroupType == NEO::EngineGroupType::linkedCopy) {

pCommandQueueGroupProperties[i].flags = ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY;

pCommandQueueGroupProperties[i].maxMemoryFillPatternSize = l0GfxCoreHelper.getMaxFillPatternSizeForCopyEngine();

}

pCommandQueueGroupProperties[i].numQueues = static_cast<uint32_t>(engineGroups[i].engines.size());

}

if (*pCount > numEngineGroups) {

uint32_t remainingCopyEngineGroups = *pCount - numEngineGroups - additionalEngines;

getCopyQueueGroupsFromSubDevice(remainingCopyEngineGroups, &pCommandQueueGroupProperties[numEngineGroups]);

}

if (*pCount > (numEngineGroups + numSubDeviceCopyEngineGroups)) {

getAdditionalEngines(additionalEngines, &pCommandQueueGroupProperties[numEngineGroups + numSubDeviceCopyEngineGroups]);

}

return ZE_RESULT_SUCCESS;

auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;

Image *pImage = nullptr;

if (neoDevice->getDeviceInfo().imageSupport == false) {

*phImage = nullptr;

return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

}

auto result = Image::create(productFamily, this, desc, &pImage);

if (result == ZE_RESULT_SUCCESS) {

*phImage = pImage->toHandle();

}

return result;

ze_sampler_handle_t *sampler) {

auto productFamily = neoDevice->getHardwareInfo().platform.eProductFamily;

*sampler = Sampler::create(productFamily, this, desc);

if (*sampler == nullptr) {

return ZE_RESULT_ERROR_UNINITIALIZED;

} else {

return ZE_RESULT_SUCCESS;

}

ze_module_build_log_handle_t *buildLog, ModuleType type) {

ModuleBuildLog *moduleBuildLog = nullptr;

if (buildLog) {

moduleBuildLog = ModuleBuildLog::create();

*buildLog = moduleBuildLog->toHandle();

}

ze_result_t result = ZE_RESULT_SUCCESS;

auto modulePtr = Module::create(this, desc, moduleBuildLog, type, &result);

if (modulePtr != nullptr) {

*module = modulePtr;

}

return result;

const auto &deviceInfo = this->neoDevice->getDeviceInfo();

pComputeProperties->maxTotalGroupSize = static_cast<uint32_t>(deviceInfo.maxWorkGroupSize);

pComputeProperties->maxGroupSizeX = static_cast<uint32_t>(deviceInfo.maxWorkItemSizes[0]);

pComputeProperties->maxGroupSizeY = static_cast<uint32_t>(deviceInfo.maxWorkItemSizes[1]);

pComputeProperties->maxGroupSizeZ = static_cast<uint32_t>(deviceInfo.maxWorkItemSizes[2]);

pComputeProperties->maxGroupCountX = std::numeric_limits<uint32_t>::max();

pComputeProperties->maxGroupCountY = std::numeric_limits<uint32_t>::max();

pComputeProperties->maxGroupCountZ = std::numeric_limits<uint32_t>::max();

pComputeProperties->maxSharedLocalMemory = static_cast<uint32_t>(deviceInfo.localMemSize);

pComputeProperties->numSubGroupSizes = static_cast<uint32_t>(deviceInfo.maxSubGroups.size());

for (uint32_t i = 0; i < pComputeProperties->numSubGroupSizes; ++i) {

pComputeProperties->subGroupSizes[i] = static_cast<uint32_t>(deviceInfo.maxSubGroups[i]);

}

return ZE_RESULT_SUCCESS;

auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();

auto internalEngine = this->getActiveDevice()->getInternalEngine();

auto internalEngineType = internalEngine.getEngineType();

auto internalEngineUsage = internalEngine.getEngineUsage();

return gfxCoreHelper.getEngineGroupType(internalEngineType, internalEngineUsage, getHwInfo());

ze_device_p2p_bandwidth_exp_properties_t *bandwidthPropertiesDesc) {

auto driverHandle = getDriverHandle();

if (driverHandle->fabricVertices.empty()) {

driverHandle->initializeVertexes();

}

if (this->fabricVertex != nullptr && peerDevice->fabricVertex != nullptr) {

uint32_t directEdgeCount = 0;

driverHandle->fabricEdgeGetExp(this->fabricVertex,

peerDevice->fabricVertex,

&directEdgeCount,

nullptr);

if (directEdgeCount > 0) {

std::vector<ze_fabric_edge_handle_t> edges(directEdgeCount);

driverHandle->fabricEdgeGetExp(this->fabricVertex,

peerDevice->fabricVertex,

&directEdgeCount,

edges.data());

for (const auto &edge : edges) {

auto fabricEdge = FabricEdge::fromHandle(edge);

ze_fabric_edge_exp_properties_t edgeProperties{};

fabricEdge->getProperties(&edgeProperties);

if (fabricEdgeModelSupportsBandwidthAndLatency(edgeProperties.model)) {

bandwidthPropertiesDesc->logicalBandwidth = edgeProperties.bandwidth;

bandwidthPropertiesDesc->physicalBandwidth = edgeProperties.bandwidth;

bandwidthPropertiesDesc->bandwidthUnit = edgeProperties.bandwidthUnit;

bandwidthPropertiesDesc->logicalLatency = edgeProperties.latency;

bandwidthPropertiesDesc->physicalLatency = edgeProperties.latency;

bandwidthPropertiesDesc->latencyUnit = edgeProperties.latencyUnit;

break;

}

}

}

}

ze_device_p2p_properties_t *pP2PProperties) {

Device *peerDevice = Device::fromHandle(hPeerDevice);

if (this->getNEODevice()->getRootDeviceIndex() == peerDevice->getNEODevice()->getRootDeviceIndex()) {

pP2PProperties->flags = ZE_DEVICE_P2P_PROPERTY_FLAG_ACCESS | ZE_DEVICE_P2P_PROPERTY_FLAG_ATOMICS;

} else {

ze_bool_t peerAccessAvaiable = false;

canAccessPeer(hPeerDevice, &peerAccessAvaiable);

if (peerAccessAvaiable) {

pP2PProperties->flags = ZE_DEVICE_P2P_PROPERTY_FLAG_ACCESS;

ze_device_p2p_bandwidth_exp_properties_t p2pBandwidthProperties{};

getP2PPropertiesDirectFabricConnection(peerDevice, &p2pBandwidthProperties);

if (std::max(p2pBandwidthProperties.physicalBandwidth, p2pBandwidthProperties.logicalBandwidth) > 0u) {

pP2PProperties->flags |= ZE_DEVICE_P2P_PROPERTY_FLAG_ATOMICS;

}

}

}

if (pP2PProperties->pNext) {

ze_base_desc_t *extendedDesc = reinterpret_cast<ze_base_desc_t *>(pP2PProperties->pNext);

if (extendedDesc->stype == ZE_STRUCTURE_TYPE_DEVICE_P2P_BANDWIDTH_EXP_PROPERTIES) {

ze_device_p2p_bandwidth_exp_properties_t *bandwidthPropertiesDesc =

reinterpret_cast<ze_device_p2p_bandwidth_exp_properties_t *>(extendedDesc);

bandwidthPropertiesDesc->logicalBandwidth = 0;

bandwidthPropertiesDesc->physicalBandwidth = 0;

bandwidthPropertiesDesc->bandwidthUnit = ZE_BANDWIDTH_UNIT_UNKNOWN;

bandwidthPropertiesDesc->logicalLatency = 0;

bandwidthPropertiesDesc->physicalLatency = 0;

bandwidthPropertiesDesc->latencyUnit = ZE_LATENCY_UNIT_UNKNOWN;

getP2PPropertiesDirectFabricConnection(peerDevice, bandwidthPropertiesDesc);

}

}

return ZE_RESULT_SUCCESS;

// Given FLAT device Hierarchy mode, then nullptr is returned for the root device since no traversal is allowed.

if (this->neoDevice->getExecutionEnvironment()->getDeviceHierarchyMode() == NEO::DeviceHierarchyMode::flat) {

*phRootDevice = nullptr;

return ZE_RESULT_SUCCESS;

}

*phRootDevice = this->rootDevice;

return ZE_RESULT_SUCCESS;

if (!driverInfo) {

return ZE_RESULT_ERROR_UNINITIALIZED;

}

auto pciBusInfo = driverInfo->getPciBusInfo();

auto isPciValid = [&](auto pci) -> bool {

return (pci.pciDomain != NEO::PhysicalDevicePciBusInfo::invalidValue &&

pci.pciBus != NEO::PhysicalDevicePciBusInfo::invalidValue &&

pci.pciDevice != NEO::PhysicalDevicePciBusInfo::invalidValue &&

pci.pciFunction != NEO::PhysicalDevicePciBusInfo::invalidValue);

};

if (!isPciValid(pciBusInfo)) {

return ZE_RESULT_ERROR_UNINITIALIZED;

}

pPciProperties->address = {pciBusInfo.pciDomain, pciBusInfo.pciBus,

pciBusInfo.pciDevice, pciBusInfo.pciFunction};

pPciProperties->maxSpeed = pciMaxSpeed;

return ZE_RESULT_SUCCESS;

if (*pCount == 0) {

*pCount = 1;

return ZE_RESULT_SUCCESS;

}

if (*pCount > 1) {

*pCount = 1;

}

if (nullptr == pMemProperties) {

return ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

const auto &deviceInfo = this->neoDevice->getDeviceInfo();

auto &hwInfo = this->getHwInfo();

auto &productHelper = this->getProductHelper();

strcpy_s(pMemProperties->name, ZE_MAX_DEVICE_NAME, getDeviceMemoryName());

auto osInterface = neoDevice->getRootDeviceEnvironment().osInterface.get();

pMemProperties->maxClockRate = productHelper.getDeviceMemoryMaxClkRate(hwInfo, osInterface, 0);

pMemProperties->maxBusWidth = deviceInfo.addressBits;

if (this->isImplicitScalingCapable() ||

this->getNEODevice()->getNumGenericSubDevices() == 0) {

pMemProperties->totalSize = deviceInfo.globalMemSize;

} else {

pMemProperties->totalSize = deviceInfo.globalMemSize / this->numSubDevices;

}

pMemProperties->flags = 0;

ze_base_properties_t *pNext = static_cast<ze_base_properties_t *>(pMemProperties->pNext);

while (pNext) {

if (pNext->stype == ZE_STRUCTURE_TYPE_DEVICE_MEMORY_EXT_PROPERTIES) {

auto extendedProperties = reinterpret_cast<ze_device_memory_ext_properties_t *>(pNext);

// GT_MEMORY_TYPES map to ze_device_memory_ext_type_t

const std::array<ze_device_memory_ext_type_t, 11> sysInfoMemType = {

ZE_DEVICE_MEMORY_EXT_TYPE_LPDDR4,

ZE_DEVICE_MEMORY_EXT_TYPE_LPDDR5,

ZE_DEVICE_MEMORY_EXT_TYPE_HBM2,

ZE_DEVICE_MEMORY_EXT_TYPE_HBM2E,

ZE_DEVICE_MEMORY_EXT_TYPE_GDDR6,

ZE_DEVICE_MEMORY_EXT_TYPE_HBM3,

ZE_DEVICE_MEMORY_EXT_TYPE_DDR5,

ZE_DEVICE_MEMORY_EXT_TYPE_GDDR7,

ZE_DEVICE_MEMORY_EXT_TYPE_HBM3E,

ZE_DEVICE_MEMORY_EXT_TYPE_HBM4,

ZE_DEVICE_MEMORY_EXT_TYPE_LPDDR5,

};

UNRECOVERABLE_IF(hwInfo.gtSystemInfo.MemoryType >= sizeof(sysInfoMemType));

extendedProperties->type = sysInfoMemType[hwInfo.gtSystemInfo.MemoryType];

uint32_t enabledSubDeviceCount = 1;

if (this->isImplicitScalingCapable()) {

enabledSubDeviceCount = static_cast<uint32_t>(neoDevice->getDeviceBitfield().count());

}

extendedProperties->physicalSize = productHelper.getDeviceMemoryPhysicalSizeInBytes(osInterface, 0) * enabledSubDeviceCount;

const uint64_t bandwidthInBytesPerSecond = productHelper.getDeviceMemoryMaxBandWidthInBytesPerSecond(hwInfo, osInterface, 0) * enabledSubDeviceCount;

// Convert to nano-seconds range

extendedProperties->readBandwidth = static_cast<uint32_t>(bandwidthInBytesPerSecond * 1e-9);

extendedProperties->writeBandwidth = extendedProperties->readBandwidth;

extendedProperties->bandwidthUnit = ZE_BANDWIDTH_UNIT_BYTES_PER_NANOSEC;

}

pNext = static_cast<ze_base_properties_t *>(pNext->pNext);

}

return ZE_RESULT_SUCCESS;

auto &hwInfo = this->getHwInfo();

auto &productHelper = this->getProductHelper();

pMemAccessProperties->hostAllocCapabilities =

static_cast<ze_memory_access_cap_flags_t>(productHelper.getHostMemCapabilities(&hwInfo));

pMemAccessProperties->deviceAllocCapabilities =

static_cast<ze_memory_access_cap_flags_t>(productHelper.getDeviceMemCapabilities());

auto memoryManager{this->getDriverHandle()->getMemoryManager()};

const bool isKmdMigrationAvailable{memoryManager->isKmdMigrationAvailable(this->getRootDeviceIndex())};

pMemAccessProperties->sharedSingleDeviceAllocCapabilities =

static_cast<ze_memory_access_cap_flags_t>(productHelper.getSingleDeviceSharedMemCapabilities(isKmdMigrationAvailable));

auto defaultContext = Context::fromHandle(getDriverHandle()->getDefaultContext());

auto multiDeviceWithSingleRoot = defaultContext->rootDeviceIndices.size() == 1 && (defaultContext->getNumDevices() > 1 || isSubdevice);

pMemAccessProperties->sharedCrossDeviceAllocCapabilities = {};

if (multiDeviceWithSingleRoot || (isKmdMigrationAvailable &&

memoryManager->hasPageFaultsEnabled(*this->getNEODevice()) &&

NEO::debugManager.flags.EnableConcurrentSharedCrossP2PDeviceAccess.get() == 1)) {

pMemAccessProperties->sharedCrossDeviceAllocCapabilities = ZE_MEMORY_ACCESS_CAP_FLAG_RW |

ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT |

ZE_MEMORY_ACCESS_CAP_FLAG_ATOMIC |

ZE_MEMORY_ACCESS_CAP_FLAG_CONCURRENT_ATOMIC;

}

pMemAccessProperties->sharedSystemAllocCapabilities =

static_cast<ze_memory_access_cap_flags_t>(productHelper.getSharedSystemMemCapabilities(&hwInfo));

return ZE_RESULT_SUCCESS;

const auto &hardwareInfo = this->neoDevice->getHardwareInfo();

auto &compilerProductHelper = this->neoDevice->getCompilerProductHelper();

const auto &deviceInfo = this->getDeviceInfo();

const auto &productHelper = this->getProductHelper();

auto releaseHelper = this->neoDevice->getReleaseHelper();

std::string ilVersion = deviceInfo.ilVersion;

size_t majorVersionPos = ilVersion.find('_');

size_t minorVersionPos = ilVersion.find('.');

if (majorVersionPos != std::string::npos && minorVersionPos != std::string::npos) {

uint32_t majorSpirvVersion = static_cast<uint32_t>(std::stoul(ilVersion.substr(majorVersionPos + 1)));

uint32_t minorSpirvVersion = static_cast<uint32_t>(std::stoul(ilVersion.substr(minorVersionPos + 1)));

pKernelProperties->spirvVersionSupported = ZE_MAKE_VERSION(majorSpirvVersion, minorSpirvVersion);

} else {

DEBUG_BREAK_IF(true);

return ZE_RESULT_ERROR_UNKNOWN;

}

pKernelProperties->flags = ZE_DEVICE_MODULE_FLAG_FP16 | ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS;

pKernelProperties->fp16flags = defaultFpFlags;

pKernelProperties->fp32flags = defaultFpFlags;

if (NEO::debugManager.flags.OverrideDefaultFP64Settings.get() == 1) {

pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_FP64;

pKernelProperties->fp64flags = defaultFpFlags | ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;

pKernelProperties->fp32flags |= ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;

} else {

pKernelProperties->fp64flags = 0;

if (hardwareInfo.capabilityTable.ftrSupportsFP64) {

pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_FP64;

pKernelProperties->fp64flags |= defaultFpFlags;

if (hardwareInfo.capabilityTable.ftrSupports64BitMath) {

pKernelProperties->fp64flags |= ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;

pKernelProperties->fp32flags |= ZE_DEVICE_FP_FLAG_ROUNDED_DIVIDE_SQRT;

}

} else if (hardwareInfo.capabilityTable.ftrSupportsFP64Emulation) {

if (neoDevice->getExecutionEnvironment()->isFP64EmulationEnabled()) {

pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_FP64;

pKernelProperties->fp64flags = defaultFpFlags | ZE_DEVICE_FP_FLAG_SOFT_FLOAT;

}

}

}

pKernelProperties->nativeKernelSupported.id[0] = 0;

pKernelProperties->flags |= ZE_DEVICE_MODULE_FLAG_DP4A;

pKernelProperties->maxArgumentsSize = static_cast<uint32_t>(this->neoDevice->getDeviceInfo().maxParameterSize);

pKernelProperties->printfBufferSize = static_cast<uint32_t>(this->neoDevice->getDeviceInfo().printfBufferSize);

void *pNext = pKernelProperties->pNext;

while (pNext) {

ze_base_desc_t *extendedProperties = reinterpret_cast<ze_base_desc_t *>(pNext);

if (extendedProperties->stype == ZE_STRUCTURE_TYPE_FLOAT_ATOMIC_EXT_PROPERTIES) {

ze_float_atomic_ext_properties_t *floatProperties =

reinterpret_cast<ze_float_atomic_ext_properties_t *>(extendedProperties);

compilerProductHelper.getKernelFp16AtomicCapabilities(releaseHelper, floatProperties->fp16Flags);

compilerProductHelper.getKernelFp32AtomicCapabilities(floatProperties->fp32Flags);

compilerProductHelper.getKernelFp64AtomicCapabilities(floatProperties->fp64Flags);

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_LOAD_STORE == FpAtomicExtFlags::globalLoadStore, "Mismatch between internal and API - specific capabilities.");

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_ADD == FpAtomicExtFlags::globalAdd, "Mismatch between internal and API - specific capabilities.");

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_GLOBAL_MIN_MAX == FpAtomicExtFlags::globalMinMax, "Mismatch between internal and API - specific capabilities.");

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_LOAD_STORE == FpAtomicExtFlags::localLoadStore, "Mismatch between internal and API - specific capabilities.");

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_ADD == FpAtomicExtFlags::localAdd, "Mismatch between internal and API - specific capabilities.");

static_assert(ZE_DEVICE_FP_ATOMIC_EXT_FLAG_LOCAL_MIN_MAX == FpAtomicExtFlags::localMinMax, "Mismatch between internal and API - specific capabilities.");

} else if (extendedProperties->stype == ZE_STRUCTURE_TYPE_SCHEDULING_HINT_EXP_PROPERTIES) {

ze_scheduling_hint_exp_properties_t *hintProperties =

reinterpret_cast<ze_scheduling_hint_exp_properties_t *>(extendedProperties);

auto supportedThreadArbitrationPolicies = productHelper.getKernelSupportedThreadArbitrationPolicies();

hintProperties->schedulingHintFlags = 0;

for (auto &p : supportedThreadArbitrationPolicies) {

switch (p) {

case NEO::ThreadArbitrationPolicy::AgeBased:

hintProperties->schedulingHintFlags |= ZE_SCHEDULING_HINT_EXP_FLAG_OLDEST_FIRST;

break;

case NEO::ThreadArbitrationPolicy::RoundRobin:

hintProperties->schedulingHintFlags |= ZE_SCHEDULING_HINT_EXP_FLAG_ROUND_ROBIN;

break;

case NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency:

hintProperties->schedulingHintFlags |= ZE_SCHEDULING_HINT_EXP_FLAG_STALL_BASED_ROUND_ROBIN;

break;

}

}

} else if (extendedProperties->stype == ZE_STRUCTURE_TYPE_DEVICE_RAYTRACING_EXT_PROPERTIES) {

ze_device_raytracing_ext_properties_t *rtProperties =

reinterpret_cast<ze_device_raytracing_ext_properties_t *>(extendedProperties);

if (releaseHelper->isRayTracingSupported()) {

rtProperties->flags = ZE_DEVICE_RAYTRACING_EXT_FLAG_RAYQUERY;

rtProperties->maxBVHLevels = NEO::RayTracingHelper::maxBvhLevels;

if (NEO::debugManager.flags.SetMaxBVHLevels.get() != -1) {

rtProperties->maxBVHLevels = static_cast<uint32_t>(NEO::debugManager.flags.SetMaxBVHLevels.get());

}

} else {

rtProperties->flags = 0;

rtProperties->maxBVHLevels = 0;

}

} else if (extendedProperties->stype == ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES) {

ze_intel_device_module_dp_exp_properties_t *dpProperties =

reinterpret_cast<ze_intel_device_module_dp_exp_properties_t *>(extendedProperties);

dpProperties->flags = 0u;

dpProperties->flags |= ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A;

auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironment();

auto releaseHelper = rootDeviceEnvironment.getReleaseHelper();

if (releaseHelper->isDotProductAccumulateSystolicSupported()) {

dpProperties->flags |= ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS;

}

} else if (static_cast<uint32_t>(extendedProperties->stype) == ZEX_STRUCTURE_DEVICE_MODULE_REGISTER_FILE_EXP) {

zex_device_module_register_file_exp_t *properties = reinterpret_cast<zex_device_module_register_file_exp_t *>(extendedProperties);

const auto supportedNumGrfs = this->getProductHelper().getSupportedNumGrfs(this->getNEODevice()->getReleaseHelper());

const auto registerFileSizesCount = static_cast<uint32_t>(supportedNumGrfs.size());

if (properties->registerFileSizes == nullptr) {

properties->registerFileSizesCount = registerFileSizesCount;

} else {

properties->registerFileSizesCount = std::min(properties->registerFileSizesCount, registerFileSizesCount);

const auto sizeToCopy = sizeof(*properties->registerFileSizes) * properties->registerFileSizesCount;

memcpy_s(properties->registerFileSizes, sizeToCopy, supportedNumGrfs.data(), sizeToCopy);

}

} else if (static_cast<uint32_t>(extendedProperties->stype) == ZEX_STRUCTURE_TYPE_BFLOAT16_ATOMIC_EXT_PROPERTIES) {

zex_bfloat16_atomic_ext_properties_t *properties = reinterpret_cast<zex_bfloat16_atomic_ext_properties_t *>(extendedProperties);

releaseHelper->getKernelCapabilitiesExtra(properties->bfloat16Flags);

}

pNext = const_cast<void *>(extendedProperties->pNext);

}

return ZE_RESULT_SUCCESS;

if (*pCount == 0) {

*pCount = 1;

return ZE_RESULT_SUCCESS;

}

if (pVectorWidthProperties == nullptr) {

return ZE_RESULT_ERROR_INVALID_ARGUMENT;

}

if (*pCount > 1) {

*pCount = 1;

}

auto &gfxCoreHelper = this->neoDevice->getGfxCoreHelper();

auto vectorWidthSize = gfxCoreHelper.getMinimalSIMDSize();

pVectorWidthProperties[0].vector_width_size = vectorWidthSize;

pVectorWidthProperties[0].preferred_vector_width_char = gfxCoreHelper.getPreferredVectorWidthChar(vectorWidthSize);

pVectorWidthProperties[0].preferred_vector_width_short = gfxCoreHelper.getPreferredVectorWidthShort(vectorWidthSize);

pVectorWidthProperties[0].preferred_vector_width_int = gfxCoreHelper.getPreferredVectorWidthInt(vectorWidthSize);

pVectorWidthProperties[0].preferred_vector_width_long = gfxCoreHelper.getPreferredVectorWidthLong(vectorWidthSize);

pVectorWidthProperties[0].preferred_vector_width_float = gfxCoreHelper.getPreferredVectorWidthFloat(vectorWidthSize);

pVectorWidthProperties[0].preferred_vector_width_half = gfxCoreHelper.getPreferredVectorWidthHalf(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_char = gfxCoreHelper.getNativeVectorWidthChar(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_short = gfxCoreHelper.getNativeVectorWidthShort(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_int = gfxCoreHelper.getNativeVectorWidthInt(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_long = gfxCoreHelper.getNativeVectorWidthLong(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_float = gfxCoreHelper.getNativeVectorWidthFloat(vectorWidthSize);

pVectorWidthProperties[0].native_vector_width_half = gfxCoreHelper.getNativeVectorWidthHalf(vectorWidthSize);

return ZE_RESULT_SUCCESS;

const auto &deviceInfo = this->neoDevice->getDeviceInfo();

const auto &hardwareInfo = this->neoDevice->getHardwareInfo();

auto &gfxCoreHelper = this->neoDevice->getGfxCoreHelper();

const auto &l0GfxCoreHelper = this->getL0GfxCoreHelper();

auto releaseHelper = this->neoDevice->getReleaseHelper();

pDeviceProperties->type = ZE_DEVICE_TYPE_GPU;

pDeviceProperties->vendorId = deviceInfo.vendorId;

pDeviceProperties->deviceId = hardwareInfo.platform.usDeviceID;

pDeviceProperties->flags = 0u;

std::array<uint8_t, NEO::ProductHelper::uuidSize> deviceUuid;

if (this->neoDevice->getUuid(deviceUuid) == false) {

this->neoDevice->generateUuid(deviceUuid);

}

std::copy_n(std::begin(deviceUuid), ZE_MAX_DEVICE_UUID_SIZE, std::begin(pDeviceProperties->uuid.id));

pDeviceProperties->subdeviceId = isSubdevice ? static_cast<NEO::SubDevice *>(neoDevice)->getSubDeviceIndex() : 0;

pDeviceProperties->coreClockRate = deviceInfo.maxClockFrequency;

pDeviceProperties->maxMemAllocSize = this->neoDevice->getDeviceInfo().maxMemAllocSize;

pDeviceProperties->maxCommandQueuePriority = 0;

pDeviceProperties->maxHardwareContexts = 1024 * 64;

pDeviceProperties->numThreadsPerEU = deviceInfo.numThreadsPerEU;

pDeviceProperties->physicalEUSimdWidth = gfxCoreHelper.getMinimalSIMDSize();

pDeviceProperties->numEUsPerSubslice = hardwareInfo.gtSystemInfo.MaxEuPerSubSlice;

if (NEO::debugManager.flags.DebugApiUsed.get() == 1) {

pDeviceProperties->numSubslicesPerSlice = hardwareInfo.gtSystemInfo.MaxSubSlicesSupported / hardwareInfo.gtSystemInfo.MaxSlicesSupported;

} else {

pDeviceProperties->numSubslicesPerSlice = std::max(NEO::getNumSubSlicesPerSlice(hardwareInfo), NEO::GfxCoreHelper::getHighestEnabledSubSliceOnAnySlice(hardwareInfo) + 1);

}

pDeviceProperties->numSlices = hardwareInfo.gtSystemInfo.SliceCount;

if (isImplicitScalingCapable()) {

pDeviceProperties->numSlices *= neoDevice->getNumGenericSubDevices();

}

if ((NEO::debugManager.flags.UseCyclesPerSecondTimer.get() == 1) ||

(pDeviceProperties->stype == ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2)) {

pDeviceProperties->timerResolution = this->neoDevice->getDeviceInfo().outProfilingTimerClock;

} else {

pDeviceProperties->timerResolution = this->neoDevice->getDeviceInfo().outProfilingTimerResolution;

}

pDeviceProperties->timestampValidBits = hardwareInfo.capabilityTable.timestampValidBits;

pDeviceProperties->kernelTimestampValidBits = hardwareInfo.capabilityTable.kernelTimestampValidBits;

if (hardwareInfo.capabilityTable.isIntegratedDevice) {

pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_INTEGRATED;

}

if (isSubdevice && this->neoDevice->getExecutionEnvironment()->getDeviceHierarchyMode() != NEO::DeviceHierarchyMode::flat) {

pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE;

}

if (this->neoDevice->getDeviceInfo().errorCorrectionSupport) {

pDeviceProperties->flags |= ZE_DEVICE_PROPERTY_FLAG_ECC;

}